lib/ftplistparser.c

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