1. /*

  2.  * Copyright 2001-2004 The Apache Software Foundation

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  *     http://www.apache.org/licenses/LICENSE-2.0

  9.  *

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. package org.apache.commons.net.ftp.parser;

  17. import java.util.Calendar;

  18. import org.apache.commons.net.ftp.FTPFile;

  19. 

  20. /**

  21.  * Implementation FTPFileEntryParser and FTPFileListParser for standard

  22.  * Unix Systems.

  23.  *

  24.  * This class is based on the logic of Daniel Savarese's

  25.  * DefaultFTPListParser, but adapted to use regular expressions and to fit the

  26.  * new FTPFileEntryParser interface.

  27.  * @author <a href="mailto:scohen@ignitesports.com">Steve Cohen</a>

  28.  * @version $Id: UnixFTPEntryParser.java,v 1.17 2004/06/22 02:30:33 scohen Exp $

  29.  * @see org.apache.commons.net.ftp.FTPFileEntryParser FTPFileEntryParser (for usage instructions)

  30.  */

  31. public class UnixFTPEntryParser extends RegexFTPFileEntryParserImpl

  32. {

  33.     /**

  34.      * months abbreviations looked for by this parser.  Also used

  35.      * to determine which month is matched by the parser

  36.      */

  37.     private static final String MONTHS =

  38.         "(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)";

  39. 

  40.     /**

  41.      * this is the regular expression used by this parser.

  42.      *

  43.      * Permissions:

  44.      *    r   the file is readable

  45.      *    w   the file is writable

  46.      *    x   the file is executable

  47.      *    -   the indicated permission is not granted

  48.      *    L   mandatory locking occurs during access (the set-group-ID bit is

  49.      *        on and the group execution bit is off)

  50.      *    s   the set-user-ID or set-group-ID bit is on, and the corresponding

  51.      *        user or group execution bit is also on

  52.      *    S   undefined bit-state (the set-user-ID bit is on and the user

  53.      *        execution bit is off)

  54.      *    t   the 1000 (octal) bit, or sticky bit, is on [see chmod(1)], and

  55.      *        execution is on

  56.      *    T   the 1000 bit is turned on, and execution is off (undefined bit-

  57.      *        state)

  58.      */

  59.     private static final String REGEX =

  60.         "([bcdlfmpSs-])"

  61.         + "(((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-])))\\s+"

  62.         + "(\\d+)\\s+"

  63.         + "(\\S+)\\s+"

  64.         + "(?:(\\S+)\\s+)?"

  65.         + "(\\d+)\\s+"

  66.         + MONTHS + "\\s+"

  67.         + "((?:[0-9])|(?:[0-2][0-9])|(?:3[0-1]))\\s+"

  68.         + "((\\d\\d\\d\\d)|((?:[01]\\d)|(?:2[0123])|(?:[1-9])):([012345]\\d))\\s+"

  69.         + "(\\S+)(\\s*.*)";

  70. 

  71. 

  72.     /**

  73.      * The sole constructor for a UnixFTPEntryParser object.

  74.      *

  75.      * @exception IllegalArgumentException

  76.      * Thrown if the regular expression is unparseable.  Should not be seen

  77.      * under normal conditions.  It it is seen, this is a sign that

  78.      * <code>REGEX</code> is  not a valid regular expression.

  79.      */

  80.     public UnixFTPEntryParser()

  81.     {

  82.         super(REGEX);

  83.     }

  84. 

  85.     /**

  86.      * Parses a line of a unix (standard) FTP server file listing and converts

  87.      * it into a usable format in the form of an <code> FTPFile </code>

  88.      * instance.  If the file listing line doesn't describe a file,

  89.      * <code> null </code> is returned, otherwise a <code> FTPFile </code>

  90.      * instance representing the files in the directory is returned.

  91.      * <p>

  92.      * @param entry A line of text from the file listing

  93.      * @return An FTPFile instance corresponding to the supplied entry

  94.      */

  95.     public FTPFile parseFTPEntry(String entry)

  96.     {

  97. 

  98.         FTPFile file = new FTPFile();

  99.         file.setRawListing(entry);

  100.         int type;

  101.         boolean isDevice = false;

  102. 

  103.         if (matches(entry))

  104.         {

  105.             String typeStr = group(1);

  106.             String hardLinkCount = group(15);

  107.             String usr = group(16);

  108.             String grp = group(17);

  109.             String filesize = group(18);

  110.             String mo = group(19);

  111.             String da = group(20);

  112.             String yr = group(22);

  113.             String hr = group(23);

  114.             String min = group(24);

  115.             String name = group(25);

  116.             String endtoken = group(26);

  117. 

  118.             // bcdlfmpSs-

  119.             switch (typeStr.charAt(0))

  120.             {

  121.             case 'd':

  122.                 type = FTPFile.DIRECTORY_TYPE;

  123.                 break;

  124.             case 'l':

  125.                 type = FTPFile.SYMBOLIC_LINK_TYPE;

  126.                 break;

  127.             case 'b':

  128.             case 'c':

  129.                 isDevice = true;

  130.                 // break; - fall through

  131.             case 'f':

  132.             case '-':

  133.             	type = FTPFile.FILE_TYPE;

  134.             	break;

  135.             default:

  136.                 type = FTPFile.UNKNOWN_TYPE;

  137.             }

  138. 

  139.             file.setType(type);

  140. 

  141.             int g = 4;

  142.             for (int access = 0; access < 3; access++, g += 4)

  143.             {

  144.                 // Use != '-' to avoid having to check for suid and sticky bits

  145.                 file.setPermission(access, FTPFile.READ_PERMISSION,

  146.                                    (!group(g).equals("-")));

  147.                 file.setPermission(access, FTPFile.WRITE_PERMISSION,

  148.                                    (!group(g + 1).equals("-")));

  149. 

  150.                 String execPerm = group(g + 2);

  151.                 if (!execPerm.equals("-") && !Character.isUpperCase(execPerm.charAt(0)))

  152.                 {

  153.                     file.setPermission(access, FTPFile.EXECUTE_PERMISSION, true);

  154.                 }

  155.                 else

  156.                 {

  157.                     file.setPermission(access, FTPFile.EXECUTE_PERMISSION, false);

  158.                 }

  159.             }

  160. 

  161.             if (!isDevice)

  162.             {

  163.                 try

  164.                 {

  165.                     file.setHardLinkCount(Integer.parseInt(hardLinkCount));

  166.                 }

  167.                 catch (NumberFormatException e)

  168.                 {

  169.                     // intentionally do nothing

  170.                 }

  171.             }

  172. 

  173.             file.setUser(usr);

  174.             file.setGroup(grp);

  175. 

  176.             try

  177.             {

  178.                 file.setSize(Integer.parseInt(filesize));

  179.             }

  180.             catch (NumberFormatException e)

  181.             {

  182.                 // intentionally do nothing

  183.             }

  184. 

  185.             Calendar cal = Calendar.getInstance();

  186.             cal.set(Calendar.SECOND, 0);

  187.             cal.set(Calendar.MINUTE, 0);

  188.             cal.set(Calendar.HOUR_OF_DAY, 0);

  189. 

  190.             try

  191.             {

  192.                 int pos = MONTHS.indexOf(mo);

  193.                 int month = pos / 4;

  194. 

  195.                 if (null != yr)

  196.                 {

  197.                     // it's a year

  198.                     cal.set(Calendar.YEAR, Integer.parseInt(yr));

  199.                 }

  200.                 else

  201.                 {

  202.                     // it must be  hour/minute or we wouldn't have matched

  203.                     int year = cal.get(Calendar.YEAR);

  204.                     // if the month we're reading is greater than now, it must

  205.                     // be last year

  206.                     if (cal.get(Calendar.MONTH) < month)

  207.                     {

  208.                         year--;

  209.                     }

  210.                     cal.set(Calendar.YEAR, year);

  211.                     cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(hr));

  212.                     cal.set(Calendar.MINUTE, Integer.parseInt(min));

  213.                 }

  214.                 cal.set(Calendar.MONTH, month);

  215. 

  216.                 cal.set(Calendar.DATE, Integer.parseInt(da));

  217.                 file.setTimestamp(cal);

  218.             }

  219.             catch (NumberFormatException e)

  220.             {

  221.                 // do nothing, date will be uninitialized

  222.             }

  223.             if (null == endtoken)

  224.             {

  225.                 file.setName(name);

  226.             }

  227.             else

  228.             {

  229.                 // oddball cases like symbolic links, file names

  230.                 // with spaces in them.

  231.                 name += endtoken;

  232.                 if (type == FTPFile.SYMBOLIC_LINK_TYPE)

  233.                 {

  234. 

  235.                     int end = name.indexOf(" -> ");

  236.                     // Give up if no link indicator is present

  237.                     if (end == -1)

  238.                     {

  239.                         file.setName(name);

  240.                     }

  241.                     else

  242.                     {

  243.                         file.setName(name.substring(0, end));

  244.                         file.setLink(name.substring(end + 4));

  245.                     }

  246. 

  247.                 }

  248.                 else

  249.                 {

  250.                     file.setName(name);

  251.                 }

  252.             }

  253.             return file;

  254.         }

  255.         return null;

  256.     }

  257. }