LCOV - code coverage report
Current view: top level - ucb/source/ucp/ftp - ftpdirp.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 670 0.0 %
Date: 2014-04-14 Functions: 0 11 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : /**************************************************************************
      22             :                                 TODO
      23             :  **************************************************************************
      24             : 
      25             :  *************************************************************************/
      26             : #include "ftpdirp.hxx"
      27             : #include <osl/time.h>
      28             : 
      29             : 
      30             : using namespace ftp;
      31             : 
      32             : typedef sal_uInt32 ULONG;
      33             : 
      34             : 
      35             : inline sal_Bool ascii_isLetter( sal_Unicode ch )
      36             : {
      37             :     return (( (ch >= 0x0041) && (ch <= 0x005A)) ||
      38             :             (( ch >= 0x0061) && (ch <= 0x007A)));
      39             : }
      40             : 
      41           0 : inline sal_Bool ascii_isWhitespace( sal_Unicode ch )
      42             : {
      43           0 :     return ((ch <= 0x20) && ch);
      44             : }
      45             : 
      46             : 
      47             : 
      48             : /*========================================================================
      49             :  *
      50             :  * FTPDirectoryParser implementation.
      51             :  *
      52             :  *======================================================================*/
      53             : /*
      54             :  * parseDOS.
      55             :  * Accepts one of two styles:
      56             :  *
      57             :  * 1  *WSP 1*2DIGIT ("." / "-") 1*2DIGIT ("." / "-") 1*4DIGIT 1*WSP
      58             :  *    1*2DIGIT ":" 1*2DIGIT [*WSP ("A" / "P") "M"] 1*WSP
      59             :  *    ((DIGIT *(DIGIT / "." / ",")) / "<DIR>") 1*WSP 1*OCTET
      60             :  *
      61             :  *    interpreted as: mm.dd.yy hh:mm (size / <DIR>) name
      62             :  *
      63             :  * 2  *WSP 1*DIGIT 1*WSP *(1*CHAR *WSP) *1("DIR" 1*WSP) 1*2DIGIT "-" 1*2DIGIT
      64             :  *    "-" 1*4DIGIT 1*WSP 1*2DIGIT ":" 1*2DIGIT 1*WSP 1*OCTET
      65             :  *
      66             :  *    interpreted as: size attribs DIR mm-dd-yy hh:mm name
      67             :  */
      68             : 
      69           0 : sal_Bool FTPDirectoryParser::parseDOS (
      70             :     FTPDirentry &rEntry,
      71             :     const sal_Char  *pBuffer)
      72             : {
      73           0 :     sal_Bool   bDirectory = false;
      74           0 :     sal_uInt32 nSize = 0;
      75           0 :     sal_uInt16 nYear = 0;
      76           0 :     sal_uInt16 nMonth = 0;
      77           0 :     sal_uInt16 nDay = 0;
      78           0 :     sal_uInt16 nHour = 0;
      79           0 :     sal_uInt16 nMinute = 0;
      80             : 
      81             :     enum StateType
      82             :     {
      83             :         STATE_INIT_LWS,
      84             :         STATE_MONTH_OR_SIZE,
      85             :         STATE_1_DAY, STATE_1_YEAR, STATE_1_YEAR_LWS, STATE_1_HOUR,
      86             :         STATE_1_MINUTE, STATE_1_MINUTE_LWS, STATE_1_AP,
      87             :         STATE_1_APM, STATE_1_LESS, STATE_1_D, STATE_1_DI,
      88             :         STATE_1_DIR, STATE_1_SIZE,
      89             :         STATE_2_SIZE, STATE_2_SIZE_LWS, STATE_2_ATTRIB,
      90             :         STATE_2_D, STATE_2_DI, STATE_2_DIR_LWS,
      91             :         STATE_2_MONTH, STATE_2_DAY, STATE_2_YEAR, STATE_2_YEAR_LWS,
      92             :         STATE_2_HOUR, STATE_2_MINUTE,
      93             :         STATE_LWS_NAME,
      94             :         STATE_ERROR
      95             :     };
      96             : 
      97           0 :     int nDigits = 0;
      98           0 :     enum StateType eState = STATE_INIT_LWS;
      99           0 :     for (const sal_Char *p = pBuffer;
     100           0 :          eState != STATE_ERROR && *p;
     101             :          ++p)
     102             :     {
     103           0 :         switch (eState)
     104             :         {
     105             :             case STATE_INIT_LWS:
     106           0 :                 if (*p >= '0' && *p <= '9')
     107             :                 {
     108           0 :                     nMonth = *p - '0';
     109           0 :                     nDigits = 1;
     110           0 :                     eState = STATE_MONTH_OR_SIZE;
     111             :                 }
     112           0 :                 else if (!ascii_isWhitespace(*p))
     113           0 :                     eState = STATE_ERROR;
     114           0 :                 break;
     115             : 
     116             :             case STATE_MONTH_OR_SIZE:
     117           0 :                 if (*p >= '0' && *p <= '9')
     118             :                 {
     119           0 :                     nMonth = 10 * nMonth + (*p - '0');
     120           0 :                     if (nDigits < 2)
     121           0 :                         ++nDigits;
     122             :                     else
     123             :                     {
     124           0 :                         nSize = nMonth;
     125           0 :                         nMonth = 0;
     126           0 :                         eState = STATE_2_SIZE;
     127             :                     }
     128             :                 }
     129           0 :                 else if (ascii_isWhitespace(*p))
     130             :                 {
     131           0 :                     nSize = nMonth;
     132           0 :                     nMonth = 0;
     133           0 :                     eState = STATE_2_SIZE_LWS;
     134             :                 }
     135           0 :                 else if ((*p == '.' || *p == '-') && nMonth && nMonth <= 12)
     136             :                 {
     137           0 :                     nDigits = 0;
     138           0 :                     eState = STATE_1_DAY;
     139             :                 }
     140             :                 else
     141           0 :                     eState = STATE_ERROR;
     142           0 :                 break;
     143             : 
     144             :             case STATE_1_DAY:
     145           0 :                 if (*p >= '0' && *p <= '9')
     146           0 :                     if (nDigits < 2)
     147             :                     {
     148           0 :                         nDay = 10 * nDay + (*p - '0');
     149           0 :                         ++nDigits;
     150             :                     }
     151             :                     else
     152           0 :                         eState = STATE_ERROR;
     153           0 :                 else if ((*p == '.' || *p == '-') && nDay && nDay <= 31)
     154             :                 {
     155           0 :                     nDigits = 0;
     156           0 :                     eState = STATE_1_YEAR;
     157             :                 }
     158             :                 else
     159           0 :                     eState = STATE_ERROR;
     160           0 :                 break;
     161             : 
     162             :             case STATE_1_YEAR:
     163           0 :                 if (*p >= '0' && *p <= '9')
     164             :                 {
     165           0 :                     if (nDigits < 4)
     166             :                     {
     167           0 :                         nYear = 10 * nYear + (*p - '0');
     168           0 :                         ++nDigits;
     169             :                     }
     170             :                     else
     171           0 :                         eState = STATE_ERROR;
     172             :                 }
     173             :                 else
     174             :                 {
     175           0 :                     if (ascii_isWhitespace(*p))
     176           0 :                         eState = STATE_1_YEAR_LWS;
     177             :                     else
     178           0 :                         eState = STATE_ERROR;
     179             :                 }
     180           0 :                 break;
     181             : 
     182             :             case STATE_1_YEAR_LWS:
     183           0 :                 if (*p >= '0' && *p <= '9')
     184             :                 {
     185           0 :                     nHour = *p - '0';
     186           0 :                     nDigits = 1;
     187           0 :                     eState = STATE_1_HOUR;
     188             :                 }
     189           0 :                 else if (!ascii_isWhitespace(*p))
     190           0 :                     eState = STATE_ERROR;
     191           0 :                 break;
     192             : 
     193             :             case STATE_1_HOUR:
     194           0 :                 if (*p >= '0' && *p <= '9')
     195           0 :                     if (nDigits < 2)
     196             :                     {
     197           0 :                         nHour = 10 * nHour + (*p - '0');
     198           0 :                         ++nDigits;
     199             :                     }
     200             :                     else
     201           0 :                         eState = STATE_ERROR;
     202           0 :                 else if (*p == ':' && nHour < 24)
     203             :                 {
     204           0 :                     nDigits = 0;
     205           0 :                     eState = STATE_1_MINUTE;
     206             :                 }
     207             :                 else
     208           0 :                     eState = STATE_ERROR;
     209           0 :                 break;
     210             : 
     211             :             case STATE_1_MINUTE:
     212           0 :                 if (*p >= '0' && *p <= '9')
     213           0 :                     if (nDigits < 2)
     214             :                     {
     215           0 :                         nMinute = 10 * nMinute + (*p - '0');
     216           0 :                         ++nDigits;
     217             :                     }
     218             :                     else
     219           0 :                         eState = STATE_ERROR;
     220           0 :                 else if ((*p == 'a' || *p == 'A') && nMinute < 60)
     221           0 :                     if (nHour >= 1 && nHour <= 11)
     222           0 :                         eState = STATE_1_AP;
     223           0 :                     else if (nHour == 12)
     224             :                     {
     225           0 :                         nHour = 0;
     226           0 :                         eState = STATE_1_AP;
     227             :                     }
     228             :                     else
     229           0 :                         eState = STATE_ERROR;
     230           0 :                 else if ((*p == 'p' || *p == 'P') && nMinute < 60)
     231           0 :                     if (nHour >= 1 && nHour <= 11)
     232             :                     {
     233           0 :                         nHour += 12;
     234           0 :                         eState = STATE_1_AP;
     235             :                     }
     236           0 :                     else if (nHour == 12)
     237           0 :                         eState = STATE_1_AP;
     238             :                     else
     239           0 :                         eState = STATE_ERROR;
     240           0 :                 else if (ascii_isWhitespace(*p) && (nMinute < 60))
     241           0 :                     eState = STATE_1_MINUTE_LWS;
     242             :                 else
     243           0 :                     eState = STATE_ERROR;
     244           0 :                 break;
     245             : 
     246             :             case STATE_1_MINUTE_LWS:
     247           0 :                 if (*p == 'a' || *p == 'A')
     248           0 :                     if (nHour >= 1 && nHour <= 11)
     249           0 :                         eState = STATE_1_AP;
     250           0 :                     else if (nHour == 12)
     251             :                     {
     252           0 :                         nHour = 0;
     253           0 :                         eState = STATE_1_AP;
     254             :                     }
     255             :                     else
     256           0 :                         eState = STATE_ERROR;
     257           0 :                 else if (*p == 'p' || *p == 'P')
     258           0 :                     if (nHour >= 1 && nHour <= 11)
     259             :                     {
     260           0 :                         nHour += 12;
     261           0 :                         eState = STATE_1_AP;
     262             :                     }
     263           0 :                     else if (nHour == 12)
     264           0 :                         eState = STATE_1_AP;
     265             :                     else
     266           0 :                         eState = STATE_ERROR;
     267           0 :                 else if (*p == '<')
     268           0 :                     eState = STATE_1_LESS;
     269           0 :                 else if (*p >= '0' && *p <= '9')
     270             :                 {
     271           0 :                     nSize = *p - '0';
     272           0 :                     eState = STATE_1_SIZE;
     273             :                 }
     274           0 :                 else if (!ascii_isWhitespace(*p))
     275           0 :                     eState = STATE_ERROR;
     276           0 :                 break;
     277             : 
     278             :             case STATE_1_AP:
     279           0 :                 eState = *p == 'm' || *p == 'M' ? STATE_1_APM : STATE_ERROR;
     280           0 :                 break;
     281             : 
     282             :             case STATE_1_APM:
     283           0 :                 if (*p == '<')
     284           0 :                     eState = STATE_1_LESS;
     285           0 :                 else if (*p >= '0' && *p <= '9')
     286             :                 {
     287           0 :                     nSize = *p - '0';
     288           0 :                     eState = STATE_1_SIZE;
     289             :                 }
     290           0 :                 else if (!ascii_isWhitespace(*p))
     291           0 :                     eState = STATE_ERROR;
     292           0 :                 break;
     293             : 
     294             :             case STATE_1_LESS:
     295           0 :                 eState = *p == 'd' || *p == 'D' ? STATE_1_D : STATE_ERROR;
     296           0 :                 break;
     297             : 
     298             :             case STATE_1_D:
     299           0 :                 eState = *p == 'i' || *p == 'I' ? STATE_1_DI : STATE_ERROR;
     300           0 :                 break;
     301             : 
     302             :             case STATE_1_DI:
     303           0 :                 eState = *p == 'r' || *p == 'R' ? STATE_1_DIR : STATE_ERROR;
     304           0 :                 break;
     305             : 
     306             :             case STATE_1_DIR:
     307           0 :                 if (*p == '>')
     308             :                 {
     309           0 :                     bDirectory = true;
     310           0 :                     eState = STATE_LWS_NAME;
     311             :                 }
     312             :                 else
     313           0 :                     eState = STATE_ERROR;
     314           0 :                 break;
     315             : 
     316             :             case STATE_1_SIZE:
     317           0 :                 if (*p >= '0' && *p <= '9')
     318           0 :                     nSize = 10 * nSize + (*p - '0');
     319           0 :                 else if (ascii_isWhitespace(*p))
     320           0 :                     eState = STATE_LWS_NAME;
     321             :                 else
     322           0 :                     eState = STATE_ERROR;
     323           0 :                 break;
     324             : 
     325             :             case STATE_2_SIZE:
     326           0 :                 if (*p >= '0' && *p <= '9')
     327           0 :                     nSize = 10 * nSize + (*p - '0');
     328           0 :                 else if (ascii_isWhitespace(*p))
     329           0 :                     eState = STATE_2_SIZE_LWS;
     330             :                 else
     331           0 :                     eState = STATE_ERROR;
     332           0 :                 break;
     333             : 
     334             :             case STATE_2_SIZE_LWS:
     335           0 :                 if (*p == 'd' || *p == 'D')
     336           0 :                     eState = STATE_2_D;
     337           0 :                 else if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z'))
     338           0 :                     eState = STATE_2_ATTRIB;
     339           0 :                 else if (*p >= '0' && *p <= '9')
     340             :                 {
     341           0 :                     nMonth = *p - '0';
     342           0 :                     nDigits = 1;
     343           0 :                     eState = STATE_2_MONTH;
     344             :                 }
     345           0 :                 else if (!ascii_isWhitespace(*p))
     346           0 :                     eState = STATE_ERROR;
     347           0 :                 break;
     348             : 
     349             :             case STATE_2_ATTRIB:
     350           0 :                 if (ascii_isWhitespace(*p))
     351           0 :                     eState = STATE_2_SIZE_LWS;
     352           0 :                 else if ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z'))
     353           0 :                     eState = STATE_ERROR;
     354           0 :                 break;
     355             : 
     356             :             case STATE_2_D:
     357           0 :                 if (*p == 'i' || *p == 'I')
     358           0 :                     eState = STATE_2_DI;
     359           0 :                 else if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z'))
     360           0 :                     eState = STATE_2_ATTRIB;
     361           0 :                 else if (ascii_isWhitespace(*p))
     362           0 :                     eState = STATE_2_SIZE_LWS;
     363             :                 else
     364           0 :                     eState = STATE_ERROR;
     365           0 :                 break;
     366             : 
     367             :             case STATE_2_DI:
     368           0 :                 if (*p == 'r' || *p == 'R')
     369             :                 {
     370           0 :                     bDirectory = true;
     371           0 :                     eState = STATE_2_DIR_LWS;
     372             :                 }
     373             :                 else
     374             :                 {
     375           0 :                     if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z'))
     376           0 :                         eState = STATE_2_ATTRIB;
     377           0 :                     else if (ascii_isWhitespace(*p))
     378           0 :                         eState = STATE_2_SIZE_LWS;
     379             :                     else
     380           0 :                         eState = STATE_ERROR;
     381             :                 }
     382           0 :                 break;
     383             : 
     384             :             case STATE_2_DIR_LWS:
     385           0 :                 if (*p >= '0' && *p <= '9')
     386             :                 {
     387           0 :                     nMonth = *p - '0';
     388           0 :                     nDigits = 1;
     389           0 :                     eState = STATE_2_MONTH;
     390             :                 }
     391           0 :                 else if (!ascii_isWhitespace(*p))
     392           0 :                     eState = STATE_ERROR;
     393           0 :                 break;
     394             : 
     395             :             case STATE_2_MONTH:
     396           0 :                 if (*p >= '0' && *p <= '9')
     397           0 :                     if (nDigits < 2)
     398             :                     {
     399           0 :                         nMonth = 10 * nMonth + (*p - '0');
     400           0 :                         ++nDigits;
     401             :                     }
     402             :                     else
     403           0 :                         eState = STATE_ERROR;
     404           0 :                 else if (*p == '-' && nMonth && nMonth <= 12)
     405             :                 {
     406           0 :                     nDigits = 0;
     407           0 :                     eState = STATE_2_DAY;
     408             :                 }
     409             :                 else
     410           0 :                     eState = STATE_ERROR;
     411           0 :                 break;
     412             : 
     413             :             case STATE_2_DAY:
     414           0 :                 if (*p >= '0' && *p <= '9')
     415           0 :                     if (nDigits < 2)
     416             :                     {
     417           0 :                         nDay = 10 * nDay + (*p - '0');
     418           0 :                         ++nDigits;
     419             :                     }
     420             :                     else
     421           0 :                         eState = STATE_ERROR;
     422           0 :                 else if (*p == '-' && nDay && nDay <= 31)
     423             :                 {
     424           0 :                     nDigits = 0;
     425           0 :                     eState = STATE_2_YEAR;
     426             :                 }
     427             :                 else
     428           0 :                     eState = STATE_ERROR;
     429           0 :                 break;
     430             : 
     431             :             case STATE_2_YEAR:
     432           0 :                 if (*p >= '0' && *p <= '9')
     433             :                 {
     434           0 :                     if (nDigits < 4)
     435             :                     {
     436           0 :                         nYear = 10 * nYear + (*p - '0');
     437           0 :                         ++nDigits;
     438             :                     }
     439             :                     else
     440           0 :                         eState = STATE_ERROR;
     441             :                 }
     442             :                 else
     443             :                 {
     444           0 :                     if (ascii_isWhitespace(*p))
     445           0 :                         eState = STATE_2_YEAR_LWS;
     446             :                     else
     447           0 :                         eState = STATE_ERROR;
     448             :                 }
     449           0 :                 break;
     450             : 
     451             :             case STATE_2_YEAR_LWS:
     452           0 :                 if (*p >= '0' && *p <= '9')
     453             :                 {
     454           0 :                     nHour = *p - '0';
     455           0 :                     nDigits = 1;
     456           0 :                     eState = STATE_2_HOUR;
     457             :                 }
     458           0 :                 else if (!ascii_isWhitespace(*p))
     459           0 :                     eState = STATE_ERROR;
     460           0 :                 break;
     461             : 
     462             :             case STATE_2_HOUR:
     463           0 :                 if (*p >= '0' && *p <= '9')
     464           0 :                     if (nDigits < 2)
     465             :                     {
     466           0 :                         nHour = 10 * nHour + (*p - '0');
     467           0 :                         ++nDigits;
     468             :                     }
     469             :                     else
     470           0 :                         eState = STATE_ERROR;
     471           0 :                 else if (*p == ':' && nHour < 24)
     472             :                 {
     473           0 :                     nDigits = 0;
     474           0 :                     eState = STATE_2_MINUTE;
     475             :                 }
     476             :                 else
     477           0 :                     eState = STATE_ERROR;
     478           0 :                 break;
     479             : 
     480             :             case STATE_2_MINUTE:
     481           0 :                 if (*p >= '0' && *p <= '9')
     482             :                 {
     483           0 :                     if (nDigits < 2)
     484             :                     {
     485           0 :                         nMinute = 10 * nMinute + (*p - '0');
     486           0 :                         ++nDigits;
     487             :                     }
     488             :                     else
     489           0 :                         eState = STATE_ERROR;
     490             :                 }
     491             :                 else
     492             :                 {
     493           0 :                     if (ascii_isWhitespace(*p) && (nMinute < 60))
     494           0 :                         eState = STATE_LWS_NAME;
     495             :                     else
     496           0 :                         eState = STATE_ERROR;
     497             :                 }
     498           0 :                 break;
     499             : 
     500             :             case STATE_LWS_NAME:
     501           0 :                 if (!ascii_isWhitespace(*p))
     502             :                 {
     503           0 :                     setPath (rEntry.m_aName, p);
     504           0 :                     if (bDirectory)
     505           0 :                         rEntry.m_nMode |= INETCOREFTP_FILEMODE_ISDIR;
     506           0 :                     rEntry.m_nSize = nSize;
     507             : 
     508           0 :                     setYear (rEntry.m_aDate, nYear);
     509             : 
     510           0 :                     rEntry.m_aDate.SetMonth(nMonth);
     511           0 :                     rEntry.m_aDate.SetDay(nDay);
     512           0 :                     rEntry.m_aDate.SetHour(nHour);
     513           0 :                     rEntry.m_aDate.SetMin(nMinute);
     514             : 
     515           0 :                     return sal_True;
     516             :                 }
     517           0 :                 break;
     518             :             case STATE_ERROR:
     519           0 :                 break;
     520             :         }
     521             :     }
     522             : 
     523           0 :     return sal_False;
     524             : }
     525             : 
     526             : /*
     527             :  * parseVMS.
     528             :  * Directory entries may span one or two lines:
     529             :  *
     530             :  *   entry: *lws name *1(*lws <NEWLINE>) 1*lws size 1*lws datetime rest
     531             :  *
     532             :  *   name: filename "." filetype ";" version
     533             :  *   filename: 1*39fchar
     534             :  *   filetype: 1*39fchar
     535             :  *   version: non0digit *digit
     536             :  *
     537             :  *   size: "0" / non0digit *digit
     538             :  *
     539             :  *   datetime: date 1*lwsp time
     540             :  *   date: day "-" month "-" year
     541             :  *   day: (*1"0" non0digit) / ("1"-"2" digit) / ("3" "0"-"1")
     542             :  *   month: "JAN" / "FEB" / "MAR" / "APR" / "MAY" / "JUN" / "JUL" / "AUG"
     543             :  *        / "SEP" / "OCT" / "NOV" / "DEC" ; all case insensitive
     544             :  *   year: 2digit / 4digit
     545             :  *   time: hour ":" minute
     546             :  *   hour: ((*1"0" / "1") digit) / ("2" "0"-"3")
     547             :  *   minute: "0"-"5" digit
     548             :  *
     549             :  *   rest: *1(lws *<ANY>)
     550             :  *
     551             :  *   lws: <TAB> / <SPACE>
     552             :  *   non0digit: "1"-"9"
     553             :  *   digit: "0" / non0digit
     554             :  *   fchar: "A"-"Z" / "a"-"z" / digit / "-" / "_" / "$"
     555             :  *
     556             :  * For directories, the returned name is the <filename> part; for non-
     557             :  * directory files, the returned name is the <filename "." filetype> part.
     558             :  * An entry is a directory iff its filetype is "DIR" (ignoring case).
     559             :  *
     560             :  * The READ, WRITE, and ISLINK mode bits are not supported.
     561             :  *
     562             :  * The returned size is the <size> part, multiplied by 512, and with the high
     563             :  * order bits truncated to fit into a ULONG.
     564             :  *
     565             :  */
     566           0 : sal_Bool FTPDirectoryParser::parseVMS (
     567             :     FTPDirentry &rEntry,
     568             :     const sal_Char  *pBuffer)
     569             : {
     570           0 :     static OUString aFirstLineName;
     571             :     static sal_Bool bFirstLineDir = sal_False;
     572             : 
     573           0 :     for (sal_Bool bFirstLine = sal_True;; bFirstLine = sal_False)
     574             :     {
     575           0 :         const sal_Char *p = pBuffer;
     576           0 :         if (bFirstLine)
     577             :         {
     578             :             // Skip <*lws> part:
     579           0 :             while (*p == '\t' || *p == ' ')
     580           0 :                 ++p;
     581             : 
     582             :             // Parse <filename "."> part:
     583           0 :             const sal_Char *pFileName = p;
     584           0 :             while ((*p >= 'A' && *p <= 'Z') ||
     585           0 :                    (*p >= 'a' && *p <= 'z') ||
     586           0 :                    (*p >= '0' && *p <= '9') ||
     587           0 :                    *p == '-' || *p == '_' || *p == '$')
     588           0 :                 ++p;
     589             : 
     590           0 :             if (*p != '.' || p == pFileName || p - pFileName > 39)
     591             :             {
     592           0 :                 if (!aFirstLineName.isEmpty())
     593           0 :                     continue;
     594             :                 else
     595           0 :                     return sal_False;
     596             :             }
     597             : 
     598             :             // Parse <filetype ";"> part:
     599           0 :             const sal_Char *pFileType = ++p;
     600           0 :             while ((*p >= 'A' && *p <= 'Z') ||
     601           0 :                    (*p >= 'a' && *p <= 'z') ||
     602           0 :                    (*p >= '0' && *p <= '9') ||
     603           0 :                    *p == '-' || *p == '_' || *p == '$')
     604           0 :                 ++p;
     605             : 
     606           0 :             if (*p != ';' || p == pFileName || p - pFileName > 39)
     607             :             {
     608           0 :                 if (!aFirstLineName.isEmpty())
     609           0 :                     continue;
     610             :                 else
     611           0 :                     return sal_False;
     612             :             }
     613           0 :             ++p;
     614             : 
     615             :             // Set entry's name and mode (ISDIR flag):
     616           0 :             if ((p - pFileType == 4) &&
     617           0 :                 (pFileType[0] == 'D' || pFileType[0] == 'd') &&
     618           0 :                 (pFileType[1] == 'I' || pFileType[1] == 'i') &&
     619           0 :                 (pFileType[2] == 'R' || pFileType[2] == 'r')    )
     620             :             {
     621           0 :                 setPath (rEntry.m_aName, pFileName, (pFileType - pFileName));
     622           0 :                 rEntry.m_nMode = INETCOREFTP_FILEMODE_ISDIR;
     623             :             }
     624             :             else
     625             :             {
     626           0 :                 setPath (rEntry.m_aName, pFileName, (p - pFileName));
     627           0 :                 rEntry.m_nMode = 0;
     628             :             }
     629             : 
     630             :             // Skip <version> part:
     631           0 :             if (*p < '1' || *p > '9')
     632             :             {
     633           0 :                 if (!aFirstLineName.isEmpty())
     634           0 :                     continue;
     635             :                 else
     636           0 :                     return sal_False;
     637             :             }
     638           0 :             ++p;
     639           0 :             while (*p >= '0' && *p <= '9')
     640           0 :                 ++p;
     641             : 
     642             :             // Parse <1*lws> or <*lws <NEWLINE>> part:
     643           0 :             sal_Bool bLWS = false;
     644           0 :             while (*p == '\t' || *p == ' ')
     645             :             {
     646           0 :                 bLWS = true;
     647           0 :                 ++p;
     648             :             }
     649           0 :             if (*p)
     650             :             {
     651           0 :                 if (!bLWS)
     652             :                 {
     653           0 :                     if (!aFirstLineName.isEmpty())
     654           0 :                         continue;
     655             :                     else
     656           0 :                         return sal_False;
     657             :                 }
     658             :             }
     659             :             else
     660             :             {
     661             :                 /*
     662             :                  * First line of entry spanning two lines,
     663             :                  * wait for second line.
     664             :                  */
     665           0 :                 aFirstLineName = rEntry.m_aName;
     666             :                 bFirstLineDir =
     667           0 :                     ((rEntry.m_nMode & INETCOREFTP_FILEMODE_ISDIR) != 0);
     668           0 :                 return sal_False;
     669             :             }
     670             :         }
     671             :         else
     672             :         {
     673             :             /*
     674             :              * Second line of entry spanning two lines,
     675             :              * restore entry's name and mode (ISDIR flag).
     676             :              */
     677           0 :             rEntry.m_aName = aFirstLineName;
     678           0 :             rEntry.m_nMode = (bFirstLineDir ? INETCOREFTP_FILEMODE_ISDIR : 0);
     679             : 
     680             :             // Skip <1*lws> part:
     681           0 :             if (*p != '\t' && *p != ' ')
     682           0 :                 return sal_False;
     683           0 :             ++p;
     684           0 :             while (*p == '\t' || *p == ' ')
     685           0 :                 ++p;
     686             :         }
     687             : 
     688             :         // Parse <size> part and set entry's size:
     689           0 :         if (*p < '0' || *p > '9')
     690           0 :             return sal_False;
     691           0 :         ULONG nSize = *p - '0';
     692           0 :         if (*p++ != '0')
     693           0 :             while (*p >= '0' && *p <= '9')
     694           0 :                 nSize = 10 * rEntry.m_nSize + (*p++ - '0');
     695           0 :         rEntry.m_nSize = 512 * nSize;
     696             : 
     697             :         // Skip <1*lws> part:
     698           0 :         if (*p != '\t' && *p != ' ')
     699           0 :             return sal_False;
     700           0 :         ++p;
     701           0 :         while (*p == '\t' || *p == ' ')
     702           0 :             ++p;
     703             : 
     704             :         // Parse <day "-"> part and set entry date's day:
     705             :         sal_uInt16 nDay;
     706           0 :         if (*p == '0')
     707             :         {
     708           0 :             ++p;
     709           0 :             if (*p < '1' || *p > '9')
     710           0 :                 return sal_False;
     711           0 :             nDay = *p++ - '0';
     712             :         }
     713           0 :         else if (*p == '1' || *p == '2')
     714             :         {
     715           0 :             nDay = *p++ - '0';
     716           0 :             if (*p >= '0' && *p <= '9')
     717           0 :                 nDay = 10 * nDay + (*p++ - '0');
     718             :         }
     719           0 :         else if (*p == '3')
     720             :         {
     721           0 :             ++p;
     722           0 :             nDay = (*p == '0' || *p == '1') ? 30 + (*p++ - '0') : 3;
     723             :         }
     724           0 :         else if (*p >= '4' && *p <= '9')
     725           0 :             nDay = *p++ - '0';
     726             :         else
     727           0 :             return sal_False;
     728             : 
     729           0 :         rEntry.m_aDate.SetDay(nDay);
     730           0 :         if (*p++ != '-')
     731           0 :             return sal_False;
     732             : 
     733             :         // Parse <month "-"> part and set entry date's month:
     734           0 :         sal_Char const * pMonth = p;
     735           0 :         sal_Int32 const monthLen = 3;
     736           0 :         for (int i = 0; i < monthLen; ++i)
     737             :         {
     738           0 :             if (!((*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z')))
     739           0 :                 return sal_False;
     740           0 :             ++p;
     741             :         }
     742           0 :         if (rtl_str_compareIgnoreAsciiCase_WithLength(
     743           0 :                 pMonth, monthLen, "JAN", monthLen) == 0)
     744           0 :             rEntry.m_aDate.SetMonth(1);
     745           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     746           0 :                      pMonth, monthLen, "FEB", monthLen) == 0)
     747           0 :             rEntry.m_aDate.SetMonth(2);
     748           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     749           0 :                      pMonth, monthLen, "MAR", monthLen) == 0)
     750           0 :             rEntry.m_aDate.SetMonth(3);
     751           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     752           0 :                      pMonth, monthLen, "APR", monthLen) == 0)
     753           0 :             rEntry.m_aDate.SetMonth(4);
     754           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     755           0 :                      pMonth, monthLen, "MAY", monthLen) == 0)
     756           0 :             rEntry.m_aDate.SetMonth(5);
     757           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     758           0 :                      pMonth, monthLen, "JUN", monthLen) == 0)
     759           0 :             rEntry.m_aDate.SetMonth(6);
     760           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     761           0 :                      pMonth, monthLen, "JUL", monthLen) == 0)
     762           0 :             rEntry.m_aDate.SetMonth(7);
     763           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     764           0 :                      pMonth, monthLen, "AUG", monthLen) == 0)
     765           0 :             rEntry.m_aDate.SetMonth(8);
     766           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     767           0 :                      pMonth, monthLen, "SEP", monthLen) == 0)
     768           0 :             rEntry.m_aDate.SetMonth(9);
     769           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     770           0 :                      pMonth, monthLen, "OCT", monthLen) == 0)
     771           0 :             rEntry.m_aDate.SetMonth(10);
     772           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     773           0 :                      pMonth, monthLen, "NOV", monthLen) == 0)
     774           0 :             rEntry.m_aDate.SetMonth(11);
     775           0 :         else if (rtl_str_compareIgnoreAsciiCase_WithLength(
     776           0 :                      pMonth, monthLen, "DEC", monthLen) == 0)
     777           0 :             rEntry.m_aDate.SetMonth(12);
     778             :         else
     779           0 :             return sal_False;
     780           0 :         if (*p++ != '-')
     781           0 :             return sal_False;
     782             : 
     783             :         // Parse <year> part and set entry date's year:
     784           0 :         sal_uInt16 nYear = 0;
     785           0 :         for (int i = 0; i < 2; ++i)
     786             :         {
     787           0 :             if (*p < '0' || *p > '9')
     788           0 :                 return sal_False;
     789           0 :             nYear = 10 * nYear + (*p++ - '0');
     790             :         }
     791           0 :         if (*p >= '0' && *p <= '9')
     792             :         {
     793           0 :             nYear = 10 * nYear + (*p++ - '0');
     794           0 :             if (*p < '0' || *p > '9')
     795           0 :                 return sal_False;
     796           0 :             nYear = 10 * nYear + (*p++ - '0');
     797             :         }
     798           0 :         setYear (rEntry.m_aDate, nYear);
     799             : 
     800             :         // Skip <1*lws> part:
     801           0 :         if (*p != '\t' && *p != ' ')
     802           0 :             return sal_False;
     803           0 :         ++p;
     804           0 :         while (*p == '\t' || *p == ' ')
     805           0 :             ++p;
     806             : 
     807             :         // Parse <hour ":"> part and set entry time's hour:
     808             :         sal_uInt16 nHour;
     809           0 :         if (*p == '0' || *p == '1')
     810             :         {
     811           0 :             nHour = *p++ - '0';
     812           0 :             if (*p >= '0' && *p <= '9')
     813           0 :                 nHour = 10 * nHour + (*p++ - '0');
     814             :         }
     815           0 :         else if (*p == '2')
     816             :         {
     817           0 :             ++p;
     818           0 :             nHour = (*p >= '0' && *p <= '3') ? 20 + (*p++ - '0') : 2;
     819             :         }
     820           0 :         else if (*p >= '3' && *p <= '9')
     821           0 :             nHour = *p++ - '0';
     822             :         else
     823           0 :             return sal_False;
     824             : 
     825           0 :         rEntry.m_aDate.SetHour(nHour);
     826           0 :         if (*p++ != ':')
     827           0 :             return sal_False;
     828             : 
     829             :         /*
     830             :          * Parse <minute> part and set entry time's minutes,
     831             :          * seconds (0), and nanoseconds (0).
     832             :          */
     833           0 :         if (*p < '0' || *p > '5')
     834           0 :             return sal_False;
     835             : 
     836           0 :         sal_uInt16 nMinute = *p++ - '0';
     837           0 :         if (*p < '0' || *p > '9')
     838           0 :             return sal_False;
     839             : 
     840           0 :         nMinute = 10 * nMinute + (*p++ - '0');
     841           0 :         rEntry.m_aDate.SetMin(nMinute);
     842           0 :         rEntry.m_aDate.SetSec(0);
     843           0 :         rEntry.m_aDate.SetNanoSec(0);
     844             : 
     845             :         // Skip <rest> part:
     846           0 :         if (*p && (*p != '\t' && *p != ' '))
     847           0 :             return sal_False;
     848             : 
     849           0 :         return sal_True;
     850           0 :     }
     851             : }
     852             : 
     853             : /*
     854             :  * parseUNIX
     855             :  */
     856           0 : sal_Bool FTPDirectoryParser::parseUNIX (
     857             :     FTPDirentry &rEntry,
     858             :     const sal_Char  *pBuffer)
     859             : {
     860             :     const sal_Char *p1, *p2;
     861           0 :     p1 = p2 = pBuffer;
     862             : 
     863           0 :     if (!((*p1 == '-') || (*p1 == 'd') || (*p1 == 'l')))
     864           0 :         return sal_False;
     865             : 
     866             :     // 1st column: FileMode.
     867           0 :     if (*p1 == 'd')
     868           0 :         rEntry.m_nMode |= INETCOREFTP_FILEMODE_ISDIR;
     869             : 
     870           0 :     if (*p1 == 'l')
     871           0 :         rEntry.m_nMode |= INETCOREFTP_FILEMODE_ISLINK;
     872             : 
     873             :     // Skip to end of column and set rights by the way
     874           0 :     while (*p1 && !ascii_isWhitespace(*p1)) {
     875           0 :         if(*p1 == 'r')
     876           0 :             rEntry.m_nMode |= INETCOREFTP_FILEMODE_READ;
     877           0 :         else if(*p1 == 'w')
     878           0 :             rEntry.m_nMode |= INETCOREFTP_FILEMODE_WRITE;
     879           0 :         p1++;
     880             :     }
     881             : 
     882             :     /*
     883             :      * Scan for the sequence of size and date fields:
     884             :      *   *LWS 1*DIGIT 1*LWS 3CHAR 1*LWS 1*2DIGIT 1*LWS
     885             :      *   (4DIGIT / (1*2DIGIT ":" 2DIGIT)) 1*LWS
     886             :      */
     887             :     enum Mode
     888             :     {
     889             :         FOUND_NONE, FOUND_SIZE, FOUND_MONTH, FOUND_DAY, FOUND_YEAR_TIME
     890             :     };
     891             : 
     892           0 :     const sal_Char *pDayStart = 0;
     893           0 :     const sal_Char *pDayEnd = 0;
     894             :     Mode eMode;
     895           0 :     for (eMode = FOUND_NONE; *p1 && eMode != FOUND_YEAR_TIME; p1 = p2 + 1)
     896             :     {
     897           0 :         while (*p1 && ascii_isWhitespace(*p1))
     898           0 :             ++p1;
     899           0 :         p2 = p1;
     900           0 :         while (*p2 && !ascii_isWhitespace(*p2))
     901           0 :             ++p2;
     902             : 
     903           0 :         switch (eMode)
     904             :         {
     905             :             case FOUND_NONE:
     906           0 :                 if (parseUNIX_isSizeField (p1, p2, rEntry.m_nSize))
     907           0 :                     eMode = FOUND_SIZE;
     908           0 :                 break;
     909             : 
     910             :             case FOUND_SIZE:
     911           0 :                 if (parseUNIX_isMonthField (p1, p2, rEntry.m_aDate))
     912           0 :                     eMode = FOUND_MONTH;
     913           0 :                 else if (!parseUNIX_isSizeField (p1, p2, rEntry.m_nSize))
     914           0 :                     eMode = FOUND_NONE;
     915           0 :                 break;
     916             : 
     917             :             case FOUND_MONTH:
     918           0 :                 if (parseUNIX_isDayField (p1, p2, rEntry.m_aDate))
     919             :                 {
     920           0 :                     pDayStart = p1;
     921           0 :                     pDayEnd = p2;
     922           0 :                     eMode = FOUND_DAY;
     923             :                 }
     924           0 :                 else if (parseUNIX_isSizeField (p1, p2, rEntry.m_nSize))
     925           0 :                     eMode = FOUND_SIZE;
     926             :                 else
     927           0 :                     eMode = FOUND_NONE;
     928           0 :                 break;
     929             : 
     930             :             case FOUND_DAY:
     931           0 :                 if (parseUNIX_isYearTimeField (p1, p2, rEntry.m_aDate))
     932           0 :                     eMode = FOUND_YEAR_TIME;
     933           0 :                 else if (
     934             :                     parseUNIX_isSizeField (
     935           0 :                         pDayStart, pDayEnd, rEntry.m_nSize) &&
     936             :                     parseUNIX_isMonthField (
     937           0 :                         p1, p2, rEntry.m_aDate))
     938           0 :                     eMode = FOUND_MONTH;
     939           0 :                 else if (parseUNIX_isSizeField (p1, p2, rEntry.m_nSize))
     940           0 :                     eMode = FOUND_SIZE;
     941             :                 else
     942           0 :                     eMode = FOUND_NONE;
     943           0 :                 break;
     944             :             case FOUND_YEAR_TIME:
     945           0 :                 break;
     946             :         }
     947             :     }
     948             : 
     949           0 :     if (eMode == FOUND_YEAR_TIME)
     950             :     {
     951             :         // 9th column: FileName (rest of line).
     952           0 :         while (*p1 && ascii_isWhitespace(*p1)) p1++;
     953           0 :         setPath (rEntry.m_aName, p1);
     954             : 
     955             :         // Done.
     956           0 :         return sal_True;
     957             :     }
     958           0 :     return sal_False;
     959             : }
     960             : 
     961             : /*
     962             :  * parseUNIX_isSizeField.
     963             :  */
     964           0 : sal_Bool FTPDirectoryParser::parseUNIX_isSizeField (
     965             :     const sal_Char *pStart,
     966             :     const sal_Char *pEnd,
     967             :     sal_uInt32     &rSize)
     968             : {
     969           0 :     if (!*pStart || !*pEnd || pStart == pEnd)
     970           0 :         return sal_False;
     971             : 
     972           0 :     rSize = 0;
     973           0 :     if (*pStart >= '0' && *pStart <= '9')
     974             :     {
     975           0 :         for (; pStart < pEnd; ++pStart)
     976           0 :             if ((*pStart >= '0') && (*pStart <= '9'))
     977           0 :                 rSize = 10 * rSize + (*pStart - '0');
     978             :             else
     979           0 :                 return sal_False;
     980           0 :         return sal_True;
     981             :     }
     982             :     else
     983             :     {
     984             :         /*
     985             :          * For a combination of long group name and large file size,
     986             :          * some FTPDs omit LWS between those two columns.
     987             :          */
     988           0 :         int nNonDigits = 0;
     989           0 :         int nDigits = 0;
     990             : 
     991           0 :         for (; pStart < pEnd; ++pStart)
     992           0 :             if ((*pStart >= '1') && (*pStart <= '9'))
     993             :             {
     994           0 :                 ++nDigits;
     995           0 :                 rSize = 10 * rSize + (*pStart - '0');
     996             :             }
     997           0 :             else if ((*pStart == '0') && nDigits)
     998             :             {
     999           0 :                 ++nDigits;
    1000           0 :                 rSize *= 10;
    1001             :             }
    1002           0 :             else if ((*pStart > ' ') && (sal::static_int_cast<sal_uInt8>(*pStart) <= '\x7F'))
    1003             :             {
    1004           0 :                 nNonDigits += nDigits + 1;
    1005           0 :                 nDigits = 0;
    1006           0 :                 rSize = 0;
    1007             :             }
    1008             :             else
    1009           0 :                 return sal_False;
    1010           0 :         return ((nNonDigits >= 9) && (nDigits >= 7));
    1011             :     }
    1012             : }
    1013             : 
    1014             : /*
    1015             :  * parseUNIX_isMonthField.
    1016             :  */
    1017           0 : sal_Bool FTPDirectoryParser::parseUNIX_isMonthField (
    1018             :     const sal_Char *pStart,
    1019             :     const sal_Char *pEnd,
    1020             :     DateTime       &rDateTime)
    1021             : {
    1022           0 :     if (!*pStart || !*pEnd || pStart + 3 != pEnd)
    1023           0 :         return sal_False;
    1024             : 
    1025           0 :     if ((pStart[0] == 'j' || pStart[0] == 'J') &&
    1026           0 :         (pStart[1] == 'a' || pStart[1] == 'A') &&
    1027           0 :         (pStart[2] == 'n' || pStart[2] == 'N')    )
    1028             :     {
    1029           0 :         rDateTime.SetMonth(1);
    1030           0 :         return sal_True;
    1031             :     }
    1032           0 :     if ((pStart[0] == 'f' || pStart[0] == 'F') &&
    1033           0 :         (pStart[1] == 'e' || pStart[1] == 'E') &&
    1034           0 :         (pStart[2] == 'b' || pStart[2] == 'B')    )
    1035             :     {
    1036           0 :         rDateTime.SetMonth(2);
    1037           0 :         return sal_True;
    1038             :     }
    1039           0 :     if ((pStart[0] == 'm' || pStart[0] == 'M') &&
    1040           0 :         (pStart[1] == 'a' || pStart[1] == 'A') &&
    1041           0 :         (pStart[2] == 'r' || pStart[2] == 'R')    )
    1042             :     {
    1043           0 :         rDateTime.SetMonth(3);
    1044           0 :         return sal_True;
    1045             :     }
    1046           0 :     if ((pStart[0] == 'a' || pStart[0] == 'A') &&
    1047           0 :         (pStart[1] == 'p' || pStart[1] == 'P') &&
    1048           0 :         (pStart[2] == 'r' || pStart[2] == 'R')    )
    1049             :     {
    1050           0 :         rDateTime.SetMonth(4);
    1051           0 :         return sal_True;
    1052             :     }
    1053           0 :     if ((pStart[0] == 'm' || pStart[0] == 'M') &&
    1054           0 :         (pStart[1] == 'a' || pStart[1] == 'A') &&
    1055           0 :         (pStart[2] == 'y' || pStart[2] == 'Y')    )
    1056             :     {
    1057           0 :         rDateTime.SetMonth(5);
    1058           0 :         return sal_True;
    1059             :     }
    1060           0 :     if ((pStart[0] == 'j' || pStart[0] == 'J') &&
    1061           0 :         (pStart[1] == 'u' || pStart[1] == 'U') &&
    1062           0 :         (pStart[2] == 'n' || pStart[2] == 'N')    )
    1063             :     {
    1064           0 :         rDateTime.SetMonth(6);
    1065           0 :         return sal_True;
    1066             :     }
    1067           0 :     if ((pStart[0] == 'j' || pStart[0] == 'J') &&
    1068           0 :         (pStart[1] == 'u' || pStart[1] == 'U') &&
    1069           0 :         (pStart[2] == 'l' || pStart[2] == 'L')    )
    1070             :     {
    1071           0 :         rDateTime.SetMonth(7);
    1072           0 :         return sal_True;
    1073             :     }
    1074           0 :     if ((pStart[0] == 'a' || pStart[0] == 'A') &&
    1075           0 :         (pStart[1] == 'u' || pStart[1] == 'U') &&
    1076           0 :         (pStart[2] == 'g' || pStart[2] == 'G')    )
    1077             :     {
    1078           0 :         rDateTime.SetMonth(8);
    1079           0 :         return sal_True;
    1080             :     }
    1081           0 :     if ((pStart[0] == 's' || pStart[0] == 'S') &&
    1082           0 :         (pStart[1] == 'e' || pStart[1] == 'E') &&
    1083           0 :         (pStart[2] == 'p' || pStart[2] == 'P')    )
    1084             :     {
    1085           0 :         rDateTime.SetMonth(9);
    1086           0 :         return sal_True;
    1087             :     }
    1088           0 :     if ((pStart[0] == 'o' || pStart[0] == 'O') &&
    1089           0 :         (pStart[1] == 'c' || pStart[1] == 'C') &&
    1090           0 :         (pStart[2] == 't' || pStart[2] == 'T')    )
    1091             :     {
    1092           0 :         rDateTime.SetMonth(10);
    1093           0 :         return sal_True;
    1094             :     }
    1095           0 :     if ((pStart[0] == 'n' || pStart[0] == 'N') &&
    1096           0 :         (pStart[1] == 'o' || pStart[1] == 'O') &&
    1097           0 :         (pStart[2] == 'v' || pStart[2] == 'V')    )
    1098             :     {
    1099           0 :         rDateTime.SetMonth(11);
    1100           0 :         return sal_True;
    1101             :     }
    1102           0 :     if ((pStart[0] == 'd' || pStart[0] == 'D') &&
    1103           0 :         (pStart[1] == 'e' || pStart[1] == 'E') &&
    1104           0 :         (pStart[2] == 'c' || pStart[2] == 'C')    )
    1105             :     {
    1106           0 :         rDateTime.SetMonth(12);
    1107           0 :         return sal_True;
    1108             :     }
    1109           0 :     return sal_False;
    1110             : }
    1111             : 
    1112             : /*
    1113             :  * parseUNIX_isDayField.
    1114             :  */
    1115           0 : sal_Bool FTPDirectoryParser::parseUNIX_isDayField (
    1116             :     const sal_Char *pStart,
    1117             :     const sal_Char *pEnd,
    1118             :     DateTime       &rDateTime)
    1119             : {
    1120           0 :     if (!*pStart || !*pEnd || pStart == pEnd)
    1121           0 :         return sal_False;
    1122           0 :     if (*pStart < '0' || *pStart > '9')
    1123           0 :         return sal_False;
    1124             : 
    1125           0 :     sal_uInt16 nDay = *pStart - '0';
    1126           0 :     if (pStart + 1 < pEnd)
    1127             :     {
    1128           0 :         if (pStart + 2 != pEnd || pStart[1] < '0' || pStart[1] > '9')
    1129           0 :             return sal_False;
    1130           0 :         nDay = 10 * nDay + (pStart[1] - '0');
    1131             :     }
    1132           0 :     if (!nDay || nDay > 31)
    1133           0 :         return sal_False;
    1134             : 
    1135           0 :     rDateTime.SetDay(nDay);
    1136           0 :     return sal_True;
    1137             : }
    1138             : 
    1139             : /*
    1140             :  * parseUNIX_isYearTimeField.
    1141             :  */
    1142           0 : sal_Bool FTPDirectoryParser::parseUNIX_isYearTimeField (
    1143             :     const sal_Char *pStart,
    1144             :     const sal_Char *pEnd,
    1145             :     DateTime       &rDateTime)
    1146             : {
    1147           0 :     if (!*pStart || !*pEnd || pStart == pEnd ||
    1148           0 :         *pStart < '0' || *pStart > '9')
    1149           0 :         return sal_False;
    1150             : 
    1151           0 :     sal_uInt16 nNumber = *pStart - '0';
    1152           0 :     ++pStart;
    1153             : 
    1154           0 :     if (pStart == pEnd)
    1155           0 :         return sal_False;
    1156           0 :     if (*pStart == ':')
    1157           0 :         return parseUNIX_isTime (pStart, pEnd, nNumber, rDateTime);
    1158           0 :     if (*pStart < '0' || *pStart > '9')
    1159           0 :         return sal_False;
    1160             : 
    1161           0 :     nNumber = 10 * nNumber + (*pStart - '0');
    1162           0 :     ++pStart;
    1163             : 
    1164           0 :     if (pStart == pEnd)
    1165           0 :         return sal_False;
    1166           0 :     if (*pStart == ':')
    1167           0 :         return parseUNIX_isTime (pStart, pEnd, nNumber, rDateTime);
    1168           0 :     if (*pStart < '0' || *pStart > '9')
    1169           0 :         return sal_False;
    1170             : 
    1171           0 :     nNumber = 10 * nNumber + (*pStart - '0');
    1172           0 :     ++pStart;
    1173             : 
    1174           0 :     if (pStart == pEnd || *pStart < '0' || *pStart > '9')
    1175           0 :         return sal_False;
    1176             : 
    1177           0 :     nNumber = 10 * nNumber + (*pStart - '0');
    1178           0 :     if (pStart + 1 != pEnd || nNumber < 1970)
    1179           0 :         return sal_False;
    1180             : 
    1181           0 :     rDateTime.SetYear(nNumber);
    1182           0 :     rDateTime.SetTime(0);
    1183           0 :     return sal_True;
    1184             : }
    1185             : 
    1186             : /*
    1187             :  * parseUNIX_isTime.
    1188             :  */
    1189           0 : sal_Bool FTPDirectoryParser::parseUNIX_isTime (
    1190             :     const sal_Char *pStart,
    1191             :     const sal_Char *pEnd,
    1192             :     sal_uInt16      nHour,
    1193             :     DateTime       &rDateTime)
    1194             : {
    1195           0 :     if ((nHour     > 23 ) || (pStart + 3 != pEnd) ||
    1196           0 :         (pStart[1] < '0') || (pStart[1] > '5')    ||
    1197           0 :         (pStart[2] < '0') || (pStart[2] > '9')       )
    1198           0 :         return sal_False;
    1199             : 
    1200           0 :     sal_uInt16 nMin = 10 * (pStart[1] - '0') + (pStart[2] - '0');
    1201             : 
    1202           0 :     rDateTime.SetHour (nHour);
    1203           0 :     rDateTime.SetMin (nMin);
    1204           0 :     rDateTime.SetSec (0);
    1205           0 :     rDateTime.SetNanoSec (0);
    1206             : 
    1207             : //      Date aCurDate;
    1208             : //      if (rDateTime.GetMonth() > aCurDate.GetMonth())
    1209             : //          rDateTime.SetYear(aCurDate.GetYear() - 1);
    1210             : //      else
    1211             : //          rDateTime.SetYear(aCurDate.GetYear());
    1212             : //      return sal_True;
    1213             : 
    1214             :     TimeValue aTimeVal;
    1215           0 :     osl_getSystemTime(&aTimeVal);
    1216             :     oslDateTime aCurrDateTime;
    1217           0 :     osl_getDateTimeFromTimeValue(&aTimeVal,&aCurrDateTime);
    1218             : 
    1219           0 :     if (rDateTime.GetMonth() > aCurrDateTime.Month)
    1220           0 :         rDateTime.SetYear(aCurrDateTime.Year - 1);
    1221             :     else
    1222           0 :         rDateTime.SetYear(aCurrDateTime.Year);
    1223           0 :     return sal_True;
    1224             : }
    1225             : 
    1226             : /*
    1227             :  * setYear.
    1228             :  *
    1229             :  * Two-digit years are taken as within 50 years back and 49 years forward
    1230             :  * (both ends inclusive) from the current year. The returned date is not
    1231             :  * checked for validity of the given day in the given month and year.
    1232             :  *
    1233             :  */
    1234           0 : sal_Bool FTPDirectoryParser::setYear (
    1235             :     DateTime &rDateTime, sal_uInt16 nYear)
    1236             : {
    1237           0 :     if (nYear < 100)
    1238             :     {
    1239             :         TimeValue aTimeVal;
    1240           0 :         osl_getSystemTime(&aTimeVal);
    1241             :         oslDateTime aCurrDateTime;
    1242           0 :         osl_getDateTimeFromTimeValue(&aTimeVal,&aCurrDateTime);
    1243           0 :         sal_uInt16 nCurrentYear = aCurrDateTime.Year;
    1244             : //        sal_uInt16 nCurrentYear = Date().GetYear();
    1245           0 :         sal_uInt16 nCurrentCentury = nCurrentYear / 100;
    1246           0 :         nCurrentYear %= 100;
    1247           0 :         if (nCurrentYear < 50)
    1248           0 :             if (nYear <= nCurrentYear)
    1249           0 :                 nYear += nCurrentCentury * 100;
    1250           0 :             else if (nYear < nCurrentYear + 50)
    1251           0 :                 nYear += nCurrentCentury * 100;
    1252             :             else
    1253           0 :                 nYear += (nCurrentCentury - 1) * 100;
    1254             :         else
    1255           0 :             if (nYear >= nCurrentYear)
    1256           0 :                 nYear += nCurrentCentury * 100;
    1257           0 :             else if (nYear >= nCurrentYear - 50)
    1258           0 :                 nYear += nCurrentCentury * 100;
    1259             :             else
    1260           0 :                 nYear += (nCurrentCentury + 1) * 100;
    1261             :     }
    1262             : 
    1263           0 :     rDateTime.SetYear(nYear);
    1264           0 :     return sal_True;
    1265             : }
    1266             : 
    1267             : /*
    1268             :  * setPath.
    1269             :  */
    1270           0 : sal_Bool FTPDirectoryParser::setPath (
    1271             :     OUString &rPath, const sal_Char *value, sal_Int32 length)
    1272             : {
    1273           0 :     if (value)
    1274             :     {
    1275           0 :         if (length < 0)
    1276           0 :             length = rtl_str_getLength (value);
    1277           0 :         rPath = OUString (value, length, RTL_TEXTENCODING_UTF8);
    1278             :     }
    1279           0 :     return (!!value);
    1280             : }
    1281             : 
    1282             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10