using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
#if NET45
using System.Threading.Tasks;
#endif
namespace FluentFTP {
///
/// Parses a line from a file listing using the first successful parser, or the specified parser.
/// Returns an FtpListItem object representing the parsed line, or null if the line was unable to be parsed.
///
public class FtpListParser {
#region Constants
// DATE/TIME FORMATS
private string[] unixDateFormats1 = { "MMM'-'d'-'yyyy", "MMM'-'dd'-'yyyy" };
private string[] unixDateFormats2 = { "MMM'-'d'-'yyyy'-'HH':'mm", "MMM'-'dd'-'yyyy'-'HH':'mm", "MMM'-'d'-'yyyy'-'H':'mm", "MMM'-'dd'-'yyyy'-'H':'mm", "MMM'-'dd'-'yyyy'-'H'.'mm" };
private string[] unixAltDateFormats1 = { "MMM'-'d'-'yyyy", "MMM'-'dd'-'yyyy" };
private string[] unixAltDateFormats2 = { "MMM'-'d'-'yyyy'-'HH':'mm:ss", "MMM'-'dd'-'yyyy'-'HH':'mm:ss", "MMM'-'d'-'yyyy'-'H':'mm:ss", "MMM'-'dd'-'yyyy'-'H':'mm:ss" };
private string[] windowsDateFormats = { "MM'-'dd'-'yy hh':'mmtt", "MM'-'dd'-'yy HH':'mm", "MM'-'dd'-'yyyy hh':'mmtt" };
private string[][] ibmDateFormats = { new string[] { "dd'/'MM'/'yy' 'HH':'mm':'ss", "dd'/'MM'/'yyyy' 'HH':'mm':'ss", "dd'.'MM'.'yy' 'HH':'mm':'ss" }, new string[] { "yy'/'MM'/'dd' 'HH':'mm':'ss", "yyyy'/'MM'/'dd' 'HH':'mm':'ss", "yy'.'MM'.'dd' 'HH':'mm':'ss" }, new string[] { "MM'/'dd'/'yy' 'HH':'mm':'ss", "MM'/'dd'/'yyyy' 'HH':'mm':'ss", "MM'.'dd'.'yy' 'HH':'mm':'ss" } };
private string[] nonstopDateFormats = { "d'-'MMM'-'yy HH':'mm':'ss" };
// FIELDS REQUIRED
private static int MIN_EXPECTED_FIELD_COUNT_UNIX = 7;
private static int MIN_EXPECTED_FIELD_COUNT_UNIXALT = 8;
private static int MIN_EXPECTED_FIELD_COUNT_VMS = 4;
private static int MIN_EXPECTED_FIELD_COUNT_OS400 = 5;
private static int MIN_EXPECTED_FIELD_COUNT_TANDEM = 7;
// UNIX
private static string SYMLINK_ARROW = "->";
private static char SYMLINK_CHAR = 'l';
private static char ORDINARY_FILE_CHAR = '-';
private static char DIRECTORY_CHAR = 'd';
// WINDOWS
private static string WIN_DIR = "";
private static char[] WIN_SEP = { ' ' };
private static int MIN_EXPECTED_FIELD_COUNT_WIN = 4;
// VMS
private static string VMS_DIR = ".DIR";
private static string VMS_HDR = "Directory";
private static string VMS_TOTAL = "Total";
private static int DEFAULT_BLOCKSIZE = 512 * 1024;
// IBM
private static string IBM_DIR = "*DIR";
private static string IBM_DDIR = "*DDIR";
private static string IBM_MEM = "*MEM";
private static string IBM_FILE = "*FILE";
// NONSTOP
private static char[] NONSTOP_TRIM = { '"' };
#endregion
#region API
///
/// the FTP connection that owns this parser
///
public FtpClient client;
private static List parsers = new List{
FtpParser.Unix, FtpParser.Windows, FtpParser.IBM, FtpParser.VMS, FtpParser.NonStop
};
///
/// which server type? (SYST)
///
public string system;
///
/// current parser, or parser set by user
///
public FtpParser parser = FtpParser.Auto;
///
/// parser calculated based on system type (SYST command)
///
public FtpParser detectedParser = FtpParser.Auto;
///
/// if we have detected that the current parser is valid
///
public bool parserConfirmed = false;
///
/// which culture to read filenames with?
///
public CultureInfo parserCulture = CultureInfo.InvariantCulture;
///
/// what is the time offset between server/client?
///
public TimeSpan timeOffset = new TimeSpan();
///
/// any time offset between server/client?
///
public bool hasTimeOffset = false;
///
/// VMS ONLY : the blocksize used to calculate the file
///
public int vmsBlocksize = DEFAULT_BLOCKSIZE;
///
/// Is the version number returned as part of the filename?
///
/// Some VMS FTP servers do not permit a file to be deleted unless
/// the filename includes the version number. Note that directories are
/// never returned with the version number.
///
public bool vmsNameHasVersion = false;
///
/// Initializes a new instance of the class.
///
/// An existing object
public FtpListParser(FtpClient client = null) {
this.client = client;
}
///
/// Try to auto-detect which parser is suitable given a system string.
///
/// result of SYST command
public void Init(string system) {
parserConfirmed = false;
this.system = system != null ? system.Trim() : null;
if (system != null) {
if (system.ToUpper().StartsWith("WINDOWS")) {
FtpTrace.WriteStatus(FtpTraceLevel.Info, "Auto-detected Windows listing parser");
parser = FtpParser.Windows;
} else if (system.ToUpper().IndexOf("UNIX") >= 0 || system.ToUpper().IndexOf("AIX") >= 0) {
FtpTrace.WriteStatus(FtpTraceLevel.Info, "Auto-detected UNIX listing parser");
parser = FtpParser.Unix;
} else if (system.ToUpper().IndexOf("VMS") >= 0) {
FtpTrace.WriteStatus(FtpTraceLevel.Info, "Auto-detected VMS listing parser");
parser = FtpParser.VMS;
} else if (system.ToUpper().IndexOf("OS/400") >= 0) {
FtpTrace.WriteStatus(FtpTraceLevel.Info, "Auto-detected OS/400 listing parser");
parser = FtpParser.IBM;
} else {
parser = FtpParser.Unix;
FtpTrace.WriteStatus(FtpTraceLevel.Warn, "Cannot auto-detect listing parser for system '" + system + "', using Unix parser");
}
}
detectedParser = parser;
}
///
/// Parse raw file list from server into file objects, using the currently active parser.
///
public FtpListItem[] ParseMultiLine(string[] fileStrings, bool isMachineList) {
FtpListItem[] files = new FtpListItem[fileStrings.Length];
if (fileStrings.Length == 0) {
return files;
}
FtpTrace.WriteStatus(FtpTraceLevel.Verbose, "Parse() called using culture: " + parserCulture.EnglishName);
ValidateParser(fileStrings);
int count = 0;
for (int i = 0; i < fileStrings.Length; i++) {
if (fileStrings[i] == null || fileStrings[i].Trim().Length == 0)
continue;
try {
// MULTI LINE LISTINGS
FtpListItem file = null;
if (IsMultiLine(parser)) {
StringBuilder filename = new StringBuilder(fileStrings[i]);
while (i + 1 < fileStrings.Length && fileStrings[i + 1].IndexOf(';') < 0) {
filename.Append(" ").Append(fileStrings[i + 1]);
i++;
}
file = ParseSingleLine(null, filename.ToString(), FtpCapability.NONE, isMachineList);
} else {
// SINGLE LINE LISTINGS
file = ParseSingleLine(null, fileStrings[i], FtpCapability.NONE, isMachineList);
}
// skip blank lines
if (file != null) {
files[count++] = file;
}
} catch (CriticalListParseException) {
FtpTrace.WriteStatus(FtpTraceLevel.Verbose, "Restarting parsing from first entry in list");
i = -1;
count = 0;
continue;
}
}
FtpListItem[] result = new FtpListItem[count];
Array.Copy(files, 0, result, 0, count);
return result;
}
private bool IsMultiLine(FtpParser p) {
return p == FtpParser.VMS;
}
///
/// Parse raw file from server into a file object, using the currently active parser.
///
public FtpListItem ParseSingleLine(string path, string file, FtpCapability caps, bool isMachineList) {
FtpListItem result = null;
// force machine listing if it is
if (isMachineList) {
result = ParseMachineList(file, caps);
} else {
// use custom parser if given
if (m_customParser != null) {
result = m_customParser(file, caps);
} else {
if (IsWrongParser()) {
ValidateParser(new string[] { file });
}
// use one of the in-built parsers
switch (parser) {
case FtpParser.Legacy:
result = ParseLegacy(path, file, caps);
break;
case FtpParser.Machine:
result = ParseMachineList(file, caps);
break;
case FtpParser.Windows:
result = ParseWindows(file);
break;
case FtpParser.Unix:
result = ParseUnix(file);
break;
case FtpParser.UnixAlt:
result = ParseUnixAlt(file);
break;
case FtpParser.VMS:
result = ParseVMS(file);
break;
case FtpParser.IBM:
result = ParseIBM(file);
break;
case FtpParser.NonStop:
result = ParseNonstop(file);
break;
}
}
}
// if parsed file successfully
if (result != null) {
// apply time difference between server/client
if (hasTimeOffset) {
result.Modified = result.Modified - timeOffset;
}
// calc absolute file paths
CalcFullPaths(result, path, false);
}
return result;
}
///
/// Validate if the current parser is correct, or if another parser seems more appropriate.
///
private void ValidateParser(string[] files) {
if (IsWrongParser()) {
// by default use the UNIX parser, if none detected
if (detectedParser == FtpParser.Auto) {
detectedParser = FtpParser.Unix;
}
if (parser == FtpParser.Auto) {
parser = detectedParser;
}
// if machine listings not supported, switch to UNIX parser
if (IsWrongMachineListing()) {
parser = detectedParser;
}
// use the initially set parser (from SYST)
if (IsParserValid(parser, files)) {
FtpTrace.WriteStatus(FtpTraceLevel.Verbose, "Confirmed format " + parser.ToString());
parserConfirmed = true;
return;
}
foreach (FtpParser p in parsers) {
if (IsParserValid(p, files)) {
parser = p;
FtpTrace.WriteStatus(FtpTraceLevel.Verbose, "Detected format " + parser.ToString());
parserConfirmed = true;
return;
}
}
parser = FtpParser.Unix;
FtpTrace.WriteStatus(FtpTraceLevel.Verbose, "Could not detect format. Using default " + parser.ToString());
}
}
private bool IsWrongParser() {
return parser == FtpParser.Auto || !parserConfirmed || IsWrongMachineListing();
}
private bool IsWrongMachineListing() {
return parser == FtpParser.Machine && client != null && !client.HasFeature(FtpCapability.MLSD);
}
///
/// Validate if the current parser is correct
///
private bool IsParserValid(FtpParser p, string[] files) {
switch (p) {
case FtpParser.Windows:
return IsWindowsValid(files);
case FtpParser.Unix:
return IsUnixValid(files);
case FtpParser.VMS:
return IsVMSValid(files);
case FtpParser.IBM:
return IsIBMValid(files);
case FtpParser.NonStop:
return IsNonstopValid(files);
}
return false;
}
#endregion
#region Legacy Parsers
///
/// Parses a line from a file listing using the first successful match in the Parsers collection.
///
/// The source path of the file listing
/// A line from the file listing
/// Server capabilities
/// A FtpListItem object representing the parsed line, null if the line was
/// unable to be parsed. If you have encountered an unsupported list type add a parser
/// to the public static Parsers collection of FtpListItem.
private static FtpListItem ParseLegacy(string path, string buf, FtpCapability capabilities) {
if (!string.IsNullOrEmpty(buf)) {
FtpListItem item;
foreach (Parser parser in Parsers) {
if ((item = parser(buf, capabilities)) != null) {
item.Input = buf;
return item;
}
}
}
return null;
}
///
/// Used for synchronizing access to the Parsers collection
///
private static Object m_parserLock = new Object();
///
/// Initializes the default list of parsers
///
private static void InitParsers() {
lock (m_parserLock) {
if (m_parsers == null) {
m_parsers = new List();
m_parsers.Add(new Parser(ParseMachineList));
m_parsers.Add(new Parser(ParseUnixList));
m_parsers.Add(new Parser(ParseDosList));
m_parsers.Add(new Parser(ParseVMSList));
}
}
}
private static List m_parsers = null;
///
/// Collection of parsers. Each parser object contains
/// a regex string that uses named groups, i.e., (?<group_name>foobar).
/// The support group names are modify for last write time, size for the
/// size and name for the name of the file system object. Each group name is
/// optional, if they are present then those values are retrieved from a
/// successful match. In addition, each parser contains a Type property
/// which gets set in the FtpListItem object to distinguish between different
/// types of objects.
///
private static Parser[] Parsers {
get {
Parser[] parsers;
lock (m_parserLock) {
if (m_parsers == null)
InitParsers();
parsers = m_parsers.ToArray();
}
return parsers;
}
}
private static Parser m_customParser;
///
/// Adds a custom parser
///
/// The parser delegate to add
///