Annotation of embedaddon/php/ext/ftp/php_ftp.c, revision 1.1.1.5
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
1.1.1.5 ! misho 5: | Copyright (c) 1997-2014 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;
1.1.1.4 misho 787: int file_len;
788: long mode, resumepos=0, ret;
1.1 misho 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);
1.1.1.5 ! misho 966: ftp->stream = NULL;
1.1 misho 967: VCWD_UNLINK(local);
968: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
969: RETURN_LONG(PHP_FTP_FAILED);
970: }
971:
1.1.1.5 ! misho 972: if (ret == PHP_FTP_FINISHED){
! 973: php_stream_close(outstream);
! 974: ftp->stream = NULL;
! 975: }
1.1 misho 976:
977: RETURN_LONG(ret);
978: }
979: /* }}} */
980:
981: /* {{{ proto int ftp_nb_continue(resource stream)
982: Continues retrieving/sending a file nbronously */
983: PHP_FUNCTION(ftp_nb_continue)
984: {
985: zval *z_ftp;
986: ftpbuf_t *ftp;
1.1.1.4 misho 987: long ret;
1.1 misho 988:
989: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ftp) == FAILURE) {
990: return;
991: }
992:
993: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
994:
995: if (!ftp->nb) {
996: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no nbronous transfer to continue.");
997: RETURN_LONG(PHP_FTP_FAILED);
998: }
999:
1000: if (ftp->direction) {
1001: ret=ftp_nb_continue_write(ftp TSRMLS_CC);
1002: } else {
1003: ret=ftp_nb_continue_read(ftp TSRMLS_CC);
1004: }
1005:
1006: if (ret != PHP_FTP_MOREDATA && ftp->closestream) {
1007: php_stream_close(ftp->stream);
1.1.1.5 ! misho 1008: ftp->stream = NULL;
1.1 misho 1009: }
1010:
1011: if (ret == PHP_FTP_FAILED) {
1012: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
1013: }
1014:
1015: RETURN_LONG(ret);
1016: }
1017: /* }}} */
1018:
1019: /* {{{ proto bool ftp_fput(resource stream, string remote_file, resource fp, int mode[, int startpos])
1020: Stores a file from an open file to the FTP server */
1021: PHP_FUNCTION(ftp_fput)
1022: {
1023: zval *z_ftp, *z_file;
1024: ftpbuf_t *ftp;
1025: ftptype_t xtype;
1026: int remote_len;
1027: long mode, startpos=0;
1028: php_stream *stream;
1029: char *remote;
1030:
1031: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsrl|l", &z_ftp, &remote, &remote_len, &z_file, &mode, &startpos) == FAILURE) {
1032: return;
1033: }
1034:
1035: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1036: php_stream_from_zval(stream, &z_file);
1037: XTYPE(xtype, mode);
1038:
1039: /* ignore autoresume if autoseek is switched off */
1040: if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
1041: startpos = 0;
1042: }
1043:
1044: if (ftp->autoseek && startpos) {
1045: /* if autoresume is wanted ask for remote size */
1046: if (startpos == PHP_FTP_AUTORESUME) {
1047: startpos = ftp_size(ftp, remote);
1048: if (startpos < 0) {
1049: startpos = 0;
1050: }
1051: }
1052: if (startpos) {
1053: php_stream_seek(stream, startpos, SEEK_SET);
1054: }
1055: }
1056:
1057: if (!ftp_put(ftp, remote, stream, xtype, startpos TSRMLS_CC)) {
1058: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
1059: RETURN_FALSE;
1060: }
1061:
1062: RETURN_TRUE;
1063: }
1064: /* }}} */
1065:
1066: /* {{{ proto int ftp_nb_fput(resource stream, string remote_file, resource fp, int mode[, int startpos])
1067: Stores a file from an open file to the FTP server nbronly */
1068: PHP_FUNCTION(ftp_nb_fput)
1069: {
1070: zval *z_ftp, *z_file;
1071: ftpbuf_t *ftp;
1072: ftptype_t xtype;
1073: int remote_len, ret;
1074: long mode, startpos=0;
1075: php_stream *stream;
1076: char *remote;
1077:
1078: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsrl|l", &z_ftp, &remote, &remote_len, &z_file, &mode, &startpos) == FAILURE) {
1079: return;
1080: }
1081:
1082: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1083: php_stream_from_zval(stream, &z_file);
1084: XTYPE(xtype, mode);
1085:
1086: /* ignore autoresume if autoseek is switched off */
1087: if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
1088: startpos = 0;
1089: }
1090:
1091: if (ftp->autoseek && startpos) {
1092: /* if autoresume is wanted ask for remote size */
1093: if (startpos == PHP_FTP_AUTORESUME) {
1094: startpos = ftp_size(ftp, remote);
1095: if (startpos < 0) {
1096: startpos = 0;
1097: }
1098: }
1099: if (startpos) {
1100: php_stream_seek(stream, startpos, SEEK_SET);
1101: }
1102: }
1103:
1104: /* configuration */
1105: ftp->direction = 1; /* send */
1106: ftp->closestream = 0; /* do not close */
1107:
1108: if (((ret = ftp_nb_put(ftp, remote, stream, xtype, startpos TSRMLS_CC)) == PHP_FTP_FAILED)) {
1109: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
1110: RETURN_LONG(ret);
1111: }
1112:
1113: RETURN_LONG(ret);
1114: }
1115: /* }}} */
1116:
1117:
1118: /* {{{ proto bool ftp_put(resource stream, string remote_file, string local_file, int mode[, int startpos])
1119: Stores a file on the FTP server */
1120: PHP_FUNCTION(ftp_put)
1121: {
1122: zval *z_ftp;
1123: ftpbuf_t *ftp;
1124: ftptype_t xtype;
1125: char *remote, *local;
1.1.1.4 misho 1126: long remote_len, local_len;
1.1 misho 1127: long mode, startpos=0;
1128: php_stream *instream;
1129:
1.1.1.2 misho 1130: 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 1131: return;
1132: }
1133:
1134: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1135: XTYPE(xtype, mode);
1136:
1.1.1.2 misho 1137: if (!(instream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "rt" : "rb", REPORT_ERRORS, NULL))) {
1.1 misho 1138: RETURN_FALSE;
1139: }
1140:
1141: /* ignore autoresume if autoseek is switched off */
1142: if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
1143: startpos = 0;
1144: }
1145:
1146: if (ftp->autoseek && startpos) {
1147: /* if autoresume is wanted ask for remote size */
1148: if (startpos == PHP_FTP_AUTORESUME) {
1149: startpos = ftp_size(ftp, remote);
1150: if (startpos < 0) {
1151: startpos = 0;
1152: }
1153: }
1154: if (startpos) {
1155: php_stream_seek(instream, startpos, SEEK_SET);
1156: }
1157: }
1158:
1159: if (!ftp_put(ftp, remote, instream, xtype, startpos TSRMLS_CC)) {
1160: php_stream_close(instream);
1161: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
1162: RETURN_FALSE;
1163: }
1164: php_stream_close(instream);
1165:
1166: RETURN_TRUE;
1167: }
1168: /* }}} */
1169:
1170:
1171: /* {{{ proto int ftp_nb_put(resource stream, string remote_file, string local_file, int mode[, int startpos])
1172: Stores a file on the FTP server */
1173: PHP_FUNCTION(ftp_nb_put)
1174: {
1175: zval *z_ftp;
1176: ftpbuf_t *ftp;
1177: ftptype_t xtype;
1178: char *remote, *local;
1.1.1.4 misho 1179: int remote_len, local_len;
1180: long mode, startpos=0, ret;
1.1 misho 1181: php_stream *instream;
1182:
1.1.1.2 misho 1183: 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 1184: return;
1185: }
1186:
1187: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1188: XTYPE(xtype, mode);
1189:
1.1.1.2 misho 1190: if (!(instream = php_stream_open_wrapper(local, mode == FTPTYPE_ASCII ? "rt" : "rb", REPORT_ERRORS, NULL))) {
1.1 misho 1191: RETURN_FALSE;
1192: }
1193:
1194: /* ignore autoresume if autoseek is switched off */
1195: if (!ftp->autoseek && startpos == PHP_FTP_AUTORESUME) {
1196: startpos = 0;
1197: }
1198:
1199: if (ftp->autoseek && startpos) {
1200: /* if autoresume is wanted ask for remote size */
1201: if (startpos == PHP_FTP_AUTORESUME) {
1202: startpos = ftp_size(ftp, remote);
1203: if (startpos < 0) {
1204: startpos = 0;
1205: }
1206: }
1207: if (startpos) {
1208: php_stream_seek(instream, startpos, SEEK_SET);
1209: }
1210: }
1211:
1212: /* configuration */
1213: ftp->direction = 1; /* send */
1214: ftp->closestream = 1; /* do close */
1215:
1216: ret = ftp_nb_put(ftp, remote, instream, xtype, startpos TSRMLS_CC);
1217:
1218: if (ret != PHP_FTP_MOREDATA) {
1219: php_stream_close(instream);
1.1.1.5 ! misho 1220: ftp->stream = NULL;
1.1 misho 1221: }
1222:
1223: if (ret == PHP_FTP_FAILED) {
1224: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
1225: }
1226:
1227: RETURN_LONG(ret);
1228: }
1229: /* }}} */
1230:
1231: /* {{{ proto int ftp_size(resource stream, string filename)
1232: Returns the size of the file, or -1 on error */
1233: PHP_FUNCTION(ftp_size)
1234: {
1235: zval *z_ftp;
1236: ftpbuf_t *ftp;
1237: char *file;
1238: int file_len;
1239:
1.1.1.2 misho 1240: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rp", &z_ftp, &file, &file_len) == FAILURE) {
1.1 misho 1241: return;
1242: }
1243:
1244: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1245:
1246: /* get file size */
1247: RETURN_LONG(ftp_size(ftp, file));
1248: }
1249: /* }}} */
1250:
1251: /* {{{ proto int ftp_mdtm(resource stream, string filename)
1252: Returns the last modification time of the file, or -1 on error */
1253: PHP_FUNCTION(ftp_mdtm)
1254: {
1255: zval *z_ftp;
1256: ftpbuf_t *ftp;
1257: char *file;
1258: int file_len;
1259:
1.1.1.2 misho 1260: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rp", &z_ftp, &file, &file_len) == FAILURE) {
1.1 misho 1261: return;
1262: }
1263:
1264: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1265:
1266: /* get file mod time */
1267: RETURN_LONG(ftp_mdtm(ftp, file));
1268: }
1269: /* }}} */
1270:
1271: /* {{{ proto bool ftp_rename(resource stream, string src, string dest)
1272: Renames the given file to a new path */
1273: PHP_FUNCTION(ftp_rename)
1274: {
1275: zval *z_ftp;
1276: ftpbuf_t *ftp;
1277: char *src, *dest;
1278: int src_len, dest_len;
1279:
1280: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &z_ftp, &src, &src_len, &dest, &dest_len) == FAILURE) {
1281: return;
1282: }
1283:
1284: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1285:
1286: /* rename the file */
1287: if (!ftp_rename(ftp, src, dest)) {
1288: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
1289: RETURN_FALSE;
1290: }
1291:
1292: RETURN_TRUE;
1293: }
1294: /* }}} */
1295:
1296: /* {{{ proto bool ftp_delete(resource stream, string file)
1297: Deletes a file */
1298: PHP_FUNCTION(ftp_delete)
1299: {
1300: zval *z_ftp;
1301: ftpbuf_t *ftp;
1302: char *file;
1303: int file_len;
1304:
1305: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &file, &file_len) == FAILURE) {
1306: return;
1307: }
1308:
1309: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1310:
1311: /* delete the file */
1312: if (!ftp_delete(ftp, file)) {
1313: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
1314: RETURN_FALSE;
1315: }
1316:
1317: RETURN_TRUE;
1318: }
1319: /* }}} */
1320:
1321: /* {{{ proto bool ftp_site(resource stream, string cmd)
1322: Sends a SITE command to the server */
1323: PHP_FUNCTION(ftp_site)
1324: {
1325: zval *z_ftp;
1326: ftpbuf_t *ftp;
1327: char *cmd;
1328: int cmd_len;
1329:
1330: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ftp, &cmd, &cmd_len) == FAILURE) {
1331: return;
1332: }
1333:
1334: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1335:
1336: /* send the site command */
1337: if (!ftp_site(ftp, cmd)) {
1338: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ftp->inbuf);
1339: RETURN_FALSE;
1340: }
1341:
1342: RETURN_TRUE;
1343: }
1344: /* }}} */
1345:
1346: /* {{{ proto bool ftp_close(resource stream)
1347: Closes the FTP stream */
1348: PHP_FUNCTION(ftp_close)
1349: {
1350: zval *z_ftp;
1351: ftpbuf_t *ftp;
1352:
1353: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ftp) == FAILURE) {
1354: return;
1355: }
1356:
1357: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1358:
1359: ftp_quit(ftp);
1360:
1361: RETURN_BOOL(zend_list_delete(Z_LVAL_P(z_ftp)) == SUCCESS);
1362: }
1363: /* }}} */
1364:
1365: /* {{{ proto bool ftp_set_option(resource stream, int option, mixed value)
1366: Sets an FTP option */
1367: PHP_FUNCTION(ftp_set_option)
1368: {
1369: zval *z_ftp, *z_value;
1370: long option;
1371: ftpbuf_t *ftp;
1372:
1373: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &z_ftp, &option, &z_value) == FAILURE) {
1374: return;
1375: }
1376:
1377: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1378:
1379: switch (option) {
1380: case PHP_FTP_OPT_TIMEOUT_SEC:
1381: if (Z_TYPE_P(z_value) != IS_LONG) {
1382: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Option TIMEOUT_SEC expects value of type long, %s given",
1383: zend_zval_type_name(z_value));
1384: RETURN_FALSE;
1385: }
1386: if (Z_LVAL_P(z_value) <= 0) {
1387: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Timeout has to be greater than 0");
1388: RETURN_FALSE;
1389: }
1390: ftp->timeout_sec = Z_LVAL_P(z_value);
1391: RETURN_TRUE;
1392: break;
1393: case PHP_FTP_OPT_AUTOSEEK:
1394: if (Z_TYPE_P(z_value) != IS_BOOL) {
1395: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Option AUTOSEEK expects value of type boolean, %s given",
1396: zend_zval_type_name(z_value));
1397: RETURN_FALSE;
1398: }
1399: ftp->autoseek = Z_LVAL_P(z_value);
1400: RETURN_TRUE;
1401: break;
1402: default:
1403: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option '%ld'", option);
1404: RETURN_FALSE;
1405: break;
1406: }
1407: }
1408: /* }}} */
1409:
1410: /* {{{ proto mixed ftp_get_option(resource stream, int option)
1411: Gets an FTP option */
1412: PHP_FUNCTION(ftp_get_option)
1413: {
1414: zval *z_ftp;
1415: long option;
1416: ftpbuf_t *ftp;
1417:
1418: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &z_ftp, &option) == FAILURE) {
1419: return;
1420: }
1421:
1422: ZEND_FETCH_RESOURCE(ftp, ftpbuf_t*, &z_ftp, -1, le_ftpbuf_name, le_ftpbuf);
1423:
1424: switch (option) {
1425: case PHP_FTP_OPT_TIMEOUT_SEC:
1426: RETURN_LONG(ftp->timeout_sec);
1427: break;
1428: case PHP_FTP_OPT_AUTOSEEK:
1429: RETURN_BOOL(ftp->autoseek);
1430: break;
1431: default:
1432: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option '%ld'", option);
1433: RETURN_FALSE;
1434: break;
1435: }
1436: }
1437: /* }}} */
1438:
1439: #endif /* HAVE_FTP */
1440:
1441: /*
1442: * Local variables:
1443: * tab-width: 4
1444: * c-basic-offset: 4
1445: * indent-tabs-mode: t
1446: * End:
1447: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>