/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/system/libraries/Ftp.php

  • Committer: Erik Wikström
  • Date: 2013-04-09 09:09:31 UTC
  • mfrom: (21 lenasys)
  • mto: (21.1.1 lenasys)
  • mto: This revision was merged to the branch mainline in revision 22.
  • Revision ID: wikxen@gmail.com-20130409090931-9jcs9kzg8et0912g
Remerged! Changed password hashes to VARCHAR(32)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
2
 
/**
3
 
 * CodeIgniter
4
 
 *
5
 
 * An open source application development framework for PHP 5.1.6 or newer
6
 
 *
7
 
 * @package             CodeIgniter
8
 
 * @author              ExpressionEngine Dev Team
9
 
 * @copyright   Copyright (c) 2008 - 2011, EllisLab, Inc.
10
 
 * @license             http://codeigniter.com/user_guide/license.html
11
 
 * @link                http://codeigniter.com
12
 
 * @since               Version 1.0
13
 
 * @filesource
14
 
 */
15
 
 
16
 
// ------------------------------------------------------------------------
17
 
 
18
 
/**
19
 
 * FTP Class
20
 
 *
21
 
 * @package             CodeIgniter
22
 
 * @subpackage  Libraries
23
 
 * @category    Libraries
24
 
 * @author              ExpressionEngine Dev Team
25
 
 * @link                http://codeigniter.com/user_guide/libraries/ftp.html
26
 
 */
27
 
class CI_FTP {
28
 
 
29
 
        var $hostname   = '';
30
 
        var $username   = '';
31
 
        var $password   = '';
32
 
        var $port               = 21;
33
 
        var $passive    = TRUE;
34
 
        var $debug              = FALSE;
35
 
        var $conn_id    = FALSE;
36
 
 
37
 
 
38
 
        /**
39
 
         * Constructor - Sets Preferences
40
 
         *
41
 
         * The constructor can be passed an array of config values
42
 
         */
43
 
        public function __construct($config = array())
44
 
        {
45
 
                if (count($config) > 0)
46
 
                {
47
 
                        $this->initialize($config);
48
 
                }
49
 
 
50
 
                log_message('debug', "FTP Class Initialized");
51
 
        }
52
 
 
53
 
        // --------------------------------------------------------------------
54
 
 
55
 
        /**
56
 
         * Initialize preferences
57
 
         *
58
 
         * @access      public
59
 
         * @param       array
60
 
         * @return      void
61
 
         */
62
 
        function initialize($config = array())
63
 
        {
64
 
                foreach ($config as $key => $val)
65
 
                {
66
 
                        if (isset($this->$key))
67
 
                        {
68
 
                                $this->$key = $val;
69
 
                        }
70
 
                }
71
 
 
72
 
                // Prep the hostname
73
 
                $this->hostname = preg_replace('|.+?://|', '', $this->hostname);
74
 
        }
75
 
 
76
 
        // --------------------------------------------------------------------
77
 
 
78
 
        /**
79
 
         * FTP Connect
80
 
         *
81
 
         * @access      public
82
 
         * @param       array    the connection values
83
 
         * @return      bool
84
 
         */
85
 
        function connect($config = array())
86
 
        {
87
 
                if (count($config) > 0)
88
 
                {
89
 
                        $this->initialize($config);
90
 
                }
91
 
 
92
 
                if (FALSE === ($this->conn_id = @ftp_connect($this->hostname, $this->port)))
93
 
                {
94
 
                        if ($this->debug == TRUE)
95
 
                        {
96
 
                                $this->_error('ftp_unable_to_connect');
97
 
                        }
98
 
                        return FALSE;
99
 
                }
100
 
 
101
 
                if ( ! $this->_login())
102
 
                {
103
 
                        if ($this->debug == TRUE)
104
 
                        {
105
 
                                $this->_error('ftp_unable_to_login');
106
 
                        }
107
 
                        return FALSE;
108
 
                }
109
 
 
110
 
                // Set passive mode if needed
111
 
                if ($this->passive == TRUE)
112
 
                {
113
 
                        ftp_pasv($this->conn_id, TRUE);
114
 
                }
115
 
 
116
 
                return TRUE;
117
 
        }
118
 
 
119
 
        // --------------------------------------------------------------------
120
 
 
121
 
        /**
122
 
         * FTP Login
123
 
         *
124
 
         * @access      private
125
 
         * @return      bool
126
 
         */
127
 
        function _login()
128
 
        {
129
 
                return @ftp_login($this->conn_id, $this->username, $this->password);
130
 
        }
131
 
 
132
 
        // --------------------------------------------------------------------
133
 
 
134
 
        /**
135
 
         * Validates the connection ID
136
 
         *
137
 
         * @access      private
138
 
         * @return      bool
139
 
         */
140
 
        function _is_conn()
141
 
        {
142
 
                if ( ! is_resource($this->conn_id))
143
 
                {
144
 
                        if ($this->debug == TRUE)
145
 
                        {
146
 
                                $this->_error('ftp_no_connection');
147
 
                        }
148
 
                        return FALSE;
149
 
                }
150
 
                return TRUE;
151
 
        }
152
 
 
153
 
        // --------------------------------------------------------------------
154
 
 
155
 
 
156
 
        /**
157
 
         * Change directory
158
 
         *
159
 
         * The second parameter lets us momentarily turn off debugging so that
160
 
         * this function can be used to test for the existence of a folder
161
 
         * without throwing an error.  There's no FTP equivalent to is_dir()
162
 
         * so we do it by trying to change to a particular directory.
163
 
         * Internally, this parameter is only used by the "mirror" function below.
164
 
         *
165
 
         * @access      public
166
 
         * @param       string
167
 
         * @param       bool
168
 
         * @return      bool
169
 
         */
170
 
        function changedir($path = '', $supress_debug = FALSE)
171
 
        {
172
 
                if ($path == '' OR ! $this->_is_conn())
173
 
                {
174
 
                        return FALSE;
175
 
                }
176
 
 
177
 
                $result = @ftp_chdir($this->conn_id, $path);
178
 
 
179
 
                if ($result === FALSE)
180
 
                {
181
 
                        if ($this->debug == TRUE AND $supress_debug == FALSE)
182
 
                        {
183
 
                                $this->_error('ftp_unable_to_changedir');
184
 
                        }
185
 
                        return FALSE;
186
 
                }
187
 
 
188
 
                return TRUE;
189
 
        }
190
 
 
191
 
        // --------------------------------------------------------------------
192
 
 
193
 
        /**
194
 
         * Create a directory
195
 
         *
196
 
         * @access      public
197
 
         * @param       string
198
 
         * @return      bool
199
 
         */
200
 
        function mkdir($path = '', $permissions = NULL)
201
 
        {
202
 
                if ($path == '' OR ! $this->_is_conn())
203
 
                {
204
 
                        return FALSE;
205
 
                }
206
 
 
207
 
                $result = @ftp_mkdir($this->conn_id, $path);
208
 
 
209
 
                if ($result === FALSE)
210
 
                {
211
 
                        if ($this->debug == TRUE)
212
 
                        {
213
 
                                $this->_error('ftp_unable_to_makdir');
214
 
                        }
215
 
                        return FALSE;
216
 
                }
217
 
 
218
 
                // Set file permissions if needed
219
 
                if ( ! is_null($permissions))
220
 
                {
221
 
                        $this->chmod($path, (int)$permissions);
222
 
                }
223
 
 
224
 
                return TRUE;
225
 
        }
226
 
 
227
 
        // --------------------------------------------------------------------
228
 
 
229
 
        /**
230
 
         * Upload a file to the server
231
 
         *
232
 
         * @access      public
233
 
         * @param       string
234
 
         * @param       string
235
 
         * @param       string
236
 
         * @return      bool
237
 
         */
238
 
        function upload($locpath, $rempath, $mode = 'auto', $permissions = NULL)
239
 
        {
240
 
                if ( ! $this->_is_conn())
241
 
                {
242
 
                        return FALSE;
243
 
                }
244
 
 
245
 
                if ( ! file_exists($locpath))
246
 
                {
247
 
                        $this->_error('ftp_no_source_file');
248
 
                        return FALSE;
249
 
                }
250
 
 
251
 
                // Set the mode if not specified
252
 
                if ($mode == 'auto')
253
 
                {
254
 
                        // Get the file extension so we can set the upload type
255
 
                        $ext = $this->_getext($locpath);
256
 
                        $mode = $this->_settype($ext);
257
 
                }
258
 
 
259
 
                $mode = ($mode == 'ascii') ? FTP_ASCII : FTP_BINARY;
260
 
 
261
 
                $result = @ftp_put($this->conn_id, $rempath, $locpath, $mode);
262
 
 
263
 
                if ($result === FALSE)
264
 
                {
265
 
                        if ($this->debug == TRUE)
266
 
                        {
267
 
                                $this->_error('ftp_unable_to_upload');
268
 
                        }
269
 
                        return FALSE;
270
 
                }
271
 
 
272
 
                // Set file permissions if needed
273
 
                if ( ! is_null($permissions))
274
 
                {
275
 
                        $this->chmod($rempath, (int)$permissions);
276
 
                }
277
 
 
278
 
                return TRUE;
279
 
        }
280
 
 
281
 
        // --------------------------------------------------------------------
282
 
 
283
 
        /**
284
 
         * Download a file from a remote server to the local server
285
 
         *
286
 
         * @access      public
287
 
         * @param       string
288
 
         * @param       string
289
 
         * @param       string
290
 
         * @return      bool
291
 
         */
292
 
        function download($rempath, $locpath, $mode = 'auto')
293
 
        {
294
 
                if ( ! $this->_is_conn())
295
 
                {
296
 
                        return FALSE;
297
 
                }
298
 
 
299
 
                // Set the mode if not specified
300
 
                if ($mode == 'auto')
301
 
                {
302
 
                        // Get the file extension so we can set the upload type
303
 
                        $ext = $this->_getext($rempath);
304
 
                        $mode = $this->_settype($ext);
305
 
                }
306
 
 
307
 
                $mode = ($mode == 'ascii') ? FTP_ASCII : FTP_BINARY;
308
 
 
309
 
                $result = @ftp_get($this->conn_id, $locpath, $rempath, $mode);
310
 
 
311
 
                if ($result === FALSE)
312
 
                {
313
 
                        if ($this->debug == TRUE)
314
 
                        {
315
 
                                $this->_error('ftp_unable_to_download');
316
 
                        }
317
 
                        return FALSE;
318
 
                }
319
 
 
320
 
                return TRUE;
321
 
        }
322
 
 
323
 
        // --------------------------------------------------------------------
324
 
 
325
 
        /**
326
 
         * Rename (or move) a file
327
 
         *
328
 
         * @access      public
329
 
         * @param       string
330
 
         * @param       string
331
 
         * @param       bool
332
 
         * @return      bool
333
 
         */
334
 
        function rename($old_file, $new_file, $move = FALSE)
335
 
        {
336
 
                if ( ! $this->_is_conn())
337
 
                {
338
 
                        return FALSE;
339
 
                }
340
 
 
341
 
                $result = @ftp_rename($this->conn_id, $old_file, $new_file);
342
 
 
343
 
                if ($result === FALSE)
344
 
                {
345
 
                        if ($this->debug == TRUE)
346
 
                        {
347
 
                                $msg = ($move == FALSE) ? 'ftp_unable_to_rename' : 'ftp_unable_to_move';
348
 
 
349
 
                                $this->_error($msg);
350
 
                        }
351
 
                        return FALSE;
352
 
                }
353
 
 
354
 
                return TRUE;
355
 
        }
356
 
 
357
 
        // --------------------------------------------------------------------
358
 
 
359
 
        /**
360
 
         * Move a file
361
 
         *
362
 
         * @access      public
363
 
         * @param       string
364
 
         * @param       string
365
 
         * @return      bool
366
 
         */
367
 
        function move($old_file, $new_file)
368
 
        {
369
 
                return $this->rename($old_file, $new_file, TRUE);
370
 
        }
371
 
 
372
 
        // --------------------------------------------------------------------
373
 
 
374
 
        /**
375
 
         * Rename (or move) a file
376
 
         *
377
 
         * @access      public
378
 
         * @param       string
379
 
         * @return      bool
380
 
         */
381
 
        function delete_file($filepath)
382
 
        {
383
 
                if ( ! $this->_is_conn())
384
 
                {
385
 
                        return FALSE;
386
 
                }
387
 
 
388
 
                $result = @ftp_delete($this->conn_id, $filepath);
389
 
 
390
 
                if ($result === FALSE)
391
 
                {
392
 
                        if ($this->debug == TRUE)
393
 
                        {
394
 
                                $this->_error('ftp_unable_to_delete');
395
 
                        }
396
 
                        return FALSE;
397
 
                }
398
 
 
399
 
                return TRUE;
400
 
        }
401
 
 
402
 
        // --------------------------------------------------------------------
403
 
 
404
 
        /**
405
 
         * Delete a folder and recursively delete everything (including sub-folders)
406
 
         * containted within it.
407
 
         *
408
 
         * @access      public
409
 
         * @param       string
410
 
         * @return      bool
411
 
         */
412
 
        function delete_dir($filepath)
413
 
        {
414
 
                if ( ! $this->_is_conn())
415
 
                {
416
 
                        return FALSE;
417
 
                }
418
 
 
419
 
                // Add a trailing slash to the file path if needed
420
 
                $filepath = preg_replace("/(.+?)\/*$/", "\\1/",  $filepath);
421
 
 
422
 
                $list = $this->list_files($filepath);
423
 
 
424
 
                if ($list !== FALSE AND count($list) > 0)
425
 
                {
426
 
                        foreach ($list as $item)
427
 
                        {
428
 
                                // If we can't delete the item it's probaly a folder so
429
 
                                // we'll recursively call delete_dir()
430
 
                                if ( ! @ftp_delete($this->conn_id, $item))
431
 
                                {
432
 
                                        $this->delete_dir($item);
433
 
                                }
434
 
                        }
435
 
                }
436
 
 
437
 
                $result = @ftp_rmdir($this->conn_id, $filepath);
438
 
 
439
 
                if ($result === FALSE)
440
 
                {
441
 
                        if ($this->debug == TRUE)
442
 
                        {
443
 
                                $this->_error('ftp_unable_to_delete');
444
 
                        }
445
 
                        return FALSE;
446
 
                }
447
 
 
448
 
                return TRUE;
449
 
        }
450
 
 
451
 
        // --------------------------------------------------------------------
452
 
 
453
 
        /**
454
 
         * Set file permissions
455
 
         *
456
 
         * @access      public
457
 
         * @param       string  the file path
458
 
         * @param       string  the permissions
459
 
         * @return      bool
460
 
         */
461
 
        function chmod($path, $perm)
462
 
        {
463
 
                if ( ! $this->_is_conn())
464
 
                {
465
 
                        return FALSE;
466
 
                }
467
 
 
468
 
                // Permissions can only be set when running PHP 5
469
 
                if ( ! function_exists('ftp_chmod'))
470
 
                {
471
 
                        if ($this->debug == TRUE)
472
 
                        {
473
 
                                $this->_error('ftp_unable_to_chmod');
474
 
                        }
475
 
                        return FALSE;
476
 
                }
477
 
 
478
 
                $result = @ftp_chmod($this->conn_id, $perm, $path);
479
 
 
480
 
                if ($result === FALSE)
481
 
                {
482
 
                        if ($this->debug == TRUE)
483
 
                        {
484
 
                                $this->_error('ftp_unable_to_chmod');
485
 
                        }
486
 
                        return FALSE;
487
 
                }
488
 
 
489
 
                return TRUE;
490
 
        }
491
 
 
492
 
        // --------------------------------------------------------------------
493
 
 
494
 
        /**
495
 
         * FTP List files in the specified directory
496
 
         *
497
 
         * @access      public
498
 
         * @return      array
499
 
         */
500
 
        function list_files($path = '.')
501
 
        {
502
 
                if ( ! $this->_is_conn())
503
 
                {
504
 
                        return FALSE;
505
 
                }
506
 
 
507
 
                return ftp_nlist($this->conn_id, $path);
508
 
        }
509
 
 
510
 
        // ------------------------------------------------------------------------
511
 
 
512
 
        /**
513
 
         * Read a directory and recreate it remotely
514
 
         *
515
 
         * This function recursively reads a folder and everything it contains (including
516
 
         * sub-folders) and creates a mirror via FTP based on it.  Whatever the directory structure
517
 
         * of the original file path will be recreated on the server.
518
 
         *
519
 
         * @access      public
520
 
         * @param       string  path to source with trailing slash
521
 
         * @param       string  path to destination - include the base folder with trailing slash
522
 
         * @return      bool
523
 
         */
524
 
        function mirror($locpath, $rempath)
525
 
        {
526
 
                if ( ! $this->_is_conn())
527
 
                {
528
 
                        return FALSE;
529
 
                }
530
 
 
531
 
                // Open the local file path
532
 
                if ($fp = @opendir($locpath))
533
 
                {
534
 
                        // Attempt to open the remote file path.
535
 
                        if ( ! $this->changedir($rempath, TRUE))
536
 
                        {
537
 
                                // If it doesn't exist we'll attempt to create the direcotory
538
 
                                if ( ! $this->mkdir($rempath) OR ! $this->changedir($rempath))
539
 
                                {
540
 
                                        return FALSE;
541
 
                                }
542
 
                        }
543
 
 
544
 
                        // Recursively read the local directory
545
 
                        while (FALSE !== ($file = readdir($fp)))
546
 
                        {
547
 
                                if (@is_dir($locpath.$file) && substr($file, 0, 1) != '.')
548
 
                                {
549
 
                                        $this->mirror($locpath.$file."/", $rempath.$file."/");
550
 
                                }
551
 
                                elseif (substr($file, 0, 1) != ".")
552
 
                                {
553
 
                                        // Get the file extension so we can se the upload type
554
 
                                        $ext = $this->_getext($file);
555
 
                                        $mode = $this->_settype($ext);
556
 
 
557
 
                                        $this->upload($locpath.$file, $rempath.$file, $mode);
558
 
                                }
559
 
                        }
560
 
                        return TRUE;
561
 
                }
562
 
 
563
 
                return FALSE;
564
 
        }
565
 
 
566
 
 
567
 
        // --------------------------------------------------------------------
568
 
 
569
 
        /**
570
 
         * Extract the file extension
571
 
         *
572
 
         * @access      private
573
 
         * @param       string
574
 
         * @return      string
575
 
         */
576
 
        function _getext($filename)
577
 
        {
578
 
                if (FALSE === strpos($filename, '.'))
579
 
                {
580
 
                        return 'txt';
581
 
                }
582
 
 
583
 
                $x = explode('.', $filename);
584
 
                return end($x);
585
 
        }
586
 
 
587
 
 
588
 
        // --------------------------------------------------------------------
589
 
 
590
 
        /**
591
 
         * Set the upload type
592
 
         *
593
 
         * @access      private
594
 
         * @param       string
595
 
         * @return      string
596
 
         */
597
 
        function _settype($ext)
598
 
        {
599
 
                $text_types = array(
600
 
                                                        'txt',
601
 
                                                        'text',
602
 
                                                        'php',
603
 
                                                        'phps',
604
 
                                                        'php4',
605
 
                                                        'js',
606
 
                                                        'css',
607
 
                                                        'htm',
608
 
                                                        'html',
609
 
                                                        'phtml',
610
 
                                                        'shtml',
611
 
                                                        'log',
612
 
                                                        'xml'
613
 
                                                        );
614
 
 
615
 
 
616
 
                return (in_array($ext, $text_types)) ? 'ascii' : 'binary';
617
 
        }
618
 
 
619
 
        // ------------------------------------------------------------------------
620
 
 
621
 
        /**
622
 
         * Close the connection
623
 
         *
624
 
         * @access      public
625
 
         * @param       string  path to source
626
 
         * @param       string  path to destination
627
 
         * @return      bool
628
 
         */
629
 
        function close()
630
 
        {
631
 
                if ( ! $this->_is_conn())
632
 
                {
633
 
                        return FALSE;
634
 
                }
635
 
 
636
 
                @ftp_close($this->conn_id);
637
 
        }
638
 
 
639
 
        // ------------------------------------------------------------------------
640
 
 
641
 
        /**
642
 
         * Display error message
643
 
         *
644
 
         * @access      private
645
 
         * @param       string
646
 
         * @return      bool
647
 
         */
648
 
        function _error($line)
649
 
        {
650
 
                $CI =& get_instance();
651
 
                $CI->lang->load('ftp');
652
 
                show_error($CI->lang->line($line));
653
 
        }
654
 
 
655
 
 
656
 
}
657
 
// END FTP Class
658
 
 
659
 
/* End of file Ftp.php */
660
 
/* Location: ./system/libraries/Ftp.php */
 
 
b'\\ No newline at end of file'