Fixed mono bug with httplistener

Update to new ThePirateBay URL

README.md

@@ -7,15 +7,30 @@ This software creates a [Torznab](https://github.com/Sonarr/Sonarr/wiki/Implemen
 Currently [Sonarr](https://sonarr.tv/) is the only software that uses Torznab. [Couchpotato](https://couchpota.to/) will hopefully get Torznab support in the future.
 
 ### Download
-Software is still in development, check back in a few days.
+Download in the [Releases page](https://github.com/zone117x/Jackett/releases)
+
+### Supported Systems
+* Works on Windows by default
+* Works on Linux and OS X using Mono. See instructions below...
+
+### Instructions for Mono
+ * Install Mono: http://www.mono-project.com/download/
+ * *For MoreThanTV & ThePirateBay* install libcurl-dev for your system, [tutorial](http://curl.haxx.se/dlwiz/?type=devel)
+   * For apt-get systems its simply: `apt-get install libcurl4-openssl-dev`
+
 
 ### Supported Trackers
  * [BitMeTV](http://www.bitmetv.org/)
  * [MoreThan.tv](https://morethan.tv/)
+ * [BIT-HDTV](https://www.bit-hdtv.com)
  * [Freshon](https://freshon.tv/)
  * [IPTorrents](https://iptorrents.com/)
+ * [TorrentLeech](http://www.torrentleech.org/)
+ * [Strike](https://getstrike.net/)
  * [The Pirate Bay](https://thepiratebay.se/)
  * [RARBG](https://rarbg.com)
+ * [TorrentDay](https://torrentday.eu/)
+ * [TorrentShack](http://torrentshack.me/)
 
 
 ### Additional Trackers
@@ -26,4 +41,4 @@ I can be contact on IRC at [irc.freenode.net#sonarr](http://webchat.freenode.net
 
 ### Screenshots
 
-![screenshot](http://i.imgur.com/8e2QylW.png "screenshot")
+![screenshot](http://i.imgur.com/OX9MKrL.png "screenshot")

src/CurlSharp/Callbacks/CurlEasyCallbacks.cs

@@ -0,0 +1,239 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Called when cURL has debug information for the client.
+    /// </summary>
+    /// <remarks>
+    ///     For usage, see the sample <c>Upload.cs</c>.
+    ///     Arguments passed to the recipient include:
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Argument</term>
+    ///             <description>Description</description>
+    ///         </listheader>
+    ///         <item>
+    ///             <term>infoType</term>
+    ///             <description>
+    ///                 Type of debug information, see
+    ///                 <see cref="CurlInfoType" />.
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <term>message</term>
+    ///             <description>Debug information as a string.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>extraData</term>
+    ///             <description>Client-provided extra data.</description>
+    ///         </item>
+    ///     </list>
+    /// </remarks>
+    public delegate void CurlDebugCallback(CurlInfoType infoType, String message, Object extraData);
+
+    /// <summary>
+    ///     Called when cURL has header data for the client.
+    /// </summary>
+    /// <remarks>
+    ///     For usage, see the sample <c>Headers.cs</c>.
+    ///     Arguments passed to the recipient include:
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Argument</term>
+    ///             <description>Description</description>
+    ///         </listheader>
+    ///         <item>
+    ///             <term>buf</term>
+    ///             <description>Header data from cURL to the client.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>size</term>
+    ///             <description>Size of a character, in bytes.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>nmemb</term>
+    ///             <description>Number of characters.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>extraData</term>
+    ///             <description>Client-provided extra data.</description>
+    ///         </item>
+    ///     </list>
+    ///     Your implementation should return the number of bytes (not
+    ///     characters) processed. Usually this is <c>size * nmemb</c>.
+    ///     Return -1 to abort the transfer.
+    /// </remarks>
+    public delegate int CurlHeaderCallback(byte[] buf, int size, int nmemb, Object extraData);
+
+    /// <summary>
+    ///     Called when cURL needs for the client to perform an
+    ///     IOCTL operation. An example might be when an FTP
+    ///     upload requires rewinding of the input file to deal
+    ///     with a resend occasioned by an error.
+    /// </summary>
+    /// <remarks>
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Argument</term>
+    ///             <description>Description</description>
+    ///         </listheader>
+    ///         <item>
+    ///             <term>cmd</term>
+    ///             <description>
+    ///                 A <see cref="CurlIoCommand" />; for now, only
+    ///                 <c>RestartRead</c> should be passed.
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <term>extraData</term>
+    ///             <description>
+    ///                 Client-provided extra data; in the
+    ///                 case of an FTP upload, it might be a
+    ///                 <c>FileStream</c> object.
+    ///             </description>
+    ///         </item>
+    ///     </list>
+    ///     Your implementation should return a <see cref="CurlIoError" />,
+    ///     which should be <see cref="CurlIoError.Ok" /> if everything
+    ///     is okay.
+    /// </remarks>
+    public delegate CurlIoError CurlIoctlCallback(CurlIoCommand cmd, Object extraData);
+
+    /// <summary>
+    ///     Called when cURL wants to report progress.
+    /// </summary>
+    /// <remarks>
+    ///     For usage, see the sample <c>Upload.cs</c>.
+    ///     Arguments passed to the recipient include:
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Argument</term>
+    ///             <description>Description</description>
+    ///         </listheader>
+    ///         <item>
+    ///             <term>extraData</term>
+    ///             <description>Client-provided extra data.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>dlTotal</term>
+    ///             <description>Number of bytes to download.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>dlNow</term>
+    ///             <description>Number of bytes downloaded so far.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>ulTotal</term>
+    ///             <description>Number of bytes to upload.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>ulNow</term>
+    ///             <description>Number of bytes uploaded so far.</description>
+    ///         </item>
+    ///     </list>
+    ///     Your implementation should return 0 to continue, or a non-zero
+    ///     value to abort the transfer.
+    /// </remarks>
+    public delegate int CurlProgressCallback(Object extraData, double dlTotal, double dlNow,
+        double ulTotal, double ulNow);
+
+    /// <summary>
+    ///     Called when cURL wants to read data from the client.
+    /// </summary>
+    /// <remarks>
+    ///     For usage, see the sample <c>Upload.cs</c>.
+    ///     Arguments passed to the recipient include:
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Argument</term>
+    ///             <description>Description</description>
+    ///         </listheader>
+    ///         <item>
+    ///             <term>buf</term>
+    ///             <description>
+    ///                 Buffer into which your client should write data
+    ///                 for cURL.
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <term>size</term>
+    ///             <description>Size of a character, usually 1.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>nmemb</term>
+    ///             <description>Number of characters.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>extraData</term>
+    ///             <description>Client-provided extra data.</description>
+    ///         </item>
+    ///     </list>
+    ///     Your implementation should return the number of bytes (not
+    ///     characters) written to <c>buf</c>. Return 0 to abort the transfer.
+    /// </remarks>
+    public delegate int CurlReadCallback([Out] byte[] buf, int size, int nmemb, Object extraData);
+
+    /// <summary>
+    ///     Called when cURL wants to report an Ssl event.
+    /// </summary>
+    /// <remarks>
+    ///     For usage, see the sample <c>SSLGet.cs</c>.
+    ///     Arguments passed to the recipient include:
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Argument</term>
+    ///             <description>Description</description>
+    ///         </listheader>
+    ///         <item>
+    ///             <term>ctx</term>
+    ///             <description>
+    ///                 An <see cref="CurlSslContext" /> object that wraps an
+    ///                 OpenSSL <c>SSL_CTX</c> pointer.
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <term>extraData</term>
+    ///             <description>Client-provided extra data.</description>
+    ///         </item>
+    ///     </list>
+    ///     Your implementation should return a <see cref="CurlCode" />,
+    ///     which should be <see cref="CurlCode.Ok" /> if everything
+    ///     is okay.
+    /// </remarks>
+    public delegate CurlCode CurlSslContextCallback(CurlSslContext ctx, Object extraData);
+
+    /// <summary>
+    ///     Called when cURL has data for the client.
+    /// </summary>
+    /// <remarks>
+    ///     For usage, see the example <c>EasyGet.cs</c>.
+    ///     Arguments passed to the delegate implementation include:
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Argument</term>
+    ///             <description>Description</description>
+    ///         </listheader>
+    ///         <item>
+    ///             <term>buf</term>
+    ///             <description>Data cURL is providing to the client.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>size</term>
+    ///             <description>Size of a character, usually 1.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>nmemb</term>
+    ///             <description>Number of characters.</description>
+    ///         </item>
+    ///         <item>
+    ///             <term>extraData</term>
+    ///             <description>Client-provided extra data.</description>
+    ///         </item>
+    ///     </list>
+    ///     Your implementation should return the number of bytes (not
+    ///     characters) processed. Return 0 to abort the transfer.
+    /// </remarks>
+    public delegate int CurlWriteCallback(byte[] buf, int size, int nmemb, Object extraData);
+}

src/CurlSharp/Callbacks/CurlShareCallbacks.cs

@@ -0,0 +1,75 @@
+using System;
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Called when <c>cURL</c> wants to lock a shared resource.
+    /// </summary>
+    /// <remarks>
+    ///     For a usage example, refer to the <c>ShareDemo.cs</c> sample.
+    ///     Arguments passed to your delegate implementation include:
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Argument</term>
+    ///             <term>Description</term>
+    ///         </listheader>
+    ///         <item>
+    ///             <term>data</term>
+    ///             <term>
+    ///                 Type of data to lock; one of the values in the
+    ///                 <see cref="CurlLockData" /> enumeration.
+    ///             </term>
+    ///         </item>
+    ///         <item>
+    ///             <term>access</term>
+    ///             <term>
+    ///                 Lock access requested; one of the values in the
+    ///                 <see cref="CurlLockAccess" /> enumeration.
+    ///             </term>
+    ///         </item>
+    ///         <item>
+    ///             <term>userData</term>
+    ///             <term>
+    ///                 Client-provided data that is not touched internally by
+    ///                 <c>cURL</c>. This is set via
+    ///                 <see cref="CurlShareOption.UserData" /> when calling the
+    ///                 <see cref="CurlShare.SetOpt" /> member of the <see cref="CurlShare" />
+    ///                 class.
+    ///             </term>
+    ///         </item>
+    ///     </list>
+    /// </remarks>
+    public delegate void CurlShareLockCallback(CurlLockData data, CurlLockAccess access, Object userData);
+
+    /// <summary>
+    ///     Called when <c>cURL</c> wants to unlock a shared resource.
+    /// </summary>
+    /// <remarks>
+    ///     For a usage example, refer to the <c>ShareDemo.cs</c> sample.
+    ///     Arguments passed to your delegate implementation include:
+    ///     <list type="table">
+    ///         <listheader>
+    ///             <term>Argument</term>
+    ///             <term>Description</term>
+    ///         </listheader>
+    ///         <item>
+    ///             <term>data</term>
+    ///             <term>
+    ///                 Type of data to unlock; one of the values in the
+    ///                 <see cref="CurlLockData" /> enumeration.
+    ///             </term>
+    ///         </item>
+    ///         <item>
+    ///             <term>userData</term>
+    ///             <term>
+    ///                 Client-provided data that is not touched internally by
+    ///                 <c>cURL</c>. This is set via
+    ///                 <see cref="CurlShareOption.UserData" /> when calling the
+    ///                 <see cref="CurlShare.SetOpt" /> member of the <see cref="CurlShare" />
+    ///                 class.
+    ///             </term>
+    ///         </item>
+    ///     </list>
+    /// </remarks>
+    public delegate void CurlShareUnlockCallback(CurlLockData data, Object userData);
+}

src/CurlSharp/Curl.cs

@@ -0,0 +1,170 @@
+/***************************************************************************
+ *
+ * CurlS#arp
+ *
+ * Copyright (c) 2013 Dr. Masroor Ehsan (masroore@gmail.com)
+ * Portions copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
+ *
+ * This software is licensed as described in the file LICENSE, which you
+ * should have received as part of this distribution.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of this Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the LICENSE file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+ * ANY KIND, either express or implied.
+ *
+ **************************************************************************/
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Top-level class for initialization and cleanup.
+    /// </summary>
+    /// <remarks>
+    ///     It also implements static methods for capabilities that don't
+    ///     logically belong in a class.
+    /// </remarks>
+    public static class Curl
+    {
+        // for state management
+        private static CurlCode _initCode;
+
+        /// <summary>
+        ///     Class constructor - initialize global status.
+        /// </summary>
+        static Curl()
+        {
+            _initCode = CurlCode.FailedInit;
+        }
+
+        // hidden instance stuff
+
+        /// <summary>
+        ///     Get the underlying cURL version as a string, example "7.12.2".
+        /// </summary>
+        /// <exception cref="System.InvalidOperationException">
+        ///     Thrown if cURL isn't properly initialized.
+        /// </exception>
+        public static string Version
+        {
+            get
+            {
+                EnsureCurl();
+                return Marshal.PtrToStringAnsi(NativeMethods.curl_version());
+            }
+        }
+
+        /// <summary>
+        ///     Process-wide initialization -- call only once per process.
+        /// </summary>
+        /// <param name="flags">
+        ///     An or'd combination of
+        ///     <see cref="CurlInitFlag" /> members.
+        /// </param>
+        /// <returns>
+        ///     A <see cref="CurlCode" />, hopefully
+        ///     <c>CurlCode.Ok</c>.
+        /// </returns>
+        public static CurlCode GlobalInit(CurlInitFlag flags)
+        {
+            _initCode = NativeMethods.curl_global_init((int)flags);
+#if USE_LIBCURLSHIM
+            if (_initCode == CurlCode.Ok)
+                NativeMethods.curl_shim_initialize();
+#endif
+            return _initCode;
+        }
+
+        /// <summary>
+        ///     Process-wide cleanup -- call just before exiting process.
+        /// </summary>
+        /// <remarks>
+        ///     While it's not necessary that your program call this method
+        ///     before exiting, doing so will prevent leaks of native cURL resources.
+        /// </remarks>
+        public static void GlobalCleanup()
+        {
+            if (_initCode == CurlCode.Ok)
+            {
+#if USE_LIBCURLSHIM
+                NativeMethods.curl_shim_cleanup();
+#endif
+                NativeMethods.curl_global_cleanup();
+                _initCode = CurlCode.FailedInit;
+            }
+        }
+
+        /// <summary>
+        ///     URL encode a String.
+        /// </summary>
+        /// <param name="url">The string to URL encode.</param>
+        /// <param name="length">
+        ///     Input string length;
+        ///     use 0 for cURL to determine.
+        /// </param>
+        /// <returns>A new URL encoded string.</returns>
+        /// <exception cref="System.InvalidOperationException">
+        ///     Thrown if cURL isn't properly initialized.
+        /// </exception>
+        public static string Escape(string url, int length)
+        {
+            EnsureCurl();
+            var p = NativeMethods.curl_escape(url, length);
+            var s = Marshal.PtrToStringAnsi(p);
+            NativeMethods.curl_free(p);
+            return s;
+        }
+
+        /// <summary>
+        ///     URL decode a String.
+        /// </summary>
+        /// <param name="url">The string to URL decode.</param>
+        /// <param name="length">
+        ///     Input string length;
+        ///     use 0 for cURL to determine.
+        /// </param>
+        /// <returns>A new URL decoded string.</returns>
+        /// <exception cref="System.InvalidOperationException">
+        ///     Thrown if cURL isn't properly initialized.
+        /// </exception>
+        public static string Unescape(string url, int length)
+        {
+            EnsureCurl();
+            var p = NativeMethods.curl_unescape(url, length);
+            var s = Marshal.PtrToStringAnsi(p);
+            NativeMethods.curl_free(p);
+            return s;
+        }
+
+        /// <summary>
+        ///     Get a <see cref="CurlVersionInfoData" /> object.
+        /// </summary>
+        /// <param name="ver">
+        ///     Specify a <see cref="CurlVersion" />, such as
+        ///     <c>CurlVersion.Now</c>.
+        /// </param>
+        /// <returns>A <see cref="CurlVersionInfoData" /> object.</returns>
+        /// <exception cref="System.InvalidOperationException">
+        ///     Thrown if cURL isn't properly initialized.
+        /// </exception>
+        public static CurlVersionInfoData GetVersionInfo(CurlVersion ver)
+        {
+            EnsureCurl();
+            return new CurlVersionInfoData(ver);
+        }
+
+        /// <summary>
+        ///     Called by other classes to ensure valid cURL state.
+        /// </summary>
+        internal static void EnsureCurl()
+        {
+            if (_initCode != CurlCode.Ok)
+                throw new InvalidOperationException("cURL not initialized");
+        }
+    }
+}

src/CurlSharp/CurlHttpMultiPartForm.cs

@@ -0,0 +1,388 @@
+/***************************************************************************
+ *
+ * CurlS#arp
+ *
+ * Copyright (c) 2014 Dr. Masroor Ehsan (masroore@gmail.com)
+ * Portions copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
+ *
+ * This software is licensed as described in the file LICENSE, which you
+ * should have received as part of this distribution.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of this Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the LICENSE file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+ * ANY KIND, either express or implied.
+ *
+ **************************************************************************/
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     This trivial class wraps the internal <c>curl_forms</c> struct.
+    /// </summary>
+    public sealed class CurlForms
+    {
+        /// <summary>The <see cref="CurlFormOption" />.</summary>
+        public CurlFormOption Option;
+
+        /// <summary>Value for the option.</summary>
+        public Object Value;
+    }
+
+    /// <summary>
+    ///     Wraps a section of multipart form data to be submitted via the
+    ///     <see cref="CurlOption.HttpPost" /> option in the
+    ///     <see cref="CurlEasy.SetOpt" /> member of the <see cref="CurlEasy" /> class.
+    /// </summary>
+    public class CurlHttpMultiPartForm : IDisposable
+    {
+        // the two curlform pointers
+        private readonly IntPtr[] _pItems;
+
+        /// <summary>
+        ///     Constructor
+        /// </summary>
+        /// <exception cref="System.InvalidOperationException">
+        ///     This is thrown
+        ///     if <see cref="Curl" /> hasn't bee properly initialized.
+        /// </exception>
+        public CurlHttpMultiPartForm()
+        {
+            Curl.EnsureCurl();
+            _pItems = new IntPtr[2];
+            _pItems[0] = IntPtr.Zero;
+            _pItems[1] = IntPtr.Zero;
+        }
+
+        /// <summary>
+        ///     Free unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        ///     Destructor
+        /// </summary>
+        ~CurlHttpMultiPartForm()
+        {
+            Dispose(false);
+        }
+
+        // for CurlEasy.SetOpt()
+        internal IntPtr GetHandle()
+        {
+            return _pItems[0];
+        }
+
+        /// <summary>
+        ///     Add a multi-part form section.
+        /// </summary>
+        /// <param name="args">
+        ///     Argument list, as described in the remarks.
+        /// </param>
+        /// <returns>
+        ///     A <see cref="CurlFormCode" />, hopefully
+        ///     <c>CurlFormCode.Ok</c>.
+        /// </returns>
+        /// <remarks>
+        ///     This is definitely the workhorse method for this class. It
+        ///     should be called in roughly the same manner as
+        ///     <c>curl_formadd()</c>, except you would omit the first two
+        ///     <c>struct curl_httppost**</c> arguments (<c>firstitem</c> and
+        ///     <c>lastitem</c>), which are wrapped in this class. So you should
+        ///     pass arguments in the following sequence:
+        ///     <para>
+        ///         <c>
+        ///             CurlHttpMultiPartForm.AddSection(option1, value1, ..., optionX, valueX,
+        ///             CurlFormOption.End)
+        ///         </c>
+        ///         ;
+        ///     </para>
+        ///     <para>
+        ///         For a complete list of possible options, see the documentation for
+        ///         the <see cref="CurlFormOption" /> enumeration.
+        ///     </para>
+        ///     <note>
+        ///         The pointer options (<c>PtrName</c>, etc.) make an
+        ///         internal copy of the passed <c>byte</c> array. Therefore, any
+        ///         changes you make to the client copy of this array AFTER calling
+        ///         this method, won't be reflected internally with <c>cURL</c>. The
+        ///         purpose of providing the pointer options is to support the
+        ///         posting of non-string binary data.
+        ///     </note>
+        /// </remarks>
+        public CurlFormCode AddSection(params object[] args)
+        {
+            var nCount = args.Length;
+            var nRealCount = nCount;
+            var retCode = CurlFormCode.Ok;
+            CurlForms[] aForms = null;
+
+            // one arg or even number of args is an error
+            if ((nCount == 1) || (nCount%2 == 0))
+                return CurlFormCode.Incomplete;
+
+            // ensure the last argument is End
+            var iCode = (CurlFormOption)
+                Convert.ToInt32(args.GetValue(nCount - 1));
+            if (iCode != CurlFormOption.End)
+                return CurlFormCode.Incomplete;
+
+            // walk through any passed arrays to get the true number of
+            // items and ensure the child arrays are properly (and not
+            // prematurely) terminated with End
+            for (var i = 0; i < nCount; i += 2)
+            {
+                iCode = (CurlFormOption) Convert.ToInt32(args.GetValue(i));
+                switch (iCode)
+                {
+                    case CurlFormOption.Array:
+                    {
+                        aForms = args.GetValue(i + 1) as CurlForms[];
+                        if (aForms == null)
+                            return CurlFormCode.Incomplete;
+                        var nFormsCount = aForms.Length;
+                        for (var j = 0; j < nFormsCount; j++)
+                        {
+                            var pcf = aForms.GetValue(j) as CurlForms;
+                            if (pcf == null)
+                                return CurlFormCode.Incomplete;
+                            if (j == nFormsCount - 1)
+                            {
+                                if (pcf.Option != CurlFormOption.End)
+                                    return CurlFormCode.Incomplete;
+                            }
+                            else
+                            {
+                                if (pcf.Option == CurlFormOption.End)
+                                    return CurlFormCode.Incomplete;
+                            }
+                        }
+                        // -2 accounts for the fact that we're a) not
+                        // including the item with End and b) not
+                        // including Array in what we pass to cURL
+                        nRealCount += 2*(nFormsCount - 2);
+                        break;
+                    }
+                }
+            }
+
+            // allocate the IntPtr array for the data
+            var aPointers = new IntPtr[nRealCount];
+            for (var i = 0; i < nRealCount - 1; i++)
+                aPointers[i] = IntPtr.Zero;
+            aPointers[nRealCount - 1] = (IntPtr) CurlFormOption.End;
+
+            // now we go through the args
+            aForms = null;
+            var formArrayPos = 0;
+            var argArrayPos = 0;
+            var ptrArrayPos = 0;
+            Object obj = null;
+
+            while ((retCode == CurlFormCode.Ok) &&
+                   (ptrArrayPos < nRealCount))
+            {
+                if (aForms != null)
+                {
+                    var pcf = aForms.GetValue(formArrayPos++)
+                        as CurlForms;
+                    if (pcf == null)
+                    {
+                        retCode = CurlFormCode.UnknownOption;
+                        break;
+                    }
+                    iCode = pcf.Option;
+                    obj = pcf.Value;
+                }
+                else
+                {
+                    iCode = (CurlFormOption) Convert.ToInt32(
+                        args.GetValue(argArrayPos++));
+                    obj = (iCode == CurlFormOption.End)
+                        ? null
+                        : args.GetValue(argArrayPos++);
+                }
+
+                switch (iCode)
+                {
+                        // handle byte-array pointer-related items
+                    case CurlFormOption.PtrName:
+                    case CurlFormOption.PtrContents:
+                    case CurlFormOption.BufferPtr:
+                    {
+                        var bytes = obj as byte[];
+                        if (bytes == null)
+                            retCode = CurlFormCode.UnknownOption;
+                        else
+                        {
+                            var nLen = bytes.Length;
+                            var ptr = Marshal.AllocHGlobal(nLen);
+                            if (ptr != IntPtr.Zero)
+                            {
+                                aPointers[ptrArrayPos++] = (IntPtr) iCode;
+                                // copy bytes to unmanaged buffer
+                                for (var j = 0; j < nLen; j++)
+                                    Marshal.WriteByte(ptr, bytes[j]);
+                                aPointers[ptrArrayPos++] = ptr;
+                            }
+                            else
+                                retCode = CurlFormCode.Memory;
+                        }
+                        break;
+                    }
+
+                        // length values
+                    case CurlFormOption.NameLength:
+                    case CurlFormOption.ContentsLength:
+                    case CurlFormOption.BufferLength:
+                        aPointers[ptrArrayPos++] = (IntPtr) iCode;
+                        aPointers[ptrArrayPos++] = (IntPtr)
+                            Convert.ToInt32(obj);
+                        break;
+
+                        // strings
+                    case CurlFormOption.CopyName:
+                    case CurlFormOption.CopyContents:
+                    case CurlFormOption.FileContent:
+                    case CurlFormOption.File:
+                    case CurlFormOption.ContentType:
+                    case CurlFormOption.Filename:
+                    case CurlFormOption.Buffer:
+                    {
+                        aPointers[ptrArrayPos++] = (IntPtr) iCode;
+                        var s = obj as String;
+                        if (s == null)
+                            retCode = CurlFormCode.UnknownOption;
+                        else
+                        {
+                            var p = Marshal.StringToHGlobalAnsi(s);
+                            if (p != IntPtr.Zero)
+                                aPointers[ptrArrayPos++] = p;
+                            else
+                                retCode = CurlFormCode.Memory;
+                        }
+                        break;
+                    }
+
+                        // array case: already handled
+                    case CurlFormOption.Array:
+                        if (aForms != null)
+                            retCode = CurlFormCode.IllegalArray;
+                        else
+                        {
+                            aForms = obj as CurlForms[];
+                            if (aForms == null)
+                                retCode = CurlFormCode.UnknownOption;
+                        }
+                        break;
+
+                        // slist
+                    case CurlFormOption.ContentHeader:
+                    {
+                        aPointers[ptrArrayPos++] = (IntPtr) iCode;
+                        var s = obj as CurlSlist;
+                        if (s == null)
+                            retCode = CurlFormCode.UnknownOption;
+                        else
+                            aPointers[ptrArrayPos++] = s.Handle;
+                        break;
+                    }
+
+                        // erroneous stuff
+                    case CurlFormOption.Nothing:
+                        retCode = CurlFormCode.Incomplete;
+                        break;
+
+                        // end
+                    case CurlFormOption.End:
+                        if (aForms != null) // end of form
+                        {
+                            aForms = null;
+                            formArrayPos = 0;
+                        }
+                        else
+                            aPointers[ptrArrayPos++] = (IntPtr) iCode;
+                        break;
+
+                        // default is unknown
+                    default:
+                        retCode = CurlFormCode.UnknownOption;
+                        break;
+                }
+            }
+
+            // ensure we didn't come up short on parameters
+            if (ptrArrayPos != nRealCount)
+                retCode = CurlFormCode.Incomplete;
+
+            // if we're OK here, call into curl
+            if (retCode == CurlFormCode.Ok)
+            {
+#if USE_LIBCURLSHIM
+                retCode = (CurlFormCode) NativeMethods.curl_shim_formadd(_pItems, aPointers, nRealCount);
+#else
+                retCode = (CurlFormCode) NativeMethods.curl_formadd(ref _pItems[0], ref _pItems[1],
+                                                                    (int) aPointers[0], aPointers[1],
+                                                                    (int) aPointers[2], aPointers[3],
+                                                                    (int) aPointers[4]);
+#endif
+            }
+
+            // unmarshal native allocations
+            for (var i = 0; i < nRealCount - 1; i += 2)
+            {
+                iCode = (CurlFormOption) (int) aPointers[i];
+                switch (iCode)
+                {
+                    case CurlFormOption.CopyName:
+                    case CurlFormOption.CopyContents:
+                    case CurlFormOption.FileContent:
+                    case CurlFormOption.File:
+                    case CurlFormOption.ContentType:
+                    case CurlFormOption.Filename:
+                    case CurlFormOption.Buffer:
+                        // byte buffer cases
+                    case CurlFormOption.PtrName:
+                    case CurlFormOption.PtrContents:
+                    case CurlFormOption.BufferPtr:
+                    {
+                        if (aPointers[i + 1] != IntPtr.Zero)
+                            Marshal.FreeHGlobal(aPointers[i + 1]);
+                        break;
+                    }
+
+                    default:
+                        break;
+                }
+            }
+
+            return retCode;
+        }
+
+        private void Dispose(bool disposing)
+        {
+            lock (this)
+            {
+                if (disposing)
+                {
+                    // clean up managed objects
+                }
+
+                // clean up native objects
+                if (_pItems[0] != IntPtr.Zero)
+                    NativeMethods.curl_formfree(_pItems[0]);
+                _pItems[0] = IntPtr.Zero;
+                _pItems[1] = IntPtr.Zero;
+            }
+        }
+    }
+}

src/CurlSharp/CurlMulti.cs

@@ -0,0 +1,302 @@
+/***************************************************************************
+ *
+ * CurlS#arp
+ *
+ * Copyright (c) 2014 Dr. Masroor Ehsan (masroore@gmail.com)
+ * Portions copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
+ *
+ * This software is licensed as described in the file LICENSE, which you
+ * should have received as part of this distribution.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of this Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the LICENSE file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+ * ANY KIND, either express or implied.
+ *
+ **************************************************************************/
+
+using System;
+using System.Collections;
+using System.Runtime.InteropServices;
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Implements the <c>curl_multi_xxx</c> API.
+    /// </summary>
+    public class CurlMulti : IDisposable
+    {
+        // private members
+        private readonly Hashtable _htEasy;
+        private int _maxFd;
+        private CurlMultiInfo[] _multiInfo;
+        private bool _bGotMultiInfo;
+#if USE_LIBCURLSHIM
+        private IntPtr _fdSets;
+#else
+        private NativeMethods.fd_set _fd_read, _fd_write, _fd_except;
+#endif
+        private IntPtr _pMulti;
+
+        /// <summary>
+        ///     Constructor
+        /// </summary>
+        /// <exception cref="System.InvalidOperationException">
+        ///     This is thrown
+        ///     if <see cref="Curl" /> hasn't bee properly initialized.
+        /// </exception>
+        /// <exception cref="System.NullReferenceException">
+        ///     This is thrown if the native <c>CurlMulti</c> handle wasn't
+        ///     created successfully.
+        /// </exception>
+        public CurlMulti()
+        {
+            Curl.EnsureCurl();
+            _pMulti = NativeMethods.curl_multi_init();
+            ensureHandle();
+            _maxFd = 0;
+#if USE_LIBCURLSHIM
+            _fdSets = IntPtr.Zero;
+            _fdSets = NativeMethods.curl_shim_alloc_fd_sets();
+#else
+            _fd_read = NativeMethods.fd_set.Create();
+            _fd_read = NativeMethods.fd_set.Create();
+            _fd_write = NativeMethods.fd_set.Create();
+            _fd_except = NativeMethods.fd_set.Create();
+#endif
+            _multiInfo = null;
+            _bGotMultiInfo = false;
+            _htEasy = new Hashtable();
+        }
+
+        /// <summary>
+        ///     Max file descriptor
+        /// </summary>
+        public int MaxFd
+        {
+            get { return _maxFd; }
+        }
+
+        /// <summary>
+        ///     Cleanup unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        ///     Destructor
+        /// </summary>
+        ~CurlMulti()
+        {
+            Dispose(false);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            lock (this)
+            {
+                // if (disposing) // managed member cleanup
+                // unmanaged cleanup
+                if (_pMulti != IntPtr.Zero)
+                {
+                    NativeMethods.curl_multi_cleanup(_pMulti);
+                    _pMulti = IntPtr.Zero;
+                }
+
+#if USE_LIBCURLSHIM
+                if (_fdSets != IntPtr.Zero)
+                {
+                    NativeMethods.curl_shim_free_fd_sets(_fdSets);
+                    _fdSets = IntPtr.Zero;
+                }
+#else
+                _fd_read.Cleanup();
+                _fd_write.Cleanup();
+                _fd_except.Cleanup();
+#endif
+            }
+        }
+
+        private void ensureHandle()
+        {
+            if (_pMulti == IntPtr.Zero)
+                throw new NullReferenceException("No internal multi handle");
+        }
+
+        /// <summary>
+        ///     Add an CurlEasy object.
+        /// </summary>
+        /// <param name="curlEasy">
+        ///     <see cref="CurlEasy" /> object to add.
+        /// </param>
+        /// <returns>
+        ///     A <see cref="CurlMultiCode" />, hopefully <c>CurlMultiCode.Ok</c>
+        /// </returns>
+        /// <exception cref="System.NullReferenceException">
+        ///     This is thrown if the native <c>CurlMulti</c> handle wasn't
+        ///     created successfully.
+        /// </exception>
+        public CurlMultiCode AddHandle(CurlEasy curlEasy)
+        {
+            ensureHandle();
+            var p = curlEasy.Handle;
+            _htEasy.Add(p, curlEasy);
+            return NativeMethods.curl_multi_add_handle(_pMulti, p);
+        }
+
+        /// <summary>
+        ///     Remove an CurlEasy object.
+        /// </summary>
+        /// <param name="curlEasy">
+        ///     <see cref="CurlEasy" /> object to remove.
+        /// </param>
+        /// <returns>
+        ///     A <see cref="CurlMultiCode" />, hopefully <c>CurlMultiCode.Ok</c>
+        /// </returns>
+        /// <exception cref="System.NullReferenceException">
+        ///     This is thrown if the native <c>CurlMulti</c> handle wasn't
+        ///     created successfully.
+        /// </exception>
+        public CurlMultiCode RemoveHandle(CurlEasy curlEasy)
+        {
+            ensureHandle();
+            var p = curlEasy.Handle;
+            _htEasy.Remove(p);
+            return NativeMethods.curl_multi_remove_handle(_pMulti, curlEasy.Handle);
+        }
+
+        /// <summary>
+        ///     Get a string description of an error code.
+        /// </summary>
+        /// <param name="errorNum">
+        ///     The <see cref="CurlMultiCode" /> for which to obtain the error
+        ///     string description.
+        /// </param>
+        /// <returns>The string description.</returns>
+        public String StrError(CurlMultiCode errorNum)
+        {
+            return Marshal.PtrToStringAnsi(NativeMethods.curl_multi_strerror(errorNum));
+        }
+
+        /// <summary>
+        ///     Read/write data to/from each CurlEasy object.
+        /// </summary>
+        /// <param name="runningObjects">
+        ///     The number of <see cref="CurlEasy" /> objects still in process is
+        ///     written by this function to this reference parameter.
+        /// </param>
+        /// <returns>
+        ///     A <see cref="CurlMultiCode" />, hopefully <c>CurlMultiCode.Ok</c>
+        /// </returns>
+        /// <exception cref="System.NullReferenceException">
+        ///     This is thrown if the native <c>CurlMulti</c> handle wasn't
+        ///     created successfully.
+        /// </exception>
+        public CurlMultiCode Perform(ref int runningObjects)
+        {
+            ensureHandle();
+            return NativeMethods.curl_multi_perform(_pMulti, ref runningObjects);
+        }
+
+        /// <summary>
+        ///     Set internal file desriptor information before calling Select.
+        /// </summary>
+        /// <returns>
+        ///     A <see cref="CurlMultiCode" />, hopefully <c>CurlMultiCode.Ok</c>
+        /// </returns>
+        /// <exception cref="System.NullReferenceException">
+        ///     This is thrown if the native <c>CurlMulti</c> handle wasn't
+        ///     created successfully.
+        /// </exception>
+        public CurlMultiCode FdSet()
+        {
+            ensureHandle();
+#if USE_LIBCURLSHIM
+            return NativeMethods.curl_shim_multi_fdset(_pMulti, _fdSets, ref _maxFd);
+#else
+            NativeMethods.FD_ZERO(_fd_read);
+            NativeMethods.FD_ZERO(_fd_write);
+            NativeMethods.FD_ZERO(_fd_except);
+            return NativeMethods.curl_multi_fdset(_pMulti, ref _fd_read, ref _fd_write, ref _fd_except, ref _maxFd);
+#endif
+        }
+
+        /// <summary>
+        ///     Call <c>select()</c> on the CurlEasy objects.
+        /// </summary>
+        /// <param name="timeoutMillis">
+        ///     The timeout for the internal <c>select()</c> call,
+        ///     in milliseconds.
+        /// </param>
+        /// <returns>
+        ///     Number or <see cref="CurlEasy" /> objects with pending reads.
+        /// </returns>
+        /// <exception cref="System.NullReferenceException">
+        ///     This is thrown if the native <c>CurlMulti</c> handle wasn't
+        ///     created successfully.
+        /// </exception>
+        public int Select(int timeoutMillis)
+        {
+            ensureHandle();
+#if USE_LIBCURLSHIM
+            return NativeMethods.curl_shim_select(_maxFd + 1, _fdSets, timeoutMillis);
+#else
+            var timeout = NativeMethods.timeval.Create(timeoutMillis);
+            return NativeMethods.select(_maxFd + 1, ref _fd_read, ref _fd_write, ref _fd_except, ref timeout);
+            //return NativeMethods.select2(_maxFd + 1, _fd_read, _fd_write, _fd_except, timeout);
+#endif
+        }
+
+        /// <summary>
+        ///     Obtain status information for a CurlMulti transfer. Requires
+        ///     CurlSharp be compiled with the libcurlshim helper.
+        /// </summary>
+        /// <returns>
+        ///     An array of <see cref="CurlMultiInfo" /> objects, one for each
+        ///     <see cref="CurlEasy" /> object child.
+        /// </returns>
+        /// <exception cref="System.NullReferenceException">
+        ///     This is thrown if the native <c>CurlMulti</c> handle wasn't
+        ///     created successfully.
+        /// </exception>
+        public CurlMultiInfo[] InfoRead()
+        {
+            if (_bGotMultiInfo)
+                return _multiInfo;
+
+            _bGotMultiInfo = true;
+
+#if USE_LIBCURLSHIM
+            var nMsgs = 0;
+            var pInfo = NativeMethods.curl_shim_multi_info_read(_pMulti, ref nMsgs);
+            if (pInfo != IntPtr.Zero)
+            {
+                _multiInfo = new CurlMultiInfo[nMsgs];
+                for (var i = 0; i < nMsgs; i++)
+                {
+                    var msg = (CurlMessage) Marshal.ReadInt32(pInfo, i*12);
+                    var pEasy = Marshal.ReadIntPtr(pInfo, i*12 + 4);
+                    var code = (CurlCode) Marshal.ReadInt32(pInfo, i*12 + 8);
+                    _multiInfo[i] = new CurlMultiInfo(msg, (CurlEasy) _htEasy[pEasy], code);
+                }
+                NativeMethods.curl_shim_multi_info_free(pInfo);
+            }
+
+            return _multiInfo;
+
+#else
+
+            throw new NotImplementedException(
+                "Sorry, CurlMulti.InfoRead is not implemented on this system."
+            );
+
+#endif
+
+        }
+    }
+}

src/CurlSharp/CurlMultiInfo.cs

@@ -0,0 +1,65 @@
+/***************************************************************************
+ *
+ * CurlS#arp
+ *
+ * Copyright (c) 2013 Dr. Masroor Ehsan (masroore@gmail.com)
+ * Portions copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
+ *
+ * This software is licensed as described in the file LICENSE, which you
+ * should have received as part of this distribution.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of this Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the LICENSE file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+ * ANY KIND, either express or implied.
+ *
+ **************************************************************************/
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Wraps the <c>cURL</c> struct <c>CURLMsg</c>. This class provides
+    ///     status information following a <see cref="CurlMulti" /> transfer.
+    /// </summary>
+    public sealed class CurlMultiInfo
+    {
+        // private members
+        private readonly CurlEasy _mCurlEasy;
+        private readonly CurlMessage _msg;
+        private readonly CurlCode _result;
+
+        internal CurlMultiInfo(CurlMessage msg, CurlEasy curlEasy, CurlCode result)
+        {
+            _msg = msg;
+            _mCurlEasy = curlEasy;
+            _result = result;
+        }
+
+        /// <summary>
+        ///     Get the status code from the <see cref="CurlMessage" /> enumeration.
+        /// </summary>
+        public CurlMessage Msg
+        {
+            get { return _msg; }
+        }
+
+        /// <summary>
+        ///     Get the <see cref="CurlEasy" /> object for this child.
+        /// </summary>
+        public CurlEasy CurlEasyHandle
+        {
+            get { return _mCurlEasy; }
+        }
+
+        /// <summary>
+        ///     Get the return code for the transfer, as a
+        ///     <see cref="CurlCode" />.
+        /// </summary>
+        public CurlCode Result
+        {
+            get { return _result; }
+        }
+    }
+}

src/CurlSharp/CurlShare.cs

@@ -0,0 +1,276 @@
+/***************************************************************************
+ *
+ * CurlS#arp
+ *
+ * Copyright (c) 2013 Dr. Masroor Ehsan (masroore@gmail.com)
+ * Portions copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
+ *
+ * This software is licensed as described in the file LICENSE, which you
+ * should have received as part of this distribution.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of this Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the LICENSE file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+ * ANY KIND, either express or implied.
+ *
+ **************************************************************************/
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     This class provides an infrastructure for serializing access to data
+    ///     shared by multiple <see cref="CurlEasy" /> objects, including cookie data
+    ///     and Dns hosts. It implements the <c>curl_share_xxx</c> API.
+    /// </summary>
+    public class CurlShare : IDisposable
+    {
+        // private members
+        private GCHandle _hThis; // for handle extraction
+        private CurlShareCode _lastErrorCode;
+        private string _lastErrorDescription;
+#if USE_LIBCURLSHIM
+        private NativeMethods._ShimLockCallback _pDelLock; // lock delegate
+        private NativeMethods._ShimUnlockCallback _pDelUnlock; // unlock delegate
+#endif
+        private IntPtr _pShare; // share handle
+        private CurlShareLockCallback _pfLock; // client lock delegate
+        private CurlShareUnlockCallback _pfUnlock; // client unlock delegate
+        private IntPtr _ptrThis; // numeric handle
+        private Object _userData; // user data for delegates
+
+        /// <summary>
+        ///     Constructor
+        /// </summary>
+        /// <exception cref="System.InvalidOperationException">
+        ///     This is thrown
+        ///     if <see cref="Curl" /> hasn't bee properly initialized.
+        /// </exception>
+        /// <exception cref="System.NullReferenceException">
+        ///     This is thrown if
+        ///     the native <c>share</c> handle wasn't created successfully.
+        /// </exception>
+        public CurlShare()
+        {
+            Curl.EnsureCurl();
+            _pShare = NativeMethods.curl_share_init();
+            EnsureHandle();
+            LockFunction = null;
+            UnlockFunction = null;
+            UserData = null;
+            installDelegates();
+        }
+
+        public object UserData
+        {
+            get { return _userData; }
+            set { _userData = value; }
+        }
+
+        public CurlShareUnlockCallback UnlockFunction
+        {
+            get { return _pfUnlock; }
+            set { _pfUnlock = value; }
+        }
+
+        public CurlShareLockCallback LockFunction
+        {
+            get { return _pfLock; }
+            set { _pfLock = value; }
+        }
+
+        public CurlLockData Share
+        {
+            set { setShareOption(CurlShareOption.Share, value); }
+        }
+
+        public CurlLockData Unshare
+        {
+            set { setShareOption(CurlShareOption.Unshare, value); }
+        }
+
+        public CurlShareCode LastErrorCode
+        {
+            get { return _lastErrorCode; }
+        }
+
+        public string LastErrorDescription
+        {
+            get { return _lastErrorDescription; }
+        }
+
+        /// <summary>
+        ///     Cleanup unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        ///     Destructor
+        /// </summary>
+        ~CurlShare()
+        {
+            Dispose(false);
+        }
+
+        /// <summary>
+        ///     Set options for this object.
+        /// </summary>
+        /// <param name="option">
+        ///     One of the values in the <see cref="CurlShareOption" />
+        ///     enumeration.
+        /// </param>
+        /// <param name="parameter">
+        ///     An appropriate object based on the value passed in the
+        ///     <c>option</c> argument. See <see cref="CurlShareOption" />
+        ///     for more information about the appropriate parameter type.
+        /// </param>
+        /// <returns>
+        ///     A <see cref="CurlShareCode" />, hopefully
+        ///     <c>CurlShareCode.Ok</c>.
+        /// </returns>
+        /// <exception cref="System.NullReferenceException">
+        ///     This is thrown if
+        ///     the native <c>share</c> handle wasn't created successfully.
+        /// </exception>
+        public CurlShareCode SetOpt(CurlShareOption option, Object parameter)
+        {
+            EnsureHandle();
+            var retCode = CurlShareCode.Ok;
+
+            switch (option)
+            {
+                case CurlShareOption.LockFunction:
+                    var lf = parameter as CurlShareLockCallback;
+                    if (lf == null)
+                        return CurlShareCode.BadOption;
+                    _pfLock = lf;
+                    break;
+
+                case CurlShareOption.UnlockFunction:
+                    var ulf = parameter as CurlShareUnlockCallback;
+                    if (ulf == null)
+                        return CurlShareCode.BadOption;
+                    _pfUnlock = ulf;
+                    break;
+
+                case CurlShareOption.Share:
+                case CurlShareOption.Unshare:
+                {
+                    var opt = (CurlLockData) Convert.ToInt32(parameter);
+                    retCode = setShareOption(option, opt);
+                    break;
+                }
+
+                case CurlShareOption.UserData:
+                    _userData = parameter;
+                    break;
+
+                default:
+                    retCode = CurlShareCode.BadOption;
+                    break;
+            }
+            return retCode;
+        }
+
+        private void setLastError(CurlShareCode code, CurlShareOption opt)
+        {
+            if (_lastErrorCode == CurlShareCode.Ok && code != CurlShareCode.Ok)
+            {
+                _lastErrorCode = code;
+                _lastErrorDescription = string.Format("Error: {0} setting option {1}", StrError(code), opt);
+            }
+        }
+
+        private CurlShareCode setShareOption(CurlShareOption option, CurlLockData value)
+        {
+            var retCode = (value != CurlLockData.Cookie) && (value != CurlLockData.Dns)
+                ? CurlShareCode.BadOption
+                : NativeMethods.curl_share_setopt(_pShare, option, (IntPtr) value);
+            setLastError(retCode, option);
+            return retCode;
+        }
+
+        /// <summary>
+        ///     Return a String description of an error code.
+        /// </summary>
+        /// <param name="errorNum">
+        ///     The <see cref="CurlShareCode" /> for which to obtain the error
+        ///     string description.
+        /// </param>
+        /// <returns>The string description.</returns>
+        public String StrError(CurlShareCode errorNum)
+        {
+            return Marshal.PtrToStringAnsi(NativeMethods.curl_share_strerror(errorNum));
+        }
+
+        private void Dispose(bool disposing)
+        {
+            lock (this)
+            {
+                // if (disposing) cleanup managed objects
+                if (_pShare != IntPtr.Zero)
+                {
+#if USE_LIBCURLSHIM
+                    NativeMethods.curl_shim_cleanup_share_delegates(_pShare);
+#endif
+                    NativeMethods.curl_share_cleanup(_pShare);
+                    _hThis.Free();
+                    _ptrThis = IntPtr.Zero;
+                    _pShare = IntPtr.Zero;
+                }
+            }
+        }
+
+        internal IntPtr GetHandle()
+        {
+            return _pShare;
+        }
+
+        private void EnsureHandle()
+        {
+            if (_pShare == IntPtr.Zero)
+                throw new NullReferenceException("No internal share handle");
+        }
+
+        private void installDelegates()
+        {
+            _hThis = GCHandle.Alloc(this);
+            _ptrThis = (IntPtr)_hThis;
+#if USE_LIBCURLSHIM
+            _pDelLock = LockDelegate;
+            _pDelUnlock = UnlockDelegate;
+            NativeMethods.curl_shim_install_share_delegates(_pShare, _ptrThis, _pDelLock, _pDelUnlock);
+#endif
+        }
+
+        internal static void LockDelegate(int data, int access, IntPtr userPtr)
+        {
+            var gch = (GCHandle) userPtr;
+            var share = (CurlShare) gch.Target;
+            if (share == null)
+                return;
+            if (share.LockFunction == null)
+                return;
+            share.LockFunction((CurlLockData) data, (CurlLockAccess) access, share.UserData);
+        }
+
+        internal static void UnlockDelegate(int data, IntPtr userPtr)
+        {
+            var gch = (GCHandle) userPtr;
+            var share = (CurlShare) gch.Target;
+            if (share == null)
+                return;
+            if (share.UnlockFunction == null)
+                return;
+            share.UnlockFunction((CurlLockData) data, share.UserData);
+        }
+    }
+}

src/CurlSharp/CurlSharp.csproj

@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{74420A79-CC16-442C-8B1E-7C1B913844F0}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>CurlSharp</RootNamespace>
+    <AssemblyName>CurlSharp</AssemblyName>
+    <FileAlignment>512</FileAlignment>
+    <ProductVersion>12.0.0</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug</OutputPath>
+    <DefineConstants>DEBUG;LINUX</DefineConstants>
+    <WarningLevel>4</WarningLevel>
+    <ConsolePause>false</ConsolePause>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>full</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release</OutputPath>
+    <WarningLevel>4</WarningLevel>
+    <ConsolePause>false</ConsolePause>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DefineConstants>LINUX</DefineConstants>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Curl.cs" />
+    <Compile Include="CurlEasy.cs" />
+    <Compile Include="CurlHttpMultiPartForm.cs" />
+    <Compile Include="CurlMulti.cs" />
+    <Compile Include="CurlMultiInfo.cs" />
+    <Compile Include="CurlShare.cs" />
+    <Compile Include="CurlSlist.cs" />
+    <Compile Include="CurlSslContext.cs" />
+    <Compile Include="CurlVersionInfoData.cs" />
+    <Compile Include="NativeMethods.cs" />
+    <Compile Include="Enums\CurlClosePolicy.cs" />
+    <Compile Include="Enums\CurlCode.cs" />
+    <Compile Include="Enums\CurlFormCode.cs" />
+    <Compile Include="Enums\CurlFormOption.cs" />
+    <Compile Include="Enums\CurlFtpAuth.cs" />
+    <Compile Include="Enums\CurlFtpSsl.cs" />
+    <Compile Include="Enums\CurlHttpAuth.cs" />
+    <Compile Include="Enums\CurlHttpVersion.cs" />
+    <Compile Include="Enums\CurlInfo.cs" />
+    <Compile Include="Enums\CurlInfoType.cs" />
+    <Compile Include="Enums\CurlInitFlag.cs" />
+    <Compile Include="Enums\CurlIoCommand.cs" />
+    <Compile Include="Enums\CurlIoError.cs" />
+    <Compile Include="Enums\CurlIpResolve.cs" />
+    <Compile Include="Enums\CurlLockAccess.cs" />
+    <Compile Include="Enums\CurlLockData.cs" />
+    <Compile Include="Enums\CurlMessage.cs" />
+    <Compile Include="Enums\CurlMultiCode.cs" />
+    <Compile Include="Enums\CurlNetrcOption.cs" />
+    <Compile Include="Enums\CurlOption.cs" />
+    <Compile Include="Enums\CurlProxyType.cs" />
+    <Compile Include="Enums\CurlShareCode.cs" />
+    <Compile Include="Enums\CurlShareOption.cs" />
+    <Compile Include="Enums\CurlSslVersion.cs" />
+    <Compile Include="Enums\CurlTimeCond.cs" />
+    <Compile Include="Enums\CurlVersion.cs" />
+    <Compile Include="Enums\CurlVersionFeatureBitmask.cs" />
+    <Compile Include="Callbacks\CurlEasyCallbacks.cs" />
+    <Compile Include="Callbacks\CurlShareCallbacks.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <ItemGroup />
+</Project>

src/CurlSharp/CurlSlist.cs

@@ -0,0 +1,144 @@
+/***************************************************************************
+ *
+ * CurlS#arp
+ *
+ * Copyright (c) 2013 Dr. Masroor Ehsan (masroore@gmail.com)
+ * Portions copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
+ *
+ * This software is licensed as described in the file LICENSE, which you
+ * should have received as part of this distribution.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of this Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the LICENSE file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+ * ANY KIND, either express or implied.
+ *
+ **************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     This class wraps a linked list of strings used in <c>cURL</c>. Use it
+    ///     to build string lists where they're required, such as when calling
+    ///     <see cref="CurlEasy.SetOpt" /> with <see cref="CurlOption.Quote" />
+    ///     as the option.
+    /// </summary>
+    public class CurlSlist : IDisposable
+    {
+#if !USE_LIBCURLSHIM
+        [StructLayout(LayoutKind.Sequential)]
+        private class curl_slist
+        {
+            /// char*
+            [MarshalAs(UnmanagedType.LPStr)] public string data;
+
+            /// curl_slist*
+            public IntPtr next;
+        }
+#endif
+        private IntPtr _handle;
+
+        /// <summary>
+        ///     Constructor
+        /// </summary>
+        /// <exception cref="System.InvalidOperationException">
+        ///     This is thrown
+        ///     if <see cref="Curl" /> hasn't bee properly initialized.
+        /// </exception>
+        public CurlSlist()
+        {
+            Curl.EnsureCurl();
+            _handle = IntPtr.Zero;
+        }
+
+        public CurlSlist(IntPtr handle)
+        {
+            _handle = handle;
+        }
+
+        /// <summary>
+        ///     Read-only copy of the strings stored in the SList
+        /// </summary>
+        public List<string> Strings
+        {
+            get
+            {
+                if (_handle == IntPtr.Zero)
+                    return null;
+                var strings = new List<string>();
+
+#if !USE_LIBCURLSHIM
+                var slist = new curl_slist();
+                Marshal.PtrToStructure(_handle, slist);
+
+                while (true)
+                {
+                    strings.Add(slist.data);
+                    if (slist.next != IntPtr.Zero)
+                        Marshal.PtrToStructure(slist.next, slist);
+                    else
+                        break;
+                }
+#endif
+                return strings;
+            }
+        }
+
+        /// <summary>
+        ///     Destructor
+        /// </summary>
+        ~CurlSlist()
+        {
+            Dispose(false);
+        }
+
+        /// <summary>
+        ///     Append a string to the list.
+        /// </summary>
+        /// <param name="str">The <c>string</c> to append.</param>
+        public void Append(string str)
+        {
+#if USE_LIBCURLSHIM
+            _handle = NativeMethods.curl_shim_add_string_to_slist(_handle, str);
+#else
+            _handle = NativeMethods.curl_slist_append(_handle, str);
+#endif
+        }
+
+        /// <summary>
+        ///     Free all internal strings.
+        /// </summary>
+        public void Dispose()
+        {
+            GC.SuppressFinalize(this);
+            Dispose(true);
+        }
+
+        internal IntPtr Handle
+        {
+            get { return _handle; }
+        }
+
+        private void Dispose(bool disposing)
+        {
+            lock (this)
+            {
+                if (_handle != IntPtr.Zero)
+                {
+#if USE_LIBCURLSHIM
+                    NativeMethods.curl_shim_free_slist(_handle);
+#else
+                    NativeMethods.curl_slist_free_all(_handle);
+#endif
+                    _handle = IntPtr.Zero;
+                }
+            }
+        }
+    }
+}

src/CurlSharp/CurlSslContext.cs

@@ -0,0 +1,49 @@
+/***************************************************************************
+ *
+ * CurlS#arp
+ *
+ * Copyright (c) 2013 Dr. Masroor Ehsan (masroore@gmail.com)
+ * Portions copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
+ *
+ * This software is licensed as described in the file LICENSE, which you
+ * should have received as part of this distribution.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of this Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the LICENSE file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+ * ANY KIND, either express or implied.
+ *
+ **************************************************************************/
+
+using System;
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     An instance of this class is passed to the delegate
+    ///     <see cref="CurlSslContextCallback" />, if it's implemented.
+    ///     Within that delegate, the code will have to make native calls to
+    ///     the <c>OpenSSL</c> library with the value returned from the
+    ///     <see cref="CurlSslContext.Context" /> property cast to an
+    ///     <c>SSL_CTX</c> pointer.
+    /// </summary>
+    public sealed class CurlSslContext
+    {
+        private readonly IntPtr _pvContext;
+
+        internal CurlSslContext(IntPtr pvContext)
+        {
+            _pvContext = pvContext;
+        }
+
+        /// <summary>
+        ///     Get the underlying OpenSSL context.
+        /// </summary>
+        public IntPtr Context
+        {
+            get { return _pvContext; }
+        }
+    }
+}

src/CurlSharp/CurlVersionInfoData.cs

@@ -0,0 +1,207 @@
+/***************************************************************************
+ *
+ * CurlS#arp
+ *
+ * Copyright (c) 2013 Dr. Masroor Ehsan (masroore@gmail.com)
+ * Portions copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
+ *
+ * This software is licensed as described in the file LICENSE, which you
+ * should have received as part of this distribution.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of this Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the LICENSE file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+ * ANY KIND, either express or implied.
+ *
+ **************************************************************************/
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     This class wraps a <c>curl_version_info_data</c> struct. An instance is
+    ///     obtained by calling <see cref="Curl.GetVersionInfo" />.
+    /// </summary>
+    public sealed class CurlVersionInfoData
+    {
+        private const int OFFSET_AGE = 0;
+        private const int OFFSET_VERSION = 4;
+        private const int OFFSET_VERSION_NUM = 8;
+        private const int OFFSET_HOST = 12;
+        private const int OFFSET_FEATURES = 16;
+        private const int OFFSET_SSL_VERSION = 20;
+        private const int OFFSET_SSL_VERSION_NUM = 24;
+        private const int OFFSET_LIBZ_VERSION = 28;
+        private const int OFFSET_PROTOCOLS = 32;
+        private const int OFFSET_ARES_VERSION = 36;
+        private const int OFFSET_ARES_VERSION_NUM = 40;
+        private const int OFFSET_LIBIDN_VERSION = 44;
+
+        private readonly IntPtr m_pVersionInfoData;
+
+        internal CurlVersionInfoData(CurlVersion ver)
+        {
+            m_pVersionInfoData = NativeMethods.curl_version_info(ver);
+        }
+#if USE_LIBCURLSHIM
+        /// <summary>
+        ///     Age of this struct, depending on how recent the linked-in
+        ///     <c>libcurl</c> is, as a <see cref="CurlVersion" />.
+        /// </summary>
+        public CurlVersion Age
+        {
+            get { return (CurlVersion) NativeMethods.curl_shim_get_version_int_value(m_pVersionInfoData, OFFSET_AGE); }
+        }
+
+        /// <summary>
+        ///     Get the internal cURL version, as a <c>string</c>.
+        /// </summary>
+        public string Version
+        {
+            get
+            {
+                return Marshal.PtrToStringAnsi(
+                    NativeMethods.curl_shim_get_version_char_ptr(m_pVersionInfoData, OFFSET_VERSION));
+            }
+        }
+
+        /// <summary>
+        ///     Get the internal cURL version number, a A 24-bit number created
+        ///     like this: [8 bits major number] | [8 bits minor number] | [8
+        ///     bits patch number]. For example, Version 7.12.2 is <c>0x070C02</c>.
+        /// </summary>
+        public int VersionNum
+        {
+            get { return NativeMethods.curl_shim_get_version_int_value(m_pVersionInfoData, OFFSET_VERSION_NUM); }
+        }
+
+        /// <summary>
+        ///     Get the host information on which the underlying cURL was built.
+        /// </summary>
+        public string Host
+        {
+            get
+            {
+                return
+                    Marshal.PtrToStringAnsi(NativeMethods.curl_shim_get_version_char_ptr(m_pVersionInfoData, OFFSET_HOST));
+            }
+        }
+
+        /// <summary>
+        ///     Get a bitmask of features, containing bits or'd from the
+        ///     <see cref="CurlVersionFeatureBitmask" /> enumeration.
+        /// </summary>
+        public int Features
+        {
+            get { return NativeMethods.curl_shim_get_version_int_value(m_pVersionInfoData, OFFSET_FEATURES); }
+        }
+
+        /// <summary>
+        ///     Get the Ssl version, if it's linked in.
+        /// </summary>
+        public string SslVersion
+        {
+            get
+            {
+                return
+                    Marshal.PtrToStringAnsi(NativeMethods.curl_shim_get_version_char_ptr(m_pVersionInfoData,
+                        OFFSET_SSL_VERSION));
+            }
+        }
+
+        /// <summary>
+        ///     Get the Ssl version number, if Ssl is linked in.
+        /// </summary>
+        public int SSLVersionNum
+        {
+            get { return NativeMethods.curl_shim_get_version_int_value(m_pVersionInfoData, OFFSET_SSL_VERSION_NUM); }
+        }
+
+        /// <summary>
+        ///     Get the libz version, if libz is linked in.
+        /// </summary>
+        public string LibZVersion
+        {
+            get
+            {
+                return
+                    Marshal.PtrToStringAnsi(NativeMethods.curl_shim_get_version_char_ptr(m_pVersionInfoData,
+                        OFFSET_LIBZ_VERSION));
+            }
+        }
+
+        /// <summary>
+        ///     Get the names of the supported protocols.
+        /// </summary>
+        public string[] Protocols
+        {
+            get
+            {
+                var nProts = NativeMethods.curl_shim_get_number_of_protocols(
+                    m_pVersionInfoData, OFFSET_PROTOCOLS);
+                var aProts = new String[nProts];
+                for (var i = 0; i < nProts; i++)
+                {
+                    aProts[i] =
+                        Marshal.PtrToStringAnsi(NativeMethods.curl_shim_get_protocol_string(m_pVersionInfoData,
+                            OFFSET_PROTOCOLS, i));
+                }
+                return aProts;
+            }
+        }
+
+        /// <summary>
+        ///     Get the ARes version, if ARes is linked in.
+        /// </summary>
+        public string ARes
+        {
+            get
+            {
+                if (Age > CurlVersion.First)
+                {
+                    return
+                        Marshal.PtrToStringAnsi(NativeMethods.curl_shim_get_version_char_ptr(m_pVersionInfoData,
+                            OFFSET_ARES_VERSION));
+                }
+                return "n.a.";
+            }
+        }
+
+        /// <summary>
+        ///     Get the ARes version number, if ARes is linked in.
+        /// </summary>
+        public int AResNum
+        {
+            get
+            {
+                if (Age > CurlVersion.First)
+                {
+                    return NativeMethods.curl_shim_get_version_int_value(m_pVersionInfoData, OFFSET_ARES_VERSION_NUM);
+                }
+                return 0;
+            }
+        }
+
+        /// <summary>
+        ///     Get the libidn version, if libidn is linked in.
+        /// </summary>
+        public string LibIdn
+        {
+            get
+            {
+                if (Age > CurlVersion.Second)
+                {
+                    return
+                        Marshal.PtrToStringAnsi(NativeMethods.curl_shim_get_version_char_ptr(m_pVersionInfoData,
+                            OFFSET_LIBIDN_VERSION));
+                }
+                return "n.a.";
+            }
+        }
+#endif
+    }
+}

src/CurlSharp/Enums/CurlClosePolicy.cs

@@ -0,0 +1,46 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Contains values used to specify the order in which cached connections
+    ///     are closed. One of these is passed as the
+    ///     <see cref="CurlOption.ClosePolicy" /> option in a call
+    ///     to <see cref="CurlEasy.SetOpt" />
+    /// </summary>
+    public enum CurlClosePolicy
+    {
+        /// <summary>
+        ///     No close policy. Never use this.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     Close the oldest cached connections first.
+        /// </summary>
+        Oldest = 1,
+
+        /// <summary>
+        ///     Close the least recently used connections first.
+        /// </summary>
+        LeastRecentlyUsed = 2,
+
+        /// <summary>
+        ///     Close the connections with the least traffic first.
+        /// </summary>
+        LeastTraffic = 3,
+
+        /// <summary>
+        ///     Close the slowest connections first.
+        /// </summary>
+        Slowest = 4,
+
+        /// <summary>
+        ///     Currently unimplemented.
+        /// </summary>
+        Callback = 5,
+
+        /// <summary>
+        ///     End-of-enumeration marker; do not use in application code.
+        /// </summary>
+        Last = 6
+    };
+}

src/CurlSharp/Enums/CurlCode.cs

@@ -0,0 +1,403 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Status code returned from <see cref="CurlEasy" /> functions.
+    /// </summary>
+    public enum CurlCode
+    {
+        /// <summary>
+        ///     All fine. Proceed as usual.
+        /// </summary>
+        Ok = 0,
+
+        /// <summary>
+        ///     Aborted by callback. An internal callback returned "abort"
+        ///     to libcurl.
+        /// </summary>
+        AbortedByCallback = 42,
+
+        /// <summary>
+        ///     Internal error. A function was called in a bad order.
+        /// </summary>
+        BadCallingOrder = 44,
+
+        /// <summary>
+        ///     Unrecognized transfer encoding.
+        /// </summary>
+        BadContentEncoding = 61,
+
+        /// <summary>
+        ///     Attempting FTP resume beyond file size.
+        /// </summary>
+        BadDownloadResume = 36,
+
+        /// <summary>
+        ///     Internal error. A function was called with a bad parameter.
+        /// </summary>
+        BadFunctionArgument = 43,
+
+        /// <summary>
+        ///     Bad password entered. An error was signaled when the password was
+        ///     entered. This can also be the result of a "bad password" returned
+        ///     from a specified password callback.
+        /// </summary>
+        BadPasswordEntered = 46,
+
+        /// <summary>
+        ///     Failed to connect to host or proxy.
+        /// </summary>
+        CouldntConnect = 7,
+
+        /// <summary>
+        ///     Couldn't resolve host. The given remote host was not resolved.
+        /// </summary>
+        CouldntResolveHost = 6,
+
+        /// <summary>
+        ///     Couldn't resolve proxy. The given proxy host could not be resolved.
+        /// </summary>
+        CouldntResolveProxy = 5,
+
+        /// <summary>
+        ///     Very early initialization code failed. This is likely to be an
+        ///     internal error or problem.
+        /// </summary>
+        FailedInit = 2,
+
+        /// <summary>
+        ///     Maximum file size exceeded.
+        /// </summary>
+        FilesizeExceeded = 63,
+
+        /// <summary>
+        ///     A file given with FILE:// couldn't be opened. Most likely
+        ///     because the file path doesn't identify an existing file. Did
+        ///     you check file permissions?
+        /// </summary>
+        FileCouldntReadFile = 37,
+
+        /// <summary>
+        ///     We were denied access when trying to login to an FTP server or
+        ///     when trying to change working directory to the one given in the URL.
+        /// </summary>
+        FtpAccessDenied = 9,
+
+        /// <summary>
+        ///     An internal failure to lookup the host used for the new
+        ///     connection.
+        /// </summary>
+        FtpCantGetHost = 15,
+
+        /// <summary>
+        ///     A bad return code on either PASV or EPSV was sent by the FTP
+        ///     server, preventing libcurl from being able to continue.
+        /// </summary>
+        FtpCantReconnect = 16,
+
+        /// <summary>
+        ///     The FTP SIZE command returned error. SIZE is not a kosher FTP
+        ///     command, it is an extension and not all servers support it. This
+        ///     is not a surprising error.
+        /// </summary>
+        FtpCouldntGetSize = 32,
+
+        /// <summary>
+        ///     This was either a weird reply to a 'RETR' command or a zero byte
+        ///     transfer complete.
+        /// </summary>
+        FtpCouldntRetrFile = 19,
+
+        /// <summary>
+        ///     libcurl failed to set ASCII transfer type (TYPE A).
+        /// </summary>
+        FtpCouldntSetAscii = 29,
+
+        /// <summary>
+        ///     Received an error when trying to set the transfer mode to binary.
+        /// </summary>
+        FtpCouldntSetBinary = 17,
+
+        /// <summary>
+        ///     FTP couldn't STOR file. The server denied the STOR operation.
+        ///     The error buffer usually contains the server's explanation to this.
+        /// </summary>
+        FtpCouldntStorFile = 25,
+
+        /// <summary>
+        ///     The FTP REST command returned error. This should never happen
+        ///     if the server is sane.
+        /// </summary>
+        FtpCouldntUseRest = 31,
+
+        /// <summary>
+        ///     The FTP PORT command returned error. This mostly happen when
+        ///     you haven't specified a good enough address for libcurl to use.
+        ///     See <see cref="CurlOption.FtpPort" />.
+        /// </summary>
+        FtpPortFailed = 30,
+
+        /// <summary>
+        ///     When sending custom "QUOTE" commands to the remote server, one
+        ///     of the commands returned an error code that was 400 or higher.
+        /// </summary>
+        FtpQuoteError = 21,
+
+        /// <summary>
+        ///     Requested FTP Ssl level failed.
+        /// </summary>
+        FtpSslFailed = 64,
+
+        /// <summary>
+        ///     The FTP server rejected access to the server after the password
+        ///     was sent to it. It might be because the username and/or the
+        ///     password were incorrect or just that the server is not allowing
+        ///     you access for the moment etc.
+        /// </summary>
+        FtpUserPasswordIncorrect = 10,
+
+        /// <summary>
+        ///     FTP servers return a 227-line as a response to a PASV command.
+        ///     If libcurl fails to parse that line, this return code is
+        ///     passed back.
+        /// </summary>
+        FtpWeird227Format = 14,
+
+        /// <summary>
+        ///     After having sent the FTP password to the server, libcurl expects
+        ///     a proper reply. This error code indicates that an unexpected code
+        ///     was returned.
+        /// </summary>
+        FtpWeirdPassReply = 11,
+
+        /// <summary>
+        ///     libcurl failed to get a sensible result back from the server as
+        ///     a response to either a PASV or a EPSV command. The server is flawed.
+        /// </summary>
+        FtpWeirdPasvReply = 13,
+
+        /// <summary>
+        ///     After connecting to an FTP server, libcurl expects to get a
+        ///     certain reply back. This error code implies that it got a strange
+        ///     or bad reply. The given remote server is probably not an
+        ///     OK FTP server.
+        /// </summary>
+        FtpWeirdServerReply = 8,
+
+        /// <summary>
+        ///     After having sent user name to the FTP server, libcurl expects a
+        ///     proper reply. This error code indicates that an unexpected code
+        ///     was returned.
+        /// </summary>
+        FtpWeirdUserReply = 12,
+
+        /// <summary>
+        ///     After a completed file transfer, the FTP server did not respond a
+        ///     proper "transfer successful" code.
+        /// </summary>
+        FtpWriteError = 20,
+
+        /// <summary>
+        ///     Function not found. A required LDAP function was not found.
+        /// </summary>
+        FunctionNotFound = 41,
+
+        /// <summary>
+        ///     Nothing was returned from the server, and under the circumstances,
+        ///     getting nothing is considered an error.
+        /// </summary>
+        GotNothing = 52,
+
+        /// <summary>
+        ///     This is an odd error that mainly occurs due to internal confusion.
+        /// </summary>
+        HttpPostError = 34,
+
+        /// <summary>
+        ///     The HTTP server does not support or accept range requests.
+        /// </summary>
+        HttpRangeError = 33,
+
+        /// <summary>
+        ///     This is returned if <see cref="CurlOption.FailOnError" />
+        ///     is set TRUE and the HTTP server returns an error code that
+        ///     is >= 400.
+        /// </summary>
+        HttpReturnedError = 22,
+
+        /// <summary>
+        ///     Interface error. A specified outgoing interface could not be
+        ///     used. Set which interface to use for outgoing connections'
+        ///     source IP address with <see cref="CurlOption.Interface" />.
+        /// </summary>
+        InterfaceFailed = 45,
+
+        /// <summary>
+        ///     End-of-enumeration marker; do not use in client applications.
+        /// </summary>
+        Last = 67,
+
+        /// <summary>
+        ///     LDAP cannot bind. LDAP bind operation failed.
+        /// </summary>
+        LdapCannotBind = 38,
+
+        /// <summary>
+        ///     Invalid LDAP URL.
+        /// </summary>
+        LdapInvalidUrl = 62,
+
+        /// <summary>
+        ///     LDAP search failed.
+        /// </summary>
+        LdapSearchFailed = 39,
+
+        /// <summary>
+        ///     Library not found. The LDAP library was not found.
+        /// </summary>
+        LibraryNotFound = 40,
+
+        /// <summary>
+        ///     Malformat user. User name badly specified. *Not currently used*
+        /// </summary>
+        MalformatUser = 24,
+
+        /// <summary>
+        ///     This is not an error. This used to be another error code in an
+        ///     old libcurl version and is currently unused.
+        /// </summary>
+        Obsolete = 50,
+
+        /// <summary>
+        ///     Operation timeout. The specified time-out period was reached
+        ///     according to the conditions.
+        /// </summary>
+        OperationTimeouted = 28,
+
+        /// <summary>
+        ///     Out of memory. A memory allocation request failed. This is serious
+        ///     badness and things are severely messed up if this ever occurs.
+        /// </summary>
+        OutOfMemory = 27,
+
+        /// <summary>
+        ///     A file transfer was shorter or larger than expected. This
+        ///     happens when the server first reports an expected transfer size,
+        ///     and then delivers data that doesn't match the previously
+        ///     given size.
+        /// </summary>
+        PartialFile = 18,
+
+        /// <summary>
+        ///     There was a problem reading a local file or an error returned by
+        ///     the read callback.
+        /// </summary>
+        ReadError = 26,
+
+        /// <summary>
+        ///     Failure with receiving network data.
+        /// </summary>
+        RecvError = 56,
+
+        /// <summary>
+        ///     Failed sending network data.
+        /// </summary>
+        SendError = 55,
+
+        /// <summary>
+        ///     Sending the data requires a rewind that failed.
+        /// </summary>
+        SendFailRewind = 65,
+
+        /// <summary>
+        ///     CurlShare is in use.
+        /// </summary>
+        ShareInUse = 57,
+
+        /// <summary>
+        ///     Problem with the CA cert (path? access rights?)
+        /// </summary>
+        SslCaCert = 60,
+
+        /// <summary>
+        ///     There's a problem with the local client certificate.
+        /// </summary>
+        SslCertProblem = 58,
+
+        /// <summary>
+        ///     Couldn't use specified cipher.
+        /// </summary>
+        SslCipher = 59,
+
+        /// <summary>
+        ///     A problem occurred somewhere in the Ssl/TLS handshake. You really
+        ///     want to use the <see cref="CurlEasy.CurlDebugCallback" /> delegate and read
+        ///     the message there as it pinpoints the problem slightly more. It
+        ///     could be certificates (file formats, paths, permissions),
+        ///     passwords, and others.
+        /// </summary>
+        SslConnectError = 35,
+
+        /// <summary>
+        ///     Failed to initialize Ssl engine.
+        /// </summary>
+        SslEngineInitFailed = 66,
+
+        /// <summary>
+        ///     The specified crypto engine wasn't found.
+        /// </summary>
+        SslEngineNotFound = 53,
+
+        /// <summary>
+        ///     Failed setting the selected Ssl crypto engine as default!
+        /// </summary>
+        SslEngineSetFailed = 54,
+
+        /// <summary>
+        ///     The remote server's Ssl certificate was deemed not OK.
+        /// </summary>
+        SslPeerCertificate = 51,
+
+        /// <summary>
+        ///     A telnet option string was improperly formatted.
+        /// </summary>
+        TelnetOptionSyntax = 49,
+
+        /// <summary>
+        ///     Too many redirects. When following redirects, libcurl hit the
+        ///     maximum amount. Set your limit with
+        ///     <see cref="CurlOption.MaxRedirs" />.
+        /// </summary>
+        TooManyRedirects = 47,
+
+        /// <summary>
+        ///     An option set with <see cref="CurlOption.TelnetOptions" />
+        ///     was not recognized/known. Refer to the appropriate documentation.
+        /// </summary>
+        UnknownTelnetOption = 48,
+
+        /// <summary>
+        ///     The URL you passed to libcurl used a protocol that this libcurl
+        ///     does not support. The support might be a compile-time option that
+        ///     wasn't used, it can be a misspelled protocol string or just a
+        ///     protocol libcurl has no code for.
+        /// </summary>
+        UnsupportedProtocol = 1,
+
+        /// <summary>
+        ///     The URL was not properly formatted.
+        /// </summary>
+        UrlMalformat = 3,
+
+        /// <summary>
+        ///     URL user malformatted. The user-part of the URL syntax was not
+        ///     correct.
+        /// </summary>
+        UrlMalformatUser = 4,
+
+        /// <summary>
+        ///     An error occurred when writing received data to a local file,
+        ///     or an error was returned to libcurl from a write callback.
+        /// </summary>
+        WriteError = 23,
+    };
+}

src/CurlSharp/Enums/CurlFormCode.cs

@@ -0,0 +1,76 @@
+/***************************************************************************
+ *
+ * Project: libcurl.NET
+ *
+ * Copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
+ *
+ * This software is licensed as described in the file LICENSE, which you
+ * should have received as part of this distribution.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of this Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the LICENSE file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+ * ANY KIND, either express or implied.
+ *
+ * $Id: Enums.cs,v 1.1 2005/02/17 22:47:25 jeffreyphillips Exp $
+ **************************************************************************/
+
+namespace CurlSharp
+{
+    /// <summary>
+    ///     One of these is returned by <see cref="CurlHttpMultiPartForm.AddSection" />.
+    /// </summary>
+    public enum CurlFormCode
+    {
+        /// <summary>
+        ///     The section was added properly.
+        /// </summary>
+        Ok = 0,
+
+        /// <summary>
+        ///     Out-of-memory when adding the section.
+        /// </summary>
+        Memory = 1,
+
+        /// <summary>
+        ///     Invalid attempt to add the same option more than once to a
+        ///     section.
+        /// </summary>
+        OptionTwice = 2,
+
+        /// <summary>
+        ///     Invalid attempt to pass a <c>null</c> string or byte array in
+        ///     one of the arguments.
+        /// </summary>
+        Null = 3,
+
+        /// <summary>
+        ///     Invalid attempt to pass an unrecognized option in one of the
+        ///     arguments.
+        /// </summary>
+        UnknownOption = 4,
+
+        /// <summary>
+        ///     Incomplete argument lists.
+        /// </summary>
+        Incomplete = 5,
+
+        /// <summary>
+        ///     Invalid attempt to provide a nested <c>Array</c>.
+        /// </summary>
+        IllegalArray = 6,
+
+        /// <summary>
+        ///     This will not be returned so long as HTTP is enabled, which
+        ///     it always is in libcurl.NET.
+        /// </summary>
+        Disabled = 7,
+
+        /// <summary>
+        ///     End-of-enumeration marker; do not use in application code.
+        /// </summary>
+        Last = 8
+    };
+}

src/CurlSharp/Enums/CurlFormOption.cs

@@ -0,0 +1,142 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     These are options available to build a multi-part form section
+    ///     in a call to <see cref="CurlHttpMultiPartForm.AddSection" />
+    /// </summary>
+    public enum CurlFormOption
+    {
+        /// <summary>
+        ///     Another possibility to send options to
+        ///     <see cref="CurlHttpMultiPartForm.AddSection" /> is this option, that
+        ///     passes a <see cref="CurlForms" /> array reference as its value.
+        ///     Each <see cref="CurlForms" /> array element has a
+        ///     <see cref="CurlFormOption" /> and a <c>string</c>. All available
+        ///     options can be used in an array, except the <c>Array</c>
+        ///     option itself! The last argument in such an array must always be
+        ///     <c>End</c>.
+        /// </summary>
+        Array = 8,
+
+        /// <summary>
+        ///     Followed by a <c>string</c>, tells libcurl that a buffer is to be
+        ///     used to upload data instead of using a file.
+        /// </summary>
+        Buffer = 11,
+
+        /// <summary>
+        ///     Followed by an <c>int</c> with the size of the
+        ///     <c>BufferPtr</c> byte array, tells libcurl the length of
+        ///     the data to upload.
+        /// </summary>
+        BufferLength = 13,
+
+        /// <summary>
+        ///     Followed by a <c>byte[]</c> array, tells libcurl the address of
+        ///     the buffer containing data to upload (as indicated with
+        ///     <c>Buffer</c>). You must also use
+        ///     <c>BufferLength</c> to set the length of the buffer area.
+        /// </summary>
+        BufferPtr = 12,
+
+        /// <summary>
+        ///     Specifies extra headers for the form POST section. This takes an
+        ///     <see cref="CurlSlist" /> prepared in the usual way using
+        ///     <see cref="CurlSlist.Append" /> and appends the list of headers to
+        ///     those libcurl automatically generates.
+        /// </summary>
+        ContentHeader = 15,
+
+        /// <summary>
+        ///     Followed by an <c>int</c> setting the length of the contents.
+        /// </summary>
+        ContentsLength = 6,
+
+        /// <summary>
+        ///     Followed by a <c>string</c> with a content-type will make cURL
+        ///     use this given content-type for this file upload part, possibly
+        ///     instead of an internally chosen one.
+        /// </summary>
+        ContentType = 14,
+
+        /// <summary>
+        ///     Followed by a <c>string</c> is used for the contents of this part, the
+        ///     actual data to send away. If you'd like it to contain zero bytes,
+        ///     you need to set the length of the name with
+        ///     <c>ContentsLength</c>.
+        /// </summary>
+        CopyContents = 4,
+
+        /// <summary>
+        ///     Followed by a <c>string</c> used to set the name of this part.
+        ///     If you'd like it to contain zero bytes, you need to set the
+        ///     length of the name with <c>NameLength</c>.
+        /// </summary>
+        CopyName = 1,
+
+        /// <summary>
+        ///     This should be the last argument to a call to
+        ///     <see cref="CurlHttpMultiPartForm.AddSection" />.
+        /// </summary>
+        End = 17,
+
+        /// <summary>
+        ///     Followed by a file name, makes this part a file upload part. It
+        ///     sets the file name field to the actual file name used here,
+        ///     it gets the contents of the file and passes as data and sets the
+        ///     content-type if the given file match one of the new internally
+        ///     known file extension. For <c>File</c> the user may send
+        ///     one or more files in one part by providing multiple <c>File</c>
+        ///     arguments each followed by the filename (and each <c>File</c>
+        ///     is allowed to have a <c>ContentType</c>).
+        /// </summary>
+        File = 10,
+
+        /// <summary>
+        ///     Followed by a file name, and does the file read: the contents
+        ///     will be used in as data in this part.
+        /// </summary>
+        FileContent = 7,
+
+        /// <summary>
+        ///     Followed by a <c>string</c> file name, will make libcurl use the
+        ///     given name in the file upload part, instead of the actual file
+        ///     name given to <c>File</c>.
+        /// </summary>
+        Filename = 16,
+
+        /// <summary>
+        ///     Followed by an <c>int</c> setting the length of the name.
+        /// </summary>
+        NameLength = 3,
+
+        /// <summary>
+        ///     Not used.
+        /// </summary>
+        Nothing = 0,
+
+        /// <summary>
+        ///     No longer used.
+        /// </summary>
+        Obsolete = 9,
+
+        /// <summary>
+        ///     No longer used.
+        /// </summary>
+        Obsolete2 = 18,
+
+        /// <summary>
+        ///     Followed by a <c>byte[]</c> used for the contents of this part.
+        ///     If you'd like it to contain zero bytes, you need to set the
+        ///     length of the name with <c>ContentsLength</c>.
+        /// </summary>
+        PtrContents = 5,
+
+        /// <summary>
+        ///     Followed by a <c>byte[]</c> used for the name of this part.
+        ///     If you'd like it to contain zero bytes, you need to set the
+        ///     length of the name with <c>NameLength</c>.
+        /// </summary>
+        PtrName = 2
+    };
+}

src/CurlSharp/Enums/CurlFtpAuth.cs

@@ -0,0 +1,31 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     This enumeration contains values used to specify the FTP Ssl
+    ///     authorization level using the
+    ///     <see cref="CurlOption.FtpSslAuth" /> option when calling
+    ///     <see cref="CurlEasy.SetOpt" />
+    /// </summary>
+    public enum CurlFtpAuth
+    {
+        /// <summary>
+        ///     Let <c>libcurl</c> decide on the authorization scheme.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        ///     Use "AUTH Ssl".
+        /// </summary>
+        SSL = 1,
+
+        /// <summary>
+        ///     Use "AUTH TLS".
+        /// </summary>
+        TLS = 2,
+
+        /// <summary>
+        ///     End-of-enumeration marker. Do not use in a client application.
+        /// </summary>
+        Last = 3
+    };
+}

src/CurlSharp/Enums/CurlFtpSsl.cs

@@ -0,0 +1,37 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     This enumeration contains values used to specify the FTP Ssl level
+    ///     using the <see cref="CurlOption.FtpSsl" /> option when calling
+    ///     <see cref="CurlEasy.SetOpt" />
+    /// </summary>
+    public enum CurlFtpSsl
+    {
+        /// <summary>
+        ///     Don't attempt to use Ssl.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     Try using Ssl, proceed as normal otherwise.
+        /// </summary>
+        Try = 1,
+
+        /// <summary>
+        ///     Require Ssl for the control connection or fail with
+        ///     <see cref="CurlCode.FtpSslFailed" />.
+        /// </summary>
+        Control = 2,
+
+        /// <summary>
+        ///     Require Ssl for all communication or fail with
+        ///     <see cref="CurlCode.FtpSslFailed" />.
+        /// </summary>
+        All = 3,
+
+        /// <summary>
+        ///     End-of-enumeration marker. Do not use in a client application.
+        /// </summary>
+        Last = 4
+    };
+}

src/CurlSharp/Enums/CurlHttpAuth.cs

@@ -0,0 +1,65 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     This enumeration contains values used to specify the HTTP authentication
+    ///     when using the <see cref="CurlOption.HttpAuth" /> option when
+    ///     calling <see cref="CurlEasy.SetOpt" />
+    /// </summary>
+    public enum CurlHttpAuth
+    {
+        /// <summary>
+        ///     No authentication.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     HTTP Basic authentication. This is the default choice, and the
+        ///     only method that is in wide-spread use and supported virtually
+        ///     everywhere. This is sending the user name and password over the
+        ///     network in plain text, easily captured by others.
+        /// </summary>
+        Basic = 1,
+
+        /// <summary>
+        ///     HTTP Digest authentication. Digest authentication is defined
+        ///     in RFC2617 and is a more secure way to do authentication over
+        ///     public networks than the regular old-fashioned Basic method.
+        /// </summary>
+        Digest = 2,
+
+        /// <summary>
+        ///     HTTP GSS-Negotiate authentication. The GSS-Negotiate (also known
+        ///     as plain "Negotiate") method was designed by Microsoft and is
+        ///     used in their web applications. It is primarily meant as a
+        ///     support for Kerberos5 authentication but may be also used along
+        ///     with another authentication methods. For more information see IETF
+        ///     draft draft-brezak-spnego-http-04.txt.
+        ///     <note>
+        ///         You need to use a version of libcurl.NET built with a suitable
+        ///         GSS-API library for this to work. This is not currently standard.
+        ///     </note>
+        /// </summary>
+        GssNegotiate = 4,
+
+        /// <summary>
+        ///     HTTP Ntlm authentication. A proprietary protocol invented and
+        ///     used by Microsoft. It uses a challenge-response and hash concept
+        ///     similar to Digest, to prevent the password from being eavesdropped.
+        /// </summary>
+        Ntlm = 8,
+
+        /// <summary>
+        ///     This is a convenience macro that sets all bits and thus makes
+        ///     libcurl pick any it finds suitable. libcurl will automatically
+        ///     select the one it finds most secure.
+        /// </summary>
+        Any = 15, // ~0
+
+        /// <summary>
+        ///     This is a convenience macro that sets all bits except Basic
+        ///     and thus makes libcurl pick any it finds suitable. libcurl
+        ///     will automatically select the one it finds most secure.
+        /// </summary>
+        AnySafe = 14 // ~Basic
+    };
+}

src/CurlSharp/Enums/CurlHttpVersion.cs

@@ -0,0 +1,31 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Contains values used to specify the HTTP version level when using
+    ///     the <see cref="CurlOption.HttpVersion" /> option in a call
+    ///     to <see cref="CurlEasy.SetOpt" />
+    /// </summary>
+    public enum CurlHttpVersion
+    {
+        /// <summary>
+        ///     We don't care about what version the library uses. libcurl will
+        ///     use whatever it thinks fit.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     Enforce HTTP 1.0 requests.
+        /// </summary>
+        Http1_0 = 1,
+
+        /// <summary>
+        ///     Enforce HTTP 1.1 requests.
+        /// </summary>
+        Http1_1 = 2,
+
+        /// <summary>
+        ///     Last entry in enumeration; do not use in application code.
+        /// </summary>
+        Last = 3
+    };
+}

src/CurlSharp/Enums/CurlInfo.cs

@@ -0,0 +1,222 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     This enumeration is used to extract information associated with an
+    ///     <see cref="CurlEasy" /> transfer. Specifically, a member of this
+    ///     enumeration is passed as the first argument to
+    ///     CurlEasy.GetInfo specifying the item to retrieve in the
+    ///     second argument, which is a reference to an <c>int</c>, a
+    ///     <c>double</c>, a <c>string</c>, a <c>DateTime</c> or an <c>object</c>.
+    /// </summary>
+    public enum CurlInfo
+    {
+        /// <summary>
+        ///     The second argument receives the elapsed time, as a <c>double</c>,
+        ///     in seconds, from the start until the connect to the remote host
+        ///     (or proxy) was completed.
+        /// </summary>
+        ConnectTime = 0x300005,
+
+        /// <summary>
+        ///     The second argument receives, as a <c>double</c>, the content-length
+        ///     of the download. This is the value read from the Content-Length: field.
+        /// </summary>
+        ContentLengthDownload = 0x30000F,
+
+        /// <summary>
+        ///     The second argument receives, as a <c>double</c>, the specified size
+        ///     of the upload.
+        /// </summary>
+        ContentLengthUpload = 0x300010,
+
+        /// <summary>
+        ///     The second argument receives, as a <c>string</c>, the content-type of
+        ///     the downloaded object. This is the value read from the Content-Type:
+        ///     field. If you get <c>null</c>, it means that the server didn't
+        ///     send a valid Content-Type header or that the protocol used
+        ///     doesn't support this.
+        /// </summary>
+        ContentType = 0x100012,
+
+        /// <summary>
+        ///     The second argument receives, as a <c>string</c>, the last
+        ///     used effective URL.
+        /// </summary>
+        EffectiveUrl = 0x100001,
+
+        /// <summary>
+        ///     The second argument receives, as a <c>long</c>, the remote time
+        ///     of the retrieved document. You should construct a <c>DateTime</c>
+        ///     from this value, as shown in the <c>InfoDemo</c> sample. If you
+        ///     get a date in the distant
+        ///     past, it can be because of many reasons (unknown, the server
+        ///     hides it or the server doesn't support the command that tells
+        ///     document time etc) and the time of the document is unknown. Note
+        ///     that you must tell the server to collect this information before
+        ///     the transfer is made, by using the
+        ///     <see cref="CurlOption.Filetime" /> option to
+        ///     <see cref="CurlEasy.SetOpt" />. (Added in 7.5)
+        /// </summary>
+        Filetime = 0x20000E,
+
+        /// <summary>
+        ///     The second argument receives an <c>int</c> specifying the total size
+        ///     of all the headers received.
+        /// </summary>
+        HeaderSize = 0x20000B,
+
+        /// <summary>
+        ///     The second argument receives, as an <c>int</c>, a bitmask indicating
+        ///     the authentication method(s) available. The meaning of the bits is
+        ///     explained in the documentation of
+        ///     <see cref="CurlOption.HttpAuth" />. (Added in 7.10.8)
+        /// </summary>
+        HttpAuthAvail = 0x200017,
+
+        /// <summary>
+        ///     The second argument receives an <c>int</c> indicating the numeric
+        ///     connect code for the HTTP request.
+        /// </summary>
+        HttpConnectCode = 0x200016,
+
+        /// <summary>
+        ///     End-of-enumeration marker; do not use in client applications.
+        /// </summary>
+        LastOne = 0x1C,
+
+        /// <summary>
+        ///     The second argument receives, as a <c>double</c>, the time, in
+        ///     seconds it took from the start until the name resolving was
+        ///     completed.
+        /// </summary>
+        NameLookupTime = 0x300004,
+
+        /// <summary>
+        ///     Never used.
+        /// </summary>
+        None = 0x0,
+
+        /// <summary>
+        ///     The second argument receives an <c>int</c> indicating the
+        ///     number of current connections. (Added in 7.13.0)
+        /// </summary>
+        NumConnects = 0x20001A,
+
+        /// <summary>
+        ///     The second argument receives an <c>int</c> indicating the operating
+        ///     system error number: <c>_errro</c> or <c>GetLastError()</c>,
+        ///     depending on the platform. (Added in 7.12.2)
+        /// </summary>
+        OsErrno = 0x200019,
+
+        /// <summary>
+        ///     The second argument receives, as a <c>double</c>, the time, in
+        ///     seconds, it took from the start until the file transfer is just about
+        ///     to begin. This includes all pre-transfer commands and negotiations
+        ///     that are specific to the particular protocol(s) involved.
+        /// </summary>
+        PreTransferTime = 0x300006,
+
+        /// <summary>
+        ///     The second argument receives a reference to the private data
+        ///     associated with the <see cref="CurlEasy" /> object (set with the
+        ///     <see cref="CurlOption.Private" /> option to
+        ///     <see cref="CurlEasy.SetOpt" />. (Added in 7.10.3)
+        /// </summary>
+        Private = 0x100015,
+
+        /// <summary>
+        ///     The second argument receives, as an <c>int</c>, a bitmask
+        ///     indicating the authentication method(s) available for your
+        ///     proxy authentication. This will be a bitmask of
+        ///     <see cref="CurlHttpAuth" /> enumeration constants.
+        ///     (Added in 7.10.8)
+        /// </summary>
+        ProxyAuthAvail = 0x200018,
+
+        /// <summary>
+        ///     The second argument receives an <c>int</c> indicating the total
+        ///     number of redirections that were actually followed. (Added in 7.9.7)
+        /// </summary>
+        RedirectCount = 0x200014,
+
+        /// <summary>
+        ///     The second argument receives, as a <c>double</c>, the total time, in
+        ///     seconds, for all redirection steps include name lookup, connect,
+        ///     pretransfer and transfer before final transaction was started.
+        ///     <c>RedirectTime</c> contains the complete execution
+        ///     time for multiple redirections. (Added in 7.9.7)
+        /// </summary>
+        RedirectTime = 0x300013,
+
+        /// <summary>
+        ///     The second argument receives an <c>int</c> containing the total size
+        ///     of the issued requests. This is so far only for HTTP requests. Note
+        ///     that this may be more than one request if
+        ///     <see cref="CurlOption.FollowLocation" /> is <c>true</c>.
+        /// </summary>
+        RequestSize = 0x20000C,
+
+        /// <summary>
+        ///     The second argument receives an <c>int</c> with the last received HTTP
+        ///     or FTP code. This option was known as <c>CURLINFO_HTTP_CODE</c> in
+        ///     libcurl 7.10.7 and earlier.
+        /// </summary>
+        ResponseCode = 0x200002,
+
+        /// <summary>
+        ///     The second argument receives a <c>double</c> with the total amount of
+        ///     bytes that were downloaded. The amount is only for the latest transfer
+        ///     and will be reset again for each new transfer.
+        /// </summary>
+        SizeDownload = 0x300008,
+
+        /// <summary>
+        ///     The second argument receives a <c>double</c> with the total amount
+        ///     of bytes that were uploaded.
+        /// </summary>
+        SizeUpload = 0x300007,
+
+        /// <summary>
+        ///     The second argument receives a <c>double</c> with the average
+        ///     download speed that cURL measured for the complete download.
+        /// </summary>
+        SpeedDownload = 0x300009,
+
+        /// <summary>
+        ///     The second argument receives a <c>double</c> with the average
+        ///     upload speed that libcurl measured for the complete upload.
+        /// </summary>
+        SpeedUpload = 0x30000A,
+
+        /// <summary>
+        ///     The second argument receives an <see cref="CurlSlist" /> containing
+        ///     the names of the available Ssl engines.
+        /// </summary>
+        SslEngines = 0x40001B,
+
+        /// <summary>
+        ///     The second argument receives an <c>int</c> with the result of
+        ///     the certificate verification that was requested (using the
+        ///     <see cref="CurlOption.SslVerifyPeer" /> option in
+        ///     <see cref="CurlEasy.SetOpt" />.
+        /// </summary>
+        SslVerifyResult = 0x20000D,
+
+        /// <summary>
+        ///     The second argument receives a <c>double</c> specifying the time,
+        ///     in seconds, from the start until the first byte is just about to be
+        ///     transferred. This includes <c>PreTransferTime</c> and
+        ///     also the time the server needs to calculate the result.
+        /// </summary>
+        StartTransferTime = 0x300011,
+
+        /// <summary>
+        ///     The second argument receives a <c>double</c> indicating the total transaction
+        ///     time in seconds for the previous transfer. This time does not include
+        ///     the connect time, so if you want the complete operation time,
+        ///     you should add the <c>ConnectTime</c>.
+        /// </summary>
+        TotalTime = 0x300003,
+    };
+}

src/CurlSharp/Enums/CurlInfoType.cs

@@ -0,0 +1,50 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     A member of this enumeration is passed as the first parameter to the
+    ///     <see cref="CurlEasy.CurlDebugCallback" /> delegate to which libcurl passes
+    ///     debug messages.
+    /// </summary>
+    public enum CurlInfoType
+    {
+        /// <summary>
+        ///     The data is informational text.
+        /// </summary>
+        Text = 0,
+
+        /// <summary>
+        ///     The data is header (or header-like) data received from the peer.
+        /// </summary>
+        HeaderIn = 1,
+
+        /// <summary>
+        ///     The data is header (or header-like) data sent to the peer.
+        /// </summary>
+        HeaderOut = 2,
+
+        /// <summary>
+        ///     The data is protocol data received from the peer.
+        /// </summary>
+        DataIn = 3,
+
+        /// <summary>
+        ///     The data is protocol data sent to the peer.
+        /// </summary>
+        DataOut = 4,
+
+        /// <summary>
+        ///     The data is Ssl-related data sent to the peer.
+        /// </summary>
+        SslDataIn = 5,
+
+        /// <summary>
+        ///     The data is Ssl-related data received from the peer.
+        /// </summary>
+        SslDataOut = 6,
+
+        /// <summary>
+        ///     End of enumeration marker, don't use in a client application.
+        /// </summary>
+        End = 7
+    };
+}

src/CurlSharp/Enums/CurlInitFlag.cs

@@ -0,0 +1,34 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Contains values used to initialize libcurl internally. One of
+    ///     these is passed in the call to <see cref="Curl.GlobalInit" />.
+    /// </summary>
+    public enum CurlInitFlag
+    {
+        /// <summary>
+        ///     Initialise nothing extra. This sets no bit.
+        /// </summary>
+        Nothing = 0,
+
+        /// <summary>
+        ///     Initialize Ssl.
+        /// </summary>
+        Ssl = 1,
+
+        /// <summary>
+        ///     Initialize the Win32 socket libraries.
+        /// </summary>
+        Win32 = 2,
+
+        /// <summary>
+        ///     Initialize everything possible. This sets all known bits.
+        /// </summary>
+        All = 3,
+
+        /// <summary>
+        ///     Equivalent to <c>All</c>.
+        /// </summary>
+        Default = All
+    };
+}

src/CurlSharp/Enums/CurlIoCommand.cs

@@ -0,0 +1,27 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Your handler for the <see cref="CurlEasy.CurlIoctlCallback" />
+    ///     delegate is passed one of these values as its first parameter.
+    ///     Right now, the only supported value is
+    ///     <code>RestartRead</code>.
+    /// </summary>
+    public enum CurlIoCommand
+    {
+        /// <summary>
+        ///     No IOCTL operation; we should never see this.
+        /// </summary>
+        Nop = 0,
+
+        /// <summary>
+        ///     When this is sent, your callback may need to, for example,
+        ///     rewind a local file that is being sent via FTP.
+        /// </summary>
+        RestartRead = 1,
+
+        /// <summary>
+        ///     End of enumeration marker, don't use in a client application.
+        /// </summary>
+        Last = 2
+    }
+}

src/CurlSharp/Enums/CurlIoError.cs

@@ -0,0 +1,30 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Your handler for the <see cref="CurlEasy.CurlIoctlCallback" /> delegate
+    ///     should return a member of this enumeration.
+    /// </summary>
+    public enum CurlIoError
+    {
+        /// <summary>
+        ///     Indicate that the callback processed everything okay.
+        /// </summary>
+        Ok = 0,
+
+        /// <summary>
+        ///     Unknown command sent to callback. Right now, only
+        ///     <code>RestartRead</code> is supported.
+        /// </summary>
+        UnknownCommand = 1,
+
+        /// <summary>
+        ///     Indicate to libcurl that a restart failed.
+        /// </summary>
+        FailRestart = 2,
+
+        /// <summary>
+        ///     End of enumeration marker, don't use in a client application.
+        /// </summary>
+        Last = 3
+    }
+}

src/CurlSharp/Enums/CurlIpResolve.cs

@@ -0,0 +1,26 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     This enumeration contains values used to specify the IP resolution
+    ///     method when using the <see cref="CurlOption.IpResolve" />
+    ///     option in a call to <see cref="CurlEasy.SetOpt" />
+    /// </summary>
+    public enum CurlIpResolve
+    {
+        /// <summary>
+        ///     Default, resolves addresses to all IP versions that your system
+        ///     allows.
+        /// </summary>
+        Whatever = 0,
+
+        /// <summary>
+        ///     Resolve to ipv4 addresses.
+        /// </summary>
+        V4 = 1,
+
+        /// <summary>
+        ///     Resolve to ipv6 addresses.
+        /// </summary>
+        V6 = 2
+    };
+}

src/CurlSharp/Enums/CurlLockAccess.cs

@@ -0,0 +1,31 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Values containing the type of shared access requested when libcurl
+    ///     calls the <see cref="CurlShare.CurlShareLockCallback" /> delegate.
+    /// </summary>
+    public enum CurlLockAccess
+    {
+        /// <summary>
+        ///     Unspecified action; the delegate should never receive this.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     The delegate receives this call when libcurl is requesting
+        ///     read access to the shared resource.
+        /// </summary>
+        Shared = 1,
+
+        /// <summary>
+        ///     The delegate receives this call when libcurl is requesting
+        ///     write access to the shared resource.
+        /// </summary>
+        Single = 2,
+
+        /// <summary>
+        ///     End-of-enumeration marker; do not use in application code.
+        /// </summary>
+        Last = 3
+    };
+}

src/CurlSharp/Enums/CurlLockData.cs

@@ -0,0 +1,48 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Members of this enumeration should be passed to
+    ///     <see cref="CurlShare.SetOpt" /> when it is called with the
+    ///     <c>CurlShare</c> or <c>Unshare</c> options
+    ///     provided in the <see cref="CurlShareOption" /> enumeration.
+    /// </summary>
+    public enum CurlLockData
+    {
+        /// <summary>
+        ///     Not used.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     Used internally by libcurl.
+        /// </summary>
+        Share = 1,
+
+        /// <summary>
+        ///     Cookie data will be shared across the <see cref="CurlEasy" /> objects
+        ///     using this shared object.
+        /// </summary>
+        Cookie = 2,
+
+        /// <summary>
+        ///     Cached Dns hosts will be shared across the <see cref="CurlEasy" />
+        ///     objects using this shared object.
+        /// </summary>
+        Dns = 3,
+
+        /// <summary>
+        ///     Not supported yet.
+        /// </summary>
+        SslSession = 4,
+
+        /// <summary>
+        ///     Not supported yet.
+        /// </summary>
+        Connect = 5,
+
+        /// <summary>
+        ///     End-of-enumeration marker; do not use in application code.
+        /// </summary>
+        Last = 6
+    };
+}

src/CurlSharp/Enums/CurlMessage.cs

@@ -0,0 +1,25 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     The status code associated with an <see cref="CurlEasy" /> object in a
+    ///     <see cref="CurlMulti" /> operation. One of these is returned in response
+    ///     to reading the <see cref="CurlMultiInfo.Msg" /> property.
+    /// </summary>
+    public enum CurlMessage
+    {
+        /// <summary>
+        ///     First entry in the enumeration, not used.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     The associated <see cref="CurlEasy" /> object completed.
+        /// </summary>
+        Done = 1,
+
+        /// <summary>
+        ///     End-of-enumeration marker, not used.
+        /// </summary>
+        Last = 2
+    };
+}

src/CurlSharp/Enums/CurlMultiCode.cs

@@ -0,0 +1,46 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Contains return codes for many of the functions in the
+    ///     <see cref="CurlMulti" /> class.
+    /// </summary>
+    public enum CurlMultiCode
+    {
+        /// <summary>
+        ///     You should call <see cref="CurlMulti.Perform" /> again before calling
+        ///     <see cref="CurlMulti.Select" />.
+        /// </summary>
+        CallMultiPerform = -1,
+
+        /// <summary>
+        ///     The function succeded.
+        /// </summary>
+        Ok = 0,
+
+        /// <summary>
+        ///     The internal <see cref="CurlMulti" /> is bad.
+        /// </summary>
+        BadHandle = 1,
+
+        /// <summary>
+        ///     One of the <see cref="CurlEasy" /> handles associated with the
+        ///     <see cref="CurlMulti" /> object is bad.
+        /// </summary>
+        BadEasyHandle = 2,
+
+        /// <summary>
+        ///     Out of memory. This is a severe problem.
+        /// </summary>
+        OutOfMemory = 3,
+
+        /// <summary>
+        ///     Internal error deep within the libcurl library.
+        /// </summary>
+        InternalError = 4,
+
+        /// <summary>
+        ///     End-of-enumeration marker, not used.
+        /// </summary>
+        Last = 5
+    };
+}

src/CurlSharp/Enums/CurlNetrcOption.cs

@@ -0,0 +1,43 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Contains values used to specify the preference of libcurl between
+    ///     using user names and passwords from your ~/.netrc file, relative to
+    ///     user names and passwords in the URL supplied with
+    ///     <see cref="CurlOption.Url" />. This is passed when using
+    ///     the <see cref="CurlOption.Netrc" /> option in a call
+    ///     to <see cref="CurlEasy.SetOpt" />
+    /// </summary>
+    public enum CurlNetrcOption
+    {
+        /// <summary>
+        ///     The library will ignore the file and use only the information
+        ///     in the URL. This is the default.
+        /// </summary>
+        Ignored = 0,
+
+        /// <summary>
+        ///     The use of your ~/.netrc file is optional, and information in the
+        ///     URL is to be preferred. The file will be scanned with the host
+        ///     and user name (to find the password only) or with the host only,
+        ///     to find the first user name and password after that machine,
+        ///     which ever information is not specified in the URL.
+        ///     <para>
+        ///         Undefined values of the option will have this effect.
+        ///     </para>
+        /// </summary>
+        Optional = 1,
+
+        /// <summary>
+        ///     This value tells the library that use of the file is required,
+        ///     to ignore the information in the URL, and to search the file
+        ///     with the host only.
+        /// </summary>
+        Required = 2,
+
+        /// <summary>
+        ///     Last entry in enumeration; do not use in application code.
+        /// </summary>
+        Last = 3
+    };
+}

src/CurlSharp/Enums/CurlProxyType.cs

@@ -0,0 +1,27 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     This enumeration contains values used to specify the proxy type when
+    ///     using the <see cref="CurlOption.Proxy" /> option when calling
+    ///     <see cref="CurlEasy.SetOpt" />
+    /// </summary>
+    public enum CurlProxyType
+    {
+        /// <summary>
+        ///     Ordinary HTTP proxy.
+        /// </summary>
+        Http = 0,
+
+        /// <summary>
+        ///     Use if the proxy supports SOCKS4 user authentication. If you're
+        ///     unfamiliar with this, consult your network administrator.
+        /// </summary>
+        Socks4 = 4,
+
+        /// <summary>
+        ///     Use if the proxy supports SOCKS5 user authentication. If you're
+        ///     unfamiliar with this, consult your network administrator.
+        /// </summary>
+        Socks5 = 5
+    };
+}

src/CurlSharp/Enums/CurlShareCode.cs

@@ -0,0 +1,40 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Contains return codes from many of the functions in the
+    ///     <see cref="CurlShare" /> class.
+    /// </summary>
+    public enum CurlShareCode
+    {
+        /// <summary>
+        ///     The function succeeded.
+        /// </summary>
+        Ok = 0,
+
+        /// <summary>
+        ///     A bad option was passed to <see cref="CurlShare.SetOpt" />.
+        /// </summary>
+        BadOption = 1,
+
+        /// <summary>
+        ///     An attempt was made to pass an option to
+        ///     <see cref="CurlShare.SetOpt" /> while the CurlShare object is in use.
+        /// </summary>
+        InUse = 2,
+
+        /// <summary>
+        ///     The <see cref="CurlShare" /> object's internal handle is invalid.
+        /// </summary>
+        Invalid = 3,
+
+        /// <summary>
+        ///     Out of memory. This is a severe problem.
+        /// </summary>
+        NoMem = 4,
+
+        /// <summary>
+        ///     End-of-enumeration marker; do not use in application code.
+        /// </summary>
+        Last = 5
+    };
+}

src/CurlSharp/Enums/CurlShareOption.cs

@@ -0,0 +1,53 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     A member of this enumeration is passed to the function
+    ///     <see cref="CurlShare.SetOpt" /> to configure a <see cref="CurlShare" />
+    ///     transfer.
+    /// </summary>
+    public enum CurlShareOption
+    {
+        /// <summary>
+        ///     Start-of-enumeration; do not use in application code.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     The parameter, which should be a member of the
+        ///     <see cref="CurlLockData" /> enumeration, specifies a type of
+        ///     data that should be shared.
+        /// </summary>
+        Share = 1,
+
+        /// <summary>
+        ///     The parameter, which should be a member of the
+        ///     <see cref="CurlLockData" /> enumeration, specifies a type of
+        ///     data that should be unshared.
+        /// </summary>
+        Unshare = 2,
+
+        /// <summary>
+        ///     The parameter should be a reference to a
+        ///     <see cref="CurlShare.CurlShareLockCallback" /> delegate.
+        /// </summary>
+        LockFunction = 3,
+
+        /// <summary>
+        ///     The parameter should be a reference to a
+        ///     <see cref="CurlShare.CurlShareUnlockCallback" /> delegate.
+        /// </summary>
+        UnlockFunction = 4,
+
+        /// <summary>
+        ///     The parameter allows you to specify an object reference that
+        ///     will passed to the <see cref="CurlShare.CurlShareLockCallback" /> delegate and
+        ///     the <see cref="CurlShare.CurlShareUnlockCallback" /> delegate.
+        /// </summary>
+        UserData = 5,
+
+        /// <summary>
+        ///     End-of-enumeration; do not use in application code.
+        /// </summary>
+        Last = 6
+    };
+}

src/CurlSharp/Enums/CurlSslVersion.cs

@@ -0,0 +1,36 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Contains values used to specify the Ssl version level when using
+    ///     the <see cref="CurlOption.SslVersion" /> option in a call
+    ///     to <see cref="CurlEasy.SetOpt" />
+    /// </summary>
+    public enum CurlSslVersion
+    {
+        /// <summary>
+        ///     Use whatever version the Ssl library selects.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        ///     Use TLS version 1.
+        /// </summary>
+        Tlsv1 = 1,
+
+        /// <summary>
+        ///     Use Ssl version 2. This is not a good option unless it's the
+        ///     only version supported by the remote server.
+        /// </summary>
+        Sslv2 = 2,
+
+        /// <summary>
+        ///     Use Ssl version 3. This is a preferred option.
+        /// </summary>
+        Sslv3 = 3,
+
+        /// <summary>
+        ///     Last entry in enumeration; do not use in application code.
+        /// </summary>
+        Last = 4
+    };
+}

src/CurlSharp/Enums/CurlTimeCond.cs

@@ -0,0 +1,39 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     Contains values used to specify the time condition when using
+    ///     the <see cref="CurlOption.TimeCondition" /> option in a call
+    ///     to <see cref="CurlEasy.SetOpt" />
+    /// </summary>
+    public enum CurlTimeCond
+    {
+        /// <summary>
+        ///     Use no time condition.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///     The time condition is true if the resource has been modified
+        ///     since the date/time passed in
+        ///     <see cref="CurlOption.TimeValue" />.
+        /// </summary>
+        IfModSince = 1,
+
+        /// <summary>
+        ///     True if the resource has not been modified since the date/time
+        ///     passed in <see cref="CurlOption.TimeValue" />.
+        /// </summary>
+        IfUnmodSince = 2,
+
+        /// <summary>
+        ///     True if the resource's last modification date/time equals that
+        ///     passed in <see cref="CurlOption.TimeValue" />.
+        /// </summary>
+        LastMod = 3,
+
+        /// <summary>
+        ///     Last entry in enumeration; do not use in application code.
+        /// </summary>
+        Last = 4
+    };
+}

src/CurlSharp/Enums/CurlVersion.cs

@@ -0,0 +1,34 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     A member of this enumeration is passed to the function
+    ///     <see cref="Curl.GetVersionInfo" />
+    /// </summary>
+    public enum CurlVersion
+    {
+        /// <summary>
+        ///     Capabilities associated with the initial version of libcurl.
+        /// </summary>
+        First = 0,
+
+        /// <summary>
+        ///     Capabilities associated with the second version of libcurl.
+        /// </summary>
+        Second = 1,
+
+        /// <summary>
+        ///     Capabilities associated with the third version of libcurl.
+        /// </summary>
+        Third = 2,
+
+        /// <summary>
+        ///     Same as <c>Third</c>.
+        /// </summary>
+        Now = Third,
+
+        /// <summary>
+        ///     End-of-enumeration marker; do not use in application code.
+        /// </summary>
+        Last = 3
+    };
+}

src/CurlSharp/Enums/CurlVersionFeatureBitmask.cs

@@ -0,0 +1,71 @@
+namespace CurlSharp
+{
+    /// <summary>
+    ///     A bitmask of libcurl features OR'd together as the value of the
+    ///     property <see cref="CurlVersionInfoData.Features" />. The feature
+    ///     bits are summarized in the table below.
+    /// </summary>
+    public enum CurlVersionFeatureBitmask
+    {
+        /// <summary>
+        ///     Supports Ipv6.
+        /// </summary>
+        Ipv6 = 0x01,
+
+        /// <summary>
+        ///     Supports kerberos4 (when using FTP).
+        /// </summary>
+        Kerberos64 = 0x02,
+
+        /// <summary>
+        ///     Supports Ssl (HTTPS/FTPS).
+        /// </summary>
+        Ssl = 0x04,
+
+        /// <summary>
+        ///     Supports HTTP deflate using libz.
+        /// </summary>
+        LibZ = 0x08,
+
+        /// <summary>
+        ///     Supports HTTP Ntlm (added in 7.10.6).
+        /// </summary>
+        Ntlm = 0x10,
+
+        /// <summary>
+        ///     Supports HTTP GSS-Negotiate (added in 7.10.6).
+        /// </summary>
+        GssNegotiate = 0x20,
+
+        /// <summary>
+        ///     libcurl was built with extra debug capabilities built-in. This
+        ///     is mainly of interest for libcurl hackers. (added in 7.10.6)
+        /// </summary>
+        Debug = 0x40,
+
+        /// <summary>
+        ///     libcurl was built with support for asynchronous name lookups,
+        ///     which allows more exact timeouts (even on Windows) and less
+        ///     blocking when using the multi interface. (added in 7.10.7)
+        /// </summary>
+        AsynchDns = 0x80,
+
+        /// <summary>
+        ///     libcurl was built with support for Spnego authentication
+        ///     (Simple and Protected GSS-API Negotiation Mechanism, defined
+        ///     in RFC 2478.) (added in 7.10.8)
+        /// </summary>
+        Spnego = 0x100,
+
+        /// <summary>
+        ///     libcurl was built with support for large files.
+        /// </summary>
+        LargeFile = 0x200,
+
+        /// <summary>
+        ///     libcurl was built with support for IDNA, domain names with
+        ///     international letters.
+        /// </summary>
+        Idn = 0x400
+    };
+}

src/CurlSharp/NativeMethods.cs

@@ -0,0 +1,402 @@
+/***************************************************************************
+ *
+ * CurlS#arp
+ *
+ * Copyright (c) 2014 Dr. Masroor Ehsan (masroore@gmail.com)
+ * Portions copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
+ *
+ * This software is licensed as described in the file LICENSE, which you
+ * should have received as part of this distribution.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of this Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the LICENSE file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
+ * ANY KIND, either express or implied.
+ *
+ **************************************************************************/
+
+//#define USE_LIBCURLSHIM
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace CurlSharp
+{
+	/// <summary>
+	///     P/Invoke signatures.
+	/// </summary>
+	internal static unsafe class NativeMethods
+	{
+		#if WIN64
+        private const string CURL_LIB = "libcurl64.dll";
+
+
+
+
+
+#if USE_LIBCURLSHIM
+        private const string CURLSHIM_LIB = "libcurlshim64.dll";
+#endif
+		
+
+
+
+#else
+		#if LINUX
+		private const string CURL_LIB = "libcurl";
+		#else
+        private const string CURL_LIB = "libcurl.dll";
+
+
+
+
+
+#if USE_LIBCURLSHIM
+        private const string CURLSHIM_LIB = "libcurlshim.dll";
+#endif
+		#endif
+		#endif
+		#if !USE_LIBCURLSHIM
+		#if LINUX
+		private const string WINSOCK_LIB = "libc";
+		#else
+        private const string WINSOCK_LIB = "ws2_32.dll";
+#endif
+		#endif
+
+		// internal delegates from cURL
+
+		// libcurl imports
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlCode curl_global_init (int flags);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern void curl_global_cleanup ();
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+		internal static extern IntPtr curl_escape (String url, int length);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+		internal static extern IntPtr curl_unescape (String url, int length);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern void curl_free (IntPtr p);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern IntPtr curl_version ();
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern IntPtr curl_easy_init ();
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern void curl_easy_cleanup (IntPtr pCurl);
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+        internal delegate int _CurlGenericCallback (IntPtr ptr, int sz, int nmemb, IntPtr userdata);
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+        internal delegate int _CurlProgressCallback (
+            IntPtr extraData, double dlTotal, double dlNow, double ulTotal, double ulNow);
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+        internal delegate int _CurlDebugCallback (
+            IntPtr ptrCurl, CurlInfoType infoType, string message, int size, IntPtr ptrUserData);
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+        internal delegate int _CurlSslCtxCallback (IntPtr ctx, IntPtr parm);
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+        internal delegate CurlIoError _CurlIoctlCallback (CurlIoCommand cmd, IntPtr parm);
+
+		// curl_easy_setopt() overloads
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlCode curl_easy_setopt (IntPtr pCurl, CurlOption opt, IntPtr parm);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlCode curl_easy_setopt (IntPtr pCurl, CurlOption opt, string parm);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlCode curl_easy_setopt (IntPtr pCurl, CurlOption opt, byte[] parm);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlCode curl_easy_setopt (IntPtr pCurl, CurlOption opt, long parm);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlCode curl_easy_setopt (IntPtr pCurl, CurlOption opt, bool parm);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl, EntryPoint = "curl_easy_setopt")]
+		internal static extern CurlCode curl_easy_setopt_cb (IntPtr pCurl, CurlOption opt, _CurlGenericCallback parm);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl, EntryPoint = "curl_easy_setopt")]
+		internal static extern CurlCode curl_easy_setopt_cb (IntPtr pCurl, CurlOption opt, _CurlProgressCallback parm);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl, EntryPoint = "curl_easy_setopt")]
+		internal static extern CurlCode curl_easy_setopt_cb (IntPtr pCurl, CurlOption opt, _CurlDebugCallback parm);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl, EntryPoint = "curl_easy_setopt")]
+		internal static extern CurlCode curl_easy_setopt_cb (IntPtr pCurl, CurlOption opt, _CurlSslCtxCallback parm);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl, EntryPoint = "curl_easy_setopt")]
+		internal static extern CurlCode curl_easy_setopt_cb (IntPtr pCurl, CurlOption opt, _CurlIoctlCallback parm);
+
+		#if !USE_LIBCURLSHIM
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlMultiCode curl_multi_fdset (IntPtr pmulti,
+		                                                       [In, Out] ref fd_set read_fd_set,
+		                                                       [In, Out] ref fd_set write_fd_set,
+		                                                       [In, Out] ref fd_set exc_fd_set,
+		                                                       [In, Out] ref int max_fd);
+
+		[StructLayout (LayoutKind.Sequential)]
+		internal struct fd_set
+		{
+			internal uint fd_count;
+			//[MarshalAs(UnmanagedType.ByValArray, SizeConst = FD_SETSIZE)] internal IntPtr[] fd_array;
+			internal fixed uint fd_array[FD_SETSIZE];
+
+			internal const int FD_SETSIZE = 64;
+
+			internal void Cleanup ()
+			{
+				//fd_array = null;
+			}
+
+			internal static fd_set Create ()
+			{
+				return new fd_set {
+					//fd_array = new IntPtr[FD_SETSIZE],
+					fd_count = 0
+				};
+			}
+
+			internal static fd_set Create (IntPtr socket)
+			{
+				var handle = Create ();
+				handle.fd_count = 1;
+				handle.fd_array [0] = (uint)socket;
+				return handle;
+			}
+		}
+
+		internal static void FD_ZERO (fd_set fds)
+		{
+			for (var i = 0; i < fd_set.FD_SETSIZE; i++) {
+				//fds.fd_array[i] = (IntPtr) 0;
+				fds.fd_array [i] = 0;
+			}
+			fds.fd_count = 0;
+		}
+
+		[StructLayout (LayoutKind.Sequential)]
+		internal struct timeval
+		{
+			/// <summary>
+			///     Time interval, in seconds.
+			/// </summary>
+			internal int tv_sec;
+
+			/// <summary>
+			///     Time interval, in microseconds.
+			/// </summary>
+			internal int tv_usec;
+
+			internal static timeval Create (int milliseconds)
+			{
+				return new timeval {
+					tv_sec = milliseconds / 1000,
+					tv_usec = (milliseconds % 1000) * 1000
+				};
+			}
+		};
+
+		[DllImport (WINSOCK_LIB, EntryPoint = "select")]
+		internal static extern int select (
+			int nfds, // number of sockets, (ignored in winsock)
+			[In, Out] ref fd_set readfds, // read sockets to watch
+			[In, Out] ref fd_set writefds, // write sockets to watch
+			[In, Out] ref fd_set exceptfds, // error sockets to watch
+			ref timeval timeout);
+
+		//[DllImport(WINSOCK_LIB, EntryPoint = "select")]
+		//internal static extern int select(int ndfs, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, timeval* timeout);
+		#endif
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlCode curl_easy_perform (IntPtr pCurl);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern IntPtr curl_easy_duphandle (IntPtr pCurl);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern IntPtr curl_easy_strerror (CurlCode err);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlCode curl_easy_getinfo (IntPtr pCurl, CurlInfo info, ref IntPtr pInfo);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlCode curl_easy_getinfo (IntPtr pCurl, CurlInfo info, ref double dblVal);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern void curl_easy_reset (IntPtr pCurl);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern IntPtr curl_multi_init ();
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlMultiCode curl_multi_cleanup (IntPtr pmulti);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlMultiCode curl_multi_add_handle (IntPtr pmulti, IntPtr peasy);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlMultiCode curl_multi_remove_handle (IntPtr pmulti, IntPtr peasy);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern IntPtr curl_multi_strerror (CurlMultiCode errorNum);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlMultiCode curl_multi_perform (IntPtr pmulti, ref int runningHandles);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern void curl_formfree (IntPtr pForm);
+
+		#if !USE_LIBCURLSHIM
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern int curl_formadd (ref IntPtr pHttppost, ref IntPtr pLastPost,
+		                                         int codeFirst, IntPtr bufFirst,
+		                                         int codeNext, IntPtr bufNext,
+		                                         int codeLast);
+		#endif
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern IntPtr curl_share_init ();
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlShareCode curl_share_cleanup (IntPtr pShare);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern IntPtr curl_share_strerror (CurlShareCode errorCode);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlShareCode curl_share_setopt (IntPtr pShare, CurlShareOption optCode, IntPtr option);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+		internal static extern IntPtr curl_slist_append (IntPtr slist, string data);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern CurlShareCode curl_slist_free_all (IntPtr pList);
+
+		[DllImport (CURL_LIB, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern IntPtr curl_version_info (CurlVersion ver);
+
+		#if USE_LIBCURLSHIM
+		
+    // libcurlshim imports
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void curl_shim_initialize();
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void curl_shim_cleanup();
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr curl_shim_alloc_strings();
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl,
+            CharSet = CharSet.Ansi)]
+        internal static extern IntPtr curl_shim_add_string_to_slist(
+            IntPtr pStrings, String str);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl,
+            CharSet = CharSet.Ansi)]
+        internal static extern IntPtr curl_shim_get_string_from_slist(
+            IntPtr pSlist, ref IntPtr pStr);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl,
+            CharSet = CharSet.Ansi)]
+        internal static extern IntPtr curl_shim_add_string(IntPtr pStrings, String str);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void curl_shim_free_strings(IntPtr pStrings);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int curl_shim_install_delegates(IntPtr pCurl, IntPtr pThis,
+            _ShimWriteCallback pWrite, _ShimReadCallback pRead,
+            _ShimProgressCallback pProgress, _ShimDebugCallback pDebug,
+            _ShimHeaderCallback pHeader, _ShimSslCtxCallback pCtx,
+            _ShimIoctlCallback pIoctl);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void curl_shim_cleanup_delegates(IntPtr pThis);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void curl_shim_get_file_time(int unixTime,
+            ref int yy, ref int mm, ref int dd, ref int hh, ref int mn, ref int ss);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void curl_shim_free_slist(IntPtr p);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr curl_shim_alloc_fd_sets();
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void curl_shim_free_fd_sets(IntPtr fdsets);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern CurlMultiCode curl_shim_multi_fdset(IntPtr multi,
+            IntPtr fdsets, ref int maxFD);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int curl_shim_select(int maxFD, IntPtr fdsets,
+            int milliseconds);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr curl_shim_multi_info_read(IntPtr multi,
+            ref int nMsgs);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void curl_shim_multi_info_free(IntPtr multiInfo);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int curl_shim_formadd(IntPtr[] ppForms, IntPtr[] pParams, int nParams);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int curl_shim_install_share_delegates(IntPtr pShare,
+            IntPtr pThis, _ShimLockCallback pLock, _ShimUnlockCallback pUnlock);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void curl_shim_cleanup_share_delegates(IntPtr pShare);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int curl_shim_get_version_int_value(IntPtr p, int offset);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr curl_shim_get_version_char_ptr(IntPtr p, int offset);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int curl_shim_get_number_of_protocols(IntPtr p, int offset);
+
+        [DllImport(CURLSHIM_LIB, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr curl_shim_get_protocol_string(IntPtr p, int offset, int index);
+
+        internal delegate void _ShimLockCallback(int data, int access, IntPtr userPtr);
+
+        internal delegate void _ShimUnlockCallback(int data, IntPtr userPtr);
+
+        internal delegate int _ShimDebugCallback(CurlInfoType infoType, IntPtr msgBuf, int msgBufSize, IntPtr parm);
+
+        internal delegate int _ShimHeaderCallback(IntPtr buf, int sz, int nmemb, IntPtr stream);
+
+        internal delegate CurlIoError _ShimIoctlCallback(CurlIoCommand cmd, IntPtr parm);
+
+        internal delegate int _ShimProgressCallback(IntPtr parm, double dlTotal, double dlNow, double ulTotal, double ulNow);
+
+        internal delegate int _ShimReadCallback(IntPtr buf, int sz, int nmemb, IntPtr parm);
+
+        internal delegate int _ShimSslCtxCallback(IntPtr ctx, IntPtr parm);
+
+        internal delegate int _ShimWriteCallback(IntPtr buf, int sz, int nmemb, IntPtr parm);
+#endif
+	}
+}

src/CurlSharp/Properties/AssemblyInfo.cs

@@ -0,0 +1,22 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+// Information about this assembly is defined by the following attributes. 
+// Change them to the values specific to your project.
+[assembly: AssemblyTitle ("CurlSharp")]
+[assembly: AssemblyDescription ("")]
+[assembly: AssemblyConfiguration ("")]
+[assembly: AssemblyCompany ("")]
+[assembly: AssemblyProduct ("")]
+[assembly: AssemblyCopyright ("max")]
+[assembly: AssemblyTrademark ("")]
+[assembly: AssemblyCulture ("")]
+// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
+// The form "{Major}.{Minor}.*" will automatically update the build and revision,
+// and "{Major}.{Minor}.{Build}.*" will update just the revision.
+[assembly: AssemblyVersion ("1.0.*")]
+// The following attributes are used to specify the signing key for the assembly, 
+// if desired. See the Mono documentation for more information about signing.
+//[assembly: AssemblyDelaySign(false)]
+//[assembly: AssemblyKeyFile("")]
+

src/Jackett.sln

@@ -1,10 +1,11 @@
-
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 2013
 VisualStudioVersion = 12.0.31101.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Jackett", "Jackett\Jackett.csproj", "{E636D5F8-68B4-4903-B4ED-CCFD9C9E899F}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CurlSharp", "CurlSharp\CurlSharp.csproj", "{74420A79-CC16-442C-8B1E-7C1B913844F0}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,6 +16,10 @@ Global
 		{E636D5F8-68B4-4903-B4ED-CCFD9C9E899F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E636D5F8-68B4-4903-B4ED-CCFD9C9E899F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E636D5F8-68B4-4903-B4ED-CCFD9C9E899F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{74420A79-CC16-442C-8B1E-7C1B913844F0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{74420A79-CC16-442C-8B1E-7C1B913844F0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{74420A79-CC16-442C-8B1E-7C1B913844F0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{74420A79-CC16-442C-8B1E-7C1B913844F0}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

src/Jackett/ConfigurationDataUrl.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett
+{
+    public class ConfigurationDataUrl : ConfigurationData
+    {
+        public StringItem Url { get; private set; }
+
+        public ConfigurationDataUrl(string defaultUrl)
+        {
+            Url = new StringItem { Name = "Url", Value = defaultUrl };
+        }
+
+        public override Item[] GetItems()
+        {
+            return new Item[] { Url };
+        }
+
+        public string GetFormattedHostUrl()
+        {
+            var uri = new Uri(Url.Value);
+            return string.Format("{0}://{1}", uri.Scheme, uri.Host);
+        }
+    }
+}

src/Jackett/CookieContainerExtensions.cs

@@ -8,15 +8,26 @@ using System.Threading.Tasks;
 
 namespace Jackett
 {
-    public static class CookieContainerExtensions
-    {
-        public static void FillFromJson(this CookieContainer cookies, Uri uri, JArray json)
-        {
-            foreach (var cookie in json)
-            {
-                var w = ((string)cookie).Split(':');
-                cookies.Add(uri, new Cookie(w[0], w[1]));
-            }
-        }
-    }
+	public static class CookieContainerExtensions
+	{
+		public static void FillFromJson (this CookieContainer cookies, Uri uri, JArray json)
+		{
+			foreach (string cookie in json) {
+
+				var w = cookie.Split ('=');
+				if (w.Length == 1)
+					cookies.Add (uri, new Cookie{ Name = cookie.Trim () });
+				else
+					cookies.Add (uri, new Cookie (w [0].Trim (), w [1].Trim ()));
+			}
+		}
+
+		public static JArray ToJson (this CookieContainer cookies, Uri baseUrl)
+		{
+			return new JArray ((
+			    from cookie in cookies.GetCookies (baseUrl).Cast<Cookie> ()
+			    select cookie.Name.Trim () + "=" + cookie.Value.Trim ()
+			).ToArray ());
+		}
+	}
 }

src/Jackett/Curl.cs

@@ -0,0 +1,137 @@
+using CurlSharp;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett
+{
+    public class CurlHelper
+    {
+        private const string ChromeUserAgent = "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.90 Safari/537.36";
+
+        public static CurlHelper Shared = new CurlHelper();
+
+        private BlockingCollection<CurlRequest> curlRequests;
+
+        public bool IsSupported { get; private set; }
+
+        private class CurlRequest
+        {
+            public TaskCompletionSource<string> TaskCompletion { get; private set; }
+
+            public string Url { get; private set; }
+
+            public string Cookies { get; private set; }
+
+            public string Referer { get; private set; }
+
+            public HttpMethod Method { get; private set; }
+
+            public string PostData { get; set; }
+
+            public CurlRequest(HttpMethod method, string url, string cookies = null, string referer = null)
+            {
+                TaskCompletion = new TaskCompletionSource<string>();
+                Method = method;
+                Url = url;
+                Cookies = cookies;
+                Referer = referer;
+            }
+        }
+
+        public async Task<string> GetStringAsync(string url, string cookies = null, string referer = null)
+        {
+            var curlRequest = new CurlRequest(HttpMethod.Get, url, cookies, referer);
+            curlRequests.Add(curlRequest);
+            var result = await curlRequest.TaskCompletion.Task;
+            return result;
+        }
+
+        public CurlHelper()
+        {
+            try
+            {
+                Curl.GlobalInit(CurlInitFlag.All);
+                IsSupported = true;
+            }
+            catch (Exception ex)
+            {
+                IsSupported = false;
+            }
+            Task.Run((Action)CurlServicer);
+        }
+
+        private void CurlServicer()
+        {
+            curlRequests = new BlockingCollection<CurlRequest>();
+            foreach (var curlRequest in curlRequests.GetConsumingEnumerable())
+            {
+                PerformCurl(curlRequest);
+            }
+        }
+
+        private void PerformCurl(CurlRequest curlRequest)
+        {
+            var headerBuffers = new List<byte[]>();
+            var contentBuffers = new List<byte[]>();
+            try
+            {
+                using (var easy = new CurlEasy())
+                {
+                    easy.Url = curlRequest.Url;
+                    easy.BufferSize = 64 * 1024;
+                    //easy.Encoding = "UTF8";
+                    easy.WriteFunction = (byte[] buf, int size, int nmemb, object data) =>
+                    {
+                        contentBuffers.Add(buf);
+                        return size * nmemb;
+                    };
+                    easy.HeaderFunction = (byte[] buf, int size, int nmemb, object extraData) =>
+                    {
+                        headerBuffers.Add(buf);
+                        return size * nmemb;
+                    };
+
+                    if (!string.IsNullOrEmpty(curlRequest.Cookies))
+                        easy.Cookie = curlRequest.Cookies;
+
+                    if (curlRequest.Method == HttpMethod.Post)
+                    {
+                        easy.Post = true;
+                        easy.PostFields = curlRequest.PostData;
+                        easy.PostFieldSize = Encoding.UTF8.GetByteCount(curlRequest.PostData);
+                    }
+
+                    easy.Perform();
+                }
+
+                var headerBytes = Combine(headerBuffers.ToArray());
+                var headerString = Encoding.UTF8.GetString(headerBytes);
+
+                var contentBytes = Combine(contentBuffers.ToArray());
+                var result = Encoding.UTF8.GetString(contentBytes);
+                curlRequest.TaskCompletion.SetResult(result);
+            }
+            catch (Exception ex)
+            {
+                curlRequest.TaskCompletion.TrySetException(ex);
+            }
+        }
+
+        public static byte[] Combine(params byte[][] arrays)
+        {
+            byte[] ret = new byte[arrays.Sum(x => x.Length)];
+            int offset = 0;
+            foreach (byte[] data in arrays)
+            {
+                Buffer.BlockCopy(data, 0, ret, offset, data.Length);
+                offset += data.Length;
+            }
+            return ret;
+        }
+    }
+}

src/Jackett/CurlHelper.cs

@@ -0,0 +1,213 @@
+using CurlSharp;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Net.Http.Headers;
+
+namespace Jackett
+{
+    public static class CurlHelper
+    {
+        private const string ChromeUserAgent = "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.90 Safari/537.36";
+
+        public class CurlRequest
+        {
+
+            public string Url { get; private set; }
+
+            public string Cookies { get; private set; }
+
+            public string Referer { get; private set; }
+
+            public HttpMethod Method { get; private set; }
+
+            public Dictionary<string, string> PostData { get; set; }
+
+            public CurlRequest(HttpMethod method, string url, string cookies = null, string referer = null)
+            {
+                Method = method;
+                Url = url;
+                Cookies = cookies;
+                Referer = referer;
+            }
+        }
+
+        public class CurlResponse
+        {
+            public Dictionary<string, string> Headers { get; private set; }
+
+            public List<string[]> HeaderList { get; private set; }
+
+            public byte[] Content { get; private set; }
+
+            public Dictionary<string, string> Cookies { get; private set; }
+
+            public List<string> CookiesFlat { get { return Cookies.Select(c => c.Key + "=" + c.Value).ToList(); } }
+
+            public string CookieHeader { get { return string.Join("; ", CookiesFlat); } }
+
+            public CurlResponse(List<string[]> headers, byte[] content)
+            {
+                Headers = new Dictionary<string, string>();
+                Cookies = new Dictionary<string, string>();
+                HeaderList = headers;
+                Content = content;
+                foreach (var h in headers)
+                {
+                    Headers[h[0]] = h[1];
+                }
+            }
+
+            public void AddCookiesFromHeaderValue(string cookieHeaderValue)
+            {
+                var rawCookies = cookieHeaderValue.Split(';');
+                foreach (var rawCookie in rawCookies)
+                {
+                    var parts = rawCookie.Split(new char[] { '=' }, 2, StringSplitOptions.RemoveEmptyEntries);
+                    if (parts.Length == 1)
+                        Cookies[rawCookie.Trim()] = string.Empty;
+                    else
+                        Cookies[parts[0].Trim()] = parts[1].Trim();
+                }
+            }
+
+            public void AddCookiesFromHeaders(List<string[]> headers)
+            {
+                foreach (var h in headers)
+                {
+                    if (h[0] == "set-cookie")
+                    {
+                        AddCookiesFromHeaderValue(h[1]);
+                    }
+                }
+            }
+        }
+
+        public static async Task<CurlResponse> GetAsync(string url, string cookies = null, string referer = null)
+        {
+            var curlRequest = new CurlRequest(HttpMethod.Get, url, cookies, referer);
+            var result = await PerformCurlAsync(curlRequest);
+            var checkedResult = await FollowRedirect(url, result);
+            return checkedResult;
+        }
+
+        public static async Task<CurlResponse> PostAsync(string url, Dictionary<string, string> formData, string cookies = null, string referer = null)
+        {
+            var curlRequest = new CurlRequest(HttpMethod.Post, url, cookies, referer);
+            curlRequest.PostData = formData;
+            var result = await PerformCurlAsync(curlRequest);
+            var checkedResult = await FollowRedirect(url, result);
+            return checkedResult;
+        }
+
+        private static async Task<CurlResponse> FollowRedirect(string url, CurlResponse response)
+        {
+            var uri = new Uri(url);
+            string redirect;
+            if (response.Headers.TryGetValue("location", out redirect))
+            {
+                string cookie = response.CookieHeader;
+                if (!redirect.StartsWith("http://") && !redirect.StartsWith("https://"))
+                {
+                    if (redirect.StartsWith("/"))
+                        redirect = string.Format("{0}://{1}{2}", uri.Scheme, uri.Host, redirect);
+                    else
+                        redirect = string.Format("{0}://{1}/{2}", uri.Scheme, uri.Host, redirect);
+                }
+                var newRedirect = await GetAsync(redirect, cookie);
+                foreach (var c in response.Cookies)
+                    newRedirect.Cookies[c.Key] = c.Value;
+                newRedirect.AddCookiesFromHeaders(response.HeaderList);
+                return newRedirect;
+            }
+            else
+                return response;
+        }
+
+
+        public static async Task<CurlResponse> PerformCurlAsync(CurlRequest curlRequest)
+        {
+            return await Task.Run(() => PerformCurl(curlRequest));
+        }
+
+        public static CurlResponse PerformCurl(CurlRequest curlRequest)
+        {
+            Curl.GlobalInit(CurlInitFlag.All);
+
+            var headerBuffers = new List<byte[]>();
+            var contentBuffers = new List<byte[]>();
+
+            using (var easy = new CurlEasy())
+            {
+                easy.Url = curlRequest.Url;
+                easy.BufferSize = 64 * 1024;
+                easy.UserAgent = ChromeUserAgent;
+                easy.WriteFunction = (byte[] buf, int size, int nmemb, object data) =>
+                {
+                    contentBuffers.Add(buf);
+                    return size * nmemb;
+                };
+                easy.HeaderFunction = (byte[] buf, int size, int nmemb, object extraData) =>
+                {
+                    headerBuffers.Add(buf);
+                    return size * nmemb;
+                };
+
+                if (!string.IsNullOrEmpty(curlRequest.Cookies))
+                    easy.Cookie = curlRequest.Cookies;
+
+                if (!string.IsNullOrEmpty(curlRequest.Referer))
+                    easy.Referer = curlRequest.Referer;
+
+                if (curlRequest.Method == HttpMethod.Post)
+                {
+                    easy.Post = true;
+                    var postString = new FormUrlEncodedContent(curlRequest.PostData).ReadAsStringAsync().Result;
+                    easy.PostFields = postString;
+                    easy.PostFieldSize = Encoding.UTF8.GetByteCount(postString);
+                }
+
+                easy.Perform();
+            }
+
+            var headerBytes = Combine(headerBuffers.ToArray());
+            var headerString = Encoding.UTF8.GetString(headerBytes);
+            var headerParts = headerString.Split(new char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
+            var headers = new List<string[]>();
+            foreach (var headerPart in headerParts.Skip(1))
+            {
+                var keyVal = headerPart.Split(new char[] { ':' }, 2);
+                if (keyVal.Length > 1)
+                {
+                    headers.Add(new[] { keyVal[0].ToLower().Trim(), keyVal[1].Trim() });
+                }
+            }
+
+            var contentBytes = Combine(contentBuffers.ToArray());
+            var curlResponse = new CurlResponse(headers, contentBytes);
+
+            if (!string.IsNullOrEmpty(curlRequest.Cookies))
+                curlResponse.AddCookiesFromHeaderValue(curlRequest.Cookies);
+            curlResponse.AddCookiesFromHeaders(headers);
+
+            return curlResponse;
+
+        }
+
+        public static byte[] Combine(params byte[][] arrays)
+        {
+            byte[] ret = new byte[arrays.Sum(x => x.Length)];
+            int offset = 0;
+            foreach (byte[] data in arrays)
+            {
+                Buffer.BlockCopy(data, 0, ret, offset, data.Length);
+                offset += data.Length;
+            }
+            return ret;
+        }
+    }
+}

src/Jackett/HttpClientExtensions.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett
+{
+    public static class HttpClientExtensions
+    {
+        public static async Task<string> GetStringAsync(this HttpClient client, string uri, int retries)
+        {
+            Exception exception = null;
+            try
+            {
+                return await client.GetStringAsync(uri);
+            }
+            catch (Exception ex)
+            {
+                exception = ex;
+            }
+            if (retries > 0)
+                return await client.GetStringAsync(uri, --retries);
+            throw exception;
+        }
+    }
+}

src/Jackett/IndexerInterface.cs

@@ -10,25 +10,25 @@ namespace Jackett
 {
     public interface IndexerInterface
     {
+
+        // Invoked when the indexer configuration has been applied and verified so the cookie needs to be saved
+        event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
         string DisplayName { get; }
         string DisplayDescription { get; }
         Uri SiteLink { get; }
 
+        // Whether this indexer has been configured, verified and saved in the past and has the settings required for functioning
+        bool IsConfigured { get; }
+
         // Retrieved for starting setup for the indexer via web API
         Task<ConfigurationData> GetConfigurationForSetup();
 
         // Called when web API wants to apply setup configuration via web API, usually this is where login and storing cookie happens
         Task ApplyConfiguration(JToken configJson);
 
-        // Called to check if configuration (cookie) is correct and indexer connection works
-        Task VerifyConnection();
-
-        // Invoked when the indexer configuration has been applied and verified so the cookie needs to be saved
-        event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
-
-        // Whether this indexer has been configured, verified and saved in the past and has the settings required for functioning
-        bool IsConfigured { get; }
-
         // Called on startup when initializing indexers from saved configuration
         void LoadFromSavedConfiguration(JToken jsonConfig);
 

src/Jackett/IndexerManager.cs

@@ -43,6 +43,7 @@ namespace Jackett
 
             IndexerInterface newIndexer = (IndexerInterface)Activator.CreateInstance(indexerType);
             newIndexer.OnSaveConfigurationRequested += newIndexer_OnSaveConfigurationRequested;
+            newIndexer.OnResultParsingError += newIndexer_OnResultParsingError;
 
             var configFilePath = GetIndexerConfigFilePath(newIndexer);
             if (File.Exists(configFilePath))
@@ -54,6 +55,14 @@ namespace Jackett
             Indexers.Add(name, newIndexer);
         }
 
+        void newIndexer_OnResultParsingError(IndexerInterface indexer, string results, Exception ex)
+        {
+            var fileName = string.Format("Error on {0} for {1}.txt", DateTime.Now.ToString("yyyyMMddHHmmss"), indexer.DisplayName);
+            var spacing = string.Join("", Enumerable.Repeat(Environment.NewLine, 5));
+            var fileContents = string.Format("{0}{1}{2}", ex, spacing, results);
+            File.WriteAllText(Path.Combine(Program.AppConfigDirectory, fileName), fileContents);
+        }
+
         string GetIndexerConfigFilePath(IndexerInterface indexer)
         {
             return Path.Combine(IndexerConfigDirectory, indexer.GetType().Name.ToLower() + ".json");
@@ -61,7 +70,6 @@ namespace Jackett
 
         void newIndexer_OnSaveConfigurationRequested(IndexerInterface indexer, JToken obj)
         {
-            var name = indexer.GetType().Name.Trim().ToLower();
             var configFilePath = GetIndexerConfigFilePath(indexer);
             if (!Directory.Exists(IndexerConfigDirectory))
                 Directory.CreateDirectory(IndexerConfigDirectory);
@@ -85,5 +93,15 @@ namespace Jackett
             LoadMissingIndexers();
         }
 
+        public async Task TestIndexer(IndexerInterface indexer)
+        {
+            var browseQuery = new TorznabQuery();
+            var results = await indexer.PerformQuery(browseQuery);
+            Program.LoggerInstance.Debug(string.Format("Found {0} releases from {1}", results.Length, indexer.DisplayName));
+            if (results.Length == 0)
+                throw new Exception("Found no results while trying to browse this tracker");
+
+        }
+
     }
 }

src/Jackett/Indexers/AlphaRatio.cs

@@ -0,0 +1,232 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class AlphaRatio : IndexerInterface
+    {
+        public string DisplayName
+        {
+			get { return "AlphaRatio"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "Legendary"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public bool IsConfigured { get; private set; }
+
+		static string BaseUrl = "https://alpharatio.cc";
+
+        static string LoginUrl = BaseUrl + "/login.php";
+
+        static string SearchUrl = BaseUrl + "/ajax.php?action=browse&searchstr=";
+
+        static string DownloadUrl = BaseUrl + "/torrents.php?action=download&id=";
+
+        static string GuidUrl = BaseUrl + "/torrents.php?torrentid=";
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        string cookieHeader;
+
+		public AlphaRatio()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value },
+				{ "login", "Log in" },
+				{ "keeplogged", "1" }
+			};
+
+            var content = new FormUrlEncodedContent(pairs);
+
+            string responseContent;
+            JArray cookieJArray;
+
+            if (Program.IsWindows)
+            {
+                // If Windows use .net http
+                var response = await client.PostAsync(LoginUrl, content);
+                responseContent = await response.Content.ReadAsStringAsync();
+                cookieJArray = cookies.ToJson(SiteLink);
+            }
+            else
+            {
+                // If UNIX system use curl
+                var response = await CurlHelper.PostAsync(LoginUrl, pairs);
+                responseContent = Encoding.UTF8.GetString(response.Content);
+                cookieHeader = response.CookieHeader;
+                cookieJArray = new JArray(response.CookiesFlat);
+            }
+
+            if (!responseContent.Contains("logout.php?"))
+            {
+                CQ dom = responseContent;
+                dom["#loginform > table"].Remove();
+                var errorMessage = dom["#loginform"].Text().Trim().Replace("\n\t", " ");
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+
+            }
+            else
+            {
+
+                var configSaveData = new JObject();
+                configSaveData["cookies"] = cookieJArray;
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(SiteLink, (JArray)jsonConfig["cookies"]);
+            cookieHeader = cookies.GetCookieHeader(SiteLink);
+            IsConfigured = true;
+        }
+
+        void FillReleaseInfoFromJson(ReleaseInfo release, JObject r)
+        {
+            var id = r["torrentId"];
+            release.Size = (long)r["size"];
+            release.Seeders = (int)r["seeders"];
+            release.Peers = (int)r["leechers"] + release.Seeders;
+            release.Guid = new Uri(GuidUrl + id);
+            release.Comments = release.Guid;
+            release.Link = new Uri(DownloadUrl + id);
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = SearchUrl + HttpUtility.UrlEncode(searchString);
+
+                string results;
+                if (Program.IsWindows)
+                {
+                    results = await client.GetStringAsync(episodeSearchUrl);
+                }
+                else
+                {
+                    var response = await CurlHelper.GetAsync(episodeSearchUrl, cookieHeader);
+                    results = Encoding.UTF8.GetString(response.Content);
+                }
+                try
+                {
+
+                    var json = JObject.Parse(results);
+                    foreach (JObject r in json["response"]["results"])
+                    {
+                        DateTime pubDate = DateTime.MinValue;
+                        double dateNum;
+                        if (double.TryParse((string)r["groupTime"], out dateNum))
+                            pubDate = UnixTimestampToDateTime(dateNum);
+
+                        var groupName = (string)r["groupName"];
+
+                        if (r["torrents"] is JArray)
+                        {
+                            foreach (JObject t in r["torrents"])
+                            {
+                                var release = new ReleaseInfo();
+                                release.PublishDate = pubDate;
+                                release.Title = groupName;
+                                release.Description = groupName;
+                                FillReleaseInfoFromJson(release, t);
+                                releases.Add(release);
+                            }
+                        }
+                        else
+                        {
+                            var release = new ReleaseInfo();
+                            release.PublishDate = pubDate;
+                            release.Title = groupName;
+                            release.Description = groupName;
+                            FillReleaseInfoFromJson(release, r);
+                            releases.Add(release);
+                        }
+
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+
+            return releases.ToArray();
+        }
+
+        static DateTime UnixTimestampToDateTime(double unixTime)
+        {
+            DateTime unixStart = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
+            long unixTimeStampInTicks = (long)(unixTime * TimeSpan.TicksPerSecond);
+            return new DateTime(unixStart.Ticks + unixTimeStampInTicks);
+        }
+
+        public async Task<byte[]> Download(Uri link)
+        {
+            if (Program.IsWindows)
+            {
+                return await client.GetByteArrayAsync(link);
+            }
+            else
+            {
+                var response = await CurlHelper.GetAsync(link.ToString(), cookieHeader);
+                return response.Content;
+            }
+
+        }
+
+    }
+}

src/Jackett/Indexers/BitHdtv.cs

@@ -0,0 +1,170 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class BitHdtv : IndexerInterface
+    {
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "BIT-HDTV"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "Home of high definition invites"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+        static string BaseUrl = "https://www.bit-hdtv.com";
+        static string LoginUrl = BaseUrl + "/takelogin.php";
+        static string SearchUrl = BaseUrl + "/torrents.php?cat=0&search=";
+        static string DownloadUrl = BaseUrl + "/download.php?/{0}/dl.torrent";
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public BitHdtv()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value }
+			};
+
+            var content = new FormUrlEncodedContent(pairs);
+
+            var response = await client.PostAsync(LoginUrl, content);
+            var responseContent = await response.Content.ReadAsStringAsync();
+
+            if (!responseContent.Contains("logout.php"))
+            {
+                CQ dom = responseContent;
+                var messageEl = dom["table.detail td.text"].Last();
+                messageEl.Children("a").Remove();
+                messageEl.Children("style").Remove();
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                configSaveData["cookies"] = cookies.ToJson(SiteLink);
+
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public bool IsConfigured { get; private set; }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), (JArray)jsonConfig["cookies"]);
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = SearchUrl + HttpUtility.UrlEncode(searchString);
+                var results = await client.GetStringAsync(episodeSearchUrl);
+                try
+                {
+                    CQ dom = results;
+                    dom["#needseed"].Remove();
+                    var rows = dom["table[width='750'] > tbody"].Children();
+                    foreach (var row in rows.Skip(1))
+                    {
+
+                        var release = new ReleaseInfo();
+
+                        var qRow = row.Cq();
+                        var qLink = qRow.Children().ElementAt(2).Cq().Children("a").First();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Title = qLink.Attr("title");
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + qLink.Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Link = new Uri(string.Format(DownloadUrl, qLink.Attr("href").Split('=')[1]));
+
+                        var dateString = qRow.Children().ElementAt(5).Cq().Text().Trim();
+                        var pubDate = DateTime.ParseExact(dateString, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
+                        release.PublishDate = pubDate;
+
+                        var sizeCol = qRow.Children().ElementAt(6);
+                        var sizeVal = sizeCol.ChildNodes[0].NodeValue;
+                        var sizeUnit = sizeCol.ChildNodes[2].NodeValue;
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, float.Parse(sizeVal));
+
+                        release.Seeders = int.Parse(qRow.Children().ElementAt(8).Cq().Text().Trim(), NumberStyles.AllowThousands);
+                        release.Peers = int.Parse(qRow.Children().ElementAt(9).Cq().Text().Trim(), NumberStyles.AllowThousands) + release.Seeders;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+
+            return releases.ToArray();
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            return client.GetByteArrayAsync(link);
+        }
+
+
+    }
+}

src/Jackett/Indexers/BitMeTV.cs

@@ -18,8 +18,11 @@ namespace Jackett
         class BmtvConfig : ConfigurationData
         {
             public StringItem Username { get; private set; }
+
             public StringItem Password { get; private set; }
+
             public ImageItem CaptchaImage { get; private set; }
+
             public StringItem CaptchaText { get; private set; }
 
             public BmtvConfig()
@@ -47,6 +50,7 @@ namespace Jackett
         HttpClient client;
 
         public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
         public BitMeTV()
         {
@@ -62,14 +66,16 @@ namespace Jackett
         }
 
         public string DisplayName { get { return "BitMeTV"; } }
+
         public string DisplayDescription { get { return "TV Episode specialty tracker"; } }
+
         public Uri SiteLink { get { return new Uri(BaseUrl); } }
 
         public bool IsConfigured { get; private set; }
 
         public async Task<ConfigurationData> GetConfigurationForSetup()
         {
-            var loginPage = await client.GetAsync(LoginUrl);
+            await client.GetAsync(LoginUrl);
             var captchaImage = await client.GetByteArrayAsync(CaptchaUrl);
             var config = new BmtvConfig();
             config.CaptchaImage.Value = captchaImage;
@@ -81,12 +87,11 @@ namespace Jackett
             var config = new BmtvConfig();
             config.LoadValuesFromJson(configJson);
 
-            var pairs = new Dictionary<string, string>
-                {
-                    { "username", config.Username.Value},
-                    { "password", config.Password.Value},
-                    { "secimage", config.CaptchaText.Value}
-                };
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value },
+				{ "secimage", config.CaptchaText.Value }
+			};
 
             var content = new FormUrlEncodedContent(pairs);
 
@@ -106,10 +111,7 @@ namespace Jackett
             else
             {
                 var configSaveData = new JObject();
-                configSaveData["cookies"] = new JArray((
-                    from cookie in cookies.GetCookies(new Uri(BaseUrl)).Cast<Cookie>()
-                    select cookie.Name + ":" + cookie.Value
-                ).ToArray());
+                configSaveData["cookies"] = cookies.ToJson(SiteLink);
 
                 if (OnSaveConfigurationRequested != null)
                     OnSaveConfigurationRequested(this, configSaveData);
@@ -118,13 +120,6 @@ namespace Jackett
             }
         }
 
-        public async Task VerifyConnection()
-        {
-            var result = await client.GetStringAsync(new Uri(SearchUrl));
-            if (result.Contains("<h1>Not logged in!</h1>"))
-                throw new Exception("Detected as not logged in");
-        }
-
         public void LoadFromSavedConfiguration(JToken jsonConfig)
         {
             cookies.FillFromJson(new Uri(BaseUrl), (JArray)jsonConfig["cookies"]);
@@ -142,42 +137,54 @@ namespace Jackett
                 var searchString = title + " " + query.GetEpisodeSearchString();
                 var episodeSearchUrl = string.Format("{0}?search={1}&cat=0", SearchUrl, HttpUtility.UrlEncode(searchString));
                 var results = await client.GetStringAsync(episodeSearchUrl);
-                CQ dom = results;
-
-                var table = dom["tbody > tr > .latest"].Parent().Parent();
-
-                foreach (var row in table.Children().Skip(1))
+                try
                 {
-                    var release = new ReleaseInfo();
+                    CQ dom = results;
 
-                    CQ qRow = row.Cq();
-                    CQ qDetailsCol = row.ChildElements.ElementAt(1).Cq();
-                    CQ qLink = qDetailsCol.Children("a").First();
+                    var table = dom["tbody > tr > .latest"].Parent().Parent();
 
-                    release.MinimumRatio = 1;
-                    release.MinimumSeedTime = 172800;
-                    release.Comments = new Uri(BaseUrl + "/" + qLink.Attr("href"));
-                    release.Guid = release.Comments;
-                    release.Title = qLink.Attr("title");
-                    release.Description = release.Title;
+                    foreach (var row in table.Children().Skip(1))
+                    {
+                        var release = new ReleaseInfo();
 
-                    //"Tuesday, June 11th 2013 at 03:52:53 AM" to...
-                    //"Tuesday June 11 2013 03 52 53 AM"
-                    var timestamp = qDetailsCol.Children("font").Text().Trim() + " ";
-                    var groups = new Regex(@"(.*?), (.*?) (.*?)th (.*?) at (.*?):(.*?):(.*?) (.*?) ").Match(timestamp).Groups;
-                    var str = string.Join(" ", groups.Cast<Group>().Skip(1).Select(g => g.Value));
-                    release.PublishDate = DateTime.ParseExact(str, "dddd MMMM d yyyy hh mm ss tt", CultureInfo.InvariantCulture);
+                        CQ qDetailsCol = row.ChildElements.ElementAt(1).Cq();
+                        CQ qLink = qDetailsCol.Children("a").First();
 
-                    release.Link = new Uri(BaseUrl + "/" + row.ChildElements.ElementAt(2).Cq().Children("a.index").Attr("href"));
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Comments = new Uri(BaseUrl + "/" + qLink.Attr("href"));
+                        release.Guid = release.Comments;
+                        release.Title = qLink.Attr("title");
+                        release.Description = release.Title;
 
-                    var sizeCol = row.ChildElements.ElementAt(6);
-                    var sizeVal = float.Parse(sizeCol.ChildNodes[0].NodeValue);
-                    var sizeUnit = sizeCol.ChildNodes[2].NodeValue;
-                    release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
+                        //"Tuesday, June 11th 2013 at 03:52:53 AM" to...
+                        //"Tuesday June 11 2013 03:52:53 AM"
+                        var timestamp = qDetailsCol.Children("font").Text().Trim() + " ";
+                        var timeParts = new List<string>(timestamp.Replace(" at", "").Replace(",", "").Split(' '));
+                        timeParts[2] = Regex.Replace(timeParts[2], "[^0-9.]", "");
+                        var formattedTimeString = string.Join(" ", timeParts.ToArray()).Trim();
+                        release.PublishDate = DateTime.ParseExact(formattedTimeString, "dddd MMMM d yyyy hh:mm:ss tt", CultureInfo.InvariantCulture);
 
-                    release.Seeders = int.Parse(row.ChildElements.ElementAt(8).Cq().Text());
-                    release.Peers = int.Parse(row.ChildElements.ElementAt(9).Cq().Text()) + release.Seeders;
-                    releases.Add(release);
+                        release.Link = new Uri(BaseUrl + "/" + row.ChildElements.ElementAt(2).Cq().Children("a.index").Attr("href"));
+
+                        var sizeCol = row.ChildElements.ElementAt(6);
+                        var sizeVal = float.Parse(sizeCol.ChildNodes[0].NodeValue);
+                        var sizeUnit = sizeCol.ChildNodes[2].NodeValue;
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
+
+                        release.Seeders = int.Parse(row.ChildElements.ElementAt(8).Cq().Text(), NumberStyles.AllowThousands);
+                        release.Peers = int.Parse(row.ChildElements.ElementAt(9).Cq().Text(), NumberStyles.AllowThousands) + release.Seeders;
+
+                        //if (!release.Title.ToLower().Contains(title.ToLower()))
+                        //    continue;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
                 }
             }
 
@@ -189,5 +196,6 @@ namespace Jackett
         {
             return client.GetByteArrayAsync(link);
         }
+
     }
 }

src/Jackett/Indexers/Freshon.cs

@@ -16,6 +16,7 @@ namespace Jackett
 {
     public class Freshon : IndexerInterface
     {
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
         static string BaseUrl = "https://freshon.tv";
         static string LoginUrl = BaseUrl + "/login.php";
@@ -51,10 +52,13 @@ namespace Jackett
             client = new HttpClient(handler);
         }
 
-        public Task<ConfigurationData> GetConfigurationForSetup()
+        public async Task<ConfigurationData> GetConfigurationForSetup()
         {
+            var request = CreateHttpRequest(new Uri(LoginUrl));
+            var response = await client.SendAsync(request);
+            await response.Content.ReadAsStreamAsync();
             var config = new ConfigurationDataBasicLogin();
-            return Task.FromResult<ConfigurationData>(config);
+            return config;
         }
 
         public async Task ApplyConfiguration(JToken configJson)
@@ -62,16 +66,16 @@ namespace Jackett
             var config = new ConfigurationDataBasicLogin();
             config.LoadValuesFromJson(configJson);
 
-            var pairs = new Dictionary<string, string>
-                {
-                    { "username", config.Username.Value},
-                    { "password", config.Password.Value}
-                };
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value }
+			};
 
             var content = new FormUrlEncodedContent(pairs);
             var message = CreateHttpRequest(new Uri(LoginPostUrl));
             message.Method = HttpMethod.Post;
             message.Content = content;
+            message.Headers.Referrer = new Uri(LoginUrl);
 
             var response = await client.SendAsync(message);
             var responseContent = await response.Content.ReadAsStringAsync();
@@ -86,10 +90,7 @@ namespace Jackett
             else
             {
                 var configSaveData = new JObject();
-                configSaveData["cookies"] = new JArray((
-                    from cookie in cookies.GetCookies(new Uri(BaseUrl)).Cast<Cookie>()
-                    select cookie.Name + ":" + cookie.Value
-                ).ToArray());
+                configSaveData["cookies"] = cookies.ToJson(SiteLink);
 
                 if (OnSaveConfigurationRequested != null)
                     OnSaveConfigurationRequested(this, configSaveData);
@@ -98,16 +99,6 @@ namespace Jackett
             }
         }
 
-        public async Task VerifyConnection()
-        {
-            var message = CreateHttpRequest(new Uri(SearchUrl));
-
-            var response = await client.SendAsync(message);
-            var result = await response.Content.ReadAsStringAsync();
-            if (!result.Contains("/logout.php"))
-                throw new Exception("Detected as not logged in");
-        }
-
         public void LoadFromSavedConfiguration(JToken jsonConfig)
         {
             cookies.FillFromJson(new Uri(BaseUrl), (JArray)jsonConfig["cookies"]);
@@ -142,45 +133,52 @@ namespace Jackett
                 var request = CreateHttpRequest(new Uri(episodeSearchUrl));
                 var response = await client.SendAsync(request);
                 var results = await response.Content.ReadAsStringAsync();
-
-                CQ dom = results;
-
-                var rows = dom["#highlight > tbody > tr"];
-
-                foreach (var row in rows.Skip(1))
+                try
                 {
-                    var release = new ReleaseInfo();
+                    CQ dom = results;
 
-                    var qRow = row.Cq();
-                    var qLink = qRow.Find("a.torrent_name_link").First();
+                    var rows = dom["#highlight > tbody > tr"];
 
-                    release.MinimumRatio = 1;
-                    release.MinimumSeedTime = 172800;
-                    release.Title = qLink.Attr("title");
-                    release.Description = release.Title;
-                    release.Guid = new Uri(BaseUrl + qLink.Attr("href"));
-                    release.Comments = release.Guid;
-                    release.Link = new Uri(BaseUrl + qRow.Find("td.table_links > a").First().Attr("href"));
+                    foreach (var row in rows.Skip(1))
+                    {
+                        var release = new ReleaseInfo();
 
-                    DateTime pubDate;
-                    var dateString = qRow.Find("td.table_added").Text().Trim();
-                    if (dateString.StartsWith("Today "))
-                        pubDate = (DateTime.UtcNow + TimeSpan.Parse(dateString.Split(' ')[1])).ToLocalTime();
-                    else if (dateString.StartsWith("Yesterday "))
-                        pubDate = (DateTime.UtcNow + TimeSpan.Parse(dateString.Split(' ')[1]) - TimeSpan.FromDays(1)).ToLocalTime();
-                    else
-                        pubDate = DateTime.ParseExact(dateString, "d-MMM-yyyy HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal).ToLocalTime();
-                    release.PublishDate = pubDate;
+                        var qRow = row.Cq();
+                        var qLink = qRow.Find("a.torrent_name_link").First();
 
-                    release.Seeders = int.Parse(qRow.Find("td.table_seeders").Text().Trim());
-                    release.Peers = int.Parse(qRow.Find("td.table_leechers").Text().Trim()) + release.Seeders;
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Title = qLink.Attr("title");
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + qLink.Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Link = new Uri(BaseUrl + qRow.Find("td.table_links > a").First().Attr("href"));
 
-                    var sizeCol = qRow.Find("td.table_size")[0];
-                    var sizeVal = float.Parse(sizeCol.ChildNodes[0].NodeValue.Trim());
-                    var sizeUnit = sizeCol.ChildNodes[2].NodeValue.Trim();
-                    release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
+                        DateTime pubDate;
+                        var dateString = qRow.Find("td.table_added").Text().Trim();
+                        if (dateString.StartsWith("Today "))
+                            pubDate = (DateTime.UtcNow + TimeSpan.Parse(dateString.Split(' ')[1])).ToLocalTime();
+                        else if (dateString.StartsWith("Yesterday "))
+                            pubDate = (DateTime.UtcNow + TimeSpan.Parse(dateString.Split(' ')[1]) - TimeSpan.FromDays(1)).ToLocalTime();
+                        else
+                            pubDate = DateTime.ParseExact(dateString, "d-MMM-yyyy HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal).ToLocalTime();
+                        release.PublishDate = pubDate;
 
-                    releases.Add(release);
+                        release.Seeders = int.Parse(qRow.Find("td.table_seeders").Text().Trim(), NumberStyles.AllowThousands);
+                        release.Peers = int.Parse(qRow.Find("td.table_leechers").Text().Trim(), NumberStyles.AllowThousands) + release.Seeders;
+
+                        var sizeCol = qRow.Find("td.table_size")[0];
+                        var sizeVal = float.Parse(sizeCol.ChildNodes[0].NodeValue.Trim());
+                        var sizeUnit = sizeCol.ChildNodes[2].NodeValue.Trim();
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
                 }
             }
 

src/Jackett/Indexers/IPTorrents.cs

@@ -2,6 +2,7 @@
 using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
@@ -14,7 +15,8 @@ namespace Jackett.Indexers
     public class IPTorrents : IndexerInterface
     {
 
-        public event Action<IndexerInterface, Newtonsoft.Json.Linq.JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
         public string DisplayName { get { return "IPTorrents"; } }
 
@@ -26,7 +28,6 @@ namespace Jackett.Indexers
 
         static string chromeUserAgent = "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.118 Safari/537.36";
 
-
         static string BaseUrl = "https://iptorrents.com";
 
         string SearchUrl = BaseUrl + "/t?q=";
@@ -62,11 +63,10 @@ namespace Jackett.Indexers
             var config = new ConfigurationDataBasicLogin();
             config.LoadValuesFromJson(configJson);
 
-            var pairs = new Dictionary<string, string>
-                {
-                    { "username", config.Username.Value},
-                    { "password", config.Password.Value}
-                };
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value }
+			};
 
             var content = new FormUrlEncodedContent(pairs);
             var message = new HttpRequestMessage();
@@ -89,10 +89,7 @@ namespace Jackett.Indexers
             else
             {
                 var configSaveData = new JObject();
-                configSaveData["cookies"] = new JArray((
-                    from cookie in cookies.GetCookies(new Uri(BaseUrl)).Cast<Cookie>()
-                    select cookie.Name + ":" + cookie.Value
-                ).ToArray());
+                configSaveData["cookies"] = cookies.ToJson(SiteLink);
 
                 if (OnSaveConfigurationRequested != null)
                     OnSaveConfigurationRequested(this, configSaveData);
@@ -111,19 +108,6 @@ namespace Jackett.Indexers
             return message;
         }
 
-        public Task VerifyConnection()
-        {
-            return Task.Run(async () =>
-            {
-                var message = CreateHttpRequest(new Uri(BaseUrl));
-
-                var response = await client.SendAsync(message);
-                var result = await response.Content.ReadAsStringAsync();
-                if (!result.Contains("/my.php"))
-                    throw new Exception("Detected as not logged in");
-            });
-        }
-
         public void LoadFromSavedConfiguration(Newtonsoft.Json.Linq.JToken jsonConfig)
         {
             cookies.FillFromJson(new Uri(BaseUrl), (JArray)jsonConfig["cookies"]);
@@ -146,55 +130,63 @@ namespace Jackett.Indexers
                 var response = await client.SendAsync(request);
                 var results = await response.Content.ReadAsStringAsync();
 
-                CQ dom = results;
-
-                var rows = dom["table.torrents > tbody > tr"];
-                foreach (var row in rows.Skip(1))
+                try
                 {
-                    var release = new ReleaseInfo();
+                    CQ dom = results;
 
-                    var qRow = row.Cq();
+                    var rows = dom["table.torrents > tbody > tr"];
+                    foreach (var row in rows.Skip(1))
+                    {
+                        var release = new ReleaseInfo();
 
-                    var qTitleLink = qRow.Find("a.t_title").First();
-                    release.Title = qTitleLink.Text().Trim();
-                    release.Description = release.Title;
-                    release.Guid = new Uri(BaseUrl + qTitleLink.Attr("href"));
-                    release.Comments = release.Guid;
+                        var qRow = row.Cq();
 
-                    DateTime pubDate;
-                    var descString = qRow.Find(".t_ctime").Text();
-                    var dateString = descString.Split('|').Last().Trim();
-                    dateString = dateString.Split(new string[] { " by " }, StringSplitOptions.None)[0];
-                    var dateValue = float.Parse(dateString.Split(' ')[0]);
-                    var dateUnit = dateString.Split(' ')[1];
-                    if (dateUnit.Contains("minute"))
-                        pubDate = DateTime.Now - TimeSpan.FromMinutes(dateValue);
-                    else if (dateUnit.Contains("hour"))
-                        pubDate = DateTime.Now - TimeSpan.FromHours(dateValue);
-                    else if (dateUnit.Contains("day"))
-                        pubDate = DateTime.Now - TimeSpan.FromDays(dateValue);
-                    else if (dateUnit.Contains("week"))
-                        pubDate = DateTime.Now - TimeSpan.FromDays(7 * dateValue);
-                    else if (dateUnit.Contains("month"))
-                        pubDate = DateTime.Now - TimeSpan.FromDays(30 * dateValue);
-                    else if (dateUnit.Contains("year"))
-                        pubDate = DateTime.Now - TimeSpan.FromDays(365 * dateValue);
-                    else
-                        pubDate = DateTime.MinValue;
-                    release.PublishDate = pubDate;
+                        var qTitleLink = qRow.Find("a.t_title").First();
+                        release.Title = qTitleLink.Text().Trim();
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + qTitleLink.Attr("href"));
+                        release.Comments = release.Guid;
 
-                    var qLink = row.ChildElements.ElementAt(3).Cq().Children("a");
-                    release.Link = new Uri(BaseUrl + qLink.Attr("href"));
+                        DateTime pubDate;
+                        var descString = qRow.Find(".t_ctime").Text();
+                        var dateString = descString.Split('|').Last().Trim();
+                        dateString = dateString.Split(new string[] { " by " }, StringSplitOptions.None)[0];
+                        var dateValue = float.Parse(dateString.Split(' ')[0]);
+                        var dateUnit = dateString.Split(' ')[1];
+                        if (dateUnit.Contains("minute"))
+                            pubDate = DateTime.Now - TimeSpan.FromMinutes(dateValue);
+                        else if (dateUnit.Contains("hour"))
+                            pubDate = DateTime.Now - TimeSpan.FromHours(dateValue);
+                        else if (dateUnit.Contains("day"))
+                            pubDate = DateTime.Now - TimeSpan.FromDays(dateValue);
+                        else if (dateUnit.Contains("week"))
+                            pubDate = DateTime.Now - TimeSpan.FromDays(7 * dateValue);
+                        else if (dateUnit.Contains("month"))
+                            pubDate = DateTime.Now - TimeSpan.FromDays(30 * dateValue);
+                        else if (dateUnit.Contains("year"))
+                            pubDate = DateTime.Now - TimeSpan.FromDays(365 * dateValue);
+                        else
+                            pubDate = DateTime.MinValue;
+                        release.PublishDate = pubDate;
 
-                    var sizeStr = row.ChildElements.ElementAt(5).Cq().Text().Trim();
-                    var sizeVal = float.Parse(sizeStr.Split(' ')[0]);
-                    var sizeUnit = sizeStr.Split(' ')[1];
-                    release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
+                        var qLink = row.ChildElements.ElementAt(3).Cq().Children("a");
+                        release.Link = new Uri(BaseUrl + qLink.Attr("href"));
 
-                    release.Seeders = int.Parse(qRow.Find(".t_seeders").Text().Trim());
-                    release.Peers = int.Parse(qRow.Find(".t_leechers").Text().Trim()) + release.Seeders;
+                        var sizeStr = row.ChildElements.ElementAt(5).Cq().Text().Trim();
+                        var sizeVal = float.Parse(sizeStr.Split(' ')[0]);
+                        var sizeUnit = sizeStr.Split(' ')[1];
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
 
-                    releases.Add(release);
+                        release.Seeders = int.Parse(qRow.Find(".t_seeders").Text().Trim(), NumberStyles.AllowThousands);
+                        release.Peers = int.Parse(qRow.Find(".t_leechers").Text().Trim(), NumberStyles.AllowThousands) + release.Seeders;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
                 }
 
             }
@@ -210,5 +202,8 @@ namespace Jackett.Indexers
             var bytes = await response.Content.ReadAsByteArrayAsync();
             return bytes;
         }
+
+
+
     }
 }

src/Jackett/Indexers/MoreThanTV.cs

@@ -0,0 +1,233 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class MoreThanTV : IndexerInterface
+    {
+        public string DisplayName
+        {
+            get { return "MoreThanTV"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "ROMANIAN Private Torrent Tracker for TV / MOVIES, and the internal tracker for the release group DRACULA"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public bool IsConfigured { get; private set; }
+
+        static string BaseUrl = "https://www.morethan.tv";
+
+        static string LoginUrl = BaseUrl + "/login.php";
+
+        static string SearchUrl = BaseUrl + "/ajax.php?action=browse&searchstr=";
+
+        static string DownloadUrl = BaseUrl + "/torrents.php?action=download&id=";
+
+        static string GuidUrl = BaseUrl + "/torrents.php?torrentid=";
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        string cookieHeader;
+        int retries = 3;
+
+        public MoreThanTV()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value },
+				{ "login", "Log in" },
+				{ "keeplogged", "1" }
+			};
+
+            var content = new FormUrlEncodedContent(pairs);
+
+            string responseContent;
+            JArray cookieJArray;
+
+            if (Program.IsWindows)
+            {
+                // If Windows use .net http
+                var response = await client.PostAsync(LoginUrl, content);
+                responseContent = await response.Content.ReadAsStringAsync();
+                cookieJArray = cookies.ToJson(SiteLink);
+            }
+            else
+            {
+                // If UNIX system use curl
+                var response = await CurlHelper.PostAsync(LoginUrl, pairs);
+                responseContent = Encoding.UTF8.GetString(response.Content);
+                cookieHeader = response.CookieHeader;
+                cookieJArray = new JArray(response.CookiesFlat);
+            }
+
+            if (!responseContent.Contains("logout.php?"))
+            {
+                CQ dom = responseContent;
+                dom["#loginform > table"].Remove();
+                var errorMessage = dom["#loginform"].Text().Trim().Replace("\n\t", " ");
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+
+            }
+            else
+            {
+
+                var configSaveData = new JObject();
+                configSaveData["cookies"] = cookieJArray;
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(SiteLink, (JArray)jsonConfig["cookies"]);
+            cookieHeader = cookies.GetCookieHeader(SiteLink);
+            IsConfigured = true;
+        }
+
+        static void FillReleaseInfoFromJson(ReleaseInfo release, JObject r)
+        {
+            var id = r["torrentId"];
+            release.Size = (long)r["size"];
+            release.Seeders = (int)r["seeders"];
+            release.Peers = (int)r["leechers"] + release.Seeders;
+            release.Guid = new Uri(GuidUrl + id);
+            release.Comments = release.Guid;
+            release.Link = new Uri(DownloadUrl + id);
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = SearchUrl + HttpUtility.UrlEncode(searchString);
+
+                string results;
+                if (Program.IsWindows)
+                {
+                    results = await client.GetStringAsync(episodeSearchUrl, retries);
+                }
+                else
+                {
+                    var response = await CurlHelper.GetAsync(episodeSearchUrl, cookieHeader);
+                    results = Encoding.UTF8.GetString(response.Content);
+                }
+                try
+                {
+
+                    var json = JObject.Parse(results);
+                    foreach (JObject r in json["response"]["results"])
+                    {
+                        DateTime pubDate = DateTime.MinValue;
+                        double dateNum;
+                        if (double.TryParse((string)r["groupTime"], out dateNum))
+                            pubDate = UnixTimestampToDateTime(dateNum);
+
+                        var groupName = (string)r["groupName"];
+
+                        if (r["torrents"] is JArray)
+                        {
+                            foreach (JObject t in r["torrents"])
+                            {
+                                var release = new ReleaseInfo();
+                                release.PublishDate = pubDate;
+                                release.Title = groupName;
+                                release.Description = groupName;
+                                FillReleaseInfoFromJson(release, t);
+                                releases.Add(release);
+                            }
+                        }
+                        else
+                        {
+                            var release = new ReleaseInfo();
+                            release.PublishDate = pubDate;
+                            release.Title = groupName;
+                            release.Description = groupName;
+                            FillReleaseInfoFromJson(release, r);
+                            releases.Add(release);
+                        }
+
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+
+            return releases.ToArray();
+        }
+
+        static DateTime UnixTimestampToDateTime(double unixTime)
+        {
+            DateTime unixStart = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
+            long unixTimeStampInTicks = (long)(unixTime * TimeSpan.TicksPerSecond);
+            return new DateTime(unixStart.Ticks + unixTimeStampInTicks);
+        }
+
+        public async Task<byte[]> Download(Uri link)
+        {
+            if (Program.IsWindows)
+            {
+                return await client.GetByteArrayAsync(link);
+            }
+            else
+            {
+                var response = await CurlHelper.GetAsync(link.ToString(), cookieHeader);
+                return response.Content;
+            }
+
+        }
+    }
+}

src/Jackett/Indexers/Rarbg.cs

@@ -0,0 +1,166 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Jackett.Indexers
+{
+    public class Rarbg : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "RARBG"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return DisplayName; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri("https://rarbg.com"); }
+        }
+
+        public bool IsConfigured { get; private set; }
+
+        const string DefaultUrl = "http://torrentapi.org";
+
+        const string TokenUrl = "/pubapi.php?get_token=get_token&format=json";
+        const string SearchTVRageUrl = "/pubapi.php?mode=search&search_tvrage={0}&token={1}&format=json&min_seeders=1";
+        const string SearchQueryUrl = "/pubapi.php?mode=search&search_string={0}&token={1}&format=json&min_seeders=1";
+
+        static string chromeUserAgent = "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.118 Safari/537.36";
+
+        string BaseUrl;
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public Rarbg()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataUrl(DefaultUrl);
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataUrl(DefaultUrl);
+            config.LoadValuesFromJson(configJson);
+
+            var formattedUrl = config.GetFormattedHostUrl();
+            var token = await GetToken(formattedUrl);
+            /*var releases = await PerformQuery(new TorznabQuery(), formattedUrl);
+            if (releases.Length == 0)
+                throw new Exception("Could not find releases from this URL");*/
+
+            BaseUrl = formattedUrl;
+
+            var configSaveData = new JObject();
+            configSaveData["base_url"] = BaseUrl;
+
+            if (OnSaveConfigurationRequested != null)
+                OnSaveConfigurationRequested(this, configSaveData);
+
+            IsConfigured = true;
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            BaseUrl = (string)jsonConfig["base_url"];
+            IsConfigured = true;
+        }
+
+        HttpRequestMessage CreateHttpRequest(string uri)
+        {
+            var message = new HttpRequestMessage();
+            message.Method = HttpMethod.Get;
+            message.RequestUri = new Uri(uri);
+            message.Headers.UserAgent.ParseAdd(chromeUserAgent);
+            return message;
+        }
+
+        async Task<string> GetToken(string url)
+        {
+            var request = CreateHttpRequest(url + TokenUrl);
+            var response = await client.SendAsync(request);
+            var result = await response.Content.ReadAsStringAsync();
+            JObject obj = JObject.Parse(result);
+            return (string)obj["token"];
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            return await PerformQuery(query, BaseUrl);
+        }
+
+        async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query, string baseUrl)
+        {
+
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            string token = await GetToken(baseUrl);
+            string searchUrl;
+            if (query.RageID != 0)
+                searchUrl = string.Format(baseUrl + SearchTVRageUrl, query.RageID, token);
+            else
+                searchUrl = string.Format(baseUrl + SearchQueryUrl, query.SearchTerm, token);
+
+            var request = CreateHttpRequest(searchUrl);
+            var response = await client.SendAsync(request);
+            var results = await response.Content.ReadAsStringAsync();
+            try
+            {
+                var jItems = JArray.Parse(results);
+                foreach (JObject item in jItems)
+                {
+                    var release = new ReleaseInfo();
+                    release.Title = (string)item["f"];
+                    release.MagnetUri = new Uri((string)item["d"]);
+                    release.Guid = release.MagnetUri;
+                    release.PublishDate = new DateTime(1970, 1, 1);
+                    release.Size = 0;
+                    release.Seeders = 1;
+                    release.Peers = 1;
+                    release.MinimumRatio = 1;
+                    release.MinimumSeedTime = 172800;
+                    releases.Add(release);
+                }
+            }
+            catch (Exception ex)
+            {
+                OnResultParsingError(this, results, ex);
+            }
+            return releases.ToArray();
+
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/Jackett/Indexers/Strike.cs

@@ -0,0 +1,155 @@
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class Strike : IndexerInterface
+    {
+
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "Strike"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "Torrent search engine"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(DefaultUrl); }
+        }
+
+        public bool IsConfigured { get; private set; }
+
+        const string DefaultUrl = "https://getstrike.net";
+
+        const string DownloadUrl = "/api/v2/torrents/download/?hash={0}";
+        const string SearchUrl = "/api/v2/torrents/search/?category=TV&phrase={0}";
+        string BaseUrl;
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public Strike()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataUrl(DefaultUrl);
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataUrl(DefaultUrl);
+            config.LoadValuesFromJson(configJson);
+
+            var formattedUrl = config.GetFormattedHostUrl();
+            var releases = await PerformQuery(new TorznabQuery(), formattedUrl);
+            if (releases.Length == 0)
+                throw new Exception("Could not find releases from this URL");
+
+            BaseUrl = formattedUrl;
+
+            var configSaveData = new JObject();
+            configSaveData["base_url"] = BaseUrl;
+
+            if (OnSaveConfigurationRequested != null)
+                OnSaveConfigurationRequested(this, configSaveData);
+
+            IsConfigured = true;
+
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            BaseUrl = (string)jsonConfig["base_url"];
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query, string baseUrl)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { "2015" })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = baseUrl + string.Format(SearchUrl, HttpUtility.UrlEncode(searchString.Trim()));
+                var results = await client.GetStringAsync(episodeSearchUrl);
+                try
+                {
+                    var jResults = JObject.Parse(results);
+                    foreach (JObject result in (JArray)jResults["torrents"])
+                    {
+                        var release = new ReleaseInfo();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+
+                        release.Title = (string)result["torrent_title"];
+                        release.Description = release.Title;
+                        release.Seeders = (int)result["seeds"];
+                        release.Peers = (int)result["leeches"] + release.Seeders;
+                        release.Size = (long)result["size"];
+
+                        // "Apr  2, 2015", "Apr 12, 2015" (note the spacing)
+                        var dateString = string.Join(" ", ((string)result["upload_date"]).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries));
+                        release.PublishDate = DateTime.ParseExact(dateString, "MMM d, yyyy", CultureInfo.InvariantCulture);
+
+                        release.Guid = new Uri((string)result["page"]);
+                        release.Comments = release.Guid;
+
+                        release.InfoHash = (string)result["torrent_hash"];
+                        release.MagnetUri = new Uri((string)result["magnet_uri"]);
+                        release.Link = new Uri(string.Format("{0}{1}{2}", baseUrl, DownloadUrl, release.InfoHash));
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+
+            return releases.ToArray();
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            return await PerformQuery(query, BaseUrl);
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            throw new NotImplementedException();
+        }
+
+
+    }
+}

src/Jackett/Indexers/ThePirateBay.cs

@@ -16,34 +16,22 @@ namespace Jackett.Indexers
     public class ThePirateBay : IndexerInterface
     {
 
-        class ThePirateBayConfig : ConfigurationData
-        {
-            public StringItem Url { get; private set; }
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
 
-            public ThePirateBayConfig()
-            {
-                Url = new StringItem { Name = "Url", Value = "https://thepiratebay.se/" };
-            }
-
-            public override Item[] GetItems()
-            {
-                return new Item[] { Url };
-            }
-        }
-
-        public event Action<IndexerInterface, Newtonsoft.Json.Linq.JToken> OnSaveConfigurationRequested;
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
 
         public string DisplayName { get { return "The Pirate Bay"; } }
 
         public string DisplayDescription { get { return "The worlds largest bittorrent indexer"; } }
 
-        public Uri SiteLink { get { return new Uri("https://thepiratebay.se/"); } }
+        public Uri SiteLink { get { return new Uri(DefaultUrl); } }
 
         public bool IsConfigured { get; private set; }
 
-        static string SearchUrl = "s/?q=\"{0}\"&category=205&page=0&orderby=99";
-        static string BrowserUrl = "browse/200";
-        static string SwitchSingleViewUrl = "switchview.php?view=s";
+        const string DefaultUrl = "https://thepiratebay.gd";
+        const string SearchUrl = "/s/?q=\"{0}\"&category=205&page=0&orderby=99";
+        const string SearchUrl2 = "/s/?q=\"{0}\"&category=208&page=0&orderby=99";
+        const string SwitchSingleViewUrl = "/switchview.php?view=s";
 
         string BaseUrl;
 
@@ -51,7 +39,6 @@ namespace Jackett.Indexers
         HttpClientHandler handler;
         HttpClient client;
 
-
         public ThePirateBay()
         {
             IsConfigured = false;
@@ -67,24 +54,21 @@ namespace Jackett.Indexers
 
         public Task<ConfigurationData> GetConfigurationForSetup()
         {
-            var config = new ThePirateBayConfig();
+            var config = new ConfigurationDataUrl(DefaultUrl);
             return Task.FromResult<ConfigurationData>(config);
         }
 
         public async Task ApplyConfiguration(JToken configJson)
         {
-            var config = new ThePirateBayConfig();
+            var config = new ConfigurationDataUrl(DefaultUrl);
             config.LoadValuesFromJson(configJson);
-            await TestBrowse(config.Url.Value);
-            BaseUrl = new Uri(config.Url.Value).ToString();
 
-            var message = new HttpRequestMessage
-            {
-                Method = HttpMethod.Get,
-                RequestUri = new Uri(BaseUrl + SwitchSingleViewUrl)
-            };
-            message.Headers.Referrer = new Uri(BaseUrl + BrowserUrl);
-            var response = await client.SendAsync(message);
+            var formattedUrl = config.GetFormattedHostUrl();
+            var releases = await PerformQuery(new TorznabQuery(), formattedUrl);
+            if (releases.Length == 0)
+                throw new Exception("Could not find releases from this URL");
+
+            BaseUrl = formattedUrl;
 
             var configSaveData = new JObject();
             configSaveData["base_url"] = BaseUrl;
@@ -95,21 +79,6 @@ namespace Jackett.Indexers
             IsConfigured = true;
         }
 
-        public async Task VerifyConnection()
-        {
-            await TestBrowse(BaseUrl);
-        }
-
-
-        async Task TestBrowse(string url)
-        {
-            var result = await client.GetStringAsync(new Uri(url) + BrowserUrl);
-            if (!result.Contains("<table id=\"searchResult\">"))
-            {
-                throw new Exception("Could not detect The Pirate Bay content");
-            }
-        }
-
         public void LoadFromSavedConfiguration(JToken jsonConfig)
         {
             BaseUrl = (string)jsonConfig["base_url"];
@@ -117,71 +86,102 @@ namespace Jackett.Indexers
         }
 
         public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            return await PerformQuery(query, BaseUrl);
+        }
+
+        async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query, string baseUrl)
         {
             List<ReleaseInfo> releases = new List<ReleaseInfo>();
 
+            List<string> searchUrls = new List<string>();
+
             foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
             {
                 var searchString = title + " " + query.GetEpisodeSearchString();
-                var episodeSearchUrl = BaseUrl + string.Format(SearchUrl, HttpUtility.UrlEncode(searchString));
+                var queryStr = HttpUtility.UrlEncode(searchString);
+                var episodeSearchUrl = baseUrl + string.Format(SearchUrl, queryStr);
+                var episodeSearchUrl2 = baseUrl + string.Format(SearchUrl2, queryStr);
+                searchUrls.Add(episodeSearchUrl);
+                searchUrls.Add(episodeSearchUrl2);
+            }
 
+            foreach (var episodeSearchUrl in searchUrls)
+            {
                 var message = new HttpRequestMessage
                 {
                     Method = HttpMethod.Get,
-                    RequestUri = new Uri(BaseUrl + SwitchSingleViewUrl)
+                    RequestUri = new Uri(baseUrl + SwitchSingleViewUrl)
                 };
                 message.Headers.Referrer = new Uri(episodeSearchUrl);
 
-                var response = await client.SendAsync(message);
-                var results = await response.Content.ReadAsStringAsync();
+                string results;
 
-                CQ dom = results;
-
-                var rows = dom["#searchResult > tbody > tr"];
-                foreach (var row in rows)
+                if (Program.IsWindows)
                 {
-                    var release = new ReleaseInfo();
-                    CQ qRow = row.Cq();
-                    CQ qLink = row.ChildElements.ElementAt(1).Cq().Children("a").First();
+                    var response = await client.SendAsync(message);
+                    results = await response.Content.ReadAsStringAsync();
+                }
+                else
+                {
+                    var response = await CurlHelper.GetAsync(baseUrl + SwitchSingleViewUrl, null, episodeSearchUrl);
+                    results = Encoding.UTF8.GetString(response.Content);
+                }
+                try
+                {
+                    CQ dom = results;
 
-                    release.MinimumRatio = 1;
-                    release.MinimumSeedTime = 172800;
-                    release.Title = qLink.Text().Trim();
-                    release.Description = release.Title;
-                    release.Comments = new Uri(BaseUrl + qLink.Attr("href").TrimStart('/'));
-                    release.Guid = release.Comments;
-
-                    var timeString = row.ChildElements.ElementAt(2).Cq().Text();
-                    if (timeString.Contains("mins ago"))
-                        release.PublishDate = (DateTime.Now - TimeSpan.FromMinutes(int.Parse(timeString.Split(' ')[0])));
-                    else if (timeString.Contains("Today"))
-                        release.PublishDate = (DateTime.UtcNow - TimeSpan.FromHours(2) - TimeSpan.Parse(timeString.Split(' ')[1])).ToLocalTime();
-                    else if (timeString.Contains("Y-day"))
-                        release.PublishDate = (DateTime.UtcNow - TimeSpan.FromHours(26) - TimeSpan.Parse(timeString.Split(' ')[1])).ToLocalTime();
-                    else if (timeString.Contains(':'))
+                    var rows = dom["#searchResult > tbody > tr"];
+                    foreach (var row in rows)
                     {
-                        var utc = DateTime.ParseExact(timeString, "MM-dd HH:mm", CultureInfo.InvariantCulture) - TimeSpan.FromHours(2);
-                        release.PublishDate = DateTime.SpecifyKind(utc, DateTimeKind.Utc).ToLocalTime();
+                        var release = new ReleaseInfo();
+
+                        CQ qLink = row.ChildElements.ElementAt(1).Cq().Children("a").First();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Title = qLink.Text().Trim();
+                        release.Description = release.Title;
+                        release.Comments = new Uri(baseUrl + "/" + qLink.Attr("href").TrimStart('/'));
+                        release.Guid = release.Comments;
+
+                        var timeString = row.ChildElements.ElementAt(2).Cq().Text();
+                        if (timeString.Contains("mins ago"))
+                            release.PublishDate = (DateTime.Now - TimeSpan.FromMinutes(int.Parse(timeString.Split(' ')[0])));
+                        else if (timeString.Contains("Today"))
+                            release.PublishDate = (DateTime.UtcNow - TimeSpan.FromHours(2) - TimeSpan.Parse(timeString.Split(' ')[1])).ToLocalTime();
+                        else if (timeString.Contains("Y-day"))
+                            release.PublishDate = (DateTime.UtcNow - TimeSpan.FromHours(26) - TimeSpan.Parse(timeString.Split(' ')[1])).ToLocalTime();
+                        else if (timeString.Contains(':'))
+                        {
+                            var utc = DateTime.ParseExact(timeString, "MM-dd HH:mm", CultureInfo.InvariantCulture) - TimeSpan.FromHours(2);
+                            release.PublishDate = DateTime.SpecifyKind(utc, DateTimeKind.Utc).ToLocalTime();
+                        }
+                        else
+                        {
+                            var utc = DateTime.ParseExact(timeString, "MM-dd yyyy", CultureInfo.InvariantCulture) - TimeSpan.FromHours(2);
+                            release.PublishDate = DateTime.SpecifyKind(utc, DateTimeKind.Utc).ToLocalTime();
+                        }
+
+                        var downloadCol = row.ChildElements.ElementAt(3).Cq().Find("a");
+                        release.MagnetUri = new Uri(downloadCol.Attr("href"));
+                        release.InfoHash = release.MagnetUri.ToString().Split(':')[3].Split('&')[0];
+
+                        var sizeString = row.ChildElements.ElementAt(4).Cq().Text().Split(' ');
+                        var sizeVal = float.Parse(sizeString[0]);
+                        var sizeUnit = sizeString[1];
+                        release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
+
+                        release.Seeders = int.Parse(row.ChildElements.ElementAt(5).Cq().Text());
+                        release.Peers = int.Parse(row.ChildElements.ElementAt(6).Cq().Text()) + release.Seeders;
+
+                        releases.Add(release);
                     }
-                    else
-                    {
-                        var utc = DateTime.ParseExact(timeString, "MM-dd yyyy", CultureInfo.InvariantCulture) - TimeSpan.FromHours(2);
-                        release.PublishDate = DateTime.SpecifyKind(utc, DateTimeKind.Utc).ToLocalTime();
-                    }
-
-                    var downloadCol = row.ChildElements.ElementAt(3).Cq().Find("a");
-                    release.MagnetUrl = new Uri(downloadCol.Attr("href"));
-                    release.InfoHash = release.MagnetUrl.ToString().Split(':')[3].Split('&')[0];
-
-                    var sizeString = row.ChildElements.ElementAt(4).Cq().Text().Split(' ');
-                    var sizeVal = float.Parse(sizeString[0]);
-                    var sizeUnit = sizeString[1];
-                    release.Size = ReleaseInfo.GetBytes(sizeUnit, sizeVal);
-
-                    release.Seeders = int.Parse(row.ChildElements.ElementAt(5).Cq().Text());
-                    release.Peers = int.Parse(row.ChildElements.ElementAt(6).Cq().Text()) + release.Seeders;
-
-                    releases.Add(release);
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
                 }
             }
             return releases.ToArray();
@@ -193,5 +193,7 @@ namespace Jackett.Indexers
         {
             throw new NotImplementedException();
         }
+
+
     }
 }

src/Jackett/Indexers/TorrentDay.cs

@@ -0,0 +1,195 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class TorrentDay : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "TorrentDay"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return DisplayName; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+        public bool IsConfigured { get; private set; }
+
+        const string BaseUrl = "https://torrentday.eu";
+        const string StartPageUrl = BaseUrl + "/login.php";
+        const string LoginUrl = BaseUrl + "/tak3login.php";
+        const string SearchUrl = BaseUrl + "/browse.php?search={0}&cata=yes&c2=1&c7=1&c14=1&c24=1&c26=1&c31=1&c32=1&c33=1";
+
+        const string chromeUserAgent = "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.118 Safari/537.36";
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public TorrentDay()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        HttpRequestMessage CreateHttpRequest(string uri)
+        {
+            var message = new HttpRequestMessage();
+            message.Method = HttpMethod.Get;
+            message.RequestUri = new Uri(uri);
+            message.Headers.UserAgent.ParseAdd(chromeUserAgent);
+            return message;
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var startMessage = CreateHttpRequest(StartPageUrl);
+            var results = await (await client.SendAsync(startMessage)).Content.ReadAsStringAsync();
+
+
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value }
+			};
+            var content = new FormUrlEncodedContent(pairs);
+            var loginRequest = CreateHttpRequest(LoginUrl);
+            loginRequest.Method = HttpMethod.Post;
+            loginRequest.Content = content;
+            loginRequest.Headers.Referrer = new Uri(StartPageUrl);
+
+            var response = await client.SendAsync(loginRequest);
+            var responseContent = await response.Content.ReadAsStringAsync();
+
+            if (!responseContent.Contains("logout.php"))
+            {
+                CQ dom = responseContent;
+                var messageEl = dom["#login"];
+                messageEl.Children("form").Remove();
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                configSaveData["cookies"] = cookies.ToJson(SiteLink);
+
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), (JArray)jsonConfig["cookies"]);
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = string.Format(SearchUrl, HttpUtility.UrlEncode(searchString));
+                var results = await client.GetStringAsync(episodeSearchUrl);
+                try
+                {
+                    CQ dom = results;
+                    var rows = dom["#torrentTable > tbody > tr.browse"];
+                    foreach (var row in rows)
+                    {
+                        CQ qRow = row.Cq();
+                        var release = new ReleaseInfo();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Title = qRow.Find(".torrentName").Text();
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + "/" + qRow.Find(".torrentName").Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Link = new Uri(BaseUrl + "/" + qRow.Find(".dlLinksInfo > a").Attr("href"));
+
+                        var sizeStr = qRow.Find(".sizeInfo").Text().Trim();
+                        var sizeParts = sizeStr.Split(' ');
+                        release.Size = ReleaseInfo.GetBytes(sizeParts[1], float.Parse(sizeParts[0]));
+
+                        var dateStr = qRow.Find(".ulInfo").Text().Trim();
+                        var dateParts = dateStr.Split(' ');
+                        var dateValue = int.Parse(dateParts[1]);
+                        TimeSpan ts = TimeSpan.Zero;
+                        if (dateStr.Contains("sec"))
+                            ts = TimeSpan.FromSeconds(dateValue);
+                        else if (dateStr.Contains("min"))
+                            ts = TimeSpan.FromMinutes(dateValue);
+                        else if (dateStr.Contains("hour"))
+                            ts = TimeSpan.FromHours(dateValue);
+                        else if (dateStr.Contains("day"))
+                            ts = TimeSpan.FromDays(dateValue);
+                        else if (dateStr.Contains("week"))
+                            ts = TimeSpan.FromDays(dateValue * 7);
+                        else if (dateStr.Contains("month"))
+                            ts = TimeSpan.FromDays(dateValue * 30);
+                        else if (dateStr.Contains("year"))
+                            ts = TimeSpan.FromDays(dateValue * 365);
+                        release.PublishDate = DateTime.Now - ts;
+
+                        release.Seeders = int.Parse(qRow.Find(".seedersInfo").Text(), NumberStyles.AllowThousands);
+                        release.Peers = int.Parse(qRow.Find(".leechersInfo").Text(), NumberStyles.AllowThousands) + release.Seeders;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+            return releases.ToArray();
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            return client.GetByteArrayAsync(link);
+        }
+    }
+}

src/Jackett/Indexers/TorrentLeech.cs

@@ -0,0 +1,178 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class TorrentLeech : IndexerInterface
+    {
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public string DisplayName
+        {
+            get { return "TorrentLeech"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return "This is what happens when you seed"; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+        const string BaseUrl = "http://www.torrentleech.org";
+        const string LoginUrl = BaseUrl + "/user/account/login/";
+        const string SearchUrl = BaseUrl + "/torrents/browse/index/query/{0}/categories/2%2C26%2C27%2C32/orderby/added?";
+
+        public bool IsConfigured { get; private set; }
+
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public TorrentLeech()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value },
+                { "remember_me", "on" },
+                { "login", "submit" }
+			};
+
+            var content = new FormUrlEncodedContent(pairs);
+
+            var response = await client.PostAsync(LoginUrl, content);
+            var responseContent = await response.Content.ReadAsStringAsync();
+
+            if (!responseContent.Contains("/user/account/logout"))
+            {
+                CQ dom = responseContent;
+                var messageEl = dom[".ui-state-error"].Last();
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                configSaveData["cookies"] = cookies.ToJson(SiteLink);
+
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), (JArray)jsonConfig["cookies"]);
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = string.Format(SearchUrl, HttpUtility.UrlEncode(searchString));
+                var results = await client.GetStringAsync(episodeSearchUrl);
+                try
+                {
+                    CQ dom = results;
+
+                    CQ qRows = dom["#torrenttable > tbody > tr"];
+
+                    foreach (var row in qRows)
+                    {
+                        var release = new ReleaseInfo();
+
+                        var qRow = row.Cq();
+
+                        var debug = qRow.Html();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+
+                        CQ qLink = qRow.Find(".title > a").First();
+                        release.Guid = new Uri(BaseUrl + qLink.Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Title = qLink.Text();
+                        release.Description = release.Title;
+
+                        release.Link = new Uri(BaseUrl + qRow.Find(".quickdownload > a").Attr("href"));
+
+                        var dateString = qRow.Find(".name").First()[0].ChildNodes[4].NodeValue.Replace(" on", "").Trim();
+                        //"2015-04-25 23:38:12"
+                        //"yyyy-MMM-dd hh:mm:ss"
+                        release.PublishDate = DateTime.ParseExact(dateString, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
+
+                        var sizeStringParts = qRow.Children().ElementAt(4).InnerText.Split(' ');
+                        release.Size = ReleaseInfo.GetBytes(sizeStringParts[1], float.Parse(sizeStringParts[0]));
+
+                        release.Seeders = int.Parse(qRow.Find(".seeders").Text());
+                        release.Peers = int.Parse(qRow.Find(".leechers").Text());
+
+                        releases.Add(release);
+                    }
+                }
+
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+
+            }
+
+
+            return releases.ToArray();
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            return client.GetByteArrayAsync(link);
+        }
+
+
+
+    }
+}

src/Jackett/Indexers/TorrentShack.cs

@@ -0,0 +1,184 @@
+using CsQuery;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Jackett.Indexers
+{
+    public class TorrentShack : IndexerInterface
+    {
+        public event Action<IndexerInterface, JToken> OnSaveConfigurationRequested;
+
+        public event Action<IndexerInterface, string, Exception> OnResultParsingError;
+
+        public string DisplayName
+        {
+            get { return "TorrentShack"; }
+        }
+
+        public string DisplayDescription
+        {
+            get { return DisplayName; }
+        }
+
+        public Uri SiteLink
+        {
+            get { return new Uri(BaseUrl); }
+        }
+
+        const string BaseUrl = "http://torrentshack.me";
+        const string LoginUrl = BaseUrl + "/login.php";
+        const string SearchUrl = BaseUrl + "/torrents.php?searchstr={0}&release_type=both&searchtags=&tags_type=0&order_by=s3&order_way=desc&torrent_preset=all&filter_cat%5B600%5D=1&filter_cat%5B620%5D=1&filter_cat%5B700%5D=1&filter_cat%5B981%5D=1&filter_cat%5B980%5D=1";
+
+
+        CookieContainer cookies;
+        HttpClientHandler handler;
+        HttpClient client;
+
+        public bool IsConfigured { get; private set; }
+
+        public TorrentShack()
+        {
+            IsConfigured = false;
+            cookies = new CookieContainer();
+            handler = new HttpClientHandler
+            {
+                CookieContainer = cookies,
+                AllowAutoRedirect = true,
+                UseCookies = true,
+            };
+            client = new HttpClient(handler);
+        }
+
+        public Task<ConfigurationData> GetConfigurationForSetup()
+        {
+            var config = new ConfigurationDataBasicLogin();
+            return Task.FromResult<ConfigurationData>(config);
+        }
+
+        public async Task ApplyConfiguration(JToken configJson)
+        {
+            var config = new ConfigurationDataBasicLogin();
+            config.LoadValuesFromJson(configJson);
+
+            var pairs = new Dictionary<string, string> {
+				{ "username", config.Username.Value },
+				{ "password", config.Password.Value },
+                { "keeplogged", "1" },
+                { "login", "Login" }
+			};
+
+            var content = new FormUrlEncodedContent(pairs);
+
+            var response = await client.PostAsync(LoginUrl, content);
+            var responseContent = await response.Content.ReadAsStringAsync();
+
+            if (!responseContent.Contains("logout.php"))
+            {
+                CQ dom = responseContent;
+                var messageEl = dom["#loginform"];
+                messageEl.Children("table").Remove();
+                var errorMessage = messageEl.Text().Trim();
+                throw new ExceptionWithConfigData(errorMessage, (ConfigurationData)config);
+            }
+            else
+            {
+                var configSaveData = new JObject();
+                configSaveData["cookies"] = cookies.ToJson(SiteLink);
+
+                if (OnSaveConfigurationRequested != null)
+                    OnSaveConfigurationRequested(this, configSaveData);
+
+                IsConfigured = true;
+            }
+
+        }
+
+        public void LoadFromSavedConfiguration(JToken jsonConfig)
+        {
+            cookies.FillFromJson(new Uri(BaseUrl), (JArray)jsonConfig["cookies"]);
+            IsConfigured = true;
+        }
+
+        public async Task<ReleaseInfo[]> PerformQuery(TorznabQuery query)
+        {
+            List<ReleaseInfo> releases = new List<ReleaseInfo>();
+
+            foreach (var title in query.ShowTitles ?? new string[] { string.Empty })
+            {
+                var searchString = title + " " + query.GetEpisodeSearchString();
+                var episodeSearchUrl = string.Format(SearchUrl, HttpUtility.UrlEncode(searchString));
+                var results = await client.GetStringAsync(episodeSearchUrl);
+                try
+                {
+                    CQ dom = results;
+                    var rows = dom["#torrent_table > tbody > tr.torrent"];
+                    foreach (var row in rows)
+                    {
+                        CQ qRow = row.Cq();
+                        var release = new ReleaseInfo();
+
+                        release.MinimumRatio = 1;
+                        release.MinimumSeedTime = 172800;
+                        release.Title = qRow.Find(".torrent_name_link").Text();
+                        release.Description = release.Title;
+                        release.Guid = new Uri(BaseUrl + "/" + qRow.Find(".torrent_name_link").Parent().Attr("href"));
+                        release.Comments = release.Guid;
+                        release.Link = new Uri(BaseUrl + "/" + qRow.Find(".torrent_handle_links > a").First().Attr("href"));
+
+                        var dateStr = qRow.Find(".time").Text().Trim();
+                        if (dateStr.ToLower().Contains("just now"))
+                            release.PublishDate = DateTime.Now;
+                        else
+                        {
+                            var dateParts = dateStr.Split(' ');
+                            var dateValue = int.Parse(dateParts[0]);
+                            TimeSpan ts = TimeSpan.Zero;
+                            if (dateStr.Contains("sec"))
+                                ts = TimeSpan.FromSeconds(dateValue);
+                            else if (dateStr.Contains("min"))
+                                ts = TimeSpan.FromMinutes(dateValue);
+                            else if (dateStr.Contains("hour"))
+                                ts = TimeSpan.FromHours(dateValue);
+                            else if (dateStr.Contains("day"))
+                                ts = TimeSpan.FromDays(dateValue);
+                            else if (dateStr.Contains("week"))
+                                ts = TimeSpan.FromDays(dateValue * 7);
+                            else if (dateStr.Contains("month"))
+                                ts = TimeSpan.FromDays(dateValue * 30);
+                            else if (dateStr.Contains("year"))
+                                ts = TimeSpan.FromDays(dateValue * 365);
+                            release.PublishDate = DateTime.Now - ts;
+                        }
+
+                        var sizeStr = qRow.Find(".size")[0].ChildNodes[0].NodeValue.Trim();
+                        var sizeParts = sizeStr.Split(' ');
+                        release.Size = ReleaseInfo.GetBytes(sizeParts[1], float.Parse(sizeParts[0], NumberStyles.AllowThousands));
+                        release.Seeders = int.Parse(qRow.Children().ElementAt(6).InnerText.Trim(), NumberStyles.AllowThousands);
+                        release.Peers = int.Parse(qRow.Children().ElementAt(7).InnerText.Trim(), NumberStyles.AllowThousands) + release.Seeders;
+
+                        releases.Add(release);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnResultParsingError(this, results, ex);
+                    throw ex;
+                }
+            }
+            return releases.ToArray();
+        }
+
+        public Task<byte[]> Download(Uri link)
+        {
+            return client.GetByteArrayAsync(link);
+        }
+    }
+}

src/Jackett/Jackett.csproj

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProjectGuid>{E636D5F8-68B4-4903-B4ED-CCFD9C9E899F}</ProjectGuid>
-    <OutputType>Exe</OutputType>
+    <OutputType>WinExe</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Jackett</RootNamespace>
     <AssemblyName>Jackett</AssemblyName>
@@ -47,40 +47,67 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
+  <PropertyGroup>
+    <ApplicationIcon>jacket_large.ico</ApplicationIcon>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject>Jackett.Program</StartupObject>
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="CsQuery">
       <HintPath>..\packages\CsQuery.1.3.4\lib\net40\CsQuery.dll</HintPath>
     </Reference>
-    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\Newtonsoft.Json.6.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
+    <Reference Include="ModernHttpClient">
+      <HintPath>..\packages\modernhttpclient.2.3.0\lib\Portable-Net45+WinRT45+WP8+WPA81\ModernHttpClient.dll</HintPath>
+    </Reference>
+    <Reference Include="NLog">
+      <HintPath>..\packages\NLog.3.2.0.0\lib\net45\NLog.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Net.Http" />
     <Reference Include="System.Net.Http.WebRequest" />
     <Reference Include="System.Web" />
+    <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
+    <Reference Include="Newtonsoft.Json">
+      <HintPath>..\packages\Newtonsoft.Json.6.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="ApiKey.cs" />
     <Compile Include="ChannelInfo.cs" />
     <Compile Include="ConfigurationData.cs" />
     <Compile Include="ConfigurationDataBasicLogin.cs" />
+    <Compile Include="ConfigurationDataUrl.cs" />
     <Compile Include="CookieContainerExtensions.cs" />
     <Compile Include="DataUrl.cs" />
     <Compile Include="ExceptionWithConfigData.cs" />
+    <Compile Include="HttpClientExtensions.cs" />
     <Compile Include="IndexerInterface.cs" />
     <Compile Include="IndexerManager.cs" />
+    <Compile Include="Indexers\BitHdtv.cs" />
     <Compile Include="Indexers\BitMeTV.cs" />
     <Compile Include="Indexers\Freshon.cs" />
     <Compile Include="Indexers\IPTorrents.cs" />
     <Compile Include="Indexers\MoreThanTV.cs" />
+    <Compile Include="Indexers\Rarbg.cs" />
+    <Compile Include="Indexers\Strike.cs" />
     <Compile Include="Indexers\ThePirateBay.cs" />
+    <Compile Include="Indexers\TorrentDay.cs" />
+    <Compile Include="Indexers\TorrentLeech.cs" />
+    <Compile Include="Indexers\TorrentShack.cs" />
+    <Compile Include="Main.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Main.Designer.cs">
+      <DependentUpon>Main.cs</DependentUpon>
+    </Compile>
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
@@ -95,6 +122,8 @@
     <Compile Include="TorznabQuery.cs" />
     <Compile Include="TVRage.cs" />
     <Compile Include="WebApi.cs" />
+    <Compile Include="CurlHelper.cs" />
+    <Compile Include="Indexers\AlphaRatio.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
@@ -107,12 +136,22 @@
     <None Include="Resources\test.xml" />
   </ItemGroup>
   <ItemGroup>
+    <EmbeddedResource Include="Main.resx">
+      <DependentUpon>Main.cs</DependentUpon>
+    </EmbeddedResource>
     <EmbeddedResource Include="Properties\Resources.resx">
       <Generator>ResXFileCodeGenerator</Generator>
       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
     </EmbeddedResource>
   </ItemGroup>
   <ItemGroup>
+    <Content Include="WebContent\logos\torrentday.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="WebContent\logos\torrentshack.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="jacket_large.ico" />
     <Content Include="WebContent\animate.css">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -128,9 +167,18 @@
     <Content Include="WebContent\crissXcross.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="WebContent\favicon.ico">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="WebContent\handlebars-v3.0.1.js">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="WebContent\jacket_medium.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="WebContent\logos\bithdtv.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="WebContent\logos\bitmetv.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -161,15 +209,29 @@
     <Content Include="WebContent\logos\rarbg.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="WebContent\logos\strike.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="WebContent\logos\thepiratebay.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="WebContent\logos\torrentleech.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="WebContent\setup_indexer.html">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
     <Content Include="Resources\validator_reply.xml" />
+    <Content Include="WebContent\logos\alpharatio.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CurlSharp\CurlSharp.csproj">
+      <Project>{74420A79-CC16-442C-8B1E-7C1B913844F0}</Project>
+      <Name>CurlSharp</Name>
+    </ProjectReference>
   </ItemGroup>
-  <ItemGroup />
   <ItemGroup>
     <BootstrapperPackage Include=".NETFramework,Version=v4.5.1">
       <Visible>False</Visible>

src/Jackett/Main.Designer.cs

@@ -0,0 +1,100 @@
+namespace Jackett
+{
+    partial class Main
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.components = new System.ComponentModel.Container();
+            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Main));
+            this.notifyIcon1 = new System.Windows.Forms.NotifyIcon(this.components);
+            this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
+            this.toolStripMenuItemAutoStart = new System.Windows.Forms.ToolStripMenuItem();
+            this.toolStripMenuItemWebUI = new System.Windows.Forms.ToolStripMenuItem();
+            this.toolStripMenuItemShutdown = new System.Windows.Forms.ToolStripMenuItem();
+            this.contextMenuStrip1.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // notifyIcon1
+            // 
+            this.notifyIcon1.ContextMenuStrip = this.contextMenuStrip1;
+            this.notifyIcon1.Icon = ((System.Drawing.Icon)(resources.GetObject("notifyIcon1.Icon")));
+            this.notifyIcon1.Text = "Jackett";
+            this.notifyIcon1.Visible = true;
+            // 
+            // contextMenuStrip1
+            // 
+            this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
+            this.toolStripMenuItemAutoStart,
+            this.toolStripMenuItemWebUI,
+            this.toolStripMenuItemShutdown});
+            this.contextMenuStrip1.Name = "contextMenuStrip1";
+            this.contextMenuStrip1.Size = new System.Drawing.Size(174, 92);
+            // 
+            // toolStripMenuItemAutoStart
+            // 
+            this.toolStripMenuItemAutoStart.CheckOnClick = true;
+            this.toolStripMenuItemAutoStart.Name = "toolStripMenuItemAutoStart";
+            this.toolStripMenuItemAutoStart.Size = new System.Drawing.Size(173, 22);
+            this.toolStripMenuItemAutoStart.Text = "Auto-start on boot";
+            // 
+            // toolStripMenuItemWebUI
+            // 
+            this.toolStripMenuItemWebUI.Name = "toolStripMenuItemWebUI";
+            this.toolStripMenuItemWebUI.Size = new System.Drawing.Size(173, 22);
+            this.toolStripMenuItemWebUI.Text = "Open Web UI";
+            // 
+            // toolStripMenuItemShutdown
+            // 
+            this.toolStripMenuItemShutdown.Name = "toolStripMenuItemShutdown";
+            this.toolStripMenuItemShutdown.Size = new System.Drawing.Size(173, 22);
+            this.toolStripMenuItemShutdown.Text = "Shutdown";
+            // 
+            // Main
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(326, 176);
+            this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
+            this.Name = "Main";
+            this.ShowInTaskbar = false;
+            this.Text = "Jackett";
+            this.WindowState = System.Windows.Forms.FormWindowState.Minimized;
+            this.contextMenuStrip1.ResumeLayout(false);
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.NotifyIcon notifyIcon1;
+        private System.Windows.Forms.ContextMenuStrip contextMenuStrip1;
+        private System.Windows.Forms.ToolStripMenuItem toolStripMenuItemAutoStart;
+        private System.Windows.Forms.ToolStripMenuItem toolStripMenuItemWebUI;
+        private System.Windows.Forms.ToolStripMenuItem toolStripMenuItemShutdown;
+
+    }
+}

src/Jackett/Main.cs

@@ -0,0 +1,76 @@
+using Microsoft.Win32;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Diagnostics;
+using System.Drawing;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace Jackett
+{
+    public partial class Main : Form
+    {
+        public Main()
+        {
+            Hide();
+            InitializeComponent();
+
+            toolStripMenuItemAutoStart.Checked = AutoStart;
+            toolStripMenuItemAutoStart.CheckedChanged += toolStripMenuItemAutoStart_CheckedChanged;
+
+            toolStripMenuItemWebUI.Click += toolStripMenuItemWebUI_Click;
+            toolStripMenuItemShutdown.Click += toolStripMenuItemShutdown_Click;
+
+            if (Program.IsFirstRun)
+                AutoStart = true;
+        }
+
+        void toolStripMenuItemWebUI_Click(object sender, EventArgs e)
+        {
+            Process.Start("http://127.0.0.1:" + Server.Port);
+        }
+
+        void toolStripMenuItemShutdown_Click(object sender, EventArgs e)
+        {
+            Process.GetCurrentProcess().Kill();
+        }
+
+        void toolStripMenuItemAutoStart_CheckedChanged(object sender, EventArgs e)
+        {
+            AutoStart = toolStripMenuItemAutoStart.Checked;
+        }
+
+        string ProgramTitle
+        {
+            get
+            {
+                return Assembly.GetExecutingAssembly().GetName().Name;
+            }
+        }
+
+        bool AutoStart
+        {
+            get
+            {
+                RegistryKey rkApp = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
+                if (rkApp.GetValue(ProgramTitle) == null)
+                    return false;
+                else
+                    return true;
+            }
+            set
+            {
+                RegistryKey rkApp = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
+                if (value && !AutoStart)
+                    rkApp.SetValue(ProgramTitle, Application.ExecutablePath.ToString());
+                else if (!value && AutoStart)
+                    rkApp.DeleteValue(ProgramTitle, false);
+            }
+        }
+    }
+}

src/Jackett/Program.cs

@@ -1,11 +1,18 @@
-using System;
+using Jackett.Indexers;
+using Newtonsoft.Json.Linq;
+using NLog;
+using NLog.Config;
+using NLog.Targets;
+using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Windows.Forms;
 
 namespace Jackett
 {
@@ -13,59 +20,122 @@ namespace Jackett
     {
         public static string AppConfigDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Jackett");
 
-        public static ManualResetEvent ExitEvent = new ManualResetEvent(false);
+        public static Server ServerInstance { get; private set; }
+
+        public static bool IsFirstRun { get; private set; }
+
+        public static Logger LoggerInstance { get; private set; }
+
+        public static ManualResetEvent ExitEvent { get; private set; }
+
+        public static bool IsWindows { get { return Environment.OSVersion.Platform == PlatformID.Win32NT; } }
+
+
 
         static void Main(string[] args)
         {
-            //var descRegex = new Regex("Uploaded (?<month>.*?)-(?<day>.*?) (?<year>.*?), Size (?<size>.*?) (?<unit>.*?), ULed");
-            var descRegex = new Regex("Uploaded (?<month>.*?)-(?<day>.*?) (?<year>.*?), Size (?<size>.*?) (?<unit>.*?), ULed by");
-            var m = descRegex.Match(("Uploaded 06-03 2013, Size 329.84 MiB, ULed by"));
-            List<string> matches = new List<string>();
-            var date = m.Groups["month"].Value;
-            for (var i = 0; i < m.Groups.Count; i++)
+            ExitEvent = new ManualResetEvent(false);
+
+            try
             {
-                var group = m.Groups[i];
-                matches.Add(group.Value); ;
+                if (!Directory.Exists(AppConfigDirectory))
+                {
+                    IsFirstRun = true;
+                    Directory.CreateDirectory(AppConfigDirectory);
+                }
+                Console.WriteLine("App config/log directory: " + AppConfigDirectory);
             }
-            //Uploaded 08-02&nbsp;2007, Size 47.15&nbsp;MiB, ULed
-            //Uploaded (<date>.*?)&nbsp;2007, Size 47.15&nbsp;MiB, ULed
-
-            var resultPage = new ResultPage(new ChannelInfo
+            catch (Exception ex)
             {
-                Title = "HDAccess",
-                Description = "Jackett for HDAccess",
-                Link = new Uri("http://hdaccess.net"),
-                ImageUrl = new Uri("https://hdaccess.net/logo_small.png"),
-                ImageTitle = "HDAccess",
-                ImageLink = new Uri("https://hdaccess.net"),
-                ImageDescription = "Jackett for HDAccess"
+                MessageBox.Show("Could not create settings directory. " + ex.Message);
+                Application.Exit();
+                return;
+            }
+
+            var logConfig = new LoggingConfiguration();
+
+            var logFile = new FileTarget();
+            logConfig.AddTarget("file", logFile);
+            logFile.Layout = "${longdate} ${level} ${message} \n ${exception:format=ToString}\n";
+            logFile.FileName = Path.Combine(AppConfigDirectory, "log.txt");
+            logFile.ArchiveFileName = "log.{#####}.txt";
+            logFile.ArchiveAboveSize = 500000;
+            logFile.MaxArchiveFiles = 1;
+            logFile.KeepFileOpen = false;
+            logFile.ArchiveNumbering = ArchiveNumberingMode.DateAndSequence;
+            var logFileRule = new LoggingRule("*", LogLevel.Debug, logFile);
+            logConfig.LoggingRules.Add(logFileRule);
+
+            if (Program.IsWindows)
+            {
+                var logAlert = new MessageBoxTarget();
+                logConfig.AddTarget("alert", logAlert);
+                logAlert.Layout = "${message}";
+                logAlert.Caption = "Alert";
+                var logAlertRule = new LoggingRule("*", LogLevel.Fatal, logAlert);
+                logConfig.LoggingRules.Add(logAlertRule);
+            }
+
+            var logConsole = new ConsoleTarget();
+            logConfig.AddTarget("console", logConsole);
+            logConsole.Layout = "${longdate} ${level} ${message} ${exception:format=ToString}";
+            var logConsoleRule = new LoggingRule("*", LogLevel.Debug, logConsole);
+            logConfig.LoggingRules.Add(logConsoleRule);
+
+            LogManager.Configuration = logConfig;
+            LoggerInstance = LogManager.GetCurrentClassLogger();
+
+            ReadSettingsFile();
+
+            var serverTask = Task.Run(async () =>
+            {
+                ServerInstance = new Server();
+                await ServerInstance.Start();
             });
 
-            resultPage.Releases.Add(new ReleaseInfo
+            try
             {
-                Title = "Better Call Saul S01E05 Alpine Shepherd 1080p NF WEBRip DD5.1 x264",
-                Guid = new Uri("https://hdaccess.net/details.php?id=11515"),
-                Link = new Uri("https://hdaccess.net/download.php?torrent=11515&amp;passkey=123456"),
-                Comments = new Uri("https://hdaccess.net/details.php?id=11515&amp;hit=1#comments"),
-                PublishDate = DateTime.Now,
-                Category = "HDTV 1080p",
-                Size = 2538463390,
-                Description = "Better.Call.Saul.S01E05.Alpine.Shepherd.1080p.NF.WEBRip.DD5.1.x264.torrent",
-                Seeders = 7,
-                Peers = 6,
-                InfoHash = "63e07ff523710ca268567dad344ce1e0e6b7e8a3",
-                MinimumRatio = 1.0,
-                MinimumSeedTime = 172800
-            });
-
-            var f = resultPage.ToXml(new Uri("http://localhost:9117"));
-
-            Task.Run(() =>
+                if (Program.IsWindows)
+                    Application.Run(new Main());
+            }
+            catch (Exception)
             {
-                var server = new Server();
-                server.Start();
-            });
-            ExitEvent.WaitOne();
+
+            }
+
+            Console.WriteLine("Running in headless mode.");
+
+
+
+            Task.WaitAll(serverTask);
+            Console.WriteLine("Server thread exit");
+        }
+
+        static void ReadSettingsFile()
+        {
+            var path = Path.Combine(AppConfigDirectory, "config.json");
+            if (!File.Exists(path))
+            {
+                JObject f = new JObject();
+                f.Add("port", Server.DefaultPort);
+                f.Add("public", true);
+                File.WriteAllText(path, f.ToString());
+            }
+
+            var configJson = JObject.Parse(File.ReadAllText(path));
+            int port = (int)configJson.GetValue("port");
+            Server.Port = port;
+
+            Server.ListenPublic = (bool)configJson.GetValue("public");
+
+            Console.WriteLine("Config file path: " + path);
+        }
+
+        static public void RestartAsAdmin()
+        {
+            var startInfo = new ProcessStartInfo(Application.ExecutablePath.ToString()) { Verb = "runas" };
+            Process.Start(startInfo);
+            Environment.Exit(0);
         }
     }
 }

src/Jackett/ReleaseInfo.cs

@@ -24,7 +24,7 @@ namespace Jackett
         public Uri ConverUrl { get; set; }
         public Uri BannerUrl { get; set; }
         public string InfoHash { get; set; }
-        public Uri MagnetUrl { get; set; }
+        public Uri MagnetUri { get; set; }
         public double? MinimumRatio { get; set; }
         public long? MinimumSeedTime { get; set; }
 

src/Jackett/ResultPage.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Xml;
 using System.Xml.Linq;
@@ -25,6 +27,7 @@ namespace Jackett
 
         string xmlDateFormat(DateTime dt)
         {
+            Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
             //Sat, 14 Mar 2015 17:10:42 -0400
             var f = string.Format(@"{0:ddd, dd MMM yyyy HH:mm:ss }{1}", dt, string.Format("{0:zzz}", dt).Replace(":", ""));
             return f;
@@ -66,19 +69,19 @@ namespace Jackett
                         select new XElement("item",
                             new XElement("title", r.Title),
                             new XElement("guid", r.Guid),
-                            new XElement("comments", r.Comments.ToString()),
-                            new XElement("pubDate", xmlDateFormat(r.PublishDate)),
-                            new XElement("size", r.Size),
+                            r.Comments == null ? null : new XElement("comments", r.Comments.ToString()),
+                            r.PublishDate == DateTime.MinValue ? null : new XElement("pubDate", xmlDateFormat(r.PublishDate)),
+                            r.Size == null ? null : new XElement("size", r.Size),
                             new XElement("description", r.Description),
-                            new XElement("link", r.Link ?? r.MagnetUrl),
+                            new XElement("link", r.Link ?? r.MagnetUri),
                             r.Category == null ? null : new XElement("category", r.Category),
                             new XElement(
                                 "enclosure",
-                                new XAttribute("url", r.Link ?? r.MagnetUrl),
-                                new XAttribute("length", r.Size),
-                                new XAttribute("type", r.Link == null ? "application/x-bittorrent;x-scheme-handler/magnet" : "application/x-bittorrent")
+                                new XAttribute("url", r.Link ?? r.MagnetUri),
+                                r.Size == null ? null : new XAttribute("length", r.Size),
+                                new XAttribute("type", "application/x-bittorrent")
                             ),
-                            getTorznabElement("magneturl", r.MagnetUrl),
+                            getTorznabElement("magneturl", r.MagnetUri),
                             getTorznabElement("rageid", r.RageID),
                             getTorznabElement("seeders", r.Seeders),
                             getTorznabElement("peers", r.Peers),

src/Jackett/Server.cs

@@ -2,32 +2,40 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Specialized;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Net;
 using System.Text;
 using System.Threading.Tasks;
 using System.Web;
+using System.Windows.Forms;
 
 namespace Jackett
 {
     public class Server
     {
+        public const int DefaultPort = 9117;
+        public static int Port = DefaultPort;
+        public static bool ListenPublic = true;
+
         HttpListener listener;
         IndexerManager indexerManager;
         WebApi webApi;
         SonarrApi sonarrApi;
 
+
         public Server()
         {
+            // Allow all SSL.. sucks I know but mono on linux is having problems without it..
+            ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
+
             LoadApiKey();
 
             indexerManager = new IndexerManager();
             sonarrApi = new SonarrApi();
             webApi = new WebApi(indexerManager, sonarrApi);
 
-            listener = new HttpListener();
-            listener.Prefixes.Add("http://*:9117/");
         }
 
         void LoadApiKey()
@@ -42,13 +50,79 @@ namespace Jackett
             }
         }
 
-        public async void Start()
+        public async Task Start()
         {
-            listener.Start();
+            Program.LoggerInstance.Info("Starting HTTP server on port " + Port + " listening " + (ListenPublic ? "publicly" : "privately"));
+
+            try
+            {
+                listener = new HttpListener();
+
+                if (ListenPublic)
+                {
+                    listener.Prefixes.Add(string.Format("http://*:{0}/", Port));
+                }
+                else
+                {
+                    listener.Prefixes.Add(string.Format("http://127.0.0.1:{0}/", Port));
+                }
+
+                listener.Start();
+            }
+            catch (HttpListenerException ex)
+            {
+                if (ex.ErrorCode == 5)
+                {
+                    var errorStr = "App must be ran as admin for permission to use port "
+                                                  + Port + Environment.NewLine + "Restart app with admin privileges?";
+                    if (Program.IsWindows)
+                    {
+                        var dialogResult = MessageBox.Show(errorStr, "Error", MessageBoxButtons.YesNo);
+                        if (dialogResult == DialogResult.No)
+                        {
+                            Application.Exit();
+                            return;
+                        }
+                        else
+                        {
+                            Program.RestartAsAdmin();
+                        }
+                    }
+                }
+                else
+                    Program.LoggerInstance.FatalException("Failed to start HTTP server. " + ex.Message, ex);
+            }
+            catch (Exception ex)
+            {
+                Program.LoggerInstance.ErrorException("Error starting HTTP server: " + ex.Message, ex);
+                return;
+            }
+
+            Program.LoggerInstance.Info("Server started on port " + Port);
+            Program.LoggerInstance.Info("Accepting only requests from local system: " + (!ListenPublic));
+
             while (true)
             {
-                var context = await listener.GetContextAsync();
-                ProcessHttpRequest(context);
+                Exception error = null;
+                try
+                {
+                    error = null;
+                    var context = await listener.GetContextAsync();
+                    ProcessHttpRequest(context);
+                }
+                catch (ObjectDisposedException ex)
+                {
+                    Program.LoggerInstance.ErrorException("Critical error, HTTP listener was destroyed", ex);
+                    Process.GetCurrentProcess().Kill();
+                }
+                catch (Exception ex)
+                {
+                    error = ex;
+                    Program.LoggerInstance.ErrorException("Error processing HTTP request", ex);
+                }
+
+                if (error != null)
+                    await Task.Delay(TimeSpan.FromSeconds(5));
             }
         }
 
@@ -60,6 +134,7 @@ namespace Jackett
 
         async void ProcessHttpRequest(HttpListenerContext context)
         {
+            Program.LoggerInstance.Trace("Received request: " + context.Request.Url.ToString());
             Exception exception = null;
             try
             {
@@ -80,6 +155,7 @@ namespace Jackett
             catch (Exception ex)
             {
                 exception = ex;
+                Program.LoggerInstance.ErrorException(ex.Message + ex.ToString(), ex);
             }
 
             if (exception != null)
@@ -89,10 +165,18 @@ namespace Jackett
                     var errorBytes = Encoding.UTF8.GetBytes(exception.Message);
                     await context.Response.OutputStream.WriteAsync(errorBytes, 0, errorBytes.Length);
                 }
-                catch (Exception) { }
+                catch (Exception)
+                {
+                }
             }
 
-            context.Response.Close();
+            try
+            {
+                context.Response.Close();
+            }
+            catch (Exception)
+            {
+            }
 
         }
 
@@ -101,8 +185,6 @@ namespace Jackett
 
             var query = HttpUtility.ParseQueryString(context.Request.Url.Query);
             var inputStream = context.Request.InputStream;
-            var reader = new StreamReader(inputStream, context.Request.ContentEncoding);
-            var bytes = await reader.ReadToEndAsync();
 
             var indexerId = context.Request.Url.Segments[2].TrimEnd('/').ToLower();
             var indexer = indexerManager.GetIndexer(indexerId);
@@ -118,10 +200,15 @@ namespace Jackett
 
             var torznabQuery = TorznabQuery.FromHttpQuery(query);
 
-            torznabQuery.ShowTitles = await sonarrApi.GetShowTitle(torznabQuery.RageID);
+            if (torznabQuery.RageID != 0)
+                torznabQuery.ShowTitles = await sonarrApi.GetShowTitle(torznabQuery.RageID);
+            else if (!string.IsNullOrEmpty(torznabQuery.SearchTerm))
+                torznabQuery.ShowTitles = new string[] { torznabQuery.SearchTerm };
 
             var releases = await indexer.PerformQuery(torznabQuery);
 
+            Program.LoggerInstance.Debug(string.Format("Found {0} releases from {1}", releases.Length, indexer.DisplayName));
+
             var severUrl = string.Format("{0}://{1}:{2}/", context.Request.Url.Scheme, context.Request.Url.Host, context.Request.Url.Port);
 
             var resultPage = new ResultPage(new ChannelInfo
@@ -138,6 +225,8 @@ namespace Jackett
             // add Jackett proxy to download links...
             foreach (var release in releases)
             {
+                if (release.Link == null || release.Link.Scheme == "magnet")
+                    continue;
                 var originalLink = release.Link;
                 var encodedLink = HttpServerUtility.UrlTokenEncode(Encoding.UTF8.GetBytes(originalLink.ToString())) + "/download.torrent";
                 var proxyLink = string.Format("{0}api/{1}/download/{2}", severUrl, indexerId, encodedLink);

src/Jackett/SonarApi.cs

@@ -1,5 +1,6 @@
 using Newtonsoft.Json.Linq;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -45,7 +46,7 @@ namespace Jackett
         HttpClientHandler handler;
         HttpClient client;
 
-        Dictionary<int, string[]> IdNameMappings;
+        ConcurrentDictionary<int, string[]> IdNameMappings;
 
         public SonarrApi()
         {
@@ -60,7 +61,7 @@ namespace Jackett
             };
             client = new HttpClient(handler);
 
-            IdNameMappings = new Dictionary<int, string[]>();
+            IdNameMappings = new ConcurrentDictionary<int, string[]>();
         }
 
         async Task ReloadNameMappings(string host, int port, string apiKey)
@@ -74,15 +75,20 @@ namespace Jackett
             foreach (var item in json)
             {
                 var titles = new List<string>();
-                titles.Add((string)item["title"]);
+                titles.Add(SanitizeTitle((string)item["title"]));
                 foreach (var t in item["alternateTitles"])
                 {
-                    titles.Add((string)t["title"]);
+                    titles.Add(SanitizeTitle((string)t["title"]));
                 }
-                IdNameMappings.Add((int)item["tvRageId"], titles.ToArray());
+                IdNameMappings.TryAdd((int)item["tvRageId"], titles.ToArray());
             }
         }
 
+        string SanitizeTitle(string title)
+        {
+            return title.Replace("(", "").Replace(")", "");
+        }
+
         void LoadSettings()
         {
             try

src/Jackett/TorznabQuery.cs

@@ -20,6 +20,7 @@ namespace Jackett
         public int Season { get; private set; }
         public string Episode { get; private set; }
         public string[] ShowTitles { get; set; }
+        public string SearchTerm { get; set; }
 
         public string GetEpisodeSearchString()
         {
@@ -30,6 +31,8 @@ namespace Jackett
             DateTime showDate;
             if (DateTime.TryParseExact(string.Format("{0} {1}", Season, Episode), "yyyy MM/dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out showDate))
                 episodeString = showDate.ToString("yyyy.MM.dd");
+            else if (string.IsNullOrEmpty(Episode))
+                episodeString = string.Format("S{0:00}", Season);
             else
                 episodeString = string.Format("S{0:00}E{1:00}", Season, int.Parse(Episode));
 
@@ -42,6 +45,7 @@ namespace Jackett
             //{t=tvsearch&cat=5030%2c5040&extended=1&apikey=test&offset=0&limit=100&rid=24493&season=5&ep=1}
             var q = new TorznabQuery();
             q.QueryType = query["t"];
+            q.SearchTerm = query["q"];
             q.Categories = query["cat"].Split(',');
             q.Extended = int.Parse(query["extended"]);
             q.ApiKey = query["apikey"];

src/Jackett/WebApi.cs

@@ -13,7 +13,7 @@ namespace Jackett
 {
     public class WebApi
     {
-        static string WebContentFolder = "WebContent";
+        static string WebContentFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "WebContent");
         static string[] StaticFiles = Directory.EnumerateFiles(WebContentFolder, "*", SearchOption.AllDirectories).ToArray();
 
         public enum WebApiMethod
@@ -27,17 +27,17 @@ namespace Jackett
             ApplySonarrConfig,
             TestSonarr
         }
-        static Dictionary<string, WebApiMethod> WebApiMethods = new Dictionary<string, WebApiMethod>
-        {
-            { "get_config_form", WebApiMethod.GetConfigForm },
-            { "configure_indexer", WebApiMethod.ConfigureIndexer },
-            { "get_indexers", WebApiMethod.GetIndexers },
-            { "test_indexer", WebApiMethod.TestIndexer },
-            { "delete_indexer", WebApiMethod.DeleteIndexer },
-            { "get_sonarr_config", WebApiMethod.GetSonarrConfig },
-            { "apply_sonarr_config", WebApiMethod.ApplySonarrConfig },
-            { "test_sonarr", WebApiMethod.TestSonarr }
-        };
+
+        static Dictionary<string, WebApiMethod> WebApiMethods = new Dictionary<string, WebApiMethod> {
+			{ "get_config_form", WebApiMethod.GetConfigForm },
+			{ "configure_indexer", WebApiMethod.ConfigureIndexer },
+			{ "get_indexers", WebApiMethod.GetIndexers },
+			{ "test_indexer", WebApiMethod.TestIndexer },
+			{ "delete_indexer", WebApiMethod.DeleteIndexer },
+			{ "get_sonarr_config", WebApiMethod.GetSonarrConfig },
+			{ "apply_sonarr_config", WebApiMethod.ApplySonarrConfig },
+			{ "test_sonarr", WebApiMethod.TestSonarr }
+		};
 
         IndexerManager indexerManager;
         SonarrApi sonarrApi;
@@ -80,7 +80,9 @@ namespace Jackett
             {
                 await context.Response.OutputStream.WriteAsync(contentFile, 0, contentFile.Length);
             }
-            catch (HttpListenerException) { }
+            catch (HttpListenerException)
+            {
+            }
         }
 
         async Task<JToken> ReadPostDataJson(Stream stream)
@@ -93,8 +95,6 @@ namespace Jackett
 
         async Task ProcessWebApiRequest(HttpListenerContext context, WebApiMethod method)
         {
-            var query = HttpUtility.ParseQueryString(context.Request.Url.Query);
-
             context.Response.ContentType = "text/json";
             context.Response.StatusCode = (int)HttpStatusCode.OK;
 
@@ -131,13 +131,20 @@ namespace Jackett
                     break;
             }
             JToken jsonReply = await handlerTask(context);
-            ReplyWithJson(context, jsonReply);
+            await ReplyWithJson(context, jsonReply, method.ToString());
         }
 
-        async void ReplyWithJson(HttpListenerContext context, JToken json)
+        async Task ReplyWithJson(HttpListenerContext context, JToken json, string apiCall)
         {
-            byte[] jsonBytes = Encoding.UTF8.GetBytes(json.ToString());
-            await context.Response.OutputStream.WriteAsync(jsonBytes, 0, jsonBytes.Length);
+            try
+            {
+                byte[] jsonBytes = Encoding.UTF8.GetBytes(json.ToString());
+                await context.Response.OutputStream.WriteAsync(jsonBytes, 0, jsonBytes.Length);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("Error writing json to stream for API call " + apiCall + Environment.NewLine + ex.ToString());
+            }
         }
 
         async Task<JToken> HandleTestSonarr(HttpListenerContext context)
@@ -228,7 +235,7 @@ namespace Jackett
                 var indexer = indexerManager.GetIndexer(indexerString);
                 jsonReply["name"] = indexer.DisplayName;
                 await indexer.ApplyConfiguration(postData["config"]);
-                await indexer.VerifyConnection();
+                await indexerManager.TestIndexer(indexer);
                 jsonReply["result"] = "success";
             }
             catch (Exception ex)
@@ -281,7 +288,7 @@ namespace Jackett
                 string indexerString = (string)postData["indexer"];
                 var indexer = indexerManager.GetIndexer(indexerString);
                 jsonReply["name"] = indexer.DisplayName;
-                await indexer.VerifyConnection();
+                await indexerManager.TestIndexer(indexer);
                 jsonReply["result"] = "success";
             }
             catch (Exception ex)

src/Jackett/WebContent/index.html

@@ -4,6 +4,8 @@
 <head>
     <meta charset="utf-8" />
 
+    <link rel='shortcut icon' type='image/x-icon' href='/favicon.ico' />
+
     <script src="jquery-2.1.3.min.js"></script>
     <script src="handlebars-v3.0.1.js"></script>
     <script src="bootstrap/bootstrap.min.js"></script>
@@ -26,6 +28,7 @@
             margin: 0 auto;
             margin-top: 30px;
             padding: 20px;
+            margin-bottom: 100px;
         }
 
         .container-fluid {
@@ -181,11 +184,22 @@
         #sonarr-warning {
             display: none;
         }
+
+        #logo {
+            max-width: 50px;
+        }
+
+        #header-title {
+            font-size: 34px;
+            vertical-align: middle;
+            padding-left: 15px;
+        }
     </style>
 </head>
 <body>
     <div id="page">
-        <h3><span>need a logo..</span></h3>
+
+        <img id="logo" src="jacket_medium.png" /><span id="header-title">Jackett</span>
 
         <hr />
 
@@ -233,6 +247,10 @@
                 <div class="modal-body">
                     <div id="unconfigured-indexers">
                     </div>
+                    <hr />
+                    <p>
+                        To add a Jackett indexer in Sonarr go to <b>Settings > Indexers > Add > Torznab > Custom</b>
+                    </p>
                 </div>
                 <div class="modal-footer">
                     <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
@@ -509,6 +527,17 @@
             $("#select-indexer-modal").modal("hide");
         }
 
+        function populateConfigItems(configForm, config) {
+            var $formItemContainer = configForm.find(".config-setup-form");
+            $formItemContainer.empty();
+            var setupItemTemplate = Handlebars.compile($("#templates > .setup-item")[0].outerHTML);
+            for (var i = 0; i < config.length; i++) {
+                var item = config[i];
+                var setupValueTemplate = Handlebars.compile($("#templates > .setup-item-" + item.type)[0].outerHTML);
+                item.value_element = setupValueTemplate(item);
+                $formItemContainer.append(setupItemTemplate(item));
+            }
+        }
 
         function newConfigModal(title, config) {
             //config-setup-modal
@@ -517,15 +546,7 @@
 
             $("#modals").append(configForm);
 
-            var $formItemContainer = configForm.find(".config-setup-form");
-            var setupItemTemplate = Handlebars.compile($("#templates > .setup-item")[0].outerHTML);
-            for (var i = 0; i < config.length; i++) {
-                var item = config[i];
-                var setupValueTemplate = Handlebars.compile($("#templates > .setup-item-" + item.type)[0].outerHTML);
-                item.value_element = setupValueTemplate(item);
-                $formItemContainer.append(setupItemTemplate(item));
-            }
-
+            populateConfigItems(configForm, config);
 
             return configForm;
             //modal.remove();
@@ -565,7 +586,7 @@
                 var jqxhr = $.post("configure_indexer", JSON.stringify(data), function (data) {
                     if (data.result == "error") {
                         if (data.config) {
-                            populateSetupForm(data.indexer, data.name, data.config);
+                            populateConfigItems(configForm, data.config);
                         }
                         doNotify("Configuration failed: " + data.error, "danger", "glyphicon glyphicon-alert");
                     }

src/Jackett/packages.config

@@ -1,5 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="CsQuery" version="1.3.4" targetFramework="net451" />
+  <package id="modernhttpclient" version="2.3.0" targetFramework="net451" />
   <package id="Newtonsoft.Json" version="6.0.8" targetFramework="net451" />
+  <package id="NLog" version="3.2.0.0" targetFramework="net451" />
 </packages>