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