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