1 /*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel (at) 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 "rawstr.h" 49 #include "ftp.h" 50 #include "ftplistparser.h" 51 #include "curl_fnmatch.h" 52 #include "curl_memory.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 curl_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 **pl_data) 189 { 190 free(*pl_data); 191 *pl_data = NULL; 192 } 193 194 195 CURLcode Curl_ftp_parselist_geterror(struct ftp_parselist_data *pl_data) 196 { 197 return pl_data->error; 198 } 199 200 201 #define FTP_LP_MALFORMATED_PERM 0x01000000 202 203 static int ftp_pl_get_permission(const char *str) 204 { 205 int permissions = 0; 206 /* USER */ 207 if(str[0] == 'r') 208 permissions |= 1 << 8; 209 else if(str[0] != '-') 210 permissions |= FTP_LP_MALFORMATED_PERM; 211 if(str[1] == 'w') 212 permissions |= 1 << 7; 213 else if(str[1] != '-') 214 permissions |= FTP_LP_MALFORMATED_PERM; 215 216 if(str[2] == 'x') 217 permissions |= 1 << 6; 218 else if(str[2] == 's') { 219 permissions |= 1 << 6; 220 permissions |= 1 << 11; 221 } 222 else if(str[2] == 'S') 223 permissions |= 1 << 11; 224 else if(str[2] != '-') 225 permissions |= FTP_LP_MALFORMATED_PERM; 226 /* GROUP */ 227 if(str[3] == 'r') 228 permissions |= 1 << 5; 229 else if(str[3] != '-') 230 permissions |= FTP_LP_MALFORMATED_PERM; 231 if(str[4] == 'w') 232 permissions |= 1 << 4; 233 else if(str[4] != '-') 234 permissions |= FTP_LP_MALFORMATED_PERM; 235 if(str[5] == 'x') 236 permissions |= 1 << 3; 237 else if(str[5] == 's') { 238 permissions |= 1 << 3; 239 permissions |= 1 << 10; 240 } 241 else if(str[5] == 'S') 242 permissions |= 1 << 10; 243 else if(str[5] != '-') 244 permissions |= FTP_LP_MALFORMATED_PERM; 245 /* others */ 246 if(str[6] == 'r') 247 permissions |= 1 << 2; 248 else if(str[6] != '-') 249 permissions |= FTP_LP_MALFORMATED_PERM; 250 if(str[7] == 'w') 251 permissions |= 1 << 1; 252 else if(str[7] != '-') 253 permissions |= FTP_LP_MALFORMATED_PERM; 254 if(str[8] == 'x') 255 permissions |= 1; 256 else if(str[8] == 't') { 257 permissions |= 1; 258 permissions |= 1 << 9; 259 } 260 else if(str[8] == 'T') 261 permissions |= 1 << 9; 262 else if(str[8] != '-') 263 permissions |= FTP_LP_MALFORMATED_PERM; 264 265 return permissions; 266 } 267 268 static void PL_ERROR(struct connectdata *conn, CURLcode err) 269 { 270 struct ftp_wc_tmpdata *tmpdata = conn->data->wildcard.tmp; 271 struct ftp_parselist_data *parser = tmpdata->parser; 272 if(parser->file_data) 273 Curl_fileinfo_dtor(NULL, parser->file_data); 274 parser->file_data = NULL; 275 parser->error = err; 276 } 277 278 static CURLcode ftp_pl_insert_finfo(struct connectdata *conn, 279 struct curl_fileinfo *finfo) 280 { 281 curl_fnmatch_callback compare; 282 struct WildcardData *wc = &conn->data->wildcard; 283 struct ftp_wc_tmpdata *tmpdata = wc->tmp; 284 struct curl_llist *llist = wc->filelist; 285 struct ftp_parselist_data *parser = tmpdata->parser; 286 bool add = TRUE; 287 288 /* move finfo pointers to b_data */ 289 char *str = finfo->b_data; 290 finfo->filename = str + parser->offsets.filename; 291 finfo->strings.group = parser->offsets.group ? 292 str + parser->offsets.group : NULL; 293 finfo->strings.perm = parser->offsets.perm ? 294 str + parser->offsets.perm : NULL; 295 finfo->strings.target = parser->offsets.symlink_target ? 296 str + parser->offsets.symlink_target : NULL; 297 finfo->strings.time = str + parser->offsets.time; 298 finfo->strings.user = parser->offsets.user ? 299 str + parser->offsets.user : NULL; 300 301 /* get correct fnmatch callback */ 302 compare = conn->data->set.fnmatch; 303 if(!compare) 304 compare = Curl_fnmatch; 305 306 /* filter pattern-corresponding filenames */ 307 if(compare(conn->data->set.fnmatch_data, wc->pattern, 308 finfo->filename) == 0) { 309 /* discard symlink which is containing multiple " -> " */ 310 if((finfo->filetype == CURLFILETYPE_SYMLINK) && finfo->strings.target && 311 (strstr(finfo->strings.target, " -> "))) { 312 add = FALSE; 313 } 314 } 315 else { 316 add = FALSE; 317 } 318 319 if(add) { 320 if(!Curl_llist_insert_next(llist, llist->tail, finfo)) { 321 Curl_fileinfo_dtor(NULL, finfo); 322 tmpdata->parser->file_data = NULL; 323 return CURLE_OUT_OF_MEMORY; 324 } 325 } 326 else { 327 Curl_fileinfo_dtor(NULL, finfo); 328 } 329 330 tmpdata->parser->file_data = NULL; 331 return CURLE_OK; 332 } 333 334 size_t Curl_ftp_parselist(char *buffer, size_t size, size_t nmemb, 335 void *connptr) 336 { 337 size_t bufflen = size*nmemb; 338 struct connectdata *conn = (struct connectdata *)connptr; 339 struct ftp_wc_tmpdata *tmpdata = conn->data->wildcard.tmp; 340 struct ftp_parselist_data *parser = tmpdata->parser; 341 struct curl_fileinfo *finfo; 342 unsigned long i = 0; 343 CURLcode result; 344 345 if(parser->error) { /* error in previous call */ 346 /* scenario: 347 * 1. call => OK.. 348 * 2. call => OUT_OF_MEMORY (or other error) 349 * 3. (last) call => is skipped RIGHT HERE and the error is hadled later 350 * in wc_statemach() 351 */ 352 return bufflen; 353 } 354 355 if(parser->os_type == OS_TYPE_UNKNOWN && bufflen > 0) { 356 /* considering info about FILE response format */ 357 parser->os_type = (buffer[0] >= '0' && buffer[0] <= '9') ? 358 OS_TYPE_WIN_NT : OS_TYPE_UNIX; 359 } 360 361 while(i < bufflen) { /* FSM */ 362 363 char c = buffer[i]; 364 if(!parser->file_data) { /* tmp file data is not allocated yet */ 365 parser->file_data = Curl_fileinfo_alloc(); 366 if(!parser->file_data) { 367 parser->error = CURLE_OUT_OF_MEMORY; 368 return bufflen; 369 } 370 parser->file_data->b_data = malloc(FTP_BUFFER_ALLOCSIZE); 371 if(!parser->file_data->b_data) { 372 PL_ERROR(conn, CURLE_OUT_OF_MEMORY); 373 return bufflen; 374 } 375 parser->file_data->b_size = FTP_BUFFER_ALLOCSIZE; 376 parser->item_offset = 0; 377 parser->item_length = 0; 378 } 379 380 finfo = parser->file_data; 381 finfo->b_data[finfo->b_used++] = c; 382 383 if(finfo->b_used >= finfo->b_size - 1) { 384 /* if it is important, extend buffer space for file data */ 385 char *tmp = realloc(finfo->b_data, 386 finfo->b_size + FTP_BUFFER_ALLOCSIZE); 387 if(tmp) { 388 finfo->b_size += FTP_BUFFER_ALLOCSIZE; 389 finfo->b_data = tmp; 390 } 391 else { 392 Curl_fileinfo_dtor(NULL, parser->file_data); 393 parser->file_data = NULL; 394 parser->error = CURLE_OUT_OF_MEMORY; 395 PL_ERROR(conn, CURLE_OUT_OF_MEMORY); 396 return bufflen; 397 } 398 } 399 400 switch (parser->os_type) { 401 case OS_TYPE_UNIX: 402 switch (parser->state.UNIX.main) { 403 case PL_UNIX_TOTALSIZE: 404 switch(parser->state.UNIX.sub.total_dirsize) { 405 case PL_UNIX_TOTALSIZE_INIT: 406 if(c == 't') { 407 parser->state.UNIX.sub.total_dirsize = PL_UNIX_TOTALSIZE_READING; 408 parser->item_length++; 409 } 410 else { 411 parser->state.UNIX.main = PL_UNIX_FILETYPE; 412 /* start FSM again not considering size of directory */ 413 finfo->b_used = 0; 414 i--; 415 } 416 break; 417 case PL_UNIX_TOTALSIZE_READING: 418 parser->item_length++; 419 if(c == '\r') { 420 parser->item_length--; 421 finfo->b_used--; 422 } 423 else if(c == '\n') { 424 finfo->b_data[parser->item_length - 1] = 0; 425 if(strncmp("total ", finfo->b_data, 6) == 0) { 426 char *endptr = finfo->b_data+6; 427 /* here we can deal with directory size, pass the leading white 428 spaces and then the digits */ 429 while(ISSPACE(*endptr)) 430 endptr++; 431 while(ISDIGIT(*endptr)) 432 endptr++; 433 if(*endptr != 0) { 434 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 435 return bufflen; 436 } 437 else { 438 parser->state.UNIX.main = PL_UNIX_FILETYPE; 439 finfo->b_used = 0; 440 } 441 } 442 else { 443 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 444 return bufflen; 445 } 446 } 447 break; 448 } 449 break; 450 case PL_UNIX_FILETYPE: 451 switch (c) { 452 case '-': 453 finfo->filetype = CURLFILETYPE_FILE; 454 break; 455 case 'd': 456 finfo->filetype = CURLFILETYPE_DIRECTORY; 457 break; 458 case 'l': 459 finfo->filetype = CURLFILETYPE_SYMLINK; 460 break; 461 case 'p': 462 finfo->filetype = CURLFILETYPE_NAMEDPIPE; 463 break; 464 case 's': 465 finfo->filetype = CURLFILETYPE_SOCKET; 466 break; 467 case 'c': 468 finfo->filetype = CURLFILETYPE_DEVICE_CHAR; 469 break; 470 case 'b': 471 finfo->filetype = CURLFILETYPE_DEVICE_BLOCK; 472 break; 473 case 'D': 474 finfo->filetype = CURLFILETYPE_DOOR; 475 break; 476 default: 477 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 478 return bufflen; 479 } 480 parser->state.UNIX.main = PL_UNIX_PERMISSION; 481 parser->item_length = 0; 482 parser->item_offset = 1; 483 break; 484 case PL_UNIX_PERMISSION: 485 parser->item_length++; 486 if(parser->item_length <= 9) { 487 if(!strchr("rwx-tTsS", c)) { 488 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 489 return bufflen; 490 } 491 } 492 else if(parser->item_length == 10) { 493 unsigned int perm; 494 if(c != ' ') { 495 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 496 return bufflen; 497 } 498 finfo->b_data[10] = 0; /* terminate permissions */ 499 perm = ftp_pl_get_permission(finfo->b_data + parser->item_offset); 500 if(perm & FTP_LP_MALFORMATED_PERM) { 501 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 502 return bufflen; 503 } 504 parser->file_data->flags |= CURLFINFOFLAG_KNOWN_PERM; 505 parser->file_data->perm = perm; 506 parser->offsets.perm = parser->item_offset; 507 508 parser->item_length = 0; 509 parser->state.UNIX.main = PL_UNIX_HLINKS; 510 parser->state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; 511 } 512 break; 513 case PL_UNIX_HLINKS: 514 switch(parser->state.UNIX.sub.hlinks) { 515 case PL_UNIX_HLINKS_PRESPACE: 516 if(c != ' ') { 517 if(c >= '0' && c <= '9') { 518 parser->item_offset = finfo->b_used - 1; 519 parser->item_length = 1; 520 parser->state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; 521 } 522 else { 523 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 524 return bufflen; 525 } 526 } 527 break; 528 case PL_UNIX_HLINKS_NUMBER: 529 parser->item_length ++; 530 if(c == ' ') { 531 char *p; 532 long int hlinks; 533 finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; 534 hlinks = strtol(finfo->b_data + parser->item_offset, &p, 10); 535 if(p[0] == '\0' && hlinks != LONG_MAX && hlinks != LONG_MIN) { 536 parser->file_data->flags |= CURLFINFOFLAG_KNOWN_HLINKCOUNT; 537 parser->file_data->hardlinks = hlinks; 538 } 539 parser->item_length = 0; 540 parser->item_offset = 0; 541 parser->state.UNIX.main = PL_UNIX_USER; 542 parser->state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; 543 } 544 else if(c < '0' || c > '9') { 545 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 546 return bufflen; 547 } 548 break; 549 } 550 break; 551 case PL_UNIX_USER: 552 switch(parser->state.UNIX.sub.user) { 553 case PL_UNIX_USER_PRESPACE: 554 if(c != ' ') { 555 parser->item_offset = finfo->b_used - 1; 556 parser->item_length = 1; 557 parser->state.UNIX.sub.user = PL_UNIX_USER_PARSING; 558 } 559 break; 560 case PL_UNIX_USER_PARSING: 561 parser->item_length++; 562 if(c == ' ') { 563 finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; 564 parser->offsets.user = parser->item_offset; 565 parser->state.UNIX.main = PL_UNIX_GROUP; 566 parser->state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; 567 parser->item_offset = 0; 568 parser->item_length = 0; 569 } 570 break; 571 } 572 break; 573 case PL_UNIX_GROUP: 574 switch(parser->state.UNIX.sub.group) { 575 case PL_UNIX_GROUP_PRESPACE: 576 if(c != ' ') { 577 parser->item_offset = finfo->b_used - 1; 578 parser->item_length = 1; 579 parser->state.UNIX.sub.group = PL_UNIX_GROUP_NAME; 580 } 581 break; 582 case PL_UNIX_GROUP_NAME: 583 parser->item_length++; 584 if(c == ' ') { 585 finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; 586 parser->offsets.group = parser->item_offset; 587 parser->state.UNIX.main = PL_UNIX_SIZE; 588 parser->state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; 589 parser->item_offset = 0; 590 parser->item_length = 0; 591 } 592 break; 593 } 594 break; 595 case PL_UNIX_SIZE: 596 switch(parser->state.UNIX.sub.size) { 597 case PL_UNIX_SIZE_PRESPACE: 598 if(c != ' ') { 599 if(c >= '0' && c <= '9') { 600 parser->item_offset = finfo->b_used - 1; 601 parser->item_length = 1; 602 parser->state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; 603 } 604 else { 605 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 606 return bufflen; 607 } 608 } 609 break; 610 case PL_UNIX_SIZE_NUMBER: 611 parser->item_length++; 612 if(c == ' ') { 613 char *p; 614 curl_off_t fsize; 615 finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; 616 fsize = curlx_strtoofft(finfo->b_data+parser->item_offset, &p, 10); 617 if(p[0] == '\0' && fsize != CURL_OFF_T_MAX && 618 fsize != CURL_OFF_T_MIN) { 619 parser->file_data->flags |= CURLFINFOFLAG_KNOWN_SIZE; 620 parser->file_data->size = fsize; 621 } 622 parser->item_length = 0; 623 parser->item_offset = 0; 624 parser->state.UNIX.main = PL_UNIX_TIME; 625 parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; 626 } 627 else if(!ISDIGIT(c)) { 628 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 629 return bufflen; 630 } 631 break; 632 } 633 break; 634 case PL_UNIX_TIME: 635 switch(parser->state.UNIX.sub.time) { 636 case PL_UNIX_TIME_PREPART1: 637 if(c != ' ') { 638 if(ISALNUM(c)) { 639 parser->item_offset = finfo->b_used -1; 640 parser->item_length = 1; 641 parser->state.UNIX.sub.time = PL_UNIX_TIME_PART1; 642 } 643 else { 644 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 645 return bufflen; 646 } 647 } 648 break; 649 case PL_UNIX_TIME_PART1: 650 parser->item_length++; 651 if(c == ' ') { 652 parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; 653 } 654 else if(!ISALNUM(c) && c != '.') { 655 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 656 return bufflen; 657 } 658 break; 659 case PL_UNIX_TIME_PREPART2: 660 parser->item_length++; 661 if(c != ' ') { 662 if(ISALNUM(c)) { 663 parser->state.UNIX.sub.time = PL_UNIX_TIME_PART2; 664 } 665 else { 666 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 667 return bufflen; 668 } 669 } 670 break; 671 case PL_UNIX_TIME_PART2: 672 parser->item_length++; 673 if(c == ' ') { 674 parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; 675 } 676 else if(!ISALNUM(c) && c != '.') { 677 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 678 return bufflen; 679 } 680 break; 681 case PL_UNIX_TIME_PREPART3: 682 parser->item_length++; 683 if(c != ' ') { 684 if(ISALNUM(c)) { 685 parser->state.UNIX.sub.time = PL_UNIX_TIME_PART3; 686 } 687 else { 688 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 689 return bufflen; 690 } 691 } 692 break; 693 case PL_UNIX_TIME_PART3: 694 parser->item_length++; 695 if(c == ' ') { 696 finfo->b_data[parser->item_offset + parser->item_length -1] = 0; 697 parser->offsets.time = parser->item_offset; 698 /* 699 if(ftp_pl_gettime(parser, finfo->b_data + parser->item_offset)) { 700 parser->file_data->flags |= CURLFINFOFLAG_KNOWN_TIME; 701 } 702 */ 703 if(finfo->filetype == CURLFILETYPE_SYMLINK) { 704 parser->state.UNIX.main = PL_UNIX_SYMLINK; 705 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; 706 } 707 else { 708 parser->state.UNIX.main = PL_UNIX_FILENAME; 709 parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_PRESPACE; 710 } 711 } 712 else if(!ISALNUM(c) && c != '.' && c != ':') { 713 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 714 return bufflen; 715 } 716 break; 717 } 718 break; 719 case PL_UNIX_FILENAME: 720 switch(parser->state.UNIX.sub.filename) { 721 case PL_UNIX_FILENAME_PRESPACE: 722 if(c != ' ') { 723 parser->item_offset = finfo->b_used - 1; 724 parser->item_length = 1; 725 parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; 726 } 727 break; 728 case PL_UNIX_FILENAME_NAME: 729 parser->item_length++; 730 if(c == '\r') { 731 parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_WINDOWSEOL; 732 } 733 else if(c == '\n') { 734 finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; 735 parser->offsets.filename = parser->item_offset; 736 parser->state.UNIX.main = PL_UNIX_FILETYPE; 737 result = ftp_pl_insert_finfo(conn, finfo); 738 if(result) { 739 PL_ERROR(conn, result); 740 return bufflen; 741 } 742 } 743 break; 744 case PL_UNIX_FILENAME_WINDOWSEOL: 745 if(c == '\n') { 746 finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; 747 parser->offsets.filename = parser->item_offset; 748 parser->state.UNIX.main = PL_UNIX_FILETYPE; 749 result = ftp_pl_insert_finfo(conn, finfo); 750 if(result) { 751 PL_ERROR(conn, result); 752 return bufflen; 753 } 754 } 755 else { 756 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 757 return bufflen; 758 } 759 break; 760 } 761 break; 762 case PL_UNIX_SYMLINK: 763 switch(parser->state.UNIX.sub.symlink) { 764 case PL_UNIX_SYMLINK_PRESPACE: 765 if(c != ' ') { 766 parser->item_offset = finfo->b_used - 1; 767 parser->item_length = 1; 768 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; 769 } 770 break; 771 case PL_UNIX_SYMLINK_NAME: 772 parser->item_length++; 773 if(c == ' ') { 774 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET1; 775 } 776 else if(c == '\r' || c == '\n') { 777 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 778 return bufflen; 779 } 780 break; 781 case PL_UNIX_SYMLINK_PRETARGET1: 782 parser->item_length++; 783 if(c == '-') { 784 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET2; 785 } 786 else if(c == '\r' || c == '\n') { 787 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 788 return bufflen; 789 } 790 else { 791 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; 792 } 793 break; 794 case PL_UNIX_SYMLINK_PRETARGET2: 795 parser->item_length++; 796 if(c == '>') { 797 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET3; 798 } 799 else if(c == '\r' || c == '\n') { 800 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 801 return bufflen; 802 } 803 else { 804 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; 805 } 806 break; 807 case PL_UNIX_SYMLINK_PRETARGET3: 808 parser->item_length++; 809 if(c == ' ') { 810 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET4; 811 /* now place where is symlink following */ 812 finfo->b_data[parser->item_offset + parser->item_length - 4] = 0; 813 parser->offsets.filename = parser->item_offset; 814 parser->item_length = 0; 815 parser->item_offset = 0; 816 } 817 else if(c == '\r' || c == '\n') { 818 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 819 return bufflen; 820 } 821 else { 822 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; 823 } 824 break; 825 case PL_UNIX_SYMLINK_PRETARGET4: 826 if(c != '\r' && c != '\n') { 827 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; 828 parser->item_offset = finfo->b_used - 1; 829 parser->item_length = 1; 830 } 831 else { 832 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 833 return bufflen; 834 } 835 break; 836 case PL_UNIX_SYMLINK_TARGET: 837 parser->item_length++; 838 if(c == '\r') { 839 parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_WINDOWSEOL; 840 } 841 else if(c == '\n') { 842 finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; 843 parser->offsets.symlink_target = parser->item_offset; 844 result = ftp_pl_insert_finfo(conn, finfo); 845 if(result) { 846 PL_ERROR(conn, result); 847 return bufflen; 848 } 849 parser->state.UNIX.main = PL_UNIX_FILETYPE; 850 } 851 break; 852 case PL_UNIX_SYMLINK_WINDOWSEOL: 853 if(c == '\n') { 854 finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; 855 parser->offsets.symlink_target = parser->item_offset; 856 result = ftp_pl_insert_finfo(conn, finfo); 857 if(result) { 858 PL_ERROR(conn, result); 859 return bufflen; 860 } 861 parser->state.UNIX.main = PL_UNIX_FILETYPE; 862 } 863 else { 864 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 865 return bufflen; 866 } 867 break; 868 } 869 break; 870 } 871 break; 872 case OS_TYPE_WIN_NT: 873 switch(parser->state.NT.main) { 874 case PL_WINNT_DATE: 875 parser->item_length++; 876 if(parser->item_length < 9) { 877 if(!strchr("0123456789-", c)) { /* only simple control */ 878 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 879 return bufflen; 880 } 881 } 882 else if(parser->item_length == 9) { 883 if(c == ' ') { 884 parser->state.NT.main = PL_WINNT_TIME; 885 parser->state.NT.sub.time = PL_WINNT_TIME_PRESPACE; 886 } 887 else { 888 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 889 return bufflen; 890 } 891 } 892 else { 893 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 894 return bufflen; 895 } 896 break; 897 case PL_WINNT_TIME: 898 parser->item_length++; 899 switch(parser->state.NT.sub.time) { 900 case PL_WINNT_TIME_PRESPACE: 901 if(!ISSPACE(c)) { 902 parser->state.NT.sub.time = PL_WINNT_TIME_TIME; 903 } 904 break; 905 case PL_WINNT_TIME_TIME: 906 if(c == ' ') { 907 parser->offsets.time = parser->item_offset; 908 finfo->b_data[parser->item_offset + parser->item_length -1] = 0; 909 parser->state.NT.main = PL_WINNT_DIRORSIZE; 910 parser->state.NT.sub.dirorsize = PL_WINNT_DIRORSIZE_PRESPACE; 911 parser->item_length = 0; 912 } 913 else if(!strchr("APM0123456789:", c)) { 914 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 915 return bufflen; 916 } 917 break; 918 } 919 break; 920 case PL_WINNT_DIRORSIZE: 921 switch(parser->state.NT.sub.dirorsize) { 922 case PL_WINNT_DIRORSIZE_PRESPACE: 923 if(c == ' ') { 924 925 } 926 else { 927 parser->item_offset = finfo->b_used - 1; 928 parser->item_length = 1; 929 parser->state.NT.sub.dirorsize = PL_WINNT_DIRORSIZE_CONTENT; 930 } 931 break; 932 case PL_WINNT_DIRORSIZE_CONTENT: 933 parser->item_length ++; 934 if(c == ' ') { 935 finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; 936 if(strcmp("<DIR>", finfo->b_data + parser->item_offset) == 0) { 937 finfo->filetype = CURLFILETYPE_DIRECTORY; 938 finfo->size = 0; 939 } 940 else { 941 char *endptr; 942 finfo->size = curlx_strtoofft(finfo->b_data + 943 parser->item_offset, 944 &endptr, 10); 945 if(!*endptr) { 946 if(finfo->size == CURL_OFF_T_MAX || 947 finfo->size == CURL_OFF_T_MIN) { 948 if(errno == ERANGE) { 949 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 950 return bufflen; 951 } 952 } 953 } 954 else { 955 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 956 return bufflen; 957 } 958 /* correct file type */ 959 parser->file_data->filetype = CURLFILETYPE_FILE; 960 } 961 962 parser->file_data->flags |= CURLFINFOFLAG_KNOWN_SIZE; 963 parser->item_length = 0; 964 parser->state.NT.main = PL_WINNT_FILENAME; 965 parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE; 966 } 967 break; 968 } 969 break; 970 case PL_WINNT_FILENAME: 971 switch (parser->state.NT.sub.filename) { 972 case PL_WINNT_FILENAME_PRESPACE: 973 if(c != ' ') { 974 parser->item_offset = finfo->b_used -1; 975 parser->item_length = 1; 976 parser->state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; 977 } 978 break; 979 case PL_WINNT_FILENAME_CONTENT: 980 parser->item_length++; 981 if(c == '\r') { 982 parser->state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; 983 finfo->b_data[finfo->b_used - 1] = 0; 984 } 985 else if(c == '\n') { 986 parser->offsets.filename = parser->item_offset; 987 finfo->b_data[finfo->b_used - 1] = 0; 988 parser->offsets.filename = parser->item_offset; 989 result = ftp_pl_insert_finfo(conn, finfo); 990 if(result) { 991 PL_ERROR(conn, result); 992 return bufflen; 993 } 994 parser->state.NT.main = PL_WINNT_DATE; 995 parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE; 996 } 997 break; 998 case PL_WINNT_FILENAME_WINEOL: 999 if(c == '\n') { 1000 parser->offsets.filename = parser->item_offset; 1001 result = ftp_pl_insert_finfo(conn, finfo); 1002 if(result) { 1003 PL_ERROR(conn, result); 1004 return bufflen; 1005 } 1006 parser->state.NT.main = PL_WINNT_DATE; 1007 parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE; 1008 } 1009 else { 1010 PL_ERROR(conn, CURLE_FTP_BAD_FILE_LIST); 1011 return bufflen; 1012 } 1013 break; 1014 } 1015 break; 1016 } 1017 break; 1018 default: 1019 return bufflen + 1; 1020 } 1021 1022 i++; 1023 } 1024 1025 return bufflen; 1026 } 1027 1028 #endif /* CURL_DISABLE_FTP */ 1029
