lib/ftplistparser.c

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