![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ftp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / ftp|
Return to ftp.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / ftp |
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 The PHP Group |
6: +----------------------------------------------------------------------+
7: | This source file is subject to version 3.01 of the PHP license, |
8: | that is bundled with this package in the file LICENSE, and is |
9: | available through the world-wide-web at the following url: |
10: | http://www.php.net/license/3_01.txt |
11: | If you did not receive a copy of the PHP license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@php.net so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Authors: Andrew Skalski <askalski@chek.com> |
16: | Stefan Esser <sesser@php.net> (resume functions) |
17: +----------------------------------------------------------------------+
18: */
19:
20: /* $Id: ftp.c 321634 2012-01-01 13:15:04Z felipe $ */
21:
22: #ifdef HAVE_CONFIG_H
23: #include "config.h"
24: #endif
25:
26: #include "php.h"
27:
28: #if HAVE_FTP
29:
30: #include <stdio.h>
31: #include <ctype.h>
32: #include <stdlib.h>
33: #ifdef HAVE_UNISTD_H
34: #include <unistd.h>
35: #endif
36: #include <fcntl.h>
37: #include <string.h>
38: #include <time.h>
39: #ifdef PHP_WIN32
40: #include <winsock2.h>
41: #elif defined(NETWARE)
42: #ifdef USE_WINSOCK /* Modified to use Winsock (NOVSOCK2.H), atleast for now */
43: #include <novsock2.h>
44: #else
45: #include <sys/socket.h>
46: #include <netinet/in.h>
47: #include <netdb.h>
48: #endif
49: #else
50: #ifdef HAVE_SYS_TYPES_H
51: #include <sys/types.h>
52: #endif
53: #include <sys/socket.h>
54: #include <netinet/in.h>
55: #include <arpa/inet.h>
56: #include <netdb.h>
57: #endif
58: #include <errno.h>
59:
60: #if HAVE_SYS_TIME_H
61: #include <sys/time.h>
62: #endif
63:
64: #ifdef HAVE_SYS_SELECT_H
65: #include <sys/select.h>
66: #endif
67:
68: #if HAVE_OPENSSL_EXT
69: #include <openssl/ssl.h>
70: #endif
71:
72: #include "ftp.h"
73: #include "ext/standard/fsock.h"
74:
75: /* Additional headers for NetWare */
76: #if defined(NETWARE) && !defined(USE_WINSOCK)
77: #include <sys/select.h>
78: #endif
79:
80: /* sends an ftp command, returns true on success, false on error.
81: * it sends the string "cmd args\r\n" if args is non-null, or
82: * "cmd\r\n" if args is null
83: */
84: static int ftp_putcmd( ftpbuf_t *ftp,
85: const char *cmd,
86: const char *args);
87:
88: /* wrapper around send/recv to handle timeouts */
89: static int my_send(ftpbuf_t *ftp, php_socket_t s, void *buf, size_t len);
90: static int my_recv(ftpbuf_t *ftp, php_socket_t s, void *buf, size_t len);
91: static int my_accept(ftpbuf_t *ftp, php_socket_t s, struct sockaddr *addr, socklen_t *addrlen);
92:
93: /* reads a line the socket , returns true on success, false on error */
94: static int ftp_readline(ftpbuf_t *ftp);
95:
96: /* reads an ftp response, returns true on success, false on error */
97: static int ftp_getresp(ftpbuf_t *ftp);
98:
99: /* sets the ftp transfer type */
100: static int ftp_type(ftpbuf_t *ftp, ftptype_t type);
101:
102: /* opens up a data stream */
103: static databuf_t* ftp_getdata(ftpbuf_t *ftp TSRMLS_DC);
104:
105: /* accepts the data connection, returns updated data buffer */
106: static databuf_t* data_accept(databuf_t *data, ftpbuf_t *ftp TSRMLS_DC);
107:
108: /* closes the data connection, returns NULL */
109: static databuf_t* data_close(ftpbuf_t *ftp, databuf_t *data);
110:
111: /* generic file lister */
112: static char** ftp_genlist(ftpbuf_t *ftp, const char *cmd, const char *path TSRMLS_DC);
113:
114: /* IP and port conversion box */
115: union ipbox {
116: struct in_addr ia[2];
117: unsigned short s[4];
118: unsigned char c[8];
119: };
120:
121: /* {{{ ftp_open
122: */
123: ftpbuf_t*
124: ftp_open(const char *host, short port, long timeout_sec TSRMLS_DC)
125: {
126: ftpbuf_t *ftp;
127: socklen_t size;
128: struct timeval tv;
129:
130:
131: /* alloc the ftp structure */
132: ftp = ecalloc(1, sizeof(*ftp));
133:
134: tv.tv_sec = timeout_sec;
135: tv.tv_usec = 0;
136:
137: ftp->fd = php_network_connect_socket_to_host(host,
138: (unsigned short) (port ? port : 21), SOCK_STREAM,
139: 0, &tv, NULL, NULL, NULL, 0 TSRMLS_CC);
140: if (ftp->fd == -1) {
141: goto bail;
142: }
143:
144: /* Default Settings */
145: ftp->timeout_sec = timeout_sec;
146: ftp->nb = 0;
147:
148: size = sizeof(ftp->localaddr);
149: memset(&ftp->localaddr, 0, size);
150: if (getsockname(ftp->fd, (struct sockaddr*) &ftp->localaddr, &size) != 0) {
151: php_error_docref(NULL TSRMLS_CC, E_WARNING, "getsockname failed: %s (%d)", strerror(errno), errno);
152: goto bail;
153: }
154:
155: if (!ftp_getresp(ftp) || ftp->resp != 220) {
156: goto bail;
157: }
158:
159: return ftp;
160:
161: bail:
162: if (ftp->fd != -1) {
163: closesocket(ftp->fd);
164: }
165: efree(ftp);
166: return NULL;
167: }
168: /* }}} */
169:
170: /* {{{ ftp_close
171: */
172: ftpbuf_t*
173: ftp_close(ftpbuf_t *ftp)
174: {
175: if (ftp == NULL) {
176: return NULL;
177: }
178: if (ftp->data) {
179: data_close(ftp, ftp->data);
180: }
181: if (ftp->fd != -1) {
182: #if HAVE_OPENSSL_EXT
183: if (ftp->ssl_active) {
184: SSL_shutdown(ftp->ssl_handle);
185: }
186: #endif
187: closesocket(ftp->fd);
188: }
189: ftp_gc(ftp);
190: efree(ftp);
191: return NULL;
192: }
193: /* }}} */
194:
195: /* {{{ ftp_gc
196: */
197: void
198: ftp_gc(ftpbuf_t *ftp)
199: {
200: if (ftp == NULL) {
201: return;
202: }
203: if (ftp->pwd) {
204: efree(ftp->pwd);
205: ftp->pwd = NULL;
206: }
207: if (ftp->syst) {
208: efree(ftp->syst);
209: ftp->syst = NULL;
210: }
211: }
212: /* }}} */
213:
214: /* {{{ ftp_quit
215: */
216: int
217: ftp_quit(ftpbuf_t *ftp)
218: {
219: if (ftp == NULL) {
220: return 0;
221: }
222:
223: if (!ftp_putcmd(ftp, "QUIT", NULL)) {
224: return 0;
225: }
226: if (!ftp_getresp(ftp) || ftp->resp != 221) {
227: return 0;
228: }
229:
230: if (ftp->pwd) {
231: efree(ftp->pwd);
232: ftp->pwd = NULL;
233: }
234:
235: return 1;
236: }
237: /* }}} */
238:
239: /* {{{ ftp_login
240: */
241: int
242: ftp_login(ftpbuf_t *ftp, const char *user, const char *pass TSRMLS_DC)
243: {
244: #if HAVE_OPENSSL_EXT
245: SSL_CTX *ctx = NULL;
246: #endif
247: if (ftp == NULL) {
248: return 0;
249: }
250:
251: #if HAVE_OPENSSL_EXT
252: if (ftp->use_ssl && !ftp->ssl_active) {
253: if (!ftp_putcmd(ftp, "AUTH", "TLS")) {
254: return 0;
255: }
256: if (!ftp_getresp(ftp)) {
257: return 0;
258: }
259:
260: if (ftp->resp != 234) {
261: if (!ftp_putcmd(ftp, "AUTH", "SSL")) {
262: return 0;
263: }
264: if (!ftp_getresp(ftp)) {
265: return 0;
266: }
267:
268: if (ftp->resp != 334) {
269: return 0;
270: } else {
271: ftp->old_ssl = 1;
272: ftp->use_ssl_for_data = 1;
273: }
274: }
275:
276: ctx = SSL_CTX_new(SSLv23_client_method());
277: if (ctx == NULL) {
278: php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to create the SSL context");
279: return 0;
280: }
281:
282: SSL_CTX_set_options(ctx, SSL_OP_ALL);
283:
284: ftp->ssl_handle = SSL_new(ctx);
285: if (ftp->ssl_handle == NULL) {
286: php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to create the SSL handle");
287: SSL_CTX_free(ctx);
288: return 0;
289: }
290:
291: SSL_set_fd(ftp->ssl_handle, ftp->fd);
292:
293: if (SSL_connect(ftp->ssl_handle) <= 0) {
294: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SSL/TLS handshake failed");
295: SSL_shutdown(ftp->ssl_handle);
296: return 0;
297: }
298:
299: ftp->ssl_active = 1;
300:
301: if (!ftp->old_ssl) {
302:
303: /* set protection buffersize to zero */
304: if (!ftp_putcmd(ftp, "PBSZ", "0")) {
305: return 0;
306: }
307: if (!ftp_getresp(ftp)) {
308: return 0;
309: }
310:
311: /* enable data conn encryption */
312: if (!ftp_putcmd(ftp, "PROT", "P")) {
313: return 0;
314: }
315: if (!ftp_getresp(ftp)) {
316: return 0;
317: }
318:
319: ftp->use_ssl_for_data = (ftp->resp >= 200 && ftp->resp <=299);
320: }
321: }
322: #endif
323:
324: if (!ftp_putcmd(ftp, "USER", user)) {
325: return 0;
326: }
327: if (!ftp_getresp(ftp)) {
328: return 0;
329: }
330: if (ftp->resp == 230) {
331: return 1;
332: }
333: if (ftp->resp != 331) {
334: return 0;
335: }
336: if (!ftp_putcmd(ftp, "PASS", pass)) {
337: return 0;
338: }
339: if (!ftp_getresp(ftp)) {
340: return 0;
341: }
342: return (ftp->resp == 230);
343: }
344: /* }}} */
345:
346: /* {{{ ftp_reinit
347: */
348: int
349: ftp_reinit(ftpbuf_t *ftp)
350: {
351: if (ftp == NULL) {
352: return 0;
353: }
354:
355: ftp_gc(ftp);
356:
357: ftp->nb = 0;
358:
359: if (!ftp_putcmd(ftp, "REIN", NULL)) {
360: return 0;
361: }
362: if (!ftp_getresp(ftp) || ftp->resp != 220) {
363: return 0;
364: }
365:
366: return 1;
367: }
368: /* }}} */
369:
370: /* {{{ ftp_syst
371: */
372: const char*
373: ftp_syst(ftpbuf_t *ftp)
374: {
375: char *syst, *end;
376:
377: if (ftp == NULL) {
378: return NULL;
379: }
380:
381: /* default to cached value */
382: if (ftp->syst) {
383: return ftp->syst;
384: }
385: if (!ftp_putcmd(ftp, "SYST", NULL)) {
386: return NULL;
387: }
388: if (!ftp_getresp(ftp) || ftp->resp != 215) {
389: return NULL;
390: }
391: syst = ftp->inbuf;
392: while (*syst == ' ') {
393: syst++;
394: }
395: if ((end = strchr(syst, ' '))) {
396: *end = 0;
397: }
398: ftp->syst = estrdup(syst);
399: if (end) {
400: *end = ' ';
401: }
402: return ftp->syst;
403: }
404: /* }}} */
405:
406: /* {{{ ftp_pwd
407: */
408: const char*
409: ftp_pwd(ftpbuf_t *ftp)
410: {
411: char *pwd, *end;
412:
413: if (ftp == NULL) {
414: return NULL;
415: }
416:
417: /* default to cached value */
418: if (ftp->pwd) {
419: return ftp->pwd;
420: }
421: if (!ftp_putcmd(ftp, "PWD", NULL)) {
422: return NULL;
423: }
424: if (!ftp_getresp(ftp) || ftp->resp != 257) {
425: return NULL;
426: }
427: /* copy out the pwd from response */
428: if ((pwd = strchr(ftp->inbuf, '"')) == NULL) {
429: return NULL;
430: }
431: if ((end = strrchr(++pwd, '"')) == NULL) {
432: return NULL;
433: }
434: ftp->pwd = estrndup(pwd, end - pwd);
435:
436: return ftp->pwd;
437: }
438: /* }}} */
439:
440: /* {{{ ftp_exec
441: */
442: int
443: ftp_exec(ftpbuf_t *ftp, const char *cmd)
444: {
445: if (ftp == NULL) {
446: return 0;
447: }
448: if (!ftp_putcmd(ftp, "SITE EXEC", cmd)) {
449: return 0;
450: }
451: if (!ftp_getresp(ftp) || ftp->resp != 200) {
452: return 0;
453: }
454:
455: return 1;
456: }
457: /* }}} */
458:
459: /* {{{ ftp_raw
460: */
461: void
462: ftp_raw(ftpbuf_t *ftp, const char *cmd, zval *return_value)
463: {
464: if (ftp == NULL || cmd == NULL) {
465: RETURN_NULL();
466: }
467: if (!ftp_putcmd(ftp, cmd, NULL)) {
468: RETURN_NULL();
469: }
470: array_init(return_value);
471: while (ftp_readline(ftp)) {
472: add_next_index_string(return_value, ftp->inbuf, 1);
473: if (isdigit(ftp->inbuf[0]) && isdigit(ftp->inbuf[1]) && isdigit(ftp->inbuf[2]) && ftp->inbuf[3] == ' ') {
474: return;
475: }
476: }
477: }
478: /* }}} */
479:
480: /* {{{ ftp_chdir
481: */
482: int
483: ftp_chdir(ftpbuf_t *ftp, const char *dir)
484: {
485: if (ftp == NULL) {
486: return 0;
487: }
488:
489: if (ftp->pwd) {
490: efree(ftp->pwd);
491: ftp->pwd = NULL;
492: }
493:
494: if (!ftp_putcmd(ftp, "CWD", dir)) {
495: return 0;
496: }
497: if (!ftp_getresp(ftp) || ftp->resp != 250) {
498: return 0;
499: }
500: return 1;
501: }
502: /* }}} */
503:
504: /* {{{ ftp_cdup
505: */
506: int
507: ftp_cdup(ftpbuf_t *ftp)
508: {
509: if (ftp == NULL) {
510: return 0;
511: }
512:
513: if (ftp->pwd) {
514: efree(ftp->pwd);
515: ftp->pwd = NULL;
516: }
517:
518: if (!ftp_putcmd(ftp, "CDUP", NULL)) {
519: return 0;
520: }
521: if (!ftp_getresp(ftp) || ftp->resp != 250) {
522: return 0;
523: }
524: return 1;
525: }
526: /* }}} */
527:
528: /* {{{ ftp_mkdir
529: */
530: char*
531: ftp_mkdir(ftpbuf_t *ftp, const char *dir)
532: {
533: char *mkd, *end;
534:
535: if (ftp == NULL) {
536: return NULL;
537: }
538: if (!ftp_putcmd(ftp, "MKD", dir)) {
539: return NULL;
540: }
541: if (!ftp_getresp(ftp) || ftp->resp != 257) {
542: return NULL;
543: }
544: /* copy out the dir from response */
545: if ((mkd = strchr(ftp->inbuf, '"')) == NULL) {
546: mkd = estrdup(dir);
547: return mkd;
548: }
549: if ((end = strrchr(++mkd, '"')) == NULL) {
550: return NULL;
551: }
552: *end = 0;
553: mkd = estrdup(mkd);
554: *end = '"';
555:
556: return mkd;
557: }
558: /* }}} */
559:
560: /* {{{ ftp_rmdir
561: */
562: int
563: ftp_rmdir(ftpbuf_t *ftp, const char *dir)
564: {
565: if (ftp == NULL) {
566: return 0;
567: }
568: if (!ftp_putcmd(ftp, "RMD", dir)) {
569: return 0;
570: }
571: if (!ftp_getresp(ftp) || ftp->resp != 250) {
572: return 0;
573: }
574: return 1;
575: }
576: /* }}} */
577:
578: /* {{{ ftp_chmod
579: */
580: int
581: ftp_chmod(ftpbuf_t *ftp, const int mode, const char *filename, const int filename_len)
582: {
583: char *buffer;
584:
585: if (ftp == NULL || filename_len <= 0) {
586: return 0;
587: }
588:
589: spprintf(&buffer, 0, "CHMOD %o %s", mode, filename);
590:
591: if (!ftp_putcmd(ftp, "SITE", buffer)) {
592: efree(buffer);
593: return 0;
594: }
595:
596: efree(buffer);
597:
598: if (!ftp_getresp(ftp) || ftp->resp != 200) {
599: return 0;
600: }
601:
602: return 1;
603: }
604: /* }}} */
605:
606: /* {{{ ftp_alloc
607: */
608: int
609: ftp_alloc(ftpbuf_t *ftp, const int size, char **response)
610: {
611: char buffer[64];
612:
613: if (ftp == NULL || size <= 0) {
614: return 0;
615: }
616:
617: snprintf(buffer, sizeof(buffer) - 1, "%d", size);
618:
619: if (!ftp_putcmd(ftp, "ALLO", buffer)) {
620: return 0;
621: }
622:
623: if (!ftp_getresp(ftp)) {
624: return 0;
625: }
626:
627: if (response && ftp->inbuf) {
628: *response = estrdup(ftp->inbuf);
629: }
630:
631: if (ftp->resp < 200 || ftp->resp >= 300) {
632: return 0;
633: }
634:
635: return 1;
636: }
637: /* }}} */
638:
639: /* {{{ ftp_nlist
640: */
641: char**
642: ftp_nlist(ftpbuf_t *ftp, const char *path TSRMLS_DC)
643: {
644: return ftp_genlist(ftp, "NLST", path TSRMLS_CC);
645: }
646: /* }}} */
647:
648: /* {{{ ftp_list
649: */
650: char**
651: ftp_list(ftpbuf_t *ftp, const char *path, int recursive TSRMLS_DC)
652: {
653: return ftp_genlist(ftp, ((recursive) ? "LIST -R" : "LIST"), path TSRMLS_CC);
654: }
655: /* }}} */
656:
657: /* {{{ ftp_type
658: */
659: int
660: ftp_type(ftpbuf_t *ftp, ftptype_t type)
661: {
662: char typechar[2] = "?";
663:
664: if (ftp == NULL) {
665: return 0;
666: }
667: if (type == ftp->type) {
668: return 1;
669: }
670: if (type == FTPTYPE_ASCII) {
671: typechar[0] = 'A';
672: } else if (type == FTPTYPE_IMAGE) {
673: typechar[0] = 'I';
674: } else {
675: return 0;
676: }
677: if (!ftp_putcmd(ftp, "TYPE", typechar)) {
678: return 0;
679: }
680: if (!ftp_getresp(ftp) || ftp->resp != 200) {
681: return 0;
682: }
683: ftp->type = type;
684:
685: return 1;
686: }
687: /* }}} */
688:
689: /* {{{ ftp_pasv
690: */
691: int
692: ftp_pasv(ftpbuf_t *ftp, int pasv)
693: {
694: char *ptr;
695: union ipbox ipbox;
696: unsigned long b[6];
697: socklen_t n;
698: struct sockaddr *sa;
699: struct sockaddr_in *sin;
700:
701: if (ftp == NULL) {
702: return 0;
703: }
704: if (pasv && ftp->pasv == 2) {
705: return 1;
706: }
707: ftp->pasv = 0;
708: if (!pasv) {
709: return 1;
710: }
711: n = sizeof(ftp->pasvaddr);
712: memset(&ftp->pasvaddr, 0, n);
713: sa = (struct sockaddr *) &ftp->pasvaddr;
714:
715: #if HAVE_IPV6
716: if (getpeername(ftp->fd, sa, &n) < 0) {
717: return 0;
718: }
719: if (sa->sa_family == AF_INET6) {
720: struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa;
721: char *endptr, delimiter;
722:
723: /* try EPSV first */
724: if (!ftp_putcmd(ftp, "EPSV", NULL)) {
725: return 0;
726: }
727: if (!ftp_getresp(ftp)) {
728: return 0;
729: }
730: if (ftp->resp == 229) {
731: /* parse out the port */
732: for (ptr = ftp->inbuf; *ptr && *ptr != '('; ptr++);
733: if (!*ptr) {
734: return 0;
735: }
736: delimiter = *++ptr;
737: for (n = 0; *ptr && n < 3; ptr++) {
738: if (*ptr == delimiter) {
739: n++;
740: }
741: }
742:
743: sin6->sin6_port = htons((unsigned short) strtoul(ptr, &endptr, 10));
744: if (ptr == endptr || *endptr != delimiter) {
745: return 0;
746: }
747: ftp->pasv = 2;
748: return 1;
749: }
750: }
751:
752: /* fall back to PASV */
753: #endif
754:
755: if (!ftp_putcmd(ftp, "PASV", NULL)) {
756: return 0;
757: }
758: if (!ftp_getresp(ftp) || ftp->resp != 227) {
759: return 0;
760: }
761: /* parse out the IP and port */
762: for (ptr = ftp->inbuf; *ptr && !isdigit(*ptr); ptr++);
763: n = sscanf(ptr, "%lu,%lu,%lu,%lu,%lu,%lu", &b[0], &b[1], &b[2], &b[3], &b[4], &b[5]);
764: if (n != 6) {
765: return 0;
766: }
767: for (n = 0; n < 6; n++) {
768: ipbox.c[n] = (unsigned char) b[n];
769: }
770: sin = (struct sockaddr_in *) sa;
771: sin->sin_family = AF_INET;
772: sin->sin_addr = ipbox.ia[0];
773: sin->sin_port = ipbox.s[2];
774:
775: ftp->pasv = 2;
776:
777: return 1;
778: }
779: /* }}} */
780:
781: /* {{{ ftp_get
782: */
783: int
784: ftp_get(ftpbuf_t *ftp, php_stream *outstream, const char *path, ftptype_t type, int resumepos TSRMLS_DC)
785: {
786: databuf_t *data = NULL;
787: int lastch;
788: size_t rcvd;
789: char arg[11];
790:
791: if (ftp == NULL) {
792: return 0;
793: }
794: if (!ftp_type(ftp, type)) {
795: goto bail;
796: }
797:
798: if ((data = ftp_getdata(ftp TSRMLS_CC)) == NULL) {
799: goto bail;
800: }
801:
802: ftp->data = data;
803:
804: if (resumepos > 0) {
805: if (resumepos > 2147483647) {
806: php_error_docref(NULL TSRMLS_CC, E_WARNING, "PHP cannot handle files greater than 2147483647 bytes.");
807: goto bail;
808: }
809: snprintf(arg, sizeof(arg), "%u", resumepos);
810: if (!ftp_putcmd(ftp, "REST", arg)) {
811: goto bail;
812: }
813: if (!ftp_getresp(ftp) || (ftp->resp != 350)) {
814: goto bail;
815: }
816: }
817:
818: if (!ftp_putcmd(ftp, "RETR", path)) {
819: goto bail;
820: }
821: if (!ftp_getresp(ftp) || (ftp->resp != 150 && ftp->resp != 125)) {
822: goto bail;
823: }
824:
825: if ((data = data_accept(data, ftp TSRMLS_CC)) == NULL) {
826: goto bail;
827: }
828:
829: lastch = 0;
830: while ((rcvd = my_recv(ftp, data->fd, data->buf, FTP_BUFSIZE))) {
831: if (rcvd == -1) {
832: goto bail;
833: }
834:
835: if (type == FTPTYPE_ASCII) {
836: #ifndef PHP_WIN32
837: char *s;
838: #endif
839: char *ptr = data->buf;
840: char *e = ptr + rcvd;
841: /* logic depends on the OS EOL
842: * Win32 -> \r\n
843: * Everything Else \n
844: */
845: #ifdef PHP_WIN32
846: php_stream_write(outstream, ptr, (e - ptr));
847: ptr = e;
848: #else
849: while (e > ptr && (s = memchr(ptr, '\r', (e - ptr)))) {
850: php_stream_write(outstream, ptr, (s - ptr));
851: if (*(s + 1) == '\n') {
852: s++;
853: php_stream_putc(outstream, '\n');
854: }
855: ptr = s + 1;
856: }
857: #endif
858: if (ptr < e) {
859: php_stream_write(outstream, ptr, (e - ptr));
860: }
861: } else if (rcvd != php_stream_write(outstream, data->buf, rcvd)) {
862: goto bail;
863: }
864: }
865:
866: ftp->data = data = data_close(ftp, data);
867:
868: if (!ftp_getresp(ftp) || (ftp->resp != 226 && ftp->resp != 250)) {
869: goto bail;
870: }
871:
872: return 1;
873: bail:
874: ftp->data = data_close(ftp, data);
875: return 0;
876: }
877: /* }}} */
878:
879: /* {{{ ftp_put
880: */
881: int
882: ftp_put(ftpbuf_t *ftp, const char *path, php_stream *instream, ftptype_t type, int startpos TSRMLS_DC)
883: {
884: databuf_t *data = NULL;
885: int size;
886: char *ptr;
887: int ch;
888: char arg[11];
889:
890: if (ftp == NULL) {
891: return 0;
892: }
893: if (!ftp_type(ftp, type)) {
894: goto bail;
895: }
896: if ((data = ftp_getdata(ftp TSRMLS_CC)) == NULL) {
897: goto bail;
898: }
899: ftp->data = data;
900:
901: if (startpos > 0) {
902: if (startpos > 2147483647) {
903: php_error_docref(NULL TSRMLS_CC, E_WARNING, "PHP cannot handle files with a size greater than 2147483647 bytes.");
904: goto bail;
905: }
906: snprintf(arg, sizeof(arg), "%u", startpos);
907: if (!ftp_putcmd(ftp, "REST", arg)) {
908: goto bail;
909: }
910: if (!ftp_getresp(ftp) || (ftp->resp != 350)) {
911: goto bail;
912: }
913: }
914:
915: if (!ftp_putcmd(ftp, "STOR", path)) {
916: goto bail;
917: }
918: if (!ftp_getresp(ftp) || (ftp->resp != 150 && ftp->resp != 125)) {
919: goto bail;
920: }
921: if ((data = data_accept(data, ftp TSRMLS_CC)) == NULL) {
922: goto bail;
923: }
924:
925: size = 0;
926: ptr = data->buf;
927: while (!php_stream_eof(instream) && (ch = php_stream_getc(instream))!=EOF) {
928: /* flush if necessary */
929: if (FTP_BUFSIZE - size < 2) {
930: if (my_send(ftp, data->fd, data->buf, size) != size) {
931: goto bail;
932: }
933: ptr = data->buf;
934: size = 0;
935: }
936:
937: if (ch == '\n' && type == FTPTYPE_ASCII) {
938: *ptr++ = '\r';
939: size++;
940: }
941:
942: *ptr++ = ch;
943: size++;
944: }
945:
946: if (size && my_send(ftp, data->fd, data->buf, size) != size) {
947: goto bail;
948: }
949: ftp->data = data = data_close(ftp, data);
950:
951: if (!ftp_getresp(ftp) || (ftp->resp != 226 && ftp->resp != 250 && ftp->resp != 200)) {
952: goto bail;
953: }
954: return 1;
955: bail:
956: ftp->data = data_close(ftp, data);
957: return 0;
958: }
959: /* }}} */
960:
961: /* {{{ ftp_size
962: */
963: int
964: ftp_size(ftpbuf_t *ftp, const char *path)
965: {
966: if (ftp == NULL) {
967: return -1;
968: }
969: if (!ftp_type(ftp, FTPTYPE_IMAGE)) {
970: return -1;
971: }
972: if (!ftp_putcmd(ftp, "SIZE", path)) {
973: return -1;
974: }
975: if (!ftp_getresp(ftp) || ftp->resp != 213) {
976: return -1;
977: }
978: return atoi(ftp->inbuf);
979: }
980: /* }}} */
981:
982: /* {{{ ftp_mdtm
983: */
984: time_t
985: ftp_mdtm(ftpbuf_t *ftp, const char *path)
986: {
987: time_t stamp;
988: struct tm *gmt, tmbuf;
989: struct tm tm;
990: char *ptr;
991: int n;
992:
993: if (ftp == NULL) {
994: return -1;
995: }
996: if (!ftp_putcmd(ftp, "MDTM", path)) {
997: return -1;
998: }
999: if (!ftp_getresp(ftp) || ftp->resp != 213) {
1000: return -1;
1001: }
1002: /* parse out the timestamp */
1003: for (ptr = ftp->inbuf; *ptr && !isdigit(*ptr); ptr++);
1004: n = sscanf(ptr, "%4u%2u%2u%2u%2u%2u", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
1005: if (n != 6) {
1006: return -1;
1007: }
1008: tm.tm_year -= 1900;
1009: tm.tm_mon--;
1010: tm.tm_isdst = -1;
1011:
1012: /* figure out the GMT offset */
1013: stamp = time(NULL);
1014: gmt = php_gmtime_r(&stamp, &tmbuf);
1015: if (!gmt) {
1016: return -1;
1017: }
1018: gmt->tm_isdst = -1;
1019:
1020: /* apply the GMT offset */
1021: tm.tm_sec += stamp - mktime(gmt);
1022: tm.tm_isdst = gmt->tm_isdst;
1023:
1024: stamp = mktime(&tm);
1025:
1026: return stamp;
1027: }
1028: /* }}} */
1029:
1030: /* {{{ ftp_delete
1031: */
1032: int
1033: ftp_delete(ftpbuf_t *ftp, const char *path)
1034: {
1035: if (ftp == NULL) {
1036: return 0;
1037: }
1038: if (!ftp_putcmd(ftp, "DELE", path)) {
1039: return 0;
1040: }
1041: if (!ftp_getresp(ftp) || ftp->resp != 250) {
1042: return 0;
1043: }
1044:
1045: return 1;
1046: }
1047: /* }}} */
1048:
1049: /* {{{ ftp_rename
1050: */
1051: int
1052: ftp_rename(ftpbuf_t *ftp, const char *src, const char *dest)
1053: {
1054: if (ftp == NULL) {
1055: return 0;
1056: }
1057: if (!ftp_putcmd(ftp, "RNFR", src)) {
1058: return 0;
1059: }
1060: if (!ftp_getresp(ftp) || ftp->resp != 350) {
1061: return 0;
1062: }
1063: if (!ftp_putcmd(ftp, "RNTO", dest)) {
1064: return 0;
1065: }
1066: if (!ftp_getresp(ftp) || ftp->resp != 250) {
1067: return 0;
1068: }
1069: return 1;
1070: }
1071: /* }}} */
1072:
1073: /* {{{ ftp_site
1074: */
1075: int
1076: ftp_site(ftpbuf_t *ftp, const char *cmd)
1077: {
1078: if (ftp == NULL) {
1079: return 0;
1080: }
1081: if (!ftp_putcmd(ftp, "SITE", cmd)) {
1082: return 0;
1083: }
1084: if (!ftp_getresp(ftp) || ftp->resp < 200 || ftp->resp >= 300) {
1085: return 0;
1086: }
1087:
1088: return 1;
1089: }
1090: /* }}} */
1091:
1092: /* static functions */
1093:
1094: /* {{{ ftp_putcmd
1095: */
1096: int
1097: ftp_putcmd(ftpbuf_t *ftp, const char *cmd, const char *args)
1098: {
1099: int size;
1100: char *data;
1101:
1102: if (strpbrk(cmd, "\r\n")) {
1103: return 0;
1104: }
1105: /* build the output buffer */
1106: if (args && args[0]) {
1107: /* "cmd args\r\n\0" */
1108: if (strlen(cmd) + strlen(args) + 4 > FTP_BUFSIZE) {
1109: return 0;
1110: }
1111: if (strpbrk(args, "\r\n")) {
1112: return 0;
1113: }
1114: size = slprintf(ftp->outbuf, sizeof(ftp->outbuf), "%s %s\r\n", cmd, args);
1115: } else {
1116: /* "cmd\r\n\0" */
1117: if (strlen(cmd) + 3 > FTP_BUFSIZE) {
1118: return 0;
1119: }
1120: size = slprintf(ftp->outbuf, sizeof(ftp->outbuf), "%s\r\n", cmd);
1121: }
1122:
1123: data = ftp->outbuf;
1124:
1125: /* Clear the extra-lines buffer */
1126: ftp->extra = NULL;
1127:
1128: if (my_send(ftp, ftp->fd, data, size) != size) {
1129: return 0;
1130: }
1131: return 1;
1132: }
1133: /* }}} */
1134:
1135: /* {{{ ftp_readline
1136: */
1137: int
1138: ftp_readline(ftpbuf_t *ftp)
1139: {
1140: int size, rcvd;
1141: char *data, *eol;
1142:
1143: /* shift the extra to the front */
1144: size = FTP_BUFSIZE;
1145: rcvd = 0;
1146: if (ftp->extra) {
1147: memmove(ftp->inbuf, ftp->extra, ftp->extralen);
1148: rcvd = ftp->extralen;
1149: }
1150:
1151: data = ftp->inbuf;
1152:
1153: do {
1154: size -= rcvd;
1155: for (eol = data; rcvd; rcvd--, eol++) {
1156: if (*eol == '\r') {
1157: *eol = 0;
1158: ftp->extra = eol + 1;
1159: if (rcvd > 1 && *(eol + 1) == '\n') {
1160: ftp->extra++;
1161: rcvd--;
1162: }
1163: if ((ftp->extralen = --rcvd) == 0) {
1164: ftp->extra = NULL;
1165: }
1166: return 1;
1167: } else if (*eol == '\n') {
1168: *eol = 0;
1169: ftp->extra = eol + 1;
1170: if ((ftp->extralen = --rcvd) == 0) {
1171: ftp->extra = NULL;
1172: }
1173: return 1;
1174: }
1175: }
1176:
1177: data = eol;
1178: if ((rcvd = my_recv(ftp, ftp->fd, data, size)) < 1) {
1179: return 0;
1180: }
1181: } while (size);
1182:
1183: return 0;
1184: }
1185: /* }}} */
1186:
1187: /* {{{ ftp_getresp
1188: */
1189: int
1190: ftp_getresp(ftpbuf_t *ftp)
1191: {
1192: char *buf;
1193:
1194: if (ftp == NULL) {
1195: return 0;
1196: }
1197: buf = ftp->inbuf;
1198: ftp->resp = 0;
1199:
1200: while (1) {
1201:
1202: if (!ftp_readline(ftp)) {
1203: return 0;
1204: }
1205:
1206: /* Break out when the end-tag is found */
1207: if (isdigit(ftp->inbuf[0]) && isdigit(ftp->inbuf[1]) && isdigit(ftp->inbuf[2]) && ftp->inbuf[3] == ' ') {
1208: break;
1209: }
1210: }
1211:
1212: /* translate the tag */
1213: if (!isdigit(ftp->inbuf[0]) || !isdigit(ftp->inbuf[1]) || !isdigit(ftp->inbuf[2])) {
1214: return 0;
1215: }
1216:
1217: ftp->resp = 100 * (ftp->inbuf[0] - '0') + 10 * (ftp->inbuf[1] - '0') + (ftp->inbuf[2] - '0');
1218:
1219: memmove(ftp->inbuf, ftp->inbuf + 4, FTP_BUFSIZE - 4);
1220:
1221: if (ftp->extra) {
1222: ftp->extra -= 4;
1223: }
1224: return 1;
1225: }
1226: /* }}} */
1227:
1228: /* {{{ my_send
1229: */
1230: int
1231: my_send(ftpbuf_t *ftp, php_socket_t s, void *buf, size_t len)
1232: {
1233: int n, size, sent;
1234:
1235: size = len;
1236: while (size) {
1237: n = php_pollfd_for_ms(s, POLLOUT, ftp->timeout_sec * 1000);
1238:
1239: if (n < 1) {
1240:
1241: #if !defined(PHP_WIN32) && !(defined(NETWARE) && defined(USE_WINSOCK))
1242: if (n == 0) {
1243: errno = ETIMEDOUT;
1244: }
1245: #endif
1246: return -1;
1247: }
1248:
1249: #if HAVE_OPENSSL_EXT
1250: if (ftp->use_ssl && ftp->fd == s && ftp->ssl_active) {
1251: sent = SSL_write(ftp->ssl_handle, buf, size);
1252: } else if (ftp->use_ssl && ftp->fd != s && ftp->use_ssl_for_data && ftp->data->ssl_active) {
1253: sent = SSL_write(ftp->data->ssl_handle, buf, size);
1254: } else {
1255: #endif
1256: sent = send(s, buf, size, 0);
1257: #if HAVE_OPENSSL_EXT
1258: }
1259: #endif
1260: if (sent == -1) {
1261: return -1;
1262: }
1263:
1264: buf = (char*) buf + sent;
1265: size -= sent;
1266: }
1267:
1268: return len;
1269: }
1270: /* }}} */
1271:
1272: /* {{{ my_recv
1273: */
1274: int
1275: my_recv(ftpbuf_t *ftp, php_socket_t s, void *buf, size_t len)
1276: {
1277: int n, nr_bytes;
1278:
1279: n = php_pollfd_for_ms(s, PHP_POLLREADABLE, ftp->timeout_sec * 1000);
1280: if (n < 1) {
1281: #if !defined(PHP_WIN32) && !(defined(NETWARE) && defined(USE_WINSOCK))
1282: if (n == 0) {
1283: errno = ETIMEDOUT;
1284: }
1285: #endif
1286: return -1;
1287: }
1288:
1289: #if HAVE_OPENSSL_EXT
1290: if (ftp->use_ssl && ftp->fd == s && ftp->ssl_active) {
1291: nr_bytes = SSL_read(ftp->ssl_handle, buf, len);
1292: } else if (ftp->use_ssl && ftp->fd != s && ftp->use_ssl_for_data && ftp->data->ssl_active) {
1293: nr_bytes = SSL_read(ftp->data->ssl_handle, buf, len);
1294: } else {
1295: #endif
1296: nr_bytes = recv(s, buf, len, 0);
1297: #if HAVE_OPENSSL_EXT
1298: }
1299: #endif
1300: return (nr_bytes);
1301: }
1302: /* }}} */
1303:
1304: /* {{{ data_available
1305: */
1306: int
1307: data_available(ftpbuf_t *ftp, php_socket_t s)
1308: {
1309: int n;
1310:
1311: n = php_pollfd_for_ms(s, PHP_POLLREADABLE, 1000);
1312: if (n < 1) {
1313: #if !defined(PHP_WIN32) && !(defined(NETWARE) && defined(USE_WINSOCK))
1314: if (n == 0) {
1315: errno = ETIMEDOUT;
1316: }
1317: #endif
1318: return 0;
1319: }
1320:
1321: return 1;
1322: }
1323: /* }}} */
1324: /* {{{ data_writeable
1325: */
1326: int
1327: data_writeable(ftpbuf_t *ftp, php_socket_t s)
1328: {
1329: int n;
1330:
1331: n = php_pollfd_for_ms(s, POLLOUT, 1000);
1332: if (n < 1) {
1333: #ifndef PHP_WIN32
1334: if (n == 0) {
1335: errno = ETIMEDOUT;
1336: }
1337: #endif
1338: return 0;
1339: }
1340:
1341: return 1;
1342: }
1343: /* }}} */
1344:
1345: /* {{{ my_accept
1346: */
1347: int
1348: my_accept(ftpbuf_t *ftp, php_socket_t s, struct sockaddr *addr, socklen_t *addrlen)
1349: {
1350: int n;
1351:
1352: n = php_pollfd_for_ms(s, PHP_POLLREADABLE, ftp->timeout_sec * 1000);
1353: if (n < 1) {
1354: #if !defined(PHP_WIN32) && !(defined(NETWARE) && defined(USE_WINSOCK))
1355: if (n == 0) {
1356: errno = ETIMEDOUT;
1357: }
1358: #endif
1359: return -1;
1360: }
1361:
1362: return accept(s, addr, addrlen);
1363: }
1364: /* }}} */
1365:
1366: /* {{{ ftp_getdata
1367: */
1368: databuf_t*
1369: ftp_getdata(ftpbuf_t *ftp TSRMLS_DC)
1370: {
1371: int fd = -1;
1372: databuf_t *data;
1373: php_sockaddr_storage addr;
1374: struct sockaddr *sa;
1375: socklen_t size;
1376: union ipbox ipbox;
1377: char arg[sizeof("255, 255, 255, 255, 255, 255")];
1378: struct timeval tv;
1379:
1380:
1381: /* ask for a passive connection if we need one */
1382: if (ftp->pasv && !ftp_pasv(ftp, 1)) {
1383: return NULL;
1384: }
1385: /* alloc the data structure */
1386: data = ecalloc(1, sizeof(*data));
1387: data->listener = -1;
1388: data->fd = -1;
1389: data->type = ftp->type;
1390:
1391: sa = (struct sockaddr *) &ftp->localaddr;
1392: /* bind/listen */
1393: if ((fd = socket(sa->sa_family, SOCK_STREAM, 0)) == SOCK_ERR) {
1394: php_error_docref(NULL TSRMLS_CC, E_WARNING, "socket() failed: %s (%d)", strerror(errno), errno);
1395: goto bail;
1396: }
1397:
1398: /* passive connection handler */
1399: if (ftp->pasv) {
1400: /* clear the ready status */
1401: ftp->pasv = 1;
1402:
1403: /* connect */
1404: /* Win 95/98 seems not to like size > sizeof(sockaddr_in) */
1405: size = php_sockaddr_size(&ftp->pasvaddr);
1406: tv.tv_sec = ftp->timeout_sec;
1407: tv.tv_usec = 0;
1408: if (php_connect_nonb(fd, (struct sockaddr*) &ftp->pasvaddr, size, &tv) == -1) {
1409: php_error_docref(NULL TSRMLS_CC, E_WARNING, "php_connect_nonb() failed: %s (%d)", strerror(errno), errno);
1410: goto bail;
1411: }
1412:
1413: data->fd = fd;
1414:
1415: ftp->data = data;
1416: return data;
1417: }
1418:
1419:
1420: /* active (normal) connection */
1421:
1422: /* bind to a local address */
1423: php_any_addr(sa->sa_family, &addr, 0);
1424: size = php_sockaddr_size(&addr);
1425:
1426: if (bind(fd, (struct sockaddr*) &addr, size) != 0) {
1427: php_error_docref(NULL TSRMLS_CC, E_WARNING, "bind() failed: %s (%d)", strerror(errno), errno);
1428: goto bail;
1429: }
1430:
1431: if (getsockname(fd, (struct sockaddr*) &addr, &size) != 0) {
1432: php_error_docref(NULL TSRMLS_CC, E_WARNING, "getsockname() failed: %s (%d)", strerror(errno), errno);
1433: goto bail;
1434: }
1435:
1436: if (listen(fd, 5) != 0) {
1437: php_error_docref(NULL TSRMLS_CC, E_WARNING, "listen() failed: %s (%d)", strerror(errno), errno);
1438: goto bail;
1439: }
1440:
1441: data->listener = fd;
1442:
1443: #if HAVE_IPV6 && HAVE_INET_NTOP
1444: if (sa->sa_family == AF_INET6) {
1445: /* need to use EPRT */
1446: char eprtarg[INET6_ADDRSTRLEN + sizeof("|x||xxxxx|")];
1447: char out[INET6_ADDRSTRLEN];
1448: inet_ntop(AF_INET6, &((struct sockaddr_in6*) sa)->sin6_addr, out, sizeof(out));
1449: snprintf(eprtarg, sizeof(eprtarg), "|2|%s|%hu|", out, ntohs(((struct sockaddr_in6 *) &addr)->sin6_port));
1450:
1451: if (!ftp_putcmd(ftp, "EPRT", eprtarg)) {
1452: goto bail;
1453: }
1454:
1455: if (!ftp_getresp(ftp) || ftp->resp != 200) {
1456: goto bail;
1457: }
1458:
1459: ftp->data = data;
1460: return data;
1461: }
1462: #endif
1463:
1464: /* send the PORT */
1465: ipbox.ia[0] = ((struct sockaddr_in*) sa)->sin_addr;
1466: ipbox.s[2] = ((struct sockaddr_in*) &addr)->sin_port;
1467: snprintf(arg, sizeof(arg), "%u,%u,%u,%u,%u,%u", ipbox.c[0], ipbox.c[1], ipbox.c[2], ipbox.c[3], ipbox.c[4], ipbox.c[5]);
1468:
1469: if (!ftp_putcmd(ftp, "PORT", arg)) {
1470: goto bail;
1471: }
1472: if (!ftp_getresp(ftp) || ftp->resp != 200) {
1473: goto bail;
1474: }
1475:
1476: ftp->data = data;
1477: return data;
1478:
1479: bail:
1480: if (fd != -1) {
1481: closesocket(fd);
1482: }
1483: efree(data);
1484: return NULL;
1485: }
1486: /* }}} */
1487:
1488: /* {{{ data_accept
1489: */
1490: databuf_t*
1491: data_accept(databuf_t *data, ftpbuf_t *ftp TSRMLS_DC)
1492: {
1493: php_sockaddr_storage addr;
1494: socklen_t size;
1495:
1496: #if HAVE_OPENSSL_EXT
1497: SSL_CTX *ctx;
1498: #endif
1499:
1500: if (data->fd != -1) {
1501: goto data_accepted;
1502: }
1503: size = sizeof(addr);
1504: data->fd = my_accept(ftp, data->listener, (struct sockaddr*) &addr, &size);
1505: closesocket(data->listener);
1506: data->listener = -1;
1507:
1508: if (data->fd == -1) {
1509: efree(data);
1510: return NULL;
1511: }
1512:
1513: data_accepted:
1514: #if HAVE_OPENSSL_EXT
1515:
1516: /* now enable ssl if we need to */
1517: if (ftp->use_ssl && ftp->use_ssl_for_data) {
1518: ctx = SSL_CTX_new(SSLv23_client_method());
1519: if (ctx == NULL) {
1520: php_error_docref(NULL TSRMLS_CC, E_WARNING, "data_accept: failed to create the SSL context");
1521: return 0;
1522: }
1523:
1524: SSL_CTX_set_options(ctx, SSL_OP_ALL);
1525:
1526: data->ssl_handle = SSL_new(ctx);
1527: if (data->ssl_handle == NULL) {
1528: php_error_docref(NULL TSRMLS_CC, E_WARNING, "data_accept: failed to create the SSL handle");
1529: SSL_CTX_free(ctx);
1530: return 0;
1531: }
1532:
1533:
1534: SSL_set_fd(data->ssl_handle, data->fd);
1535:
1536: if (ftp->old_ssl) {
1537: SSL_copy_session_id(data->ssl_handle, ftp->ssl_handle);
1538: }
1539:
1540: if (SSL_connect(data->ssl_handle) <= 0) {
1541: php_error_docref(NULL TSRMLS_CC, E_WARNING, "data_accept: SSL/TLS handshake failed");
1542: SSL_shutdown(data->ssl_handle);
1543: return 0;
1544: }
1545:
1546: data->ssl_active = 1;
1547: }
1548:
1549: #endif
1550:
1551: return data;
1552: }
1553: /* }}} */
1554:
1555: /* {{{ data_close
1556: */
1557: databuf_t*
1558: data_close(ftpbuf_t *ftp, databuf_t *data)
1559: {
1560: if (data == NULL) {
1561: return NULL;
1562: }
1563: if (data->listener != -1) {
1564: #if HAVE_OPENSSL_EXT
1565: if (data->ssl_active) {
1566: SSL_shutdown(data->ssl_handle);
1567: data->ssl_active = 0;
1568: }
1569: #endif
1570: closesocket(data->listener);
1571: }
1572: if (data->fd != -1) {
1573: #if HAVE_OPENSSL_EXT
1574: if (data->ssl_active) {
1575: SSL_shutdown(data->ssl_handle);
1576: data->ssl_active = 0;
1577: }
1578: #endif
1579: closesocket(data->fd);
1580: }
1581: if (ftp) {
1582: ftp->data = NULL;
1583: }
1584: efree(data);
1585: return NULL;
1586: }
1587: /* }}} */
1588:
1589: /* {{{ ftp_genlist
1590: */
1591: char**
1592: ftp_genlist(ftpbuf_t *ftp, const char *cmd, const char *path TSRMLS_DC)
1593: {
1594: php_stream *tmpstream = NULL;
1595: databuf_t *data = NULL;
1596: char *ptr;
1597: int ch, lastch;
1598: int size, rcvd;
1599: int lines;
1600: char **ret = NULL;
1601: char **entry;
1602: char *text;
1603:
1604:
1605: if ((tmpstream = php_stream_fopen_tmpfile()) == NULL) {
1606: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to create temporary file. Check permissions in temporary files directory.");
1607: return NULL;
1608: }
1609:
1610: if (!ftp_type(ftp, FTPTYPE_ASCII)) {
1611: goto bail;
1612: }
1613:
1614: if ((data = ftp_getdata(ftp TSRMLS_CC)) == NULL) {
1615: goto bail;
1616: }
1617: ftp->data = data;
1618:
1619: if (!ftp_putcmd(ftp, cmd, path)) {
1620: goto bail;
1621: }
1622: if (!ftp_getresp(ftp) || (ftp->resp != 150 && ftp->resp != 125 && ftp->resp != 226)) {
1623: goto bail;
1624: }
1625:
1626: /* some servers don't open a ftp-data connection if the directory is empty */
1627: if (ftp->resp == 226) {
1628: ftp->data = data_close(ftp, data);
1629: php_stream_close(tmpstream);
1630: return ecalloc(1, sizeof(char**));
1631: }
1632:
1633: /* pull data buffer into tmpfile */
1634: if ((data = data_accept(data, ftp TSRMLS_CC)) == NULL) {
1635: goto bail;
1636: }
1637: size = 0;
1638: lines = 0;
1639: lastch = 0;
1640: while ((rcvd = my_recv(ftp, data->fd, data->buf, FTP_BUFSIZE))) {
1641: if (rcvd == -1) {
1642: goto bail;
1643: }
1644:
1645: php_stream_write(tmpstream, data->buf, rcvd);
1646:
1647: size += rcvd;
1648: for (ptr = data->buf; rcvd; rcvd--, ptr++) {
1649: if (*ptr == '\n' && lastch == '\r') {
1650: lines++;
1651: } else {
1652: size++;
1653: }
1654: lastch = *ptr;
1655: }
1656: }
1657:
1658: ftp->data = data = data_close(ftp, data);
1659:
1660: php_stream_rewind(tmpstream);
1661:
1662: ret = safe_emalloc((lines + 1), sizeof(char**), size * sizeof(char*));
1663:
1664: entry = ret;
1665: text = (char*) (ret + lines + 1);
1666: *entry = text;
1667: lastch = 0;
1668: while ((ch = php_stream_getc(tmpstream)) != EOF) {
1669: if (ch == '\n' && lastch == '\r') {
1670: *(text - 1) = 0;
1671: *++entry = text;
1672: } else {
1673: *text++ = ch;
1674: }
1675: lastch = ch;
1676: }
1677: *entry = NULL;
1678:
1679: php_stream_close(tmpstream);
1680:
1681: if (!ftp_getresp(ftp) || (ftp->resp != 226 && ftp->resp != 250)) {
1682: efree(ret);
1683: return NULL;
1684: }
1685:
1686: return ret;
1687: bail:
1688: ftp->data = data_close(ftp, data);
1689: php_stream_close(tmpstream);
1690: if (ret)
1691: efree(ret);
1692: return NULL;
1693: }
1694: /* }}} */
1695:
1696: /* {{{ ftp_nb_get
1697: */
1698: int
1699: ftp_nb_get(ftpbuf_t *ftp, php_stream *outstream, const char *path, ftptype_t type, int resumepos TSRMLS_DC)
1700: {
1701: databuf_t *data = NULL;
1702: char arg[11];
1703:
1704: if (ftp == NULL) {
1705: return PHP_FTP_FAILED;
1706: }
1707:
1708: if (!ftp_type(ftp, type)) {
1709: goto bail;
1710: }
1711:
1712: if ((data = ftp_getdata(ftp TSRMLS_CC)) == NULL) {
1713: goto bail;
1714: }
1715:
1716: if (resumepos>0) {
1717: /* We are working on an architecture that supports 64-bit integers
1718: * since php is 32 bit by design, we bail out with warning
1719: */
1720: if (resumepos > 2147483647) {
1721: php_error_docref(NULL TSRMLS_CC, E_WARNING, "PHP cannot handle files greater than 2147483648 bytes.");
1722: goto bail;
1723: }
1724: snprintf(arg, sizeof(arg), "%u", resumepos);
1725: if (!ftp_putcmd(ftp, "REST", arg)) {
1726: goto bail;
1727: }
1728: if (!ftp_getresp(ftp) || (ftp->resp != 350)) {
1729: goto bail;
1730: }
1731: }
1732:
1733: if (!ftp_putcmd(ftp, "RETR", path)) {
1734: goto bail;
1735: }
1736: if (!ftp_getresp(ftp) || (ftp->resp != 150 && ftp->resp != 125)) {
1737: goto bail;
1738: }
1739:
1740: if ((data = data_accept(data, ftp TSRMLS_CC)) == NULL) {
1741: goto bail;
1742: }
1743:
1744: ftp->data = data;
1745: ftp->stream = outstream;
1746: ftp->lastch = 0;
1747: ftp->nb = 1;
1748:
1749: return (ftp_nb_continue_read(ftp TSRMLS_CC));
1750:
1751: bail:
1752: ftp->data = data_close(ftp, data);
1753: return PHP_FTP_FAILED;
1754: }
1755: /* }}} */
1756:
1757: /* {{{ ftp_nb_continue_read
1758: */
1759: int
1760: ftp_nb_continue_read(ftpbuf_t *ftp TSRMLS_DC)
1761: {
1762: databuf_t *data = NULL;
1763: char *ptr;
1764: int lastch;
1765: size_t rcvd;
1766: ftptype_t type;
1767:
1768: data = ftp->data;
1769:
1770: /* check if there is already more data */
1771: if (!data_available(ftp, data->fd)) {
1772: return PHP_FTP_MOREDATA;
1773: }
1774:
1775: type = ftp->type;
1776:
1777: lastch = ftp->lastch;
1778: if ((rcvd = my_recv(ftp, data->fd, data->buf, FTP_BUFSIZE))) {
1779: if (rcvd == -1) {
1780: goto bail;
1781: }
1782:
1783: if (type == FTPTYPE_ASCII) {
1784: for (ptr = data->buf; rcvd; rcvd--, ptr++) {
1785: if (lastch == '\r' && *ptr != '\n') {
1786: php_stream_putc(ftp->stream, '\r');
1787: }
1788: if (*ptr != '\r') {
1789: php_stream_putc(ftp->stream, *ptr);
1790: }
1791: lastch = *ptr;
1792: }
1793: } else if (rcvd != php_stream_write(ftp->stream, data->buf, rcvd)) {
1794: goto bail;
1795: }
1796:
1797: ftp->lastch = lastch;
1798: return PHP_FTP_MOREDATA;
1799: }
1800:
1801: if (type == FTPTYPE_ASCII && lastch == '\r') {
1802: php_stream_putc(ftp->stream, '\r');
1803: }
1804:
1805: ftp->data = data = data_close(ftp, data);
1806:
1807: if (!ftp_getresp(ftp) || (ftp->resp != 226 && ftp->resp != 250)) {
1808: goto bail;
1809: }
1810:
1811: ftp->nb = 0;
1812: return PHP_FTP_FINISHED;
1813: bail:
1814: ftp->nb = 0;
1815: ftp->data = data_close(ftp, data);
1816: return PHP_FTP_FAILED;
1817: }
1818: /* }}} */
1819:
1820: /* {{{ ftp_nb_put
1821: */
1822: int
1823: ftp_nb_put(ftpbuf_t *ftp, const char *path, php_stream *instream, ftptype_t type, int startpos TSRMLS_DC)
1824: {
1825: databuf_t *data = NULL;
1826: char arg[11];
1827:
1828: if (ftp == NULL) {
1829: return 0;
1830: }
1831: if (!ftp_type(ftp, type)) {
1832: goto bail;
1833: }
1834: if ((data = ftp_getdata(ftp TSRMLS_CC)) == NULL) {
1835: goto bail;
1836: }
1837: if (startpos > 0) {
1838: if (startpos > 2147483647) {
1839: php_error_docref(NULL TSRMLS_CC, E_WARNING, "PHP cannot handle files with a size greater than 2147483647 bytes.");
1840: goto bail;
1841: }
1842: snprintf(arg, sizeof(arg), "%u", startpos);
1843: if (!ftp_putcmd(ftp, "REST", arg)) {
1844: goto bail;
1845: }
1846: if (!ftp_getresp(ftp) || (ftp->resp != 350)) {
1847: goto bail;
1848: }
1849: }
1850:
1851: if (!ftp_putcmd(ftp, "STOR", path)) {
1852: goto bail;
1853: }
1854: if (!ftp_getresp(ftp) || (ftp->resp != 150 && ftp->resp != 125)) {
1855: goto bail;
1856: }
1857: if ((data = data_accept(data, ftp TSRMLS_CC)) == NULL) {
1858: goto bail;
1859: }
1860: ftp->data = data;
1861: ftp->stream = instream;
1862: ftp->lastch = 0;
1863: ftp->nb = 1;
1864:
1865: return (ftp_nb_continue_write(ftp TSRMLS_CC));
1866:
1867: bail:
1868: ftp->data = data_close(ftp, data);
1869: return PHP_FTP_FAILED;
1870: }
1871: /* }}} */
1872:
1873:
1874: /* {{{ ftp_nb_continue_write
1875: */
1876: int
1877: ftp_nb_continue_write(ftpbuf_t *ftp TSRMLS_DC)
1878: {
1879: int size;
1880: char *ptr;
1881: int ch;
1882:
1883: /* check if we can write more data */
1884: if (!data_writeable(ftp, ftp->data->fd)) {
1885: return PHP_FTP_MOREDATA;
1886: }
1887:
1888: size = 0;
1889: ptr = ftp->data->buf;
1890: while (!php_stream_eof(ftp->stream) && (ch = php_stream_getc(ftp->stream)) != EOF) {
1891:
1892: if (ch == '\n' && ftp->type == FTPTYPE_ASCII) {
1893: *ptr++ = '\r';
1894: size++;
1895: }
1896:
1897: *ptr++ = ch;
1898: size++;
1899:
1900: /* flush if necessary */
1901: if (FTP_BUFSIZE - size < 2) {
1902: if (my_send(ftp, ftp->data->fd, ftp->data->buf, size) != size) {
1903: goto bail;
1904: }
1905: return PHP_FTP_MOREDATA;
1906: }
1907: }
1908:
1909: if (size && my_send(ftp, ftp->data->fd, ftp->data->buf, size) != size) {
1910: goto bail;
1911: }
1912: ftp->data = data_close(ftp, ftp->data);
1913:
1914: if (!ftp_getresp(ftp) || (ftp->resp != 226 && ftp->resp != 250)) {
1915: goto bail;
1916: }
1917: ftp->nb = 0;
1918: return PHP_FTP_FINISHED;
1919: bail:
1920: ftp->data = data_close(ftp, ftp->data);
1921: ftp->nb = 0;
1922: return PHP_FTP_FAILED;
1923: }
1924: /* }}} */
1925:
1926: #endif /* HAVE_FTP */
1927:
1928: /*
1929: * Local variables:
1930: * tab-width: 4
1931: * c-basic-offset: 4
1932: * End:
1933: * vim600: sw=4 ts=4 fdm=marker
1934: * vim<600: sw=4 ts=4
1935: */