master
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#include "curl_setup.h"
26#ifndef CURL_DISABLE_FTP
28#include "curl_trc.h"
30/**
31 * Now implemented:
32 *
33 * 1) Unix version 1
34 * drwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog
35 * 2) Unix version 2
36 * drwxr-xr-x 1 user01 ftp 512 Jan 29 1997 prog
37 * 3) Unix version 3
38 * drwxr-xr-x 1 1 1 512 Jan 29 23:32 prog
39 * 4) Unix symlink
40 * lrwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog -> prog2000
41 * 5) DOS style
42 * 01-29-97 11:32PM <DIR> prog
43 */
45#include "urldata.h"
46#include "fileinfo.h"
47#include "llist.h"
48#include "ftp.h"
49#include "ftp-int.h"
50#include "ftplistparser.h"
51#include "curl_fnmatch.h"
52#include "multiif.h"
53#include "curlx/strparse.h"
55typedef enum {
56 PL_UNIX_TOTALSIZE = 0,
57 PL_UNIX_FILETYPE,
58 PL_UNIX_PERMISSION,
59 PL_UNIX_HLINKS,
60 PL_UNIX_USER,
61 PL_UNIX_GROUP,
62 PL_UNIX_SIZE,
63 PL_UNIX_TIME,
64 PL_UNIX_FILENAME,
65 PL_UNIX_SYMLINK
66} pl_unix_mainstate;
68typedef union {
69 enum {
70 PL_UNIX_TOTALSIZE_INIT = 0,
71 PL_UNIX_TOTALSIZE_READING
72 } total_dirsize;
74 enum {
75 PL_UNIX_HLINKS_PRESPACE = 0,
76 PL_UNIX_HLINKS_NUMBER
77 } hlinks;
79 enum {
80 PL_UNIX_USER_PRESPACE = 0,
81 PL_UNIX_USER_PARSING
82 } user;
84 enum {
85 PL_UNIX_GROUP_PRESPACE = 0,
86 PL_UNIX_GROUP_NAME
87 } group;
89 enum {
90 PL_UNIX_SIZE_PRESPACE = 0,
91 PL_UNIX_SIZE_NUMBER
92 } size;
94 enum {
95 PL_UNIX_TIME_PREPART1 = 0,
96 PL_UNIX_TIME_PART1,
97 PL_UNIX_TIME_PREPART2,
98 PL_UNIX_TIME_PART2,
99 PL_UNIX_TIME_PREPART3,
100 PL_UNIX_TIME_PART3
101 } time;
103 enum {
104 PL_UNIX_FILENAME_PRESPACE = 0,
105 PL_UNIX_FILENAME_NAME,
106 PL_UNIX_FILENAME_WINDOWSEOL
107 } filename;
109 enum {
110 PL_UNIX_SYMLINK_PRESPACE = 0,
111 PL_UNIX_SYMLINK_NAME,
112 PL_UNIX_SYMLINK_PRETARGET1,
113 PL_UNIX_SYMLINK_PRETARGET2,
114 PL_UNIX_SYMLINK_PRETARGET3,
115 PL_UNIX_SYMLINK_PRETARGET4,
116 PL_UNIX_SYMLINK_TARGET,
117 PL_UNIX_SYMLINK_WINDOWSEOL
118 } symlink;
119} pl_unix_substate;
121typedef enum {
122 PL_WINNT_DATE = 0,
123 PL_WINNT_TIME,
124 PL_WINNT_DIRORSIZE,
125 PL_WINNT_FILENAME
126} pl_winNT_mainstate;
128typedef union {
129 enum {
130 PL_WINNT_TIME_PRESPACE = 0,
131 PL_WINNT_TIME_TIME
132 } time;
133 enum {
134 PL_WINNT_DIRORSIZE_PRESPACE = 0,
135 PL_WINNT_DIRORSIZE_CONTENT
136 } dirorsize;
137 enum {
138 PL_WINNT_FILENAME_PRESPACE = 0,
139 PL_WINNT_FILENAME_CONTENT,
140 PL_WINNT_FILENAME_WINEOL
141 } filename;
142} pl_winNT_substate;
144/* This struct is used in wildcard downloading - for parsing LIST response */
145struct ftp_parselist_data {
146 enum {
147 OS_TYPE_UNKNOWN = 0,
148 OS_TYPE_UNIX,
149 OS_TYPE_WIN_NT
150 } os_type;
152 union {
153 struct {
154 pl_unix_mainstate main;
155 pl_unix_substate sub;
156 } UNIX;
158 struct {
159 pl_winNT_mainstate main;
160 pl_winNT_substate sub;
161 } NT;
162 } state;
164 CURLcode error;
165 struct fileinfo *file_data;
166 unsigned int item_length;
167 size_t item_offset;
168 struct {
169 size_t filename;
170 size_t user;
171 size_t group;
172 size_t time;
173 size_t perm;
174 size_t symlink_target;
175 } offsets;
176};
178static void fileinfo_dtor(void *user, void *element)
179{
180 (void)user;
181 Curl_fileinfo_cleanup(element);
182}
184void Curl_wildcard_init(struct WildcardData *wc)
185{
186 Curl_llist_init(&wc->filelist, fileinfo_dtor);
187 wc->state = CURLWC_INIT;
188}
190void Curl_wildcard_dtor(struct WildcardData **wcp)
191{
192 struct WildcardData *wc = *wcp;
193 if(!wc)
194 return;
196 if(wc->dtor) {
197 wc->dtor(wc->ftpwc);
198 wc->dtor = ZERO_NULL;
199 wc->ftpwc = NULL;
200 }
201 DEBUGASSERT(!wc->ftpwc);
203 Curl_llist_destroy(&wc->filelist, NULL);
204 curlx_safefree(wc->path);
205 curlx_safefree(wc->pattern);
206 wc->state = CURLWC_INIT;
207 curlx_free(wc);
208 *wcp = NULL;
209}
211struct ftp_parselist_data *Curl_ftp_parselist_data_alloc(void)
212{
213 return curlx_calloc(1, sizeof(struct ftp_parselist_data));
214}
216void Curl_ftp_parselist_data_free(struct ftp_parselist_data **parserp)
217{
218 struct ftp_parselist_data *parser = *parserp;
219 if(parser)
220 Curl_fileinfo_cleanup(parser->file_data);
221 curlx_free(parser);
222 *parserp = NULL;
223}
225CURLcode Curl_ftp_parselist_geterror(struct ftp_parselist_data *pl_data)
226{
227 return pl_data->error;
228}
230#define FTP_LP_MALFORMATED_PERM 0x01000000
232static unsigned int ftp_pl_get_permission(const char *str)
233{
234 unsigned int permissions = 0;
235 /* USER */
236 if(str[0] == 'r')
237 permissions |= 1 << 8;
238 else if(str[0] != '-')
239 permissions |= FTP_LP_MALFORMATED_PERM;
240 if(str[1] == 'w')
241 permissions |= 1 << 7;
242 else if(str[1] != '-')
243 permissions |= FTP_LP_MALFORMATED_PERM;
245 if(str[2] == 'x')
246 permissions |= 1 << 6;
247 else if(str[2] == 's') {
248 permissions |= 1 << 6;
249 permissions |= 1 << 11;
250 }
251 else if(str[2] == 'S')
252 permissions |= 1 << 11;
253 else if(str[2] != '-')
254 permissions |= FTP_LP_MALFORMATED_PERM;
255 /* GROUP */
256 if(str[3] == 'r')
257 permissions |= 1 << 5;
258 else if(str[3] != '-')
259 permissions |= FTP_LP_MALFORMATED_PERM;
260 if(str[4] == 'w')
261 permissions |= 1 << 4;
262 else if(str[4] != '-')
263 permissions |= FTP_LP_MALFORMATED_PERM;
264 if(str[5] == 'x')
265 permissions |= 1 << 3;
266 else if(str[5] == 's') {
267 permissions |= 1 << 3;
268 permissions |= 1 << 10;
269 }
270 else if(str[5] == 'S')
271 permissions |= 1 << 10;
272 else if(str[5] != '-')
273 permissions |= FTP_LP_MALFORMATED_PERM;
274 /* others */
275 if(str[6] == 'r')
276 permissions |= 1 << 2;
277 else if(str[6] != '-')
278 permissions |= FTP_LP_MALFORMATED_PERM;
279 if(str[7] == 'w')
280 permissions |= 1 << 1;
281 else if(str[7] != '-')
282 permissions |= FTP_LP_MALFORMATED_PERM;
283 if(str[8] == 'x')
284 permissions |= 1;
285 else if(str[8] == 't') {
286 permissions |= 1;
287 permissions |= 1 << 9;
288 }
289 else if(str[8] == 'T')
290 permissions |= 1 << 9;
291 else if(str[8] != '-')
292 permissions |= FTP_LP_MALFORMATED_PERM;
294 return permissions;
295}
297static CURLcode ftp_pl_insert_finfo(struct Curl_easy *data,
298 struct fileinfo *infop)
299{
300 curl_fnmatch_callback compare;
301 struct WildcardData *wc = data->wildcard;
302 struct ftp_wc *ftpwc = wc->ftpwc;
303 struct Curl_llist *llist = &wc->filelist;
304 struct ftp_parselist_data *parser = ftpwc->parser;
305 bool add = TRUE;
306 struct curl_fileinfo *finfo = &infop->info;
307 CURLcode result = CURLE_OK;
309 /* set the finfo pointers */
310 char *str = curlx_dyn_ptr(&infop->buf);
311 finfo->filename = str + parser->offsets.filename;
312 finfo->strings.group = parser->offsets.group ?
313 str + parser->offsets.group : NULL;
314 finfo->strings.perm = parser->offsets.perm ?
315 str + parser->offsets.perm : NULL;
316 finfo->strings.target = parser->offsets.symlink_target &&
317 (finfo->filetype == CURLFILETYPE_SYMLINK) ?
318 str + parser->offsets.symlink_target : NULL;
319 finfo->strings.time = str + parser->offsets.time;
320 finfo->strings.user = parser->offsets.user ?
321 str + parser->offsets.user : NULL;
323 /* get correct fnmatch callback */
324 compare = data->set.fnmatch;
325 if(!compare)
326 compare = Curl_fnmatch;
328 /* filter pattern-corresponding filenames */
329 if(strchr(finfo->filename, '/'))
330 add = FALSE;
331 else {
332 /* a real file name cannot contain a slash */
333 struct Curl_mapi_guard guard;
334 CURL_CBAPI_START(&guard, data, easy_fnmatch_data);
335 if(compare(data->set.fnmatch_data, wc->pattern, finfo->filename) == 0) {
336 /* discard symlink which is containing multiple " -> " */
337 if((finfo->filetype == CURLFILETYPE_SYMLINK) && finfo->strings.target &&
338 strstr(finfo->strings.target, " -> ")) {
339 add = FALSE;
340 }
341 }
342 else {
343 add = FALSE;
344 }
345 CURL_CBAPI_END(&guard);
346 }
348 if(add && (Curl_llist_count(llist) >= MAX_FTP_DIR_ENTRIES)) {
349 infof(data, "Reached maximum number of dir entries (%d)",
350 MAX_FTP_DIR_ENTRIES);
351 add = FALSE;
352 result = CURLE_FTP_BAD_FILE_LIST;
353 }
355 if(add) {
356 Curl_llist_append(llist, finfo, &infop->list);
357 }
358 else {
359 Curl_fileinfo_cleanup(infop);
360 }
362 ftpwc->parser->file_data = NULL;
363 return result;
364}
366#define MAX_FTPLIST_BUFFER 10000 /* arbitrarily set */
368static CURLcode unix_filetype(const char c, curlfiletype *t)
369{
370 switch(c) {
371 case '-':
372 *t = CURLFILETYPE_FILE;
373 break;
374 case 'd':
375 *t = CURLFILETYPE_DIRECTORY;
376 break;
377 case 'l':
378 *t = CURLFILETYPE_SYMLINK;
379 break;
380 case 'p':
381 *t = CURLFILETYPE_NAMEDPIPE;
382 break;
383 case 's':
384 *t = CURLFILETYPE_SOCKET;
385 break;
386 case 'c':
387 *t = CURLFILETYPE_DEVICE_CHAR;
388 break;
389 case 'b':
390 *t = CURLFILETYPE_DEVICE_BLOCK;
391 break;
392 case 'D':
393 *t = CURLFILETYPE_DOOR;
394 break;
395 default:
396 return CURLE_FTP_BAD_FILE_LIST;
397 }
398 return CURLE_OK;
399}
401static CURLcode parse_unix_totalsize(struct ftp_parselist_data *parser,
402 struct fileinfo *infop,
403 const char c)
404{
405 size_t len = curlx_dyn_len(&infop->buf);
406 char *mem = curlx_dyn_ptr(&infop->buf);
407 switch(parser->state.UNIX.sub.total_dirsize) {
408 case PL_UNIX_TOTALSIZE_INIT:
409 if(c == 't') {
410 parser->state.UNIX.sub.total_dirsize = PL_UNIX_TOTALSIZE_READING;
411 parser->item_length++;
412 }
413 else {
414 parser->state.UNIX.main = PL_UNIX_FILETYPE;
415 /* continue to fall through */
416 }
417 break;
418 case PL_UNIX_TOTALSIZE_READING:
419 parser->item_length++;
420 if(c == '\r') {
421 parser->item_length--;
422 if(len)
423 curlx_dyn_setlen(&infop->buf, --len);
424 }
425 else if(c == '\n') {
426 mem[parser->item_length - 1] = 0;
427 if(!strncmp("total ", mem, 6)) {
428 const char *endptr = mem + 6;
429 /* here we can deal with directory size, pass the leading
430 whitespace and then the digits */
431 curlx_str_passblanks(&endptr);
432 while(ISDIGIT(*endptr))
433 endptr++;
434 if(*endptr) {
435 return CURLE_FTP_BAD_FILE_LIST;
436 }
437 parser->state.UNIX.main = PL_UNIX_FILETYPE;
438 curlx_dyn_reset(&infop->buf);
439 }
440 else
441 return CURLE_FTP_BAD_FILE_LIST;
442 }
443 break;
444 }
445 return CURLE_OK;
446}
448static CURLcode parse_unix_permission(struct ftp_parselist_data *parser,
449 struct fileinfo *infop,
450 const char c)
451{
452 char *mem = curlx_dyn_ptr(&infop->buf);
453 parser->item_length++;
454 if((parser->item_length <= 9) && !strchr("rwx-tTsS", c))
455 return CURLE_FTP_BAD_FILE_LIST;
457 else if(parser->item_length == 10) {
458 unsigned int perm;
459 if(c != ' ')
460 return CURLE_FTP_BAD_FILE_LIST;
462 mem[10] = 0; /* terminate permissions */
463 perm = ftp_pl_get_permission(mem + parser->item_offset);
464 if(perm & FTP_LP_MALFORMATED_PERM)
465 return CURLE_FTP_BAD_FILE_LIST;
467 parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_PERM;
468 parser->file_data->info.perm = perm;
469 parser->offsets.perm = parser->item_offset;
471 parser->item_length = 0;
472 parser->state.UNIX.main = PL_UNIX_HLINKS;
473 parser->state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE;
474 }
475 return CURLE_OK;
476}
478static CURLcode parse_unix_hlinks(struct ftp_parselist_data *parser,
479 struct fileinfo *infop,
480 const char c)
481{
482 size_t len = curlx_dyn_len(&infop->buf);
483 char *mem = curlx_dyn_ptr(&infop->buf);
485 switch(parser->state.UNIX.sub.hlinks) {
486 case PL_UNIX_HLINKS_PRESPACE:
487 if(c != ' ') {
488 if(ISDIGIT(c) && len) {
489 parser->item_offset = len - 1;
490 parser->item_length = 1;
491 parser->state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER;
492 }
493 else
494 return CURLE_FTP_BAD_FILE_LIST;
495 }
496 break;
497 case PL_UNIX_HLINKS_NUMBER:
498 parser->item_length++;
499 if(c == ' ') {
500 const char *p = &mem[parser->item_offset];
501 curl_off_t hlinks;
502 mem[parser->item_offset + parser->item_length - 1] = 0;
504 if(!curlx_str_number(&p, &hlinks, LONG_MAX)) {
505 parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_HLINKCOUNT;
506 parser->file_data->info.hardlinks = (long)hlinks;
507 }
508 parser->item_length = 0;
509 parser->item_offset = 0;
510 parser->state.UNIX.main = PL_UNIX_USER;
511 parser->state.UNIX.sub.user = PL_UNIX_USER_PRESPACE;
512 }
513 else if(!ISDIGIT(c))
514 return CURLE_FTP_BAD_FILE_LIST;
516 break;
517 }
518 return CURLE_OK;
519}
521static CURLcode parse_unix_user(struct ftp_parselist_data *parser,
522 struct fileinfo *infop,
523 const char c)
524{
525 size_t len = curlx_dyn_len(&infop->buf);
526 char *mem = curlx_dyn_ptr(&infop->buf);
527 switch(parser->state.UNIX.sub.user) {
528 case PL_UNIX_USER_PRESPACE:
529 if(c != ' ' && len) {
530 parser->item_offset = len - 1;
531 parser->item_length = 1;
532 parser->state.UNIX.sub.user = PL_UNIX_USER_PARSING;
533 }
534 break;
535 case PL_UNIX_USER_PARSING:
536 parser->item_length++;
537 if(c == ' ') {
538 mem[parser->item_offset + parser->item_length - 1] = 0;
539 parser->offsets.user = parser->item_offset;
540 parser->state.UNIX.main = PL_UNIX_GROUP;
541 parser->state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE;
542 parser->item_offset = 0;
543 parser->item_length = 0;
544 }
545 break;
546 }
547 return CURLE_OK;
548}
550static CURLcode parse_unix_group(struct ftp_parselist_data *parser,
551 struct fileinfo *infop,
552 const char c)
553{
554 size_t len = curlx_dyn_len(&infop->buf);
555 char *mem = curlx_dyn_ptr(&infop->buf);
556 switch(parser->state.UNIX.sub.group) {
557 case PL_UNIX_GROUP_PRESPACE:
558 if(c != ' ' && len) {
559 parser->item_offset = len - 1;
560 parser->item_length = 1;
561 parser->state.UNIX.sub.group = PL_UNIX_GROUP_NAME;
562 }
563 break;
564 case PL_UNIX_GROUP_NAME:
565 parser->item_length++;
566 if(c == ' ') {
567 mem[parser->item_offset + parser->item_length - 1] = 0;
568 parser->offsets.group = parser->item_offset;
569 parser->state.UNIX.main = PL_UNIX_SIZE;
570 parser->state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE;
571 parser->item_offset = 0;
572 parser->item_length = 0;
573 }
574 break;
575 }
576 return CURLE_OK;
577}
579static CURLcode parse_unix_size(struct ftp_parselist_data *parser,
580 struct fileinfo *infop,
581 const char c)
582{
583 size_t len = curlx_dyn_len(&infop->buf);
584 char *mem = curlx_dyn_ptr(&infop->buf);
585 switch(parser->state.UNIX.sub.size) {
586 case PL_UNIX_SIZE_PRESPACE:
587 if(c != ' ') {
588 if(ISDIGIT(c) && len) {
589 parser->item_offset = len - 1;
590 parser->item_length = 1;
591 parser->state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER;
592 }
593 else
594 return CURLE_FTP_BAD_FILE_LIST;
595 }
596 break;
597 case PL_UNIX_SIZE_NUMBER:
598 parser->item_length++;
599 if(c == ' ') {
600 const char *p = mem + parser->item_offset;
601 curl_off_t fsize;
602 mem[parser->item_offset + parser->item_length - 1] = 0;
603 if(!curlx_str_numblanks(&p, &fsize)) {
604 if(p[0] == '\0' && fsize != CURL_OFF_T_MAX) {
605 parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_SIZE;
606 parser->file_data->info.size = fsize;
607 }
608 parser->item_length = 0;
609 parser->item_offset = 0;
610 parser->state.UNIX.main = PL_UNIX_TIME;
611 parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART1;
612 }
613 }
614 else if(!ISDIGIT(c))
615 return CURLE_FTP_BAD_FILE_LIST;
617 break;
618 }
619 return CURLE_OK;
620}
622static CURLcode parse_unix_time(struct ftp_parselist_data *parser,
623 struct fileinfo *infop,
624 const char c)
625{
626 size_t len = curlx_dyn_len(&infop->buf);
627 char *mem = curlx_dyn_ptr(&infop->buf);
628 struct curl_fileinfo *finfo = &infop->info;
630 switch(parser->state.UNIX.sub.time) {
631 case PL_UNIX_TIME_PREPART1:
632 if(c != ' ') {
633 if(ISALNUM(c) && len) {
634 parser->item_offset = len - 1;
635 parser->item_length = 1;
636 parser->state.UNIX.sub.time = PL_UNIX_TIME_PART1;
637 }
638 else
639 return CURLE_FTP_BAD_FILE_LIST;
640 }
641 break;
642 case PL_UNIX_TIME_PART1:
643 parser->item_length++;
644 if(c == ' ')
645 parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART2;
647 else if(!ISALNUM(c) && c != '.')
648 return CURLE_FTP_BAD_FILE_LIST;
650 break;
651 case PL_UNIX_TIME_PREPART2:
652 parser->item_length++;
653 if(c != ' ') {
654 if(ISALNUM(c))
655 parser->state.UNIX.sub.time = PL_UNIX_TIME_PART2;
656 else
657 return CURLE_FTP_BAD_FILE_LIST;
658 }
659 break;
660 case PL_UNIX_TIME_PART2:
661 parser->item_length++;
662 if(c == ' ')
663 parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART3;
664 else if(!ISALNUM(c) && c != '.')
665 return CURLE_FTP_BAD_FILE_LIST;
666 break;
667 case PL_UNIX_TIME_PREPART3:
668 parser->item_length++;
669 if(c != ' ') {
670 if(ISALNUM(c))
671 parser->state.UNIX.sub.time = PL_UNIX_TIME_PART3;
672 else
673 return CURLE_FTP_BAD_FILE_LIST;
674 }
675 break;
676 case PL_UNIX_TIME_PART3:
677 parser->item_length++;
678 if(c == ' ') {
679 mem[parser->item_offset + parser->item_length - 1] = 0;
680 parser->offsets.time = parser->item_offset;
681 if(finfo->filetype == CURLFILETYPE_SYMLINK) {
682 parser->state.UNIX.main = PL_UNIX_SYMLINK;
683 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE;
684 }
685 else {
686 parser->state.UNIX.main = PL_UNIX_FILENAME;
687 parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_PRESPACE;
688 }
689 }
690 else if(!ISALNUM(c) && c != '.' && c != ':')
691 return CURLE_FTP_BAD_FILE_LIST;
692 break;
693 }
694 return CURLE_OK;
695}
697static CURLcode parse_unix_filename(struct Curl_easy *data,
698 struct ftp_parselist_data *parser,
699 struct fileinfo *infop,
700 const char c)
701{
702 size_t len = curlx_dyn_len(&infop->buf);
703 char *mem = curlx_dyn_ptr(&infop->buf);
704 CURLcode result = CURLE_OK;
706 switch(parser->state.UNIX.sub.filename) {
707 case PL_UNIX_FILENAME_PRESPACE:
708 if(c != ' ' && len) {
709 parser->item_offset = len - 1;
710 parser->item_length = 1;
711 parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME;
712 }
713 break;
714 case PL_UNIX_FILENAME_NAME:
715 parser->item_length++;
716 if(c == '\r')
717 parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_WINDOWSEOL;
719 else if(c == '\n') {
720 mem[parser->item_offset + parser->item_length - 1] = 0;
721 parser->offsets.filename = parser->item_offset;
722 parser->state.UNIX.main = PL_UNIX_FILETYPE;
723 result = ftp_pl_insert_finfo(data, infop);
724 }
725 break;
726 case PL_UNIX_FILENAME_WINDOWSEOL:
727 if(c == '\n') {
728 mem[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(data, infop);
732 }
733 else
734 result = CURLE_FTP_BAD_FILE_LIST;
735 break;
736 }
737 return result;
738}
740static CURLcode parse_unix_symlink(struct Curl_easy *data,
741 struct ftp_parselist_data *parser,
742 struct fileinfo *infop,
743 const char c)
744{
745 size_t len = curlx_dyn_len(&infop->buf);
746 char *mem = curlx_dyn_ptr(&infop->buf);
747 CURLcode result = CURLE_OK;
749 switch(parser->state.UNIX.sub.symlink) {
750 case PL_UNIX_SYMLINK_PRESPACE:
751 if(c != ' ' && len) {
752 parser->item_offset = len - 1;
753 parser->item_length = 1;
754 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME;
755 }
756 break;
757 case PL_UNIX_SYMLINK_NAME:
758 parser->item_length++;
759 if(c == ' ')
760 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET1;
762 else if(c == '\r' || c == '\n')
763 return CURLE_FTP_BAD_FILE_LIST;
765 break;
766 case PL_UNIX_SYMLINK_PRETARGET1:
767 parser->item_length++;
768 if(c == '-')
769 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET2;
771 else if(c == '\r' || c == '\n')
772 return CURLE_FTP_BAD_FILE_LIST;
773 else
774 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME;
775 break;
776 case PL_UNIX_SYMLINK_PRETARGET2:
777 parser->item_length++;
778 if(c == '>')
779 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET3;
780 else if(c == '\r' || c == '\n')
781 return CURLE_FTP_BAD_FILE_LIST;
782 else
783 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME;
785 break;
786 case PL_UNIX_SYMLINK_PRETARGET3:
787 parser->item_length++;
788 if(c == ' ') {
789 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET4;
790 /* now place where is symlink following */
791 mem[parser->item_offset + parser->item_length - 4] = 0;
792 parser->offsets.filename = parser->item_offset;
793 parser->item_length = 0;
794 parser->item_offset = 0;
795 }
796 else if(c == '\r' || c == '\n')
797 return CURLE_FTP_BAD_FILE_LIST;
798 else
799 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME;
800 break;
801 case PL_UNIX_SYMLINK_PRETARGET4:
802 if(c != '\r' && c != '\n' && len) {
803 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET;
804 parser->item_offset = len - 1;
805 parser->item_length = 1;
806 }
807 else
808 return CURLE_FTP_BAD_FILE_LIST;
810 break;
811 case PL_UNIX_SYMLINK_TARGET:
812 parser->item_length++;
813 if(c == '\r')
814 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_WINDOWSEOL;
816 else if(c == '\n') {
817 mem[parser->item_offset + parser->item_length - 1] = 0;
818 parser->offsets.symlink_target = parser->item_offset;
819 result = ftp_pl_insert_finfo(data, infop);
820 if(result)
821 break;
823 parser->state.UNIX.main = PL_UNIX_FILETYPE;
824 }
825 break;
826 case PL_UNIX_SYMLINK_WINDOWSEOL:
827 if(c == '\n') {
828 mem[parser->item_offset + parser->item_length - 1] = 0;
829 parser->offsets.symlink_target = parser->item_offset;
830 result = ftp_pl_insert_finfo(data, infop);
831 if(result)
832 break;
834 parser->state.UNIX.main = PL_UNIX_FILETYPE;
835 }
836 else
837 result = CURLE_FTP_BAD_FILE_LIST;
839 break;
840 }
841 return result;
842}
844static CURLcode parse_unix(struct Curl_easy *data,
845 struct ftp_parselist_data *parser,
846 struct fileinfo *infop,
847 const char c)
848{
849 struct curl_fileinfo *finfo = &infop->info;
850 CURLcode result = CURLE_OK;
852 switch(parser->state.UNIX.main) {
853 case PL_UNIX_TOTALSIZE:
854 result = parse_unix_totalsize(parser, infop, c);
855 if(result)
856 break;
857 if(parser->state.UNIX.main != PL_UNIX_FILETYPE)
858 break;
859 FALLTHROUGH();
860 case PL_UNIX_FILETYPE:
861 result = unix_filetype(c, &finfo->filetype);
862 if(!result) {
863 parser->state.UNIX.main = PL_UNIX_PERMISSION;
864 parser->item_length = 0;
865 parser->item_offset = 1;
866 }
867 break;
868 case PL_UNIX_PERMISSION:
869 result = parse_unix_permission(parser, infop, c);
870 break;
871 case PL_UNIX_HLINKS:
872 result = parse_unix_hlinks(parser, infop, c);
873 break;
874 case PL_UNIX_USER:
875 result = parse_unix_user(parser, infop, c);
876 break;
877 case PL_UNIX_GROUP:
878 result = parse_unix_group(parser, infop, c);
879 break;
880 case PL_UNIX_SIZE:
881 result = parse_unix_size(parser, infop, c);
882 break;
883 case PL_UNIX_TIME:
884 result = parse_unix_time(parser, infop, c);
885 break;
886 case PL_UNIX_FILENAME:
887 result = parse_unix_filename(data, parser, infop, c);
888 break;
889 case PL_UNIX_SYMLINK:
890 result = parse_unix_symlink(data, parser, infop, c);
891 break;
892 }
893 return result;
894}
896static CURLcode parse_winnt(struct Curl_easy *data,
897 struct ftp_parselist_data *parser,
898 struct fileinfo *infop,
899 const char c)
900{
901 struct curl_fileinfo *finfo = &infop->info;
902 size_t len = curlx_dyn_len(&infop->buf);
903 char *mem = curlx_dyn_ptr(&infop->buf);
904 CURLcode result = CURLE_OK;
906 switch(parser->state.NT.main) {
907 case PL_WINNT_DATE:
908 parser->item_length++;
909 if(parser->item_length < 9) {
910 if(!strchr("0123456789-", c)) { /* only simple control */
911 return CURLE_FTP_BAD_FILE_LIST;
912 }
913 }
914 else if(parser->item_length == 9) {
915 if(c == ' ') {
916 parser->state.NT.main = PL_WINNT_TIME;
917 parser->state.NT.sub.time = PL_WINNT_TIME_PRESPACE;
918 }
919 else
920 return CURLE_FTP_BAD_FILE_LIST;
921 }
922 else
923 return CURLE_FTP_BAD_FILE_LIST;
924 break;
925 case PL_WINNT_TIME:
926 parser->item_length++;
927 switch(parser->state.NT.sub.time) {
928 case PL_WINNT_TIME_PRESPACE:
929 if(!ISBLANK(c))
930 parser->state.NT.sub.time = PL_WINNT_TIME_TIME;
931 break;
932 case PL_WINNT_TIME_TIME:
933 if(c == ' ') {
934 parser->offsets.time = parser->item_offset;
935 mem[parser->item_offset + parser->item_length - 1] = 0;
936 parser->state.NT.main = PL_WINNT_DIRORSIZE;
937 parser->state.NT.sub.dirorsize = PL_WINNT_DIRORSIZE_PRESPACE;
938 parser->item_length = 0;
939 }
940 else if(!strchr("APM0123456789:", c))
941 return CURLE_FTP_BAD_FILE_LIST;
942 break;
943 }
944 break;
945 case PL_WINNT_DIRORSIZE:
946 switch(parser->state.NT.sub.dirorsize) {
947 case PL_WINNT_DIRORSIZE_PRESPACE:
948 if(c != ' ' && len) {
949 parser->item_offset = len - 1;
950 parser->item_length = 1;
951 parser->state.NT.sub.dirorsize = PL_WINNT_DIRORSIZE_CONTENT;
952 }
953 break;
954 case PL_WINNT_DIRORSIZE_CONTENT:
955 parser->item_length++;
956 if(c == ' ') {
957 mem[parser->item_offset + parser->item_length - 1] = 0;
958 if(!strcmp("<DIR>", mem + parser->item_offset)) {
959 finfo->filetype = CURLFILETYPE_DIRECTORY;
960 finfo->size = 0;
961 }
962 else {
963 const char *p = mem + parser->item_offset;
964 if(curlx_str_numblanks(&p, &finfo->size)) {
965 return CURLE_FTP_BAD_FILE_LIST;
966 }
967 /* correct file type */
968 parser->file_data->info.filetype = CURLFILETYPE_FILE;
969 }
971 parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_SIZE;
972 parser->item_length = 0;
973 parser->state.NT.main = PL_WINNT_FILENAME;
974 parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE;
975 }
976 break;
977 }
978 break;
979 case PL_WINNT_FILENAME:
980 switch(parser->state.NT.sub.filename) {
981 case PL_WINNT_FILENAME_PRESPACE:
982 if(c != ' ' && len) {
983 parser->item_offset = len - 1;
984 parser->item_length = 1;
985 parser->state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT;
986 }
987 break;
988 case PL_WINNT_FILENAME_CONTENT:
989 parser->item_length++;
990 if(!len)
991 return CURLE_FTP_BAD_FILE_LIST;
992 if(c == '\r') {
993 parser->state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL;
994 mem[len - 1] = 0;
995 }
996 else if(c == '\n') {
997 parser->offsets.filename = parser->item_offset;
998 mem[len - 1] = 0;
999 result = ftp_pl_insert_finfo(data, infop);
1000 if(result)
1001 return result;
1003 parser->state.NT.main = PL_WINNT_DATE;
1004 parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE;
1005 }
1006 break;
1007 case PL_WINNT_FILENAME_WINEOL:
1008 if(c == '\n') {
1009 parser->offsets.filename = parser->item_offset;
1010 result = ftp_pl_insert_finfo(data, infop);
1011 if(result)
1012 return result;
1014 parser->state.NT.main = PL_WINNT_DATE;
1015 parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE;
1016 }
1017 else
1018 return CURLE_FTP_BAD_FILE_LIST;
1020 break;
1021 }
1022 break;
1023 }
1025 return CURLE_OK;
1026}
1028/* returns TRUE if in wildcard listing mode */
1029bool Curl_ftp_listmode(struct Curl_easy *data)
1030{
1031 if(data->state.wildcardmatch) {
1032 struct WildcardData * const wildcard = data->wildcard;
1033 return wildcard && (wildcard->state == CURLWC_MATCHING);
1034 }
1035 return FALSE;
1036}
1038size_t Curl_ftp_parselist(char *buffer, size_t size, size_t nmemb,
1039 void *connptr)
1040{
1041 size_t bufflen = size * nmemb;
1042 struct Curl_easy *data = (struct Curl_easy *)connptr;
1043 struct ftp_wc *ftpwc = data->wildcard->ftpwc;
1044 struct ftp_parselist_data *parser = ftpwc->parser;
1045 size_t i = 0;
1046 CURLcode result;
1047 size_t retsize = bufflen;
1049 if(parser->error) { /* error in previous call */
1050 /* scenario:
1051 * 1. call => OK..
1052 * 2. call => OUT_OF_MEMORY (or other error)
1053 * 3. (last) call => is skipped RIGHT HERE and the error is handled later
1054 * in wc_statemach()
1055 */
1056 goto fail;
1057 }
1059 if(parser->os_type == OS_TYPE_UNKNOWN && bufflen > 0) {
1060 /* considering info about FILE response format */
1061 parser->os_type = ISDIGIT(buffer[0]) ? OS_TYPE_WIN_NT : OS_TYPE_UNIX;
1062 }
1064 while(i < bufflen) { /* FSM */
1065 char c = buffer[i];
1066 struct fileinfo *infop;
1067 if(!parser->file_data) { /* tmp file data is not allocated yet */
1068 parser->file_data = Curl_fileinfo_alloc();
1069 if(!parser->file_data) {
1070 parser->error = CURLE_OUT_OF_MEMORY;
1071 goto fail;
1072 }
1073 parser->item_offset = 0;
1074 parser->item_length = 0;
1075 curlx_dyn_init(&parser->file_data->buf, MAX_FTPLIST_BUFFER);
1076 }
1078 infop = parser->file_data;
1080 if(curlx_dyn_addn(&infop->buf, &c, 1)) {
1081 parser->error = CURLE_OUT_OF_MEMORY;
1082 goto fail;
1083 }
1085 switch(parser->os_type) {
1086 case OS_TYPE_UNIX:
1087 result = parse_unix(data, parser, infop, c);
1088 break;
1089 case OS_TYPE_WIN_NT:
1090 result = parse_winnt(data, parser, infop, c);
1091 break;
1092 default:
1093 retsize = bufflen + 1;
1094 goto fail;
1095 }
1096 if(result) {
1097 parser->error = result;
1098 goto fail;
1099 }
1101 i++;
1102 }
1103 return retsize;
1105fail:
1107 /* Clean up any allocated memory. */
1108 if(parser->file_data) {
1109 Curl_fileinfo_cleanup(parser->file_data);
1110 parser->file_data = NULL;
1111 }
1113 return retsize;
1114}
1116#endif /* !CURL_DISABLE_FTP */
Diagnostics4 git calls · 230 ms
CallStatusSizeTime0230 ms
discover200152 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=152 git.server.agent=gitty/1.0 git.server.object_format=sha1 git.server.caps=agent ls-refs fetch object-format git.server.fetch=shallow filter sideband-all git.protocol.version=2 git.pkt.frames=8 git.pkt.data=6 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=152 git.pkt.payload.max=34
ls-refs200149 B · hit3 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=149 git.response.cache=HIT git.response.duration_ms=3 git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=149 git.pkt.payload.max=78 git.ls_refs.count=2 git.ls_refs.head=refs/heads/master
fetchblob:none · deepen 10200287 KiB · hit4 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=223 git.response.bytes=293470 git.response.cache=HIT git.response.duration_ms=4 git.fetch.filter=blob:none git.fetch.filter.requested=tree:0 git.fetch.filter.fallback=blob:none git.fetch.filter.learned=false git.fetch.wants=31c911efe5652725e930f4d2e60c9060e5f6646d git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=10 git.pkt.data=8 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=293470 git.pkt.payload.max=65516 git.sideband.band1.bytes=293354 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=87 git.pack.bytes=293354 git.pack.ofs_delta=0 git.pack.ref_delta=1 git.pack.chain.max=1 git.pack.trailer=6a646bcda6740bab42e321b51998b52ea15146c0 git.pack.full=86Open pack map
fetch2006.5 KiB223 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=6659 git.response.cache=MISS git.response.duration_ms=223 git.fetch.wants=c92b07d549c97b2fdd3ffd5e1ca1936a44bee210 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=6659 git.pkt.payload.max=6638 git.sideband.band1.bytes=6637 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0
Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.
- Remote
- https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/curl.git
- Ref
- refs/heads/master
- Commit
- 31c911efe5652725e930f4d2e60c9060e5f6646d
- cf-ray
- a5e280df0d4e0555
- Request
- 2f057198…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format