luna - curl/lib/ftplistparser.c

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