/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: galaxyAbstractor
  • Date: 2013-04-10 15:58:59 UTC
  • mfrom: (20.1.1 lenasys)
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: galaxyabstractor@gmail.com-20130410155859-cih60kaz5es8savt
CodeIgniter implementation of basic CMS system

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/system/libraries/Ftp.php
 
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'