phpBB/includes/functions_transfer.php

   1 <?php
   2 /**
   3 *
   4 * @package phpBB3
   5 * @version $Id$
   6 * @copyright (c) 2005 phpBB Group
   7 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
   8 *
   9 */
  10
  11 /**
  12 * @ignore
  13 */
  14 if (!defined('IN_PHPBB'))
  15 {
  16         exit;
  17 }
  18
  19 require_once PHPBB_ROOT_PATH . 'includes/libraries/sftp/sftp.' . PHP_EXT;
  20
  21 /**
  22 * Transfer class, wrapper for ftp/sftp/ssh
  23 * @package phpBB3
  24 */
  25 class transfer
  26 {
  27         var $connection;
  28         var $host;
  29         var $port;
  30         var $username;
  31         var $password;
  32         var $timeout;
  33         var $root_path;
  34         var $tmp_path;
  35         var $file_perms;
  36         var $dir_perms;
  37
  38         /**
  39         * Constructor - init some basic values
  40         */
  41         function __construct()
  42         {
  43                 $this->file_perms       = 0644;
  44                 $this->dir_perms        = 0777;
  45
  46                 // We use the store directory as temporary path to circumvent open basedir restrictions
  47                 $this->tmp_path = PHPBB_ROOT_PATH . 'store/';
  48         }
  49
  50         /**
  51         * Write file to location
  52         */
  53         public function write_file($destination_file = '', $contents = '')
  54         {
  55                 $destination_file = $this->root_path . str_replace(PHPBB_ROOT_PATH, '', $destination_file);
  56
  57                 // need to create a temp file and then move that temp file.
  58                 // ftp functions can only move files around and can't create.
  59                 // This means that the users will need to have access to write
  60                 // temporary files or have write access on a folder within phpBB
  61                 // like the cache folder. If the user can't do either, then
  62                 // he/she needs to use the fsock ftp method
  63                 $temp_name = tempnam($this->tmp_path, 'transfer_');
  64                 @unlink($temp_name);
  65
  66                 $fp = @fopen($temp_name, 'w');
  67
  68                 if (!$fp)
  69                 {
  70                         trigger_error('Unable to create temporary file ' . $temp_name, E_USER_ERROR);
  71                 }
  72
  73                 @fwrite($fp, $contents);
  74                 @fclose($fp);
  75
  76                 $result = $this->overwrite_file($temp_name, $destination_file);
  77
  78                 // remove temporary file now
  79                 @unlink($temp_name);
  80
  81                 return $result;
  82         }
  83
  84         /**
  85         * Moving file into location. If the destination file already exists it gets overwritten
  86         */
  87         public function overwrite_file($source_file, $destination_file)
  88         {
  89                 /**
  90                 * @todo generally think about overwriting files in another way, by creating a temporary file and then renaming it
  91                 * @todo check for the destination file existance too
  92                 */
  93                 $this->_delete($destination_file);
  94                 $result = $this->_put($source_file, $destination_file);
  95                 $this->_chmod($destination_file, $this->file_perms);
  96
  97                 return $result;
  98         }
  99
 100         /**
 101         * Create directory structure
 102         */
 103         public function make_dir($dir)
 104         {
 105                 $dir = str_replace(PHPBB_ROOT_PATH, '', $dir);
 106                 $dir = explode('/', $dir);
 107                 $dirs = '';
 108
 109                 for ($i = 0, $total = sizeof($dir); $i < $total; $i++)
 110                 {
 111                         $result = true;
 112
 113                         if (strpos($dir[$i], '.') === 0)
 114                         {
 115                                 continue;
 116                         }
 117                         $cur_dir = $dir[$i] . '/';
 118
 119                         if (!file_exists(PHPBB_ROOT_PATH . $dirs . $cur_dir))
 120                         {
 121                                 // create the directory
 122                                 $result = $this->_mkdir($dir[$i]);
 123                                 $this->_chmod($dir[$i], $this->dir_perms);
 124                         }
 125
 126                         $this->_chdir($this->root_path . $dirs . $dir[$i]);
 127                         $dirs .= $cur_dir;
 128                 }
 129
 130                 $this->_chdir($this->root_path);
 131
 132                 /**
 133                 * @todo stack result into array to make sure every path creation has been taken care of
 134                 */
 135                 return $result;
 136         }
 137
 138         /**
 139         * Copy file from source location to destination location
 140         */
 141         public function copy_file($from_loc, $to_loc)
 142         {
 143                 $from_loc = ((strpos($from_loc, PHPBB_ROOT_PATH) !== 0) ? PHPBB_ROOT_PATH : '') . $from_loc;
 144                 $to_loc = $this->root_path . str_replace(PHPBB_ROOT_PATH, '', $to_loc);
 145
 146                 if (!file_exists($from_loc))
 147                 {
 148                         return false;
 149                 }
 150
 151                 $result = $this->overwrite_file($from_loc, $to_loc);
 152
 153                 return $result;
 154         }
 155
 156         /**
 157         * Remove file
 158         */
 159         public function delete_file($file)
 160         {
 161                 $file = $this->root_path . str_replace(PHPBB_ROOT_PATH, '', $file);
 162
 163                 return $this->_delete($file);
 164         }
 165
 166         /**
 167         * Remove directory
 168         * @todo remove child directories?
 169         */
 170         public function remove_dir($dir)
 171         {
 172                 $dir = $this->root_path . str_replace(PHPBB_ROOT_PATH, '', $dir);
 173
 174                 return $this->_rmdir($dir);
 175         }
 176
 177         /**
 178         * Rename a file or folder
 179         */
 180         public function rename($old_handle, $new_handle)
 181         {
 182                 $old_handle = $this->root_path . str_replace(PHPBB_ROOT_PATH, '', $old_handle);
 183
 184                 return $this->_rename($old_handle, $new_handle);
 185         }
 186
 187         /**
 188         * Check if a specified file exist...
 189         */
 190         public function file_exists($directory, $filename)
 191         {
 192                 $directory = $this->root_path . str_replace(PHPBB_ROOT_PATH, '', $directory);
 193
 194                 $this->_chdir($directory);
 195                 $result = $this->_ls('');
 196
 197                 if ($result !== false && is_array($result))
 198                 {
 199                         return (in_array($filename, $result)) ? true : false;
 200                 }
 201
 202                 return false;
 203         }
 204
 205         /**
 206         * Open session
 207         */
 208         public function open_session()
 209         {
 210                 return $this->_init();
 211         }
 212
 213         /**
 214         * Close current session
 215         */
 216         public function close_session()
 217         {
 218                 return $this->_close();
 219         }
 220
 221         /**
 222         * Determine methods able to be used
 223         */
 224         public static function methods()
 225         {
 226                 $methods = array();
 227                 $disabled_functions = explode(',', @ini_get('disable_functions'));
 228
 229                 if (@extension_loaded('ftp'))
 230                 {
 231                         $methods[] = 'ftp';
 232                 }
 233
 234                 if (!in_array('fsockopen', $disabled_functions))
 235                 {
 236                         $methods[] = 'ftp_fsock';
 237                         $methods[] = 'sftp';
 238                 }
 239
 240                 return $methods;
 241         }
 242 }
 243
 244 /**
 245 * FTP transfer class
 246 * @package phpBB3
 247 */
 248 class ftp extends transfer
 249 {
 250         /**
 251         * Standard parameters for FTP session
 252         */
 253         function __construct($host, $username, $password, $root_path, $port = 21, $timeout = 10)
 254         {
 255                 $this->host                     = $host;
 256                 $this->port                     = $port;
 257                 $this->username         = $username;
 258                 $this->password         = $password;
 259                 $this->timeout          = $timeout;
 260
 261                 // Make sure $this->root_path is layed out the same way as the phpbb::$user->page['root_script_path'] value (/ at the end)
 262                 $this->root_path        = str_replace('\\', '/', $this->root_path);
 263
 264                 if (!empty($root_path))
 265                 {
 266                         $this->root_path = (($root_path[0] != '/' ) ? '/' : '') . $root_path . ((substr($root_path, -1, 1) == '/') ? '' : '/');
 267                 }
 268
 269                 // Init some needed values
 270                 parent::__construct();
 271
 272                 return;
 273         }
 274
 275         /**
 276         * Requests data
 277         */
 278         public static function data()
 279         {
 280                 $root_path = phpbb::$url->realpath(PHPBB_ROOT_PATH);
 281                 return array(
 282                         'host'          => 'localhost',
 283                         'username'      => preg_match('#^/home/([^/]+)#', $root_path, $matches) ? $matches[1] : 'anonymous',
 284                         'password'      => '',
 285                         'root_path'     => phpbb::$user->page['root_script_path'],
 286                         'port'          => 21,
 287                         'timeout'       => 10
 288                 );
 289         }
 290
 291         /**
 292         * Init FTP Session
 293         * @access private
 294         */
 295         protected function _init()
 296         {
 297                 // connect to the server
 298                 $this->connection = @ftp_connect($this->host, $this->port, $this->timeout);
 299
 300                 if (!$this->connection)
 301                 {
 302                         return 'ERR_CONNECTING_SERVER';
 303                 }
 304
 305                 // attempt to turn pasv mode on
 306                 @ftp_pasv($this->connection, true);
 307
 308                 // login to the server
 309                 if (!@ftp_login($this->connection, $this->username, $this->password))
 310                 {
 311                         return 'ERR_UNABLE_TO_LOGIN';
 312                 }
 313
 314                 // change to the root directory
 315                 if (!$this->_chdir($this->root_path))
 316                 {
 317                         return 'ERR_CHANGING_DIRECTORY';
 318                 }
 319
 320                 return true;
 321         }
 322
 323         /**
 324         * Create Directory (MKDIR)
 325         * @access private
 326         */
 327         protected function _mkdir($dir)
 328         {
 329                 return @ftp_mkdir($this->connection, $dir);
 330         }
 331
 332         /**
 333         * Remove directory (RMDIR)
 334         * @access private
 335         */
 336         protected function _rmdir($dir)
 337         {
 338                 return @ftp_rmdir($this->connection, $dir);
 339         }
 340
 341         /**
 342         * Rename file
 343         * @access private
 344         */
 345         protected function _rename($old_handle, $new_handle)
 346         {
 347                 return @ftp_rename($this->connection, $old_handle, $new_handle);
 348         }
 349
 350         /**
 351         * Change current working directory (CHDIR)
 352         * @access private
 353         */
 354         protected function _chdir($dir = '')
 355         {
 356                 if ($dir && $dir !== '/')
 357                 {
 358                         if (substr($dir, -1, 1) == '/')
 359                         {
 360                                 $dir = substr($dir, 0, -1);
 361                         }
 362                 }
 363
 364                 return @ftp_chdir($this->connection, $dir);
 365         }
 366
 367         /**
 368         * change file permissions (CHMOD)
 369         * @access private
 370         */
 371         protected function _chmod($file, $perms)
 372         {
 373                 if (function_exists('ftp_chmod'))
 374                 {
 375                         $err = @ftp_chmod($this->connection, $perms, $file);
 376                 }
 377                 else
 378                 {
 379                         // Unfortunatly CHMOD is not expecting an octal value...
 380                         // We need to transform the integer (which was an octal) to an octal representation (to get the int) and then pass as is. ;)
 381                         $chmod_cmd = 'CHMOD ' . base_convert($perms, 10, 8) . ' ' . $file;
 382                         $err = $this->_site($chmod_cmd);
 383                 }
 384
 385                 return $err;
 386         }
 387
 388         /**
 389         * Upload file to location (PUT)
 390         * @access private
 391         */
 392         protected function _put($from_file, $to_file)
 393         {
 394                 // get the file extension
 395                 $file_extension = strtolower(substr(strrchr($to_file, '.'), 1));
 396
 397                 // We only use the BINARY file mode to cicumvent rewrite actions from ftp server (mostly linefeeds being replaced)
 398                 $mode = FTP_BINARY;
 399
 400                 $to_dir = dirname($to_file);
 401                 $to_file = basename($to_file);
 402                 $this->_chdir($to_dir);
 403
 404                 $result = @ftp_put($this->connection, $to_file, $from_file, $mode);
 405                 $this->_chdir($this->root_path);
 406
 407                 return $result;
 408         }
 409
 410         /**
 411         * Delete file (DELETE)
 412         * @access private
 413         */
 414         protected function _delete($file)
 415         {
 416                 return @ftp_delete($this->connection, $file);
 417         }
 418
 419         /**
 420         * Close ftp session (CLOSE)
 421         * @access private
 422         */
 423         protected function _close()
 424         {
 425                 if (!$this->connection)
 426                 {
 427                         return false;
 428                 }
 429
 430                 return @ftp_quit($this->connection);
 431         }
 432
 433         /**
 434         * Return current working directory (CWD)
 435         * At the moment not used by parent class
 436         * @access private
 437         */
 438         protected function _cwd()
 439         {
 440                 return @ftp_pwd($this->connection);
 441         }
 442
 443         /**
 444         * Return list of files in a given directory (LS)
 445         * @access private
 446         */
 447         protected function _ls($dir = './')
 448         {
 449                 $list = @ftp_nlist($this->connection, $dir);
 450
 451                 // Remove path if prepended
 452                 foreach ($list as $key => $item)
 453                 {
 454                         // Use same separator for item and dir
 455                         $item = str_replace('\\', '/', $item);
 456                         $dir = str_replace('\\', '/', $dir);
 457
 458                         if (!empty($dir) && strpos($item, $dir) === 0)
 459                         {
 460                                 $item = substr($item, strlen($dir));
 461                         }
 462
 463                         $list[$key] = $item;
 464                 }
 465
 466                 return $list;
 467         }
 468
 469         /**
 470         * FTP SITE command (ftp-only function)
 471         * @access private
 472         */
 473         private function _site($command)
 474         {
 475                 return @ftp_site($this->connection, $command);
 476         }
 477 }
 478
 479 /**
 480 * FTP fsock transfer class
 481 *
 482 * @author wGEric
 483 * @package phpBB3
 484 */
 485 class ftp_fsock extends transfer
 486 {
 487         var $data_connection;
 488
 489         /**
 490         * Standard parameters for FTP session
 491         */
 492         function __construct($host, $username, $password, $root_path, $port = 21, $timeout = 10)
 493         {
 494                 $this->host                     = $host;
 495                 $this->port                     = $port;
 496                 $this->username         = $username;
 497                 $this->password         = $password;
 498                 $this->timeout          = $timeout;
 499
 500                 // Make sure $this->root_path is layed out the same way as the phpbb::$user->page['root_script_path'] value (/ at the end)
 501                 $this->root_path        = str_replace('\\', '/', $this->root_path);
 502
 503                 if (!empty($root_path))
 504                 {
 505                         $this->root_path = (($root_path[0] != '/' ) ? '/' : '') . $root_path . ((substr($root_path, -1, 1) == '/') ? '' : '/');
 506                 }
 507
 508                 // Init some needed values
 509                 parent::__construct();
 510
 511                 return;
 512         }
 513
 514         /**
 515         * Requests data
 516         */
 517         public static function data()
 518         {
 519                 $root_path = phpbb::$url->realpath(PHPBB_ROOT_PATH);
 520                 return array(
 521                         'host'          => 'localhost',
 522                         'username'      => preg_match('#^/home/([^/]+)#', $root_path, $matches) ? $matches[1] : 'anonymous',
 523                         'password'      => '',
 524                         'root_path'     => phpbb::$user->page['root_script_path'],
 525                         'port'          => 21,
 526                         'timeout'       => 10
 527                 );
 528         }
 529
 530         /**
 531         * Init FTP Session
 532         * @access private
 533         */
 534         protected function _init()
 535         {
 536                 $errno = 0;
 537                 $errstr = '';
 538
 539                 // connect to the server
 540                 $this->connection = @fsockopen($this->host, $this->port, $errno, $errstr, $this->timeout);
 541
 542                 if (!$this->connection || !$this->_check_command())
 543                 {
 544                         return 'ERR_CONNECTING_SERVER';
 545                 }
 546
 547                 @stream_set_timeout($this->connection, $this->timeout);
 548
 549                 // login
 550                 if (!$this->_send_command('USER', $this->username))
 551                 {
 552                         return 'ERR_UNABLE_TO_LOGIN';
 553                 }
 554
 555                 if (!$this->_send_command('PASS', $this->password))
 556                 {
 557                         return 'ERR_UNABLE_TO_LOGIN';
 558                 }
 559
 560                 // change to the root directory
 561                 if (!$this->_chdir($this->root_path))
 562                 {
 563                         return 'ERR_CHANGING_DIRECTORY';
 564                 }
 565
 566                 return true;
 567         }
 568
 569         /**
 570         * Create Directory (MKDIR)
 571         * @access private
 572         */
 573         protected function _mkdir($dir)
 574         {
 575                 return $this->_send_command('MKD', $dir);
 576         }
 577
 578         /**
 579         * Remove directory (RMDIR)
 580         * @access private
 581         */
 582         protected function _rmdir($dir)
 583         {
 584                 return $this->_send_command('RMD', $dir);
 585         }
 586
 587         /**
 588         * Rename File
 589         * @access private
 590         */
 591         protected function _rename($old_handle, $new_handle)
 592         {
 593                 $this->_send_command('RNFR', $old_handle);
 594                 return $this->_send_command('RNTO', $new_handle);
 595         }
 596
 597         /**
 598         * Change current working directory (CHDIR)
 599         * @access private
 600         */
 601         protected function _chdir($dir = '')
 602         {
 603                 if ($dir && $dir !== '/')
 604                 {
 605                         if (substr($dir, -1, 1) == '/')
 606                         {
 607                                 $dir = substr($dir, 0, -1);
 608                         }
 609                 }
 610
 611                 return $this->_send_command('CWD', $dir);
 612         }
 613
 614         /**
 615         * change file permissions (CHMOD)
 616         * @access private
 617         */
 618         protected function _chmod($file, $perms)
 619         {
 620                 // Unfortunatly CHMOD is not expecting an octal value...
 621                 // We need to transform the integer (which was an octal) to an octal representation (to get the int) and then pass as is. ;)
 622                 return $this->_send_command('SITE CHMOD', base_convert($perms, 10, 8) . ' ' . $file);
 623         }
 624
 625         /**
 626         * Upload file to location (PUT)
 627         * @access private
 628         */
 629         protected function _put($from_file, $to_file)
 630         {
 631                 // We only use the BINARY file mode to cicumvent rewrite actions from ftp server (mostly linefeeds being replaced)
 632                 // 'I' == BINARY
 633                 // 'A' == ASCII
 634                 if (!$this->_send_command('TYPE', 'I'))
 635                 {
 636                         return false;
 637                 }
 638
 639                 // open the connection to send file over
 640                 if (!$this->_open_data_connection())
 641                 {
 642                         return false;
 643                 }
 644
 645                 $this->_send_command('STOR', $to_file, false);
 646
 647                 // send the file
 648                 $fp = @fopen($from_file, 'rb');
 649                 while (!@feof($fp))
 650                 {
 651                         @fwrite($this->data_connection, @fread($fp, 4096));
 652                 }
 653                 @fclose($fp);
 654
 655                 // close connection
 656                 $this->_close_data_connection();
 657
 658                 return $this->_check_command();
 659         }
 660
 661         /**
 662         * Delete file (DELETE)
 663         * @access private
 664         */
 665         protected function _delete($file)
 666         {
 667                 return $this->_send_command('DELE', $file);
 668         }
 669
 670         /**
 671         * Close ftp session (CLOSE)
 672         * @access private
 673         */
 674         protected function _close()
 675         {
 676                 if (!$this->connection)
 677                 {
 678                         return false;
 679                 }
 680
 681                 return $this->_send_command('QUIT');
 682         }
 683
 684         /**
 685         * Return current working directory (CWD)
 686         * At the moment not used by parent class
 687         * @access private
 688         */
 689         protected function _cwd()
 690         {
 691                 $this->_send_command('PWD', '', false);
 692                 return preg_replace('#^[0-9]{3} "(.+)" .+\r\n#', '\\1', $this->_check_command(true));
 693         }
 694
 695         /**
 696         * Return list of files in a given directory (LS)
 697         * @access private
 698         */
 699         protected function _ls($dir = './')
 700         {
 701                 if (!$this->_open_data_connection())
 702                 {
 703                         return false;
 704                 }
 705
 706                 $this->_send_command('NLST', $dir);
 707
 708                 $list = array();
 709                 while (!@feof($this->data_connection))
 710                 {
 711                         $list[] = preg_replace('#[\r\n]#', '', @fgets($this->data_connection, 512));
 712                 }
 713                 $this->_close_data_connection();
 714
 715                 // Clear buffer
 716                 $this->_check_command();
 717
 718                 // Remove path if prepended
 719                 foreach ($list as $key => $item)
 720                 {
 721                         // Use same separator for item and dir
 722                         $item = str_replace('\\', '/', $item);
 723                         $dir = str_replace('\\', '/', $dir);
 724
 725                         if (strpos($item, $dir) === 0)
 726                         {
 727                                 $item = substr($item, strlen($dir));
 728                         }
 729
 730                         $list[$key] = $item;
 731                 }
 732
 733                 return $list;
 734         }
 735
 736         /**
 737         * Send a command to server (FTP fsock only function)
 738         * @access private
 739         */
 740         private function _send_command($command, $args = '', $check = true)
 741         {
 742                 if (!empty($args))
 743                 {
 744                         $command = "$command $args";
 745                 }
 746
 747                 fwrite($this->connection, $command . "\r\n");
 748
 749                 if ($check === true && !$this->_check_command())
 750                 {
 751                         return false;
 752                 }
 753
 754                 return true;
 755         }
 756
 757         /**
 758         * Opens a connection to send data (FTP fosck only function)
 759         * @access private
 760         */
 761         private function _open_data_connection()
 762         {
 763                 $this->_send_command('PASV', '', false);
 764
 765                 if (!$ip_port = $this->_check_command(true))
 766                 {
 767                         return false;
 768                 }
 769
 770                 // open the connection to start sending the file
 771                 if (!preg_match('#[0-9]{1,3},[0-9]{1,3},[0-9]{1,3},[0-9]{1,3},[0-9]+,[0-9]+#', $ip_port, $temp))
 772                 {
 773                         // bad ip and port
 774                         return false;
 775                 }
 776
 777                 $temp = explode(',', $temp[0]);
 778                 $server_ip = $temp[0] . '.' . $temp[1] . '.' . $temp[2] . '.' . $temp[3];
 779                 $server_port = $temp[4] * 256 + $temp[5];
 780                 $errno = 0;
 781                 $errstr = '';
 782
 783                 if (!$this->data_connection = @fsockopen($server_ip, $server_port, $errno, $errstr, $this->timeout))
 784                 {
 785                         return false;
 786                 }
 787                 @stream_set_timeout($this->data_connection, $this->timeout);
 788
 789                 return true;
 790         }
 791
 792         /**
 793         * Closes a connection used to send data
 794         * @access private
 795         */
 796         private function _close_data_connection()
 797         {
 798                 return @fclose($this->data_connection);
 799         }
 800
 801         /**
 802         * Check to make sure command was successful (FTP fsock only function)
 803         * @access private
 804         */
 805         private function _check_command($return = false)
 806         {
 807                 $response = '';
 808
 809                 do
 810                 {
 811                         $result = @fgets($this->connection, 512);
 812                         $response .= $result;
 813                 }
 814                 while (substr($response, 3, 1) != ' ');
 815
 816                 if (!preg_match('#^[123]#', $response))
 817                 {
 818                         return false;
 819                 }
 820
 821                 return ($return) ? $response : true;
 822         }
 823 }
 824
 825 /**
 826 * SFTP transfer class
 827 * @package phpBB3
 828 */
 829 class sftp extends transfer
 830 {
 831         var $current_path;
 832
 833         /**
 834         * Standard parameters for SFTP session
 835         */
 836         function __construct($host, $username, $password, $root_path, $port = 22, $timeout = 10)
 837         {
 838                 $this->host                     = $host;
 839                 $this->port                     = $port;
 840                 $this->username         = $username;
 841                 $this->password         = $password;
 842                 $this->timeout          = $timeout;
 843
 844                 // Make sure $this->root_path is layed out the same way as the phpbb::$user->page['root_script_path'] value (/ at the end)
 845                 $this->root_path        = str_replace('\\', '/', $this->root_path);
 846
 847                 if (!empty($root_path))
 848                 {
 849                         $this->root_path = (($root_path[0] != '/' ) ? '/' : '') . $root_path . ((substr($root_path, -1, 1) == '/') ? '' : '/');
 850                 }
 851
 852                 // Init some needed values
 853                 parent::__construct();
 854
 855                 return;
 856         }
 857
 858         /**
 859         * Requests data
 860         */
 861         public static function data()
 862         {
 863                 $root_path = phpbb::$url->realpath(PHPBB_ROOT_PATH);
 864                 return array(
 865                         'host'          => 'localhost',
 866                         'username'      => preg_match('#^/home/([^/]+)#', $root_path, $matches) ? $matches[1] : 'anonymous',
 867                         'password'      => '',
 868                         'root_path'     => $root_path,
 869                         'port'          => 22,
 870                         'timeout'       => 10
 871                 );
 872         }
 873         /**
 874         * Init SFTP Session
 875         * @access private
 876         */
 877         protected function _init()
 878         {
 879                 // connect to the server
 880                 $this->connection = new ssh2_sftp($this->host, $this->port, $this->timeout);
 881
 882                 if (!$this->connection->login($this->username, $this->password))
 883                 {
 884                         return 'ERR_CONNECTING_SERVER';
 885                 }
 886
 887                 // change to the root directory
 888                 if (!$this->_chdir($this->root_path))
 889                 {
 890                         return 'ERR_CHANGING_DIRECTORY';
 891                 }
 892
 893                 return true;
 894         }
 895
 896         /**
 897         * Create Directory (MKDIR)
 898         * @access private
 899         */
 900         protected function _mkdir($dir)
 901         {
 902                 return $this->connection->mkdir($dir);
 903         }
 904
 905         /**
 906         * Remove directory (RMDIR)
 907         * @access private
 908         */
 909         protected function _rmdir($dir)
 910         {
 911                 return $this->connection->rmdir($dir);
 912         }
 913
 914         /**
 915         * Rename File
 916         * @access private
 917         */
 918         protected function _rename($old_handle, $new_handle)
 919         {
 920                 return $this->connection->rename($old_handle, $new_handle);
 921         }
 922
 923         /**
 924         * Change current working directory (CHDIR)
 925         * @access private
 926         */
 927         protected function _chdir($dir = '')
 928         {
 929                 return $this->connection->chdir($dir);
 930         }
 931
 932         /**
 933         * change file permissions (CHMOD)
 934         * @access private
 935         */
 936         protected function _chmod($file, $perms)
 937         {
 938                 return $this->connection->chmod($file, $perms);
 939         }
 940
 941         /**
 942         * Upload file to location (PUT)
 943         * @access private
 944         */
 945         protected function _put($from_file, $to_file)
 946         {
 947                 return $this->connection->put($to_file, $from_file, NET_SFTP_LOCAL_FILE);
 948         }
 949
 950         /**
 951         * Delete file (DELETE)
 952         * @access private
 953         */
 954         protected function _delete($file)
 955         {
 956                 return $this->connection->delete($file);
 957         }
 958
 959         /**
 960         * Close ftp session (CLOSE)
 961         * @access private
 962         */
 963         protected function _close()
 964         {
 965                 if (!$this->connection)
 966                 {
 967                         return false;
 968                 }
 969
 970                 return $this->connection->disconnect();
 971         }
 972
 973         /**
 974         * Return current working directory (CWD)
 975         * At the moment not used by parent class
 976         * @access private
 977         */
 978         protected function _cwd()
 979         {
 980                 return $this->connection->pwd();
 981         }
 982
 983         /**
 984         * Return list of files in a given directory (LS)
 985         * @access private
 986         */
 987         protected function _ls($dir = './')
 988         {
 989                 $list = $this->connection->nlist($dir);
 990
 991                 // Remove path if prepended
 992                 foreach ($list as $key => $item)
 993                 {
 994                         // Use same separator for item and dir
 995                         $item = str_replace('\\', '/', $item);
 996                         $dir = str_replace('\\', '/', $dir);
 997
 998                         if (strpos($item, $dir) === 0)
 999                         {
1000                                 $item = substr($item, strlen($dir));
1001                         }
1002
1003                         $list[$key] = $item;
1004                 }
1005
1006                 return $list;
1007         }
1008 }
1009
1010 ?>