/src/mozilla-central/netwerk/streamconv/converters/ParseFTPList.cpp

Source (jump to first uncovered line)
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "ParseFTPList.h"
#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "plstr.h"
#include "nsDebug.h"
#include "prprf.h"
#include "nsUnicharUtils.h"
#include "mozilla/CheckedInt.h"
#include "mozilla/IntegerPrintfMacros.h"
#include "mozilla/TextUtils.h"
#include "mozilla/Sprintf.h"

/* ==================================================================== */

using mozilla::CheckedInt;
using mozilla::IsAsciiDigit;
using mozilla::IsAsciiAlpha;
using mozilla::IsAsciiLowercaseAlpha;
using mozilla::IsAsciiAlphanumeric;

static const int kMaxFTPListLen = 32768;

static inline int ParsingFailed(struct list_state *state)
{
  if (state->parsed_one || state->lstyle) /* junk if we fail to parse */
    return '?';      /* this time but had previously parsed successfully */
  return '"';        /* its part of a comment or error message */
}

void
FixupYear(PRExplodedTime* aTime)
{
  /* if year has only two digits then assume that
     00-79 is 2000-2079
     80-99 is 1980-1999 */
  if (aTime->tm_year < 80) {
    aTime->tm_year += 2000;
  } else if (aTime->tm_year < 100) {
    aTime->tm_year += 1900;
  }
}

int ParseFTPList(const char *line, struct list_state *state,
                 struct list_result *result, PRTimeParamFn timeParam,
                 NowTimeFn nowTimeFn)
{
  unsigned int carry_buf_len; /* copy of state->carry_buf_len */
  unsigned int pos;
  const char *p;

  if (!line || !state || !result)
    return 0;

  memset( result, 0, sizeof(*result) );
  state->numlines++;

  /* carry buffer is only valid from one line to the next */
  carry_buf_len = state->carry_buf_len;
  state->carry_buf_len = 0;

  /* strip leading whitespace */
  while (*line == ' ' || *line == '\t')
    line++;

  /* line is terminated at first '\0' or '\n' */
  p = line;
  while (*p && *p != '\n')
    p++;
  unsigned int linelen = p - line;

  if (linelen > 0 && *p == '\n' && *(p-1) == '\r')
    linelen--;

  /* DON'T strip trailing whitespace. */

  if (linelen > kMaxFTPListLen) {
    return ParsingFailed(state);
  }

  if (linelen > 0)
  {
    static const char *month_names = "JanFebMarAprMayJunJulAugSepOctNovDec";
    const char *tokens[16]; /* 16 is more than enough */
    unsigned int toklen[(sizeof(tokens)/sizeof(tokens[0]))];
    unsigned int linelen_sans_wsp;  // line length sans whitespace
    unsigned int numtoks = 0;
    unsigned int tokmarker = 0; /* extra info for lstyle handler */
    unsigned int month_num = 0;
    char tbuf[4];
    int lstyle = 0;

    if (carry_buf_len) /* VMS long filename carryover buffer */
    {
      tokens[0] = state->carry_buf;
      toklen[0] = carry_buf_len;
      numtoks++;
    }

    pos = 0;
    while (pos < linelen && numtoks < (sizeof(tokens)/sizeof(tokens[0])) )
    {
      while (pos < linelen &&
            (line[pos] == ' ' || line[pos] == '\t' || line[pos] == '\r'))
        pos++;
      if (pos < linelen)
      {
        tokens[numtoks] = &line[pos];
        while (pos < linelen &&
           (line[pos] != ' ' && line[pos] != '\t' && line[pos] != '\r'))
          pos++;
        if (tokens[numtoks] != &line[pos])
        {
          toklen[numtoks] = (&line[pos] - tokens[numtoks]);
          numtoks++;
        }
      }
    }

    if (!numtoks)
      return ParsingFailed(state);

    linelen_sans_wsp = &(tokens[numtoks-1][toklen[numtoks-1]]) - tokens[0];
    if (numtoks == (sizeof(tokens)/sizeof(tokens[0])) )
    {
      pos = linelen;
      while (pos > 0 && (line[pos-1] == ' ' || line[pos-1] == '\t'))
        pos--;
      linelen_sans_wsp = pos;
    }

    /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

#if defined(SUPPORT_EPLF)
    /* EPLF handling must come somewhere before /bin/dls handling. */
    if (!lstyle && (!state->lstyle || state->lstyle == 'E'))
    {
      if (*line == '+' && linelen > 4 && numtoks >= 2)
      {
        pos = 1;
        while (pos < (linelen-1))
        {
          p = &line[pos++];
          if (*p == '/')
            result->fe_type = 'd'; /* its a dir */
          else if (*p == 'r')
            result->fe_type = 'f'; /* its a file */
          else if (*p == 'm')
          {
            if (IsAsciiDigit(line[pos]))
            {
              while (pos < linelen && IsAsciiDigit(line[pos]))
                pos++;
              if (pos < linelen && line[pos] == ',')
              {
                PRTime t;
                PRTime seconds;
                PR_sscanf(p+1, "%llu", &seconds);
                t = seconds * PR_USEC_PER_SEC;
                PR_ExplodeTime(t, timeParam, &(result->fe_time) );
              }
            }
          }
          else if (*p == 's')
          {
            if (IsAsciiDigit(line[pos]))
            {
              while (pos < linelen && IsAsciiDigit(line[pos]))
                pos++;
              if (pos < linelen && line[pos] == ',' &&
                 ((&line[pos]) - (p+1)) < int(sizeof(result->fe_size)-1) )
              {
                memcpy( result->fe_size, p+1, (unsigned)(&line[pos] - (p+1)) );
                result->fe_size[(&line[pos] - (p+1))] = '\0';
              }
            }
          }
          else if (IsAsciiAlpha(*p)) /* 'i'/'up' or unknown "fact" (property) */
          {
            while (pos < linelen && *++p != ',')
              pos++;
          }
          else if (*p != '\t' || (p+1) != tokens[1])
          {
            break; /* its not EPLF after all */
          }
          else
          {
            state->parsed_one = 1;
            state->lstyle = lstyle = 'E';

            p = &(line[linelen_sans_wsp]);
            result->fe_fname = tokens[1];
            result->fe_fnlen = p - tokens[1];

            if (!result->fe_type) /* access denied */
            {
              result->fe_type = 'f'; /* is assuming 'f'ile correct? */
              return '?';            /* NO! junk it. */
            }
            return result->fe_type;
          }
          if (pos >= (linelen-1) || line[pos] != ',')
            break;
          pos++;
        } /* while (pos < linelen) */
        memset( result, 0, sizeof(*result) );
      } /* if (*line == '+' && linelen > 4 && numtoks >= 2) */
    } /* if (!lstyle && (!state->lstyle || state->lstyle == 'E')) */
#endif /* SUPPORT_EPLF */

    /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

#if defined(SUPPORT_VMS)
    if (!lstyle && (!state->lstyle || state->lstyle == 'V'))
    {                          /* try VMS Multinet/UCX/CMS server */
      /*
       * Legal characters in a VMS file/dir spec are [A-Z0-9$.-_~].
       * '$' cannot begin a filename and `-' cannot be used as the first
       * or last character. '.' is only valid as a directory separator
       * and <file>.<type> separator. A canonical filename spec might look
       * like this: DISK$VOL:[DIR1.DIR2.DIR3]FILE.TYPE;123
       * All VMS FTP servers LIST in uppercase.
       *
       * We need to be picky about this in order to support
       * multi-line listings correctly.
      */
      if (!state->parsed_one &&
          (numtoks == 1 || (numtoks == 2 && toklen[0] == 9 &&
                            memcmp(tokens[0], "Directory", 9)==0 )))
      {
        /* If no dirstyle has been detected yet, and this line is a
         * VMS list's dirname, then turn on VMS dirstyle.
         * eg "ACA:[ANONYMOUS]", "DISK$FTP:[ANONYMOUS]", "SYS$ANONFTP:"
        */
        p = tokens[0];
        pos = toklen[0];
        if (numtoks == 2)
        {
          p = tokens[1];
          pos = toklen[1];
        }
        pos--;
        if (pos >= 3)
        {
          while (pos > 0 && p[pos] != '[')
          {
            pos--;
            if (p[pos] == '-' || p[pos] == '$')
            {
              if (pos == 0 || p[pos-1] == '[' || p[pos-1] == '.' ||
                  (p[pos] == '-' && (p[pos+1] == ']' || p[pos+1] == '.')))
                break;
            }
            else if (p[pos] != '.' && p[pos] != '~' &&
                     !IsAsciiAlphanumeric(p[pos]))
              break;
            else if (IsAsciiLowercaseAlpha(p[pos]))
              break;
          }
          if (pos > 0)
          {
            pos--;
            if (p[pos] != ':' || p[pos+1] != '[')
              pos = 0;
          }
        }
        if (pos > 0 && p[pos] == ':')
        {
          while (pos > 0)
          {
            pos--;
            if (p[pos] != '$' && p[pos] != '_' && p[pos] != '-' &&
                p[pos] != '~' && !IsAsciiAlphanumeric(p[pos]))
              break;
            else if (IsAsciiLowercaseAlpha(p[pos]))
              break;
          }
          if (pos == 0)
          {
            state->lstyle = 'V';
            return '?'; /* its junk */
          }
        }
        /* fallthrough */
      }
      else if ((tokens[0][toklen[0]-1]) != ';')
      {
        if (numtoks == 1 && (state->lstyle == 'V' && !carry_buf_len))
          lstyle = 'V';
        else if (numtoks < 4)
          ;
        else if (toklen[1] >= 10 && memcmp(tokens[1], "%RMS-E-PRV", 10) == 0)
          lstyle = 'V';
        else if ((&line[linelen] - tokens[1]) >= 22 &&
                  memcmp(tokens[1], "insufficient privilege", 22) == 0)
          lstyle = 'V';
        else if (numtoks != 4 && numtoks != 6)
          ;
        else if (numtoks == 6 && (
                 toklen[5] < 4 || *tokens[5] != '(' ||        /* perms */
                           (tokens[5][toklen[5]-1]) != ')'  ))
          ;
        else if (  (toklen[2] == 10 || toklen[2] == 11) &&
                        (tokens[2][toklen[2]-5]) == '-' &&
                        (tokens[2][toklen[2]-9]) == '-' &&
        (((toklen[3]==4 || toklen[3]==5 || toklen[3]==7 || toklen[3]==8) &&
                        (tokens[3][toklen[3]-3]) == ':' ) ||
         ((toklen[3]==10 || toklen[3]==11 ) &&
                        (tokens[3][toklen[3]-3]) == '.' )
        ) &&  /* time in [H]H:MM[:SS[.CC]] format */
                                    IsAsciiDigit(*tokens[1]) && /* size */
                                    IsAsciiDigit(*tokens[2]) && /* date */
                                    IsAsciiDigit(*tokens[3])    /* time */
                )
        {
          lstyle = 'V';
        }
        if (lstyle == 'V')
        {
          /*
          * MultiNet FTP:
          *   LOGIN.COM;2                 1   4-NOV-1994 04:09 [ANONYMOUS] (RWE,RWE,,)
          *   PUB.DIR;1                   1  27-JAN-1994 14:46 [ANONYMOUS] (RWE,RWE,RE,RWE)
          *   README.FTP;1        %RMS-E-PRV, insufficient privilege or file protection violation
          *   ROUSSOS.DIR;1               1  27-JAN-1994 14:48 [CS,ROUSSOS] (RWE,RWE,RE,R)
          *   S67-50903.JPG;1           328  22-SEP-1998 16:19 [ANONYMOUS] (RWED,RWED,,)
          * UCX FTP:
          *   CII-MANUAL.TEX;1  213/216  29-JAN-1996 03:33:12  [ANONYMOU,ANONYMOUS] (RWED,RWED,,)
          * CMU/VMS-IP FTP
          *   [VMSSERV.FILES]ALARM.DIR;1 1/3 5-MAR-1993 18:09
          * TCPware FTP
          *   FOO.BAR;1 4 5-MAR-1993 18:09:01.12
          * Long filename example:
          *   THIS-IS-A-LONG-VMS-FILENAME.AND-THIS-IS-A-LONG-VMS-FILETYPE\r\n
          *                    213[/nnn]  29-JAN-1996 03:33[:nn]  [ANONYMOU,ANONYMOUS] (RWED,RWED,,)
          */
          tokmarker = 0;
          p = tokens[0];
          pos = 0;
          if (*p == '[' && toklen[0] >= 4) /* CMU style */
          {
            if (p[1] != ']')
            {
              p++;
              pos++;
            }
            while (lstyle && pos < toklen[0] && *p != ']')
            {
              if (*p != '$' && *p != '.' && *p != '_' && *p != '-' &&
                  *p != '~' && !IsAsciiAlphanumeric(*p))
                lstyle = 0;
              pos++;
              p++;
            }
            if (lstyle && pos < (toklen[0]-1))
            {
              /* ']' was found and there is at least one character after it */
              NS_ASSERTION(*p == ']', "unexpected state");
              pos++;
              p++;
              tokmarker = pos; /* length of leading "[DIR1.DIR2.etc]" */
            } else {
              /* not a CMU style listing */
              lstyle = 0;
            }
          }
          while (lstyle && pos < toklen[0] && *p != ';')
          {
            if (*p != '$' && *p != '.' && *p != '_' && *p != '-' &&
                *p != '~' && !IsAsciiAlphanumeric(*p))
              lstyle = 0;
            else if (IsAsciiLowercaseAlpha(*p))
              lstyle = 0;
            p++;
            pos++;
          }
          if (lstyle && *p == ';')
          {
            if (pos == 0 || pos == (toklen[0]-1))
              lstyle = 0;
            for (pos++;lstyle && pos < toklen[0];pos++)
            {
              if (!IsAsciiDigit(tokens[0][pos]))
                lstyle = 0;
            }
          }
          pos = (p - tokens[0]); /* => fnlength sans ";####" */
          pos -= tokmarker;      /* => fnlength sans "[DIR1.DIR2.etc]" */
          p = &(tokens[0][tokmarker]); /* offset of basename */

          if (!lstyle || pos == 0 || pos > 80) /* VMS filenames can't be longer than that */
          {
            lstyle = 0;
          }
          else if (numtoks == 1)
          {
            /* if VMS has been detected and there is only one token and that
             * token was a VMS filename then this is a multiline VMS LIST entry.
            */
            if (pos >= (sizeof(state->carry_buf)-1))
              pos = (sizeof(state->carry_buf)-1); /* shouldn't happen */
            memcpy( state->carry_buf, p, pos );
            state->carry_buf_len = pos;
            return '?'; /* tell caller to treat as junk */
          }
          else if (IsAsciiDigit(*tokens[1])) /* not no-privs message */
          {
            for (pos = 0; lstyle && pos < (toklen[1]); pos++)
            {
              if (!IsAsciiDigit((tokens[1][pos])) && (tokens[1][pos]) != '/')
                lstyle = 0;
            }
            if (lstyle && numtoks > 4) /* Multinet or UCX but not CMU */
            {
              for (pos = 1; lstyle && pos < (toklen[5]-1); pos++)
              {
                p = &(tokens[5][pos]);
                if (*p!='R' && *p!='W' && *p!='E' && *p!='D' && *p!=',')
                  lstyle = 0;
              }
            }
          }
        } /* passed initial tests */
      } /* else if ((tokens[0][toklen[0]-1]) != ';') */

      if (lstyle == 'V')
      {
        state->parsed_one = 1;
        state->lstyle = lstyle;

        if (IsAsciiDigit(*tokens[1]))  /* not permission denied etc */
        {
          /* strip leading directory name */
          if (*tokens[0] == '[') /* CMU server */
          {
            pos = toklen[0]-1;
            p = tokens[0]+1;
            while (*p != ']')
            {
              p++;
              pos--;
            }
            toklen[0] = --pos;
            tokens[0] = ++p;
          }
          pos = 0;
          while (pos < toklen[0] && (tokens[0][pos]) != ';')
            pos++;

          result->fe_cinfs = 1;
          result->fe_type = 'f';
          result->fe_fname = tokens[0];
          result->fe_fnlen = pos;

          if (pos > 4)
          {
            p = &(tokens[0][pos-4]);
            if (p[0] == '.' && p[1] == 'D' && p[2] == 'I' && p[3] == 'R')
            {
              result->fe_fnlen -= 4;
              result->fe_type = 'd';
            }
          }

          if (result->fe_type != 'd')
          {
            /* #### or used/allocated form. If used/allocated form, then
             * 'used' is the size in bytes if and only if 'used'<=allocated.
             * If 'used' is size in bytes then it can be > 2^32
             * If 'used' is not size in bytes then it is size in blocks.
            */
            pos = 0;
            while (pos < toklen[1] && (tokens[1][pos]) != '/')
              pos++;

            /*
             * On OpenVMS, the size is given in blocks. A block is 512
             * bytes. This can only approximate the size of the file,
             * but that's better than not showing a size at all.
             * numBlocks is clamped to UINT32_MAX to make 32-bit and
             * 64-bit builds return consistent results.
             */
            uint64_t numBlocks = strtoul(tokens[1], nullptr, 10);
            numBlocks = std::min(numBlocks, (uint64_t)UINT32_MAX);
            uint64_t fileSize = numBlocks * 512;
            SprintfLiteral(result->fe_size, "%" PRIu64, fileSize);
          } /* if (result->fe_type != 'd') */

          p = tokens[2] + 2;
          if (*p == '-')
            p++;
          tbuf[0] = p[0];
          tbuf[1] = ToLowerCaseASCII(p[1]);
          tbuf[2] = ToLowerCaseASCII(p[2]);
          month_num = 0;
          for (pos = 0; pos < (12*3); pos+=3)
          {
            if (tbuf[0] == month_names[pos+0] &&
                tbuf[1] == month_names[pos+1] &&
                tbuf[2] == month_names[pos+2])
              break;
            month_num++;
          }
          if (month_num >= 12)
            month_num = 0;
          result->fe_time.tm_month = month_num;
          result->fe_time.tm_mday = atoi(tokens[2]);
          result->fe_time.tm_year = atoi(p+4); // NSPR wants year as XXXX

          p = tokens[3] + 2;
          if (*p == ':')
            p++;
          if (p[2] == ':')
            result->fe_time.tm_sec = atoi(p+3);
          result->fe_time.tm_hour = atoi(tokens[3]);
          result->fe_time.tm_min  = atoi(p);

          return result->fe_type;

        } /* if (IsAsciiDigit(*tokens[1])) */

        return '?'; /* junk */

      } /* if (lstyle == 'V') */
    } /* if (!lstyle && (!state->lstyle || state->lstyle == 'V')) */
#endif

    /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

#if defined(SUPPORT_CMS)
    /* Virtual Machine/Conversational Monitor System (IBM Mainframe) */
    if (!lstyle && (!state->lstyle || state->lstyle == 'C'))  /* VM/CMS */
    {
      /* LISTing according to mirror.pl
       * Filename FileType  Fm Format Lrecl  Records Blocks Date      Time
       * LASTING  GLOBALV   A1 V      41     21     1       9/16/91   15:10:32
       * J43401   NETLOG    A0 V      77     1      1       9/12/91   12:36:04
       * PROFILE  EXEC      A1 V      17     3      1       9/12/91   12:39:07
       * DIRUNIX  SCRIPT    A1 V      77     1216   17      1/04/93   20:30:47
       * MAIL     PROFILE   A2 F      80     1      1       10/14/92  16:12:27
       * BADY2K   TEXT      A0 V      1      1      1       1/03/102  10:11:12
       * AUTHORS            A1 DIR    -      -      -       9/20/99   10:31:11
       *
       * LISTing from vm.marist.edu and vm.sc.edu
       * 220-FTPSERVE IBM VM Level 420 at VM.MARIST.EDU, 04:58:12 EDT WEDNESDAY 2002-07-10
       * AUTHORS           DIR        -          -          - 1999-09-20 10:31:11 -
       * HARRINGTON        DIR        -          -          - 1997-02-12 15:33:28 -
       * PICS              DIR        -          -          - 2000-10-12 15:43:23 -
       * SYSFILE           DIR        -          -          - 2000-07-20 17:48:01 -
       * WELCNVT  EXEC     V         72          9          1 1999-09-20 17:16:18 -
       * WELCOME  EREADME  F         80         21          1 1999-12-27 16:19:00 -
       * WELCOME  README   V         82         21          1 1999-12-27 16:19:04 -
       * README   ANONYMOU V         71         26          1 1997-04-02 12:33:20 TCP291
       * README   ANONYOLD V         71         15          1 1995-08-25 16:04:27 TCP291
      */
      if (numtoks >= 7 && (toklen[0]+toklen[1]) <= 16)
      {
        for (pos = 1; !lstyle && (pos+5) < numtoks; pos++)
        {
          p = tokens[pos];
          if ((toklen[pos] == 1 && (*p == 'F' || *p == 'V')) ||
              (toklen[pos] == 3 && *p == 'D' && p[1] == 'I' && p[2] == 'R'))
          {
            if (toklen[pos+5] == 8 && (tokens[pos+5][2]) == ':' &&
                                      (tokens[pos+5][5]) == ':'   )
            {
              p = tokens[pos+4];
              if ((toklen[pos+4] == 10 && p[4] == '-' && p[7] == '-') ||
                  (toklen[pos+4] >= 7 && toklen[pos+4] <= 9 &&
                            p[((p[1]!='/')?(2):(1))] == '/' &&
                            p[((p[1]!='/')?(5):(4))] == '/'))
               /* Y2K bugs possible ("7/06/102" or "13/02/101") */
              {
                if ( (*tokens[pos+1] == '-' &&
                      *tokens[pos+2] == '-' &&
                      *tokens[pos+3] == '-')  ||
                      (IsAsciiDigit(*tokens[pos+1]) &&
                       IsAsciiDigit(*tokens[pos+2]) &&
                       IsAsciiDigit(*tokens[pos+3])) )
                {
                  lstyle = 'C';
                  tokmarker = pos;
                }
              }
            }
          }
        } /* for (pos = 1; !lstyle && (pos+5) < numtoks; pos++) */
      } /* if (numtoks >= 7) */

      /* extra checking if first pass */
      if (lstyle && !state->lstyle)
      {
        for (pos = 0, p = tokens[0]; lstyle && pos < toklen[0]; pos++, p++)
        {
          if (IsAsciiLowercaseAlpha(*p))
            lstyle = 0;
        }
        for (pos = tokmarker+1; pos <= tokmarker+3; pos++)
        {
          if (!(toklen[pos] == 1 && *tokens[pos] == '-'))
          {
            for (p = tokens[pos]; lstyle && p<(tokens[pos]+toklen[pos]); p++)
            {
              if (!IsAsciiDigit(*p))
                lstyle = 0;
            }
          }
        }
        for (pos = 0, p = tokens[tokmarker+4];
             lstyle && pos < toklen[tokmarker+4]; pos++, p++)
        {
          if (*p == '/')
          {
            /* There may be Y2K bugs in the date. Don't simplify to
             * pos != (len-3) && pos != (len-6) like time is done.
            */
            if ((tokens[tokmarker+4][1]) == '/')
            {
              if (pos != 1 && pos != 4)
                lstyle = 0;
            }
            else if (pos != 2 && pos != 5)
              lstyle = 0;
          }
          else if (*p != '-' && !IsAsciiDigit(*p))
            lstyle = 0;
          else if (*p == '-' && pos != 4 && pos != 7)
            lstyle = 0;
        }
        for (pos = 0, p = tokens[tokmarker+5];
             lstyle && pos < toklen[tokmarker+5]; pos++, p++)
        {
          if (*p != ':' && !IsAsciiDigit(*p))
            lstyle = 0;
          else if (*p == ':' && pos != (toklen[tokmarker+5]-3)
                             && pos != (toklen[tokmarker+5]-6))
            lstyle = 0;
        }
      } /* initial if() */

      if (lstyle == 'C')
      {
        state->parsed_one = 1;
        state->lstyle = lstyle;

        p = tokens[tokmarker+4];
        if (toklen[tokmarker+4] == 10) /* newstyle: YYYY-MM-DD format */
        {
          result->fe_time.tm_year = atoi(p+0);
          result->fe_time.tm_month  = atoi(p+5) - 1;
          result->fe_time.tm_mday = atoi(p+8);
        }
        else /* oldstyle: [M]M/DD/YY format */
        {
          pos = toklen[tokmarker+4];
          result->fe_time.tm_month  = atoi(p) - 1;
          result->fe_time.tm_mday = atoi((p+pos)-5);
          result->fe_time.tm_year = atoi((p+pos)-2);
          FixupYear(&result->fe_time);
        }

        p = tokens[tokmarker+5];
        pos = toklen[tokmarker+5];
        result->fe_time.tm_hour  = atoi(p);
        result->fe_time.tm_min = atoi((p+pos)-5);
        result->fe_time.tm_sec = atoi((p+pos)-2);

        result->fe_cinfs = 1;
        result->fe_fname = tokens[0];
        result->fe_fnlen = toklen[0];
        result->fe_type  = 'f';

        p = tokens[tokmarker];
        if (toklen[tokmarker] == 3 && *p=='D' && p[1]=='I' && p[2]=='R')
          result->fe_type  = 'd';

        if ((/*newstyle*/ toklen[tokmarker+4] == 10 && tokmarker > 1) ||
            (/*oldstyle*/ toklen[tokmarker+4] != 10 && tokmarker > 2))
        {                            /* have a filetype column */
          char *dot;
          p = &(tokens[0][toklen[0]]);
          memcpy( &dot, &p, sizeof(dot) ); /* NASTY! */
          *dot++ = '.';
          p = tokens[1];
          for (pos = 0; pos < toklen[1]; pos++)
            *dot++ = *p++;
          result->fe_fnlen += 1 + toklen[1];
        }

        /* oldstyle LISTING:
         * files/dirs not on the 'A' minidisk are not RETRievable/CHDIRable
        if (toklen[tokmarker+4] != 10 && *tokens[tokmarker-1] != 'A')
          return '?';
        */

        /* VM/CMS LISTings have no usable filesize field.
         * Have to use the 'SIZE' command for that.
        */
        return result->fe_type;

      } /* if (lstyle == 'C' && (!state->lstyle || state->lstyle == lstyle)) */
    } /* VM/CMS */
#endif

    /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

#if defined(SUPPORT_DOS) /* WinNT DOS dirstyle */
    if (!lstyle && (!state->lstyle || state->lstyle == 'W'))
    {
      /*
       * "10-23-00  01:27PM       <DIR>          veronist"
       * "06-15-00  07:37AM       <DIR>          zoe"
       * "07-14-00  01:35PM              2094926 canprankdesk.tif"
       * "07-21-00  01:19PM                95077 Jon Kauffman Enjoys the Good Life.jpg"
       * "07-21-00  01:19PM                52275 Name Plate.jpg"
       * "07-14-00  01:38PM              2250540 Valentineoffprank-HiRes.jpg"
      */
      // Microsoft FTP server with FtpDirBrowseShowLongDate set returns year
      // in 4-digit format:
      // "10-10-2014  10:10AM       <DIR>        FTP"
      // Windows CE FTP server returns time in 24-hour format:
      // "05-03-13  22:01       <DIR>          APPS"
      if ((numtoks >= 4) && (toklen[0] == 8 || toklen[0] == 10) &&
          (toklen[1] == 5 || toklen[1] == 7) &&
          (*tokens[2] == '<' || IsAsciiDigit(*tokens[2])) )
      {
        p = tokens[0];
        if ( IsAsciiDigit(p[0]) && IsAsciiDigit(p[1]) && p[2]=='-' &&
             IsAsciiDigit(p[3]) && IsAsciiDigit(p[4]) && p[5]=='-' &&
             IsAsciiDigit(p[6]) && IsAsciiDigit(p[7]) )
        {
          p = tokens[1];
          if ( IsAsciiDigit(p[0]) && IsAsciiDigit(p[1]) && p[2]==':' &&
               IsAsciiDigit(p[3]) && IsAsciiDigit(p[4]) &&
               (toklen[1] == 5 || (toklen[1] == 7 &&
                                  (p[5]=='A' || p[5]=='P') && p[6]=='M')))
          {
            lstyle = 'W';
            if (!state->lstyle)
            {
              p = tokens[2];
              /* <DIR> or <JUNCTION> */
              if (*p != '<' || p[toklen[2]-1] != '>')
              {
                for (pos = 1; (lstyle && pos < toklen[2]); pos++)
                {
                  if (!IsAsciiDigit(*++p))
                    lstyle = 0;
                }
              }
            }
          }
        }
      }

      if (lstyle == 'W')
      {
        state->parsed_one = 1;
        state->lstyle = lstyle;

        p = &(line[linelen]); /* line end */
        result->fe_cinfs = 1;
        result->fe_fname = tokens[3];
        result->fe_fnlen = p - tokens[3];
        result->fe_type = 'd';

        if (*tokens[2] != '<') /* not <DIR> or <JUNCTION> */
        {
          // try to handle correctly spaces at the beginning of the filename
          // filesize (token[2]) must end at offset 38
          if (tokens[2] + toklen[2] - line == 38) {
            result->fe_fname = &(line[39]);
            result->fe_fnlen = p - result->fe_fname;
          }
          result->fe_type = 'f';
          pos = toklen[2];
          while (pos > (sizeof(result->fe_size)-1))
            pos = (sizeof(result->fe_size)-1);
          memcpy( result->fe_size, tokens[2], pos );
          result->fe_size[pos] = '\0';
        }
        else {
          // try to handle correctly spaces at the beginning of the filename
          // token[2] must begin at offset 24, the length is 5 or 10
          // token[3] must begin at offset 39 or higher
          if (tokens[2] - line == 24 && (toklen[2] == 5 || toklen[2] == 10) &&
              tokens[3] - line >= 39) {
            result->fe_fname = &(line[39]);
            result->fe_fnlen = p - result->fe_fname;
          }

          if ((tokens[2][1]) != 'D') /* not <DIR> */
          {
            result->fe_type = '?'; /* unknown until junc for sure */
            if (result->fe_fnlen > 4)
            {
              p = result->fe_fname;
              for (pos = result->fe_fnlen - 4; pos > 0; pos--)
              {
                if (p[0] == ' ' && p[3] == ' ' && p[2] == '>' &&
                    (p[1] == '=' || p[1] == '-'))
                {
                  result->fe_type = 'l';
                  result->fe_fnlen = p - result->fe_fname;
                  result->fe_lname = p + 4;
                  result->fe_lnlen = &(line[linelen])
                                     - result->fe_lname;
                  break;
                }
                p++;
              }
            }
          }
        }

        result->fe_time.tm_month = atoi(tokens[0]+0);
        if (result->fe_time.tm_month != 0)
        {
          result->fe_time.tm_month--;
          result->fe_time.tm_mday = atoi(tokens[0]+3);
          result->fe_time.tm_year = atoi(tokens[0]+6);
          FixupYear(&result->fe_time);
        }

        result->fe_time.tm_hour = atoi(tokens[1]+0);
        result->fe_time.tm_min = atoi(tokens[1]+3);
        if (toklen[1] == 7)
        {
          if ((tokens[1][5]) == 'P' && result->fe_time.tm_hour < 12)
            result->fe_time.tm_hour += 12;
          else if ((tokens[1][5]) == 'A' && result->fe_time.tm_hour == 12)
            result->fe_time.tm_hour = 0;
        }

        /* the caller should do this (if dropping "." and ".." is desired)
        if (result->fe_type == 'd' && result->fe_fname[0] == '.' &&
            (result->fe_fnlen == 1 || (result->fe_fnlen == 2 &&
                                      result->fe_fname[1] == '.')))
          return '?';
        */

        return result->fe_type;
      } /* if (lstyle == 'W' && (!state->lstyle || state->lstyle == lstyle)) */
    } /* if (!lstyle && (!state->lstyle || state->lstyle == 'W')) */
#endif

    /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

#if defined(SUPPORT_OS2)
    if (!lstyle && (!state->lstyle || state->lstyle == 'O')) /* OS/2 test */
    {
      /* 220 server IBM TCP/IP for OS/2 - FTP Server ver 23:04:36 on Jan 15 1997 ready.
      * fixed position, space padded columns. I have only a vague idea
      * of what the contents between col 18 and 34 might be: All I can infer
      * is that there may be attribute flags in there and there may be
      * a " DIR" in there.
      *
      *          1         2         3         4         5         6
      *0123456789012345678901234567890123456789012345678901234567890123456789
      *----- size -------|??????????????? MM-DD-YY|  HH:MM| nnnnnnnnn....
      *                 0  DIR            04-11-95   16:26  .
      *                 0  DIR            04-11-95   16:26  ..
      *                 0  DIR            04-11-95   16:26  ADDRESS
      *               612  RHSA           07-28-95   16:45  air_tra1.bag
      *               195  A              08-09-95   10:23  Alfa1.bag
      *                 0  RHS   DIR      04-11-95   16:26  ATTACH
      *               372  A              08-09-95   10:26  Aussie_1.bag
      *            310992                 06-28-94   09:56  INSTALL.EXE
      *                            1         2         3         4
      *                  01234567890123456789012345678901234567890123456789
      * dirlist from the mirror.pl project, col positions from Mozilla.
      */
      p = &(line[toklen[0]]);
      /* \s(\d\d-\d\d-\d\d)\s+(\d\d:\d\d)\s */
      if (numtoks >= 4 && toklen[0] <= 18 && IsAsciiDigit(*tokens[0]) &&
         (linelen - toklen[0]) >= (53-18)                        &&
         p[18-18] == ' ' && p[34-18] == ' '                      &&
         p[37-18] == '-' && p[40-18] == '-' && p[43-18] == ' '   &&
         p[45-18] == ' ' && p[48-18] == ':' && p[51-18] == ' '   &&
         IsAsciiDigit(p[35-18]) && IsAsciiDigit(p[36-18])                  &&
         IsAsciiDigit(p[38-18]) && IsAsciiDigit(p[39-18])                  &&
         IsAsciiDigit(p[41-18]) && IsAsciiDigit(p[42-18])                  &&
         IsAsciiDigit(p[46-18]) && IsAsciiDigit(p[47-18])                  &&
         IsAsciiDigit(p[49-18]) && IsAsciiDigit(p[50-18])
      )
      {
        lstyle = 'O'; /* OS/2 */
        if (!state->lstyle)
        {
          for (pos = 1; lstyle && pos < toklen[0]; pos++)
          {
            if (!IsAsciiDigit(tokens[0][pos]))
              lstyle = 0;
          }
        }
      }

      if (lstyle == 'O')
      {
        state->parsed_one = 1;
        state->lstyle = lstyle;

        p = &(line[toklen[0]]);

        result->fe_cinfs = 1;
        result->fe_fname = &p[53-18];
        result->fe_fnlen = (&(line[linelen_sans_wsp]))
                           - (result->fe_fname);
        result->fe_type = 'f';

        /* I don't have a real listing to determine exact pos, so scan. */
        for (pos = (18-18); pos < ((35-18)-4); pos++)
        {
          if (p[pos+0] == ' ' && p[pos+1] == 'D' &&
              p[pos+2] == 'I' && p[pos+3] == 'R')
          {
            result->fe_type = 'd';
            break;
          }
        }

        if (result->fe_type != 'd')
        {
          pos = toklen[0];
          if (pos > (sizeof(result->fe_size)-1))
            pos = (sizeof(result->fe_size)-1);
          memcpy( result->fe_size, tokens[0], pos );
          result->fe_size[pos] = '\0';
        }

        result->fe_time.tm_month = atoi(&p[35-18]) - 1;
        result->fe_time.tm_mday = atoi(&p[38-18]);
        result->fe_time.tm_year = atoi(&p[41-18]);
        FixupYear(&result->fe_time);
        result->fe_time.tm_hour = atoi(&p[46-18]);
        result->fe_time.tm_min = atoi(&p[49-18]);

        /* the caller should do this (if dropping "." and ".." is desired)
        if (result->fe_type == 'd' && result->fe_fname[0] == '.' &&
            (result->fe_fnlen == 1 || (result->fe_fnlen == 2 &&
                                      result->fe_fname[1] == '.')))
          return '?';
        */

        return result->fe_type;
      } /* if (lstyle == 'O') */

    } /* if (!lstyle && (!state->lstyle || state->lstyle == 'O')) */
#endif

    /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

#if defined(SUPPORT_LSL)
    if (!lstyle && (!state->lstyle || state->lstyle == 'U')) /* /bin/ls & co. */
    {
      /* UNIX-style listing, without inum and without blocks
       * "-rw-r--r--   1 root     other        531 Jan 29 03:26 README"
       * "dr-xr-xr-x   2 root     other        512 Apr  8  1994 etc"
       * "dr-xr-xr-x   2 root     512 Apr  8  1994 etc"
       * "lrwxrwxrwx   1 root     other          7 Jan 25 00:17 bin -> usr/bin"
       * Also produced by Microsoft's FTP servers for Windows:
       * "----------   1 owner    group         1803128 Jul 10 10:18 ls-lR.Z"
       * "d---------   1 owner    group               0 May  9 19:45 Softlib"
       * Also WFTPD for MSDOS:
       * "-rwxrwxrwx   1 noone    nogroup      322 Aug 19  1996 message.ftp"
       * Hellsoft for NetWare:
       * "d[RWCEMFA] supervisor            512       Jan 16 18:53    login"
       * "-[RWCEMFA] rhesus             214059       Oct 20 15:27    cx.exe"
       * Newer Hellsoft for NetWare: (netlab2.usu.edu)
       * - [RWCEAFMS] NFAUUser               192 Apr 27 15:21 HEADER.html
       * d [RWCEAFMS] jrd                    512 Jul 11 03:01 allupdates
       * Also NetPresenz for the Mac:
       * "-------r--         326  1391972  1392298 Nov 22  1995 MegaPhone.sit"
       * "drwxrwxr-x               folder        2 May 10  1996 network"
       * Protected directory:
       * "drwx-wx-wt  2 root  wheel  512 Jul  1 02:15 incoming"
       * uid/gid instead of username/groupname:
       * "drwxr-xr-x  2 0  0  512 May 28 22:17 etc"
      */

      bool is_old_Hellsoft = false;

      if (numtoks >= 6)
      {
        /* there are two perm formats (Hellsoft/NetWare and *IX strmode(3)).
         * Scan for size column only if the perm format is one or the other.
         */
        if (toklen[0] == 1 || (tokens[0][1]) == '[')
        {
          if (*tokens[0] == 'd' || *tokens[0] == '-')
          {
            pos = toklen[0]-1;
            p = tokens[0] + 1;
            if (pos == 0)
            {
              p = tokens[1];
              pos = toklen[1];
            }
            if ((pos == 9 || pos == 10)        &&
                (*p == '[' && p[pos-1] == ']') &&
                (p[1] == 'R' || p[1] == '-')   &&
                (p[2] == 'W' || p[2] == '-')   &&
                (p[3] == 'C' || p[3] == '-')   &&
                (p[4] == 'E' || p[4] == '-'))
            {
              /* rest is FMA[S] or AFM[S] */
              lstyle = 'U'; /* very likely one of the NetWare servers */
              if (toklen[0] == 10)
                is_old_Hellsoft = true;
            }
          }
        }
        else if ((toklen[0] == 10 || toklen[0] == 11)
                   && strchr("-bcdlpsw?DFam", *tokens[0]))
        {
          p = &(tokens[0][1]);
          if ((p[0] == 'r' || p[0] == '-') &&
              (p[1] == 'w' || p[1] == '-') &&
              (p[3] == 'r' || p[3] == '-') &&
              (p[4] == 'w' || p[4] == '-') &&
              (p[6] == 'r' || p[6] == '-') &&
              (p[7] == 'w' || p[7] == '-'))
            /* 'x'/p[9] can be S|s|x|-|T|t or implementation specific */
          {
            lstyle = 'U'; /* very likely /bin/ls */
          }
        }
      }
      if (lstyle == 'U') /* first token checks out */
      {
        lstyle = 0;
        for (pos = (numtoks-5); !lstyle && pos > 1; pos--)
        {
          /* scan for: (\d+)\s+([A-Z][a-z][a-z])\s+
           *  (\d\d\d\d|\d\:\d\d|\d\d\:\d\d|\d\:\d\d\:\d\d|\d\d\:\d\d\:\d\d)
           *  \s+(.+)$
          */
          if (IsAsciiDigit(*tokens[pos]) /* size */
              /* (\w\w\w) */
           && toklen[pos+1] == 3 && IsAsciiAlpha(*tokens[pos+1]) &&
              IsAsciiAlpha(tokens[pos+1][1]) && IsAsciiAlpha(tokens[pos+1][2])
              /* (\d|\d\d) */
           && IsAsciiDigit(*tokens[pos+2]) &&
                (toklen[pos+2] == 1 ||
                  (toklen[pos+2] == 2 && IsAsciiDigit(tokens[pos+2][1])))
           && toklen[pos+3] >= 4 && IsAsciiDigit(*tokens[pos+3])
              /* (\d\:\d\d\:\d\d|\d\d\:\d\d\:\d\d) */
           && (toklen[pos+3] <= 5 || (
               (toklen[pos+3] == 7 || toklen[pos+3] == 8) &&
               (tokens[pos+3][toklen[pos+3]-3]) == ':'))
           && IsAsciiDigit(tokens[pos+3][toklen[pos+3]-2])
           && IsAsciiDigit(tokens[pos+3][toklen[pos+3]-1])
           && (
              /* (\d\d\d\d) */
                 ((toklen[pos+3] == 4 || toklen[pos+3] == 5) &&
                  IsAsciiDigit(tokens[pos+3][1]) &&
                  IsAsciiDigit(tokens[pos+3][2])  )
              /* (\d\:\d\d|\d\:\d\d\:\d\d) */
              || ((toklen[pos+3] == 4 || toklen[pos+3] == 7) &&
                  (tokens[pos+3][1]) == ':' &&
                  IsAsciiDigit(tokens[pos+3][2]) && IsAsciiDigit(tokens[pos+3][3]))
              /* (\d\d\:\d\d|\d\d\:\d\d\:\d\d) */
              || ((toklen[pos+3] == 5 || toklen[pos+3] == 8) &&
                  IsAsciiDigit(tokens[pos+3][1]) && (tokens[pos+3][2]) == ':' &&
                  IsAsciiDigit(tokens[pos+3][3]) && IsAsciiDigit(tokens[pos+3][4]))
              )
           )
          {
            lstyle = 'U'; /* assume /bin/ls or variant format */
            tokmarker = pos;

            /* check that size is numeric */
            p = tokens[tokmarker];
            unsigned int i;
            for (i = 0; i < toklen[tokmarker]; i++)
            {
              if (!IsAsciiDigit(*p++))
              {
                lstyle = 0;
                break;
              }
            }
            if (lstyle)
            {
              month_num = 0;
              p = tokens[tokmarker+1];
              for (i = 0; i < (12*3); i+=3)
              {
                if (p[0] == month_names[i+0] &&
                    p[1] == month_names[i+1] &&
                    p[2] == month_names[i+2])
                  break;
                month_num++;
              }
              if (month_num >= 12)
                lstyle = 0;
            }
          } /* relative position test */
        } /* for (pos = (numtoks-5); !lstyle && pos > 1; pos--) */
      } /* if (lstyle == 'U') */

      if (lstyle == 'U')
      {
        state->parsed_one = 1;
        state->lstyle = lstyle;

        result->fe_cinfs = 0;
        result->fe_type = '?';
        if (*tokens[0] == 'd' || *tokens[0] == 'l')
          result->fe_type = *tokens[0];
        else if (*tokens[0] == 'D')
          result->fe_type = 'd';
        else if (*tokens[0] == '-' || *tokens[0] == 'F')
          result->fe_type = 'f'; /* (hopefully a regular file) */

        if (result->fe_type != 'd')
        {
          pos = toklen[tokmarker];
          if (pos > (sizeof(result->fe_size)-1))
            pos = (sizeof(result->fe_size)-1);
          memcpy( result->fe_size, tokens[tokmarker], pos );
          result->fe_size[pos] = '\0';
        }

        result->fe_time.tm_month  = month_num;
        result->fe_time.tm_mday = atoi(tokens[tokmarker+2]);
        if (result->fe_time.tm_mday == 0)
          result->fe_time.tm_mday++;

        p = tokens[tokmarker+3];
        pos = (unsigned int)atoi(p);
        if (p[1] == ':') /* one digit hour */
          p--;
        if (p[2] != ':') /* year */
        {
          result->fe_time.tm_year = pos;
        }
        else
        {
          result->fe_time.tm_hour = pos;
          result->fe_time.tm_min  = atoi(p+3);
          if (p[5] == ':')
            result->fe_time.tm_sec = atoi(p+6);

          if (!state->now_time)
          {
            state->now_time = nowTimeFn();
            PR_ExplodeTime((state->now_time), timeParam, &(state->now_tm) );
          }

          result->fe_time.tm_year = state->now_tm.tm_year;
          if ( (( state->now_tm.tm_month << 5) + state->now_tm.tm_mday) <
               ((result->fe_time.tm_month << 5) + result->fe_time.tm_mday) )
            result->fe_time.tm_year--;

        } /* time/year */

        // The length of the whole date string should be 12. On AIX the length
        // is only 11 when the year is present in the date string and there is
        // 1 padding space at the end of the string. In both cases the filename
        // starts at offset 13 from the start of the date string.
        // Don't care about leading spaces when the date string has different
        // format or when old Hellsoft output was detected.
        {
          const char *date_start = tokens[tokmarker+1];
          const char *date_end = tokens[tokmarker+3] + toklen[tokmarker+3];
          if (!is_old_Hellsoft && ((date_end - date_start) == 12 ||
              ((date_end - date_start) == 11 && date_end[1] == ' ')))
            result->fe_fname = date_start + 13;
          else
            result->fe_fname = tokens[tokmarker+4];
        }

        result->fe_fnlen = (&(line[linelen]))
                           - (result->fe_fname);

        if (result->fe_type == 'l' && result->fe_fnlen > 4)
        {
          /* First try to use result->fe_size to find " -> " sequence.
             This can give proper result for cases like "aaa -> bbb -> ccc". */
          uintptr_t fe_size = atoi(result->fe_size);
          CheckedInt<uintptr_t> arrow_start(result->fe_fnlen);
          arrow_start -= fe_size;
          arrow_start -= 4;

          if (arrow_start.isValid() &&
              PL_strncmp(result->fe_fname + arrow_start.value(), " -> ", 4) == 0)
          {
            result->fe_lname = result->fe_fname + (result->fe_fnlen - fe_size);
            result->fe_lnlen = (&(line[linelen])) - (result->fe_lname);
            result->fe_fnlen = arrow_start.value();
          }
          else
          {
            /* Search for sequence " -> " from the end for case when there are
               more occurrences. F.e. if ftpd returns "a -> b -> c" assume
               "a -> b" as a name. Powerusers can remove unnecessary parts
               manually but there is no way to follow the link when some
               essential part is missing. */
            p = result->fe_fname + (result->fe_fnlen - 5);
            for (pos = (result->fe_fnlen - 5); pos > 0; pos--)
            {
              if (PL_strncmp(p, " -> ", 4) == 0)
              {
                result->fe_lname = p + 4;
                result->fe_lnlen = (&(line[linelen]))
                                 - (result->fe_lname);
                result->fe_fnlen = pos;
                break;
              }
              p--;
            }
          }
        }

#if defined(SUPPORT_LSLF) /* some (very rare) servers return ls -lF */
        if (result->fe_fnlen > 1)
        {
          p = result->fe_fname[result->fe_fnlen-1];
          pos = result->fe_type;
          if (pos == 'd') {
             if (*p == '/') result->fe_fnlen--; /* directory */
          } else if (pos == 'l') {
             if (*p == '@') result->fe_fnlen--; /* symlink */
          } else if (pos == 'f') {
             if (*p == '*') result->fe_fnlen--; /* executable */
          } else if (*p == '=' || *p == '%' || *p == '|') {
            result->fe_fnlen--; /* socket, whiteout, fifo */
          }
        }
#endif

        /* the caller should do this (if dropping "." and ".." is desired)
        if (result->fe_type == 'd' && result->fe_fname[0] == '.' &&
            (result->fe_fnlen == 1 || (result->fe_fnlen == 2 &&
                                      result->fe_fname[1] == '.')))
          return '?';
        */

        return result->fe_type;

      } /* if (lstyle == 'U') */

    } /* if (!lstyle && (!state->lstyle || state->lstyle == 'U')) */
#endif

    /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

#if defined(SUPPORT_W16) /* 16bit Windows */
    if (!lstyle && (!state->lstyle || state->lstyle == 'w'))
    {       /* old SuperTCP suite FTP server for Win3.1 */
            /* old NetManage Chameleon TCP/IP suite FTP server for Win3.1 */
      /*
      * SuperTCP dirlist from the mirror.pl project
      * mon/day/year separator may be '/' or '-'.
      * .               <DIR>           11-16-94        17:16
      * ..              <DIR>           11-16-94        17:16
      * INSTALL         <DIR>           11-16-94        17:17
      * CMT             <DIR>           11-21-94        10:17
      * DESIGN1.DOC          11264      05-11-95        14:20
      * README.TXT            1045      05-10-95        11:01
      * WPKIT1.EXE          960338      06-21-95        17:01
      * CMT.CSV                  0      07-06-95        14:56
      *
      * Chameleon dirlist guessed from lynx
      * .               <DIR>      Nov 16 1994 17:16
      * ..              <DIR>      Nov 16 1994 17:16
      * INSTALL         <DIR>      Nov 16 1994 17:17
      * CMT             <DIR>      Nov 21 1994 10:17
      * DESIGN1.DOC     11264      May 11 1995 14:20   A
      * README.TXT       1045      May 10 1995 11:01
      * WPKIT1.EXE     960338      Jun 21 1995 17:01   R
      * CMT.CSV             0      Jul 06 1995 14:56   RHA
      */
      if (numtoks >= 4 && toklen[0] < 13 &&
          ((toklen[1] == 5 && *tokens[1] == '<') || IsAsciiDigit(*tokens[1])) )
      {
        if (numtoks == 4
         && (toklen[2] == 8 || toklen[2] == 9)
         && (((tokens[2][2]) == '/' && (tokens[2][5]) == '/') ||
             ((tokens[2][2]) == '-' && (tokens[2][5]) == '-'))
         && (toklen[3] == 4 || toklen[3] == 5)
         && (tokens[3][toklen[3]-3]) == ':'
         && IsAsciiDigit(tokens[2][0]) && IsAsciiDigit(tokens[2][1])
         && IsAsciiDigit(tokens[2][3]) && IsAsciiDigit(tokens[2][4])
         && IsAsciiDigit(tokens[2][6]) && IsAsciiDigit(tokens[2][7])
         && (toklen[2] < 9 || IsAsciiDigit(tokens[2][8]))
         && IsAsciiDigit(tokens[3][toklen[3]-1]) && IsAsciiDigit(tokens[3][toklen[3]-2])
         && IsAsciiDigit(tokens[3][toklen[3]-4]) && IsAsciiDigit(*tokens[3])
         )
        {
          lstyle = 'w';
        }
        else if ((numtoks == 6 || numtoks == 7)
         && toklen[2] == 3 && toklen[3] == 2
         && toklen[4] == 4 && toklen[5] == 5
         && (tokens[5][2]) == ':'
         && IsAsciiAlpha(tokens[2][0]) && IsAsciiAlpha(tokens[2][1])
         &&                               IsAsciiAlpha(tokens[2][2])
         && IsAsciiDigit(tokens[3][0]) && IsAsciiDigit(tokens[3][1])
         && IsAsciiDigit(tokens[4][0]) && IsAsciiDigit(tokens[4][1])
         && IsAsciiDigit(tokens[4][2]) && IsAsciiDigit(tokens[4][3])
         && IsAsciiDigit(tokens[5][0]) && IsAsciiDigit(tokens[5][1])
         && IsAsciiDigit(tokens[5][3]) && IsAsciiDigit(tokens[5][4])
         /* could also check that (&(tokens[5][5]) - tokens[2]) == 17 */
        )
        {
          lstyle = 'w';
        }
        if (lstyle && state->lstyle != lstyle) /* first time */
        {
          p = tokens[1];
          if (toklen[1] != 5 || p[0] != '<' || p[1] != 'D' ||
                 p[2] != 'I' || p[3] != 'R' || p[4] != '>')
          {
            for (pos = 0; lstyle && pos < toklen[1]; pos++)
            {
              if (!IsAsciiDigit(*p++))
                lstyle = 0;
            }
          } /* not <DIR> */
        } /* if (first time) */
      } /* if (numtoks == ...) */

      if (lstyle == 'w')
      {
        state->parsed_one = 1;
        state->lstyle = lstyle;

        result->fe_cinfs = 1;
        result->fe_fname = tokens[0];
        result->fe_fnlen = toklen[0];
        result->fe_type = 'd';

        p = tokens[1];
        if (IsAsciiDigit(*p))
        {
          result->fe_type = 'f';
          pos = toklen[1];
          if (pos > (sizeof(result->fe_size)-1))
            pos = sizeof(result->fe_size)-1;
          memcpy( result->fe_size, p, pos );
          result->fe_size[pos] = '\0';
        }

        p = tokens[2];
        if (toklen[2] == 3) /* Chameleon */
        {
          tbuf[0] = ToUpperCaseASCII(p[0]);
          tbuf[1] = ToLowerCaseASCII(p[1]);
          tbuf[2] = ToLowerCaseASCII(p[2]);
          for (pos = 0; pos < (12*3); pos+=3)
          {
            if (tbuf[0] == month_names[pos+0] &&
                tbuf[1] == month_names[pos+1] &&
                tbuf[2] == month_names[pos+2])
            {
              result->fe_time.tm_month = pos/3;
              result->fe_time.tm_mday = atoi(tokens[3]);
              result->fe_time.tm_year = atoi(tokens[4]);
              break;
            }
          }
          pos = 5; /* Chameleon toknum of date field */
        }
        else
        {
          result->fe_time.tm_month = atoi(p+0)-1;
          result->fe_time.tm_mday = atoi(p+3);
          result->fe_time.tm_year = atoi(p+6);
          FixupYear(&result->fe_time); /* SuperTCP */

          pos = 3; /* SuperTCP toknum of date field */
        }

        result->fe_time.tm_hour = atoi(tokens[pos]);
        result->fe_time.tm_min = atoi(&(tokens[pos][toklen[pos]-2]));

        /* the caller should do this (if dropping "." and ".." is desired)
        if (result->fe_type == 'd' && result->fe_fname[0] == '.' &&
            (result->fe_fnlen == 1 || (result->fe_fnlen == 2 &&
                                      result->fe_fname[1] == '.')))
          return '?';
        */

        return result->fe_type;
      } /* (lstyle == 'w') */

    } /* if (!lstyle && (!state->lstyle || state->lstyle == 'w'))  */
#endif

    /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

#if defined(SUPPORT_DLS) /* dls -dtR */
    if (!lstyle &&
       (state->lstyle == 'D' || (!state->lstyle && state->numlines == 1)))
       /* /bin/dls lines have to be immediately recognizable (first line) */
    {
      /* I haven't seen an FTP server that delivers a /bin/dls listing,
       * but can infer the format from the lynx and mirror.pl projects.
       * Both formats are supported.
       *
       * Lynx says:
       * README              763  Information about this server\0
       * bin/                  -  \0
       * etc/                  =  \0
       * ls-lR                 0  \0
       * ls-lR.Z               3  \0
       * pub/                  =  Public area\0
       * usr/                  -  \0
       * morgan               14  -> ../real/morgan\0
       * TIMIT.mostlikely.Z\0
       *                   79215  \0
       *
       * mirror.pl says:
       * filename:  ^(\S*)\s+
       * size:      (\-|\=|\d+)\s+
       * month/day: ((\w\w\w\s+\d+|\d+\s+\w\w\w)\s+
       * time/year: (\d+:\d+|\d\d\d\d))\s+
       * rest:      (.+)
       *
       * README              763  Jul 11 21:05  Information about this server
       * bin/                  -  Apr 28  1994
       * etc/                  =  11 Jul 21:04
       * ls-lR                 0   6 Aug 17:14
       * ls-lR.Z               3  05 Sep 1994
       * pub/                  =  Jul 11 21:04  Public area
       * usr/                  -  Sep  7 09:39
       * morgan               14  Apr 18 09:39  -> ../real/morgan
       * TIMIT.mostlikely.Z
       *                   79215  Jul 11 21:04
      */
      if (!state->lstyle && line[linelen-1] == ':' &&
          linelen >= 2 && toklen[numtoks-1] != 1)
      {
        /* code in mirror.pl suggests that a listing may be preceded
         * by a PWD line in the form "/some/dir/names/here:"
         * but does not necessarily begin with '/'. *sigh*
        */
        pos = 0;
        p = line;
        while (pos < (linelen-1))
        {
          /* illegal (or extremely unusual) chars in a dirspec */
          if (*p == '<' || *p == '|' || *p == '>' ||
              *p == '?' || *p == '*' || *p == '\\')
            break;
          if (*p == '/' && pos < (linelen-2) && p[1] == '/')
            break;
          pos++;
          p++;
        }
        if (pos == (linelen-1))
        {
          state->lstyle = 'D';
          return '?';
        }
      }

      if (!lstyle && numtoks >= 2)
      {
        pos = 22; /* pos of (\d+|-|=) if this is not part of a multiline */
        if (state->lstyle && carry_buf_len) /* first is from previous line */
          pos = toklen[1]-1; /* and is 'as-is' (may contain whitespace) */

        if (linelen > pos)
        {
          p = &line[pos];
          if ((*p == '-' || *p == '=' || IsAsciiDigit(*p)) &&
              ((linelen == (pos+1)) ||
               (linelen >= (pos+3) && p[1] == ' ' && p[2] == ' ')) )
          {
            tokmarker = 1;
            if (!carry_buf_len)
            {
              pos = 1;
              while (pos < numtoks && (tokens[pos]+toklen[pos]) < (&line[23]))
                pos++;
              tokmarker = 0;
              if ((tokens[pos]+toklen[pos]) == (&line[23]))
                tokmarker = pos;
            }
            if (tokmarker)
            {
              lstyle = 'D';
              if (*tokens[tokmarker] == '-' || *tokens[tokmarker] == '=')
              {
                if (toklen[tokmarker] != 1 ||
                   (tokens[tokmarker-1][toklen[tokmarker-1]-1]) != '/')
                  lstyle = 0;
              }
              else
              {
                for (pos = 0; lstyle && pos < toklen[tokmarker]; pos++)
                {
                  if (!IsAsciiDigit(tokens[tokmarker][pos]))
                    lstyle = 0;
                }
              }
              if (lstyle && !state->lstyle) /* first time */
              {
                /* scan for illegal (or incredibly unusual) chars in fname */
                for (p = tokens[0]; lstyle &&
                     p < &(tokens[tokmarker-1][toklen[tokmarker-1]]); p++)
                {
                  if (*p == '<' || *p == '|' || *p == '>' ||
                      *p == '?' || *p == '*' || *p == '/' || *p == '\\')
                    lstyle = 0;
                }
              }

            } /* size token found */
          } /* expected chars behind expected size token */
        } /* if (linelen > pos) */
      } /* if (!lstyle && numtoks >= 2) */

      if (!lstyle && state->lstyle == 'D' && !carry_buf_len)
      {
        /* the filename of a multi-line entry can be identified
         * correctly only if dls format had been previously established.
         * This should always be true because there should be entries
         * for '.' and/or '..' and/or CWD that precede the rest of the
         * listing.
        */
        pos = linelen;
        if (pos > (sizeof(state->carry_buf)-1))
          pos = sizeof(state->carry_buf)-1;
        memcpy( state->carry_buf, line, pos );
        state->carry_buf_len = pos;
        return '?';
      }

      if (lstyle == 'D')
      {
        state->parsed_one = 1;
        state->lstyle = lstyle;

        p = &(tokens[tokmarker-1][toklen[tokmarker-1]]);
        result->fe_fname = tokens[0];
        result->fe_fnlen = p - tokens[0];
        result->fe_type  = 'f';

        if (result->fe_fname[result->fe_fnlen-1] == '/')
        {
          if (result->fe_lnlen == 1)
            result->fe_type = '?';
          else
          {
            result->fe_fnlen--;
            result->fe_type  = 'd';
          }
        }
        else if (IsAsciiDigit(*tokens[tokmarker]))
        {
          pos = toklen[tokmarker];
          if (pos > (sizeof(result->fe_size)-1))
            pos = sizeof(result->fe_size)-1;
          memcpy( result->fe_size, tokens[tokmarker], pos );
          result->fe_size[pos] = '\0';
        }

        if ((tokmarker+3) < numtoks &&
              (&(tokens[numtoks-1][toklen[numtoks-1]]) -
               tokens[tokmarker+1]) >= (1+1+3+1+4) )
        {
          pos = (tokmarker+3);
          p = tokens[pos];
          pos = toklen[pos];

          if ((pos == 4 || pos == 5)
          &&  IsAsciiDigit(*p) && IsAsciiDigit(p[pos-1]) && IsAsciiDigit(p[pos-2])
          &&  ((pos == 5 && p[2] == ':') ||
               (pos == 4 && (IsAsciiDigit(p[1]) || p[1] == ':')))
             )
          {
            month_num = tokmarker+1; /* assumed position of month field */
            pos = tokmarker+2;       /* assumed position of mday field */
            if (IsAsciiDigit(*tokens[month_num])) /* positions are reversed */
            {
              month_num++;
              pos--;
            }
            p = tokens[month_num];
            if (IsAsciiDigit(*tokens[pos])
            && (toklen[pos] == 1 ||
                  (toklen[pos] == 2 && IsAsciiDigit(tokens[pos][1])))
            && toklen[month_num] == 3
            && IsAsciiAlpha(*p) && IsAsciiAlpha(p[1]) && IsAsciiAlpha(p[2])  )
            {
              pos = atoi(tokens[pos]);
              if (pos > 0 && pos <= 31)
              {
                result->fe_time.tm_mday = pos;
                month_num = 1;
                for (pos = 0; pos < (12*3); pos+=3)
                {
                  if (p[0] == month_names[pos+0] &&
                      p[1] == month_names[pos+1] &&
                      p[2] == month_names[pos+2])
                    break;
                  month_num++;
                }
                if (month_num > 12)
                  result->fe_time.tm_mday = 0;
                else
                  result->fe_time.tm_month = month_num - 1;
              }
            }
            if (result->fe_time.tm_mday)
            {
              tokmarker += 3; /* skip mday/mon/yrtime (to find " -> ") */
              p = tokens[tokmarker];

              pos = atoi(p);
              if (pos > 24)
                result->fe_time.tm_year = pos;
              else
              {
                if (p[1] == ':')
                  p--;
                result->fe_time.tm_hour = pos;
                result->fe_time.tm_min = atoi(p+3);
                if (!state->now_time)
                {
                  state->now_time = nowTimeFn();
                  PR_ExplodeTime((state->now_time), timeParam, &(state->now_tm) );
                }
                result->fe_time.tm_year = state->now_tm.tm_year;
                if ( (( state->now_tm.tm_month  << 4) + state->now_tm.tm_mday) <
                     ((result->fe_time.tm_month << 4) + result->fe_time.tm_mday) )
                  result->fe_time.tm_year--;
              } /* got year or time */
            } /* got month/mday */
          } /* may have year or time */
        } /* enough remaining to possibly have date/time */

        if (numtoks > (tokmarker+2))
        {
          pos = tokmarker+1;
          p = tokens[pos];
          if (toklen[pos] == 2 && *p == '-' && p[1] == '>')
          {
            p = &(tokens[numtoks-1][toklen[numtoks-1]]);
            result->fe_type  = 'l';
            result->fe_lname = tokens[pos+1];
            result->fe_lnlen = p - result->fe_lname;
            if (result->fe_lnlen > 1 &&
                result->fe_lname[result->fe_lnlen-1] == '/')
              result->fe_lnlen--;
          }
        } /* if (numtoks > (tokmarker+2)) */

        /* the caller should do this (if dropping "." and ".." is desired)
        if (result->fe_type == 'd' && result->fe_fname[0] == '.' &&
            (result->fe_fnlen == 1 || (result->fe_fnlen == 2 &&
                                      result->fe_fname[1] == '.')))
          return '?';
        */

        return result->fe_type;

      } /* if (lstyle == 'D') */
    } /* if (!lstyle && (!state->lstyle || state->lstyle == 'D')) */
#endif

    /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

  } /* if (linelen > 0) */

  return ParsingFailed(state);
}


Coverage Report

Created: 2018-09-25 14:53