1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
9: *
10: * This software is licensed as described in the file COPYING, which
11: * you should have received as part of this distribution. The terms
12: * are also available at https://curl.haxx.se/docs/copyright.html.
13: *
14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15: * copies of the Software, and permit persons to whom the Software is
16: * furnished to do so, under the terms of the COPYING file.
17: *
18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: * KIND, either express or implied.
20: *
21: ***************************************************************************/
22:
23: /**
24: * Now implemented:
25: *
26: * 1) Unix version 1
27: * drwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog
28: * 2) Unix version 2
29: * drwxr-xr-x 1 user01 ftp 512 Jan 29 1997 prog
30: * 3) Unix version 3
31: * drwxr-xr-x 1 1 1 512 Jan 29 23:32 prog
32: * 4) Unix symlink
33: * lrwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog -> prog2000
34: * 5) DOS style
35: * 01-29-97 11:32PM <DIR> prog
36: */
37:
38: #include "curl_setup.h"
39:
40: #ifndef CURL_DISABLE_FTP
41:
42: #include <curl/curl.h>
43:
44: #include "urldata.h"
45: #include "fileinfo.h"
46: #include "llist.h"
47: #include "strtoofft.h"
48: #include "ftp.h"
49: #include "ftplistparser.h"
50: #include "curl_fnmatch.h"
51: #include "curl_memory.h"
52: #include "multiif.h"
53: /* The last #include file should be: */
54: #include "memdebug.h"
55:
56: /* allocs buffer which will contain one line of LIST command response */
57: #define FTP_BUFFER_ALLOCSIZE 160
58:
59: typedef enum {
60: PL_UNIX_TOTALSIZE = 0,
61: PL_UNIX_FILETYPE,
62: PL_UNIX_PERMISSION,
63: PL_UNIX_HLINKS,
64: PL_UNIX_USER,
65: PL_UNIX_GROUP,
66: PL_UNIX_SIZE,
67: PL_UNIX_TIME,
68: PL_UNIX_FILENAME,
69: PL_UNIX_SYMLINK
70: } pl_unix_mainstate;
71:
72: typedef union {
73: enum {
74: PL_UNIX_TOTALSIZE_INIT = 0,
75: PL_UNIX_TOTALSIZE_READING
76: } total_dirsize;
77:
78: enum {
79: PL_UNIX_HLINKS_PRESPACE = 0,
80: PL_UNIX_HLINKS_NUMBER
81: } hlinks;
82:
83: enum {
84: PL_UNIX_USER_PRESPACE = 0,
85: PL_UNIX_USER_PARSING
86: } user;
87:
88: enum {
89: PL_UNIX_GROUP_PRESPACE = 0,
90: PL_UNIX_GROUP_NAME
91: } group;
92:
93: enum {
94: PL_UNIX_SIZE_PRESPACE = 0,
95: PL_UNIX_SIZE_NUMBER
96: } size;
97:
98: enum {
99: PL_UNIX_TIME_PREPART1 = 0,
100: PL_UNIX_TIME_PART1,
101: PL_UNIX_TIME_PREPART2,
102: PL_UNIX_TIME_PART2,
103: PL_UNIX_TIME_PREPART3,
104: PL_UNIX_TIME_PART3
105: } time;
106:
107: enum {
108: PL_UNIX_FILENAME_PRESPACE = 0,
109: PL_UNIX_FILENAME_NAME,
110: PL_UNIX_FILENAME_WINDOWSEOL
111: } filename;
112:
113: enum {
114: PL_UNIX_SYMLINK_PRESPACE = 0,
115: PL_UNIX_SYMLINK_NAME,
116: PL_UNIX_SYMLINK_PRETARGET1,
117: PL_UNIX_SYMLINK_PRETARGET2,
118: PL_UNIX_SYMLINK_PRETARGET3,
119: PL_UNIX_SYMLINK_PRETARGET4,
120: PL_UNIX_SYMLINK_TARGET,
121: PL_UNIX_SYMLINK_WINDOWSEOL
122: } symlink;
123: } pl_unix_substate;
124:
125: typedef enum {
126: PL_WINNT_DATE = 0,
127: PL_WINNT_TIME,
128: PL_WINNT_DIRORSIZE,
129: PL_WINNT_FILENAME
130: } pl_winNT_mainstate;
131:
132: typedef union {
133: enum {
134: PL_WINNT_TIME_PRESPACE = 0,
135: PL_WINNT_TIME_TIME
136: } time;
137: enum {
138: PL_WINNT_DIRORSIZE_PRESPACE = 0,
139: PL_WINNT_DIRORSIZE_CONTENT
140: } dirorsize;
141: enum {
142: PL_WINNT_FILENAME_PRESPACE = 0,
143: PL_WINNT_FILENAME_CONTENT,
144: PL_WINNT_FILENAME_WINEOL
145: } filename;
146: } pl_winNT_substate;
147:
148: /* This struct is used in wildcard downloading - for parsing LIST response */
149: struct ftp_parselist_data {
150: enum {
151: OS_TYPE_UNKNOWN = 0,
152: OS_TYPE_UNIX,
153: OS_TYPE_WIN_NT
154: } os_type;
155:
156: union {
157: struct {
158: pl_unix_mainstate main;
159: pl_unix_substate sub;
160: } UNIX;
161:
162: struct {
163: pl_winNT_mainstate main;
164: pl_winNT_substate sub;
165: } NT;
166: } state;
167:
168: CURLcode error;
169: struct fileinfo *file_data;
170: unsigned int item_length;
171: size_t item_offset;
172: struct {
173: size_t filename;
174: size_t user;
175: size_t group;
176: size_t time;
177: size_t perm;
178: size_t symlink_target;
179: } offsets;
180: };
181:
182: struct ftp_parselist_data *Curl_ftp_parselist_data_alloc(void)
183: {
184: return calloc(1, sizeof(struct ftp_parselist_data));
185: }
186:
187:
188: void Curl_ftp_parselist_data_free(struct ftp_parselist_data **parserp)
189: {
190: struct ftp_parselist_data *parser = *parserp;
191: if(parser)
192: Curl_fileinfo_cleanup(parser->file_data);
193: free(parser);
194: *parserp = NULL;
195: }
196:
197:
198: CURLcode Curl_ftp_parselist_geterror(struct ftp_parselist_data *pl_data)
199: {
200: return pl_data->error;
201: }
202:
203:
204: #define FTP_LP_MALFORMATED_PERM 0x01000000
205:
206: static int ftp_pl_get_permission(const char *str)
207: {
208: int permissions = 0;
209: /* USER */
210: if(str[0] == 'r')
211: permissions |= 1 << 8;
212: else if(str[0] != '-')
213: permissions |= FTP_LP_MALFORMATED_PERM;
214: if(str[1] == 'w')
215: permissions |= 1 << 7;
216: else if(str[1] != '-')
217: permissions |= FTP_LP_MALFORMATED_PERM;
218:
219: if(str[2] == 'x')
220: permissions |= 1 << 6;
221: else if(str[2] == 's') {
222: permissions |= 1 << 6;
223: permissions |= 1 << 11;
224: }
225: else if(str[2] == 'S')
226: permissions |= 1 << 11;
227: else if(str[2] != '-')
228: permissions |= FTP_LP_MALFORMATED_PERM;
229: /* GROUP */
230: if(str[3] == 'r')
231: permissions |= 1 << 5;
232: else if(str[3] != '-')
233: permissions |= FTP_LP_MALFORMATED_PERM;
234: if(str[4] == 'w')
235: permissions |= 1 << 4;
236: else if(str[4] != '-')
237: permissions |= FTP_LP_MALFORMATED_PERM;
238: if(str[5] == 'x')
239: permissions |= 1 << 3;
240: else if(str[5] == 's') {
241: permissions |= 1 << 3;
242: permissions |= 1 << 10;
243: }
244: else if(str[5] == 'S')
245: permissions |= 1 << 10;
246: else if(str[5] != '-')
247: permissions |= FTP_LP_MALFORMATED_PERM;
248: /* others */
249: if(str[6] == 'r')
250: permissions |= 1 << 2;
251: else if(str[6] != '-')
252: permissions |= FTP_LP_MALFORMATED_PERM;
253: if(str[7] == 'w')
254: permissions |= 1 << 1;
255: else if(str[7] != '-')
256: permissions |= FTP_LP_MALFORMATED_PERM;
257: if(str[8] == 'x')
258: permissions |= 1;
259: else if(str[8] == 't') {
260: permissions |= 1;
261: permissions |= 1 << 9;
262: }
263: else if(str[8] == 'T')
264: permissions |= 1 << 9;
265: else if(str[8] != '-')
266: permissions |= FTP_LP_MALFORMATED_PERM;
267:
268: return permissions;
269: }
270:
271: static CURLcode ftp_pl_insert_finfo(struct connectdata *conn,
272: struct fileinfo *infop)
273: {
274: curl_fnmatch_callback compare;
275: struct WildcardData *wc = &conn->data->wildcard;
276: struct ftp_wc *ftpwc = wc->protdata;
277: struct curl_llist *llist = &wc->filelist;
278: struct ftp_parselist_data *parser = ftpwc->parser;
279: bool add = TRUE;
280: struct curl_fileinfo *finfo = &infop->info;
281:
282: /* move finfo pointers to b_data */
283: char *str = finfo->b_data;
284: finfo->filename = str + parser->offsets.filename;
285: finfo->strings.group = parser->offsets.group ?
286: str + parser->offsets.group : NULL;
287: finfo->strings.perm = parser->offsets.perm ?
288: str + parser->offsets.perm : NULL;
289: finfo->strings.target = parser->offsets.symlink_target ?
290: str + parser->offsets.symlink_target : NULL;
291: finfo->strings.time = str + parser->offsets.time;
292: finfo->strings.user = parser->offsets.user ?
293: str + parser->offsets.user : NULL;
294:
295: /* get correct fnmatch callback */
296: compare = conn->data->set.fnmatch;
297: if(!compare)
298: compare = Curl_fnmatch;
299:
300: /* filter pattern-corresponding filenames */
301: Curl_set_in_callback(conn->data, true);
302: if(compare(conn->data->set.fnmatch_data, wc->pattern,
303: finfo->filename) == 0) {
304: /* discard symlink which is containing multiple " -> " */
305: if((finfo->filetype == CURLFILETYPE_SYMLINK) && finfo->strings.target &&
306: (strstr(finfo->strings.target, " -> "))) {
307: add = FALSE;
308: }
309: }
310: else {
311: add = FALSE;
312: }
313: Curl_set_in_callback(conn->data, false);
314:
315: if(add) {
316: Curl_llist_insert_next(llist, llist->tail, finfo, &infop->list);
317: }
318: else {
319: Curl_fileinfo_cleanup(infop);
320: }
321:
322: ftpwc->parser->file_data = NULL;
323: return CURLE_OK;
324: }
325:
326: size_t Curl_ftp_parselist(char *buffer, size_t size, size_t nmemb,
327: void *connptr)
328: {
329: size_t bufflen = size*nmemb;
330: struct connectdata *conn = (struct connectdata *)connptr;
331: struct ftp_wc *ftpwc = conn->data->wildcard.protdata;
332: struct ftp_parselist_data *parser = ftpwc->parser;
333: struct fileinfo *infop;
334: struct curl_fileinfo *finfo;
335: unsigned long i = 0;
336: CURLcode result;
337: size_t retsize = bufflen;
338:
339: if(parser->error) { /* error in previous call */
340: /* scenario:
341: * 1. call => OK..
342: * 2. call => OUT_OF_MEMORY (or other error)
343: * 3. (last) call => is skipped RIGHT HERE and the error is hadled later
344: * in wc_statemach()
345: */
346: goto fail;
347: }
348:
349: if(parser->os_type == OS_TYPE_UNKNOWN && bufflen > 0) {
350: /* considering info about FILE response format */
351: parser->os_type = (buffer[0] >= '0' && buffer[0] <= '9') ?
352: OS_TYPE_WIN_NT : OS_TYPE_UNIX;
353: }
354:
355: while(i < bufflen) { /* FSM */
356:
357: char c = buffer[i];
358: if(!parser->file_data) { /* tmp file data is not allocated yet */
359: parser->file_data = Curl_fileinfo_alloc();
360: if(!parser->file_data) {
361: parser->error = CURLE_OUT_OF_MEMORY;
362: goto fail;
363: }
364: parser->file_data->info.b_data = malloc(FTP_BUFFER_ALLOCSIZE);
365: if(!parser->file_data->info.b_data) {
366: parser->error = CURLE_OUT_OF_MEMORY;
367: goto fail;
368: }
369: parser->file_data->info.b_size = FTP_BUFFER_ALLOCSIZE;
370: parser->item_offset = 0;
371: parser->item_length = 0;
372: }
373:
374: infop = parser->file_data;
375: finfo = &infop->info;
376: finfo->b_data[finfo->b_used++] = c;
377:
378: if(finfo->b_used >= finfo->b_size - 1) {
379: /* if it is important, extend buffer space for file data */
380: char *tmp = realloc(finfo->b_data,
381: finfo->b_size + FTP_BUFFER_ALLOCSIZE);
382: if(tmp) {
383: finfo->b_size += FTP_BUFFER_ALLOCSIZE;
384: finfo->b_data = tmp;
385: }
386: else {
387: Curl_fileinfo_cleanup(parser->file_data);
388: parser->file_data = NULL;
389: parser->error = CURLE_OUT_OF_MEMORY;
390: goto fail;
391: }
392: }
393:
394: switch(parser->os_type) {
395: case OS_TYPE_UNIX:
396: switch(parser->state.UNIX.main) {
397: case PL_UNIX_TOTALSIZE:
398: switch(parser->state.UNIX.sub.total_dirsize) {
399: case PL_UNIX_TOTALSIZE_INIT:
400: if(c == 't') {
401: parser->state.UNIX.sub.total_dirsize = PL_UNIX_TOTALSIZE_READING;
402: parser->item_length++;
403: }
404: else {
405: parser->state.UNIX.main = PL_UNIX_FILETYPE;
406: /* start FSM again not considering size of directory */
407: finfo->b_used = 0;
408: continue;
409: }
410: break;
411: case PL_UNIX_TOTALSIZE_READING:
412: parser->item_length++;
413: if(c == '\r') {
414: parser->item_length--;
415: finfo->b_used--;
416: }
417: else if(c == '\n') {
418: finfo->b_data[parser->item_length - 1] = 0;
419: if(strncmp("total ", finfo->b_data, 6) == 0) {
420: char *endptr = finfo->b_data + 6;
421: /* here we can deal with directory size, pass the leading white
422: spaces and then the digits */
423: while(ISSPACE(*endptr))
424: endptr++;
425: while(ISDIGIT(*endptr))
426: endptr++;
427: if(*endptr != 0) {
428: parser->error = CURLE_FTP_BAD_FILE_LIST;
429: goto fail;
430: }
431: parser->state.UNIX.main = PL_UNIX_FILETYPE;
432: finfo->b_used = 0;
433: }
434: else {
435: parser->error = CURLE_FTP_BAD_FILE_LIST;
436: goto fail;
437: }
438: }
439: break;
440: }
441: break;
442: case PL_UNIX_FILETYPE:
443: switch(c) {
444: case '-':
445: finfo->filetype = CURLFILETYPE_FILE;
446: break;
447: case 'd':
448: finfo->filetype = CURLFILETYPE_DIRECTORY;
449: break;
450: case 'l':
451: finfo->filetype = CURLFILETYPE_SYMLINK;
452: break;
453: case 'p':
454: finfo->filetype = CURLFILETYPE_NAMEDPIPE;
455: break;
456: case 's':
457: finfo->filetype = CURLFILETYPE_SOCKET;
458: break;
459: case 'c':
460: finfo->filetype = CURLFILETYPE_DEVICE_CHAR;
461: break;
462: case 'b':
463: finfo->filetype = CURLFILETYPE_DEVICE_BLOCK;
464: break;
465: case 'D':
466: finfo->filetype = CURLFILETYPE_DOOR;
467: break;
468: default:
469: parser->error = CURLE_FTP_BAD_FILE_LIST;
470: goto fail;
471: }
472: parser->state.UNIX.main = PL_UNIX_PERMISSION;
473: parser->item_length = 0;
474: parser->item_offset = 1;
475: break;
476: case PL_UNIX_PERMISSION:
477: parser->item_length++;
478: if(parser->item_length <= 9) {
479: if(!strchr("rwx-tTsS", c)) {
480: parser->error = CURLE_FTP_BAD_FILE_LIST;
481: goto fail;
482: }
483: }
484: else if(parser->item_length == 10) {
485: unsigned int perm;
486: if(c != ' ') {
487: parser->error = CURLE_FTP_BAD_FILE_LIST;
488: goto fail;
489: }
490: finfo->b_data[10] = 0; /* terminate permissions */
491: perm = ftp_pl_get_permission(finfo->b_data + parser->item_offset);
492: if(perm & FTP_LP_MALFORMATED_PERM) {
493: parser->error = CURLE_FTP_BAD_FILE_LIST;
494: goto fail;
495: }
496: parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_PERM;
497: parser->file_data->info.perm = perm;
498: parser->offsets.perm = parser->item_offset;
499:
500: parser->item_length = 0;
501: parser->state.UNIX.main = PL_UNIX_HLINKS;
502: parser->state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE;
503: }
504: break;
505: case PL_UNIX_HLINKS:
506: switch(parser->state.UNIX.sub.hlinks) {
507: case PL_UNIX_HLINKS_PRESPACE:
508: if(c != ' ') {
509: if(c >= '0' && c <= '9') {
510: parser->item_offset = finfo->b_used - 1;
511: parser->item_length = 1;
512: parser->state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER;
513: }
514: else {
515: parser->error = CURLE_FTP_BAD_FILE_LIST;
516: goto fail;
517: }
518: }
519: break;
520: case PL_UNIX_HLINKS_NUMBER:
521: parser->item_length ++;
522: if(c == ' ') {
523: char *p;
524: long int hlinks;
525: finfo->b_data[parser->item_offset + parser->item_length - 1] = 0;
526: hlinks = strtol(finfo->b_data + parser->item_offset, &p, 10);
527: if(p[0] == '\0' && hlinks != LONG_MAX && hlinks != LONG_MIN) {
528: parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_HLINKCOUNT;
529: parser->file_data->info.hardlinks = hlinks;
530: }
531: parser->item_length = 0;
532: parser->item_offset = 0;
533: parser->state.UNIX.main = PL_UNIX_USER;
534: parser->state.UNIX.sub.user = PL_UNIX_USER_PRESPACE;
535: }
536: else if(c < '0' || c > '9') {
537: parser->error = CURLE_FTP_BAD_FILE_LIST;
538: goto fail;
539: }
540: break;
541: }
542: break;
543: case PL_UNIX_USER:
544: switch(parser->state.UNIX.sub.user) {
545: case PL_UNIX_USER_PRESPACE:
546: if(c != ' ') {
547: parser->item_offset = finfo->b_used - 1;
548: parser->item_length = 1;
549: parser->state.UNIX.sub.user = PL_UNIX_USER_PARSING;
550: }
551: break;
552: case PL_UNIX_USER_PARSING:
553: parser->item_length++;
554: if(c == ' ') {
555: finfo->b_data[parser->item_offset + parser->item_length - 1] = 0;
556: parser->offsets.user = parser->item_offset;
557: parser->state.UNIX.main = PL_UNIX_GROUP;
558: parser->state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE;
559: parser->item_offset = 0;
560: parser->item_length = 0;
561: }
562: break;
563: }
564: break;
565: case PL_UNIX_GROUP:
566: switch(parser->state.UNIX.sub.group) {
567: case PL_UNIX_GROUP_PRESPACE:
568: if(c != ' ') {
569: parser->item_offset = finfo->b_used - 1;
570: parser->item_length = 1;
571: parser->state.UNIX.sub.group = PL_UNIX_GROUP_NAME;
572: }
573: break;
574: case PL_UNIX_GROUP_NAME:
575: parser->item_length++;
576: if(c == ' ') {
577: finfo->b_data[parser->item_offset + parser->item_length - 1] = 0;
578: parser->offsets.group = parser->item_offset;
579: parser->state.UNIX.main = PL_UNIX_SIZE;
580: parser->state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE;
581: parser->item_offset = 0;
582: parser->item_length = 0;
583: }
584: break;
585: }
586: break;
587: case PL_UNIX_SIZE:
588: switch(parser->state.UNIX.sub.size) {
589: case PL_UNIX_SIZE_PRESPACE:
590: if(c != ' ') {
591: if(c >= '0' && c <= '9') {
592: parser->item_offset = finfo->b_used - 1;
593: parser->item_length = 1;
594: parser->state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER;
595: }
596: else {
597: parser->error = CURLE_FTP_BAD_FILE_LIST;
598: goto fail;
599: }
600: }
601: break;
602: case PL_UNIX_SIZE_NUMBER:
603: parser->item_length++;
604: if(c == ' ') {
605: char *p;
606: curl_off_t fsize;
607: finfo->b_data[parser->item_offset + parser->item_length - 1] = 0;
608: if(!curlx_strtoofft(finfo->b_data + parser->item_offset,
609: &p, 10, &fsize)) {
610: if(p[0] == '\0' && fsize != CURL_OFF_T_MAX &&
611: fsize != CURL_OFF_T_MIN) {
612: parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_SIZE;
613: parser->file_data->info.size = fsize;
614: }
615: parser->item_length = 0;
616: parser->item_offset = 0;
617: parser->state.UNIX.main = PL_UNIX_TIME;
618: parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART1;
619: }
620: }
621: else if(!ISDIGIT(c)) {
622: parser->error = CURLE_FTP_BAD_FILE_LIST;
623: goto fail;
624: }
625: break;
626: }
627: break;
628: case PL_UNIX_TIME:
629: switch(parser->state.UNIX.sub.time) {
630: case PL_UNIX_TIME_PREPART1:
631: if(c != ' ') {
632: if(ISALNUM(c)) {
633: parser->item_offset = finfo->b_used -1;
634: parser->item_length = 1;
635: parser->state.UNIX.sub.time = PL_UNIX_TIME_PART1;
636: }
637: else {
638: parser->error = CURLE_FTP_BAD_FILE_LIST;
639: goto fail;
640: }
641: }
642: break;
643: case PL_UNIX_TIME_PART1:
644: parser->item_length++;
645: if(c == ' ') {
646: parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART2;
647: }
648: else if(!ISALNUM(c) && c != '.') {
649: parser->error = CURLE_FTP_BAD_FILE_LIST;
650: goto fail;
651: }
652: break;
653: case PL_UNIX_TIME_PREPART2:
654: parser->item_length++;
655: if(c != ' ') {
656: if(ISALNUM(c)) {
657: parser->state.UNIX.sub.time = PL_UNIX_TIME_PART2;
658: }
659: else {
660: parser->error = CURLE_FTP_BAD_FILE_LIST;
661: goto fail;
662: }
663: }
664: break;
665: case PL_UNIX_TIME_PART2:
666: parser->item_length++;
667: if(c == ' ') {
668: parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART3;
669: }
670: else if(!ISALNUM(c) && c != '.') {
671: parser->error = CURLE_FTP_BAD_FILE_LIST;
672: goto fail;
673: }
674: break;
675: case PL_UNIX_TIME_PREPART3:
676: parser->item_length++;
677: if(c != ' ') {
678: if(ISALNUM(c)) {
679: parser->state.UNIX.sub.time = PL_UNIX_TIME_PART3;
680: }
681: else {
682: parser->error = CURLE_FTP_BAD_FILE_LIST;
683: goto fail;
684: }
685: }
686: break;
687: case PL_UNIX_TIME_PART3:
688: parser->item_length++;
689: if(c == ' ') {
690: finfo->b_data[parser->item_offset + parser->item_length -1] = 0;
691: parser->offsets.time = parser->item_offset;
692: /*
693: if(ftp_pl_gettime(parser, finfo->b_data + parser->item_offset)) {
694: parser->file_data->flags |= CURLFINFOFLAG_KNOWN_TIME;
695: }
696: */
697: if(finfo->filetype == CURLFILETYPE_SYMLINK) {
698: parser->state.UNIX.main = PL_UNIX_SYMLINK;
699: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE;
700: }
701: else {
702: parser->state.UNIX.main = PL_UNIX_FILENAME;
703: parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_PRESPACE;
704: }
705: }
706: else if(!ISALNUM(c) && c != '.' && c != ':') {
707: parser->error = CURLE_FTP_BAD_FILE_LIST;
708: goto fail;
709: }
710: break;
711: }
712: break;
713: case PL_UNIX_FILENAME:
714: switch(parser->state.UNIX.sub.filename) {
715: case PL_UNIX_FILENAME_PRESPACE:
716: if(c != ' ') {
717: parser->item_offset = finfo->b_used - 1;
718: parser->item_length = 1;
719: parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME;
720: }
721: break;
722: case PL_UNIX_FILENAME_NAME:
723: parser->item_length++;
724: if(c == '\r') {
725: parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_WINDOWSEOL;
726: }
727: else if(c == '\n') {
728: finfo->b_data[parser->item_offset + parser->item_length - 1] = 0;
729: parser->offsets.filename = parser->item_offset;
730: parser->state.UNIX.main = PL_UNIX_FILETYPE;
731: result = ftp_pl_insert_finfo(conn, infop);
732: if(result) {
733: parser->error = result;
734: goto fail;
735: }
736: }
737: break;
738: case PL_UNIX_FILENAME_WINDOWSEOL:
739: if(c == '\n') {
740: finfo->b_data[parser->item_offset + parser->item_length - 1] = 0;
741: parser->offsets.filename = parser->item_offset;
742: parser->state.UNIX.main = PL_UNIX_FILETYPE;
743: result = ftp_pl_insert_finfo(conn, infop);
744: if(result) {
745: parser->error = result;
746: goto fail;
747: }
748: }
749: else {
750: parser->error = CURLE_FTP_BAD_FILE_LIST;
751: goto fail;
752: }
753: break;
754: }
755: break;
756: case PL_UNIX_SYMLINK:
757: switch(parser->state.UNIX.sub.symlink) {
758: case PL_UNIX_SYMLINK_PRESPACE:
759: if(c != ' ') {
760: parser->item_offset = finfo->b_used - 1;
761: parser->item_length = 1;
762: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME;
763: }
764: break;
765: case PL_UNIX_SYMLINK_NAME:
766: parser->item_length++;
767: if(c == ' ') {
768: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET1;
769: }
770: else if(c == '\r' || c == '\n') {
771: parser->error = CURLE_FTP_BAD_FILE_LIST;
772: goto fail;
773: }
774: break;
775: case PL_UNIX_SYMLINK_PRETARGET1:
776: parser->item_length++;
777: if(c == '-') {
778: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET2;
779: }
780: else if(c == '\r' || c == '\n') {
781: parser->error = CURLE_FTP_BAD_FILE_LIST;
782: goto fail;
783: }
784: else {
785: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME;
786: }
787: break;
788: case PL_UNIX_SYMLINK_PRETARGET2:
789: parser->item_length++;
790: if(c == '>') {
791: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET3;
792: }
793: else if(c == '\r' || c == '\n') {
794: parser->error = CURLE_FTP_BAD_FILE_LIST;
795: goto fail;
796: }
797: else {
798: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME;
799: }
800: break;
801: case PL_UNIX_SYMLINK_PRETARGET3:
802: parser->item_length++;
803: if(c == ' ') {
804: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET4;
805: /* now place where is symlink following */
806: finfo->b_data[parser->item_offset + parser->item_length - 4] = 0;
807: parser->offsets.filename = parser->item_offset;
808: parser->item_length = 0;
809: parser->item_offset = 0;
810: }
811: else if(c == '\r' || c == '\n') {
812: parser->error = CURLE_FTP_BAD_FILE_LIST;
813: goto fail;
814: }
815: else {
816: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME;
817: }
818: break;
819: case PL_UNIX_SYMLINK_PRETARGET4:
820: if(c != '\r' && c != '\n') {
821: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET;
822: parser->item_offset = finfo->b_used - 1;
823: parser->item_length = 1;
824: }
825: else {
826: parser->error = CURLE_FTP_BAD_FILE_LIST;
827: goto fail;
828: }
829: break;
830: case PL_UNIX_SYMLINK_TARGET:
831: parser->item_length++;
832: if(c == '\r') {
833: parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_WINDOWSEOL;
834: }
835: else if(c == '\n') {
836: finfo->b_data[parser->item_offset + parser->item_length - 1] = 0;
837: parser->offsets.symlink_target = parser->item_offset;
838: result = ftp_pl_insert_finfo(conn, infop);
839: if(result) {
840: parser->error = result;
841: goto fail;
842: }
843: parser->state.UNIX.main = PL_UNIX_FILETYPE;
844: }
845: break;
846: case PL_UNIX_SYMLINK_WINDOWSEOL:
847: if(c == '\n') {
848: finfo->b_data[parser->item_offset + parser->item_length - 1] = 0;
849: parser->offsets.symlink_target = parser->item_offset;
850: result = ftp_pl_insert_finfo(conn, infop);
851: if(result) {
852: parser->error = result;
853: goto fail;
854: }
855: parser->state.UNIX.main = PL_UNIX_FILETYPE;
856: }
857: else {
858: parser->error = CURLE_FTP_BAD_FILE_LIST;
859: goto fail;
860: }
861: break;
862: }
863: break;
864: }
865: break;
866: case OS_TYPE_WIN_NT:
867: switch(parser->state.NT.main) {
868: case PL_WINNT_DATE:
869: parser->item_length++;
870: if(parser->item_length < 9) {
871: if(!strchr("0123456789-", c)) { /* only simple control */
872: parser->error = CURLE_FTP_BAD_FILE_LIST;
873: goto fail;
874: }
875: }
876: else if(parser->item_length == 9) {
877: if(c == ' ') {
878: parser->state.NT.main = PL_WINNT_TIME;
879: parser->state.NT.sub.time = PL_WINNT_TIME_PRESPACE;
880: }
881: else {
882: parser->error = CURLE_FTP_BAD_FILE_LIST;
883: goto fail;
884: }
885: }
886: else {
887: parser->error = CURLE_FTP_BAD_FILE_LIST;
888: goto fail;
889: }
890: break;
891: case PL_WINNT_TIME:
892: parser->item_length++;
893: switch(parser->state.NT.sub.time) {
894: case PL_WINNT_TIME_PRESPACE:
895: if(!ISSPACE(c)) {
896: parser->state.NT.sub.time = PL_WINNT_TIME_TIME;
897: }
898: break;
899: case PL_WINNT_TIME_TIME:
900: if(c == ' ') {
901: parser->offsets.time = parser->item_offset;
902: finfo->b_data[parser->item_offset + parser->item_length -1] = 0;
903: parser->state.NT.main = PL_WINNT_DIRORSIZE;
904: parser->state.NT.sub.dirorsize = PL_WINNT_DIRORSIZE_PRESPACE;
905: parser->item_length = 0;
906: }
907: else if(!strchr("APM0123456789:", c)) {
908: parser->error = CURLE_FTP_BAD_FILE_LIST;
909: goto fail;
910: }
911: break;
912: }
913: break;
914: case PL_WINNT_DIRORSIZE:
915: switch(parser->state.NT.sub.dirorsize) {
916: case PL_WINNT_DIRORSIZE_PRESPACE:
917: if(c != ' ') {
918: parser->item_offset = finfo->b_used - 1;
919: parser->item_length = 1;
920: parser->state.NT.sub.dirorsize = PL_WINNT_DIRORSIZE_CONTENT;
921: }
922: break;
923: case PL_WINNT_DIRORSIZE_CONTENT:
924: parser->item_length ++;
925: if(c == ' ') {
926: finfo->b_data[parser->item_offset + parser->item_length - 1] = 0;
927: if(strcmp("<DIR>", finfo->b_data + parser->item_offset) == 0) {
928: finfo->filetype = CURLFILETYPE_DIRECTORY;
929: finfo->size = 0;
930: }
931: else {
932: char *endptr;
933: if(curlx_strtoofft(finfo->b_data +
934: parser->item_offset,
935: &endptr, 10, &finfo->size)) {
936: parser->error = CURLE_FTP_BAD_FILE_LIST;
937: goto fail;
938: }
939: /* correct file type */
940: parser->file_data->info.filetype = CURLFILETYPE_FILE;
941: }
942:
943: parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_SIZE;
944: parser->item_length = 0;
945: parser->state.NT.main = PL_WINNT_FILENAME;
946: parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE;
947: }
948: break;
949: }
950: break;
951: case PL_WINNT_FILENAME:
952: switch(parser->state.NT.sub.filename) {
953: case PL_WINNT_FILENAME_PRESPACE:
954: if(c != ' ') {
955: parser->item_offset = finfo->b_used -1;
956: parser->item_length = 1;
957: parser->state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT;
958: }
959: break;
960: case PL_WINNT_FILENAME_CONTENT:
961: parser->item_length++;
962: if(c == '\r') {
963: parser->state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL;
964: finfo->b_data[finfo->b_used - 1] = 0;
965: }
966: else if(c == '\n') {
967: parser->offsets.filename = parser->item_offset;
968: finfo->b_data[finfo->b_used - 1] = 0;
969: parser->offsets.filename = parser->item_offset;
970: result = ftp_pl_insert_finfo(conn, infop);
971: if(result) {
972: parser->error = result;
973: goto fail;
974: }
975: parser->state.NT.main = PL_WINNT_DATE;
976: parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE;
977: }
978: break;
979: case PL_WINNT_FILENAME_WINEOL:
980: if(c == '\n') {
981: parser->offsets.filename = parser->item_offset;
982: result = ftp_pl_insert_finfo(conn, infop);
983: if(result) {
984: parser->error = result;
985: goto fail;
986: }
987: parser->state.NT.main = PL_WINNT_DATE;
988: parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE;
989: }
990: else {
991: parser->error = CURLE_FTP_BAD_FILE_LIST;
992: goto fail;
993: }
994: break;
995: }
996: break;
997: }
998: break;
999: default:
1000: retsize = bufflen + 1;
1001: goto fail;
1002: }
1003:
1004: i++;
1005: }
1006: return retsize;
1007:
1008: fail:
1009:
1010: /* Clean up any allocated memory. */
1011: if(parser->file_data) {
1012: Curl_fileinfo_cleanup(parser->file_data);
1013: parser->file_data = NULL;
1014: }
1015:
1016: return retsize;
1017: }
1018:
1019: #endif /* CURL_DISABLE_FTP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ftplistparser.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib