C#

1. Can anyone shed some light on SCP?
2. Any reason not to use FTP assuming I encrypt the files before transfer?

HttpWebRequest http = WebRequest.Create(LoginURL) as HttpWebRequest;
http.KeepAlive = true;
http.Method = "POST";
http.ContentType = "application/x-www-form-urlencoded";
//http.CookieContainer = AuthCookies;
string postData = "languageCode=&reqType=&j_username=myuser&j_password=mypass&sign-in.x=29&sign-in.y=7";
byte[] dataBytes = UTF8Encoding.UTF8.GetBytes(postData);
http.ContentLength = postData.Length;

using (Stream postStream = http.GetRequestStream())
{
    postStream.Write(dataBytes, 0, dataBytes.Length);
}

HttpWebResponse httpResponse = http.GetResponse() as HttpWebResponse;
//foreach (Cookie ck in httpResponse.Cookies)
//{
//  AuthCookies.Add(ck);
//}
using (Stream respStream = httpResponse.GetResponseStream())
{
    StreamReader reader = new StreamReader(respStream, Encoding.UTF8);
    File.WriteAllText("loginresp.html", reader.ReadToEnd());
    reader.Close();
}

//DOB Verify
httpResponse.Close();
HttpWebRequest http2 = WebRequest.Create(DOBVerifyURL) as HttpWebRequest;
http2.KeepAlive = true;
http2.Method = "POST";
http2.ContentType = "application/x-www-form-urlencoded";
//http2.CookieContainer = AuthCookies;
http2.Headers["Cookie"] = httpResponse.Headers["Set-Cookie"];
http2.Referer = LoginURL;
http2.UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.103 Safari/537.36";
postData = "reqType=&cmd=checkSecu&languageCode=&additionalHolderAuthValue=urlencodeddob&continue.x=86&continue.y=13";
dataBytes = UTF8Encoding.UTF8.GetBytes(postData);
http2.ContentLength = postData.Length;
using (Stream postStream = http2.GetRequestStream())
{
    postStream.Write(dataBytes, 0, dataBytes.Length);
}
HttpWebResponse httpResponse2 = http2.GetResponse() as HttpWebResponse;
//foreach (Cookie ck in httpResponse2.Cookies)
//{
//  AuthCookies.Add(ck);
//}
using (Stream respStream2 = httpResponse2.GetResponseStream())
{
    HttpWebRequest http3 = WebRequest.Create(AcctActivityURL) as HttpWebRequest;
    http3.KeepAlive = true;
    http3.ContentType = "text/html";
    //http3.CookieContainer = AuthCookies;
    http3.Headers["Cookie"] = httpResponse2.Headers["Set-Cookie"];
    http3.Referer = LoginURL;
    http3.UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.103 Safari/537.36";
    http3.AllowAutoRedirect = false;
    HttpWebResponse httpResponse3 = http3.GetResponse() as HttpWebResponse;
    using (Stream respStream3 = httpResponse3.GetResponseStream())
    {
        StreamReader reader = new StreamReader(respStream3, Encoding.UTF8);
        File.WriteAllText("dobresp.html", reader.ReadToEnd());
        reader.Close();
    }
}

public static class OldHaspCommunication
 {
    private static SerialPort m_port;
    private static string m_portName;
    private static bool m_isOpen = false;

    private static int m_baudRate;
    private static Parity m_parity;
    private static int m_dataBits;
    private static StopBits m_stopBits;
    private static bool m_xonxoff;
    private static bool m_dtr;
    private static bool m_rts;

    // ................................

    // Open port.
    public static void OpenPort(string portName,
                                int baudRate,
                                Parity parity,
                                int dataBits,
                                StopBits stopBits,
                                bool dtr,
                                bool rts,
                                bool xonxoff = false)
    {

        // Create new Serial Port object
        m_port = new SerialPort(portName, baudRate, parity, dataBits, stopBits);

        // .........................................
        // Set class member variables.

        m_portName = portName;
        m_baudRate = baudRate;
        m_parity = parity;
        m_dataBits = dataBits;
        m_stopBits = stopBits;
        m_xonxoff = xonxoff;
        m_dtr = dtr;
        m_rts = rts;

        // ............................................
        // Initialize some port object properties

        // XOnXOff - parameter
        if (xonxoff)
            m_port.Handshake = Handshake.XOnXOff;

        // Set DTR/RTS
        m_port.DtrEnable = dtr;
        m_port.RtsEnable = rts;

        // Set
        m_port.ReadTimeout = 500;
        m_port.WriteTimeout = 500;

        // ..............................................
        // Some final steps.

        // Open the port for communications
        m_port.Open();

        // If we get this far, mark port as opened.
        m_isOpen = true;
    }

    /// <summary>
    /// Just makes sure to read the specified number of bytes from the serial port.
    /// Typical reads may return fewer bytes then told to read. This method is used
    /// to avoid this problem.
    /// Based on a similar function from Jon Skeet: http://jonskeet.uk/csharp/readbinary.html
    /// </summary>
    /// <param name="data"> [OUT] Data read should be stored here</param>
    /// <param name="length"> [IN] How much data to read exactly </param>
    /// <param name="count"> [IN] Some kind of retry count parameter.</param>
    private static void ReadAll(byte[] data, uint length, int retryCount)
    {

        // Check data length parameter.
        if (length > data.Length)
        {
            throw new Exception("Wrong data length in ReadAll");
        }

        int offset = 0;
        int i = 0;
        int remaining = checked((int)length); // NOTE: Will throw OverflowException if length > Int32.MaxValue due to checked keyword.

        // Start reading.
        while (remaining > 0)
        {
            // Just a retry count check
            if (i >= retryCount)
            {
                throw new Exception("Exceeded retry count parameter during reading in ReadAll");
            }

            // Read Certain amount of bytes
            int read = m_port.Read(data, offset, remaining);

            // Was there error?
            if (read <= 0)
            {
                throw new EndOfStreamException(String.Format("ReadAll(OldHaspCommunication) - End of data reached with {0} bytes left to read", remaining));
            }

            // Advance offset, and decrease remaining count.
            remaining -= read;
            offset += read;

            i++;

        }


    }

    /// <summary>
    /// Write specified number of bytes to the serial port
    /// </summary>
    /// <param name="data"> [IN] Buffer from which to write data</param>
    /// <param name="length"> [IN] How many bytes to write</param>
    private static void WriteAll(byte[] data, uint length)
    {
        // TODO: Maybe we should add a retry count as in C++

        int len = checked((int)length); // NOTE: Will throw OverflowException if length > Int32.MaxValue due to checked keyword.

        // We can't write more data to serial port than available in the array.
        if (len > data.Length)
        {
            throw new Exception("Wrong data length in WriteAll");
        }

        // Do the write.
        m_port.Write(data, 0, len);
    }





    /// <summary>
    /// Close the serial port.
    /// NOTE: Don't forget to call this one.
    /// </summary>
    public static void ClosePort()
    {
        if (m_isOpen)
        {
            Reset(); // Calls our custom Reset function.
            m_port.Close(); // Close port
            m_isOpen = false; // Mark this object as closed.
        }
    }

    // ...
    private static void Reset()
    {
        m_port.DiscardInBuffer();
        m_port.DiscardOutBuffer();
    }


}