Annotation of embedaddon/php/ext/ftp/php_ftp.c, revision 1.1.1.3

1.1       misho       1: /*
                      2:    +----------------------------------------------------------------------+
                      3:    | PHP Version 5                                                        |
                      4:    +----------------------------------------------------------------------+
1.1.1.3 ! misho       5:    | Copyright (c) 1997-2013 The PHP Group                                |
1.1       misho       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: 
1.1.1.2   misho      20: /* $Id$ */
1.1       misho      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: #if HAVE_OPENSSL_EXT
                     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: 
1.1.1.2   misho      44: static int le_ftpbuf;
1.1       misho      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: #if HAVE_OPENSSL_EXT
                     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: #if HAVE_OPENSSL_EXT
                    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,
                    286:        "ftp",
                    287:        php_ftp_functions,
                    288:        PHP_MINIT(ftp),
                    289:        NULL,
                    290:        NULL,
                    291:        NULL,
                    292:        PHP_MINFO(ftp),
                    293:     NO_VERSION_YET,
                    294:        STANDARD_MODULE_PROPERTIES
                    295: };
                    296: 
                    297: #if COMPILE_DL_FTP
                    298: ZEND_GET_MODULE(php_ftp)
                    299: #endif
                    300: 
                    301: static void ftp_destructor_ftpbuf(zend_rsrc_list_entry *rsrc TSRMLS_DC)
                    302: {
                    303:        ftpbuf_t *ftp = (ftpbuf_t *)rsrc->ptr;
                    304: 
                    305:        ftp_close(ftp);
                    306: }
                    307: 
                    308: PHP_MINIT_FUNCTION(ftp)
                    309: {
                    310:        le_ftpbuf = zend_register_list_destructors_ex(ftp_destructor_ftpbuf, NULL, le_ftpbuf_name, module_number);
                    311:        REGISTER_LONG_CONSTANT("FTP_ASCII",  FTPTYPE_ASCII, CONST_PERSISTENT | CONST_CS);
                    312:        REGISTER_LONG_CONSTANT("FTP_TEXT",   FTPTYPE_ASCII, CONST_PERSISTENT | CONST_CS);
                    313:        REGISTER_LONG_CONSTANT("FTP_BINARY", FTPTYPE_IMAGE, CONST_PERSISTENT | CONST_CS);
                    314:        REGISTER_LONG_CONSTANT("FTP_IMAGE",  FTPTYPE_IMAGE, CONST_PERSISTENT | CONST_CS);
                    315:        REGISTER_LONG_CONSTANT("FTP_AUTORESUME", PHP_FTP_AUTORESUME, CONST_PERSISTENT | CONST_CS);
                    316:        REGISTER_LONG_CONSTANT("FTP_TIMEOUT_SEC", PHP_FTP_OPT_TIMEOUT_SEC, CONST_PERSISTENT | CONST_CS);
                    317:        REGISTER_LONG_CONSTANT("FTP_AUTOSEEK", PHP_FTP_OPT_AUTOSEEK, CONST_PERSISTENT | CONST_CS);
                    318:        REGISTER_LONG_CONSTANT("FTP_FAILED", PHP_FTP_FAILED, CONST_PERSISTENT | CONST_CS);
                    319:        REGISTER_LONG_CONSTANT("FTP_FINISHED", PHP_FTP_FINISHED, CONST_PERSISTENT | CONST_CS);
                    320:        REGISTER_LONG_CONSTANT("FTP_MOREDATA", PHP_FTP_MOREDATA, CONST_PERSISTENT | CONST_CS);
                    321:        return SUCCESS;
                    322: }
                    323: 
                    324: PHP_MINFO_FUNCTION(ftp)
                    325: {
                    326:        php_info_print_table_start();
                    327:        php_info_print_table_row(2, "FTP support", "enabled");
                    328:        php_info_print_table_end();
                    329: }
                    330: 
                    331: #define        XTYPE(xtype, mode)      { \
                    332:                                                                if (mode != FTPTYPE_ASCII && mode != FTPTYPE_IMAGE) { \
                    333:                                                                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Mode must be FTP_ASCII or FTP_BINARY"); \
                    334:                                                                        RETURN_FALSE; \
                    335:                                                                } \
                    336:                                                                xtype = mode; \
                    337:                                                        }
                    338: 
                    339: 
                    340: /* {{{ proto resource ftp_connect(string host [, int port [, int timeout]])
                    341:    Opens a FTP stream */
                    342: PHP_FUNCTION(ftp_connect)
                    343: {
                    344:        ftpbuf_t        *ftp;
                    345:        char            *host;
                    346:        int             host_len;
                    347:        long            port = 0;
                    348:        long            timeout_sec = FTP_DEFAULT_TIMEOUT;
                    349: 
                    350:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &host, &host_len, &port, &timeout_sec) == FAILURE) {
                    351:                return;
                    352:        }
                    353: 
                    354:        if (timeout_sec <= 0) {
                    355:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Timeout has to be greater than 0");
                    356:                RETURN_FALSE;
                    357:        }
                    358: 
                    359:        /* connect */
                    360:        if (!(ftp = ftp_open(host, (short)port, timeout_sec TSRMLS_CC))) {
                    361:                RETURN_FALSE;
                    362:        }
                    363: 
                    364:        /* autoseek for resuming */
                    365:        ftp->autoseek = FTP_DEFAULT_AUTOSEEK;
                    366: #if HAVE_OPENSSL_EXT
                    367:        /* disable ssl */
                    368:        ftp->use_ssl = 0;
                    369: #endif
                    370: 
                    371:        ZEND_REGISTER_RESOURCE(return_value, ftp, le_ftpbuf);
                    372: }
                    373: /* }}} */
                    374: 
                    375: #if HAVE_OPENSSL_EXT
                    376: /* {{{ proto resource ftp_ssl_connect(string host [, int port [, int timeout]])
                    377:    Opens a FTP-SSL stream */
                    378: PHP_FUNCTION(ftp_ssl_connect)
                    379: {
                    380:        ftpbuf_t        *ftp;
                    381:        char            *host;
                    382:        int             host_len;
                    383:        long            port = 0;
                    384:        long            timeout_sec = FTP_DEFAULT_TIMEOUT;
                    385: 
                    386:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &host, &host_len, &port, &timeout_sec) == FAILURE) {
                    387:                return;
                    388:        }
                    389: 
                    390:        if (timeout_sec <= 0) {
                    391:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Timeout has to be greater than 0");
                    392:                RETURN_FALSE;
                    393:        }
                    394: 
                    395:        /* connect */
                    396:        if (!(ftp = ftp_open(host, (short)port, timeout_sec TSRMLS_CC))) {
                    397:                RETURN_FALSE;
                    398:        }
                    399: 
                    400:        /* autoseek for resuming */
                    401:        ftp->autoseek = FTP_DEFAULT_AUTOSEEK;
                    402:        /* enable ssl */
                    403:        ftp->use_ssl = 1;
                    404: 
                    405:        ZEND_REGISTER_RESOURCE(return_value, ftp, le_ftpbuf);
                    406: }
                    407: /* }}} */
                    408: #endif
                    409: 
                    410: /* {{{ proto bool ftp_login(resource stream, string username, string password)
                    411:    Logs into the FTP server */
                    412: PHP_FUNCTION(ftp_login)
                    413: {
                    414:        zval            *z_ftp;
                    415:        ftpbuf_t        *ftp;
                    416:        char *user, *pass;
                    417:        int user_len, pass_len;
                    418: 
                    419:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &z_ftp, &user, &user_len, &pass, &pass_len) == FAILURE) {
                    420:                return;
                    421:        }
                    422: 
                    423:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    424: 
                    425:        /* log in */
                    426:        if (!ftp_login(ftp, user, pass TSRMLS_CC)) {
                    427:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    428:                RETURN_FALSE;
                    429:        }
                    430: 
                    431:        RETURN_TRUE;
                    432: }
                    433: /* }}} */
                    434: 
                    435: /* {{{ proto string ftp_pwd(resource stream)
                    436:    Returns the present working directory */
                    437: PHP_FUNCTION(ftp_pwd)
                    438: {
                    439:        zval            *z_ftp;
                    440:        ftpbuf_t        *ftp;
                    441:        const char      *pwd;
                    442: 
                    443:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ftp) == FAILURE) {
                    444:                return;
                    445:        }
                    446: 
                    447:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    448: 
                    449:        if (!(pwd = ftp_pwd(ftp))) {
                    450:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    451:                RETURN_FALSE;
                    452:        }
                    453: 
                    454:        RETURN_STRING((char*) pwd, 1);
                    455: }
                    456: /* }}} */
                    457: 
                    458: /* {{{ proto bool ftp_cdup(resource stream)
                    459:    Changes to the parent directory */
                    460: PHP_FUNCTION(ftp_cdup)
                    461: {
                    462:        zval            *z_ftp;
                    463:        ftpbuf_t        *ftp;
                    464: 
                    465:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ftp) == FAILURE) {
                    466:                return;
                    467:        }
                    468: 
                    469:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    470: 
                    471:        if (!ftp_cdup(ftp)) {
                    472:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    473:                RETURN_FALSE;
                    474:        }
                    475: 
                    476:        RETURN_TRUE;
                    477: }
                    478: /* }}} */
                    479: 
                    480: /* {{{ proto bool ftp_chdir(resource stream, string directory)
                    481:    Changes directories */
                    482: PHP_FUNCTION(ftp_chdir)
                    483: {
                    484:        zval            *z_ftp;
                    485:        ftpbuf_t        *ftp;
                    486:        char            *dir;
                    487:        int                     dir_len;
                    488: 
                    489:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &dir, &dir_len) == FAILURE) {
                    490:                return;
                    491:        }
                    492: 
                    493:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    494: 
                    495:        /* change directories */
                    496:        if (!ftp_chdir(ftp, dir)) {
                    497:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    498:                RETURN_FALSE;
                    499:        }
                    500: 
                    501:        RETURN_TRUE;
                    502: }
                    503: /* }}} */
                    504: 
                    505: /* {{{ proto bool ftp_exec(resource stream, string command)
                    506:    Requests execution of a program on the FTP server */
                    507: PHP_FUNCTION(ftp_exec)
                    508: {
                    509:        zval            *z_ftp;
                    510:        ftpbuf_t        *ftp;
                    511:        char            *cmd;
                    512:        int                     cmd_len;
                    513: 
                    514:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &cmd, &cmd_len) == FAILURE) {
                    515:                return;
                    516:        }
                    517: 
                    518:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    519: 
                    520:        /* execute serverside command */
                    521:        if (!ftp_exec(ftp, cmd)) {
                    522:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    523:                RETURN_FALSE;
                    524:        }
                    525: 
                    526:        RETURN_TRUE;
                    527: }
                    528: /* }}} */
                    529: 
                    530: /* {{{ proto array ftp_raw(resource stream, string command)
                    531:    Sends a literal command to the FTP server */
                    532: PHP_FUNCTION(ftp_raw)
                    533: {
                    534:        zval            *z_ftp;
                    535:        ftpbuf_t        *ftp;
                    536:        char            *cmd;
                    537:        int                     cmd_len;
                    538: 
                    539:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &cmd, &cmd_len) == FAILURE) {
                    540:                return;
                    541:        }
                    542: 
                    543:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    544: 
                    545:        /* execute arbitrary ftp command */
                    546:        ftp_raw(ftp, cmd, return_value);
                    547: }
                    548: /* }}} */
                    549: 
                    550: /* {{{ proto string ftp_mkdir(resource stream, string directory)
                    551:    Creates a directory and returns the absolute path for the new directory or false on error */
                    552: PHP_FUNCTION(ftp_mkdir)
                    553: {
                    554:        zval            *z_ftp;
                    555:        ftpbuf_t        *ftp;
                    556:        char            *dir, *tmp;
                    557:        int             dir_len;
                    558: 
                    559:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &dir, &dir_len) == FAILURE) {
                    560:                return;
                    561:        }
                    562: 
                    563:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    564: 
                    565:        /* create directorie */
                    566:        if (NULL == (tmp = ftp_mkdir(ftp, dir))) {
                    567:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    568:                RETURN_FALSE;
                    569:        }
                    570: 
                    571:        RETURN_STRING(tmp, 0);
                    572: }
                    573: /* }}} */
                    574: 
                    575: /* {{{ proto bool ftp_rmdir(resource stream, string directory)
                    576:    Removes a directory */
                    577: PHP_FUNCTION(ftp_rmdir)
                    578: {
                    579:        zval            *z_ftp;
                    580:        ftpbuf_t        *ftp;
                    581:        char            *dir;
                    582:        int             dir_len;
                    583: 
                    584:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &dir, &dir_len) == FAILURE) {
                    585:                return;
                    586:        }
                    587: 
                    588:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    589: 
                    590:        /* remove directorie */
                    591:        if (!ftp_rmdir(ftp, dir)) {
                    592:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    593:                RETURN_FALSE;
                    594:        }
                    595: 
                    596:        RETURN_TRUE;
                    597: }
                    598: /* }}} */
                    599: 
                    600: /* {{{ proto int ftp_chmod(resource stream, int mode, string filename)
                    601:    Sets permissions on a file */
                    602: PHP_FUNCTION(ftp_chmod)
                    603: {
                    604:        zval            *z_ftp;
                    605:        ftpbuf_t        *ftp;
                    606:        char            *filename;
                    607:        int             filename_len;
                    608:        long            mode;
                    609: 
1.1.1.2   misho     610:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlp", &z_ftp, &mode, &filename, &filename_len) == FAILURE) {
1.1       misho     611:                RETURN_FALSE;
                    612:        }
                    613: 
                    614:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    615: 
                    616:        if (!ftp_chmod(ftp, mode, filename, filename_len)) {
                    617:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    618:                RETURN_FALSE;
                    619:        }
                    620: 
                    621:        RETURN_LONG(mode);
                    622: }
                    623: /* }}} */
                    624: 
                    625: /* {{{ proto bool ftp_alloc(resource stream, int size[, &response])
                    626:    Attempt to allocate space on the remote FTP server */
                    627: PHP_FUNCTION(ftp_alloc)
                    628: {
                    629:        zval            *z_ftp, *zresponse = NULL;
                    630:        ftpbuf_t        *ftp;
                    631:        long            size, ret;
                    632:        char            *response = NULL;
                    633: 
                    634:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|z", &z_ftp, &size, &zresponse) == FAILURE) {
                    635:                RETURN_FALSE;
                    636:        }
                    637: 
                    638:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    639: 
                    640:        ret = ftp_alloc(ftp, size, zresponse ? &response : NULL);
                    641:        if (response) {
                    642:                zval_dtor(zresponse);
                    643:                ZVAL_STRING(zresponse, response, 0);
                    644:        }
                    645: 
                    646:        if (!ret) {
                    647:                RETURN_FALSE;
                    648:        }
                    649: 
                    650:        RETURN_TRUE;
                    651: }
                    652: /* }}} */
                    653: 
                    654: /* {{{ proto array ftp_nlist(resource stream, string directory)
                    655:    Returns an array of filenames in the given directory */
                    656: PHP_FUNCTION(ftp_nlist)
                    657: {
                    658:        zval            *z_ftp;
                    659:        ftpbuf_t        *ftp;
                    660:        char            **nlist, **ptr, *dir;
                    661:        int             dir_len;
                    662: 
1.1.1.2   misho     663:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rp", &z_ftp, &dir, &dir_len) == FAILURE) {
1.1       misho     664:                return;
                    665:        }
                    666: 
                    667:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    668: 
                    669:        /* get list of files */
                    670:        if (NULL == (nlist = ftp_nlist(ftp, dir TSRMLS_CC))) {
                    671:                RETURN_FALSE;
                    672:        }
                    673: 
                    674:        array_init(return_value);
                    675:        for (ptr = nlist; *ptr; ptr++) {
                    676:                add_next_index_string(return_value, *ptr, 1);
                    677:        }
                    678:        efree(nlist);
                    679: }
                    680: /* }}} */
                    681: 
                    682: /* {{{ proto array ftp_rawlist(resource stream, string directory [, bool recursive])
                    683:    Returns a detailed listing of a directory as an array of output lines */
                    684: PHP_FUNCTION(ftp_rawlist)
                    685: {
                    686:        zval            *z_ftp;
                    687:        ftpbuf_t        *ftp;
                    688:        char            **llist, **ptr, *dir;
                    689:        int             dir_len;
                    690:        zend_bool       recursive = 0;
                    691: 
                    692:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|b", &z_ftp, &dir, &dir_len, &recursive) == FAILURE) {
                    693:                return;
                    694:        }
                    695: 
                    696:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    697: 
                    698:        /* get raw directory listing */
                    699:        if (NULL == (llist = ftp_list(ftp, dir, recursive TSRMLS_CC))) {
                    700:                RETURN_FALSE;
                    701:        }
                    702: 
                    703:        array_init(return_value);
                    704:        for (ptr = llist; *ptr; ptr++) {
                    705:                add_next_index_string(return_value, *ptr, 1);
                    706:        }
                    707:        efree(llist);
                    708: }
                    709: /* }}} */
                    710: 
                    711: /* {{{ proto string ftp_systype(resource stream)
                    712:    Returns the system type identifier */
                    713: PHP_FUNCTION(ftp_systype)
                    714: {
                    715:        zval            *z_ftp;
                    716:        ftpbuf_t        *ftp;
                    717:        const char      *syst;
                    718: 
                    719:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ftp) == FAILURE) {
                    720:                return;
                    721:        }
                    722: 
                    723:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    724: 
                    725:        if (NULL == (syst = ftp_syst(ftp))) {
                    726:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    727:                RETURN_FALSE;
                    728:        }
                    729: 
                    730:        RETURN_STRING((char*) syst, 1);
                    731: }
                    732: /* }}} */
                    733: 
                    734: /* {{{ proto bool ftp_fget(resource stream, resource fp, string remote_file, int mode[, int resumepos])
                    735:    Retrieves a file from the FTP server and writes it to an open file */
                    736: PHP_FUNCTION(ftp_fget)
                    737: {
                    738:        zval            *z_ftp, *z_file;
                    739:        ftpbuf_t        *ftp;
                    740:        ftptype_t       xtype;
                    741:        php_stream      *stream;
                    742:        char            *file;
                    743:        int             file_len;
                    744:        long            mode, resumepos=0;
                    745: 
                    746:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrsl|l", &z_ftp, &z_file, &file, &file_len, &mode, &resumepos) == FAILURE) {
                    747:                return;
                    748:        }
                    749: 
                    750:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    751:        php_stream_from_zval(stream, &z_file);
                    752:        XTYPE(xtype, mode);
                    753: 
                    754:        /* ignore autoresume if autoseek is switched off */
                    755:        if (!ftp->autoseek && resumepos == PHP_FTP_AUTORESUME) {
                    756:                resumepos = 0;
                    757:        }
                    758: 
                    759:        if (ftp->autoseek && resumepos) {
                    760:                /* if autoresume is wanted seek to end */
                    761:                if (resumepos == PHP_FTP_AUTORESUME) {
                    762:                        php_stream_seek(stream, 0, SEEK_END);
                    763:                        resumepos = php_stream_tell(stream);
                    764:                } else {
                    765:                        php_stream_seek(stream, resumepos, SEEK_SET);
                    766:                }
                    767:        }
                    768: 
                    769:        if (!ftp_get(ftp, stream, file, xtype, resumepos TSRMLS_CC)) {
                    770:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    771:                RETURN_FALSE;
                    772:        }
                    773: 
                    774:        RETURN_TRUE;
                    775: }
                    776: /* }}} */
                    777: 
                    778: /* {{{ proto int ftp_nb_fget(resource stream, resource fp, string remote_file, int mode[, int resumepos])
                    779:    Retrieves a file from the FTP server asynchronly and writes it to an open file */
                    780: PHP_FUNCTION(ftp_nb_fget)
                    781: {
                    782:        zval            *z_ftp, *z_file;
                    783:        ftpbuf_t        *ftp;
                    784:        ftptype_t       xtype;
                    785:        php_stream      *stream;
                    786:        char            *file;
                    787:        int             file_len, ret;
                    788:        long            mode, resumepos=0;
                    789: 
                    790:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrsl|l", &z_ftp, &z_file, &file, &file_len, &mode, &resumepos) == FAILURE) {
                    791:                return;
                    792:        }
                    793: 
                    794:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    795:        php_stream_from_zval(stream, &z_file);
                    796:        XTYPE(xtype, mode);
                    797: 
                    798:        /* ignore autoresume if autoseek is switched off */
                    799:        if (!ftp->autoseek && resumepos == PHP_FTP_AUTORESUME) {
                    800:                resumepos = 0;
                    801:        }
                    802: 
                    803:        if (ftp->autoseek && resumepos) {
                    804:                /* if autoresume is wanted seek to end */
                    805:                if (resumepos == PHP_FTP_AUTORESUME) {
                    806:                        php_stream_seek(stream, 0, SEEK_END);
                    807:                        resumepos = php_stream_tell(stream);
                    808:                } else {
                    809:                        php_stream_seek(stream, resumepos, SEEK_SET);
                    810:                }
                    811:        }
                    812: 
                    813:        /* configuration */
                    814:        ftp->direction = 0;   /* recv */
                    815:        ftp->closestream = 0; /* do not close */
                    816: 
                    817:        if ((ret = ftp_nb_get(ftp, stream, file, xtype, resumepos TSRMLS_CC)) == PHP_FTP_FAILED) {
                    818:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    819:                RETURN_LONG(ret);
                    820:        }
                    821: 
                    822:        RETURN_LONG(ret);
                    823: }
                    824: /* }}} */
                    825: 
                    826: /* {{{ proto bool ftp_pasv(resource stream, bool pasv)
                    827:    Turns passive mode on or off */
                    828: PHP_FUNCTION(ftp_pasv)
                    829: {
                    830:        zval            *z_ftp;
                    831:        ftpbuf_t        *ftp;
                    832:        zend_bool       pasv;
                    833: 
                    834:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rb", &z_ftp, &pasv) == FAILURE) {
                    835:                return;
                    836:        }
                    837: 
                    838:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    839: 
                    840:        if (!ftp_pasv(ftp, pasv ? 1 : 0)) {
                    841:                RETURN_FALSE;
                    842:        }
                    843: 
                    844:        RETURN_TRUE;
                    845: }
                    846: /* }}} */
                    847: 
                    848: /* {{{ proto bool ftp_get(resource stream, string local_file, string remote_file, int mode[, int resume_pos])
                    849:    Retrieves a file from the FTP server and writes it to a local file */
                    850: PHP_FUNCTION(ftp_get)
                    851: {
                    852:        zval            *z_ftp;
                    853:        ftpbuf_t        *ftp;
                    854:        ftptype_t       xtype;
                    855:        php_stream      *outstream;
                    856:        char            *local, *remote;
                    857:        int             local_len, remote_len;
                    858:        long            mode, resumepos=0;
                    859: 
1.1.1.2   misho     860:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rppl|l", &z_ftp, &local, &local_len, &remote, &remote_len, &mode, &resumepos) == FAILURE) {
1.1       misho     861:                return;
                    862:        }
                    863: 
                    864:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    865:        XTYPE(xtype, mode);
                    866: 
                    867:        /* ignore autoresume if autoseek is switched off */
                    868:        if (!ftp->autoseek && resumepos == PHP_FTP_AUTORESUME) {
                    869:                resumepos = 0;
                    870:        }
                    871: 
                    872: #ifdef PHP_WIN32
                    873:        mode = FTPTYPE_IMAGE;
                    874: #endif
                    875: 
                    876:        if (ftp->autoseek && resumepos) {
1.1.1.2   misho     877:                outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "rt+" : "rb+", REPORT_ERRORS, NULL);
1.1       misho     878:                if (outstream == NULL) {
1.1.1.2   misho     879:                        outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "wt" : "wb", REPORT_ERRORS, NULL);
1.1       misho     880:                }
                    881:                if (outstream != NULL) {
                    882:                        /* if autoresume is wanted seek to end */
                    883:                        if (resumepos == PHP_FTP_AUTORESUME) {
                    884:                                php_stream_seek(outstream, 0, SEEK_END);
                    885:                                resumepos = php_stream_tell(outstream);
                    886:                        } else {
                    887:                                php_stream_seek(outstream, resumepos, SEEK_SET);
                    888:                        }
                    889:                }
                    890:        } else {
1.1.1.2   misho     891:                outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "wt" : "wb", REPORT_ERRORS, NULL);
1.1       misho     892:        }
                    893: 
                    894:        if (outstream == NULL)  {
                    895:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error opening %s", local);
                    896:                RETURN_FALSE;
                    897:        }
                    898: 
                    899:        if (!ftp_get(ftp, outstream, remote, xtype, resumepos TSRMLS_CC)) {
                    900:                php_stream_close(outstream);
                    901:                VCWD_UNLINK(local);
                    902:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    903:                RETURN_FALSE;
                    904:        }
                    905: 
                    906:        php_stream_close(outstream);
                    907:        RETURN_TRUE;
                    908: }
                    909: /* }}} */
                    910: 
                    911: /* {{{ proto int ftp_nb_get(resource stream, string local_file, string remote_file, int mode[, int resume_pos])
                    912:    Retrieves a file from the FTP server nbhronly and writes it to a local file */
                    913: PHP_FUNCTION(ftp_nb_get)
                    914: {
                    915:        zval            *z_ftp;
                    916:        ftpbuf_t        *ftp;
                    917:        ftptype_t       xtype;
                    918:        php_stream      *outstream;
                    919:        char            *local, *remote;
                    920:        int             local_len, remote_len, ret;
                    921:        long            mode, resumepos=0;
                    922: 
                    923:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rssl|l", &z_ftp, &local, &local_len, &remote, &remote_len, &mode, &resumepos) == FAILURE) {
                    924:                return;
                    925:        }
                    926: 
                    927:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    928:        XTYPE(xtype, mode);
                    929: 
                    930:        /* ignore autoresume if autoseek is switched off */
                    931:        if (!ftp->autoseek && resumepos == PHP_FTP_AUTORESUME) {
                    932:                resumepos = 0;
                    933:        }
                    934: #ifdef PHP_WIN32
                    935:        mode = FTPTYPE_IMAGE;
                    936: #endif
                    937:        if (ftp->autoseek && resumepos) {
1.1.1.2   misho     938:                outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "rt+" : "rb+", REPORT_ERRORS, NULL);
1.1       misho     939:                if (outstream == NULL) {
1.1.1.2   misho     940:                        outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "wt" : "wb", REPORT_ERRORS, NULL);
1.1       misho     941:                }
                    942:                if (outstream != NULL) {
                    943:                        /* if autoresume is wanted seek to end */
                    944:                        if (resumepos == PHP_FTP_AUTORESUME) {
                    945:                                php_stream_seek(outstream, 0, SEEK_END);
                    946:                                resumepos = php_stream_tell(outstream);
                    947:                        } else {
                    948:                                php_stream_seek(outstream, resumepos, SEEK_SET);
                    949:                        }
                    950:                }
                    951:        } else {
1.1.1.2   misho     952:                outstream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "wt" : "wb", REPORT_ERRORS, NULL);
1.1       misho     953:        }
                    954: 
                    955:        if (outstream == NULL)  {
                    956:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error opening %s", local);
                    957:                RETURN_FALSE;
                    958:        }
                    959: 
                    960:        /* configuration */
                    961:        ftp->direction = 0;   /* recv */
                    962:        ftp->closestream = 1; /* do close */
                    963: 
                    964:        if ((ret = ftp_nb_get(ftp, outstream, remote, xtype, resumepos TSRMLS_CC)) == PHP_FTP_FAILED) {
                    965:                php_stream_close(outstream);
                    966:                VCWD_UNLINK(local);
                    967:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                    968:                RETURN_LONG(PHP_FTP_FAILED);
                    969:        }
                    970: 
                    971:        if (ret == PHP_FTP_FINISHED) {
                    972:                php_stream_close(outstream);
                    973:        }
                    974: 
                    975:        RETURN_LONG(ret);
                    976: }
                    977: /* }}} */
                    978: 
                    979: /* {{{ proto int ftp_nb_continue(resource stream)
                    980:    Continues retrieving/sending a file nbronously */
                    981: PHP_FUNCTION(ftp_nb_continue)
                    982: {
                    983:        zval            *z_ftp;
                    984:        ftpbuf_t        *ftp;
                    985:        int             ret;
                    986: 
                    987:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ftp) == FAILURE) {
                    988:                return;
                    989:        }
                    990: 
                    991:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                    992: 
                    993:        if (!ftp->nb) {
                    994:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "no nbronous transfer to continue.");
                    995:                RETURN_LONG(PHP_FTP_FAILED);
                    996:        }
                    997: 
                    998:        if (ftp->direction) {
                    999:                ret=ftp_nb_continue_write(ftp TSRMLS_CC);
                   1000:        } else {
                   1001:                ret=ftp_nb_continue_read(ftp TSRMLS_CC);
                   1002:        }
                   1003: 
                   1004:        if (ret != PHP_FTP_MOREDATA && ftp->closestream) {
                   1005:                php_stream_close(ftp->stream);
                   1006:        }
                   1007: 
                   1008:        if (ret == PHP_FTP_FAILED) {
                   1009:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                   1010:        }
                   1011: 
                   1012:        RETURN_LONG(ret);
                   1013: }
                   1014: /* }}} */
                   1015: 
                   1016: /* {{{ proto bool ftp_fput(resource stream, string remote_file, resource fp, int mode[, int startpos])
                   1017:    Stores a file from an open file to the FTP server */
                   1018: PHP_FUNCTION(ftp_fput)
                   1019: {
                   1020:        zval            *z_ftp, *z_file;
                   1021:        ftpbuf_t        *ftp;
                   1022:        ftptype_t       xtype;
                   1023:        int             remote_len;
                   1024:        long            mode, startpos=0;
                   1025:        php_stream      *stream;
                   1026:        char            *remote;
                   1027: 
                   1028:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsrl|l", &z_ftp, &remote, &remote_len, &z_file, &mode, &startpos) == FAILURE) {
                   1029:                return;
                   1030:        }
                   1031: 
                   1032:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1033:        php_stream_from_zval(stream, &z_file);
                   1034:        XTYPE(xtype, mode);
                   1035: 
                   1036:        /* ignore autoresume if autoseek is switched off */
                   1037:        if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
                   1038:                startpos = 0;
                   1039:        }
                   1040: 
                   1041:        if (ftp->autoseek && startpos) {
                   1042:                /* if autoresume is wanted ask for remote size */
                   1043:                if (startpos == PHP_FTP_AUTORESUME) {
                   1044:                        startpos = ftp_size(ftp, remote);
                   1045:                        if (startpos < 0) {
                   1046:                                startpos = 0;
                   1047:                        }
                   1048:                }
                   1049:                if (startpos) {
                   1050:                        php_stream_seek(stream, startpos, SEEK_SET);
                   1051:                }
                   1052:        }
                   1053: 
                   1054:        if (!ftp_put(ftp, remote, stream, xtype, startpos TSRMLS_CC)) {
                   1055:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                   1056:                RETURN_FALSE;
                   1057:        }
                   1058: 
                   1059:        RETURN_TRUE;
                   1060: }
                   1061: /* }}} */
                   1062: 
                   1063: /* {{{ proto int ftp_nb_fput(resource stream, string remote_file, resource fp, int mode[, int startpos])
                   1064:    Stores a file from an open file to the FTP server nbronly */
                   1065: PHP_FUNCTION(ftp_nb_fput)
                   1066: {
                   1067:        zval            *z_ftp, *z_file;
                   1068:        ftpbuf_t        *ftp;
                   1069:        ftptype_t       xtype;
                   1070:        int             remote_len, ret;
                   1071:        long            mode, startpos=0;
                   1072:        php_stream      *stream;
                   1073:        char            *remote;
                   1074: 
                   1075:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsrl|l", &z_ftp, &remote, &remote_len, &z_file, &mode, &startpos) == FAILURE) {
                   1076:                return;
                   1077:        }
                   1078: 
                   1079:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1080:        php_stream_from_zval(stream, &z_file);
                   1081:        XTYPE(xtype, mode);
                   1082: 
                   1083:        /* ignore autoresume if autoseek is switched off */
                   1084:        if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
                   1085:                startpos = 0;
                   1086:        }
                   1087: 
                   1088:        if (ftp->autoseek && startpos) {
                   1089:                /* if autoresume is wanted ask for remote size */
                   1090:                if (startpos == PHP_FTP_AUTORESUME) {
                   1091:                        startpos = ftp_size(ftp, remote);
                   1092:                        if (startpos < 0) {
                   1093:                                startpos = 0;
                   1094:                        }
                   1095:                }
                   1096:                if (startpos) {
                   1097:                        php_stream_seek(stream, startpos, SEEK_SET);
                   1098:                }
                   1099:        }
                   1100: 
                   1101:        /* configuration */
                   1102:        ftp->direction = 1;   /* send */
                   1103:        ftp->closestream = 0; /* do not close */
                   1104: 
                   1105:        if (((ret = ftp_nb_put(ftp, remote, stream, xtype, startpos TSRMLS_CC)) == PHP_FTP_FAILED)) {
                   1106:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                   1107:                RETURN_LONG(ret);
                   1108:        }
                   1109: 
                   1110:        RETURN_LONG(ret);
                   1111: }
                   1112: /* }}} */
                   1113: 
                   1114: 
                   1115: /* {{{ proto bool ftp_put(resource stream, string remote_file, string local_file, int mode[, int startpos])
                   1116:    Stores a file on the FTP server */
                   1117: PHP_FUNCTION(ftp_put)
                   1118: {
                   1119:        zval            *z_ftp;
                   1120:        ftpbuf_t        *ftp;
                   1121:        ftptype_t       xtype;
                   1122:        char            *remote, *local;
                   1123:        int             remote_len, local_len;
                   1124:        long            mode, startpos=0;
                   1125:        php_stream      *instream;
                   1126: 
1.1.1.2   misho    1127:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rppl|l", &z_ftp, &remote, &remote_len, &local, &local_len, &mode, &startpos) == FAILURE) {
1.1       misho    1128:                return;
                   1129:        }
                   1130: 
                   1131:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1132:        XTYPE(xtype, mode);
                   1133: 
1.1.1.2   misho    1134:        if (!(instream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "rt" : "rb", REPORT_ERRORS, NULL))) {
1.1       misho    1135:                RETURN_FALSE;
                   1136:        }
                   1137: 
                   1138:        /* ignore autoresume if autoseek is switched off */
                   1139:        if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
                   1140:                startpos = 0;
                   1141:        }
                   1142: 
                   1143:        if (ftp->autoseek && startpos) {
                   1144:                /* if autoresume is wanted ask for remote size */
                   1145:                if (startpos == PHP_FTP_AUTORESUME) {
                   1146:                        startpos = ftp_size(ftp, remote);
                   1147:                        if (startpos < 0) {
                   1148:                                startpos = 0;
                   1149:                        }
                   1150:                }
                   1151:                if (startpos) {
                   1152:                        php_stream_seek(instream, startpos, SEEK_SET);
                   1153:                }
                   1154:        }
                   1155: 
                   1156:        if (!ftp_put(ftp, remote, instream, xtype, startpos TSRMLS_CC)) {
                   1157:                php_stream_close(instream);
                   1158:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                   1159:                RETURN_FALSE;
                   1160:        }
                   1161:        php_stream_close(instream);
                   1162: 
                   1163:        RETURN_TRUE;
                   1164: }
                   1165: /* }}} */
                   1166: 
                   1167: 
                   1168: /* {{{ proto int ftp_nb_put(resource stream, string remote_file, string local_file, int mode[, int startpos])
                   1169:    Stores a file on the FTP server */
                   1170: PHP_FUNCTION(ftp_nb_put)
                   1171: {
                   1172:        zval            *z_ftp;
                   1173:        ftpbuf_t        *ftp;
                   1174:        ftptype_t       xtype;
                   1175:        char            *remote, *local;
                   1176:        int             remote_len, local_len, ret;
                   1177:        long            mode, startpos=0;
                   1178:        php_stream      *instream;
                   1179: 
1.1.1.2   misho    1180:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rppl|l", &z_ftp, &remote, &remote_len, &local, &local_len, &mode, &startpos) == FAILURE) {
1.1       misho    1181:                return;
                   1182:        }
                   1183: 
                   1184:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1185:        XTYPE(xtype, mode);
                   1186: 
1.1.1.2   misho    1187:        if (!(instream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "rt" : "rb", REPORT_ERRORS, NULL))) {
1.1       misho    1188:                RETURN_FALSE;
                   1189:        }
                   1190: 
                   1191:        /* ignore autoresume if autoseek is switched off */
                   1192:        if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
                   1193:                startpos = 0;
                   1194:        }
                   1195: 
                   1196:        if (ftp->autoseek && startpos) {
                   1197:                /* if autoresume is wanted ask for remote size */
                   1198:                if (startpos == PHP_FTP_AUTORESUME) {
                   1199:                        startpos = ftp_size(ftp, remote);
                   1200:                        if (startpos < 0) {
                   1201:                                startpos = 0;
                   1202:                        }
                   1203:                }
                   1204:                if (startpos) {
                   1205:                        php_stream_seek(instream, startpos, SEEK_SET);
                   1206:                }
                   1207:        }
                   1208: 
                   1209:        /* configuration */
                   1210:        ftp->direction = 1;   /* send */
                   1211:        ftp->closestream = 1; /* do close */
                   1212: 
                   1213:        ret = ftp_nb_put(ftp, remote, instream, xtype, startpos TSRMLS_CC);
                   1214: 
                   1215:        if (ret != PHP_FTP_MOREDATA) {
                   1216:                php_stream_close(instream);
                   1217:        }
                   1218: 
                   1219:        if (ret == PHP_FTP_FAILED) {
                   1220:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                   1221:        }
                   1222: 
                   1223:        RETURN_LONG(ret);
                   1224: }
                   1225: /* }}} */
                   1226: 
                   1227: /* {{{ proto int ftp_size(resource stream, string filename)
                   1228:    Returns the size of the file, or -1 on error */
                   1229: PHP_FUNCTION(ftp_size)
                   1230: {
                   1231:        zval            *z_ftp;
                   1232:        ftpbuf_t        *ftp;
                   1233:        char            *file;
                   1234:        int             file_len;
                   1235: 
1.1.1.2   misho    1236:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rp", &z_ftp, &file, &file_len) == FAILURE) {
1.1       misho    1237:                return;
                   1238:        }
                   1239: 
                   1240:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1241: 
                   1242:        /* get file size */
                   1243:        RETURN_LONG(ftp_size(ftp, file));
                   1244: }
                   1245: /* }}} */
                   1246: 
                   1247: /* {{{ proto int ftp_mdtm(resource stream, string filename)
                   1248:    Returns the last modification time of the file, or -1 on error */
                   1249: PHP_FUNCTION(ftp_mdtm)
                   1250: {
                   1251:        zval            *z_ftp;
                   1252:        ftpbuf_t        *ftp;
                   1253:        char            *file;
                   1254:        int             file_len;
                   1255: 
1.1.1.2   misho    1256:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rp", &z_ftp, &file, &file_len) == FAILURE) {
1.1       misho    1257:                return;
                   1258:        }
                   1259: 
                   1260:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1261: 
                   1262:        /* get file mod time */
                   1263:        RETURN_LONG(ftp_mdtm(ftp, file));
                   1264: }
                   1265: /* }}} */
                   1266: 
                   1267: /* {{{ proto bool ftp_rename(resource stream, string src, string dest)
                   1268:    Renames the given file to a new path */
                   1269: PHP_FUNCTION(ftp_rename)
                   1270: {
                   1271:        zval            *z_ftp;
                   1272:        ftpbuf_t        *ftp;
                   1273:        char            *src, *dest;
                   1274:        int             src_len, dest_len;
                   1275: 
                   1276:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &z_ftp, &src, &src_len, &dest, &dest_len) == FAILURE) {
                   1277:                return;
                   1278:        }
                   1279: 
                   1280:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1281: 
                   1282:        /* rename the file */
                   1283:        if (!ftp_rename(ftp, src, dest)) {
                   1284:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                   1285:                RETURN_FALSE;
                   1286:        }
                   1287: 
                   1288:        RETURN_TRUE;
                   1289: }
                   1290: /* }}} */
                   1291: 
                   1292: /* {{{ proto bool ftp_delete(resource stream, string file)
                   1293:    Deletes a file */
                   1294: PHP_FUNCTION(ftp_delete)
                   1295: {
                   1296:        zval            *z_ftp;
                   1297:        ftpbuf_t        *ftp;
                   1298:        char            *file;
                   1299:        int             file_len;
                   1300: 
                   1301:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &file, &file_len) == FAILURE) {
                   1302:                return;
                   1303:        }
                   1304: 
                   1305:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1306: 
                   1307:        /* delete the file */
                   1308:        if (!ftp_delete(ftp, file)) {
                   1309:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                   1310:                RETURN_FALSE;
                   1311:        }
                   1312: 
                   1313:        RETURN_TRUE;
                   1314: }
                   1315: /* }}} */
                   1316: 
                   1317: /* {{{ proto bool ftp_site(resource stream, string cmd)
                   1318:    Sends a SITE command to the server */
                   1319: PHP_FUNCTION(ftp_site)
                   1320: {
                   1321:        zval            *z_ftp;
                   1322:        ftpbuf_t        *ftp;
                   1323:        char            *cmd;
                   1324:        int             cmd_len;
                   1325: 
                   1326:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &cmd, &cmd_len) == FAILURE) {
                   1327:                return;
                   1328:        }
                   1329: 
                   1330:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1331: 
                   1332:        /* send the site command */
                   1333:        if (!ftp_site(ftp, cmd)) {
                   1334:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
                   1335:                RETURN_FALSE;
                   1336:        }
                   1337: 
                   1338:        RETURN_TRUE;
                   1339: }
                   1340: /* }}} */
                   1341: 
                   1342: /* {{{ proto bool ftp_close(resource stream)
                   1343:    Closes the FTP stream */
                   1344: PHP_FUNCTION(ftp_close)
                   1345: {
                   1346:        zval            *z_ftp;
                   1347:        ftpbuf_t        *ftp;
                   1348: 
                   1349:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ftp) == FAILURE) {
                   1350:                return;
                   1351:        }
                   1352: 
                   1353:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1354: 
                   1355:        ftp_quit(ftp);
                   1356: 
                   1357:        RETURN_BOOL(zend_list_delete(Z_LVAL_P(z_ftp)) == SUCCESS);
                   1358: }
                   1359: /* }}} */
                   1360: 
                   1361: /* {{{ proto bool ftp_set_option(resource stream, int option, mixed value)
                   1362:    Sets an FTP option */
                   1363: PHP_FUNCTION(ftp_set_option)
                   1364: {
                   1365:        zval            *z_ftp, *z_value;
                   1366:        long            option;
                   1367:        ftpbuf_t        *ftp;
                   1368: 
                   1369:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &z_ftp, &option, &z_value) == FAILURE) {
                   1370:                return;
                   1371:        }
                   1372: 
                   1373:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1374: 
                   1375:        switch (option) {
                   1376:                case PHP_FTP_OPT_TIMEOUT_SEC:
                   1377:                        if (Z_TYPE_P(z_value) != IS_LONG) {
                   1378:                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Option TIMEOUT_SEC expects value of type long, %s given",
                   1379:                                        zend_zval_type_name(z_value));
                   1380:                                RETURN_FALSE;
                   1381:                        }
                   1382:                        if (Z_LVAL_P(z_value) <= 0) {
                   1383:                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Timeout has to be greater than 0");
                   1384:                                RETURN_FALSE;
                   1385:                        }
                   1386:                        ftp->timeout_sec = Z_LVAL_P(z_value);
                   1387:                        RETURN_TRUE;
                   1388:                        break;
                   1389:                case PHP_FTP_OPT_AUTOSEEK:
                   1390:                        if (Z_TYPE_P(z_value) != IS_BOOL) {
                   1391:                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Option AUTOSEEK expects value of type boolean, %s given",
                   1392:                                        zend_zval_type_name(z_value));
                   1393:                                RETURN_FALSE;
                   1394:                        }
                   1395:                        ftp->autoseek = Z_LVAL_P(z_value);
                   1396:                        RETURN_TRUE;
                   1397:                        break;
                   1398:                default:
                   1399:                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option '%ld'", option);
                   1400:                        RETURN_FALSE;
                   1401:                        break;
                   1402:        }
                   1403: }
                   1404: /* }}} */
                   1405: 
                   1406: /* {{{ proto mixed ftp_get_option(resource stream, int option)
                   1407:    Gets an FTP option */
                   1408: PHP_FUNCTION(ftp_get_option)
                   1409: {
                   1410:        zval            *z_ftp;
                   1411:        long            option;
                   1412:        ftpbuf_t        *ftp;
                   1413: 
                   1414:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &z_ftp, &option) == FAILURE) {
                   1415:                return;
                   1416:        }
                   1417: 
                   1418:        ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
                   1419: 
                   1420:        switch (option) {
                   1421:                case PHP_FTP_OPT_TIMEOUT_SEC:
                   1422:                        RETURN_LONG(ftp->timeout_sec);
                   1423:                        break;
                   1424:                case PHP_FTP_OPT_AUTOSEEK:
                   1425:                        RETURN_BOOL(ftp->autoseek);
                   1426:                        break;
                   1427:                default:
                   1428:                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option '%ld'", option);
                   1429:                        RETURN_FALSE;
                   1430:                        break;
                   1431:        }
                   1432: }
                   1433: /* }}} */
                   1434: 
                   1435: #endif /* HAVE_FTP */
                   1436: 
                   1437: /*
                   1438:  * Local variables:
                   1439:  * tab-width: 4
                   1440:  * c-basic-offset: 4
                   1441:  * indent-tabs-mode: t
                   1442:  * End:
                   1443:  */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>