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