PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/ftp - php_ftp.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 317 478 66.3 %
Date: 2015-08-29 Functions: 36 36 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2015 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Andrew Skalski <askalski@chek.com>                          |
      16             :    |          Stefan Esser <sesser@php.net> (resume functions)            |
      17             :    +----------------------------------------------------------------------+
      18             :  */
      19             : 
      20             : /* $Id$ */
      21             : 
      22             : #ifdef HAVE_CONFIG_H
      23             : #include "config.h"
      24             : #endif
      25             : 
      26             : #include "php.h"
      27             : 
      28             : #if defined(NETWARE) && defined(USE_WINSOCK)
      29             : #include <novsock2.h>
      30             : #endif
      31             : 
      32             : #ifdef HAVE_FTP_SSL
      33             : # include <openssl/ssl.h>
      34             : #endif
      35             : 
      36             : #if HAVE_FTP
      37             : 
      38             : #include "ext/standard/info.h"
      39             : #include "ext/standard/file.h"
      40             : 
      41             : #include "php_ftp.h"
      42             : #include "ftp.h"
      43             : 
      44             : static int le_ftpbuf;
      45             : #define le_ftpbuf_name "FTP Buffer"
      46             : 
      47             : /* {{{ arginfo */
      48             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_connect, 0, 0, 1)
      49             :         ZEND_ARG_INFO(0, host)
      50             :         ZEND_ARG_INFO(0, port)
      51             :         ZEND_ARG_INFO(0, timeout)
      52             : ZEND_END_ARG_INFO()
      53             : 
      54             : #ifdef HAVE_FTP_SSL
      55             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_ssl_connect, 0, 0, 1)
      56             :         ZEND_ARG_INFO(0, host)
      57             :         ZEND_ARG_INFO(0, port)
      58             :         ZEND_ARG_INFO(0, timeout)
      59             : ZEND_END_ARG_INFO()
      60             : #endif
      61             : 
      62             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_login, 0)
      63             :         ZEND_ARG_INFO(0, ftp)
      64             :         ZEND_ARG_INFO(0, username)
      65             :         ZEND_ARG_INFO(0, password)
      66             : ZEND_END_ARG_INFO()
      67             : 
      68             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_pwd, 0)
      69             :         ZEND_ARG_INFO(0, ftp)
      70             : ZEND_END_ARG_INFO()
      71             : 
      72             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_cdup, 0)
      73             :         ZEND_ARG_INFO(0, ftp)
      74             : ZEND_END_ARG_INFO()
      75             : 
      76             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_chdir, 0)
      77             :         ZEND_ARG_INFO(0, ftp)
      78             :         ZEND_ARG_INFO(0, directory)
      79             : ZEND_END_ARG_INFO()
      80             : 
      81             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_exec, 0)
      82             :         ZEND_ARG_INFO(0, ftp)
      83             :         ZEND_ARG_INFO(0, command)
      84             : ZEND_END_ARG_INFO()
      85             : 
      86             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_raw, 0)
      87             :         ZEND_ARG_INFO(0, ftp)
      88             :         ZEND_ARG_INFO(0, command)
      89             : ZEND_END_ARG_INFO()
      90             : 
      91             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_mkdir, 0)
      92             :         ZEND_ARG_INFO(0, ftp)
      93             :         ZEND_ARG_INFO(0, directory)
      94             : ZEND_END_ARG_INFO()
      95             : 
      96             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_rmdir, 0)
      97             :         ZEND_ARG_INFO(0, ftp)
      98             :         ZEND_ARG_INFO(0, directory)
      99             : ZEND_END_ARG_INFO()
     100             : 
     101             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_chmod, 0)
     102             :         ZEND_ARG_INFO(0, ftp)
     103             :         ZEND_ARG_INFO(0, mode)
     104             :         ZEND_ARG_INFO(0, filename)
     105             : ZEND_END_ARG_INFO()
     106             : 
     107             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_alloc, 0, 0, 2)
     108             :         ZEND_ARG_INFO(0, ftp)
     109             :         ZEND_ARG_INFO(0, size)
     110             :         ZEND_ARG_INFO(1, response)
     111             : ZEND_END_ARG_INFO()
     112             : 
     113             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_nlist, 0)
     114             :         ZEND_ARG_INFO(0, ftp)
     115             :         ZEND_ARG_INFO(0, directory)
     116             : ZEND_END_ARG_INFO()
     117             : 
     118             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_rawlist, 0, 0, 2)
     119             :         ZEND_ARG_INFO(0, ftp)
     120             :         ZEND_ARG_INFO(0, directory)
     121             :         ZEND_ARG_INFO(0, recursive)
     122             : ZEND_END_ARG_INFO()
     123             : 
     124             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_systype, 0)
     125             :         ZEND_ARG_INFO(0, ftp)
     126             : ZEND_END_ARG_INFO()
     127             : 
     128             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_fget, 0, 0, 4)
     129             :         ZEND_ARG_INFO(0, ftp)
     130             :         ZEND_ARG_INFO(0, fp)
     131             :         ZEND_ARG_INFO(0, remote_file)
     132             :         ZEND_ARG_INFO(0, mode)
     133             :         ZEND_ARG_INFO(0, resumepos)
     134             : ZEND_END_ARG_INFO()
     135             : 
     136             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_nb_fget, 0, 0, 4)
     137             :         ZEND_ARG_INFO(0, ftp)
     138             :         ZEND_ARG_INFO(0, fp)
     139             :         ZEND_ARG_INFO(0, remote_file)
     140             :         ZEND_ARG_INFO(0, mode)
     141             :         ZEND_ARG_INFO(0, resumepos)
     142             : ZEND_END_ARG_INFO()
     143             : 
     144             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_pasv, 0)
     145             :         ZEND_ARG_INFO(0, ftp)
     146             :         ZEND_ARG_INFO(0, pasv)
     147             : ZEND_END_ARG_INFO()
     148             : 
     149             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_get, 0, 0, 4)
     150             :         ZEND_ARG_INFO(0, ftp)
     151             :         ZEND_ARG_INFO(0, local_file)
     152             :         ZEND_ARG_INFO(0, remote_file)
     153             :         ZEND_ARG_INFO(0, mode)
     154             :         ZEND_ARG_INFO(0, resume_pos)
     155             : ZEND_END_ARG_INFO()
     156             : 
     157             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_nb_get, 0, 0, 4)
     158             :         ZEND_ARG_INFO(0, ftp)
     159             :         ZEND_ARG_INFO(0, local_file)
     160             :         ZEND_ARG_INFO(0, remote_file)
     161             :         ZEND_ARG_INFO(0, mode)
     162             :         ZEND_ARG_INFO(0, resume_pos)
     163             : ZEND_END_ARG_INFO()
     164             : 
     165             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_nb_continue, 0)
     166             :         ZEND_ARG_INFO(0, ftp)
     167             : ZEND_END_ARG_INFO()
     168             : 
     169             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_fput, 0, 0, 4)
     170             :         ZEND_ARG_INFO(0, ftp)
     171             :         ZEND_ARG_INFO(0, remote_file)
     172             :         ZEND_ARG_INFO(0, fp)
     173             :         ZEND_ARG_INFO(0, mode)
     174             :         ZEND_ARG_INFO(0, startpos)
     175             : ZEND_END_ARG_INFO()
     176             : 
     177             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_nb_fput, 0, 0, 4)
     178             :         ZEND_ARG_INFO(0, ftp)
     179             :         ZEND_ARG_INFO(0, remote_file)
     180             :         ZEND_ARG_INFO(0, fp)
     181             :         ZEND_ARG_INFO(0, mode)
     182             :         ZEND_ARG_INFO(0, startpos)
     183             : ZEND_END_ARG_INFO()
     184             : 
     185             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_put, 0, 0, 4)
     186             :         ZEND_ARG_INFO(0, ftp)
     187             :         ZEND_ARG_INFO(0, remote_file)
     188             :         ZEND_ARG_INFO(0, local_file)
     189             :         ZEND_ARG_INFO(0, mode)
     190             :         ZEND_ARG_INFO(0, startpos)
     191             : ZEND_END_ARG_INFO()
     192             : 
     193             : ZEND_BEGIN_ARG_INFO_EX(arginfo_ftp_nb_put, 0, 0, 4)
     194             :         ZEND_ARG_INFO(0, ftp)
     195             :         ZEND_ARG_INFO(0, remote_file)
     196             :         ZEND_ARG_INFO(0, local_file)
     197             :         ZEND_ARG_INFO(0, mode)
     198             :         ZEND_ARG_INFO(0, startpos)
     199             : ZEND_END_ARG_INFO()
     200             : 
     201             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_size, 0)
     202             :         ZEND_ARG_INFO(0, ftp)
     203             :         ZEND_ARG_INFO(0, filename)
     204             : ZEND_END_ARG_INFO()
     205             : 
     206             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_mdtm, 0)
     207             :         ZEND_ARG_INFO(0, ftp)
     208             :         ZEND_ARG_INFO(0, filename)
     209             : ZEND_END_ARG_INFO()
     210             : 
     211             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_rename, 0)
     212             :         ZEND_ARG_INFO(0, ftp)
     213             :         ZEND_ARG_INFO(0, src)
     214             :         ZEND_ARG_INFO(0, dest)
     215             : ZEND_END_ARG_INFO()
     216             : 
     217             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_delete, 0)
     218             :         ZEND_ARG_INFO(0, ftp)
     219             :         ZEND_ARG_INFO(0, file)
     220             : ZEND_END_ARG_INFO()
     221             : 
     222             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_site, 0)
     223             :         ZEND_ARG_INFO(0, ftp)
     224             :         ZEND_ARG_INFO(0, cmd)
     225             : ZEND_END_ARG_INFO()
     226             : 
     227             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_close, 0)
     228             :         ZEND_ARG_INFO(0, ftp)
     229             : ZEND_END_ARG_INFO()
     230             : 
     231             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_set_option, 0)
     232             :         ZEND_ARG_INFO(0, ftp)
     233             :         ZEND_ARG_INFO(0, option)
     234             :         ZEND_ARG_INFO(0, value)
     235             : ZEND_END_ARG_INFO()
     236             : 
     237             : ZEND_BEGIN_ARG_INFO(arginfo_ftp_get_option, 0)
     238             :         ZEND_ARG_INFO(0, ftp)
     239             :         ZEND_ARG_INFO(0, option)
     240             : ZEND_END_ARG_INFO()
     241             : 
     242             : /* }}} */
     243             : 
     244             : const zend_function_entry php_ftp_functions[] = {
     245             :         PHP_FE(ftp_connect,                     arginfo_ftp_connect)
     246             : #ifdef HAVE_FTP_SSL
     247             :         PHP_FE(ftp_ssl_connect,         arginfo_ftp_ssl_connect)
     248             : #endif
     249             :         PHP_FE(ftp_login,                       arginfo_ftp_login)
     250             :         PHP_FE(ftp_pwd,                         arginfo_ftp_pwd)
     251             :         PHP_FE(ftp_cdup,                        arginfo_ftp_cdup)
     252             :         PHP_FE(ftp_chdir,                       arginfo_ftp_chdir)
     253             :         PHP_FE(ftp_exec,                        arginfo_ftp_exec)
     254             :         PHP_FE(ftp_raw,                         arginfo_ftp_raw)
     255             :         PHP_FE(ftp_mkdir,                       arginfo_ftp_mkdir)
     256             :         PHP_FE(ftp_rmdir,                       arginfo_ftp_rmdir)
     257             :         PHP_FE(ftp_chmod,                       arginfo_ftp_chmod)
     258             :         PHP_FE(ftp_alloc,                       arginfo_ftp_alloc)
     259             :         PHP_FE(ftp_nlist,                       arginfo_ftp_nlist)
     260             :         PHP_FE(ftp_rawlist,                     arginfo_ftp_rawlist)
     261             :         PHP_FE(ftp_systype,                     arginfo_ftp_systype)
     262             :         PHP_FE(ftp_pasv,                        arginfo_ftp_pasv)
     263             :         PHP_FE(ftp_get,                         arginfo_ftp_get)
     264             :         PHP_FE(ftp_fget,                        arginfo_ftp_fget)
     265             :         PHP_FE(ftp_put,                         arginfo_ftp_put)
     266             :         PHP_FE(ftp_fput,                        arginfo_ftp_fput)
     267             :         PHP_FE(ftp_size,                        arginfo_ftp_size)
     268             :         PHP_FE(ftp_mdtm,                        arginfo_ftp_mdtm)
     269             :         PHP_FE(ftp_rename,                      arginfo_ftp_rename)
     270             :         PHP_FE(ftp_delete,                      arginfo_ftp_delete)
     271             :         PHP_FE(ftp_site,                        arginfo_ftp_site)
     272             :         PHP_FE(ftp_close,                       arginfo_ftp_close)
     273             :         PHP_FE(ftp_set_option,          arginfo_ftp_set_option)
     274             :         PHP_FE(ftp_get_option,          arginfo_ftp_get_option)
     275             :         PHP_FE(ftp_nb_fget,                     arginfo_ftp_nb_fget)
     276             :         PHP_FE(ftp_nb_get,                      arginfo_ftp_nb_get)
     277             :         PHP_FE(ftp_nb_continue,         arginfo_ftp_nb_continue)
     278             :         PHP_FE(ftp_nb_put,                      arginfo_ftp_nb_put)
     279             :         PHP_FE(ftp_nb_fput,                     arginfo_ftp_nb_fput)
     280             :         PHP_FALIAS(ftp_quit, ftp_close, arginfo_ftp_close)
     281             :         PHP_FE_END
     282             : };
     283             : 
     284             : zend_module_entry php_ftp_module_entry = {
     285             :         STANDARD_MODULE_HEADER_EX,
     286             :         NULL,
     287             :         NULL,
     288             :         "ftp",
     289             :         php_ftp_functions,
     290             :         PHP_MINIT(ftp),
     291             :         NULL,
     292             :         NULL,
     293             :         NULL,
     294             :         PHP_MINFO(ftp),
     295             :         PHP_FTP_VERSION,
     296             :         STANDARD_MODULE_PROPERTIES
     297             : };
     298             : 
     299             : #if COMPILE_DL_FTP
     300             : ZEND_GET_MODULE(php_ftp)
     301             : #endif
     302             : 
     303          31 : static void ftp_destructor_ftpbuf(zend_resource *rsrc)
     304             : {
     305          31 :         ftpbuf_t *ftp = (ftpbuf_t *)rsrc->ptr;
     306             : 
     307          31 :         ftp_close(ftp);
     308          31 : }
     309             : 
     310       21291 : PHP_MINIT_FUNCTION(ftp)
     311             : {
     312             : #ifdef HAVE_FTP_SSL
     313       21291 :         SSL_library_init();
     314       21291 :         OpenSSL_add_all_ciphers();
     315       21291 :         OpenSSL_add_all_digests();
     316       21291 :         OpenSSL_add_all_algorithms();
     317             : 
     318       21291 :         SSL_load_error_strings();
     319             : #endif
     320             : 
     321       21291 :         le_ftpbuf = zend_register_list_destructors_ex(ftp_destructor_ftpbuf, NULL, le_ftpbuf_name, module_number);
     322       21291 :         REGISTER_LONG_CONSTANT("FTP_ASCII",  FTPTYPE_ASCII, CONST_PERSISTENT | CONST_CS);
     323       21291 :         REGISTER_LONG_CONSTANT("FTP_TEXT",   FTPTYPE_ASCII, CONST_PERSISTENT | CONST_CS);
     324       21291 :         REGISTER_LONG_CONSTANT("FTP_BINARY", FTPTYPE_IMAGE, CONST_PERSISTENT | CONST_CS);
     325       21291 :         REGISTER_LONG_CONSTANT("FTP_IMAGE",  FTPTYPE_IMAGE, CONST_PERSISTENT | CONST_CS);
     326       21291 :         REGISTER_LONG_CONSTANT("FTP_AUTORESUME", PHP_FTP_AUTORESUME, CONST_PERSISTENT | CONST_CS);
     327       21291 :         REGISTER_LONG_CONSTANT("FTP_TIMEOUT_SEC", PHP_FTP_OPT_TIMEOUT_SEC, CONST_PERSISTENT | CONST_CS);
     328       21291 :         REGISTER_LONG_CONSTANT("FTP_AUTOSEEK", PHP_FTP_OPT_AUTOSEEK, CONST_PERSISTENT | CONST_CS);
     329       21291 :         REGISTER_LONG_CONSTANT("FTP_FAILED", PHP_FTP_FAILED, CONST_PERSISTENT | CONST_CS);
     330       21291 :         REGISTER_LONG_CONSTANT("FTP_FINISHED", PHP_FTP_FINISHED, CONST_PERSISTENT | CONST_CS);
     331       21291 :         REGISTER_LONG_CONSTANT("FTP_MOREDATA", PHP_FTP_MOREDATA, CONST_PERSISTENT | CONST_CS);
     332       21291 :         return SUCCESS;
     333             : }
     334             : 
     335         142 : PHP_MINFO_FUNCTION(ftp)
     336             : {
     337         142 :         php_info_print_table_start();
     338         142 :         php_info_print_table_row(2, "FTP support", "enabled");
     339             : #ifdef HAVE_FTP_SSL
     340         142 :         php_info_print_table_row(2, "FTPS support", "enabled");
     341             : #else
     342             :         php_info_print_table_row(2, "FTPS support", "disabled");
     343             : #endif
     344         142 :         php_info_print_table_end();
     345         142 : }
     346             : 
     347             : #define XTYPE(xtype, mode)      { \
     348             :                                                                 if (mode != FTPTYPE_ASCII && mode != FTPTYPE_IMAGE) { \
     349             :                                                                         php_error_docref(NULL, E_WARNING, "Mode must be FTP_ASCII or FTP_BINARY"); \
     350             :                                                                         RETURN_FALSE; \
     351             :                                                                 } \
     352             :                                                                 xtype = mode; \
     353             :                                                         }
     354             : 
     355             : 
     356             : /* {{{ proto resource ftp_connect(string host [, int port [, int timeout]])
     357             :    Opens a FTP stream */
     358          32 : PHP_FUNCTION(ftp_connect)
     359             : {
     360             :         ftpbuf_t        *ftp;
     361             :         char            *host;
     362             :         size_t          host_len;
     363          32 :         zend_long               port = 0;
     364          32 :         zend_long               timeout_sec = FTP_DEFAULT_TIMEOUT;
     365             : 
     366          32 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|ll", &host, &host_len, &port, &timeout_sec) == FAILURE) {
     367           1 :                 return;
     368             :         }
     369             : 
     370          31 :         if (timeout_sec <= 0) {
     371           1 :                 php_error_docref(NULL, E_WARNING, "Timeout has to be greater than 0");
     372           1 :                 RETURN_FALSE;
     373             :         }
     374             : 
     375             :         /* connect */
     376          30 :         if (!(ftp = ftp_open(host, (short)port, timeout_sec))) {
     377           1 :                 RETURN_FALSE;
     378             :         }
     379             : 
     380             :         /* autoseek for resuming */
     381          29 :         ftp->autoseek = FTP_DEFAULT_AUTOSEEK;
     382             : #ifdef HAVE_FTP_SSL
     383             :         /* disable ssl */
     384          29 :         ftp->use_ssl = 0;
     385             : #endif
     386             : 
     387          29 :         RETURN_RES(zend_register_resource(ftp, le_ftpbuf));
     388             : }
     389             : /* }}} */
     390             : 
     391             : #ifdef HAVE_FTP_SSL
     392             : /* {{{ proto resource ftp_ssl_connect(string host [, int port [, int timeout]])
     393             :    Opens a FTP-SSL stream */
     394           2 : PHP_FUNCTION(ftp_ssl_connect)
     395             : {
     396             :         ftpbuf_t        *ftp;
     397             :         char            *host;
     398             :         size_t          host_len;
     399           2 :         zend_long               port = 0;
     400           2 :         zend_long               timeout_sec = FTP_DEFAULT_TIMEOUT;
     401             : 
     402           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|ll", &host, &host_len, &port, &timeout_sec) == FAILURE) {
     403           0 :                 return;
     404             :         }
     405             : 
     406           2 :         if (timeout_sec <= 0) {
     407           0 :                 php_error_docref(NULL, E_WARNING, "Timeout has to be greater than 0");
     408           0 :                 RETURN_FALSE;
     409             :         }
     410             : 
     411             :         /* connect */
     412           2 :         if (!(ftp = ftp_open(host, (short)port, timeout_sec))) {
     413           0 :                 RETURN_FALSE;
     414             :         }
     415             : 
     416             :         /* autoseek for resuming */
     417           2 :         ftp->autoseek = FTP_DEFAULT_AUTOSEEK;
     418             :         /* enable ssl */
     419           2 :         ftp->use_ssl = 1;
     420             : 
     421           2 :         RETURN_RES(zend_register_resource(ftp, le_ftpbuf));
     422             : }
     423             : /* }}} */
     424             : #endif
     425             : 
     426             : /* {{{ proto bool ftp_login(resource stream, string username, string password)
     427             :    Logs into the FTP server */
     428          33 : PHP_FUNCTION(ftp_login)
     429             : {
     430             :         zval            *z_ftp;
     431             :         ftpbuf_t        *ftp;
     432             :         char *user, *pass;
     433             :         size_t user_len, pass_len;
     434             : 
     435          33 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rss", &z_ftp, &user, &user_len, &pass, &pass_len) == FAILURE) {
     436           1 :                 return;
     437             :         }
     438             : 
     439          32 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     440           0 :                 RETURN_FALSE;
     441             :         }
     442             : 
     443             :         /* log in */
     444          32 :         if (!ftp_login(ftp, user, pass)) {
     445           2 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     446           2 :                 RETURN_FALSE;
     447             :         }
     448             : 
     449          30 :         RETURN_TRUE;
     450             : }
     451             : /* }}} */
     452             : 
     453             : /* {{{ proto string ftp_pwd(resource stream)
     454             :    Returns the present working directory */
     455           7 : PHP_FUNCTION(ftp_pwd)
     456             : {
     457             :         zval            *z_ftp;
     458             :         ftpbuf_t        *ftp;
     459             :         const char      *pwd;
     460             : 
     461           7 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &z_ftp) == FAILURE) {
     462           1 :                 return;
     463             :         }
     464             : 
     465           6 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     466           0 :                 RETURN_FALSE;
     467             :         }
     468             : 
     469           6 :         if (!(pwd = ftp_pwd(ftp))) {
     470           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     471           1 :                 RETURN_FALSE;
     472             :         }
     473             : 
     474          10 :         RETURN_STRING((char*) pwd);
     475             : }
     476             : /* }}} */
     477             : 
     478             : /* {{{ proto bool ftp_cdup(resource stream)
     479             :    Changes to the parent directory */
     480           3 : PHP_FUNCTION(ftp_cdup)
     481             : {
     482             :         zval            *z_ftp;
     483             :         ftpbuf_t        *ftp;
     484             : 
     485           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &z_ftp) == FAILURE) {
     486           1 :                 return;
     487             :         }
     488             : 
     489           2 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     490           0 :                 RETURN_FALSE;
     491             :         }
     492             : 
     493           2 :         if (!ftp_cdup(ftp)) {
     494           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     495           1 :                 RETURN_FALSE;
     496             :         }
     497             : 
     498           1 :         RETURN_TRUE;
     499             : }
     500             : /* }}} */
     501             : 
     502             : /* {{{ proto bool ftp_chdir(resource stream, string directory)
     503             :    Changes directories */
     504           5 : PHP_FUNCTION(ftp_chdir)
     505             : {
     506             :         zval            *z_ftp;
     507             :         ftpbuf_t        *ftp;
     508             :         char            *dir;
     509             :         size_t                  dir_len;
     510             : 
     511           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &z_ftp, &dir, &dir_len) == FAILURE) {
     512           1 :                 return;
     513             :         }
     514             : 
     515           4 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     516           0 :                 RETURN_FALSE;
     517             :         }
     518             : 
     519             :         /* change directories */
     520           4 :         if (!ftp_chdir(ftp, dir)) {
     521           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     522           1 :                 RETURN_FALSE;
     523             :         }
     524             : 
     525           3 :         RETURN_TRUE;
     526             : }
     527             : /* }}} */
     528             : 
     529             : /* {{{ proto bool ftp_exec(resource stream, string command)
     530             :    Requests execution of a program on the FTP server */
     531           3 : PHP_FUNCTION(ftp_exec)
     532             : {
     533             :         zval            *z_ftp;
     534             :         ftpbuf_t        *ftp;
     535             :         char            *cmd;
     536             :         size_t                  cmd_len;
     537             : 
     538           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &z_ftp, &cmd, &cmd_len) == FAILURE) {
     539           1 :                 return;
     540             :         }
     541             : 
     542           2 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     543           0 :                 RETURN_FALSE;
     544             :         }
     545             : 
     546             :         /* execute serverside command */
     547           2 :         if (!ftp_exec(ftp, cmd)) {
     548           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     549           1 :                 RETURN_FALSE;
     550             :         }
     551             : 
     552           1 :         RETURN_TRUE;
     553             : }
     554             : /* }}} */
     555             : 
     556             : /* {{{ proto array ftp_raw(resource stream, string command)
     557             :    Sends a literal command to the FTP server */
     558           5 : PHP_FUNCTION(ftp_raw)
     559             : {
     560             :         zval            *z_ftp;
     561             :         ftpbuf_t        *ftp;
     562             :         char            *cmd;
     563             :         size_t                  cmd_len;
     564             : 
     565           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &z_ftp, &cmd, &cmd_len) == FAILURE) {
     566           1 :                 return;
     567             :         }
     568             : 
     569           4 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     570           0 :                 RETURN_FALSE;
     571             :         }
     572             : 
     573             :         /* execute arbitrary ftp command */
     574           4 :         ftp_raw(ftp, cmd, return_value);
     575             : }
     576             : /* }}} */
     577             : 
     578             : /* {{{ proto string ftp_mkdir(resource stream, string directory)
     579             :    Creates a directory and returns the absolute path for the new directory or false on error */
     580           4 : PHP_FUNCTION(ftp_mkdir)
     581             : {
     582             :         zval            *z_ftp;
     583             :         ftpbuf_t        *ftp;
     584             :         char            *dir;
     585             :         zend_string *tmp;
     586             :         size_t          dir_len;
     587             : 
     588           4 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &z_ftp, &dir, &dir_len) == FAILURE) {
     589           1 :                 return;
     590             :         }
     591             : 
     592           3 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     593           0 :                 RETURN_FALSE;
     594             :         }
     595             : 
     596             :         /* create directorie */
     597           3 :         if (NULL == (tmp = ftp_mkdir(ftp, dir))) {
     598           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     599           1 :                 RETURN_FALSE;
     600             :         }
     601             : 
     602           2 :         RETURN_STR(tmp);
     603             : }
     604             : /* }}} */
     605             : 
     606             : /* {{{ proto bool ftp_rmdir(resource stream, string directory)
     607             :    Removes a directory */
     608           3 : PHP_FUNCTION(ftp_rmdir)
     609             : {
     610             :         zval            *z_ftp;
     611             :         ftpbuf_t        *ftp;
     612             :         char            *dir;
     613             :         size_t          dir_len;
     614             : 
     615           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &z_ftp, &dir, &dir_len) == FAILURE) {
     616           1 :                 return;
     617             :         }
     618             : 
     619           2 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     620           0 :                 RETURN_FALSE;
     621             :         }
     622             : 
     623             :         /* remove directorie */
     624           2 :         if (!ftp_rmdir(ftp, dir)) {
     625           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     626           1 :                 RETURN_FALSE;
     627             :         }
     628             : 
     629           1 :         RETURN_TRUE;
     630             : }
     631             : /* }}} */
     632             : 
     633             : /* {{{ proto int ftp_chmod(resource stream, int mode, string filename)
     634             :    Sets permissions on a file */
     635           3 : PHP_FUNCTION(ftp_chmod)
     636             : {
     637             :         zval            *z_ftp;
     638             :         ftpbuf_t        *ftp;
     639             :         char            *filename;
     640             :         size_t          filename_len;
     641             :         zend_long               mode;
     642             : 
     643           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rlp", &z_ftp, &mode, &filename, &filename_len) == FAILURE) {
     644           1 :                 RETURN_FALSE;
     645             :         }
     646             : 
     647           2 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     648           0 :                 RETURN_FALSE;
     649             :         }
     650             : 
     651           2 :         if (!ftp_chmod(ftp, mode, filename, filename_len)) {
     652           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     653           1 :                 RETURN_FALSE;
     654             :         }
     655             : 
     656           1 :         RETURN_LONG(mode);
     657             : }
     658             : /* }}} */
     659             : 
     660             : /* {{{ proto bool ftp_alloc(resource stream, int size[, &response])
     661             :    Attempt to allocate space on the remote FTP server */
     662           4 : PHP_FUNCTION(ftp_alloc)
     663             : {
     664           4 :         zval            *z_ftp, *zresponse = NULL;
     665             :         ftpbuf_t        *ftp;
     666             :         zend_long               size, ret;
     667           4 :         zend_string     *response = NULL;
     668             : 
     669           4 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl|z/", &z_ftp, &size, &zresponse) == FAILURE) {
     670           1 :                 RETURN_FALSE;
     671             :         }
     672             : 
     673           3 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     674           0 :                 RETURN_FALSE;
     675             :         }
     676             : 
     677           3 :         ret = ftp_alloc(ftp, size, zresponse ? &response : NULL);
     678           3 :         if (response) {
     679           1 :                 zval_dtor(zresponse);
     680           1 :                 ZVAL_STR(zresponse, response);
     681             :         }
     682             : 
     683           3 :         if (!ret) {
     684           1 :                 RETURN_FALSE;
     685             :         }
     686             : 
     687           2 :         RETURN_TRUE;
     688             : }
     689             : /* }}} */
     690             : 
     691             : /* {{{ proto array ftp_nlist(resource stream, string directory)
     692             :    Returns an array of filenames in the given directory */
     693           7 : PHP_FUNCTION(ftp_nlist)
     694             : {
     695             :         zval            *z_ftp;
     696             :         ftpbuf_t        *ftp;
     697             :         char            **nlist, **ptr, *dir;
     698             :         size_t          dir_len;
     699             : 
     700           7 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rp", &z_ftp, &dir, &dir_len) == FAILURE) {
     701           1 :                 return;
     702             :         }
     703             : 
     704           6 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     705           0 :                 RETURN_FALSE;
     706             :         }
     707             : 
     708             :         /* get list of files */
     709           6 :         if (NULL == (nlist = ftp_nlist(ftp, dir))) {
     710           2 :                 RETURN_FALSE;
     711             :         }
     712             : 
     713           4 :         array_init(return_value);
     714          10 :         for (ptr = nlist; *ptr; ptr++) {
     715           6 :                 add_next_index_string(return_value, *ptr);
     716             :         }
     717           4 :         efree(nlist);
     718             : }
     719             : /* }}} */
     720             : 
     721             : /* {{{ proto array ftp_rawlist(resource stream, string directory [, bool recursive])
     722             :    Returns a detailed listing of a directory as an array of output lines */
     723           2 : PHP_FUNCTION(ftp_rawlist)
     724             : {
     725             :         zval            *z_ftp;
     726             :         ftpbuf_t        *ftp;
     727             :         char            **llist, **ptr, *dir;
     728             :         size_t          dir_len;
     729           2 :         zend_bool       recursive = 0;
     730             : 
     731           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|b", &z_ftp, &dir, &dir_len, &recursive) == FAILURE) {
     732           1 :                 return;
     733             :         }
     734             : 
     735           1 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     736           0 :                 RETURN_FALSE;
     737             :         }
     738             : 
     739             :         /* get raw directory listing */
     740           1 :         if (NULL == (llist = ftp_list(ftp, dir, recursive))) {
     741           1 :                 RETURN_FALSE;
     742             :         }
     743             : 
     744           0 :         array_init(return_value);
     745           0 :         for (ptr = llist; *ptr; ptr++) {
     746           0 :                 add_next_index_string(return_value, *ptr);
     747             :         }
     748           0 :         efree(llist);
     749             : }
     750             : /* }}} */
     751             : 
     752             : /* {{{ proto string ftp_systype(resource stream)
     753             :    Returns the system type identifier */
     754           4 : PHP_FUNCTION(ftp_systype)
     755             : {
     756             :         zval            *z_ftp;
     757             :         ftpbuf_t        *ftp;
     758             :         const char      *syst;
     759             : 
     760           4 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &z_ftp) == FAILURE) {
     761           1 :                 return;
     762             :         }
     763             : 
     764           3 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     765           0 :                 RETURN_FALSE;
     766             :         }
     767             : 
     768           3 :         if (NULL == (syst = ftp_syst(ftp))) {
     769           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     770           1 :                 RETURN_FALSE;
     771             :         }
     772             : 
     773           4 :         RETURN_STRING((char*) syst);
     774             : }
     775             : /* }}} */
     776             : 
     777             : /* {{{ proto bool ftp_fget(resource stream, resource fp, string remote_file, int mode[, int resumepos])
     778             :    Retrieves a file from the FTP server and writes it to an open file */
     779           8 : PHP_FUNCTION(ftp_fget)
     780             : {
     781             :         zval            *z_ftp, *z_file;
     782             :         ftpbuf_t        *ftp;
     783             :         ftptype_t       xtype;
     784             :         php_stream      *stream;
     785             :         char            *file;
     786             :         size_t          file_len;
     787           8 :         zend_long               mode, resumepos=0;
     788             : 
     789           8 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rrsl|l", &z_ftp, &z_file, &file, &file_len, &mode, &resumepos) == FAILURE) {
     790           1 :                 return;
     791             :         }
     792             : 
     793           7 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     794           0 :                 RETURN_FALSE;
     795             :         }
     796           7 :         php_stream_from_res(stream, Z_RES_P(z_file));
     797           7 :         XTYPE(xtype, mode);
     798             : 
     799             :         /* ignore autoresume if autoseek is switched off */
     800           6 :         if (!ftp->autoseek && resumepos == PHP_FTP_AUTORESUME) {
     801           1 :                 resumepos = 0;
     802             :         }
     803             : 
     804           6 :         if (ftp->autoseek && resumepos) {
     805             :                 /* if autoresume is wanted seek to end */
     806           2 :                 if (resumepos == PHP_FTP_AUTORESUME) {
     807           1 :                         php_stream_seek(stream, 0, SEEK_END);
     808           1 :                         resumepos = php_stream_tell(stream);
     809             :                 } else {
     810           1 :                         php_stream_seek(stream, resumepos, SEEK_SET);
     811             :                 }
     812             :         }
     813             : 
     814           6 :         if (!ftp_get(ftp, stream, file, xtype, resumepos)) {
     815           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     816           1 :                 RETURN_FALSE;
     817             :         }
     818             : 
     819           5 :         RETURN_TRUE;
     820             : }
     821             : /* }}} */
     822             : 
     823             : /* {{{ proto int ftp_nb_fget(resource stream, resource fp, string remote_file, int mode[, int resumepos])
     824             :    Retrieves a file from the FTP server asynchronly and writes it to an open file */
     825           5 : PHP_FUNCTION(ftp_nb_fget)
     826             : {
     827             :         zval            *z_ftp, *z_file;
     828             :         ftpbuf_t        *ftp;
     829             :         ftptype_t       xtype;
     830             :         php_stream      *stream;
     831             :         char            *file;
     832             :         size_t          file_len;
     833           5 :         zend_long               mode, resumepos=0, ret;
     834             : 
     835           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rrsl|l", &z_ftp, &z_file, &file, &file_len, &mode, &resumepos) == FAILURE) {
     836           1 :                 return;
     837             :         }
     838             : 
     839           4 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     840           0 :                 RETURN_FALSE;
     841             :         }
     842           4 :         php_stream_from_res(stream, Z_RES_P(z_file));
     843           4 :         XTYPE(xtype, mode);
     844             : 
     845             :         /* ignore autoresume if autoseek is switched off */
     846           3 :         if (!ftp->autoseek && resumepos == PHP_FTP_AUTORESUME) {
     847           1 :                 resumepos = 0;
     848             :         }
     849             : 
     850           3 :         if (ftp->autoseek && resumepos) {
     851             :                 /* if autoresume is wanted seek to end */
     852           2 :                 if (resumepos == PHP_FTP_AUTORESUME) {
     853           1 :                         php_stream_seek(stream, 0, SEEK_END);
     854           1 :                         resumepos = php_stream_tell(stream);
     855             :                 } else {
     856           1 :                         php_stream_seek(stream, resumepos, SEEK_SET);
     857             :                 }
     858             :         }
     859             : 
     860             :         /* configuration */
     861           3 :         ftp->direction = 0;   /* recv */
     862           3 :         ftp->closestream = 0; /* do not close */
     863             : 
     864           3 :         if ((ret = ftp_nb_get(ftp, stream, file, xtype, resumepos)) == PHP_FTP_FAILED) {
     865           0 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     866           0 :                 RETURN_LONG(ret);
     867             :         }
     868             : 
     869           3 :         RETURN_LONG(ret);
     870             : }
     871             : /* }}} */
     872             : 
     873             : /* {{{ proto bool ftp_pasv(resource stream, bool pasv)
     874             :    Turns passive mode on or off */
     875           1 : PHP_FUNCTION(ftp_pasv)
     876             : {
     877             :         zval            *z_ftp;
     878             :         ftpbuf_t        *ftp;
     879             :         zend_bool       pasv;
     880             : 
     881           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rb", &z_ftp, &pasv) == FAILURE) {
     882           1 :                 return;
     883             :         }
     884             : 
     885           0 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     886           0 :                 RETURN_FALSE;
     887             :         }
     888             : 
     889           0 :         if (!ftp_pasv(ftp, pasv ? 1 : 0)) {
     890           0 :                 RETURN_FALSE;
     891             :         }
     892             : 
     893           0 :         RETURN_TRUE;
     894             : }
     895             : /* }}} */
     896             : 
     897             : /* {{{ proto bool ftp_get(resource stream, string local_file, string remote_file, int mode[, int resume_pos])
     898             :    Retrieves a file from the FTP server and writes it to a local file */
     899           5 : PHP_FUNCTION(ftp_get)
     900             : {
     901             :         zval            *z_ftp;
     902             :         ftpbuf_t        *ftp;
     903             :         ftptype_t       xtype;
     904             :         php_stream      *outstream;
     905             :         char            *local, *remote;
     906             :         size_t          local_len, remote_len;
     907           5 :         zend_long               mode, resumepos=0;
     908             : 
     909           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rppl|l", &z_ftp, &local, &local_len, &remote, &remote_len, &mode, &resumepos) == FAILURE) {
     910           1 :                 return;
     911             :         }
     912             : 
     913           4 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     914           0 :                 RETURN_FALSE;
     915             :         }
     916           4 :         XTYPE(xtype, mode);
     917             : 
     918             :         /* ignore autoresume if autoseek is switched off */
     919           3 :         if (!ftp->autoseek && resumepos == PHP_FTP_AUTORESUME) {
     920           0 :                 resumepos = 0;
     921             :         }
     922             : 
     923             : #ifdef PHP_WIN32
     924             :         mode = FTPTYPE_IMAGE;
     925             : #endif
     926             : 
     927           3 :         if (ftp->autoseek && resumepos) {
     928           0 :                 outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "rt+" : "rb+", REPORT_ERRORS, NULL);
     929           0 :                 if (outstream == NULL) {
     930           0 :                         outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "wt" : "wb", REPORT_ERRORS, NULL);
     931             :                 }
     932           0 :                 if (outstream != NULL) {
     933             :                         /* if autoresume is wanted seek to end */
     934           0 :                         if (resumepos == PHP_FTP_AUTORESUME) {
     935           0 :                                 php_stream_seek(outstream, 0, SEEK_END);
     936           0 :                                 resumepos = php_stream_tell(outstream);
     937             :                         } else {
     938           0 :                                 php_stream_seek(outstream, resumepos, SEEK_SET);
     939             :                         }
     940             :                 }
     941             :         } else {
     942           3 :                 outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "wt" : "wb", REPORT_ERRORS, NULL);
     943             :         }
     944             : 
     945           3 :         if (outstream == NULL)  {
     946           0 :                 php_error_docref(NULL, E_WARNING, "Error opening %s", local);
     947           0 :                 RETURN_FALSE;
     948             :         }
     949             : 
     950           3 :         if (!ftp_get(ftp, outstream, remote, xtype, resumepos)) {
     951           1 :                 php_stream_close(outstream);
     952           1 :                 VCWD_UNLINK(local);
     953           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
     954           1 :                 RETURN_FALSE;
     955             :         }
     956             : 
     957           2 :         php_stream_close(outstream);
     958           2 :         RETURN_TRUE;
     959             : }
     960             : /* }}} */
     961             : 
     962             : /* {{{ proto int ftp_nb_get(resource stream, string local_file, string remote_file, int mode[, int resume_pos])
     963             :    Retrieves a file from the FTP server nbhronly and writes it to a local file */
     964           3 : PHP_FUNCTION(ftp_nb_get)
     965             : {
     966             :         zval            *z_ftp;
     967             :         ftpbuf_t        *ftp;
     968             :         ftptype_t       xtype;
     969             :         php_stream      *outstream;
     970             :         char            *local, *remote;
     971             :         size_t          local_len, remote_len;
     972             :         int ret;
     973           3 :         zend_long               mode, resumepos=0;
     974             : 
     975           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rssl|l", &z_ftp, &local, &local_len, &remote, &remote_len, &mode, &resumepos) == FAILURE) {
     976           1 :                 return;
     977             :         }
     978             : 
     979           2 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
     980           0 :                 RETURN_FALSE;
     981             :         }
     982           2 :         XTYPE(xtype, mode);
     983             : 
     984             :         /* ignore autoresume if autoseek is switched off */
     985           2 :         if (!ftp->autoseek && resumepos == PHP_FTP_AUTORESUME) {
     986           0 :                 resumepos = 0;
     987             :         }
     988             : #ifdef PHP_WIN32
     989             :         mode = FTPTYPE_IMAGE;
     990             : #endif
     991           3 :         if (ftp->autoseek && resumepos) {
     992           1 :                 outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "rt+" : "rb+", REPORT_ERRORS, NULL);
     993           1 :                 if (outstream == NULL) {
     994           0 :                         outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "wt" : "wb", REPORT_ERRORS, NULL);
     995             :                 }
     996           1 :                 if (outstream != NULL) {
     997             :                         /* if autoresume is wanted seek to end */
     998           1 :                         if (resumepos == PHP_FTP_AUTORESUME) {
     999           0 :                                 php_stream_seek(outstream, 0, SEEK_END);
    1000           0 :                                 resumepos = php_stream_tell(outstream);
    1001             :                         } else {
    1002           1 :                                 php_stream_seek(outstream, resumepos, SEEK_SET);
    1003             :                         }
    1004             :                 }
    1005             :         } else {
    1006           1 :                 outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "wt" : "wb", REPORT_ERRORS, NULL);
    1007             :         }
    1008             : 
    1009           2 :         if (outstream == NULL)  {
    1010           0 :                 php_error_docref(NULL, E_WARNING, "Error opening %s", local);
    1011           0 :                 RETURN_FALSE;
    1012             :         }
    1013             : 
    1014             :         /* configuration */
    1015           2 :         ftp->direction = 0;   /* recv */
    1016           2 :         ftp->closestream = 1; /* do close */
    1017             : 
    1018           2 :         if ((ret = ftp_nb_get(ftp, outstream, remote, xtype, resumepos)) == PHP_FTP_FAILED) {
    1019           0 :                 php_stream_close(outstream);
    1020           0 :                 ftp->stream = NULL;
    1021           0 :                 VCWD_UNLINK(local);
    1022           0 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
    1023           0 :                 RETURN_LONG(PHP_FTP_FAILED);
    1024             :         }
    1025             : 
    1026           2 :         if (ret == PHP_FTP_FINISHED){
    1027           0 :                 php_stream_close(outstream);
    1028           0 :                 ftp->stream = NULL;
    1029             :         }
    1030             : 
    1031           2 :         RETURN_LONG(ret);
    1032             : }
    1033             : /* }}} */
    1034             : 
    1035             : /* {{{ proto int ftp_nb_continue(resource stream)
    1036             :    Continues retrieving/sending a file nbronously */
    1037           7 : PHP_FUNCTION(ftp_nb_continue)
    1038             : {
    1039             :         zval            *z_ftp;
    1040             :         ftpbuf_t        *ftp;
    1041             :         zend_long               ret;
    1042             : 
    1043           7 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &z_ftp) == FAILURE) {
    1044           1 :                 return;
    1045             :         }
    1046             : 
    1047           6 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1048           0 :                 RETURN_FALSE;
    1049             :         }
    1050             : 
    1051           6 :         if (!ftp->nb) {
    1052           1 :                 php_error_docref(NULL, E_WARNING, "no nbronous transfer to continue.");
    1053           1 :                 RETURN_LONG(PHP_FTP_FAILED);
    1054             :         }
    1055             : 
    1056           5 :         if (ftp->direction) {
    1057           0 :                 ret=ftp_nb_continue_write(ftp);
    1058             :         } else {
    1059           5 :                 ret=ftp_nb_continue_read(ftp);
    1060             :         }
    1061             : 
    1062           5 :         if (ret != PHP_FTP_MOREDATA && ftp->closestream) {
    1063           1 :                 php_stream_close(ftp->stream);
    1064           1 :                 ftp->stream = NULL;
    1065             :         }
    1066             : 
    1067           5 :         if (ret == PHP_FTP_FAILED) {
    1068           0 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
    1069             :         }
    1070             : 
    1071           5 :         RETURN_LONG(ret);
    1072             : }
    1073             : /* }}} */
    1074             : 
    1075             : /* {{{ proto bool ftp_fput(resource stream, string remote_file, resource fp, int mode[, int startpos])
    1076             :    Stores a file from an open file to the FTP server */
    1077           2 : PHP_FUNCTION(ftp_fput)
    1078             : {
    1079             :         zval            *z_ftp, *z_file;
    1080             :         ftpbuf_t        *ftp;
    1081             :         ftptype_t       xtype;
    1082             :         size_t          remote_len;
    1083           2 :         zend_long               mode, startpos=0;
    1084             :         php_stream      *stream;
    1085             :         char            *remote;
    1086             : 
    1087           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsrl|l", &z_ftp, &remote, &remote_len, &z_file, &mode, &startpos) == FAILURE) {
    1088           1 :                 return;
    1089             :         }
    1090             : 
    1091           1 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1092           0 :                 RETURN_FALSE;
    1093             :         }
    1094           1 :         php_stream_from_zval(stream, z_file);
    1095           1 :         XTYPE(xtype, mode);
    1096             : 
    1097             :         /* ignore autoresume if autoseek is switched off */
    1098           0 :         if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
    1099           0 :                 startpos = 0;
    1100             :         }
    1101             : 
    1102           0 :         if (ftp->autoseek && startpos) {
    1103             :                 /* if autoresume is wanted ask for remote size */
    1104           0 :                 if (startpos == PHP_FTP_AUTORESUME) {
    1105           0 :                         startpos = ftp_size(ftp, remote);
    1106           0 :                         if (startpos < 0) {
    1107           0 :                                 startpos = 0;
    1108             :                         }
    1109             :                 }
    1110           0 :                 if (startpos) {
    1111           0 :                         php_stream_seek(stream, startpos, SEEK_SET);
    1112             :                 }
    1113             :         }
    1114             : 
    1115           0 :         if (!ftp_put(ftp, remote, stream, xtype, startpos)) {
    1116           0 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
    1117           0 :                 RETURN_FALSE;
    1118             :         }
    1119             : 
    1120           0 :         RETURN_TRUE;
    1121             : }
    1122             : /* }}} */
    1123             : 
    1124             : /* {{{ proto int ftp_nb_fput(resource stream, string remote_file, resource fp, int mode[, int startpos])
    1125             :    Stores a file from an open file to the FTP server nbronly */
    1126           2 : PHP_FUNCTION(ftp_nb_fput)
    1127             : {
    1128             :         zval            *z_ftp, *z_file;
    1129             :         ftpbuf_t        *ftp;
    1130             :         ftptype_t       xtype;
    1131             :         size_t          remote_len;
    1132             :         int             ret;
    1133           2 :         zend_long       mode, startpos=0;
    1134             :         php_stream      *stream;
    1135             :         char            *remote;
    1136             : 
    1137           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsrl|l", &z_ftp, &remote, &remote_len, &z_file, &mode, &startpos) == FAILURE) {
    1138           1 :                 return;
    1139             :         }
    1140             : 
    1141           1 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1142           0 :                 RETURN_FALSE;
    1143             :         }
    1144           1 :         php_stream_from_res(stream, Z_RES_P(z_file));
    1145           1 :         XTYPE(xtype, mode);
    1146             : 
    1147             :         /* ignore autoresume if autoseek is switched off */
    1148           0 :         if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
    1149           0 :                 startpos = 0;
    1150             :         }
    1151             : 
    1152           0 :         if (ftp->autoseek && startpos) {
    1153             :                 /* if autoresume is wanted ask for remote size */
    1154           0 :                 if (startpos == PHP_FTP_AUTORESUME) {
    1155           0 :                         startpos = ftp_size(ftp, remote);
    1156           0 :                         if (startpos < 0) {
    1157           0 :                                 startpos = 0;
    1158             :                         }
    1159             :                 }
    1160           0 :                 if (startpos) {
    1161           0 :                         php_stream_seek(stream, startpos, SEEK_SET);
    1162             :                 }
    1163             :         }
    1164             : 
    1165             :         /* configuration */
    1166           0 :         ftp->direction = 1;   /* send */
    1167           0 :         ftp->closestream = 0; /* do not close */
    1168             : 
    1169           0 :         if (((ret = ftp_nb_put(ftp, remote, stream, xtype, startpos)) == PHP_FTP_FAILED)) {
    1170           0 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
    1171           0 :                 RETURN_LONG(ret);
    1172             :         }
    1173             : 
    1174           0 :         RETURN_LONG(ret);
    1175             : }
    1176             : /* }}} */
    1177             : 
    1178             : 
    1179             : /* {{{ proto bool ftp_put(resource stream, string remote_file, string local_file, int mode[, int startpos])
    1180             :    Stores a file on the FTP server */
    1181           3 : PHP_FUNCTION(ftp_put)
    1182             : {
    1183             :         zval            *z_ftp;
    1184             :         ftpbuf_t        *ftp;
    1185             :         ftptype_t       xtype;
    1186             :         char            *remote, *local;
    1187             :         size_t          remote_len, local_len;
    1188           3 :         zend_long               mode, startpos=0;
    1189             :         php_stream      *instream;
    1190             : 
    1191           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rppl|l", &z_ftp, &remote, &remote_len, &local, &local_len, &mode, &startpos) == FAILURE) {
    1192           1 :                 return;
    1193             :         }
    1194             : 
    1195           2 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1196           0 :                 RETURN_FALSE;
    1197             :         }
    1198           2 :         XTYPE(xtype, mode);
    1199             : 
    1200           2 :         if (!(instream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "rt" : "rb", REPORT_ERRORS, NULL))) {
    1201           0 :                 RETURN_FALSE;
    1202             :         }
    1203             : 
    1204             :         /* ignore autoresume if autoseek is switched off */
    1205           2 :         if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
    1206           0 :                 startpos = 0;
    1207             :         }
    1208             : 
    1209           2 :         if (ftp->autoseek && startpos) {
    1210             :                 /* if autoresume is wanted ask for remote size */
    1211           0 :                 if (startpos == PHP_FTP_AUTORESUME) {
    1212           0 :                         startpos = ftp_size(ftp, remote);
    1213           0 :                         if (startpos < 0) {
    1214           0 :                                 startpos = 0;
    1215             :                         }
    1216             :                 }
    1217           0 :                 if (startpos) {
    1218           0 :                         php_stream_seek(instream, startpos, SEEK_SET);
    1219             :                 }
    1220             :         }
    1221             : 
    1222           2 :         if (!ftp_put(ftp, remote, instream, xtype, startpos)) {
    1223           0 :                 php_stream_close(instream);
    1224           0 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
    1225           0 :                 RETURN_FALSE;
    1226             :         }
    1227           2 :         php_stream_close(instream);
    1228             : 
    1229           2 :         RETURN_TRUE;
    1230             : }
    1231             : /* }}} */
    1232             : 
    1233             : 
    1234             : /* {{{ proto int ftp_nb_put(resource stream, string remote_file, string local_file, int mode[, int startpos])
    1235             :    Stores a file on the FTP server */
    1236           1 : PHP_FUNCTION(ftp_nb_put)
    1237             : {
    1238             :         zval            *z_ftp;
    1239             :         ftpbuf_t        *ftp;
    1240             :         ftptype_t       xtype;
    1241             :         char            *remote, *local;
    1242             :         size_t          remote_len, local_len;
    1243           1 :         zend_long               mode, startpos=0, ret;
    1244             :         php_stream      *instream;
    1245             : 
    1246           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rppl|l", &z_ftp, &remote, &remote_len, &local, &local_len, &mode, &startpos) == FAILURE) {
    1247           1 :                 return;
    1248             :         }
    1249             : 
    1250           0 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1251           0 :                 RETURN_FALSE;
    1252             :         }
    1253           0 :         XTYPE(xtype, mode);
    1254             : 
    1255           0 :         if (!(instream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "rt" : "rb", REPORT_ERRORS, NULL))) {
    1256           0 :                 RETURN_FALSE;
    1257             :         }
    1258             : 
    1259             :         /* ignore autoresume if autoseek is switched off */
    1260           0 :         if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
    1261           0 :                 startpos = 0;
    1262             :         }
    1263             : 
    1264           0 :         if (ftp->autoseek && startpos) {
    1265             :                 /* if autoresume is wanted ask for remote size */
    1266           0 :                 if (startpos == PHP_FTP_AUTORESUME) {
    1267           0 :                         startpos = ftp_size(ftp, remote);
    1268           0 :                         if (startpos < 0) {
    1269           0 :                                 startpos = 0;
    1270             :                         }
    1271             :                 }
    1272           0 :                 if (startpos) {
    1273           0 :                         php_stream_seek(instream, startpos, SEEK_SET);
    1274             :                 }
    1275             :         }
    1276             : 
    1277             :         /* configuration */
    1278           0 :         ftp->direction = 1;   /* send */
    1279           0 :         ftp->closestream = 1; /* do close */
    1280             : 
    1281           0 :         ret = ftp_nb_put(ftp, remote, instream, xtype, startpos);
    1282             : 
    1283           0 :         if (ret != PHP_FTP_MOREDATA) {
    1284           0 :                 php_stream_close(instream);
    1285           0 :                 ftp->stream = NULL;
    1286             :         }
    1287             : 
    1288           0 :         if (ret == PHP_FTP_FAILED) {
    1289           0 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
    1290             :         }
    1291             : 
    1292           0 :         RETURN_LONG(ret);
    1293             : }
    1294             : /* }}} */
    1295             : 
    1296             : /* {{{ proto int ftp_size(resource stream, string filename)
    1297             :    Returns the size of the file, or -1 on error */
    1298           3 : PHP_FUNCTION(ftp_size)
    1299             : {
    1300             :         zval            *z_ftp;
    1301             :         ftpbuf_t        *ftp;
    1302             :         char            *file;
    1303             :         size_t          file_len;
    1304             : 
    1305           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rp", &z_ftp, &file, &file_len) == FAILURE) {
    1306           1 :                 return;
    1307             :         }
    1308             : 
    1309           2 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1310           0 :                 RETURN_FALSE;
    1311             :         }
    1312             : 
    1313             :         /* get file size */
    1314           2 :         RETURN_LONG(ftp_size(ftp, file));
    1315             : }
    1316             : /* }}} */
    1317             : 
    1318             : /* {{{ proto int ftp_mdtm(resource stream, string filename)
    1319             :    Returns the last modification time of the file, or -1 on error */
    1320           8 : PHP_FUNCTION(ftp_mdtm)
    1321             : {
    1322             :         zval            *z_ftp;
    1323             :         ftpbuf_t        *ftp;
    1324             :         char            *file;
    1325             :         size_t          file_len;
    1326             : 
    1327           8 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rp", &z_ftp, &file, &file_len) == FAILURE) {
    1328           1 :                 return;
    1329             :         }
    1330             : 
    1331           7 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1332           0 :                 RETURN_FALSE;
    1333             :         }
    1334             : 
    1335             :         /* get file mod time */
    1336           7 :         RETURN_LONG(ftp_mdtm(ftp, file));
    1337             : }
    1338             : /* }}} */
    1339             : 
    1340             : /* {{{ proto bool ftp_rename(resource stream, string src, string dest)
    1341             :    Renames the given file to a new path */
    1342           1 : PHP_FUNCTION(ftp_rename)
    1343             : {
    1344             :         zval            *z_ftp;
    1345             :         ftpbuf_t        *ftp;
    1346             :         char            *src, *dest;
    1347             :         size_t          src_len, dest_len;
    1348             : 
    1349           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rss", &z_ftp, &src, &src_len, &dest, &dest_len) == FAILURE) {
    1350           1 :                 return;
    1351             :         }
    1352             : 
    1353           0 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1354           0 :                 RETURN_FALSE;
    1355             :         }
    1356             : 
    1357             :         /* rename the file */
    1358           0 :         if (!ftp_rename(ftp, src, dest)) {
    1359           0 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
    1360           0 :                 RETURN_FALSE;
    1361             :         }
    1362             : 
    1363           0 :         RETURN_TRUE;
    1364             : }
    1365             : /* }}} */
    1366             : 
    1367             : /* {{{ proto bool ftp_delete(resource stream, string file)
    1368             :    Deletes a file */
    1369           2 : PHP_FUNCTION(ftp_delete)
    1370             : {
    1371             :         zval            *z_ftp;
    1372             :         ftpbuf_t        *ftp;
    1373             :         char            *file;
    1374             :         size_t          file_len;
    1375             : 
    1376           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &z_ftp, &file, &file_len) == FAILURE) {
    1377           1 :                 return;
    1378             :         }
    1379             : 
    1380           1 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1381           0 :                 RETURN_FALSE;
    1382             :         }
    1383             : 
    1384             :         /* delete the file */
    1385           1 :         if (!ftp_delete(ftp, file)) {
    1386           1 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
    1387           1 :                 RETURN_FALSE;
    1388             :         }
    1389             : 
    1390           0 :         RETURN_TRUE;
    1391             : }
    1392             : /* }}} */
    1393             : 
    1394             : /* {{{ proto bool ftp_site(resource stream, string cmd)
    1395             :    Sends a SITE command to the server */
    1396           1 : PHP_FUNCTION(ftp_site)
    1397             : {
    1398             :         zval            *z_ftp;
    1399             :         ftpbuf_t        *ftp;
    1400             :         char            *cmd;
    1401             :         size_t          cmd_len;
    1402             : 
    1403           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &z_ftp, &cmd, &cmd_len) == FAILURE) {
    1404           1 :                 return;
    1405             :         }
    1406             : 
    1407           0 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1408           0 :                 RETURN_FALSE;
    1409             :         }
    1410             : 
    1411             :         /* send the site command */
    1412           0 :         if (!ftp_site(ftp, cmd)) {
    1413           0 :                 php_error_docref(NULL, E_WARNING, "%s", ftp->inbuf);
    1414           0 :                 RETURN_FALSE;
    1415             :         }
    1416             : 
    1417           0 :         RETURN_TRUE;
    1418             : }
    1419             : /* }}} */
    1420             : 
    1421             : /* {{{ proto bool ftp_close(resource stream)
    1422             :    Closes the FTP stream */
    1423          12 : PHP_FUNCTION(ftp_close)
    1424             : {
    1425             :         zval            *z_ftp;
    1426             :         ftpbuf_t        *ftp;
    1427             : 
    1428          12 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &z_ftp) == FAILURE) {
    1429           1 :                 return;
    1430             :         }
    1431             : 
    1432          11 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1433           0 :                 RETURN_FALSE;
    1434             :         }
    1435             : 
    1436          11 :         ftp_quit(ftp);
    1437             : 
    1438          11 :         RETURN_BOOL(zend_list_close(Z_RES_P(z_ftp)) == SUCCESS);
    1439             : }
    1440             : /* }}} */
    1441             : 
    1442             : /* {{{ proto bool ftp_set_option(resource stream, int option, mixed value)
    1443             :    Sets an FTP option */
    1444           3 : PHP_FUNCTION(ftp_set_option)
    1445             : {
    1446             :         zval            *z_ftp, *z_value;
    1447             :         zend_long               option;
    1448             :         ftpbuf_t        *ftp;
    1449             : 
    1450           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rlz", &z_ftp, &option, &z_value) == FAILURE) {
    1451           1 :                 return;
    1452             :         }
    1453             : 
    1454           2 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1455           0 :                 RETURN_FALSE;
    1456             :         }
    1457             : 
    1458           2 :         switch (option) {
    1459             :                 case PHP_FTP_OPT_TIMEOUT_SEC:
    1460           0 :                         if (Z_TYPE_P(z_value) != IS_LONG) {
    1461           0 :                                 php_error_docref(NULL, E_WARNING, "Option TIMEOUT_SEC expects value of type long, %s given",
    1462             :                                         zend_zval_type_name(z_value));
    1463           0 :                                 RETURN_FALSE;
    1464             :                         }
    1465           0 :                         if (Z_LVAL_P(z_value) <= 0) {
    1466           0 :                                 php_error_docref(NULL, E_WARNING, "Timeout has to be greater than 0");
    1467           0 :                                 RETURN_FALSE;
    1468             :                         }
    1469           0 :                         ftp->timeout_sec = Z_LVAL_P(z_value);
    1470           0 :                         RETURN_TRUE;
    1471             :                         break;
    1472             :                 case PHP_FTP_OPT_AUTOSEEK:
    1473           6 :                         if (Z_TYPE_P(z_value) != IS_TRUE && Z_TYPE_P(z_value) != IS_FALSE) {
    1474           0 :                                 php_error_docref(NULL, E_WARNING, "Option AUTOSEEK expects value of type boolean, %s given",
    1475             :                                         zend_zval_type_name(z_value));
    1476           0 :                                 RETURN_FALSE;
    1477             :                         }
    1478           4 :                         ftp->autoseek = Z_TYPE_P(z_value) == IS_TRUE ? 1 : 0;
    1479           2 :                         RETURN_TRUE;
    1480             :                         break;
    1481             :                 default:
    1482           0 :                         php_error_docref(NULL, E_WARNING, "Unknown option '%pd'", option);
    1483           0 :                         RETURN_FALSE;
    1484             :                         break;
    1485             :         }
    1486             : }
    1487             : /* }}} */
    1488             : 
    1489             : /* {{{ proto mixed ftp_get_option(resource stream, int option)
    1490             :    Gets an FTP option */
    1491           1 : PHP_FUNCTION(ftp_get_option)
    1492             : {
    1493             :         zval            *z_ftp;
    1494             :         zend_long               option;
    1495             :         ftpbuf_t        *ftp;
    1496             : 
    1497           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &z_ftp, &option) == FAILURE) {
    1498           1 :                 return;
    1499             :         }
    1500             : 
    1501           0 :         if ((ftp = (ftpbuf_t *)zend_fetch_resource(Z_RES_P(z_ftp), le_ftpbuf_name, le_ftpbuf)) == NULL) {
    1502           0 :                 RETURN_FALSE;
    1503             :         }
    1504             : 
    1505           0 :         switch (option) {
    1506             :                 case PHP_FTP_OPT_TIMEOUT_SEC:
    1507           0 :                         RETURN_LONG(ftp->timeout_sec);
    1508             :                         break;
    1509             :                 case PHP_FTP_OPT_AUTOSEEK:
    1510           0 :                         RETURN_BOOL(ftp->autoseek);
    1511             :                         break;
    1512             :                 default:
    1513           0 :                         php_error_docref(NULL, E_WARNING, "Unknown option '%pd'", option);
    1514           0 :                         RETURN_FALSE;
    1515             :                         break;
    1516             :         }
    1517             : }
    1518             : /* }}} */
    1519             : 
    1520             : #endif /* HAVE_FTP */
    1521             : 
    1522             : /*
    1523             :  * Local variables:
    1524             :  * tab-width: 4
    1525             :  * c-basic-offset: 4
    1526             :  * indent-tabs-mode: t
    1527             :  * End:
    1528             :  */

Generated by: LCOV version 1.10

Generated at Sat, 29 Aug 2015 10:22:14 +0000 (2 days ago)

Copyright © 2005-2015 The PHP Group
All rights reserved.