예제 #1
0
 /// <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>CURL*</c> handle wasn't created successfully.</exception>
 public Easy()
 {
     Curl.EnsureCurl();
     m_pCURL = External.curl_easy_init();
     EnsureHandle();
     External.curl_easy_setopt_int(m_pCURL, CURLoption.CURLOPT_NOPROGRESS,
                                   1);
     m_pMyStrings     = External.curl_shim_alloc_strings();
     m_pfWrite        = null;
     m_privateData    = null;
     m_writeData      = null;
     m_pfRead         = null;
     m_readData       = null;
     m_pfProgress     = null;
     m_progressData   = null;
     m_pfDebug        = null;
     m_debugData      = null;
     m_pfHeader       = null;
     m_headerData     = null;
     m_pfSSLContext   = null;
     m_sslContextData = null;
     m_pfIoctl        = null;
     m_ioctlData      = null;
     InstallDelegates();
 }
예제 #2
0
        /// <summary>
        /// Extract <c>DateTime</c> information from an <c>Easy</c> object.
        /// </summary>
        /// <param name="info">One of the values in the
        /// <see cref="CURLINFO"/> enumeration. In this case, it must
        /// specifically be <see cref="CURLINFO.CURLINFO_FILETIME"/>.
        /// </param>
        /// <param name="dt">Reference to a <c>DateTime</c> value.</param>
        /// <returns>The <see cref="CURLcode"/> obtained from the internal
        /// call to <c>curl_easy_getinfo()</c>.
        /// </returns>
        /// <exception cref="System.NullReferenceException">This is thrown if
        /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
        public CURLcode GetInfo(CURLINFO info, ref DateTime dt)
        {
            EnsureHandle();
            CURLcode retCode = CURLcode.CURLE_OK;
            IntPtr   ptr     = IntPtr.Zero;

            if (info != CURLINFO.CURLINFO_FILETIME)
            {
                return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
            }

            retCode = External.curl_easy_getinfo(m_pCURL, info, ref ptr);
            if (retCode == CURLcode.CURLE_OK)
            {
                if ((int)ptr < 0)
                {
                    dt = new DateTime(0);
                }
                else
                {
                    int yy = 0, mm = 0, dd = 0, hh = 0, mn = 0, ss = 0;
                    External.curl_shim_get_file_time((int)ptr, ref yy,
                                                     ref mm, ref dd, ref hh, ref mn, ref ss);
                    dt = new DateTime(yy, mm, dd, hh, mn, ss);
                }
            }
            return(retCode);
        }
예제 #3
0
        /// <summary>
        /// Obtain status information for a Multi transfer.
        /// </summary>
        /// <returns>
        /// An array of <see cref="MultiInfo"/> objects, one for each
        /// <see cref="Easy"/> object child.
        /// </returns>
        /// <exception cref="System.NullReferenceException">
        /// This is thrown if the native <c>Multi</c> handle wasn't
        /// created successfully.
        /// </exception>
        public MultiInfo[] InfoRead()
        {
            if (m_bGotMultiInfo)
            {
                return(m_multiInfo);
            }
            m_bGotMultiInfo = true;

            int    nMsgs = 0;
            IntPtr pInfo = External.curl_shim_multi_info_read(m_pMulti,
                                                              ref nMsgs);

            if (pInfo != IntPtr.Zero)
            {
                m_multiInfo = new MultiInfo[nMsgs];
                for (int i = 0; i < nMsgs; i++)
                {
                    CURLMSG msg = (CURLMSG)Marshal.ReadInt32(
                        pInfo, i * 12);
                    IntPtr pEasy = Marshal.ReadIntPtr(
                        pInfo, i * 12 + 4);
                    CURLcode code = (CURLcode)Marshal.ReadInt32(
                        pInfo, i * 12 + 8);
                    m_multiInfo[i] = new MultiInfo(msg,
                                                   (Easy)m_htEasy[pEasy], code);
                }
                External.curl_shim_multi_info_free(pInfo);
            }
            return(m_multiInfo);
        }
예제 #4
0
 /// <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 (sm_curlCode == CURLcode.CURLE_OK)
     {
         External.curl_shim_cleanup();
         External.curl_global_cleanup();
         sm_curlCode = CURLcode.CURLE_FAILED_INIT;
     }
 }
예제 #5
0
 /// <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.CURLE_OK</c>.</returns>
 public static CURLcode GlobalInit(int flags)
 {
     sm_curlCode = External.curl_global_init(flags);
     if (sm_curlCode == CURLcode.CURLE_OK)
     {
         External.curl_shim_initialize();
     }
     return(sm_curlCode);
 }
예제 #6
0
        /// <summary>
        /// Remove an Easy object.
        /// </summary>
        /// <param name="easy">
        /// <see cref="Easy"/> object to remove.
        /// </param>
        /// <returns>
        /// A <see cref="CURLMcode"/>, hopefully <c>CURLMcode.CURLM_OK</c>
        /// </returns>
        /// <exception cref="System.NullReferenceException">
        /// This is thrown if the native <c>Multi</c> handle wasn't
        /// created successfully.
        /// </exception>
        public CURLMcode RemoveHandle(Easy easy)
        {
            EnsureHandle();
            IntPtr p = easy.GetHandle();

            m_htEasy.Remove(p);
            return(External.curl_multi_remove_handle(m_pMulti,
                                                     easy.GetHandle()));
        }
예제 #7
0
        /// <summary>
        /// Add an Easy object.
        /// </summary>
        /// <param name="easy">
        /// <see cref="Easy"/> object to add.
        /// </param>
        /// <returns>
        /// A <see cref="CURLMcode"/>, hopefully <c>CURLMcode.CURLM_OK</c>
        /// </returns>
        /// <exception cref="System.NullReferenceException">
        /// This is thrown if the native <c>Multi</c> handle wasn't
        /// created successfully.
        /// </exception>
        public CURLMcode AddHandle(Easy easy)
        {
            EnsureHandle();
            IntPtr p = easy.GetHandle();

            m_htEasy.Add(p, easy);
            return(External.curl_multi_add_handle(m_pMulti,
                                                  easy.GetHandle()));
        }
예제 #8
0
 private void InstallDelegates()
 {
     m_pDelLock   = new External.CURLSH_LOCK_DELEGATE(LockDelegate);
     m_pDelUnlock = new External.CURLSH_UNLOCK_DELEGATE(UnlockDelegate);
     m_hThis      = GCHandle.Alloc(this);
     m_ptrThis    = (IntPtr)m_hThis;
     External.curl_shim_install_share_delegates(m_pShare,
                                                m_ptrThis, m_pDelLock, m_pDelUnlock);
 }
예제 #9
0
        /// <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();
            IntPtr p = External.curl_unescape(url, length);
            String s = Marshal.PtrToStringAnsi(p);

            External.curl_free(p);
            return(s);
        }
예제 #10
0
        private External.CURLSH_UNLOCK_DELEGATE m_pDelUnlock; // unlock delegate

        /// <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 Share()
        {
            Curl.EnsureCurl();
            m_pShare = External.curl_share_init();
            EnsureHandle();
            m_pfLock   = null;
            m_pfUnlock = null;
            m_userData = null;
            InstallDelegates();
        }
예제 #11
0
파일: Slist.cs 프로젝트: frozen4/UnityPlus
 private void Dispose(bool disposing)
 {
     lock (this) {
         // no if (disposing) pattern to clean up managed objects
         if (m_pStringList != IntPtr.Zero)
         {
             External.curl_shim_free_slist(m_pStringList);
             m_pStringList = IntPtr.Zero;
         }
     }
 }
예제 #12
0
        /// <summary>
        /// Extract <c>int</c> information from an <c>Easy</c> object.
        /// </summary>
        /// <param name="info">One of the values in the
        /// <see cref="CURLINFO"/> enumeration. In this case, it must
        /// specifically be one of the members that obtains a <c>double</c>.
        /// </param>
        /// <param name="dblVal">Reference to an <c>double</c> value.</param>
        /// <returns>The <see cref="CURLcode"/> obtained from the internal
        /// call to <c>curl_easy_getinfo()</c>.
        /// </returns>
        /// <exception cref="System.NullReferenceException">This is thrown if
        /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
        public CURLcode GetInfo(CURLINFO info, ref double dblVal)
        {
            EnsureHandle();

            // ensure it's an integral type
            if ((int)info < CURLINFO_DOUBLE)
            {
                return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
            }

            return(External.curl_easy_getinfo_double(m_pCURL, info, ref dblVal));
        }
예제 #13
0
 /// <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>Multi</c> handle wasn't
 /// created successfully.
 /// </exception>
 public Multi()
 {
     Curl.EnsureCurl();
     m_pMulti = External.curl_multi_init();
     EnsureHandle();
     m_fdSets        = IntPtr.Zero;
     m_maxFD         = 0;
     m_fdSets        = External.curl_shim_alloc_fd_sets();
     m_multiInfo     = null;
     m_bGotMultiInfo = false;
     m_htEasy        = new Hashtable();
 }
예제 #14
0
 private void Dispose(bool disposing)
 {
     lock (this) {
         // no if (disposing) pattern to clean up managed objects
         if (m_pItems[0] != IntPtr.Zero)
         {
             External.curl_formfree(m_pItems[0]);
         }
         m_pItems[0] = IntPtr.Zero;
         m_pItems[1] = IntPtr.Zero;
     }
 }
예제 #15
0
 private void Dispose(bool disposing)
 {
     lock (this) {
         // if (disposing) cleanup managed objects
         if (m_pShare != IntPtr.Zero)
         {
             External.curl_shim_cleanup_share_delegates(m_pShare);
             External.curl_share_cleanup(m_pShare);
             m_hThis.Free();
             m_ptrThis = IntPtr.Zero;
             m_pShare  = IntPtr.Zero;
         }
     }
 }
예제 #16
0
        /// <summary>
        /// Set options for this object.
        /// </summary>
        /// <param name="option">
        /// One of the values in the <see cref="CURLSHoption"/>
        /// enumeration.
        /// </param>
        /// <param name="parameter">
        /// An appropriate object based on the value passed in the
        /// <c>option</c> argument. See <see cref="CURLSHoption"/>
        /// for more information about the appropriate parameter type.
        /// </param>
        /// <returns>
        /// A <see cref="CURLSHcode"/>, hopefully
        /// <c>CURLSHcode.CURLSHE_OK</c>.
        /// </returns>
        /// <exception cref="System.NullReferenceException">This is thrown if
        /// the native <c>share</c> handle wasn't created successfully.</exception>
        public CURLSHcode SetOpt(CURLSHoption option, Object parameter)
        {
            EnsureHandle();
            CURLSHcode retCode = CURLSHcode.CURLSHE_OK;

            switch (option)
            {
            case CURLSHoption.CURLSHOPT_LOCKFUNC:
                LockFunction lf = parameter as LockFunction;
                if (lf == null)
                {
                    return(CURLSHcode.CURLSHE_BAD_OPTION);
                }
                m_pfLock = lf;
                break;

            case CURLSHoption.CURLSHOPT_UNLOCKFUNC:
                UnlockFunction ulf = parameter as UnlockFunction;
                if (ulf == null)
                {
                    return(CURLSHcode.CURLSHE_BAD_OPTION);
                }
                m_pfUnlock = ulf;
                break;

            case CURLSHoption.CURLSHOPT_SHARE:
            case CURLSHoption.CURLSHOPT_UNSHARE:
            {
                CURLlockData opt = (CURLlockData)
                                   Convert.ToInt32(parameter);
                if ((opt != CURLlockData.CURL_LOCK_DATA_COOKIE) &&
                    (opt != CURLlockData.CURL_LOCK_DATA_DNS))
                {
                    return(CURLSHcode.CURLSHE_BAD_OPTION);
                }
                retCode = External.curl_share_setopt(m_pShare,
                                                     option, (IntPtr)opt);
                break;
            }

            case CURLSHoption.CURLSHOPT_USERDATA:
                m_userData = parameter;
                break;

            default:
                retCode = CURLSHcode.CURLSHE_BAD_OPTION;
                break;
            }
            return(retCode);
        }
예제 #17
0
 // install the fuctions that will be called from libcurlshim
 private void InstallDelegates()
 {
     m_pDelWrite  = new External.CURL_WRITE_DELEGATE(WriteDelegate);
     m_pDelRead   = new External.CURL_READ_DELEGATE(ReadDelegate);
     m_pDelProg   = new External.CURL_PROGRESS_DELEGATE(ProgressDelegate);
     m_pDelDebug  = new External.CURL_DEBUG_DELEGATE(DebugDelegate);
     m_pDelHeader = new External.CURL_HEADER_DELEGATE(HeaderDelegate);
     m_pDelSSLCtx = new External.CURL_SSL_CTX_DELEGATE(SSLCtxDelegate);
     m_pDelIoctl  = new External.CURL_IOCTL_DELEGATE(IoctlDelegate);
     m_hThis      = GCHandle.Alloc(this);
     m_ptrThis    = (IntPtr)m_hThis;
     External.curl_shim_install_delegates(m_pCURL, m_ptrThis,
                                          m_pDelWrite, m_pDelRead, m_pDelProg,
                                          m_pDelDebug, m_pDelHeader, m_pDelSSLCtx, m_pDelIoctl);
 }
예제 #18
0
 private void Dispose(bool disposing)
 {
     lock (this) {
         // if (disposing) cleanup managed resources
         // cleanup unmanaged resources
         if (m_pCURL != IntPtr.Zero)
         {
             External.curl_shim_cleanup_delegates(m_ptrThis);
             External.curl_easy_cleanup(m_pCURL);
             External.curl_shim_free_strings(m_pMyStrings);
             m_hThis.Free();
             m_pCURL = IntPtr.Zero;
         }
     }
 }
예제 #19
0
 /// <summary>
 /// Perform a transfer.
 /// </summary>
 /// <exception cref="System.NullReferenceException">This is thrown if
 /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
 /// <returns>The <see cref="CURLcode"/> obtained from the internal
 /// call to <c>curl_easy_perform()</c>.
 /// </returns>
 public CURLcode Perform()
 {
     EnsureHandle();
     try
     {
         return((CURLcode)External.curl_easy_perform(m_pCURL));
     }
     catch (Exception e)
     {
         //  this.Cleanup(); //check error with , memory corupted here
         //this.SetOpt(CURLoption.CURLOPT_URL, _URL);
         // return (CURLcode)External.curl_easy_perform(m_pCURL);
         Exception myEx = new Exception("Unable to connect to curl", e);
         myEx.Data.Add("Code", 1);
         throw myEx;
     }
 }
예제 #20
0
 void Dispose(bool disposing)
 {
     lock (this) {
         // if (disposing) // managed member cleanup
         // unmanaged cleanup
         if (m_pMulti != IntPtr.Zero)
         {
             External.curl_multi_cleanup(m_pMulti);
             m_pMulti = IntPtr.Zero;
         }
         if (m_fdSets != IntPtr.Zero)
         {
             External.curl_shim_free_fd_sets(m_fdSets);
             m_fdSets = IntPtr.Zero;
         }
     }
 }
예제 #21
0
        /// <summary>
        /// Extract <c>string</c> information from an <c>Easy</c> object.
        /// </summary>
        /// <param name="info">One of the values in the
        /// <see cref="CURLINFO"/> enumeration. In this case, it must
        /// specifically be one of the members that obtains a <c>string</c>.
        /// </param>
        /// <param name="strVal">Reference to an <c>string</c> value.</param>
        /// <returns>The <see cref="CURLcode"/> obtained from the internal
        /// call to <c>curl_easy_getinfo()</c>.
        /// </returns>
        /// <exception cref="System.NullReferenceException">This is thrown if
        /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
        public CURLcode GetInfo(CURLINFO info, ref string strVal)
        {
            EnsureHandle();
            CURLcode retCode = CURLcode.CURLE_OK;
            IntPtr   ptr     = IntPtr.Zero;

            if ((int)info < CURLINFO_STRING || (int)info >= CURLINFO_LONG)
            {
                return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
            }
            retCode = External.curl_easy_getinfo_ptr(m_pCURL, info, ref ptr);
            if (retCode == CURLcode.CURLE_OK)
            {
                strVal = Marshal.PtrToStringAnsi(ptr);
            }
            return(retCode);
        }
예제 #22
0
        /// <summary>
        /// Extract <c>DateTime</c> information from an <c>Easy</c> object.
        /// </summary>
        /// <param name="info">One of the values in the
        /// <see cref="CURLINFO"/> enumeration. In this case, it must
        /// specifically be <see cref="CURLINFO.CURLINFO_FILETIME"/>.
        /// </param>
        /// <param name="dt">Reference to a <c>DateTime</c> value.</param>
        /// <returns>The <see cref="CURLcode"/> obtained from the internal
        /// call to <c>curl_easy_getinfo()</c>.
        /// </returns>
        /// <exception cref="System.NullReferenceException">This is thrown if
        /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
        public CURLcode GetInfo(CURLINFO info, ref DateTime dt)
        {
            EnsureHandle();
            CURLcode retCode = CURLcode.CURLE_OK;

            if (info != CURLINFO.CURLINFO_FILETIME)
            {
                return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
            }

            int yy = 0, mm = 0, dd = 0, hh = 0, mn = 0, ss = 0;

            retCode = External.curl_easy_getinfo_time(m_pCURL, info, ref yy, ref mm, ref dd, ref hh, ref mn, ref ss);
            if (retCode == CURLcode.CURLE_OK)
            {
                dt = new DateTime(yy, mm, dd, hh, mn, ss);
            }
            return(retCode);
        }
예제 #23
0
        /// <summary>
        /// Extract <c>int</c> information from an <c>Easy</c> object.
        /// </summary>
        /// <param name="info">One of the values in the
        /// <see cref="CURLINFO"/> enumeration. In this case, it must
        /// specifically be one of the members that obtains an <c>int</c>.
        /// </param>
        /// <param name="intVal">Reference to an <c>int</c> value.</param>
        /// <returns>The <see cref="CURLcode"/> obtained from the internal
        /// call to <c>curl_easy_getinfo()</c>.
        /// </returns>
        /// <exception cref="System.NullReferenceException">This is thrown if
        /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
        public CURLcode GetInfo(CURLINFO info, ref int intVal)
        {
            EnsureHandle();
            CURLcode retCode = CURLcode.CURLE_OK;
            IntPtr   ptr     = IntPtr.Zero;

            // ensure it's an integral type
            if ((int)info < CURLINFO_LONG || (int)info >= CURLINFO_DOUBLE)
            {
                return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
            }

            retCode = External.curl_easy_getinfo(m_pCURL, info, ref ptr);
            if (retCode == CURLcode.CURLE_OK)
            {
                intVal = (int)ptr;
            }
            return(retCode);
        }
예제 #24
0
 private Easy(Easy from)
 {
     m_pCURL = External.curl_easy_duphandle(from.m_pCURL);
     EnsureHandle();
     m_pMyStrings     = External.curl_shim_alloc_strings();
     m_pfWrite        = null;
     m_privateData    = null;
     m_writeData      = null;
     m_pfRead         = null;
     m_readData       = null;
     m_pfProgress     = null;
     m_progressData   = null;
     m_pfDebug        = null;
     m_debugData      = null;
     m_pfHeader       = null;
     m_headerData     = null;
     m_pfSSLContext   = null;
     m_sslContextData = null;
     m_pfIoctl        = null;
     m_ioctlData      = null;
     InstallDelegates();
 }
예제 #25
0
        /// <summary>
        /// Extract information from a cURL handle.
        /// </summary>
        /// <param name="info">One of the values in the
        /// <see cref="CURLINFO"/> enumeration.</param>
        /// <param name="objInfo">Reference to an object into which the
        /// value specified by <c>info</c> is written.</param>
        /// <returns>The <see cref="CURLcode"/> obtained from the internal
        /// call to <c>curl_easy_getinfo()</c>.
        /// </returns>
        /// <exception cref="System.NullReferenceException">This is thrown if
        /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
        public CURLcode GetInfo(CURLINFO info, ref Object objInfo)
        {
            EnsureHandle();
            CURLcode retCode = CURLcode.CURLE_OK;
            IntPtr   ptr     = IntPtr.Zero;

            if ((int)info < CURLINFO_STRING)
            {
                return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
            }

            // trickery for filetime
            if (info == CURLINFO.CURLINFO_FILETIME)
            {
                return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
            }

            // private data
            if (info == CURLINFO.CURLINFO_PRIVATE)
            {
                objInfo = m_privateData;
                return(retCode);
            }

            // string case
            if ((int)info < CURLINFO_LONG)
            {
                retCode = External.curl_easy_getinfo_ptr(m_pCURL, info, ref ptr);
                if (retCode == CURLcode.CURLE_OK)
                {
                    objInfo = (Object)Marshal.PtrToStringAnsi(ptr);
                }
                return(retCode);
            }

            // int or double: return problem
            return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
        }
예제 #26
0
        /// <summary>
        /// Extract <c>Slist</c> information from an <c>Easy</c> object.
        /// </summary>
        /// <param name="info">One of the values in the
        /// <see cref="CURLINFO"/> enumeration. In this case, it must
        /// specifically be one of the members that obtains an <c>Slist</c>.
        /// </param>
        /// <param name="slist">Reference to an <c>Slist</c> value.</param>
        /// <returns>The <see cref="CURLcode"/> obtained from the internal
        /// call to <c>curl_easy_getinfo()</c>.
        /// </returns>
        /// <exception cref="System.NullReferenceException">This is thrown if
        /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
        public CURLcode GetInfo(CURLINFO info, ref Slist slist)
        {
            EnsureHandle();
            CURLcode retCode = CURLcode.CURLE_OK;
            IntPtr   ptr = IntPtr.Zero, ptrs = IntPtr.Zero;

            if ((int)info < CURLINFO_SLIST)
            {
                return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
            }
            retCode = External.curl_easy_getinfo_ptr(m_pCURL, info, ref ptr);
            if (retCode != CURLcode.CURLE_OK)
            {
                return(retCode);
            }
            slist = new Slist();
            while (ptr != IntPtr.Zero)
            {
                ptr = External.curl_shim_get_string_from_slist(
                    ptr, ref ptrs);
                slist.Append(Marshal.PtrToStringAnsi(ptrs));
            }
            return(retCode);
        }
예제 #27
0
 /// <summary>
 /// Get a string description of an error code.
 /// </summary>
 /// <param name="code">Error code.</param>
 /// <returns>String description of the error code.</returns>
 public String StrError(CURLcode code)
 {
     return(Marshal.PtrToStringAnsi(
                External.curl_easy_strerror(code)));
 }
예제 #28
0
 /// <summary>
 /// Perform a transfer.
 /// </summary>
 /// <exception cref="System.NullReferenceException">This is thrown if
 /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
 /// <returns>The <see cref="CURLcode"/> obtained from the internal
 /// call to <c>curl_easy_perform()</c>.
 /// </returns>
 public CURLcode Perform()
 {
     EnsureHandle();
     return((CURLcode)External.curl_easy_perform(m_pCURL));
 }
예제 #29
0
        /// <summary>
        /// Set options for this object. See the <c>EasyGet</c> sample for
        /// basic usage.
        /// </summary>
        /// <param name="option">This should be a valid <see cref="CURLoption"/>.</param>
        /// <param name="parameter">This should be a parameter of a varying
        /// type based on the value of the <c>option</c> parameter.</param>
        /// <exception cref="System.NullReferenceException">This is thrown if
        /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
        /// <returns>A <see cref="CURLcode"/>, typically obtained from
        /// <c>cURL</c> internally, but sometimes a
        /// <see cref="CURLcode.CURLE_BAD_FUNCTION_ARGUMENT"/>
        /// will be returned if the type of value of <c>parameter</c> is invalid.
        /// </returns>
        public CURLcode SetOpt(CURLoption option, Object parameter)
        {
            EnsureHandle();
            CURLcode retCode = CURLcode.CURLE_OK;

            // numeric cases
            if ((int)option < CURLOPTTYPE_OBJECTPOINT)
            {
                int i = 0;
                if (option == CURLoption.CURLOPT_DNS_USE_GLOBAL_CACHE ||
                    option == CURLoption.CURLOPT_SOURCE_PORT)
                {
                    return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                }
                else if (option == CURLoption.CURLOPT_TIMEVALUE)
                {
                    // unboxing may throw class cast exception
                    //DateTime d = (DateTime)parameter;
                    DateTime startTime = Main.DateTimeBegin;
                    TimeSpan currTime  = new TimeSpan(DateTime.Now.Ticks - startTime.Ticks);
                    i = Convert.ToInt32(currTime.TotalSeconds);
                }
                else
                {
                    i = Convert.ToInt32(parameter);
                }

                retCode = External.curl_easy_setopt_int(m_pCURL,
                                                        option, i);
            }

            // object cases: the majority
            else if ((int)option < CURLOPTTYPE_FUNCTIONPOINT)
            {
                switch (option)
                {
                // various data items
                case CURLoption.CURLOPT_PRIVATE:
                    m_privateData = parameter; break;

                case CURLoption.CURLOPT_WRITEDATA:
                    m_writeData = parameter; break;

                case CURLoption.CURLOPT_READDATA:
                    m_readData = parameter; break;

                case CURLoption.CURLOPT_PROGRESSDATA:
                    m_progressData = parameter; break;

                case CURLoption.CURLOPT_DEBUGDATA:
                    m_debugData = parameter; break;

                case CURLoption.CURLOPT_HEADERDATA:
                    m_headerData = parameter; break;

                case CURLoption.CURLOPT_SSL_CTX_DATA:
                    m_sslContextData = parameter; break;

                case CURLoption.CURLOPT_IOCTLDATA:
                    m_ioctlData = parameter; break;

                // items that can't be set externally or
                // obsolete items
                case CURLoption.CURLOPT_ERRORBUFFER:
                case CURLoption.CURLOPT_STDERR:
                case CURLoption.CURLOPT_SOURCE_HOST:
                case CURLoption.CURLOPT_SOURCE_PATH:
                case CURLoption.CURLOPT_PASV_HOST:
                    return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);

                // singular case for share
                case CURLoption.CURLOPT_SHARE:
                {
                    Share share = parameter as Share;
                    if (share == null)
                    {
                        return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                    }
                    retCode = External.curl_easy_setopt_ptr(m_pCURL,
                                                            option, share.GetHandle());
                    break;
                }

                // multipart HTTP post
                case CURLoption.CURLOPT_HTTPPOST:
                {
                    MultiPartForm mf = parameter as MultiPartForm;
                    if (mf == null)
                    {
                        return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                    }
                    retCode = External.curl_easy_setopt_ptr(m_pCURL,
                                                            option, mf.GetHandle());
                    break;
                }

                // items curl wants as a curl_slist
                case CURLoption.CURLOPT_HTTPHEADER:
                case CURLoption.CURLOPT_PREQUOTE:
                case CURLoption.CURLOPT_QUOTE:
                case CURLoption.CURLOPT_POSTQUOTE:
                case CURLoption.CURLOPT_SOURCE_QUOTE:
                case CURLoption.CURLOPT_TELNETOPTIONS:
                case CURLoption.CURLOPT_HTTP200ALIASES:
                {
                    Slist slist = parameter as Slist;
                    if (slist == null)
                    {
                        retCode = External.curl_easy_setopt_ptr(m_pCURL,
                                                                option, IntPtr.Zero);
                    }
                    else
                    {
                        retCode = External.curl_easy_setopt_ptr(m_pCURL,
                                                                option, slist.GetHandle());
                    }
                    break;
                }

                // string items
                default:
                {
                    string s = parameter as string;
                    if (s == null)
                    {
                        retCode = External.curl_easy_setopt_ptr(m_pCURL,
                                                                option, IntPtr.Zero);
                    }
                    else
                    {
                        IntPtr pCurlStr = External.curl_shim_add_string(
                            m_pMyStrings, s);
                        if (pCurlStr != IntPtr.Zero)
                        {
                            retCode = External.curl_easy_setopt_ptr(m_pCURL,
                                                                    option, pCurlStr);
                        }
                    }
                    break;
                }
                }
            }

            // FUNCTIONPOINT args, for delegates
            else if ((int)option < CURLOPTTYPE_OFF_T)
            {
                switch (option)
                {
                case CURLoption.CURLOPT_WRITEFUNCTION:
                {
                    WriteFunction wf = parameter as WriteFunction;
                    if (wf == null)
                    {
                        return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                    }
                    m_pfWrite = wf;
                    break;
                }

                case CURLoption.CURLOPT_READFUNCTION:
                {
                    ReadFunction rf = parameter as ReadFunction;
                    if (rf == null)
                    {
                        return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                    }
                    m_pfRead = rf;
                    break;
                }

                case CURLoption.CURLOPT_PROGRESSFUNCTION:
                {
                    ProgressFunction pf = parameter as ProgressFunction;
                    if (pf == null)
                    {
                        return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                    }
                    m_pfProgress = pf;
                    break;
                }

                case CURLoption.CURLOPT_DEBUGFUNCTION:
                {
                    DebugFunction pd = parameter as DebugFunction;
                    if (pd == null)
                    {
                        return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                    }
                    m_pfDebug = pd;
                    break;
                }

                case CURLoption.CURLOPT_HEADERFUNCTION:
                {
                    HeaderFunction hf = parameter as HeaderFunction;
                    if (hf == null)
                    {
                        return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                    }
                    m_pfHeader = hf;
                    break;
                }

                case CURLoption.CURLOPT_SSL_CTX_FUNCTION:
                {
                    SSLContextFunction sf = parameter as SSLContextFunction;
                    if (sf == null)
                    {
                        return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                    }
                    m_pfSSLContext = sf;
                    break;
                }

                case CURLoption.CURLOPT_IOCTLFUNCTION:
                {
                    IoctlFunction iof = parameter as IoctlFunction;
                    if (iof == null)
                    {
                        return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                    }
                    m_pfIoctl = iof;
                    break;
                }

                default:
                    return(CURLcode.CURLE_BAD_FUNCTION_ARGUMENT);
                }
            }

            // otherwise, it's one of those 64-bit off_t guys!
            else
            {
                Int64 i = Convert.ToInt64(parameter);
                retCode = External.curl_easy_setopt_int64(m_pCURL,
                                                          option, i);
            }

            return(retCode);
        }
예제 #30
0
 /// <summary>
 /// Reset the internal cURL handle.
 /// </summary>
 /// <exception cref="System.NullReferenceException">This is thrown if
 /// the native <c>CURL*</c> handle wasn't created successfully.</exception>
 public void Reset()
 {
     EnsureHandle();
     External.curl_easy_reset(m_pCURL);
 }