| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_ucb.hxx" |
| |
| /************************************************************************** |
| TODO |
| ************************************************************************** |
| |
| *************************************************************************/ |
| #include "ftpdirp.hxx" |
| #include <osl/time.h> |
| |
| |
| using namespace rtl; |
| using namespace ftp; |
| |
| |
| typedef sal_uInt32 ULONG; |
| |
| |
| inline sal_Bool ascii_isLetter( sal_Unicode ch ) |
| { |
| return (( (ch >= 0x0041) && (ch <= 0x005A)) || |
| (( ch >= 0x0061) && (ch <= 0x007A))); |
| } |
| |
| inline sal_Bool ascii_isWhitespace( sal_Unicode ch ) |
| { |
| return ((ch <= 0x20) && ch); |
| } |
| |
| |
| |
| /*======================================================================== |
| * |
| * FTPDirectoryParser implementation. |
| * |
| *======================================================================*/ |
| /* |
| * parseDOS. |
| * Accepts one of two styles: |
| * |
| * 1 *WSP 1*2DIGIT ("." / "-") 1*2DIGIT ("." / "-") 1*4DIGIT 1*WSP |
| * 1*2DIGIT ":" 1*2DIGIT [*WSP ("A" / "P") "M"] 1*WSP |
| * ((DIGIT *(DIGIT / "." / ",")) / "<DIR>") 1*WSP 1*OCTET |
| * |
| * interpreted as: mm.dd.yy hh:mm (size / <DIR>) name |
| * |
| * 2 *WSP 1*DIGIT 1*WSP *(1*CHAR *WSP) *1("DIR" 1*WSP) 1*2DIGIT "-" 1*2DIGIT |
| * "-" 1*4DIGIT 1*WSP 1*2DIGIT ":" 1*2DIGIT 1*WSP 1*OCTET |
| * |
| * interpreted as: size attribs DIR mm-dd-yy hh:mm name |
| */ |
| |
| sal_Bool FTPDirectoryParser::parseDOS ( |
| FTPDirentry &rEntry, |
| const sal_Char *pBuffer) |
| { |
| sal_Bool bDirectory = false; |
| sal_uInt32 nSize = 0; |
| sal_uInt16 nYear = 0; |
| sal_uInt16 nMonth = 0; |
| sal_uInt16 nDay = 0; |
| sal_uInt16 nHour = 0; |
| sal_uInt16 nMinute = 0; |
| |
| enum StateType |
| { |
| STATE_INIT_LWS, |
| STATE_MONTH_OR_SIZE, |
| STATE_1_DAY, STATE_1_YEAR, STATE_1_YEAR_LWS, STATE_1_HOUR, |
| STATE_1_MINUTE, STATE_1_MINUTE_LWS, STATE_1_AP, |
| STATE_1_APM, STATE_1_LESS, STATE_1_D, STATE_1_DI, |
| STATE_1_DIR, STATE_1_SIZE, |
| STATE_2_SIZE, STATE_2_SIZE_LWS, STATE_2_ATTRIB, |
| STATE_2_D, STATE_2_DI, STATE_2_DIR_LWS, |
| STATE_2_MONTH, STATE_2_DAY, STATE_2_YEAR, STATE_2_YEAR_LWS, |
| STATE_2_HOUR, STATE_2_MINUTE, |
| STATE_LWS_NAME, |
| STATE_ERROR |
| }; |
| |
| int nDigits = 0; |
| enum StateType eState = STATE_INIT_LWS; |
| for (const sal_Char *p = pBuffer; |
| eState != STATE_ERROR && *p; |
| ++p) |
| { |
| switch (eState) |
| { |
| case STATE_INIT_LWS: |
| if (*p >= '0' && *p <= '9') |
| { |
| nMonth = *p - '0'; |
| nDigits = 1; |
| eState = STATE_MONTH_OR_SIZE; |
| } |
| else if (!ascii_isWhitespace(*p)) |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_MONTH_OR_SIZE: |
| if (*p >= '0' && *p <= '9') |
| { |
| nMonth = 10 * nMonth + (*p - '0'); |
| if (nDigits < 2) |
| ++nDigits; |
| else |
| { |
| nSize = nMonth; |
| nMonth = 0; |
| eState = STATE_2_SIZE; |
| } |
| } |
| else if (ascii_isWhitespace(*p)) |
| { |
| nSize = nMonth; |
| nMonth = 0; |
| eState = STATE_2_SIZE_LWS; |
| } |
| else if ((*p == '.' || *p == '-') && nMonth && nMonth <= 12) |
| { |
| nDigits = 0; |
| eState = STATE_1_DAY; |
| } |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_1_DAY: |
| if (*p >= '0' && *p <= '9') |
| if (nDigits < 2) |
| { |
| nDay = 10 * nDay + (*p - '0'); |
| ++nDigits; |
| } |
| else |
| eState = STATE_ERROR; |
| else if ((*p == '.' || *p == '-') && nDay && nDay <= 31) |
| { |
| nDigits = 0; |
| eState = STATE_1_YEAR; |
| } |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_1_YEAR: |
| if (*p >= '0' && *p <= '9') |
| { |
| if (nDigits < 4) |
| { |
| nYear = 10 * nYear + (*p - '0'); |
| ++nDigits; |
| } |
| else |
| eState = STATE_ERROR; |
| } |
| else |
| { |
| if (ascii_isWhitespace(*p)) |
| eState = STATE_1_YEAR_LWS; |
| else |
| eState = STATE_ERROR; |
| } |
| break; |
| |
| case STATE_1_YEAR_LWS: |
| if (*p >= '0' && *p <= '9') |
| { |
| nHour = *p - '0'; |
| nDigits = 1; |
| eState = STATE_1_HOUR; |
| } |
| else if (!ascii_isWhitespace(*p)) |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_1_HOUR: |
| if (*p >= '0' && *p <= '9') |
| if (nDigits < 2) |
| { |
| nHour = 10 * nHour + (*p - '0'); |
| ++nDigits; |
| } |
| else |
| eState = STATE_ERROR; |
| else if (*p == ':' && nHour < 24) |
| { |
| nDigits = 0; |
| eState = STATE_1_MINUTE; |
| } |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_1_MINUTE: |
| if (*p >= '0' && *p <= '9') |
| if (nDigits < 2) |
| { |
| nMinute = 10 * nMinute + (*p - '0'); |
| ++nDigits; |
| } |
| else |
| eState = STATE_ERROR; |
| else if ((*p == 'a' || *p == 'A') && nMinute < 60) |
| if (nHour >= 1 && nHour <= 11) |
| eState = STATE_1_AP; |
| else if (nHour == 12) |
| { |
| nHour = 0; |
| eState = STATE_1_AP; |
| } |
| else |
| eState = STATE_ERROR; |
| else if ((*p == 'p' || *p == 'P') && nMinute < 60) |
| if (nHour >= 1 && nHour <= 11) |
| { |
| nHour += 12; |
| eState = STATE_1_AP; |
| } |
| else if (nHour == 12) |
| eState = STATE_1_AP; |
| else |
| eState = STATE_ERROR; |
| else if (ascii_isWhitespace(*p) && (nMinute < 60)) |
| eState = STATE_1_MINUTE_LWS; |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_1_MINUTE_LWS: |
| if (*p == 'a' || *p == 'A') |
| if (nHour >= 1 && nHour <= 11) |
| eState = STATE_1_AP; |
| else if (nHour == 12) |
| { |
| nHour = 0; |
| eState = STATE_1_AP; |
| } |
| else |
| eState = STATE_ERROR; |
| else if (*p == 'p' || *p == 'P') |
| if (nHour >= 1 && nHour <= 11) |
| { |
| nHour += 12; |
| eState = STATE_1_AP; |
| } |
| else if (nHour == 12) |
| eState = STATE_1_AP; |
| else |
| eState = STATE_ERROR; |
| else if (*p == '<') |
| eState = STATE_1_LESS; |
| else if (*p >= '0' && *p <= '9') |
| { |
| nSize = *p - '0'; |
| eState = STATE_1_SIZE; |
| } |
| else if (!ascii_isWhitespace(*p)) |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_1_AP: |
| eState = *p == 'm' || *p == 'M' ? STATE_1_APM : STATE_ERROR; |
| break; |
| |
| case STATE_1_APM: |
| if (*p == '<') |
| eState = STATE_1_LESS; |
| else if (*p >= '0' && *p <= '9') |
| { |
| nSize = *p - '0'; |
| eState = STATE_1_SIZE; |
| } |
| else if (!ascii_isWhitespace(*p)) |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_1_LESS: |
| eState = *p == 'd' || *p == 'D' ? STATE_1_D : STATE_ERROR; |
| break; |
| |
| case STATE_1_D: |
| eState = *p == 'i' || *p == 'I' ? STATE_1_DI : STATE_ERROR; |
| break; |
| |
| case STATE_1_DI: |
| eState = *p == 'r' || *p == 'R' ? STATE_1_DIR : STATE_ERROR; |
| break; |
| |
| case STATE_1_DIR: |
| if (*p == '>') |
| { |
| bDirectory = true; |
| eState = STATE_LWS_NAME; |
| } |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_1_SIZE: |
| if (*p >= '0' && *p <= '9') |
| nSize = 10 * nSize + (*p - '0'); |
| else if (ascii_isWhitespace(*p)) |
| eState = STATE_LWS_NAME; |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_2_SIZE: |
| if (*p >= '0' && *p <= '9') |
| nSize = 10 * nSize + (*p - '0'); |
| else if (ascii_isWhitespace(*p)) |
| eState = STATE_2_SIZE_LWS; |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_2_SIZE_LWS: |
| if (*p == 'd' || *p == 'D') |
| eState = STATE_2_D; |
| else if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')) |
| eState = STATE_2_ATTRIB; |
| else if (*p >= '0' && *p <= '9') |
| { |
| nMonth = *p - '0'; |
| nDigits = 1; |
| eState = STATE_2_MONTH; |
| } |
| else if (!ascii_isWhitespace(*p)) |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_2_ATTRIB: |
| if (ascii_isWhitespace(*p)) |
| eState = STATE_2_SIZE_LWS; |
| else if ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z')) |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_2_D: |
| if (*p == 'i' || *p == 'I') |
| eState = STATE_2_DI; |
| else if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')) |
| eState = STATE_2_ATTRIB; |
| else if (ascii_isWhitespace(*p)) |
| eState = STATE_2_SIZE_LWS; |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_2_DI: |
| if (*p == 'r' || *p == 'R') |
| { |
| bDirectory = true; |
| eState = STATE_2_DIR_LWS; |
| } |
| else |
| { |
| if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')) |
| eState = STATE_2_ATTRIB; |
| else if (ascii_isWhitespace(*p)) |
| eState = STATE_2_SIZE_LWS; |
| else |
| eState = STATE_ERROR; |
| } |
| break; |
| |
| case STATE_2_DIR_LWS: |
| if (*p >= '0' && *p <= '9') |
| { |
| nMonth = *p - '0'; |
| nDigits = 1; |
| eState = STATE_2_MONTH; |
| } |
| else if (!ascii_isWhitespace(*p)) |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_2_MONTH: |
| if (*p >= '0' && *p <= '9') |
| if (nDigits < 2) |
| { |
| nMonth = 10 * nMonth + (*p - '0'); |
| ++nDigits; |
| } |
| else |
| eState = STATE_ERROR; |
| else if (*p == '-' && nMonth && nMonth <= 12) |
| { |
| nDigits = 0; |
| eState = STATE_2_DAY; |
| } |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_2_DAY: |
| if (*p >= '0' && *p <= '9') |
| if (nDigits < 2) |
| { |
| nDay = 10 * nDay + (*p - '0'); |
| ++nDigits; |
| } |
| else |
| eState = STATE_ERROR; |
| else if (*p == '-' && nDay && nDay <= 31) |
| { |
| nDigits = 0; |
| eState = STATE_2_YEAR; |
| } |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_2_YEAR: |
| if (*p >= '0' && *p <= '9') |
| { |
| if (nDigits < 4) |
| { |
| nYear = 10 * nYear + (*p - '0'); |
| ++nDigits; |
| } |
| else |
| eState = STATE_ERROR; |
| } |
| else |
| { |
| if (ascii_isWhitespace(*p)) |
| eState = STATE_2_YEAR_LWS; |
| else |
| eState = STATE_ERROR; |
| } |
| break; |
| |
| case STATE_2_YEAR_LWS: |
| if (*p >= '0' && *p <= '9') |
| { |
| nHour = *p - '0'; |
| nDigits = 1; |
| eState = STATE_2_HOUR; |
| } |
| else if (!ascii_isWhitespace(*p)) |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_2_HOUR: |
| if (*p >= '0' && *p <= '9') |
| if (nDigits < 2) |
| { |
| nHour = 10 * nHour + (*p - '0'); |
| ++nDigits; |
| } |
| else |
| eState = STATE_ERROR; |
| else if (*p == ':' && nHour < 24) |
| { |
| nDigits = 0; |
| eState = STATE_2_MINUTE; |
| } |
| else |
| eState = STATE_ERROR; |
| break; |
| |
| case STATE_2_MINUTE: |
| if (*p >= '0' && *p <= '9') |
| { |
| if (nDigits < 2) |
| { |
| nMinute = 10 * nMinute + (*p - '0'); |
| ++nDigits; |
| } |
| else |
| eState = STATE_ERROR; |
| } |
| else |
| { |
| if (ascii_isWhitespace(*p) && (nMinute < 60)) |
| eState = STATE_LWS_NAME; |
| else |
| eState = STATE_ERROR; |
| } |
| break; |
| |
| case STATE_LWS_NAME: |
| if (!ascii_isWhitespace(*p)) |
| { |
| setPath (rEntry.m_aName, p); |
| if (bDirectory) |
| rEntry.m_nMode |= INETCOREFTP_FILEMODE_ISDIR; |
| rEntry.m_nSize = nSize; |
| |
| setYear (rEntry.m_aDate, nYear); |
| |
| rEntry.m_aDate.SetMonth(nMonth); |
| rEntry.m_aDate.SetDay(nDay); |
| rEntry.m_aDate.SetHour(nHour); |
| rEntry.m_aDate.SetMin(nMinute); |
| |
| return sal_True; |
| } |
| break; |
| case STATE_ERROR: |
| break; |
| } |
| } |
| |
| return sal_False; |
| } |
| |
| /* |
| * parseVMS. |
| * Directory entries may span one or two lines: |
| * |
| * entry: *lws name *1(*lws <NEWLINE>) 1*lws size 1*lws datetime rest |
| * |
| * name: filename "." filetype ";" version |
| * filename: 1*39fchar |
| * filetype: 1*39fchar |
| * version: non0digit *digit |
| * |
| * size: "0" / non0digit *digit |
| * |
| * datetime: date 1*lwsp time |
| * date: day "-" month "-" year |
| * day: (*1"0" non0digit) / ("1"-"2" digit) / ("3" "0"-"1") |
| * month: "JAN" / "FEB" / "MAR" / "APR" / "MAY" / "JUN" / "JUL" / "AUG" |
| * / "SEP" / "OCT" / "NOV" / "DEC" ; all case insensitive |
| * year: 2digit / 4digit |
| * time: hour ":" minute |
| * hour: ((*1"0" / "1") digit) / ("2" "0"-"3") |
| * minute: "0"-"5" digit |
| * |
| * rest: *1(lws *<ANY>) |
| * |
| * lws: <TAB> / <SPACE> |
| * non0digit: "1"-"9" |
| * digit: "0" / non0digit |
| * fchar: "A"-"Z" / "a"-"z" / digit / "-" / "_" / "$" |
| * |
| * For directories, the returned name is the <filename> part; for non- |
| * directory files, the returned name is the <filename "." filetype> part. |
| * An entry is a directory iff its filetype is "DIR" (ignoring case). |
| * |
| * The READ, WRITE, and ISLINK mode bits are not supported. |
| * |
| * The returned size is the <size> part, multiplied by 512, and with the high |
| * order bits truncated to fit into a ULONG. |
| * |
| */ |
| sal_Bool FTPDirectoryParser::parseVMS ( |
| FTPDirentry &rEntry, |
| const sal_Char *pBuffer) |
| { |
| static OUString aFirstLineName; |
| static sal_Bool bFirstLineDir = sal_False; |
| |
| for (sal_Bool bFirstLine = sal_True;; bFirstLine = sal_False) |
| { |
| const sal_Char *p = pBuffer; |
| if (bFirstLine) |
| { |
| // Skip <*lws> part: |
| while (*p == '\t' || *p == ' ') |
| ++p; |
| |
| // Parse <filename "."> part: |
| const sal_Char *pFileName = p; |
| while ((*p >= 'A' && *p <= 'Z') || |
| (*p >= 'a' && *p <= 'z') || |
| (*p >= '0' && *p <= '9') || |
| *p == '-' || *p == '_' || *p == '$') |
| ++p; |
| |
| if (*p != '.' || p == pFileName || p - pFileName > 39) |
| { |
| if (aFirstLineName.getLength()) |
| continue; |
| else |
| return sal_False; |
| } |
| |
| // Parse <filetype ";"> part: |
| const sal_Char *pFileType = ++p; |
| while ((*p >= 'A' && *p <= 'Z') || |
| (*p >= 'a' && *p <= 'z') || |
| (*p >= '0' && *p <= '9') || |
| *p == '-' || *p == '_' || *p == '$') |
| ++p; |
| |
| if (*p != ';' || p == pFileName || p - pFileName > 39) |
| { |
| if (aFirstLineName.getLength()) |
| continue; |
| else |
| return sal_False; |
| } |
| ++p; |
| |
| // Set entry's name and mode (ISDIR flag): |
| if ((p - pFileType == 4) && |
| (pFileType[0] == 'D' || pFileType[0] == 'd') && |
| (pFileType[1] == 'I' || pFileType[1] == 'i') && |
| (pFileType[2] == 'R' || pFileType[2] == 'r') ) |
| { |
| setPath (rEntry.m_aName, pFileName, (pFileType - pFileName)); |
| rEntry.m_nMode = INETCOREFTP_FILEMODE_ISDIR; |
| } |
| else |
| { |
| setPath (rEntry.m_aName, pFileName, (p - pFileName)); |
| rEntry.m_nMode = 0; |
| } |
| |
| // Skip <version> part: |
| if (*p < '1' || *p > '9') |
| { |
| if (aFirstLineName.getLength()) |
| continue; |
| else |
| return sal_False; |
| } |
| ++p; |
| while (*p >= '0' && *p <= '9') |
| ++p; |
| |
| // Parse <1*lws> or <*lws <NEWLINE>> part: |
| sal_Bool bLWS = false; |
| while (*p == '\t' || *p == ' ') |
| { |
| bLWS = true; |
| ++p; |
| } |
| if (*p) |
| { |
| if (!bLWS) |
| { |
| if (aFirstLineName.getLength()) |
| continue; |
| else |
| return sal_False; |
| } |
| } |
| else |
| { |
| /* |
| * First line of entry spanning two lines, |
| * wait for second line. |
| */ |
| aFirstLineName = rEntry.m_aName; |
| bFirstLineDir = |
| ((rEntry.m_nMode & INETCOREFTP_FILEMODE_ISDIR) != 0); |
| return sal_False; |
| } |
| } |
| else |
| { |
| /* |
| * Second line of entry spanning two lines, |
| * restore entry's name and mode (ISDIR flag). |
| */ |
| rEntry.m_aName = aFirstLineName; |
| rEntry.m_nMode = (bFirstLineDir ? INETCOREFTP_FILEMODE_ISDIR : 0); |
| |
| // Skip <1*lws> part: |
| if (*p != '\t' && *p != ' ') |
| return sal_False; |
| ++p; |
| while (*p == '\t' || *p == ' ') |
| ++p; |
| } |
| |
| // Parse <size> part and set entry's size: |
| if (*p < '0' || *p > '9') |
| return sal_False; |
| ULONG nSize = *p - '0'; |
| if (*p++ != '0') |
| while (*p >= '0' && *p <= '9') |
| nSize = 10 * rEntry.m_nSize + (*p++ - '0'); |
| rEntry.m_nSize = 512 * nSize; |
| |
| // Skip <1*lws> part: |
| if (*p != '\t' && *p != ' ') |
| return sal_False; |
| ++p; |
| while (*p == '\t' || *p == ' ') |
| ++p; |
| |
| // Parse <day "-"> part and set entry date's day: |
| sal_uInt16 nDay; |
| if (*p == '0') |
| { |
| ++p; |
| if (*p < '1' || *p > '9') |
| return sal_False; |
| nDay = *p++ - '0'; |
| } |
| else if (*p == '1' || *p == '2') |
| { |
| nDay = *p++ - '0'; |
| if (*p >= '0' && *p <= '9') |
| nDay = 10 * nDay + (*p++ - '0'); |
| } |
| else if (*p == '3') |
| { |
| ++p; |
| nDay = (*p == '0' || *p == '1') ? 30 + (*p++ - '0') : 3; |
| } |
| else if (*p >= '4' && *p <= '9') |
| nDay = *p++ - '0'; |
| else |
| return sal_False; |
| |
| rEntry.m_aDate.SetDay(nDay); |
| if (*p++ != '-') |
| return sal_False; |
| |
| // Parse <month "-"> part and set entry date's month: |
| sal_Char const * pMonth = p; |
| sal_Int32 const monthLen = 3; |
| for (int i = 0; i < monthLen; ++i) |
| { |
| if (!((*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z'))) |
| return sal_False; |
| ++p; |
| } |
| if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("JAN")) == 0) |
| rEntry.m_aDate.SetMonth(1); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("FEB")) == 0) |
| rEntry.m_aDate.SetMonth(2); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("MAR")) == 0) |
| rEntry.m_aDate.SetMonth(3); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("APR")) == 0) |
| rEntry.m_aDate.SetMonth(4); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("MAY")) == 0) |
| rEntry.m_aDate.SetMonth(5); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("JUN")) == 0) |
| rEntry.m_aDate.SetMonth(6); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("JUL")) == 0) |
| rEntry.m_aDate.SetMonth(7); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("AUG")) == 0) |
| rEntry.m_aDate.SetMonth(8); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("SEP")) == 0) |
| rEntry.m_aDate.SetMonth(9); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("OCT")) == 0) |
| rEntry.m_aDate.SetMonth(10); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("NOV")) == 0) |
| rEntry.m_aDate.SetMonth(11); |
| else if (rtl_str_compareIgnoreAsciiCase_WithLength( |
| pMonth, monthLen, RTL_CONSTASCII_STRINGPARAM("DEC")) == 0) |
| rEntry.m_aDate.SetMonth(12); |
| else |
| return sal_False; |
| if (*p++ != '-') |
| return sal_False; |
| |
| // Parse <year> part and set entry date's year: |
| sal_uInt16 nYear = 0; |
| {for (int i = 0; i < 2; ++i) |
| { |
| if (*p < '0' || *p > '9') |
| return sal_False; |
| nYear = 10 * nYear + (*p++ - '0'); |
| }} |
| if (*p >= '0' && *p <= '9') |
| { |
| nYear = 10 * nYear + (*p++ - '0'); |
| if (*p < '0' || *p > '9') |
| return sal_False; |
| nYear = 10 * nYear + (*p++ - '0'); |
| } |
| setYear (rEntry.m_aDate, nYear); |
| |
| // Skip <1*lws> part: |
| if (*p != '\t' && *p != ' ') |
| return sal_False; |
| ++p; |
| while (*p == '\t' || *p == ' ') |
| ++p; |
| |
| // Parse <hour ":"> part and set entry time's hour: |
| sal_uInt16 nHour; |
| if (*p == '0' || *p == '1') |
| { |
| nHour = *p++ - '0'; |
| if (*p >= '0' && *p <= '9') |
| nHour = 10 * nHour + (*p++ - '0'); |
| } |
| else if (*p == '2') |
| { |
| ++p; |
| nHour = (*p >= '0' && *p <= '3') ? 20 + (*p++ - '0') : 2; |
| } |
| else if (*p >= '3' && *p <= '9') |
| nHour = *p++ - '0'; |
| else |
| return sal_False; |
| |
| rEntry.m_aDate.SetHour(nHour); |
| if (*p++ != ':') |
| return sal_False; |
| |
| /* |
| * Parse <minute> part and set entry time's minutes, |
| * seconds (0), and 1/100 seconds (0). |
| */ |
| if (*p < '0' || *p > '5') |
| return sal_False; |
| |
| sal_uInt16 nMinute = *p++ - '0'; |
| if (*p < '0' || *p > '9') |
| return sal_False; |
| |
| nMinute = 10 * nMinute + (*p++ - '0'); |
| rEntry.m_aDate.SetMin(nMinute); |
| rEntry.m_aDate.SetSec(0); |
| rEntry.m_aDate.Set100Sec(0); |
| |
| // Skip <rest> part: |
| if (*p && (*p != '\t' && *p != ' ')) |
| return sal_False; |
| |
| return sal_True; |
| } |
| } |
| |
| /* |
| * parseUNIX |
| */ |
| sal_Bool FTPDirectoryParser::parseUNIX ( |
| FTPDirentry &rEntry, |
| const sal_Char *pBuffer) |
| { |
| const sal_Char *p1, *p2; |
| p1 = p2 = pBuffer; |
| |
| if (!((*p1 == '-') || (*p1 == 'd') || (*p1 == 'l'))) |
| return sal_False; |
| |
| // 1st column: FileMode. |
| if (*p1 == 'd') |
| rEntry.m_nMode |= INETCOREFTP_FILEMODE_ISDIR; |
| |
| if (*p1 == 'l') |
| rEntry.m_nMode |= INETCOREFTP_FILEMODE_ISLINK; |
| |
| // Skip to end of column and set rights by the way |
| while (*p1 && !ascii_isWhitespace(*p1)) { |
| if(*p1 == 'r') |
| rEntry.m_nMode |= INETCOREFTP_FILEMODE_READ; |
| else if(*p1 == 'w') |
| rEntry.m_nMode |= INETCOREFTP_FILEMODE_WRITE; |
| p1++; |
| } |
| |
| /* |
| * Scan for the sequence of size and date fields: |
| * *LWS 1*DIGIT 1*LWS 3CHAR 1*LWS 1*2DIGIT 1*LWS |
| * (4DIGIT / (1*2DIGIT ":" 2DIGIT)) 1*LWS |
| */ |
| enum Mode |
| { |
| FOUND_NONE, FOUND_SIZE, FOUND_MONTH, FOUND_DAY, FOUND_YEAR_TIME |
| }; |
| |
| const sal_Char *pDayStart = 0; |
| const sal_Char *pDayEnd = 0; |
| Mode eMode; |
| for (eMode = FOUND_NONE; *p1 && eMode != FOUND_YEAR_TIME; p1 = p2 + 1) |
| { |
| while (*p1 && ascii_isWhitespace(*p1)) |
| ++p1; |
| p2 = p1; |
| while (*p2 && !ascii_isWhitespace(*p2)) |
| ++p2; |
| |
| switch (eMode) |
| { |
| case FOUND_NONE: |
| if (parseUNIX_isSizeField (p1, p2, rEntry.m_nSize)) |
| eMode = FOUND_SIZE; |
| break; |
| |
| case FOUND_SIZE: |
| if (parseUNIX_isMonthField (p1, p2, rEntry.m_aDate)) |
| eMode = FOUND_MONTH; |
| else if (!parseUNIX_isSizeField (p1, p2, rEntry.m_nSize)) |
| eMode = FOUND_NONE; |
| break; |
| |
| case FOUND_MONTH: |
| if (parseUNIX_isDayField (p1, p2, rEntry.m_aDate)) |
| { |
| pDayStart = p1; |
| pDayEnd = p2; |
| eMode = FOUND_DAY; |
| } |
| else if (parseUNIX_isSizeField (p1, p2, rEntry.m_nSize)) |
| eMode = FOUND_SIZE; |
| else |
| eMode = FOUND_NONE; |
| break; |
| |
| case FOUND_DAY: |
| if (parseUNIX_isYearTimeField (p1, p2, rEntry.m_aDate)) |
| eMode = FOUND_YEAR_TIME; |
| else if ( |
| parseUNIX_isSizeField ( |
| pDayStart, pDayEnd, rEntry.m_nSize) && |
| parseUNIX_isMonthField ( |
| p1, p2, rEntry.m_aDate)) |
| eMode = FOUND_MONTH; |
| else if (parseUNIX_isSizeField (p1, p2, rEntry.m_nSize)) |
| eMode = FOUND_SIZE; |
| else |
| eMode = FOUND_NONE; |
| break; |
| case FOUND_YEAR_TIME: |
| break; |
| } |
| } |
| |
| if (eMode == FOUND_YEAR_TIME) |
| { |
| // 9th column: FileName (rest of line). |
| while (*p1 && ascii_isWhitespace(*p1)) p1++; |
| setPath (rEntry.m_aName, p1); |
| |
| // Done. |
| return sal_True; |
| } |
| return sal_False; |
| } |
| |
| /* |
| * parseUNIX_isSizeField. |
| */ |
| sal_Bool FTPDirectoryParser::parseUNIX_isSizeField ( |
| const sal_Char *pStart, |
| const sal_Char *pEnd, |
| sal_uInt32 &rSize) |
| { |
| if (!*pStart || !*pEnd || pStart == pEnd) |
| return sal_False; |
| |
| rSize = 0; |
| if (*pStart >= '0' && *pStart <= '9') |
| { |
| for (; pStart < pEnd; ++pStart) |
| if ((*pStart >= '0') && (*pStart <= '9')) |
| rSize = 10 * rSize + (*pStart - '0'); |
| else |
| return sal_False; |
| return sal_True; |
| } |
| else |
| { |
| /* |
| * For a combination of long group name and large file size, |
| * some FTPDs omit LWS between those two columns. |
| */ |
| int nNonDigits = 0; |
| int nDigits = 0; |
| |
| for (; pStart < pEnd; ++pStart) |
| if ((*pStart >= '1') && (*pStart <= '9')) |
| { |
| ++nDigits; |
| rSize = 10 * rSize + (*pStart - '0'); |
| } |
| else if ((*pStart == '0') && nDigits) |
| { |
| ++nDigits; |
| rSize *= 10; |
| } |
| else if ((*pStart > ' ') && (sal::static_int_cast<sal_uInt8>(*pStart) <= '\x7F')) |
| { |
| nNonDigits += nDigits + 1; |
| nDigits = 0; |
| rSize = 0; |
| } |
| else |
| return sal_False; |
| return ((nNonDigits >= 9) && (nDigits >= 7)); |
| } |
| } |
| |
| /* |
| * parseUNIX_isMonthField. |
| */ |
| sal_Bool FTPDirectoryParser::parseUNIX_isMonthField ( |
| const sal_Char *pStart, |
| const sal_Char *pEnd, |
| DateTime &rDateTime) |
| { |
| if (!*pStart || !*pEnd || pStart + 3 != pEnd) |
| return sal_False; |
| |
| if ((pStart[0] == 'j' || pStart[0] == 'J') && |
| (pStart[1] == 'a' || pStart[1] == 'A') && |
| (pStart[2] == 'n' || pStart[2] == 'N') ) |
| { |
| rDateTime.SetMonth(1); |
| return sal_True; |
| } |
| if ((pStart[0] == 'f' || pStart[0] == 'F') && |
| (pStart[1] == 'e' || pStart[1] == 'E') && |
| (pStart[2] == 'b' || pStart[2] == 'B') ) |
| { |
| rDateTime.SetMonth(2); |
| return sal_True; |
| } |
| if ((pStart[0] == 'm' || pStart[0] == 'M') && |
| (pStart[1] == 'a' || pStart[1] == 'A') && |
| (pStart[2] == 'r' || pStart[2] == 'R') ) |
| { |
| rDateTime.SetMonth(3); |
| return sal_True; |
| } |
| if ((pStart[0] == 'a' || pStart[0] == 'A') && |
| (pStart[1] == 'p' || pStart[1] == 'P') && |
| (pStart[2] == 'r' || pStart[2] == 'R') ) |
| { |
| rDateTime.SetMonth(4); |
| return sal_True; |
| } |
| if ((pStart[0] == 'm' || pStart[0] == 'M') && |
| (pStart[1] == 'a' || pStart[1] == 'A') && |
| (pStart[2] == 'y' || pStart[2] == 'Y') ) |
| { |
| rDateTime.SetMonth(5); |
| return sal_True; |
| } |
| if ((pStart[0] == 'j' || pStart[0] == 'J') && |
| (pStart[1] == 'u' || pStart[1] == 'U') && |
| (pStart[2] == 'n' || pStart[2] == 'N') ) |
| { |
| rDateTime.SetMonth(6); |
| return sal_True; |
| } |
| if ((pStart[0] == 'j' || pStart[0] == 'J') && |
| (pStart[1] == 'u' || pStart[1] == 'U') && |
| (pStart[2] == 'l' || pStart[2] == 'L') ) |
| { |
| rDateTime.SetMonth(7); |
| return sal_True; |
| } |
| if ((pStart[0] == 'a' || pStart[0] == 'A') && |
| (pStart[1] == 'u' || pStart[1] == 'U') && |
| (pStart[2] == 'g' || pStart[2] == 'G') ) |
| { |
| rDateTime.SetMonth(8); |
| return sal_True; |
| } |
| if ((pStart[0] == 's' || pStart[0] == 'S') && |
| (pStart[1] == 'e' || pStart[1] == 'E') && |
| (pStart[2] == 'p' || pStart[2] == 'P') ) |
| { |
| rDateTime.SetMonth(9); |
| return sal_True; |
| } |
| if ((pStart[0] == 'o' || pStart[0] == 'O') && |
| (pStart[1] == 'c' || pStart[1] == 'C') && |
| (pStart[2] == 't' || pStart[2] == 'T') ) |
| { |
| rDateTime.SetMonth(10); |
| return sal_True; |
| } |
| if ((pStart[0] == 'n' || pStart[0] == 'N') && |
| (pStart[1] == 'o' || pStart[1] == 'O') && |
| (pStart[2] == 'v' || pStart[2] == 'V') ) |
| { |
| rDateTime.SetMonth(11); |
| return sal_True; |
| } |
| if ((pStart[0] == 'd' || pStart[0] == 'D') && |
| (pStart[1] == 'e' || pStart[1] == 'E') && |
| (pStart[2] == 'c' || pStart[2] == 'C') ) |
| { |
| rDateTime.SetMonth(12); |
| return sal_True; |
| } |
| return sal_False; |
| } |
| |
| /* |
| * parseUNIX_isDayField. |
| */ |
| sal_Bool FTPDirectoryParser::parseUNIX_isDayField ( |
| const sal_Char *pStart, |
| const sal_Char *pEnd, |
| DateTime &rDateTime) |
| { |
| if (!*pStart || !*pEnd || pStart == pEnd) |
| return sal_False; |
| if (*pStart < '0' || *pStart > '9') |
| return sal_False; |
| |
| sal_uInt16 nDay = *pStart - '0'; |
| if (pStart + 1 < pEnd) |
| { |
| if (pStart + 2 != pEnd || pStart[1] < '0' || pStart[1] > '9') |
| return sal_False; |
| nDay = 10 * nDay + (pStart[1] - '0'); |
| } |
| if (!nDay || nDay > 31) |
| return sal_False; |
| |
| rDateTime.SetDay(nDay); |
| return sal_True; |
| } |
| |
| /* |
| * parseUNIX_isYearTimeField. |
| */ |
| sal_Bool FTPDirectoryParser::parseUNIX_isYearTimeField ( |
| const sal_Char *pStart, |
| const sal_Char *pEnd, |
| DateTime &rDateTime) |
| { |
| if (!*pStart || !*pEnd || pStart == pEnd || |
| *pStart < '0' || *pStart > '9') |
| return sal_False; |
| |
| sal_uInt16 nNumber = *pStart - '0'; |
| ++pStart; |
| |
| if (pStart == pEnd) |
| return sal_False; |
| if (*pStart == ':') |
| return parseUNIX_isTime (pStart, pEnd, nNumber, rDateTime); |
| if (*pStart < '0' || *pStart > '9') |
| return sal_False; |
| |
| nNumber = 10 * nNumber + (*pStart - '0'); |
| ++pStart; |
| |
| if (pStart == pEnd) |
| return sal_False; |
| if (*pStart == ':') |
| return parseUNIX_isTime (pStart, pEnd, nNumber, rDateTime); |
| if (*pStart < '0' || *pStart > '9') |
| return sal_False; |
| |
| nNumber = 10 * nNumber + (*pStart - '0'); |
| ++pStart; |
| |
| if (pStart == pEnd || *pStart < '0' || *pStart > '9') |
| return sal_False; |
| |
| nNumber = 10 * nNumber + (*pStart - '0'); |
| if (pStart + 1 != pEnd || nNumber < 1970) |
| return sal_False; |
| |
| rDateTime.SetYear(nNumber); |
| rDateTime.SetTime(0); |
| return sal_True; |
| } |
| |
| /* |
| * parseUNIX_isTime. |
| */ |
| sal_Bool FTPDirectoryParser::parseUNIX_isTime ( |
| const sal_Char *pStart, |
| const sal_Char *pEnd, |
| sal_uInt16 nHour, |
| DateTime &rDateTime) |
| { |
| if ((nHour > 23 ) || (pStart + 3 != pEnd) || |
| (pStart[1] < '0') || (pStart[1] > '5') || |
| (pStart[2] < '0') || (pStart[2] > '9') ) |
| return sal_False; |
| |
| sal_uInt16 nMin = 10 * (pStart[1] - '0') + (pStart[2] - '0'); |
| |
| rDateTime.SetHour (nHour); |
| rDateTime.SetMin (nMin); |
| rDateTime.SetSec (0); |
| rDateTime.Set100Sec (0); |
| |
| // Date aCurDate; |
| // if (rDateTime.GetMonth() > aCurDate.GetMonth()) |
| // rDateTime.SetYear(aCurDate.GetYear() - 1); |
| // else |
| // rDateTime.SetYear(aCurDate.GetYear()); |
| // return sal_True; |
| |
| TimeValue aTimeVal; |
| osl_getSystemTime(&aTimeVal); |
| oslDateTime aCurrDateTime; |
| osl_getDateTimeFromTimeValue(&aTimeVal,&aCurrDateTime); |
| |
| if (rDateTime.GetMonth() > aCurrDateTime.Month) |
| rDateTime.SetYear(aCurrDateTime.Year - 1); |
| else |
| rDateTime.SetYear(aCurrDateTime.Year); |
| return sal_True; |
| } |
| |
| /* |
| * setYear. |
| * |
| * Two-digit years are taken as within 50 years back and 49 years forward |
| * (both ends inclusive) from the current year. The returned date is not |
| * checked for validity of the given day in the given month and year. |
| * |
| */ |
| sal_Bool FTPDirectoryParser::setYear ( |
| DateTime &rDateTime, sal_uInt16 nYear) |
| { |
| if (nYear < 100) |
| { |
| TimeValue aTimeVal; |
| osl_getSystemTime(&aTimeVal); |
| oslDateTime aCurrDateTime; |
| osl_getDateTimeFromTimeValue(&aTimeVal,&aCurrDateTime); |
| sal_uInt16 nCurrentYear = aCurrDateTime.Year; |
| // sal_uInt16 nCurrentYear = Date().GetYear(); |
| sal_uInt16 nCurrentCentury = nCurrentYear / 100; |
| nCurrentYear %= 100; |
| if (nCurrentYear < 50) |
| if (nYear <= nCurrentYear) |
| nYear += nCurrentCentury * 100; |
| else if (nYear < nCurrentYear + 50) |
| nYear += nCurrentCentury * 100; |
| else |
| nYear += (nCurrentCentury - 1) * 100; |
| else |
| if (nYear >= nCurrentYear) |
| nYear += nCurrentCentury * 100; |
| else if (nYear >= nCurrentYear - 50) |
| nYear += nCurrentCentury * 100; |
| else |
| nYear += (nCurrentCentury + 1) * 100; |
| } |
| |
| rDateTime.SetYear(nYear); |
| return sal_True; |
| } |
| |
| /* |
| * setPath. |
| */ |
| sal_Bool FTPDirectoryParser::setPath ( |
| OUString &rPath, const sal_Char *value, sal_Int32 length) |
| { |
| if (value) |
| { |
| if (length < 0) |
| length = rtl_str_getLength (value); |
| rPath = OUString (value, length, RTL_TEXTENCODING_UTF8); |
| } |
| return (!!value); |
| } |
