//
// savdicl.cs
//
// Simple demo to illustrate some features of SSSP
// Scans a file or dir using a given TCP/IP port
//
// To build:
//   Open savdicli.sln or savdicli.csproj in Microsoft Visual Studio 2005
//   and choose the menu option: Build | Build Solution. The binary
//   savdicli.exe will be output to .\bin\Release.
//
// Copyright (c) 2007 Sophos Plc, www.sophos.com.
//
using System;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Net.Sockets;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.Diagnostics;
namespace SAVDICLI
{
    /// <summary>
    /// Utility class that provides some global functionality. 
    /// </summary>
    public class Utility
    {
        /// <summary>
        /// Regex that picks out any non-alphanumeric characters.
        /// </summary>
        private static Regex m_toencPattern = new Regex("([^0-9a-zA-Z])");
        /// <summary>
        /// Regex that picks out any encoded URL escape sequences ('%' followed
        /// by 2 hexadecimal digits).
        /// </summary>
        private static Regex m_encPattern = new Regex("%([0-9a-fA-F]{2})");
        /// <summary>
        /// A delegate used to replace characters in a string being URL-encoded.
        /// </summary>
        /// <param name="match">The Match object passed in</param>
        /// <returns>The replacement string</returns>
        private static string UrlEncodeMatchEvaluator(Match match)
        {
            return string.Format("%{0:X2}", Convert.ToByte(match.Groups[1].Value[0]));
        }
        /// <summary>
        /// This method encodes a string by replacing any non-alphanumeric
        /// characters with an escape sequence ('%' followed by 2 hexadecimal digits).
        /// </summary>
        /// <param name="s">The string to be encoded</param>
        /// <returns>The encoded string</returns>
        public static string UrlEncode(string s)
        {
            return m_toencPattern.Replace(s, UrlEncodeMatchEvaluator);
        }
        /// <summary>
        /// A delegate used to replace escape sequences in a URL-encoded string with
        /// corresponding characters.
        /// </summary>
        /// <param name="match">The match object passed in</param>
        /// <returns>The replacement string</returns>
        private static string UrlDecodeMatchEvaluator(Match match)
        {
            return "" + long.Parse(match.Groups[1].Value, NumberStyles.HexNumber);
        }
        /// <summary>
        /// This method decodes an encoded string by replacing any escape sequences
        /// with corresponding non-alphanumeric characters.
        /// </summary>
        /// <param name="s">The string to be decoded</param>
        /// <returns>The decoded string</returns>
        public static string UrlDecode(string s)
        {
            return m_encPattern.Replace(s, UrlDecodeMatchEvaluator);
        }
    }
    /// <summary>
    /// This class provides methods to connect to a SAVDI server instance
    /// and send and receive data.
    /// </summary>
    public class Session
    {
        /// <summary>
        /// The hostname of the server to connect to.
        /// </summary>
        string m_hostname;
        /// <summary>
        /// The port on which to connect to the server.
        /// </summary>
        uint m_port;
        /// <summary>
        /// Flag that indicates if a TCP connection has been established with the server.
        /// </summary>
        bool m_connected;
        /// <summary>
        /// Flag that indicates if the TCP session is active.
        /// </summary>
        bool m_active;
        /// <summary>
        /// The TcpClient object that provides the TCP connection.
        /// </summary>
        TcpClient m_tcpcli = new TcpClient();
        /// <summary>
        /// Flag that controls the amount of debugging information printed out.
        /// </summary>
        bool m_debug = true;
        /// <summary>
        /// A delegate that is used to send individual lines received from the server
        /// on to the caller as soon as they are received.
        /// </summary>
        /// <param name="line">The line received from the server</param>
        public delegate void RecvMessageProgress(string line);
        /// <summary>
        /// A property that can be used to externally control the level of debugging 
        /// information printed out by the Session.
        /// </summary>
        public bool DebugSocketComms
        {
            get { return m_debug; }
            set { m_debug = value; }
        }
        /// <summary>
        /// This read-only property tells the caller how large a chunk should be when 
        /// using SCANDATA to send the contents of a file to the server. Currently
        /// hardcoded to 4096 bytes.
        /// </summary>
        public int RecommendedChunkSize
        {
            get { return 4096; }
        }
        /// <summary>
        /// A property that indicates if a TCP connection to the server has been established.
        /// </summary>
        public bool Connected
        {
            get { return m_connected; }
            set { m_connected = value; }
        }
        /// <summary>
        /// A property that indicates if a TCP session is active.
        /// </summary>
        public bool Active
        {
            get { return m_active; }
            set { m_active = value; }
        }
        /// <summary>
        /// Constructor for a Session object.
        /// </summary>
        /// <param name="hostname">The hostname of the server</param>
        /// <param name="port">The port on which to connect to the server</param>
        public Session(string hostname, uint port)
        {
            m_hostname = hostname;
            m_port = port;
            Connected = false;
            Active = false;
        }
        /// <summary>
        /// Sends bytes to the server.
        /// </summary>
        /// <param name="numbytes">Number of bytes to send</param>
        /// <param name="data">The bytes to send</param>
        /// <returns>The actual number of bytes sent</returns>
        public int Send(int numbytes, byte[] data)
        {
            int sent = 0;
            if (numbytes > 0)
            {
                m_tcpcli.GetStream().Write(data, 0, numbytes);
                sent = numbytes;
            }
            return sent;
        }
        /// <summary>
        /// Receives bytes from the server.
        /// </summary>
        /// <param name="numbytes">The number of bytes to receive</param>
        /// <param name="data">The destination buffer for the bytes</param>
        /// <returns>The actual number of bytes received</returns>
        public int Recv(int numbytes, out byte[] data)
        {
            int read = 0;
            data = new byte[numbytes];
            data.Initialize();
            if (numbytes > 0)
            {
                read = m_tcpcli.GetStream().Read(data, 0, numbytes);
            }
            return read;
        }
        /// <summary>
        /// Sends a line to the server.
        /// </summary>
        /// <param name="line">The line to send</param>
        /// <returns>Indicates whether the send was successful</returns>
        public bool SendLine(string line)
        {
            ASCIIEncoding asciienc = new ASCIIEncoding();
            byte[] data = asciienc.GetBytes(line + "\n");
            int numsent = Send(data.Length, data);
            if (DebugSocketComms)
                Console.WriteLine("Sent: " + line);
            return numsent == data.Length;
        }
        /// <summary>
        /// Receives a line from the server.
        /// </summary>
        /// <param name="line">A variable to collect the line</param>
        /// <returns>Indicates whether the receipt was successful</returns>
        public bool RecvLine(out string line)
        {
            bool done = false;
            line = "";
            while (!done)
            {
                // Receive only one byte at a time and append to the string
                byte[] data = new byte[1];
                if (1 != Recv(1, out data))
                {
                    throw new Exception("Error receiving data from server");
                }
                if (data[0] == '\r')
                    continue;
                else if (data[0] == '\n')
                    done = true;
                else
                    line += Convert.ToChar(data[0]);
            }
            if (DebugSocketComms)
                Console.WriteLine("Recv: " + line);
            return true;
        }
        /// <summary>
        /// Receives a message from the server. A message consists of a set of
        /// zero or more lines, terminated by a blank line.
        /// </summary>
        /// <param name="lines">A container to collect the message</param>
        /// <returns>Indicates whether the receipt was successful</returns>
        public bool RecvMessage(out string[] lines)
        {
            // Forward to the actual implementation
            return RecvMessage(out lines, null);
        }
        /// <summary>
        /// Receives a message from the server. A message consists of a set of
        /// zero or more lines, terminated by a blank line.
        /// </summary>
        /// <param name="lines">A container to collect the message</param>
        /// <param name="callback">A callback (RecvMessageProgress delegate instance) to get individual message lines</param>
        /// <returns>Indicates whether the receipt was successful</returns>
        public bool RecvMessage(out string[] lines, RecvMessageProgress callback)
        {
            ArrayList lineslist = new ArrayList();
            while (true)
            {
                string line = "";
                if (!RecvLine(out line) || (line.Length == 0))
                {
                    break;
                }
                lineslist.Add(line);
                if (callback != null)
                {
                    callback(line);
                }
            }
            lines = new string[lineslist.Count];
            IEnumerator enumerator = lineslist.GetEnumerator();
            int pos = 0;
            while (enumerator.MoveNext())
            {
                lines.SetValue(enumerator.Current, pos);
                pos++;
            }
            // If we got even one line, it's been a success
            return lines.Length > 0;
        }
        /// <summary>
        /// Connects to the server if not already connected and performs
        /// a handshake.
        /// </summary>
        public void Connect()
        {
            if (Connected)
                return;
            m_tcpcli.Connect(m_hostname, (int)m_port);
            string line = "";
            if (RecvLine(out line))
            {
                if (line.StartsWith("OK SSSP/1.0"))
                {
                    Connected = true;
                }
            }
            if (!Connected)
            {
                throw new Exception("Server failed to initiate handshake");
            }
            line = "SSSP/1.0";
            SendLine(line);
            if (RecvLine(out line))
            {
                if (line.StartsWith("ACC "))
                {
                    Active = true;
                }
                else if (line.StartsWith("REJ "))
                {
                    throw new Exception("The server rejected the connection request");
                }
                else
                {
                    throw new Exception("Unexpected response from server: " + line);
                }
            }
        }
        /// <summary>
        /// Disconnects from the server if not already disconnected, but performs
        /// a goodbye handshake first.
        /// </summary>
        public void Disconnect()
        {
            if (Active)
            {
                SendLine("BYE");
                string line;
                RecvLine(out line);
                Active = false;
            }
            if (Connected)
            {
                m_tcpcli.Close();
                Connected = false;
            }
        }
    }
    /// <summary>
    /// A helper class that encapsulates various SAVDI server options available
    /// to the client. Objects of this class are initialised with a dictionary 
    /// containing option name strings as keys, mapped to lists of string values. 
    /// </summary>
    public class Options
    {
        private string m_version = "";
        private bool m_queryServerAllowed = false;
        private bool m_querySAVIAllowed = false;
        private bool m_queryEngineAllowed = false;
        private bool m_queryOptionsAllowed = false;
        private bool m_scanDataAllowed = false;
        private bool m_scanFileAllowed = false;
        private bool m_scanDirAllowed = false;
        private bool m_scanDirRecursiveAllowed = false;
        private long m_maxScanData = 0;
        private long m_maxMemorySize = 0;
        private long m_maxClassificationSize = 0;
        private Dictionary<string, List<string>> m_options = null;
        /// <summary>
        /// This property holds the version string returned by the server.
        /// </summary>
        public string Version
        {
            get { return m_version; }
            set { m_version = value; }
        }
        /// <summary>
        /// This property indicates if the "QUERY SERVER" SSSP command is allowed.
        /// </summary>
        public bool QueryServerAllowed
        {
            get { return m_queryServerAllowed; }
            set { m_queryServerAllowed = value; }
        }
        /// <summary>
        /// This property indicates if the "QUERY SAVI" SSSP command is allowed.
        /// </summary>
        public bool QuerySAVIAllowed
        {
            get { return m_querySAVIAllowed; }
            set { m_querySAVIAllowed = value; }
        }
        /// <summary>
        /// This property indicates if the "QUERY ENGINE" SSSP command is allowed.
        /// </summary>
        public bool QueryEngineAllowed
        {
            get { return m_queryEngineAllowed; }
            set { m_queryEngineAllowed = value; }
        }
        /// <summary>
        /// This property indicates if the "QUERY OPTIONS" SSSP command is allowed.
        /// </summary>
        public bool QueryOptionsAllowed
        {
            get { return m_queryOptionsAllowed; }
            set { m_queryOptionsAllowed = value; }
        }
        /// <summary>
        /// This property indicates if the "SCANDATA" SSSP command is allowed.
        /// </summary>
        public bool ScanDataAllowed
        {
            get { return m_scanDataAllowed; }
            set { m_scanDataAllowed = value; }
        }
        /// <summary>
        /// This property indicates if the "SCANFILE" SSSP command is allowed.
        /// </summary>
        public bool ScanFileAllowed
        {
            get { return m_scanFileAllowed; }
            set { m_scanFileAllowed = value; }
        }
        /// <summary>
        /// This property indicates if the "SCANDIR" SSSP command is allowed.
        /// </summary>
        public bool ScanDirAllowed
        {
            get { return m_scanDirAllowed; }
            set { m_scanDirAllowed = value; }
        }
        /// <summary>
        /// This property indicates if the "SCANDIRR" SSSP command is allowed.
        /// </summary>
        public bool ScanDirRecursiveAllowed
        {
            get { return m_scanDirRecursiveAllowed; }
            set { m_scanDirRecursiveAllowed = value; }
        }
        /// <summary>
        /// This property indicates the maximum amount of data that the server will accept
        /// for a "SCANDATA" request. Zero means it is unlimited.
        /// </summary>
        public long MaxScanData
        {
            get { return m_maxScanData; }
            set { m_maxScanData = value; }
        }
        /// <summary>
        /// This property indicates the maximum amount of data the server will hold in memory
        /// before using a temporary file when implementing a "SCANDATA" request.
        /// </summary>
        public long MaxMemorySize
        {
            get { return m_maxMemorySize; }
            set { m_maxMemorySize = value; }
        }
        /// <summary>
        /// This property indicates the maximum amount of data from the start of a file that
        /// the client needs to send in a "SCANDATA" request when requesting classification only.
        /// </summary>
        public long MaxClassificationSize
        {
            get { return m_maxClassificationSize; }
            set { m_maxClassificationSize = value; }
        }
        /// <summary>
        /// Property that gives read-only raw data access to the options dictionary.
        /// </summary>
        public Dictionary<string, List<string>> RawOptions
        {
            get { return m_options; }
        }
        /// <summary>
        /// Contructor for Options object.
        /// </summary>
        /// <param name="options">A dictionary mapping an option name to a list of option values</param>
        public Options(ref Dictionary<string, List<string>> options)
        {
            m_options = new Dictionary<string, List<string>>();
            foreach (string key in options.Keys)
            {
                m_options[key] = new List<string>();
                List<string> valuelist = options[key];
                m_options[key].AddRange(valuelist);
                switch (key)
                {
                    case "version":
                        Version = valuelist[0]; break;
                    case "method":
                        foreach (string value in valuelist)
                        {
                            switch (value)
                            {
                                case "QUERY SERVER":
                                    QueryServerAllowed = true; break;
                                case "QUERY SAVI":
                                    QuerySAVIAllowed = true; break;
                                case "QUERY ENGINE":
                                    QueryEngineAllowed = true; break;
                                case "OPTIONS":
                                    QueryOptionsAllowed = true; break;
                                case "SCANDATA":
                                    ScanDataAllowed = true; break;
                                case "SCANFILE":
                                    ScanFileAllowed = true; break;
                                case "SCANDIR":
                                    ScanDirAllowed = true; break;
                                case "SCANDIRR":
                                    ScanDirRecursiveAllowed = true; break;
                                default:
                                    break;
                            }
                        }
                        break;
                    case "maxscandata":
                        MaxScanData = Convert.ToInt64(valuelist[0]); break;
                    case "maxmemorysize":
                        MaxMemorySize = Convert.ToInt64(valuelist[0]); break;
                    case "maxclassificationsize":
                        MaxClassificationSize = Convert.ToInt64(valuelist[0]); break;
                    default:
                        break;
                }
            }
        }
    }
    /// <summary>
    /// A class that provides an API to query options available to interact
    /// with a SAVDI server, to set certain options and to request the server to 
    /// scan files or directories with or without progress information.
    /// </summary>
    public class Client
    {
        /// <summary>
        /// The Session object held by the Client.
        /// </summary>
        private Session m_session = null;
        /// <summary>
        /// The Options object held by the Client.
        /// </summary>
        private Options m_options = null;
        /// <summary>
        /// Regex pattern to match ACC status lines returned by the server.
        /// </summary>
        private Regex m_accPattern = new Regex(@"^ACC\s+(.*?)\s*$");
        /// <summary>
        /// Regex pattern used to scan for lines of "key: value" 
        /// lines returned by the server when the Client object queries it for supported options.
        /// </summary>
        private Regex m_optionPattern = new Regex(@"^(\w+):\s*(.*?)\s*$");
        /// <summary>
        /// Regex pattern that matches a threat detected message.
        /// returned by the server
        /// </summary>
        private Regex m_virusPattern = new Regex(@"^VIRUS\s+(\S+)\s+(.*)");
        /// <summary>
        /// Regex pattern that matches a file type indicator message
        /// returned by the server in response to a "classification" request.
        /// </summary>
        private Regex m_typePattern = new Regex(@"^TYPE\s+(\S+)\s+(.+)$");
        /// <summary>
        /// Regex pattern that matches a "file location" message
        /// returned by the server in response to a "classification" request.
        /// </summary>
        private Regex m_filePattern = new Regex(@"^FILE\s+(.+)$");
        /// <summary>
        /// Regex pattern that matches DONE status lines returned by the server.
        /// </summary>
        private Regex m_donePattern = new Regex(@"^DONE\s+(\S+)\s+(\S+)\s+(.+)$");
        /// <summary>
        /// Regex pattern that matches OK status lines returned by the server after
        /// a scan has been successfully completed.
        /// </summary>
        private Regex m_okPattern = new Regex(@"^OK\s+(.+)$");
        /// <summary>
        /// Regex pattern that matches FAIL status lines returned by the server.
        /// </summary>
        private Regex m_failPattern = new Regex(@"^FAIL\s+(\S+)\s+(.+)$");
        /// <summary>
        /// Regex pattern that matches lines returned by the server in case of an event.
        /// </summary>
        private Regex m_eventPattern = new Regex(@"^EVENT\s+(FILE|DIR|ARCHIVE|ERROR|VIRUS)\s+(.+)$");
        /// <summary>
        /// A delegate that is implemented as a callback by users of the Session object 
        /// to receive progress information during a scan. Use of the delegate is optional, 
        /// i.e., it is possible to request scans without specifying a callback.
        /// </summary>
        /// <param name="eventname">The name of the event that has occurred</param>
        /// <param name="eventdata">String data associated with the event</param>
        public delegate void ScanProgressMonitor(string eventname, string eventdata);
        /// <summary>
        /// A cached copy of a callback based on the ScanProgressMonitor delegate that may have
        /// been passed in by a user of the Session object.
        /// </summary>
        private ScanProgressMonitor m_scanprogcallback = null;
        /// <summary>
        /// Constructor for Client object.
        /// </summary>
        /// <param name="hostname">The hostname of the server</param>
        /// <param name="port">The port on which to connect to the server</param>
        public Client(string hostname, uint port)
        {
            m_session = new Session(hostname, port);
            m_session.Connect();
            QueryOptions();
        }
        /// <summary>
        /// A method called explicitly to disconnect cleanly from the server.
        /// </summary>
        public void Disconnect()
        {
            if (m_session != null)
                m_session.Disconnect();
        }
        /// <summary>
        /// Method that queries the server for supported options and intialises the
        /// Options member object.
        /// </summary>
        private void QueryOptions()
        {
            m_session.SendLine("QUERY SERVER");
            string[] lines;
            if (!m_session.RecvMessage(out lines))
            {
                throw new Exception("Unexpected response from server");
            }
            Dictionary<string, List<string>> opts = new Dictionary<string, List<string>>();
            foreach (string line in lines)
            {
                Match match = m_optionPattern.Match(line);
                if (match.Success && match.Groups.Count == 3)
                {
                    string key = match.Groups[1].Value;
                    string value = match.Groups[2].Value;
                    if (!opts.ContainsKey(key))
                    {
                        opts[key] = new List<string>();
                    }
                    opts[key].Add(value);
                }
            }
            m_options = new Options(ref opts);
        }
        /// <summary>
        /// A read-only property that returns the Options object.
        /// </summary>
        public Options Options
        {
            get { return m_options; }
        }
        /// <summary>
        /// Sets options on the server. 
        /// </summary>
        /// <param name="options">A Dictionary object mapping string option 
        /// names to lists of string option values. </param>
        public void SetOptions(ref Dictionary<string, List<string>> options)
        {
            m_session.SendLine("OPTIONS");
            foreach (string optionname in options.Keys)
            {
                foreach (string optionvalue in options[optionname])
                {
                    m_session.SendLine(optionname + ":" + optionvalue);
                }
            }
            m_session.SendLine("");
            string line = "";
            m_session.RecvLine(out line);
            string[] lines;
            m_session.RecvMessage(out lines); // Message discarded on success
            if (!m_accPattern.Match(line).Success)
            {
                throw new Exception("The server rejected the OPTIONS request. Details:" + String.Join("\n", lines));
            }
        }
        /// <summary>
        /// Sets a single option on the server.
        /// </summary>
        /// <param name="optionname">An option to set on the server</param>
        /// <param name="optionvalue">The value to set the option to</param>
        public void SetOption(string optionname, string optionvalue)
        {
            // Construct a dictionary, add the option name and value to it
            // and forward to the actual implementation
            Dictionary<string, List<string>> options = new Dictionary<string, List<string>>();
            options[optionname] = new List<string>();
            options[optionname].Add(optionvalue);
            SetOptions(ref options);
        }
        /// <summary>
        /// A Session.RecvMessageProgress delegate instance that is called by
        /// by the m_session Session object, once per line, when receiving a long message.
        /// </summary>
        /// <param name="line">A line of text sent back by the Session object</param>
        private void HandleScanResponse(string line)
        {
            Match match = m_eventPattern.Match(line);
            if (match.Success)
            {
                if (m_scanprogcallback != null)
                {
                    // The cached callback is interested only in events, so we won't 
                    // forward every line received from the Sesion object
                    m_scanprogcallback(match.Groups[1].Value, match.Groups[2].Value);
                }
            }
            else
            {
                match = m_okPattern.Match(line);
                if (match.Success)
                {
                    Console.WriteLine("Handled: " + line);
                }
                else
                {
                    match = m_donePattern.Match(line);
                    if (match.Success)
                    {
                        Console.WriteLine("Handled: " + line);
                    }
                    else
                    {
                        match = m_failPattern.Match(line);
                        if (match.Success)
                        {
                            Console.WriteLine("Handled: " + line);
                        }
                        else
                        {
                            Console.WriteLine("NOT handled: " + line);
                            // Other possible matches: (Included here
                            // only for completeness!)
                            m_virusPattern.Match(line);
                            m_typePattern.Match(line);
                            m_filePattern.Match(line);
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Method that requests the server to scan a file or a directory.
        /// </summary>
        /// <param name="filepath">Path to a file or directory</param>
        /// <param name="request">The actual name of the request command to send to the server</param>
        /// <param name="callback">A callback (ScanProgressMonitor delegate instance) to monitor the scan progress</param>
        private void ScanPath(string filepath, string request, ScanProgressMonitor callback)
        {
            if (callback != null)
            {
                m_scanprogcallback = callback;
            }
            string line = "";
            string pathtosend = Utility.UrlEncode(filepath);
            // Note that SCANDIR and SCANDIRR will also scan valid file paths, 
            // not just directories
            Debug.Assert(request == "SCANFILE" || request == "SCANDIR" || request == "SCANDIRR");
            line = request + " " + pathtosend;
            m_session.SendLine(line);
            m_session.RecvLine(out line);
            if (!m_accPattern.IsMatch(line))
            {
                throw new Exception("The server rejected the " + request + " request");
           }
            string[] lines;
            // Briefly disable the printing out of socket communication by the Session object
            //
            m_session.DebugSocketComms = false;
            // Handle the message in a separate callback function
            //
            Session.RecvMessageProgress recvmsgcallback = new Session.RecvMessageProgress(HandleScanResponse);
            m_session.RecvMessage(out lines, recvmsgcallback);
            m_session.DebugSocketComms = true;
        }
        /// <summary>
        /// Public method to scan a file. Differs from ScanFile as it sends the entire 
        /// contents of the file to the server, instead of just sending the file path.
        /// </summary>
        /// <param name="filepath">Path to a file</param>
        public void ScanData(string filepath)
        {
            ScanData(filepath, null);
        }
        /// <summary>
        /// Public method to scan a file. Differs from ScanFile as it sends the entire 
        /// contents of the file to the server, instead of just sending the file path.
        /// </summary>
        /// <param name="filepath">Path to a file</param>
        /// <param name="callback">A callback function to monitor scan progress</param>
        public void ScanData(string filepath, ScanProgressMonitor callback)
        {
            FileInfo fileinfo = new FileInfo(filepath);
            if (fileinfo.Length >= Options.MaxScanData)
            {
                throw new Exception("File too large to send to server");
            }
            FileStream filestream = new FileStream(filepath, FileMode.Open);
            BinaryReader filereader = new BinaryReader(filestream);
            string line = "SCANDATA " + fileinfo.Length;
            m_session.SendLine(line);
            int CHUNKSIZE = m_session.RecommendedChunkSize;
            for (int numchunks = 0; numchunks < fileinfo.Length / CHUNKSIZE; numchunks++)
            {
                m_session.Send(CHUNKSIZE, filereader.ReadBytes(CHUNKSIZE));
            }
            int lastchunksize = (int)(fileinfo.Length % CHUNKSIZE);
            m_session.Send(lastchunksize, filereader.ReadBytes(lastchunksize));
            filereader.Close();
            filestream.Close();
            Console.WriteLine("Sent " + fileinfo.Length + " bytes in " + (fileinfo.Length / CHUNKSIZE + 1) + " chunk(s) of max size " + CHUNKSIZE + " bytes");
            line = "";
            m_session.RecvLine(out line);
            if (!m_accPattern.Match(line).Success)
            {
                throw new Exception("The server rejected the SCANDATA request");
            }
            string[] lines;
           m_session.RecvMessage(out lines);
        }
        /// <summary>
        /// Public method to scan a file.
        /// </summary>
        /// <param name="filepath">Path to a file</param>
        public void ScanFile(string filepath)
        {
            // Forward to the core implementation
            ScanFile(filepath, null);
        }
        /// <summary>
        /// Public method to scan a file.
        /// </summary>
        /// <param name="filepath">Path to a file</param>
        /// <param name="callback">A callback function to monitor scan progress</param>
        public void ScanFile(string filepath, ScanProgressMonitor callback)
        {
            // Forward to the core implementation
            ScanPath(filepath, "SCANFILE", callback);
        }
        /// <summary>
        /// Public method to scan the contents of a directory.
        /// </summary>
        /// <param name="filepath">Path to a directory</param>
        public void ScanDir(string filepath)
        {
            // Forward to the core implementation
            ScanDir(filepath, null);
        }
        /// <summary>
        /// Public method to scan the contents of a directory.
        /// </summary>
        /// <param name="filepath">Path to a directory</param>
        /// <param name="callback">A callback function to monitor scan progress</param>
        public void ScanDir(string filepath, ScanProgressMonitor callback)
        {
            // Forward to the core implementation
            ScanPath(filepath, "SCANDIR", callback);
        }
        /// <summary>
        /// Public method to scan the contents of a directory and all-subdirectories, recursively.
        /// </summary>
        /// <param name="filepath">Path to a directory</param>
        public void ScanDirRecursive(string filepath)
        {
            // Forward to the core implementation
            ScanDirRecursive(filepath, null);
        }
        /// <summary>
        /// Public method to scan the contents of a directory and all-subdirectories, recursively.
        /// </summary>
        /// <param name="filepath">Path to a directory</param>
        /// <param name="callback">A callback function to monitor scan progress</param>
        public void ScanDirRecursive(string filepath, ScanProgressMonitor callback)
        {
            // Forward to the core implementation
            ScanPath(filepath, "SCANDIRR", callback);
        }
    }
    /// <summary>
    /// This class contains the entry point as well as methods to parse the 
    /// command-line parameters passed in and to display the usage/help banner.
    /// </summary>
    public class Program
    {
        /// <summary>
        /// Prints the usage/help banner.
        /// </summary>
        private static void Usage()
        {
            Console.WriteLine("Usage: savdicli.exe [OPTIONS] <file|dir> [<host>] [<port>]                ");
            Console.WriteLine("Options:                                                                  ");
            Console.WriteLine("  -a        : Request the server to scan data from a local <file>         ");
            Console.WriteLine("  -f        : Scan a remote <file> path on the server                     ");
            Console.WriteLine("  -d        : Request the server to scan a remote <dir> (DEFAULT)         ");
            Console.WriteLine("  -r        : Request the server to scan a remote <dir> and all           ");
            Console.WriteLine("              sub-directories recursively                                 ");
            Console.WriteLine(" <file>     : The path to a local or remote file (argument not compatible ");
            Console.WriteLine("              with the -d or -r flags)                                    ");
            Console.WriteLine(" <dir>      : The path to a remote directory on the server (argument not  ");
            Console.WriteLine("              compatible with the -a or -f flags)                         ");
            Console.WriteLine("                                                                          ");
            Console.WriteLine("  -h        : Shows this help message                                     ");
            Console.WriteLine("                                                                          ");
            Console.WriteLine("Notes:                                                                    ");
            Console.WriteLine(" 1) This program sends the contents of a file or the path to a file or a  ");
            Console.WriteLine("    directory to a local or remote instance of the SAV Dynamic Interface  ");
            Console.WriteLine("    server. The item is scanned via SSSP (Sophos Simple Scanning Protol). ");
            Console.WriteLine(" 2) The default <host> is 'localhost', and the default <port> 4010.       ");
            Console.WriteLine(" 3) Only one option must be specified. The default is '-d'.               ");
            Console.WriteLine(" 4) If <dir> happens to be remote file, it will be scanned as a file,     ");
            Console.WriteLine("    i.e., '-f' will be implicitly assumed.                                ");
        }
        /// <summary>
        /// This method scans the list of command-line parameters supplied to it and returns
        /// interesting values to the caller.
        /// </summary>
        /// <param name="args">The list of command-line parameters to scan</param>
        /// <param name="option">The scanning method that will be used by the server</param>
        /// <param name="filepath">The path to the file or directory to be scanned</param>
        /// <param name="hostname">The hostname of the server</param>
        /// <param name="port">The port on which to connect to the server</param>
        private static void ParseArgs(ref string[] args,
                                        out string option,
                                        out string filepath,
                                        out string hostname,
                                        out uint port)
        {
            option = "";
            filepath = "";
            hostname = "localhost";
            port = 4010;
            // Scan the arguments list
            //
            if (args.Length < 1 || args.Length > 4)
            {
                Usage();
                Environment.Exit(2);
            }
            int nextargpos = 0;
            Regex validArgsPattern = new Regex("^-([?ahfdr])$");
            Match match = validArgsPattern.Match(args[0]);
            if (match.Success)
            {
                option = match.Groups[1].Value;
                nextargpos++;
            }
            if (option == "h" || option == "?")
            {
                Usage();
                Environment.Exit(1);
            }
            if (args.Length > nextargpos)
            {
                filepath = args[nextargpos];
                nextargpos++;
            }
            if (args.Length > nextargpos)
            {
                hostname = args[nextargpos];
                nextargpos++;
            }
            if (args.Length > nextargpos)
            {
                try
                {
                    port = Convert.ToUInt32(args[nextargpos]);
                }
                catch (Exception)
                {
                    Usage();
                    Environment.Exit(2);
                }
            }
            // Check that we have all the arguments we need
            if (filepath.Length == 0 || hostname.Length == 0 || port == 0)
            {
                Usage();
                Environment.Exit(2);
            }
        }
       private static void PrintRecursiveScandirProgress(string eventname, string eventdata)
        {
            Console.WriteLine("(Callback) Event: " + eventname + " " + eventdata);
        }
        /// <summary>
        /// Method that performs the core task of connecting to the server, requesting
        /// a scan and disconnecting.
        /// </summary>
        /// <param name="option">The scanning method that will be used by the server</param>
        /// <param name="filepath">The path to the file or directory to be scanned</param>
        /// <param name="hostname">The hostname of the server</param>
        /// <param name="port">The port on which to connect to the server</param>
        private static void RunClient(string option, string filepath, string hostname, uint port)
        {
            // Construct the client 
            Client client = new Client(hostname, port);
            try
            {
                if (option == "d" || option == "") // By default, assume user wants to scan a directory
                {
                    if (client.Options.ScanDirAllowed)
                        client.ScanDir(filepath);
                    else
                        throw new Exception("Scanning of directories is not available on the server");
                }
                else if (option == "r")
                {
                    if (client.Options.ScanDirRecursiveAllowed)
                    {
                        // Demonstration of how to use a callback function to receive scanning events
                        // from the server as they occur. This implementation simply prints out the event.
                        Client.ScanProgressMonitor callback = new Client.ScanProgressMonitor(PrintRecursiveScandirProgress);
                        // How to switch on detailed reporting using SetOptions. 
                        // In this case the following events will be reported back by the server:
                        //      file : When a file is found
                        //      error: When a file/scanning error is encountered
                        //      virus: When a virus is found
                        //
                        Dictionary<string, List<string>> options = new Dictionary<string, List<string>>();
                        options["report"] = new List<string>();
                        options["report"].Add("file");
                        options["report"].Add("error");
                       options["report"].Add("virus");
                        client.SetOptions(ref options);
                        client.ScanDirRecursive(filepath, callback);
                        // Switch back to the default options for the rest of this session
                        //
                        client.SetOption("savidefault", "");
                    }
                    else
                        throw new Exception("Recursive scanning of directories is not available on the server");
                }
                else if (option == "f")
                {
                    if (client.Options.ScanFileAllowed)
                        client.ScanFile(filepath);
                    else
                        throw new Exception("Scanning of files is disabled on the server");
                }
                else if (option == "a")
                {
                    // Ensure that the file exists
                    //
                    FileInfo fileinfo = new FileInfo(filepath);
                    if (fileinfo.Exists)
                    {
                        if (client.Options.ScanDataAllowed)
                            client.ScanData(Path.GetFullPath(filepath));
                        else
                            throw new Exception("Scanning of data via SSSP is disabled on the server");
                    }
                    else
                    {
                        throw new Exception("File not found: " + filepath);
                    }
                }
            }
            finally
            {
                client.Disconnect();
            }
        }
        /// <summary>
        /// The entry point into the assembly.
        /// </summary>
        /// <param name="args">The list of string objects, one for each command-line parameter</param>
        public static void Main(string[] args)
        {
            string option = "";
            string filepath = "";
            string hostname = "localhost";
            uint port = 4010;
            ParseArgs(ref args, out option, out filepath, out hostname, out port);
            try
            {
                RunClient(option, filepath, hostname, port);
            }
            catch (Exception e)
            {
                Console.WriteLine("FATAL Error: " + e.Message);
                Environment.Exit(1);
            }
            Environment.Exit(0);
        }
    }
}