curlhs 0.0.2 → 0.1.1

raw patch · 28 files changed

+7841/−3777 lines, 28 filesdep +rtlddep ~bytestringdep ~timesetup-changedPVP ok

version bump matches the API change (PVP)

Dependencies added: rtld

Dependency ranges changed: bytestring, time

API changes (from Hackage documentation)

Files

• LICENSE +1/−1
• Network/CURL000/LibC0.c +114/−0
• Network/CURL000/LibCC.hsc +503/−0
• Network/CURL000/LibHS.hsc +776/−0
• Network/CURL000/LibLD.hs +96/−0
• Network/CURL000/Types.hsc +879/−0
• Network/CURL000/curl-7.30.0/COPYING +21/−0
• Network/CURL000/curl-7.30.0/curl.h +2227/−0
• Network/CURL000/curl-7.30.0/curlbuild.h +585/−0
• Network/CURL000/curl-7.30.0/curlrules.h +262/−0
• Network/CURL000/curl-7.30.0/curlver.h +69/−0
• Network/CURL000/curl-7.30.0/easy.h +102/−0
• Network/CURL000/curl-7.30.0/multi.h +397/−0
• Network/CURL000/curl-7.30.0/stdcheaders.h +33/−0
• Network/CURL000/curl-7.30.0/typecheck-gcc.h +604/−0
• Network/CURL720.hs +525/−0
• Network/CURL730.hs +575/−0
• Network/CURLXXX.hs +23/−0
• Network/Curlhs/Base.hsc +0/−1814
• Network/Curlhs/Core.hs +0/−122
• Network/Curlhs/Easy.hs +0/−284
• Network/Curlhs/Errors.hsc +0/−216
• Network/Curlhs/Setopt.hsc +0/−513
• Network/Curlhs/Types.hs +0/−675
• README +0/−6
• README.md +15/−0
• Setup.hs +1/−108
• curlhs.cabal +33/−38

@@ -1,4 +1,4 @@-Copyright (c) 2012 Krzysztof Kardzis+Copyright (c) 2012-2014 Krzysztof Kardzis  Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above

@@ -0,0 +1,114 @@+/* ------------------------------------------------------------------------- */+/* |                                                                         */+/* Module      :  Network.CURL000.LibC0                                      */+/* Copyright   :  Copyright © 2012-2014 Krzysztof Kardzis                    */+/* License     :  ISC License (MIT/BSD-style, see LICENSE file for details)  */+/*                                                                           */+/* Maintainer  :  Krzysztof Kardzis <kkardzis@gmail.com>                     */+/* Stability   :  experimental                                               */+/* Portability :  non-portable                                               */+/*                                                                           */+/* ------------------------------------------------------------------------- */++#include "curl-7.30.0/curl.h"++#include "RTLD.h"+++/* ------------------------------------------------------------------------- */+/* global symbol table (for run-time linking)                                */+/* ------------------------------------------------------------------------- */+enum { CURL720, CURL730 };++#define CURLXXX CURL730+#define SYMTAB curlSYMTAB++SYMTABENTRY curlSYMTAB[] =+  { {CURL720, CURLXXX, "curl_easy_cleanup"}+  , {CURL720, CURLXXX, "curl_easy_duphandle"}+  , {CURL720, CURLXXX, "curl_easy_escape"}+  , {CURL720, CURLXXX, "curl_easy_getinfo"}+  , {CURL720, CURLXXX, "curl_easy_init"}+  , {CURL720, CURLXXX, "curl_easy_pause"}+  , {CURL720, CURLXXX, "curl_easy_perform"}+  , {CURL720, CURLXXX, "curl_easy_recv"}+  , {CURL720, CURLXXX, "curl_easy_reset"}+  , {CURL720, CURLXXX, "curl_easy_send"}+  , {CURL720, CURLXXX, "curl_easy_setopt"}+  , {CURL720, CURLXXX, "curl_easy_strerror"}+  , {CURL720, CURLXXX, "curl_easy_unescape"}+  , {CURL720, CURLXXX, "curl_escape"}+  , {CURL720, CURLXXX, "curl_formadd"}+  , {CURL720, CURLXXX, "curl_formfree"}+  , {CURL720, CURLXXX, "curl_formget"}+  , {CURL720, CURLXXX, "curl_free"}+  , {CURL720, CURLXXX, "curl_getdate"}+  , {CURL720, CURLXXX, "curl_getenv"}+  , {CURL720, CURLXXX, "curl_global_cleanup"}+  , {CURL720, CURLXXX, "curl_global_init"}+  , {CURL720, CURLXXX, "curl_global_init_mem"}+  , {CURL720, CURLXXX, "curl_maprintf"}+  , {CURL720, CURLXXX, "curl_mfprintf"}+  , {CURL720, CURLXXX, "curl_mprintf"}+  , {CURL720, CURLXXX, "curl_msnprintf"}+  , {CURL720, CURLXXX, "curl_msprintf"}+  , {CURL720, CURLXXX, "curl_multi_add_handle"}+  , {CURL720, CURLXXX, "curl_multi_assign"}+  , {CURL720, CURLXXX, "curl_multi_cleanup"}+  , {CURL720, CURLXXX, "curl_multi_fdset"}+  , {CURL720, CURLXXX, "curl_multi_info_read"}+  , {CURL720, CURLXXX, "curl_multi_init"}+  , {CURL720, CURLXXX, "curl_multi_perform"}+  , {CURL720, CURLXXX, "curl_multi_remove_handle"}+  , {CURL720, CURLXXX, "curl_multi_setopt"}+  , {CURL720, CURLXXX, "curl_multi_socket"}+  , {CURL720, CURLXXX, "curl_multi_socket_action"}+  , {CURL720, CURLXXX, "curl_multi_socket_all"}+  , {CURL720, CURLXXX, "curl_multi_strerror"}+  , {CURL720, CURLXXX, "curl_multi_timeout"}+ // {CURL728, CURLXXX, "curl_multi_wait"}+  , {CURL730, CURLXXX, "curl_multi_wait"}+  , {CURL720, CURLXXX, "curl_mvaprintf"}+  , {CURL720, CURLXXX, "curl_mvfprintf"}+  , {CURL720, CURLXXX, "curl_mvprintf"}+  , {CURL720, CURLXXX, "curl_mvsnprintf"}+  , {CURL720, CURLXXX, "curl_mvsprintf"}+  , {CURL720, CURLXXX, "curl_share_cleanup"}+  , {CURL720, CURLXXX, "curl_share_init"}+  , {CURL720, CURLXXX, "curl_share_setopt"}+  , {CURL720, CURLXXX, "curl_share_strerror"}+  , {CURL720, CURLXXX, "curl_slist_append"}+  , {CURL720, CURLXXX, "curl_slist_free_all"}+  , {CURL720, CURLXXX, "curl_strequal"}+  , {CURL720, CURLXXX, "curl_strnequal"}+  , {CURL720, CURLXXX, "curl_unescape"}+  , {CURL720, CURLXXX, "curl_version"}+  , {CURL720, CURLXXX, "curl_version_info"}+  };++/* Force section .data instead of default .bss, because with .bss something  */+/* wrong happens during linking in ghci/runghc (at least on FreeBSD).        */+void* __attribute__((section(".data"))) curlADRTAB[TABLEN] = {};+++/* ------------------------------------------------------------------------- */+/* wrappers for variadic functions                                           */+/* ------------------------------------------------------------------------- */+typedef int (*setoptFP)(void *, int, ...);++int curlOptLong(setoptFP setopt, void *handle, int opt, long val) {+  return setopt(handle, opt, val);+};++int curlOptCOff(setoptFP setopt, void *handle, int opt, curl_off_t val) {+  return setopt(handle, opt, val);+};++int curlOptDPtr(setoptFP setopt, void *handle, int opt, void *val) {+  return setopt(handle, opt, val);+};++int curlOptFPtr(setoptFP setopt, void *handle, int opt, void (*val)()) {+  return setopt(handle, opt, val);+};+

@@ -0,0 +1,503 @@+-------------------------------------------------------------------------------+-- |+-- Module      :  Network.CURL000.LibCC+-- Copyright   :  Copyright © 2012-2014 Krzysztof Kardzis+-- License     :  ISC License (MIT/BSD-style, see LICENSE file for details)+-- +-- Maintainer  :  Krzysztof Kardzis <kkardzis@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable+--+-------------------------------------------------------------------------------+{-# LANGUAGE ForeignFunctionInterface #-}+{-# LANGUAGE EmptyDataDecls           #-}++module Network.CURL000.LibCC+  ( curlADRTAB+  , curlSYMTAB+  , curlTABLEN++  , curl_easy_cleanup+  , curl_easy_duphandle+  , curl_easy_escape+  , curl_easy_getinfo+  , curl_easy_init+  , curl_easy_pause+  , curl_easy_perform+  , curl_easy_recv+  , curl_easy_reset+  , curl_easy_send+  , curl_easy_setopt'Long+  , curl_easy_setopt'COff+  , curl_easy_setopt'DPtr+  , curl_easy_setopt'FPtr+  , curl_easy_strerror+  , curl_easy_unescape+ -- curl_escape+  , curl_formadd+  , curl_formfree+  , curl_formget+  , curl_free+  , curl_getdate+ -- curl_getenv+  , curl_global_cleanup+  , curl_global_init+  , curl_global_init_mem+ -- curl_maprintf+ -- curl_mfprintf+ -- curl_mprintf+ -- curl_msnprintf+ -- curl_msprintf+  , curl_multi_add_handle+  , curl_multi_assign+  , curl_multi_cleanup+  , curl_multi_fdset+  , curl_multi_info_read+  , curl_multi_init+  , curl_multi_perform+  , curl_multi_remove_handle+  , curl_multi_setopt+  , curl_multi_socket+  , curl_multi_socket_action+  , curl_multi_socket_all+  , curl_multi_strerror+  , curl_multi_timeout+  , curl_multi_wait+ -- curl_mvaprintf+ -- curl_mvfprintf+ -- curl_mvprintf+ -- curl_mvsnprintf+ -- curl_mvsprintf+  , curl_share_cleanup+  , curl_share_init+  , curl_share_setopt'Long+  , curl_share_setopt'FPtr+  , curl_share_strerror+  , curl_slist_append+  , curl_slist_free_all+ -- curl_strequal+ -- curl_strnequal+ -- curl_unescape+  , curl_version+  , curl_version_info++  , CURL_write_callback, wrapCURL_write_callback+  , CURL_read_callback , wrapCURL_read_callback++  , CURL_lock_function  , wrapCURL_lock_function+  , CURL_unlock_function, wrapCURL_unlock_function++  , CURL, CURLM, CURLSH++  , CURLslist (..)+  , CURLcerts (..)++  , CURL_off_t++  ) where++import Foreign.Storable+import Foreign.C.String+import Foreign.C.Types+import Foreign.Ptr++import Control.Applicative ((<$>), (<*>))+import Control.Monad       (when)++import System.IO.Unsafe (unsafePerformIO)+import System.RTLD++#include "LibC0.c"+++-------------------------------------------------------------------------------+foreign import ccall "&curlADRTAB" curlADRTAB :: Ptr (FunPtr ())+foreign import ccall "&curlSYMTAB" curlSYMTAB :: Ptr SYMTABENTRY++curlTABLEN :: Int+curlTABLEN = #{const TABLEN}++peekFP :: Int -> IO (FunPtr a)+peekFP fid = do+  fp <- peekElemOff curlADRTAB fid+  when (fp==nullFunPtr) (nullFP fid)+  return (castFunPtr fp)++nullFP :: Int -> IO ()+nullFP fid =+  let name = unsafePerformIO $+        peekElemOff curlSYMTAB fid >>= \(RTSYM (_,_,cs)) -> peekCString cs+  in  error $ concat ["<curlhs> failed to call '", name, "' (NULL)"]++++-------------------------------------------------------------------------------+data CURL+data CURLM+data CURLSH++data CURLhttppost+data CURLvinfo+data CURLwaitfd+data CURLmsg++type CURLcode   = CInt+type CURLMcode  = CInt+type CURLSHcode = CInt++type CURLoption   = CInt+type CURLMoption  = CInt+type CURLSHopt = CInt++type CURL_lock_data   = CInt+type CURL_lock_access = CInt++type CURLinfo    = CInt+type CURLversion = CInt++type CURLformcode   = CInt+type CURLformoption = CInt++type CURLsocket = CInt++type CURL_off_t = CLLong  -- ??++type CURL_formget_callback = IO ()+type CURL_malloc_callback = IO ()+type CURL_free_callback = IO ()+type CURL_realloc_callback = IO ()+type CURL_calloc_callback = IO ()+type CURL_strdup_callback = IO ()+++data CURLslist = CURLslist (Ptr CChar) (Ptr CURLslist)++instance Storable CURLslist where+  sizeOf _    = #{size    struct curl_slist}+  alignment _ = #{alignof struct curl_slist}+  poke _ _    = undefined+  peek ptr    = CURLslist+    <$> #{peek struct curl_slist, data} ptr+    <*> #{peek struct curl_slist, next} ptr+++data CURLcerts = CURLcerts CInt (Ptr (Ptr CURLslist))++instance Storable CURLcerts where+  sizeOf _    = #{size    struct curl_certinfo}+  alignment _ = #{alignof struct curl_certinfo}+  poke _ _    = undefined+  peek ptr    = CURLcerts+    <$> #{peek struct curl_certinfo, num_of_certs} ptr+    <*> #{peek struct curl_certinfo, certinfo    } ptr+++-------------------------------------------------------------------------------+#{SAFECALL curl_easy_cleanup \+, Ptr CURL {- ^ handle -}    \+, IO ()                      }++#{SAFECALL curl_easy_duphandle \+, Ptr CURL      {- ^ handle -} \+, IO (Ptr CURL) {- ^ handle -} }++#{SAFECALL curl_easy_escape                 \+, Ptr CURL       {- ^ handle             -} \+, Ptr CChar      {- ^ const string (url) -} \+, CInt           {- ^ length             -} \+, IO (Ptr CChar) {- ^ URL encoded string -} }++-- #{SAFECALL curl_easy_getinfo \+-- , Ptr CURL    {- ^ handle -} \+-- , CURLinfo    {- ^ info   -} \+-- , Ptr ()      {- ^ param  -} \+-- , IO CURLcode {- ^ status -} }++#{SAFECALL curl_easy_init      \+, IO (Ptr CURL) {- ^ handle -} }++#{SAFECALL curl_easy_pause    \+, Ptr CURL    {- ^ handle  -} \+, CInt        {- ^ bitmask -} \+, IO CURLcode {- ^ status  -} }++#{SAFECALL curl_easy_perform \+, Ptr CURL    {- ^ handle -} \+, IO CURLcode {- ^ status -} }++#{SAFECALL curl_easy_recv    \+, Ptr CURL    {- ^ handle -} \+, Ptr ()      {- ^ buffer -} \+, CSize       {- ^ buflen -} \+, Ptr CSize   {- ^ n      -} \+, IO CURLcode {- ^ status -} }++#{SAFECALL curl_easy_reset \+, Ptr CURL  {- ^ handle -} \+, IO ()                    }++#{SAFECALL curl_easy_send          \+, Ptr CURL    {- ^ handle       -} \+, Ptr ()      {- ^ const buffer -} \+, CSize       {- ^ buflen       -} \+, Ptr CSize   {- ^ n            -} \+, IO CURLcode {- ^ status       -} }++-- #{SAFECALL curl_easy_setopt  \+-- , Ptr CURL    {- ^ handle -} \+-- , CURLoption  {- ^ option -} \+-- , Ptr ()      {- ^ param  -} \+-- , IO CURLcode {- ^ status -} }++#{SAFECALL curl_easy_strerror         \+, CURLcode       {- ^ errornum     -} \+, IO (Ptr CChar) {- ^ const string -} }++#{SAFECALL curl_easy_unescape           \+, Ptr CURL       {- ^ handle         -} \+, Ptr CChar      {- ^ const string   -} \+, CInt           {- ^ inlength       -} \+, Ptr CInt       {- ^ outlength      -} \+, IO (Ptr CChar) {- ^ decoded string -} }+++-------------------------------------------------------------------------------+#{SAFECALL curl_formadd                   \+, Ptr (Ptr CURLhttppost) {- ^ httppost -} \+, Ptr (Ptr CURLhttppost) {- ^ lastpost -} \+, CURLformoption         {- ^ option   -} \+, Ptr ()                 {- ^ value    -} \+, IO CURLformcode        {- ^ status   -} }++#{SAFECALL curl_formfree        \+, Ptr CURLhttppost {- ^ form -} \+, IO ()                         }++#{SAFECALL curl_formget                       \+, Ptr CURLhttppost             {- ^ form   -} \+, Ptr ()                       {- ^ userp  -} \+, FunPtr CURL_formget_callback {- ^ append -} \+, IO CInt                      {- ^ status -} }+++-------------------------------------------------------------------------------+#{SAFECALL curl_free \+, Ptr () {- ^ ptr -} \+, IO ()              }+++-------------------------------------------------------------------------------+#{SAFECALL curl_getdate                \+, Ptr CChar {- ^ const datestring   -} \+, Ptr CTime {- ^ const now (unused) -} \+, IO CTime  {- ^ time               -} }+++-------------------------------------------------------------------------------+#{SAFECALL curl_global_cleanup \+, IO ()                        }++#{SAFECALL curl_global_init  \+, CLong       {- ^ flags  -} \+, IO CURLcode {- ^ status -} }++#{SAFECALL curl_global_init_mem               \+, CLong                        {- ^ flags  -} \+, FunPtr CURL_malloc_callback  {- ^ m      -} \+, FunPtr CURL_free_callback    {- ^ f      -} \+, FunPtr CURL_realloc_callback {- ^ r      -} \+, FunPtr CURL_strdup_callback  {- ^ s      -} \+, FunPtr CURL_calloc_callback  {- ^ c      -} \+, IO CURLcode                  {- ^ status -} }+++-------------------------------------------------------------------------------+#{SAFECALL curl_multi_add_handle    \+, Ptr CURLM    {- ^ multi handle -} \+, Ptr CURL     {- ^ easy handle  -} \+, IO CURLMcode {- ^ multi status -} }++#{SAFECALL curl_multi_assign        \+, Ptr CURLM    {- ^ multi handle -} \+, CURLsocket   {- ^ sockfd       -} \+, Ptr ()       {- ^ sockptr      -} \+, IO CURLMcode {- ^ multi status -} }++#{SAFECALL curl_multi_cleanup       \+, Ptr CURLM    {- ^ multi handle -} \+, IO CURLMcode {- ^ multi status -} }++#{SAFECALL curl_multi_fdset         \+, Ptr CURLM    {- ^ multi handle -} \+, Ptr ()       {- ^ read_fd_set  -} \+, Ptr ()       {- ^ write_fd_set -} \+, Ptr ()       {- ^ exc_fd_set   -} \+, Ptr CInt     {- ^ max_fd       -} \+, IO CURLMcode {- ^ multi status -} }++#{SAFECALL curl_multi_info_read          \+, Ptr CURLM        {- ^ multi handle  -} \+, Ptr CInt         {- ^ msgs_in_queue -} \+, IO (Ptr CURLmsg) {- ^ message       -} }++#{SAFECALL curl_multi_init            \+, IO (Ptr CURLM) {- ^ multi handle -} }++#{SAFECALL curl_multi_perform          \+, Ptr CURLM    {- ^ multi handle    -} \+, Ptr CInt     {- ^ running handles -} \+, IO CURLMcode {- ^ multi status    -} }++#{SAFECALL curl_multi_remove_handle \+, Ptr CURLM    {- ^ multi handle -} \+, Ptr CURL     {- ^ easy handle  -} \+, IO CURLMcode {- ^ multi status -} }++#{SAFECALL curl_multi_setopt        \+, Ptr CURLM    {- ^ multi handle -} \+, CURLMoption  {- ^ option       -} \+, Ptr ()       {- ^ value        -} \+, IO CURLMcode {- ^ multi status -} }++#{SAFECALL curl_multi_socket           \+, Ptr CURLM    {- ^ multi handle    -} \+, CURLsocket   {- ^ sockfd          -} \+, Ptr CInt     {- ^ running handles -} \+, IO CURLMcode {- ^ multi status    -} }++#{SAFECALL curl_multi_socket_action    \+, Ptr CURLM    {- ^ multi handle    -} \+, CURLsocket   {- ^ sockfd          -} \+, CInt         {- ^ ev_bitmask      -} \+, Ptr CInt     {- ^ running handles -} \+, IO CURLMcode {- ^ multi status    -} }++#{SAFECALL curl_multi_socket_all       \+, Ptr CURLM    {- ^ multi handle    -} \+, Ptr CInt     {- ^ running handles -} \+, IO CURLMcode {- ^ multi status    -} }++#{SAFECALL curl_multi_strerror        \+, CURLMcode      {- ^ errornum     -} \+, IO (Ptr CChar) {- ^ const string -} }++#{SAFECALL curl_multi_timeout       \+, Ptr CURLM    {- ^ multi handle -} \+, Ptr CLong    {- ^ timeout      -} \+, IO CURLMcode {- ^ multi status -} }++#{SAFECALL curl_multi_wait            \+, Ptr CURLM      {- ^ multi handle -} \+, Ptr CURLwaitfd {- ^ extra_fds[]  -} \+, CUInt          {- ^ extra_nfds   -} \+, CInt           {- ^ timeout_ms   -} \+, Ptr CInt       {- ^ numfds       -} \+, IO CURLMcode   {- ^ multi status -} }+++-------------------------------------------------------------------------------+#{SAFECALL curl_share_cleanup        \+, Ptr CURLSH    {- ^ share handle -} \+, IO CURLSHcode {- ^ share status -} }++#{SAFECALL curl_share_init             \+, IO (Ptr CURLSH) {- ^ share handle -} }++-- #{SAFECALL curl_share_setopt         \+-- , Ptr CURLSH    {- ^ share handle -} \+-- , CURLSHopt  {- ^ option       -} \+-- , Ptr ()        {- ^ value        -} \+-- , IO CURLSHcode {- ^ share status -} }++#{SAFECALL curl_share_strerror        \+, CURLSHcode     {- ^ errornum     -} \+, IO (Ptr CChar) {- ^ const string -} }+++-------------------------------------------------------------------------------+#{SAFECALL curl_slist_append              \+, Ptr CURLslist      {- ^ list         -} \+, Ptr CChar          {- ^ const string -} \+, IO (Ptr CURLslist) {- ^ list         -} }++#{SAFECALL curl_slist_free_all \+, Ptr CURLslist {- ^ list -}   \+, IO ()                        }+++-------------------------------------------------------------------------------+#{SAFECALL curl_version         \+, IO (Ptr CChar) {- ^ string -} }++#{SAFECALL curl_version_info   \+, CURLversion {- ^ type/age -} \+, IO (Ptr CURLvinfo)           }+++-------------------------------------------------------------------------------+-- Callbacks+-------------------------------------------------------------------------------+#{WRAP CURL_write_callback, Ptr CChar -> CSize -> CSize -> Ptr () -> IO CSize}+#{WRAP CURL_read_callback , Ptr CChar -> CSize -> CSize -> Ptr () -> IO CSize}+++#{WRAP CURL_lock_function                                          \+, Ptr CURL -> CURL_lock_data -> CURL_lock_access -> Ptr () -> IO ()}++#{WRAP CURL_unlock_function                    \+, Ptr CURL -> CURL_lock_data -> Ptr () -> IO ()}+++-------------------------------------------------------------------------------+-- Wrappers for variadic functions+-------------------------------------------------------------------------------+{-# NOINLINE curl_easy_getinfo #-}+curl_easy_getinfo :: Ptr CURL -> CURLinfo -> Ptr () -> IO CURLcode+curl_easy_getinfo a b c =+  peekFP #{FPID curl_easy_getinfo} >>= \fp -> curlOptDPtr fp (castPtr a) b c+++{-# NOINLINE curl_easy_setopt'Long #-}+curl_easy_setopt'Long :: Ptr CURL -> CURLoption -> CLong -> IO CURLcode+curl_easy_setopt'Long a b c =+  peekFP #{FPID curl_easy_setopt} >>= \fp -> curlOptLong fp (castPtr a) b c++{-# NOINLINE curl_easy_setopt'COff #-}+curl_easy_setopt'COff :: Ptr CURL -> CURLoption -> CURL_off_t -> IO CURLcode+curl_easy_setopt'COff a b c =+  peekFP #{FPID curl_easy_setopt} >>= \fp -> curlOptCOff fp (castPtr a) b c++{-# NOINLINE curl_easy_setopt'DPtr #-}+curl_easy_setopt'DPtr :: Ptr CURL -> CURLoption -> Ptr () -> IO CURLcode+curl_easy_setopt'DPtr a b c =+  peekFP #{FPID curl_easy_setopt} >>= \fp -> curlOptDPtr fp (castPtr a) b c++{-# NOINLINE curl_easy_setopt'FPtr #-}+curl_easy_setopt'FPtr :: Ptr CURL -> CURLoption -> FunPtr () -> IO CURLcode+curl_easy_setopt'FPtr a b c =+  peekFP #{FPID curl_easy_setopt} >>= \fp -> curlOptFPtr fp (castPtr a) b c+++{-# NOINLINE curl_share_setopt'Long #-}+curl_share_setopt'Long :: Ptr CURLSH -> CURLSHopt -> CLong -> IO CURLSHcode+curl_share_setopt'Long a b c =+  peekFP #{FPID curl_share_setopt} >>= \fp -> curlOptLong fp (castPtr a) b c++{-# NOINLINE curl_share_setopt'FPtr #-}+curl_share_setopt'FPtr :: Ptr CURLSH -> CURLSHopt -> FunPtr () -> IO CURLSHcode+curl_share_setopt'FPtr a b c =+  peekFP #{FPID curl_share_setopt} >>= \fp -> curlOptFPtr fp (castPtr a) b c+++foreign import ccall safe curlOptLong+  :: FunPtr () -> Ptr () -> CInt -> CLong -> IO CInt++foreign import ccall safe curlOptCOff+  :: FunPtr () -> Ptr () -> CInt -> CURL_off_t -> IO CInt++foreign import ccall safe curlOptDPtr+  :: FunPtr () -> Ptr () -> CInt -> Ptr () -> IO CInt++foreign import ccall safe curlOptFPtr+  :: FunPtr () -> Ptr () -> CInt -> FunPtr () -> IO CInt+

@@ -0,0 +1,776 @@+-------------------------------------------------------------------------------+-- |+-- Module      :  Network.CURL000.LibHS+-- Copyright   :  Copyright © 2012-2014 Krzysztof Kardzis+-- License     :  ISC License (MIT/BSD-style, see LICENSE file for details)+-- +-- Maintainer  :  Krzysztof Kardzis <kkardzis@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable+--+-------------------------------------------------------------------------------+{-# LANGUAGE GADTs #-}++module Network.CURL000.LibHS+  ( curl_easy_cleanup+ -- curl_easy_duphandle+ -- curl_easy_escape+  , curl_easy_getinfo+  , curl_easy_init+ -- curl_easy_pause+  , curl_easy_perform+  , curl_easy_recv+  , curl_easy_reset+  , curl_easy_send+  , curl_easy_setopt+ -- curl_easy_strerror+ -- curl_easy_unescape+ -- curl_escape+ -- curl_formadd+ -- curl_formfree+ -- curl_formget+ -- curl_free+ -- curl_getdate+ -- curl_getenv+  , curl_global_cleanup+  , curl_global_init+ -- curl_global_init_mem+ -- curl_maprintf+ -- curl_mfprintf+ -- curl_mprintf+ -- curl_msnprintf+ -- curl_msprintf+ -- curl_multi_add_handle+ -- curl_multi_assign+ -- curl_multi_cleanup+ -- curl_multi_fdset+ -- curl_multi_info_read+ -- curl_multi_init+ -- curl_multi_perform+ -- curl_multi_remove_handle+ -- curl_multi_setopt+ -- curl_multi_socket+ -- curl_multi_socket_action+ -- curl_multi_socket_all+ -- curl_multi_strerror+ -- curl_multi_timeout+ -- curl_multi_wait+ -- curl_mvaprintf+ -- curl_mvfprintf+ -- curl_mvprintf+ -- curl_mvsnprintf+ -- curl_mvsprintf+  , curl_share_cleanup+  , curl_share_init+  , curl_share_setopt+ -- curl_share_strerror+ -- curl_slist_append+ -- curl_slist_free_all+ -- curl_strequal+ -- curl_strnequal+ -- curl_unescape+  , curl_version+  , curl_version_info++  ) where++import qualified Network.CURL000.LibCC as C++import Network.CURL000.Types++import qualified Data.ByteString as BS+import Data.ByteString.Unsafe (unsafeUseAsCStringLen)+import Data.ByteString        (ByteString, packCStringLen)+import Data.IORef             (IORef, newIORef, atomicModifyIORef)+import Data.Time.Clock        (UTCTime)+import Data.Time.Clock.POSIX  (utcTimeToPOSIXSeconds, posixSecondsToUTCTime)+import Data.List              (partition)+import Data.Unique            (newUnique)++import Control.Applicative ((<$>), (<*>))+import Control.Concurrent  (MVar, newMVar, takeMVar, tryPutMVar, modifyMVar)+import Control.Concurrent  (withMVar, modifyMVar_)+import Control.Exception   (throwIO, bracketOnError)+import Control.Monad       (when, forM_, foldM)++import Foreign.Marshal.Alloc+import Foreign.Marshal.Array+import Foreign.Marshal.Utils+import Foreign.Storable+import Foreign.C.String+import Foreign.C.Types+import Foreign.Ptr++#include "LibC0.c"+++-------------------------------------------------------------------------------+-- | Global libcurl initialisation+--   (<http://curl.haxx.se/libcurl/c/curl_global_init.html>).+-------------------------------------------------------------------------------+curl_global_init :: IO ()+curl_global_init = do+  code <- C.curl_global_init #{const CURL_GLOBAL_ALL}+  when (code/=0) (error "<curlhs> curl_global_init failed")+++-------------------------------------------------------------------------------+-- | Global libcurl cleanup+--   (<http://curl.haxx.se/libcurl/c/curl_global_cleanup.html>).+-------------------------------------------------------------------------------+curl_global_cleanup :: IO ()+curl_global_cleanup = C.curl_global_cleanup+++-------------------------------------------------------------------------------+-- | Returns the libcurl version string+--   (<http://curl.haxx.se/libcurl/c/curl_version.html>).+-------------------------------------------------------------------------------+curl_version :: IO String+curl_version = C.curl_version >>= peekCAString+++-------------------------------------------------------------------------------+-- | Returns run-time libcurl version info+--   (<http://curl.haxx.se/libcurl/c/curl_version_info.html>).+-------------------------------------------------------------------------------+curl_version_info :: IO CURL_version_info+curl_version_info =+  C.curl_version_info #{const CURLVERSION_NOW} >>= \ptr -> CURL_version_info+    <$> (#{peek curl_version_info_data, version        } ptr >>= peekCAString)+    <*> (#{peek curl_version_info_data, version_num    } ptr >>= peekCUInt)+    <*> (#{peek curl_version_info_data, host           } ptr >>= peekCAString)+    <*> (#{peek curl_version_info_data, features       } ptr >>= peekCFeatures)+    <*> (#{peek curl_version_info_data, ssl_version    } ptr >>= peekCString0)+    <*> (#{peek curl_version_info_data, ssl_version_num} ptr >>= peekCLong)+    <*> (#{peek curl_version_info_data, libz_version   } ptr >>= peekCString0)+    <*> (#{peek curl_version_info_data, protocols      } ptr >>= peekCStringL)+    <*> (#{peek curl_version_info_data, ares           } ptr >>= peekCString0)+    <*> (#{peek curl_version_info_data, ares_num       } ptr >>= peekCInt)+    <*> (#{peek curl_version_info_data, libidn         } ptr >>= peekCString0)+    <*> (#{peek curl_version_info_data, iconv_ver_num  } ptr >>= peekCInt)+    <*> (#{peek curl_version_info_data, libssh_version } ptr >>= peekCString0)++peekCString0 :: Ptr CChar -> IO String+peekCString0 ptr = if (ptr==nullPtr) then return [] else peekCAString ptr++peekCStringL :: Ptr (Ptr CChar) -> IO [String]+peekCStringL ptr = peekArray0 nullPtr ptr >>= mapM peekCAString++peekCFeatures :: CInt -> IO [CURLfeature]+peekCFeatures = return . fromCIntMask++peekCUInt :: CUInt -> IO Int+peekCUInt = return . fromIntegral++peekCInt :: CInt -> IO Int+peekCInt = return . fromIntegral++peekCLong :: CLong -> IO Int+peekCLong = return . fromIntegral++++-------------------------------------------------------------------------------+-- | Start a libcurl easy session+--   (<http://curl.haxx.se/libcurl/c/curl_easy_init.html>).+-------------------------------------------------------------------------------+curl_easy_init :: IO CURL+curl_easy_init = do+  ccurl <- C.curl_easy_init; curlmvar <- newMVar ccurl+  uid <- newUnique; cbref <- newIORef []; slref <- newIORef []+  let curl = CURL uid curlmvar cbref slref+  if (ccurl/=nullPtr) then return curl else do+    desc <- C.curl_easy_strerror #{const CURLE_FAILED_INIT} >>= peekCString0+    throwCURLE curl "curl_easy_init" desc CURLE_FAILED_INIT+++-------------------------------------------------------------------------------+throwCURLE :: CURL -> String -> String -> CURLC -> IO a+throwCURLE curl func desc code = throwIO (CURLE curl func desc code)++checkCURLE :: CURL -> String -> (IO CInt) -> IO ()+checkCURLE curl func action =+  action >>= \code -> when (code/=0) $ do+    desc <- C.curl_easy_strerror code >>= peekCString0+    throwCURLE curl func desc (toCURLC code)++withCCURL :: CURL -> (Ptr C.CURL -> IO a) -> IO a+withCCURL (CURL _ curlmvar _ _) = withMVar curlmvar+++-------------------------------------------------------------------------------+-- | Reset all options of a libcurl session handle+--   (<http://curl.haxx.se/libcurl/c/curl_easy_reset.html>).+-------------------------------------------------------------------------------+curl_easy_reset :: CURL -> IO ()+curl_easy_reset (CURL _ curlmvar cbref slref) =+  modifyMVar_ curlmvar $ \ccurl -> do+    when (ccurl/=nullPtr) (C.curl_easy_reset ccurl)+    freeCURL cbref slref >> return ccurl+++-------------------------------------------------------------------------------+-- | End a libcurl easy session+--   (<http://curl.haxx.se/libcurl/c/curl_easy_cleanup.html>).+-------------------------------------------------------------------------------+curl_easy_cleanup :: CURL -> IO ()+curl_easy_cleanup (CURL _ curlmvar cbref slref) =+  modifyMVar_ curlmvar $ \ccurl -> do+    when (ccurl/=nullPtr) (C.curl_easy_cleanup ccurl)+    freeCURL cbref slref >> return nullPtr++freeCURL :: IORef [CURLCB] -> IORef [CURLSL] -> IO ()+freeCURL cbref slref = do+  atomicModifyIORef cbref (\cbs -> ([],cbs)) >>= mapM_ freeCB+  atomicModifyIORef slref (\sls -> ([],sls)) >>= mapM_ freeSL+++-------------------------------------------------------------------------------+-- | Perform a file transfer+--   (<http://curl.haxx.se/libcurl/c/curl_easy_perform.html>).+-------------------------------------------------------------------------------+curl_easy_perform :: CURL -> IO ()+curl_easy_perform curl =+  withCCURL curl (checkCURLE curl "curl_easy_perform" . C.curl_easy_perform)+++-------------------------------------------------------------------------------+-- | Receives raw data on an @easy@ connection+--   (<http://curl.haxx.se/libcurl/c/curl_easy_recv.html>).+-------------------------------------------------------------------------------+curl_easy_recv :: CURL -> Int -> IO ByteString+curl_easy_recv curl len =+  withCCURL curl $ \ccurl -> alloca $ \nptr -> allocaBytes len $ \buff -> do+    let check = checkCURLE curl "curl_easy_recv"+    check $ C.curl_easy_recv ccurl buff (fromIntegral len) nptr+    n <- fmap fromIntegral (peek nptr)+    packCStringLen (castPtr buff, n)+++-------------------------------------------------------------------------------+-- | Sends raw data over an @easy@ connection+--   (<http://curl.haxx.se/libcurl/c/curl_easy_send.html>).+-------------------------------------------------------------------------------+curl_easy_send :: CURL -> ByteString -> IO Int+curl_easy_send curl bs =+  withCCURL curl $ \ccurl -> alloca $ \nptr -> do+    let check = checkCURLE curl "curl_easy_send"+    check $ unsafeUseAsCStringLen bs $ \(cs, cl) ->+      C.curl_easy_send ccurl (castPtr cs) (fromIntegral cl) nptr+    fmap fromIntegral (peek nptr)+++-------------------------------------------------------------------------------+-- | Extract information from a curl handle+--   (<http://curl.haxx.se/libcurl/c/curl_easy_getinfo.html>).+-------------------------------------------------------------------------------+#define hsc_getopt(opt, foo) printf(#opt " -> getopt %d " #foo, opt)+curl_easy_getinfo :: CURL -> CURLinfo a -> IO a+curl_easy_getinfo curl opt = withCCURL curl $ \ccurl ->+  let getopt :: Storable x => CInt -> (Ptr x -> IO a) -> IO a+      getopt x fpeek = alloca $ \ptr -> getptr x (castPtr ptr) >> fpeek ptr+      getptr x ptr = check $ C.curl_easy_getinfo ccurl x ptr+      check = checkCURLE curl "curl_easy_getinfo"+  in case opt of+    #{getopt CURLINFO_EFFECTIVE_URL          , getString}+    #{getopt CURLINFO_RESPONSE_CODE          , getCLong }+    #{getopt CURLINFO_HTTP_CONNECTCODE       , getCLong }+    #{getopt CURLINFO_FILETIME               , getTime  }+    #{getopt CURLINFO_TOTAL_TIME             , getDouble}+    #{getopt CURLINFO_NAMELOOKUP_TIME        , getDouble}+    #{getopt CURLINFO_CONNECT_TIME           , getDouble}+    #{getopt CURLINFO_APPCONNECT_TIME        , getDouble}+    #{getopt CURLINFO_PRETRANSFER_TIME       , getDouble}+    #{getopt CURLINFO_STARTTRANSFER_TIME     , getDouble}+    #{getopt CURLINFO_REDIRECT_TIME          , getDouble}+    #{getopt CURLINFO_REDIRECT_COUNT         , getCLong }+    #{getopt CURLINFO_REDIRECT_URL           , getString}+    #{getopt CURLINFO_SIZE_UPLOAD            , getDouble}+    #{getopt CURLINFO_SIZE_DOWNLOAD          , getDouble}+    #{getopt CURLINFO_SPEED_DOWNLOAD         , getDouble}+    #{getopt CURLINFO_SPEED_UPLOAD           , getDouble}+    #{getopt CURLINFO_HEADER_SIZE            , getCLong }+    #{getopt CURLINFO_REQUEST_SIZE           , getCLong }+    #{getopt CURLINFO_SSL_VERIFYRESULT       , getCLong }+    #{getopt CURLINFO_SSL_ENGINES            , getSList }+    #{getopt CURLINFO_CONTENT_LENGTH_DOWNLOAD, getDouble}+    #{getopt CURLINFO_CONTENT_LENGTH_UPLOAD  , getDouble}+    #{getopt CURLINFO_CONTENT_TYPE           , getString}+    #{getopt CURLINFO_HTTPAUTH_AVAIL         , getAuth  }+    #{getopt CURLINFO_PROXYAUTH_AVAIL        , getAuth  }+    #{getopt CURLINFO_OS_ERRNO               , getCLong }+    #{getopt CURLINFO_NUM_CONNECTS           , getCLong }+    #{getopt CURLINFO_PRIMARY_IP             , getString}+    #{getopt CURLINFO_PRIMARY_PORT           , getCLong }+    #{getopt CURLINFO_LOCAL_IP               , getString}+    #{getopt CURLINFO_LOCAL_PORT             , getCLong }+    #{getopt CURLINFO_COOKIELIST             , getSList }+    #{getopt CURLINFO_LASTSOCKET             , getCLong }+    #{getopt CURLINFO_FTP_ENTRY_PATH         , getString}+    #{getopt CURLINFO_CERTINFO               , getCerts }+    #{getopt CURLINFO_CONDITION_UNMET        , getBool  }+    #{getopt CURLINFO_RTSP_SESSION_ID        , getString}+    #{getopt CURLINFO_RTSP_CLIENT_CSEQ       , getCLong }+    #{getopt CURLINFO_RTSP_SERVER_CSEQ       , getCLong }+    #{getopt CURLINFO_RTSP_CSEQ_RECV         , getCLong }++getString :: Ptr (Ptr CChar) -> IO String+getString ptr = peek ptr >>= peekCString0++getDouble :: Ptr CDouble -> IO Double+getDouble = fmap realToFrac . peek++getCLong :: Ptr CLong -> IO CLong+getCLong = peek++getBool :: Ptr CLong -> IO Bool+getBool = fmap toBool . peek++getAuth :: Ptr CLong -> IO [CURLauth]+getAuth = fmap fromCLongMask . peek++getTime :: Ptr CLong -> IO (Maybe UTCTime)+getTime =+  let mconv f x = if (x==(-1) || x==0) then Nothing else Just (f x)+  in  fmap (mconv (posixSecondsToUTCTime . realToFrac)) . peek++getCerts :: Ptr (Ptr C.CURLcerts) -> IO [[String]]+getCerts ptr =+  peek ptr >>= \certs -> if (certs==nullPtr) then return [] else+    peek certs >>= \(C.CURLcerts len tab) ->+      peekArray (fromIntegral len) tab >>= mapM peekCURLslist++getSList :: Ptr (Ptr C.CURLslist) -> IO [String]+getSList ptr =+  peek ptr >>= \slist -> do+    strings <- peekCURLslist slist+    C.curl_slist_free_all slist+    return strings++peekCURLslist :: Ptr C.CURLslist -> IO [String]+peekCURLslist ptr =+  if (ptr==nullPtr) then return [] else+    peek ptr >>= \(C.CURLslist cs csl) -> do+      slist_head <- peekCAString cs+      slist_tail <- peekCURLslist csl+      return (slist_head : slist_tail)+++-------------------------------------------------------------------------------+-- | Set options for a curl easy handle+--   (<http://curl.haxx.se/libcurl/c/curl_easy_setopt.html>).+-------------------------------------------------------------------------------+curl_easy_setopt :: CURL -> [CURLoption] -> IO ()+curl_easy_setopt curl@(CURL _ _ cbref slref) opts =+  withCCURL curl $ \ccurl -> forM_ opts $ \opt ->+    checkCURLE curl "curl_easy_setopt" $ case opt of++  #define hsc_setopt(opt, foo) printf(#opt " x -> " #foo " ccurl %d x", opt)++  ---- CALLBACK OPTIONS -------------------------------------------------------+  #{setopt CURLOPT_WRITEFUNCTION          , curlcb FWRITE}+  #{setopt CURLOPT_READFUNCTION           , curlcb FREAD }++  ---- BEHAVIOR OPTIONS -------------------------------------------------------+  #{setopt CURLOPT_VERBOSE                , bool     }+  #{setopt CURLOPT_HEADER                 , bool     }+  #{setopt CURLOPT_NOPROGRESS             , bool     }+  #{setopt CURLOPT_NOSIGNAL               , bool     }+  #{setopt CURLOPT_WILDCARDMATCH          , bool     }++  ---- ERROR OPTIONS ----------------------------------------------------------+  -- CURLOPT_ERRORBUFFER+  -- CURLOPT_STDERR+  #{setopt CURLOPT_FAILONERROR            , bool     }++  ---- NETWORK OPTIONS --------------------------------------------------------+  #{setopt CURLOPT_URL                    , string   }+  #{setopt CURLOPT_PROTOCOLS              , enum     }+  #{setopt CURLOPT_REDIR_PROTOCOLS        , enum     }+  #{setopt CURLOPT_PROXY                  , string   }+  #{setopt CURLOPT_PROXYPORT              , clong    }+  #{setopt CURLOPT_PROXYTYPE              , enum     }+  #{setopt CURLOPT_NOPROXY                , string   }+  #{setopt CURLOPT_HTTPPROXYTUNNEL        , bool     }+  #{setopt CURLOPT_SOCKS5_GSSAPI_SERVICE  , string   }+  #{setopt CURLOPT_SOCKS5_GSSAPI_NEC      , bool     }+  #{setopt CURLOPT_INTERFACE              , string   }+  #{setopt CURLOPT_LOCALPORT              , clong    }+  #{setopt CURLOPT_LOCALPORTRANGE         , clong    }+  #{setopt CURLOPT_DNS_CACHE_TIMEOUT      , clong    }+  -- #{setopt CURLOPT_DNS_USE_GLOBAL_CACHE   , bool     }+  #{setopt CURLOPT_BUFFERSIZE             , clong    }+  #{setopt CURLOPT_PORT                   , clong    }+  #{setopt CURLOPT_TCP_NODELAY            , bool     }+  #{setopt CURLOPT_ADDRESS_SCOPE          , clong    }+  #{setopt CURLOPT_TCP_KEEPALIVE          , bool     }+  #{setopt CURLOPT_TCP_KEEPIDLE           , clong    }+  #{setopt CURLOPT_TCP_KEEPINTVL          , clong    }++  ---- NAMES and PASSWORDS OPTIONS (Authentication) ---------------------------+  #{setopt CURLOPT_NETRC                  , enum     }+  #{setopt CURLOPT_NETRC_FILE             , string   }+  #{setopt CURLOPT_USERPWD                , string   }+  #{setopt CURLOPT_PROXYUSERPWD           , string   }+  #{setopt CURLOPT_USERNAME               , string   }+  #{setopt CURLOPT_PASSWORD               , string   }+  #{setopt CURLOPT_PROXYUSERNAME          , string   }+  #{setopt CURLOPT_PROXYPASSWORD          , string   }+  #{setopt CURLOPT_HTTPAUTH               , enum     }+  #{setopt CURLOPT_TLSAUTH_TYPE           , string   }+  #{setopt CURLOPT_TLSAUTH_USERNAME       , string   }+  #{setopt CURLOPT_TLSAUTH_PASSWORD       , string   }+  #{setopt CURLOPT_PROXYAUTH              , enum     }++  ---- HTTP OPTIONS -----------------------------------------------------------+  #{setopt CURLOPT_AUTOREFERER            , bool     }+  #{setopt CURLOPT_ACCEPT_ENCODING        , string   }+  #{setopt CURLOPT_TRANSFER_ENCODING      , bool     }+  #{setopt CURLOPT_FOLLOWLOCATION         , bool     }+  #{setopt CURLOPT_UNRESTRICTED_AUTH      , bool     }+  #{setopt CURLOPT_MAXREDIRS              , clong    }+  #{setopt CURLOPT_POSTREDIR              , enum     }+  #{setopt CURLOPT_PUT                    , bool     }+  #{setopt CURLOPT_POST                   , bool     }+  -- #{setopt CURLOPT_POSTFIELDS             , buffer   }+  #{setopt CURLOPT_POSTFIELDSIZE          , clong    }+  #{setopt CURLOPT_POSTFIELDSIZE_LARGE    , int64    }+  #{setopt CURLOPT_COPYPOSTFIELDS         , string   }+  -- CURLOPT_HTTPPOST+  #{setopt CURLOPT_REFERER                , string   }+  #{setopt CURLOPT_USERAGENT              , string   }+  #{setopt CURLOPT_HTTPHEADER             , slist    }+  #{setopt CURLOPT_HTTP200ALIASES         , slist    }+  #{setopt CURLOPT_COOKIE                 , string   }+  #{setopt CURLOPT_COOKIEFILE             , string   }+  #{setopt CURLOPT_COOKIEJAR              , string   }+  #{setopt CURLOPT_COOKIESESSION          , bool     }+  #{setopt CURLOPT_COOKIELIST             , string   }+  #{setopt CURLOPT_HTTPGET                , bool     }+  #{setopt CURLOPT_HTTP_VERSION           , enum     }+  #{setopt CURLOPT_IGNORE_CONTENT_LENGTH  , bool     }+  #{setopt CURLOPT_HTTP_CONTENT_DECODING  , bool     }+  #{setopt CURLOPT_HTTP_TRANSFER_DECODING , bool     }++  ---- SMTP OPTIONS -----------------------------------------------------------+  #{setopt CURLOPT_MAIL_FROM              , string   }+  #{setopt CURLOPT_MAIL_RCPT              , slist    }+  #{setopt CURLOPT_MAIL_AUTH              , string   }++  ---- TFTP OPTIONS -----------------------------------------------------------+  #{setopt CURLOPT_TFTP_BLKSIZE           , clong    }++  ---- FTP OPTIONS ------------------------------------------------------------+  #{setopt CURLOPT_FTPPORT                , string   }+  #{setopt CURLOPT_QUOTE                  , slist    }+  #{setopt CURLOPT_POSTQUOTE              , slist    }+  #{setopt CURLOPT_PREQUOTE               , slist    }+  #{setopt CURLOPT_DIRLISTONLY            , bool     }+  #{setopt CURLOPT_APPEND                 , bool     }+  #{setopt CURLOPT_FTP_USE_EPRT           , bool     }+  #{setopt CURLOPT_FTP_USE_EPSV           , bool     }+  #{setopt CURLOPT_FTP_USE_PRET           , bool     }+  #{setopt CURLOPT_FTP_CREATE_MISSING_DIRS, enum     }+  #{setopt CURLOPT_FTP_RESPONSE_TIMEOUT   , clong    }+  #{setopt CURLOPT_FTP_ALTERNATIVE_TO_USER, string   }+  #{setopt CURLOPT_FTP_SKIP_PASV_IP       , bool     }+  #{setopt CURLOPT_FTPSSLAUTH             , enum     }+  #{setopt CURLOPT_FTP_SSL_CCC            , enum     }+  #{setopt CURLOPT_FTP_ACCOUNT            , string   }+  #{setopt CURLOPT_FTP_FILEMETHOD         , enum     }++  ---- RTSP OPTIONS -----------------------------------------------------------+  #define CURLOPT_RTSP_HEADER CURLOPT_RTSPHEADER+  #{setopt CURLOPT_RTSP_REQUEST           , enum     }+  #{setopt CURLOPT_RTSP_SESSION_ID        , string   }+  #{setopt CURLOPT_RTSP_STREAM_URI        , string   }+  #{setopt CURLOPT_RTSP_TRANSPORT         , string   }+  #{setopt CURLOPT_RTSP_HEADER            , slist    }+  #{setopt CURLOPT_RTSP_CLIENT_CSEQ       , clong    }+  #{setopt CURLOPT_RTSP_SERVER_CSEQ       , clong    }++  ---- PROTOCOL OPTIONS -------------------------------------------------------+  #{setopt CURLOPT_TRANSFERTEXT           , bool     }+  #{setopt CURLOPT_PROXY_TRANSFER_MODE    , bool     }+  #{setopt CURLOPT_CRLF                   , bool     }+  #{setopt CURLOPT_RANGE                  , string   }+  #{setopt CURLOPT_RESUME_FROM            , clong    }+  #{setopt CURLOPT_RESUME_FROM_LARGE      , int64    }+  #{setopt CURLOPT_CUSTOMREQUEST          , string   }+  #{setopt CURLOPT_FILETIME               , bool     }+  #{setopt CURLOPT_NOBODY                 , bool     }+  #{setopt CURLOPT_INFILESIZE             , clong    }+  #{setopt CURLOPT_INFILESIZE_LARGE       , int64    }+  #{setopt CURLOPT_UPLOAD                 , bool     }+  #{setopt CURLOPT_MAXFILESIZE            , clong    }+  #{setopt CURLOPT_MAXFILESIZE_LARGE      , int64    }+  #{setopt CURLOPT_TIMECONDITION          , enum     }+  #{setopt CURLOPT_TIMEVALUE              , time     }++  ---- CONNECTION OPTIONS -----------------------------------------------------+  #{setopt CURLOPT_TIMEOUT                , clong    }+  #{setopt CURLOPT_TIMEOUT_MS             , clong    }+  #{setopt CURLOPT_LOW_SPEED_LIMIT        , clong    }+  #{setopt CURLOPT_LOW_SPEED_TIME         , clong    }+  #{setopt CURLOPT_MAX_SEND_SPEED_LARGE   , int64    }+  #{setopt CURLOPT_MAX_RECV_SPEED_LARGE   , int64    }+  #{setopt CURLOPT_MAXCONNECTS            , clong    }+  -- #{setopt CURLOPT_CLOSEPOLICY            , enum     }+  #{setopt CURLOPT_FRESH_CONNECT          , bool     }+  #{setopt CURLOPT_FORBID_REUSE           , bool     }+  #{setopt CURLOPT_CONNECTTIMEOUT         , clong    }+  #{setopt CURLOPT_CONNECTTIMEOUT_MS      , clong    }+  #{setopt CURLOPT_IPRESOLVE              , enum     }+  #{setopt CURLOPT_CONNECT_ONLY           , bool     }+  #{setopt CURLOPT_USE_SSL                , enum     }+  #{setopt CURLOPT_RESOLVE                , slist    }+  #{setopt CURLOPT_DNS_SERVERS            , string   }+  #{setopt CURLOPT_ACCEPTTIMEOUT_MS       , clong    }++  ---- SSL and SECURITY OPTIONS -----------------------------------------------+  #{setopt CURLOPT_SSLCERT                , string   }+  #{setopt CURLOPT_SSLCERTTYPE            , string   }+  #{setopt CURLOPT_SSLKEY                 , string   }+  #{setopt CURLOPT_SSLKEYTYPE             , string   }+  #{setopt CURLOPT_KEYPASSWD              , string   }+  #{setopt CURLOPT_SSLENGINE              , string   }+  #{setopt CURLOPT_SSLENGINE_DEFAULT      , bool     }+  #{setopt CURLOPT_SSLVERSION             , enum     }+  #{setopt CURLOPT_SSL_VERIFYPEER         , bool     }+  #{setopt CURLOPT_CAINFO                 , string   }+  #{setopt CURLOPT_ISSUERCERT             , string   }+  #{setopt CURLOPT_CAPATH                 , string   }+  #{setopt CURLOPT_CRLFILE                , string   }+  #{setopt CURLOPT_SSL_VERIFYHOST         , clong    }+  #{setopt CURLOPT_CERTINFO               , bool     }+  #{setopt CURLOPT_RANDOM_FILE            , string   }+  #{setopt CURLOPT_EGDSOCKET              , string   }+  #{setopt CURLOPT_SSL_CIPHER_LIST        , string   }+  #{setopt CURLOPT_SSL_SESSIONID_CACHE    , bool     }+  #{setopt CURLOPT_SSL_OPTIONS            , enum     }+  #{setopt CURLOPT_KRBLEVEL               , string   }+  #{setopt CURLOPT_GSSAPI_DELEGATION      , enum     }++  ---- SSH OPTIONS ------------------------------------------------------------+  #{setopt CURLOPT_SSH_AUTH_TYPES         , enum     }+  #{setopt CURLOPT_SSH_HOST_PUBLIC_KEY_MD5, string   }+  #{setopt CURLOPT_SSH_PUBLIC_KEYFILE     , string   }+  #{setopt CURLOPT_SSH_PRIVATE_KEYFILE    , string   }+  #{setopt CURLOPT_SSH_KNOWNHOSTS         , string   }+  -- CURLOPT_SSH_KEYFUNCTION+  -- CURLOPT_SSH_KEYDATA++  ---- OTHER OPTIONS ----------------------------------------------------------+  -- CURLOPT_PRIVATE+  #{setopt CURLOPT_SHARE                  , curlsh   }+  #{setopt CURLOPT_NEW_FILE_PERMS         , clong    }+  #{setopt CURLOPT_NEW_DIRECTORY_PERMS    , clong    }++  ---- TELNET OPTIONS ---------------------------------------------------------+  #{setopt CURLOPT_TELNETOPTIONS          , slist    }++  where+    ---------------------------------------------------------------------------+    enum  ccurl copt x = C.curl_easy_setopt'Long ccurl copt (toCLong      x)+    bool  ccurl copt x = C.curl_easy_setopt'Long ccurl copt (fromBool     x)+    time  ccurl copt x = C.curl_easy_setopt'Long ccurl copt (fromUTCTime  x)+    clong ccurl copt x = C.curl_easy_setopt'Long ccurl copt (fromIntegral x)+    int64 ccurl copt x = C.curl_easy_setopt'COff ccurl copt (fromIntegral x)+    fromUTCTime = truncate . utcTimeToPOSIXSeconds+    ---------------------------------------------------------------------------+    string ccurl copt x = withCAString x $ \p ->+      C.curl_easy_setopt'DPtr ccurl copt (castPtr p)+    ---------------------------------------------------------------------------+    slist ccurl copt x = makeSL slref ccurl copt x+    ---------------------------------------------------------------------------+    curlcb :: CURLCBT a -> Ptr C.CURL -> CInt -> Maybe a -> IO CInt+    curlcb cbt ccurl copt x = makeCB cbref cbt ccurl copt x+    ---------------------------------------------------------------------------+    curlsh ccurl copt Nothing = C.curl_easy_setopt'DPtr ccurl copt nullPtr+    curlsh ccurl copt (Just (CURLSH _ mvar)) =+      withMVar mvar $ \(ccurlsh,_,_) ->+        C.curl_easy_setopt'DPtr ccurl copt (castPtr ccurlsh)+++-------------------------------------------------------------------------------+wrapSL :: [String] -> IO (Maybe (Ptr C.CURLslist))+wrapSL = foldM wrap (Just nullPtr)+  where+  wrap Nothing _ = return Nothing+  wrap (Just sl) xs =+    withCAString xs (C.curl_slist_append sl) >>= \nsl ->+      if (nsl/=nullPtr) then return (Just nsl) else do+         when (sl/=nullPtr) (C.curl_slist_free_all sl)+         return Nothing++freeSL :: CURLSL -> IO ()+freeSL (_,sl) = when (sl/=nullPtr) (C.curl_slist_free_all sl)++makeSL :: IORef [CURLSL] -> Ptr C.CURL -> CInt -> [String] -> IO CInt+makeSL slref ccurl copt xs =+  let cons sl (tokeep, tofree) = ((copt,sl):tokeep, tofree)+      keep 0 sl sls = cons sl $ partition ((==copt) . fst) sls+      keep _ sl sls = cons sl $ (sls,[])+  in  wrapSL xs >>= \msl -> case msl of+        Nothing -> return #{const CURLE_OUT_OF_MEMORY}+        Just sl -> do+          code <- C.curl_easy_setopt'DPtr ccurl copt (castPtr sl)+          atomicModifyIORef slref (keep code sl) >>= mapM_ freeSL+          return code+++-------------------------------------------------------------------------------+wrapCB :: CURLCBT a -> a -> IO (FunPtr ())+wrapCB cbt = case cbt of+  FWRITE -> fmap castFunPtr . C.wrapCURL_write_callback . write_callback+  FREAD  -> fmap castFunPtr . C.wrapCURL_read_callback  . read_callback++freeCB :: CURLCB -> IO ()+freeCB (CURLCB _ fp) = when (fp/=nullFunPtr) (freeHaskellFunPtr fp)++makeCB+  :: IORef [CURLCB] -> CURLCBT a -> Ptr C.CURL -> CInt -> Maybe a -> IO CInt+makeCB cbref cbt ccurl copt mcb =+  let comp :: CURLCBT a -> CURLCB -> Bool+      comp FWRITE (CURLCB FWRITE _) = True; comp FWRITE _ = False+      comp FREAD  (CURLCB FREAD  _) = True; comp FREAD  _ = False+      cons fp (tokeep, tofree) = ((CURLCB cbt fp):tokeep, tofree)+      keep 0 fp cbs = cons fp $ partition (comp cbt) cbs+      keep _ fp cbs = cons fp $ (cbs,[])+  in  maybe (return nullFunPtr) (wrapCB cbt) mcb >>= \fp -> do+        code <- C.curl_easy_setopt'FPtr ccurl copt fp+        atomicModifyIORef cbref (keep code fp) >>= mapM_ freeCB+        return code+++-------------------------------------------------------------------------------+write_callback :: CURL_write_callback -> C.CURL_write_callback+write_callback fwrite ptr size nmemb _ = do+  stat <- packCStringLen (ptr, fromIntegral (size * nmemb)) >>= fwrite+  return $ case stat of+    CURL_WRITEFUNC_OK    -> (size * nmemb)+    CURL_WRITEFUNC_FAIL  -> 0+    CURL_WRITEFUNC_PAUSE -> #{const CURL_WRITEFUNC_PAUSE}+++-------------------------------------------------------------------------------+read_callback :: CURL_read_callback -> C.CURL_read_callback+read_callback fread buff size nmemb _ = do+  let buffLen = fromIntegral (size * nmemb)+  stat <- fread buffLen+  case stat of+    CURL_READFUNC_PAUSE -> return #{const CURL_READFUNC_PAUSE}+    CURL_READFUNC_ABORT -> return #{const CURL_READFUNC_ABORT}+    CURL_READFUNC_OK bs -> unsafeUseAsCStringLen (BS.take buffLen bs)+      (\(cs, cl) -> copyBytes buff cs cl >> return (fromIntegral cl))+++-------------------------------------------------------------------------------+-- | Create a shared object+--   (<http://curl.haxx.se/libcurl/c/curl_share_init.html>).+-------------------------------------------------------------------------------+curl_share_init :: IO CURLSH+curl_share_init = bracketOnError createcurlsh curl_share_cleanup setupcurlsh+  where+  -----------------+  createcurlsh = do+    ccurlsh <- C.curl_share_init+    (f1,f2) <- if (ccurlsh == nullPtr)+      then return (nullFunPtr, nullFunPtr)+      else do+        shlocks <- newSHLocks+        f1 <- C.wrapCURL_lock_function   (lock_function   shlocks)+        f2 <- C.wrapCURL_unlock_function (unlock_function shlocks)+        return (castFunPtr f1, castFunPtr f2)+    uid <- newUnique; mvar <- newMVar (ccurlsh,f1,f2)+    return (CURLSH uid mvar)+  ------------------------------------+  setupcurlsh curlsh@(CURLSH _ mvar) =+    withMVar mvar $ \(ccurlsh,f1,f2) -> do+      let func = "curl_share_init"+      if (ccurlsh == nullPtr)+        then do+          let getstrerror x = C.curl_easy_strerror x >>= peekCString0+          desc <- getstrerror #{const CURLE_FAILED_INIT}+          throwCURLSHE curlsh func desc CURLSHE_FAILED_INIT+        else do+          let withCHECK = checkCURLSHE curlsh func+          let setshopt = C.curl_share_setopt'FPtr ccurlsh+          withCHECK $ setshopt #{const CURLSHOPT_LOCKFUNC  } f1+          withCHECK $ setshopt #{const CURLSHOPT_UNLOCKFUNC} f2+          return curlsh+++-------------------------------------------------------------------------------+-- | Clean up a shared object+--   (<http://curl.haxx.se/libcurl/c/curl_share_cleanup.html>).+-------------------------------------------------------------------------------+curl_share_cleanup :: CURLSH -> IO ()+curl_share_cleanup curlsh@(CURLSH _ mvar) =+  let withCHECK = checkCURLSHE curlsh "curl_share_cleanup"+  in  modifyMVar_ mvar $ \(ccurlsh,f1,f2) -> do+        when (ccurlsh/=nullPtr) (withCHECK $ C.curl_share_cleanup ccurlsh)+        when (f1/=nullFunPtr) (freeHaskellFunPtr f1)+        when (f2/=nullFunPtr) (freeHaskellFunPtr f2)+        return (nullPtr,nullFunPtr,nullFunPtr)+++-------------------------------------------------------------------------------+-- | Set options for a shared object+--   (<http://curl.haxx.se/libcurl/c/curl_share_setopt.html>).+-------------------------------------------------------------------------------+#define hsc_curlshopt(opt, foo) printf(#opt " x -> " #foo " %d x", opt)+curl_share_setopt :: CURLSH -> [CURLSHoption] -> IO ()+curl_share_setopt curlsh@(CURLSH _ mvar) opts =+  withMVar mvar $ \(ccurlsh,_,_) -> do+    let func = "curl_share_setopt"+    when (ccurlsh==nullPtr) $ do+      desc <- C.curl_share_strerror #{const CURLSHE_INVALID} >>= peekCString0+      throwCURLSHE curlsh func desc CURLSHE_INVALID+    let enum copt x = C.curl_share_setopt'Long ccurlsh copt (toCLong x)+    flip mapM_ opts $ \opt -> checkCURLSHE curlsh func $ case opt of+      #{curlshopt CURLSHOPT_SHARE  , enum}+      #{curlshopt CURLSHOPT_UNSHARE, enum}+++-------------------------------------------------------------------------------+throwCURLSHE :: CURLSH -> String -> String -> CURLSHC -> IO a+throwCURLSHE curlsh func desc code = throwIO (CURLSHE curlsh func desc code)++checkCURLSHE :: CURLSH -> String -> (IO CInt) -> IO ()+checkCURLSHE curlsh func action =+  action >>= \code -> when (code/=0) $ do+    desc <- C.curl_share_strerror code >>= peekCString0+    throwCURLSHE curlsh func desc (toCURLSHC code)+++-------------------------------------------------------------------------------+type SHLocks  = MVar [(SHLockID, SHLock)]+type SHLock   = MVar ()+type SHLockID = CInt++newSHLocks :: IO SHLocks+newSHLocks = newMVar []++getSHLock :: SHLock -> IO ()+getSHLock shlock = takeMVar shlock++putSHLock :: SHLock -> IO ()+putSHLock shlock = tryPutMVar shlock () >> return ()++lookupSHLock :: SHLocks -> SHLockID -> IO SHLock+lookupSHLock mvar shlockid =+  modifyMVar mvar $ \shlocks ->+    case (lookup shlockid shlocks) of+      Just shlock -> return (shlocks, shlock)+      Nothing     -> newMVar () >>= \nl -> return ((shlockid, nl):shlocks, nl)++lock_function :: SHLocks -> C.CURL_lock_function+lock_function shlocks _ccurl lockdata _lockaccess _usrptr =+  lookupSHLock shlocks lockdata >>= getSHLock++unlock_function :: SHLocks -> C.CURL_unlock_function+unlock_function shlocks _ccurl lockdata _usrptr =+  lookupSHLock shlocks lockdata >>= putSHLock+

@@ -0,0 +1,96 @@+-------------------------------------------------------------------------------+-- |+-- Module      :  Network.CURL000.LibLD+-- Copyright   :  Copyright © 2012-2014 Krzysztof Kardzis+-- License     :  ISC License (MIT/BSD-style, see LICENSE file for details)+-- +-- Maintainer  :  Krzysztof Kardzis <kkardzis@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable+--+-------------------------------------------------------------------------------++module Network.CURL000.LibLD+  ( RTLD(..), LIBCURL(..)+  ) where++import Network.CURL000.LibCC (curlADRTAB, curlSYMTAB, curlTABLEN)+import Network.CURL000.LibHS (curl_global_init, curl_global_cleanup)+import Network.CURL000.LibHS (curl_version)++import Text.ParserCombinators.ReadP (ReadP, readP_to_S, string)+import Text.Read.Lex (readDecP)++import Control.Concurrent (MVar, newMVar)+import System.IO.Unsafe (unsafePerformIO)++import System.Info (os)+import System.RTLD+++-------------------------------------------------------------------------------+data LIBCURL = CURL720 | CURL730+  deriving (Eq, Ord, Enum, Bounded)++instance RTLD LIBCURL where+  loadlib x = rtload curlRTSO x+  freelib _ = rtfree curlRTSO+++-------------------------------------------------------------------------------+curlGlobalState :: MVar (Maybe (LIBCURL, LIBH, Int))+curlGlobalState = unsafePerformIO (newMVar Nothing)+{-# NOINLINE curlGlobalState #-}++curlRTSO :: RTSO LIBCURL+curlRTSO = RTSO+  { rtPKGMVAR = curlGlobalState+  , rtPKGNAME = "<curlhs>"+  , rtLIBNAME = libname+  , rtSONAMES = sonames+  , rtONLOAD  = const curl_global_init+  , rtONFREE  = const curl_global_cleanup+  , rtGETAPI  = const (fmap readapi curl_version)+  , rtSYMTAB  = curlSYMTAB+  , rtADRTAB  = curlADRTAB+  , rtTABLEN  = curlTABLEN+  }+++-------------------------------------------------------------------------------+libname :: LIBCURL -> String+libname CURL720 = "libcurl/7.20"+libname CURL730 = "libcurl/7.30"++readapi :: String -> Maybe LIBCURL+readapi xs = parse >>= check+  where+  readP = readP_to_S (string "libcurl/7." >> (readDecP :: ReadP Int))+  parse = case (readP xs) of [(v,_)] -> Just v; _ -> Nothing+  check v+    | v>=20 && v<30 = Just CURL720+    | v>=30         = Just CURL730+    | otherwise     = Nothing+++-------------------------------------------------------------------------------+sonames :: LIBCURL -> [String]+sonames+  | os == "mingw32" = winsonames+  | os == "darwin"  = osxsonames+  | os == "linux"   = gnusonames+  | os == "freebsd" = bsdsonames+  | otherwise = const []++winsonames :: LIBCURL -> [String]+winsonames _ = ["libcurl.dll"]++osxsonames :: LIBCURL -> [String]+osxsonames _ = ["libcurl.dylib"]++gnusonames :: LIBCURL -> [String]+gnusonames _ = ["libcurl.so.4", "libcurl.so"]++bsdsonames :: LIBCURL -> [String]+bsdsonames _ = ["libcurl.so"]+

@@ -0,0 +1,879 @@+-------------------------------------------------------------------------------+-- |+-- Module      :  Network.CURL000.Types+-- Copyright   :  Copyright © 2012-2014 Krzysztof Kardzis+-- License     :  ISC License (MIT/BSD-style, see LICENSE file for details)+-- +-- Maintainer  :  Krzysztof Kardzis <kkardzis@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable+--+-------------------------------------------------------------------------------+{-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE EmptyDataDecls     #-}+{-# LANGUAGE GADTs              #-}++module Network.CURL000.Types where++import qualified Network.CURL000.LibCC as C++import Control.Exception  (Exception)+import Control.Concurrent (MVar)++import Data.Time.Clock (UTCTime)+import Data.ByteString (ByteString)+import Data.Typeable   (Typeable, typeOf)+import Data.Maybe      (mapMaybe)+import Data.List       (foldl')+import Data.Bits       ((.|.), (.&.))+import Data.Int        (Int64)+import Data.Unique     (Unique, hashUnique)+import Data.IORef      (IORef)++import Foreign.C.Types+import Foreign.Ptr++#include "LibC0.c"+++-------------------------------------------------------------------------------+class ENUM a where+  toENUM :: a -> Int+  enumlist :: [a]++instance ENUM a => ENUM [a] where+  toENUM = foldl' (.|.) 0 . map toENUM+  enumlist = []++toCInt :: ENUM a => a -> CInt+toCInt = fromIntegral . toENUM++toCLong :: ENUM a => a -> CLong+toCLong = fromIntegral . toENUM++fromCIntMask :: ENUM a => CInt -> [a]+fromCIntMask mask =+  let checkBit x = if ((mask .&. (toCInt x)) == 0) then Nothing else Just x+  in  mapMaybe checkBit enumlist++fromCLongMask :: ENUM a => CLong -> [a]+fromCLongMask mask =+  let checkBit x = if ((mask .&. (toCLong x)) == 0) then Nothing else Just x+  in  mapMaybe checkBit enumlist++fromCInt :: (ENUM a, Typeable a) => CInt -> a+fromCInt cval =+  let enums = map (\enum -> (toCInt enum, enum)) enumlist+      enumE = error $ concat ["<curlhs> unknown constant (", v, ") -> ", t]+      (v,t) = (show cval, show $ typeOf $ snd $ head enums)+  in  maybe enumE id $ lookup cval enums++++{-+-------------------------------------------------------------------------------+deriving instance Typeable CURLMcode+deriving instance Show CURLMcode+instance Exception CURLMcode++#{ENUM CURLMcode           \+, CURLM_CALL_MULTI_PERFORM \+, CURLM_BAD_HANDLE         \+, CURLM_BAD_EASY_HANDLE    \+, CURLM_OUT_OF_MEMORY      \+, CURLM_INTERNAL_ERROR     \+, CURLM_BAD_SOCKET         \+, CURLM_UNKNOWN_OPTION     }+-}+++-------------------------------------------------------------------------------+deriving instance Show CURLfeature++#{ENUM CURLfeature          \+, CURL_VERSION_IPV6         \+, CURL_VERSION_KERBEROS4    \+, CURL_VERSION_SSL          \+, CURL_VERSION_LIBZ         \+, CURL_VERSION_NTLM         \+, CURL_VERSION_GSSNEGOTIATE \+, CURL_VERSION_DEBUG        \+, CURL_VERSION_CURLDEBUG    \+, CURL_VERSION_ASYNCHDNS    \+, CURL_VERSION_SPNEGO       \+, CURL_VERSION_LARGEFILE    \+, CURL_VERSION_IDN          \+, CURL_VERSION_SSPI         \+, CURL_VERSION_CONV         \+, CURL_VERSION_TLSAUTH_SRP  \+, CURL_VERSION_NTLM_WB      }+++-------------------------------------------------------------------------------+#{ENUM CURLproto   \+, CURLPROTO_ALL    \+, CURLPROTO_HTTP   \+, CURLPROTO_HTTPS  \+, CURLPROTO_FTP    \+, CURLPROTO_FTPS   \+, CURLPROTO_SCP    \+, CURLPROTO_SFTP   \+, CURLPROTO_TELNET \+, CURLPROTO_LDAP   \+, CURLPROTO_LDAPS  \+, CURLPROTO_DICT   \+, CURLPROTO_FILE   \+, CURLPROTO_TFTP   \+, CURLPROTO_IMAP   \+, CURLPROTO_IMAPS  \+, CURLPROTO_POP3   \+, CURLPROTO_POP3S  \+, CURLPROTO_SMTP   \+, CURLPROTO_SMTPS  \+, CURLPROTO_RTSP   \+, CURLPROTO_RTMP   \+, CURLPROTO_RTMPT  \+, CURLPROTO_RTMPE  \+, CURLPROTO_RTMPTE \+, CURLPROTO_RTMPS  \+, CURLPROTO_RTMPTS \+, CURLPROTO_GOPHER }+++-------------------------------------------------------------------------------+#{ENUM CURLproxy            \+, CURLPROXY_HTTP            \+, CURLPROXY_HTTP_1_0        \+, CURLPROXY_SOCKS4          \+, CURLPROXY_SOCKS5          \+, CURLPROXY_SOCKS4A         \+, CURLPROXY_SOCKS5_HOSTNAME }+++-------------------------------------------------------------------------------+#{ENUM CURLnetrc      \+, CURL_NETRC_IGNORED  \+, CURL_NETRC_OPTIONAL \+, CURL_NETRC_REQUIRED }+++-------------------------------------------------------------------------------+#{ENUM CURLauth         \+, CURLAUTH_BASIC        \+, CURLAUTH_DIGEST       \+, CURLAUTH_DIGEST_IE    \+, CURLAUTH_GSSNEGOTIATE \+, CURLAUTH_NTLM         \+, CURLAUTH_NTLM_WB      \+, CURLAUTH_ONLY         \+, CURLAUTH_ANY          \+, CURLAUTH_ANYSAFE      }+++-------------------------------------------------------------------------------+#{ENUM CURLtlsauth \+, CURL_TLSAUTH_SRP }+++-------------------------------------------------------------------------------+#{ENUM CURLredir      \+, CURL_REDIR_GET_ALL  \+, CURL_REDIR_POST_301 \+, CURL_REDIR_POST_302 \+, CURL_REDIR_POST_303 \+, CURL_REDIR_POST_ALL }+++-------------------------------------------------------------------------------+#{ENUM CURLhttpver       \+, CURL_HTTP_VERSION_NONE \+, CURL_HTTP_VERSION_1_0  \+, CURL_HTTP_VERSION_1_1  }+++-------------------------------------------------------------------------------+#{ENUM CURLftpcreate       \+, CURLFTP_CREATE_DIR_NONE  \+, CURLFTP_CREATE_DIR       \+, CURLFTP_CREATE_DIR_RETRY }+++-------------------------------------------------------------------------------+#{ENUM CURLftpauth    \+, CURLFTPAUTH_DEFAULT \+, CURLFTPAUTH_SSL     \+, CURLFTPAUTH_TLS     }+++-------------------------------------------------------------------------------+#{ENUM CURLftpssl        \+, CURLFTPSSL_CCC_NONE    \+, CURLFTPSSL_CCC_PASSIVE \+, CURLFTPSSL_CCC_ACTIVE  }+ ++-------------------------------------------------------------------------------+#{ENUM CURLftpmethod      \+, CURLFTPMETHOD_DEFAULT   \+, CURLFTPMETHOD_MULTICWD  \+, CURLFTPMETHOD_NOCWD     \+, CURLFTPMETHOD_SINGLECWD }+++-------------------------------------------------------------------------------+#{ENUM CURLrtspreq           \+, CURL_RTSPREQ_OPTIONS       \+, CURL_RTSPREQ_DESCRIBE      \+, CURL_RTSPREQ_ANNOUNCE      \+, CURL_RTSPREQ_SETUP         \+, CURL_RTSPREQ_PLAY          \+, CURL_RTSPREQ_PAUSE         \+, CURL_RTSPREQ_TEARDOWN      \+, CURL_RTSPREQ_GET_PARAMETER \+, CURL_RTSPREQ_SET_PARAMETER \+, CURL_RTSPREQ_RECORD        \+, CURL_RTSPREQ_RECEIVE       }+++-------------------------------------------------------------------------------+#{ENUM CURLtimecond          \+, CURL_TIMECOND_NONE         \+, CURL_TIMECOND_IFMODSINCE   \+, CURL_TIMECOND_IFUNMODSINCE \+, CURL_TIMECOND_LASTMOD      }+++{-+-------------------------------------------------------------------------------+#{ENUM CURLclosepol                   \+, CURLCLOSEPOLICY_NONE                \+, CURLCLOSEPOLICY_OLDEST              \+, CURLCLOSEPOLICY_LEAST_RECENTLY_USED \+, CURLCLOSEPOLICY_LEAST_TRAFFIC       \+, CURLCLOSEPOLICY_SLOWEST             \+, CURLCLOSEPOLICY_CALLBACK            }+-}+++-------------------------------------------------------------------------------+#{ENUM CURLipresolve      \+, CURL_IPRESOLVE_WHATEVER \+, CURL_IPRESOLVE_V4       \+, CURL_IPRESOLVE_V6       }+++-------------------------------------------------------------------------------+#{ENUM CURLusessl    \+, CURLUSESSL_NONE    \+, CURLUSESSL_TRY     \+, CURLUSESSL_CONTROL \+, CURLUSESSL_ALL     }+++-------------------------------------------------------------------------------+#{ENUM CURLsslver         \+, CURL_SSLVERSION_DEFAULT \+, CURL_SSLVERSION_TLSv1   \+, CURL_SSLVERSION_SSLv2   \+, CURL_SSLVERSION_SSLv3   }+++-------------------------------------------------------------------------------+#{ENUM CURLsslopt        \+, CURLSSLOPT_ALLOW_BEAST }+++-------------------------------------------------------------------------------+#{ENUM CURLgssapi                   \+, CURLGSSAPI_DELEGATION_NONE        \+, CURLGSSAPI_DELEGATION_POLICY_FLAG \+, CURLGSSAPI_DELEGATION_FLAG        }+++-------------------------------------------------------------------------------+#{ENUM CURLsshauth       \+, CURLSSH_AUTH_ANY       \+, CURLSSH_AUTH_NONE      \+, CURLSSH_AUTH_PUBLICKEY \+, CURLSSH_AUTH_PASSWORD  \+, CURLSSH_AUTH_HOST      \+, CURLSSH_AUTH_KEYBOARD  \+, CURLSSH_AUTH_AGENT     \+, CURLSSH_AUTH_DEFAULT   }+++-------------------------------------------------------------------------------+data CURLSH = CURLSH Unique (MVar ((Ptr C.CURLSH),(FunPtr ()),(FunPtr ())))++instance Show CURLSH where+  showsPrec p (CURLSH u _) = showString "CURLSH#" . showsPrec p (hashUnique u)++instance Eq CURLSH where+  (CURLSH u1 _) == (CURLSH u2 _) = u1 == u2+++-------------------------------------------------------------------------------+data CURLSHE = CURLSHE CURLSH String String CURLSHC+  deriving (Eq, Typeable)++instance Exception CURLSHE++instance Show CURLSHE where+  showsPrec p (CURLSHE curlsh func desc code) =+    showsPrec p code . showString " (" . showString func . showString " "+    . showsPrec p curlsh . showString ") " . showString desc+++-------------------------------------------------------------------------------+data CURLSHC+  = CURLSHE_FAILED_INIT+  | CURLSHE_BAD_OPTION+  | CURLSHE_IN_USE+  | CURLSHE_INVALID+  | CURLSHE_NOMEM+  | CURLSHE_NOT_BUILT_IN+  | CURLSHE_UNKNOWN_ERROR+  deriving (Show, Eq)++toCURLSHC :: CInt -> CURLSHC+toCURLSHC x = case x of+  #{const CURLSHE_BAD_OPTION  } -> CURLSHE_BAD_OPTION+  #{const CURLSHE_IN_USE      } -> CURLSHE_IN_USE+  #{const CURLSHE_INVALID     } -> CURLSHE_INVALID+  #{const CURLSHE_NOMEM       } -> CURLSHE_NOMEM+  #{const CURLSHE_NOT_BUILT_IN} -> CURLSHE_NOT_BUILT_IN+  _                             -> CURLSHE_UNKNOWN_ERROR+++-------------------------------------------------------------------------------+data CURLSHoption+  = CURLSHOPT_SHARE   CURLSHlockdata+  | CURLSHOPT_UNSHARE CURLSHlockdata+++-------------------------------------------------------------------------------+#{ENUM CURLSHlockdata        \+, CURL_LOCK_DATA_COOKIE      \+, CURL_LOCK_DATA_DNS         \+, CURL_LOCK_DATA_SSL_SESSION }+++-------------------------------------------------------------------------------+data CURL_version_info = CURL_version_info+  { curl_version_info_version         :: String+  , curl_version_info_version_num     :: Int+  , curl_version_info_host            :: String+  , curl_version_info_features        :: [CURLfeature]+  , curl_version_info_ssl_version     :: String+  , curl_version_info_ssl_version_num :: Int+  , curl_version_info_libz_version    :: String+  , curl_version_info_protocols       :: [String]+  , curl_version_info_ares            :: String+  , curl_version_info_ares_num        :: Int+  , curl_version_info_libidn          :: String+  , curl_version_info_iconv_ver_num   :: Int+  , curl_version_info_libssh_version  :: String+  } deriving (Show)+++-------------------------------------------------------------------------------+data CURLinfo a where+  CURLINFO_EFFECTIVE_URL           :: CURLinfo String     -- Ptr CChar+  CURLINFO_RESPONSE_CODE           :: CURLinfo CLong      -- CLong+  CURLINFO_HTTP_CONNECTCODE        :: CURLinfo CLong      -- CLong+  CURLINFO_FILETIME                :: CURLinfo (Maybe UTCTime) -- CLong+  CURLINFO_TOTAL_TIME              :: CURLinfo Double     -- CDouble+  CURLINFO_NAMELOOKUP_TIME         :: CURLinfo Double     -- CDouble+  CURLINFO_CONNECT_TIME            :: CURLinfo Double     -- CDouble+  CURLINFO_APPCONNECT_TIME         :: CURLinfo Double     -- CDouble+  CURLINFO_PRETRANSFER_TIME        :: CURLinfo Double     -- CDouble+  CURLINFO_STARTTRANSFER_TIME      :: CURLinfo Double     -- CDouble+  CURLINFO_REDIRECT_TIME           :: CURLinfo Double     -- CDouble+  CURLINFO_REDIRECT_COUNT          :: CURLinfo CLong      -- CLong+  CURLINFO_REDIRECT_URL            :: CURLinfo String     -- Ptr CChar+  CURLINFO_SIZE_UPLOAD             :: CURLinfo Double     -- CDouble+  CURLINFO_SIZE_DOWNLOAD           :: CURLinfo Double     -- CDouble+  CURLINFO_SPEED_DOWNLOAD          :: CURLinfo Double     -- CDouble+  CURLINFO_SPEED_UPLOAD            :: CURLinfo Double     -- CDouble+  CURLINFO_HEADER_SIZE             :: CURLinfo CLong      -- CLong+  CURLINFO_REQUEST_SIZE            :: CURLinfo CLong      -- CLong+  CURLINFO_SSL_VERIFYRESULT        :: CURLinfo CLong      -- CLong+  CURLINFO_SSL_ENGINES             :: CURLinfo [String]   -- Ptr CURLslist+  CURLINFO_CONTENT_LENGTH_DOWNLOAD :: CURLinfo Double     -- CDouble+  CURLINFO_CONTENT_LENGTH_UPLOAD   :: CURLinfo Double     -- CDouble+  CURLINFO_CONTENT_TYPE            :: CURLinfo String     -- Ptr CChar+  -- CURLINFO_PRIVATE+  CURLINFO_HTTPAUTH_AVAIL          :: CURLinfo [CURLauth] -- CLong+  CURLINFO_PROXYAUTH_AVAIL         :: CURLinfo [CURLauth] -- CLong+  CURLINFO_OS_ERRNO                :: CURLinfo CLong      -- CLong+  CURLINFO_NUM_CONNECTS            :: CURLinfo CLong      -- CLong+  CURLINFO_PRIMARY_IP              :: CURLinfo String     -- Ptr CChar+  CURLINFO_PRIMARY_PORT            :: CURLinfo CLong      -- CLong+  CURLINFO_LOCAL_IP                :: CURLinfo String     -- Ptr CChar+  CURLINFO_LOCAL_PORT              :: CURLinfo CLong      -- CLong+  CURLINFO_COOKIELIST              :: CURLinfo [String]   -- Ptr CURLslist+  CURLINFO_LASTSOCKET              :: CURLinfo CLong      -- CLong+  CURLINFO_FTP_ENTRY_PATH          :: CURLinfo String     -- Ptr CChar+  CURLINFO_CERTINFO                :: CURLinfo [[String]] -- Ptr CURLcertinfo+  CURLINFO_CONDITION_UNMET         :: CURLinfo Bool       -- CLong+  CURLINFO_RTSP_SESSION_ID         :: CURLinfo String     -- Ptr CChar+  CURLINFO_RTSP_CLIENT_CSEQ        :: CURLinfo CLong      -- CLong+  CURLINFO_RTSP_SERVER_CSEQ        :: CURLinfo CLong      -- CLong+  CURLINFO_RTSP_CSEQ_RECV          :: CURLinfo CLong      -- CLong+++-------------------------------------------------------------------------------+data CURLoption+  ---- BEHAVIOR OPTIONS -------------------------------------------------------+  = CURLOPT_VERBOSE                 Bool+  | CURLOPT_HEADER                  Bool+  | CURLOPT_NOPROGRESS              Bool+  | CURLOPT_NOSIGNAL                Bool+  | CURLOPT_WILDCARDMATCH           Bool++  ---- CALLBACK OPTIONS -------------------------------------------------------+  | CURLOPT_WRITEFUNCTION           (Maybe CURL_write_callback)+ -- CURLOPT_WRITEDATA+  | CURLOPT_READFUNCTION            (Maybe CURL_read_callback)+ -- CURLOPT_READDATA+ -- CURLOPT_IOCTLFUNCTION+ -- CURLOPT_IOCTLDATA+ -- CURLOPT_SEEKFUNCTION+ -- CURLOPT_SEEKDATA+ -- CURLOPT_SOCKOPTFUNCTION+ -- CURLOPT_SOCKOPTDATA+ -- CURLOPT_OPENSOCKETFUNCTION+ -- CURLOPT_OPENSOCKETDATA+ -- CURLOPT_CLOSESOCKETFUNCTION+ -- CURLOPT_CLOSESOCKETDATA+ -- CURLOPT_PROGRESSFUNCTION+ -- CURLOPT_PROGRESSDATA+ -- CURLOPT_HEADERFUNCTION+ -- CURLOPT_HEADERDATA+ -- CURLOPT_DEBUGFUNCTION+ -- CURLOPT_DEBUGDATA+ -- CURLOPT_SSL_CTX_FUNCTION+ -- CURLOPT_SSL_CTX_DATA+ -- CURLOPT_CONV_TO_NETWORK_FUNCTION+ -- CURLOPT_CONV_FROM_NETWORK_FUNCTION+ -- CURLOPT_CONV_FROM_UTF8_FUNCTION+ -- CURLOPT_INTERLEAVEFUNCTION+ -- CURLOPT_INTERLEAVEDATA+ -- CURLOPT_CHUNK_BGN_FUNCTION+ -- CURLOPT_CHUNK_END_FUNCTION+ -- CURLOPT_CHUNK_DATA+ -- CURLOPT_FNMATCH_FUNCTION+ -- CURLOPT_FNMATCH_DATA++  ---- ERROR OPTIONS ----------------------------------------------------------+ -- CURLOPT_ERRORBUFFER             ?+ -- CURLOPT_STDERR                  ?+  | CURLOPT_FAILONERROR             Bool++  ---- NETWORK OPTIONS --------------------------------------------------------+  | CURLOPT_URL                     String+  | CURLOPT_PROTOCOLS               [CURLproto]+  | CURLOPT_REDIR_PROTOCOLS         [CURLproto]+  | CURLOPT_PROXY                   String+  | CURLOPT_PROXYPORT               CLong+  | CURLOPT_PROXYTYPE               CURLproxy+  | CURLOPT_NOPROXY                 String -- or better [String]+  | CURLOPT_HTTPPROXYTUNNEL         Bool+  | CURLOPT_SOCKS5_GSSAPI_SERVICE   String+  | CURLOPT_SOCKS5_GSSAPI_NEC       Bool+  | CURLOPT_INTERFACE               String+  | CURLOPT_LOCALPORT               CLong+  | CURLOPT_LOCALPORTRANGE          CLong+  | CURLOPT_DNS_CACHE_TIMEOUT       CLong+ -- CURLOPT_DNS_USE_GLOBAL_CACHE    Bool+  | CURLOPT_BUFFERSIZE              CLong+  | CURLOPT_PORT                    CLong+  | CURLOPT_TCP_NODELAY             Bool+  | CURLOPT_ADDRESS_SCOPE           CLong+  | CURLOPT_TCP_KEEPALIVE           Bool+  | CURLOPT_TCP_KEEPIDLE            CLong+  | CURLOPT_TCP_KEEPINTVL           CLong++  ---- NAMES and PASSWORDS OPTIONS (Authentication) ---------------------------+  | CURLOPT_NETRC                   CURLnetrc+  | CURLOPT_NETRC_FILE              FilePath+  | CURLOPT_USERPWD                 String+  | CURLOPT_PROXYUSERPWD            String+  | CURLOPT_USERNAME                String+  | CURLOPT_PASSWORD                String+  | CURLOPT_PROXYUSERNAME           String+  | CURLOPT_PROXYPASSWORD           String+  | CURLOPT_HTTPAUTH                [CURLauth]+  | CURLOPT_TLSAUTH_TYPE            String -- should be [CURLtlsauth]+  | CURLOPT_TLSAUTH_USERNAME        String+  | CURLOPT_TLSAUTH_PASSWORD        String+  | CURLOPT_PROXYAUTH               [CURLauth]++  ---- HTTP OPTIONS -----------------------------------------------------------+  | CURLOPT_AUTOREFERER             Bool+  | CURLOPT_ACCEPT_ENCODING         String+  | CURLOPT_TRANSFER_ENCODING       Bool+  | CURLOPT_FOLLOWLOCATION          Bool+  | CURLOPT_UNRESTRICTED_AUTH       Bool+  | CURLOPT_MAXREDIRS               CLong+  | CURLOPT_POSTREDIR               [CURLredir]+  | CURLOPT_PUT                     Bool+  | CURLOPT_POST                    Bool+ -- CURLOPT_POSTFIELDS              String -- not copied+  | CURLOPT_POSTFIELDSIZE           CLong+  | CURLOPT_POSTFIELDSIZE_LARGE     Int64+  | CURLOPT_COPYPOSTFIELDS          String+ -- CURLOPT_HTTPPOST                [CURL_httppost]+  | CURLOPT_REFERER                 String+  | CURLOPT_USERAGENT               String+  | CURLOPT_HTTPHEADER              [String]+  | CURLOPT_HTTP200ALIASES          [String]+  | CURLOPT_COOKIE                  String -- or better [String]+  | CURLOPT_COOKIEFILE              FilePath+  | CURLOPT_COOKIEJAR               FilePath+  | CURLOPT_COOKIESESSION           Bool+  | CURLOPT_COOKIELIST              String+  | CURLOPT_HTTPGET                 Bool+  | CURLOPT_HTTP_VERSION            CURLhttpver+  | CURLOPT_IGNORE_CONTENT_LENGTH   Bool+  | CURLOPT_HTTP_CONTENT_DECODING   Bool+  | CURLOPT_HTTP_TRANSFER_DECODING  Bool++  ---- SMTP OPTIONS -----------------------------------------------------------+  | CURLOPT_MAIL_FROM               String+  | CURLOPT_MAIL_RCPT               [String]+  | CURLOPT_MAIL_AUTH               String++  ---- TFTP OPTIONS -----------------------------------------------------------+  | CURLOPT_TFTP_BLKSIZE            CLong++  ---- FTP OPTIONS ------------------------------------------------------------+  | CURLOPT_FTPPORT                 String+  | CURLOPT_QUOTE                   [String]+  | CURLOPT_POSTQUOTE               [String]+  | CURLOPT_PREQUOTE                [String]+  | CURLOPT_DIRLISTONLY             Bool+  | CURLOPT_APPEND                  Bool+  | CURLOPT_FTP_USE_EPRT            Bool+  | CURLOPT_FTP_USE_EPSV            Bool+  | CURLOPT_FTP_USE_PRET            Bool+  | CURLOPT_FTP_CREATE_MISSING_DIRS CURLftpcreate+  | CURLOPT_FTP_RESPONSE_TIMEOUT    CLong+  | CURLOPT_FTP_ALTERNATIVE_TO_USER String+  | CURLOPT_FTP_SKIP_PASV_IP        Bool+  | CURLOPT_FTPSSLAUTH              CURLftpauth+  | CURLOPT_FTP_SSL_CCC             CURLftpssl+  | CURLOPT_FTP_ACCOUNT             String+  | CURLOPT_FTP_FILEMETHOD          CURLftpmethod++  ---- RTSP OPTIONS -----------------------------------------------------------+  | CURLOPT_RTSP_REQUEST            CURLrtspreq+  | CURLOPT_RTSP_SESSION_ID         String+  | CURLOPT_RTSP_STREAM_URI         String+  | CURLOPT_RTSP_TRANSPORT          String+  | CURLOPT_RTSP_HEADER             [String]+  | CURLOPT_RTSP_CLIENT_CSEQ        CLong+  | CURLOPT_RTSP_SERVER_CSEQ        CLong++  ---- PROTOCOL OPTIONS -------------------------------------------------------+  | CURLOPT_TRANSFERTEXT            Bool+  | CURLOPT_PROXY_TRANSFER_MODE     Bool+  | CURLOPT_CRLF                    Bool+  | CURLOPT_RANGE                   String+  | CURLOPT_RESUME_FROM             CLong+  | CURLOPT_RESUME_FROM_LARGE       Int64+  | CURLOPT_CUSTOMREQUEST           String+  | CURLOPT_FILETIME                Bool+  | CURLOPT_NOBODY                  Bool+  | CURLOPT_INFILESIZE              CLong+  | CURLOPT_INFILESIZE_LARGE        Int64+  | CURLOPT_UPLOAD                  Bool+  | CURLOPT_MAXFILESIZE             CLong+  | CURLOPT_MAXFILESIZE_LARGE       Int64+  | CURLOPT_TIMECONDITION           CURLtimecond+  | CURLOPT_TIMEVALUE               UTCTime++  ---- CONNECTION OPTIONS -----------------------------------------------------+  | CURLOPT_TIMEOUT                 CLong+  | CURLOPT_TIMEOUT_MS              CLong+  | CURLOPT_LOW_SPEED_LIMIT         CLong+  | CURLOPT_LOW_SPEED_TIME          CLong+  | CURLOPT_MAX_SEND_SPEED_LARGE    Int64+  | CURLOPT_MAX_RECV_SPEED_LARGE    Int64+  | CURLOPT_MAXCONNECTS             CLong+ -- CURLOPT_CLOSEPOLICY             CURLclosepol+  | CURLOPT_FRESH_CONNECT           Bool+  | CURLOPT_FORBID_REUSE            Bool+  | CURLOPT_CONNECTTIMEOUT          CLong+  | CURLOPT_CONNECTTIMEOUT_MS       CLong+  | CURLOPT_IPRESOLVE               CURLipresolve+  | CURLOPT_CONNECT_ONLY            Bool+  | CURLOPT_USE_SSL                 CURLusessl+  | CURLOPT_RESOLVE                 [String]+  | CURLOPT_DNS_SERVERS             String -- or better [String]+  | CURLOPT_ACCEPTTIMEOUT_MS        CLong++  ---- SSL and SECURITY OPTIONS -----------------------------------------------+  | CURLOPT_SSLCERT                 FilePath+  | CURLOPT_SSLCERTTYPE             String+  | CURLOPT_SSLKEY                  FilePath+  | CURLOPT_SSLKEYTYPE              String+  | CURLOPT_KEYPASSWD               String+  | CURLOPT_SSLENGINE               String+  | CURLOPT_SSLENGINE_DEFAULT       Bool+  | CURLOPT_SSLVERSION              CURLsslver+  | CURLOPT_SSL_VERIFYPEER          Bool+  | CURLOPT_CAINFO                  FilePath+  | CURLOPT_ISSUERCERT              FilePath+  | CURLOPT_CAPATH                  FilePath+  | CURLOPT_CRLFILE                 FilePath+  | CURLOPT_SSL_VERIFYHOST          CLong+  | CURLOPT_CERTINFO                Bool+  | CURLOPT_RANDOM_FILE             FilePath+  | CURLOPT_EGDSOCKET               String+  | CURLOPT_SSL_CIPHER_LIST         String -- or better [String]+  | CURLOPT_SSL_SESSIONID_CACHE     Bool+  | CURLOPT_SSL_OPTIONS             [CURLsslopt]+  | CURLOPT_KRBLEVEL                String+  | CURLOPT_GSSAPI_DELEGATION       CURLgssapi++  ---- SSH OPTIONS ------------------------------------------------------------+  | CURLOPT_SSH_AUTH_TYPES          [CURLsshauth]+  | CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 String+  | CURLOPT_SSH_PUBLIC_KEYFILE      FilePath+  | CURLOPT_SSH_PRIVATE_KEYFILE     FilePath+  | CURLOPT_SSH_KNOWNHOSTS          FilePath+ -- CURLOPT_SSH_KEYFUNCTION         (Maybe CURL_sshkey_callback)+ -- CURLOPT_SSH_KEYDATA             -- ?++  ---- OTHER OPTIONS ----------------------------------------------------------+ -- CURLOPT_PRIVATE                 -- ?+  | CURLOPT_SHARE                   (Maybe CURLSH)+  | CURLOPT_NEW_FILE_PERMS          CLong+  | CURLOPT_NEW_DIRECTORY_PERMS     CLong++  ---- TELNET OPTIONS ---------------------------------------------------------+  | CURLOPT_TELNETOPTIONS           [String]+++-------------------------------------------------------------------------------+type CURL_write_callback = ByteString -> IO CURL_write_response++data CURL_write_response+  = CURL_WRITEFUNC_OK+  | CURL_WRITEFUNC_FAIL+  | CURL_WRITEFUNC_PAUSE+  deriving (Eq)+++type CURL_read_callback = Int -> IO CURL_read_response++data CURL_read_response+  = CURL_READFUNC_OK ByteString+  | CURL_READFUNC_ABORT+  | CURL_READFUNC_PAUSE+  deriving (Eq)++++-------------------------------------------------------------------------------+data CURLC+  = CURLE_UNSUPPORTED_PROTOCOL+  | CURLE_FAILED_INIT+  | CURLE_URL_MALFORMAT+  | CURLE_NOT_BUILT_IN+  | CURLE_COULDNT_RESOLVE_PROXY+  | CURLE_COULDNT_RESOLVE_HOST+  | CURLE_COULDNT_CONNECT+  | CURLE_FTP_WEIRD_SERVER_REPLY+  | CURLE_REMOTE_ACCESS_DENIED+  | CURLE_FTP_ACCEPT_FAILED+  | CURLE_FTP_WEIRD_PASS_REPLY+  | CURLE_FTP_ACCEPT_TIMEOUT+  | CURLE_FTP_WEIRD_PASV_REPLY+  | CURLE_FTP_WEIRD_227_FORMAT+  | CURLE_FTP_CANT_GET_HOST+  | CURLE_FTP_COULDNT_SET_TYPE+  | CURLE_PARTIAL_FILE+  | CURLE_FTP_COULDNT_RETR_FILE+  | CURLE_QUOTE_ERROR+  | CURLE_HTTP_RETURNED_ERROR+  | CURLE_WRITE_ERROR+  | CURLE_UPLOAD_FAILED+  | CURLE_READ_ERROR+  | CURLE_OUT_OF_MEMORY+  | CURLE_OPERATION_TIMEDOUT+  | CURLE_FTP_PORT_FAILED+  | CURLE_FTP_COULDNT_USE_REST+  | CURLE_RANGE_ERROR+  | CURLE_HTTP_POST_ERROR+  | CURLE_SSL_CONNECT_ERROR+  | CURLE_BAD_DOWNLOAD_RESUME+  | CURLE_FILE_COULDNT_READ_FILE+  | CURLE_LDAP_CANNOT_BIND+  | CURLE_LDAP_SEARCH_FAILED+  | CURLE_FUNCTION_NOT_FOUND+  | CURLE_ABORTED_BY_CALLBACK+  | CURLE_BAD_FUNCTION_ARGUMENT+  | CURLE_INTERFACE_FAILED+  | CURLE_TOO_MANY_REDIRECTS+  | CURLE_UNKNOWN_OPTION+  | CURLE_TELNET_OPTION_SYNTAX+  | CURLE_PEER_FAILED_VERIFICATION+  | CURLE_GOT_NOTHING+  | CURLE_SSL_ENGINE_NOTFOUND+  | CURLE_SSL_ENGINE_SETFAILED+  | CURLE_SEND_ERROR+  | CURLE_RECV_ERROR+  | CURLE_SSL_CERTPROBLEM+  | CURLE_SSL_CIPHER+  | CURLE_SSL_CACERT+  | CURLE_BAD_CONTENT_ENCODING+  | CURLE_LDAP_INVALID_URL+  | CURLE_FILESIZE_EXCEEDED+  | CURLE_USE_SSL_FAILED+  | CURLE_SEND_FAIL_REWIND+  | CURLE_SSL_ENGINE_INITFAILED+  | CURLE_LOGIN_DENIED+  | CURLE_TFTP_NOTFOUND+  | CURLE_TFTP_PERM+  | CURLE_REMOTE_DISK_FULL+  | CURLE_TFTP_ILLEGAL+  | CURLE_TFTP_UNKNOWNID+  | CURLE_REMOTE_FILE_EXISTS+  | CURLE_TFTP_NOSUCHUSER+  | CURLE_CONV_FAILED+  | CURLE_CONV_REQD+  | CURLE_SSL_CACERT_BADFILE+  | CURLE_REMOTE_FILE_NOT_FOUND+  | CURLE_SSH+  | CURLE_SSL_SHUTDOWN_FAILED+  | CURLE_AGAIN+  | CURLE_SSL_CRL_BADFILE+  | CURLE_SSL_ISSUER_ERROR+  | CURLE_FTP_PRET_FAILED+  | CURLE_RTSP_CSEQ_ERROR+  | CURLE_RTSP_SESSION_ERROR+  | CURLE_FTP_BAD_FILE_LIST+  | CURLE_CHUNK_FAILED+  | CURLE_UNKNOWN_ERROR+  deriving (Show, Eq)++toCURLC :: CInt -> CURLC+toCURLC x = case x of+  #{const CURLE_UNSUPPORTED_PROTOCOL    } -> CURLE_UNSUPPORTED_PROTOCOL+  #{const CURLE_FAILED_INIT             } -> CURLE_FAILED_INIT+  #{const CURLE_URL_MALFORMAT           } -> CURLE_URL_MALFORMAT+  #{const CURLE_NOT_BUILT_IN            } -> CURLE_NOT_BUILT_IN+  #{const CURLE_COULDNT_RESOLVE_PROXY   } -> CURLE_COULDNT_RESOLVE_PROXY+  #{const CURLE_COULDNT_RESOLVE_HOST    } -> CURLE_COULDNT_RESOLVE_HOST+  #{const CURLE_COULDNT_CONNECT         } -> CURLE_COULDNT_CONNECT+  #{const CURLE_FTP_WEIRD_SERVER_REPLY  } -> CURLE_FTP_WEIRD_SERVER_REPLY+  #{const CURLE_REMOTE_ACCESS_DENIED    } -> CURLE_REMOTE_ACCESS_DENIED+  #{const CURLE_FTP_ACCEPT_FAILED       } -> CURLE_FTP_ACCEPT_FAILED+  #{const CURLE_FTP_WEIRD_PASS_REPLY    } -> CURLE_FTP_WEIRD_PASS_REPLY+  #{const CURLE_FTP_ACCEPT_TIMEOUT      } -> CURLE_FTP_ACCEPT_TIMEOUT+  #{const CURLE_FTP_WEIRD_PASV_REPLY    } -> CURLE_FTP_WEIRD_PASV_REPLY+  #{const CURLE_FTP_WEIRD_227_FORMAT    } -> CURLE_FTP_WEIRD_227_FORMAT+  #{const CURLE_FTP_CANT_GET_HOST       } -> CURLE_FTP_CANT_GET_HOST+  #{const CURLE_FTP_COULDNT_SET_TYPE    } -> CURLE_FTP_COULDNT_SET_TYPE+  #{const CURLE_PARTIAL_FILE            } -> CURLE_PARTIAL_FILE+  #{const CURLE_FTP_COULDNT_RETR_FILE   } -> CURLE_FTP_COULDNT_RETR_FILE+  #{const CURLE_QUOTE_ERROR             } -> CURLE_QUOTE_ERROR+  #{const CURLE_HTTP_RETURNED_ERROR     } -> CURLE_HTTP_RETURNED_ERROR+  #{const CURLE_WRITE_ERROR             } -> CURLE_WRITE_ERROR+  #{const CURLE_UPLOAD_FAILED           } -> CURLE_UPLOAD_FAILED+  #{const CURLE_READ_ERROR              } -> CURLE_READ_ERROR+  #{const CURLE_OUT_OF_MEMORY           } -> CURLE_OUT_OF_MEMORY+  #{const CURLE_OPERATION_TIMEDOUT      } -> CURLE_OPERATION_TIMEDOUT+  #{const CURLE_FTP_PORT_FAILED         } -> CURLE_FTP_PORT_FAILED+  #{const CURLE_FTP_COULDNT_USE_REST    } -> CURLE_FTP_COULDNT_USE_REST+  #{const CURLE_RANGE_ERROR             } -> CURLE_RANGE_ERROR+  #{const CURLE_HTTP_POST_ERROR         } -> CURLE_HTTP_POST_ERROR+  #{const CURLE_SSL_CONNECT_ERROR       } -> CURLE_SSL_CONNECT_ERROR+  #{const CURLE_BAD_DOWNLOAD_RESUME     } -> CURLE_BAD_DOWNLOAD_RESUME+  #{const CURLE_FILE_COULDNT_READ_FILE  } -> CURLE_FILE_COULDNT_READ_FILE+  #{const CURLE_LDAP_CANNOT_BIND        } -> CURLE_LDAP_CANNOT_BIND+  #{const CURLE_LDAP_SEARCH_FAILED      } -> CURLE_LDAP_SEARCH_FAILED+  #{const CURLE_FUNCTION_NOT_FOUND      } -> CURLE_FUNCTION_NOT_FOUND+  #{const CURLE_ABORTED_BY_CALLBACK     } -> CURLE_ABORTED_BY_CALLBACK+  #{const CURLE_BAD_FUNCTION_ARGUMENT   } -> CURLE_BAD_FUNCTION_ARGUMENT+  #{const CURLE_INTERFACE_FAILED        } -> CURLE_INTERFACE_FAILED+  #{const CURLE_TOO_MANY_REDIRECTS      } -> CURLE_TOO_MANY_REDIRECTS+  #{const CURLE_UNKNOWN_OPTION          } -> CURLE_UNKNOWN_OPTION+  #{const CURLE_TELNET_OPTION_SYNTAX    } -> CURLE_TELNET_OPTION_SYNTAX+  #{const CURLE_PEER_FAILED_VERIFICATION} -> CURLE_PEER_FAILED_VERIFICATION+  #{const CURLE_GOT_NOTHING             } -> CURLE_GOT_NOTHING+  #{const CURLE_SSL_ENGINE_NOTFOUND     } -> CURLE_SSL_ENGINE_NOTFOUND+  #{const CURLE_SSL_ENGINE_SETFAILED    } -> CURLE_SSL_ENGINE_SETFAILED+  #{const CURLE_SEND_ERROR              } -> CURLE_SEND_ERROR+  #{const CURLE_RECV_ERROR              } -> CURLE_RECV_ERROR+  #{const CURLE_SSL_CERTPROBLEM         } -> CURLE_SSL_CERTPROBLEM+  #{const CURLE_SSL_CIPHER              } -> CURLE_SSL_CIPHER+  #{const CURLE_SSL_CACERT              } -> CURLE_SSL_CACERT+  #{const CURLE_BAD_CONTENT_ENCODING    } -> CURLE_BAD_CONTENT_ENCODING+  #{const CURLE_LDAP_INVALID_URL        } -> CURLE_LDAP_INVALID_URL+  #{const CURLE_FILESIZE_EXCEEDED       } -> CURLE_FILESIZE_EXCEEDED+  #{const CURLE_USE_SSL_FAILED          } -> CURLE_USE_SSL_FAILED+  #{const CURLE_SEND_FAIL_REWIND        } -> CURLE_SEND_FAIL_REWIND+  #{const CURLE_SSL_ENGINE_INITFAILED   } -> CURLE_SSL_ENGINE_INITFAILED+  #{const CURLE_LOGIN_DENIED            } -> CURLE_LOGIN_DENIED+  #{const CURLE_TFTP_NOTFOUND           } -> CURLE_TFTP_NOTFOUND+  #{const CURLE_TFTP_PERM               } -> CURLE_TFTP_PERM+  #{const CURLE_REMOTE_DISK_FULL        } -> CURLE_REMOTE_DISK_FULL+  #{const CURLE_TFTP_ILLEGAL            } -> CURLE_TFTP_ILLEGAL+  #{const CURLE_TFTP_UNKNOWNID          } -> CURLE_TFTP_UNKNOWNID+  #{const CURLE_REMOTE_FILE_EXISTS      } -> CURLE_REMOTE_FILE_EXISTS+  #{const CURLE_TFTP_NOSUCHUSER         } -> CURLE_TFTP_NOSUCHUSER+  #{const CURLE_CONV_FAILED             } -> CURLE_CONV_FAILED+  #{const CURLE_CONV_REQD               } -> CURLE_CONV_REQD+  #{const CURLE_SSL_CACERT_BADFILE      } -> CURLE_SSL_CACERT_BADFILE+  #{const CURLE_REMOTE_FILE_NOT_FOUND   } -> CURLE_REMOTE_FILE_NOT_FOUND+  #{const CURLE_SSH                     } -> CURLE_SSH+  #{const CURLE_SSL_SHUTDOWN_FAILED     } -> CURLE_SSL_SHUTDOWN_FAILED+  #{const CURLE_AGAIN                   } -> CURLE_AGAIN+  #{const CURLE_SSL_CRL_BADFILE         } -> CURLE_SSL_CRL_BADFILE+  #{const CURLE_SSL_ISSUER_ERROR        } -> CURLE_SSL_ISSUER_ERROR+  #{const CURLE_FTP_PRET_FAILED         } -> CURLE_FTP_PRET_FAILED+  #{const CURLE_RTSP_CSEQ_ERROR         } -> CURLE_RTSP_CSEQ_ERROR+  #{const CURLE_RTSP_SESSION_ERROR      } -> CURLE_RTSP_SESSION_ERROR+  #{const CURLE_FTP_BAD_FILE_LIST       } -> CURLE_FTP_BAD_FILE_LIST+  #{const CURLE_CHUNK_FAILED            } -> CURLE_CHUNK_FAILED+  _                                       -> CURLE_UNKNOWN_ERROR+++-------------------------------------------------------------------------------+data CURLCB where+  CURLCB :: CURLCBT a -> FunPtr () -> CURLCB++data CURLCBT a where+  FWRITE :: CURLCBT CURL_write_callback+  FREAD  :: CURLCBT CURL_read_callback++type CURLSL = (CInt, Ptr C.CURLslist)+++-------------------------------------------------------------------------------+data CURL = CURL Unique (MVar (Ptr C.CURL)) (IORef [CURLCB]) (IORef [CURLSL])++instance Show CURL where+  showsPrec p (CURL u _ _ _) = showString "CURL#" . showsPrec p (hashUnique u)++instance Eq CURL where+  (CURL u1 _ _ _) == (CURL u2 _ _ _) = u1 == u2+++-------------------------------------------------------------------------------+data CURLE = CURLE CURL String String CURLC+  deriving (Eq, Typeable)++instance Exception CURLE++instance Show CURLE where+  showsPrec p (CURLE curl func desc code) =+    showString "\n<curlhs> " . showString desc+    . showString "\n<curlhs> " . showsPrec p code . showString " ("+    . showString func . showString " <" . showsPrec p curl . showString ">)"++

@@ -0,0 +1,21 @@+COPYRIGHT AND PERMISSION NOTICE++Copyright (c) 1996 - 2013, Daniel Stenberg, <daniel@haxx.se>.++All rights reserved.++Permission to use, copy, modify, and distribute this software for any purpose+with or without fee is hereby granted, provided that the above copyright+notice and this permission notice appear in all copies.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE+OR OTHER DEALINGS IN THE SOFTWARE.++Except as contained in this notice, the name of a copyright holder shall not+be used in advertising or otherwise to promote the sale, use or other dealings+in this Software without prior written authorization of the copyright holder.

@@ -0,0 +1,2227 @@+#ifndef __CURL_CURL_H+#define __CURL_CURL_H+/***************************************************************************+ *                                  _   _ ____  _+ *  Project                     ___| | | |  _ \| |+ *                             / __| | | | |_) | |+ *                            | (__| |_| |  _ <| |___+ *                             \___|\___/|_| \_\_____|+ *+ * Copyright (C) 1998 - 2013, Daniel Stenberg, <daniel@haxx.se>, et al.+ *+ * This software is licensed as described in the file COPYING, which+ * you should have received as part of this distribution. The terms+ * are also available at http://curl.haxx.se/docs/copyright.html.+ *+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell+ * copies of the Software, and permit persons to whom the Software is+ * furnished to do so, under the terms of the COPYING file.+ *+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY+ * KIND, either express or implied.+ *+ ***************************************************************************/++/*+ * If you have libcurl problems, all docs and details are found here:+ *   http://curl.haxx.se/libcurl/+ *+ * curl-library mailing list subscription and unsubscription web interface:+ *   http://cool.haxx.se/mailman/listinfo/curl-library/+ */++#include "curlver.h"         /* libcurl version defines   */+#include "curlbuild.h"       /* libcurl build definitions */+#include "curlrules.h"       /* libcurl rules enforcement */++/*+ * Define WIN32 when build target is Win32 API+ */++#if (defined(_WIN32) || defined(__WIN32__)) && \+     !defined(WIN32) && !defined(__SYMBIAN32__)+#define WIN32+#endif++#include <stdio.h>+#include <limits.h>++#if defined(__FreeBSD__) && (__FreeBSD__ >= 2)+/* Needed for __FreeBSD_version symbol definition */+#include <osreldate.h>+#endif++/* The include stuff here below is mainly for time_t! */+#include <sys/types.h>+#include <time.h>++#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__)+#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || defined(__LWIP_OPT_H__))+/* The check above prevents the winsock2 inclusion if winsock.h already was+   included, since they can't co-exist without problems */+#include <winsock2.h>+#include <ws2tcpip.h>+#endif+#endif++/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish+   libc5-based Linux systems. Only include it on systems that are known to+   require it! */+#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \+    defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \+    defined(ANDROID) || defined(__ANDROID__) || \+   (defined(__FreeBSD_version) && (__FreeBSD_version < 800000))+#include <sys/select.h>+#endif++#if !defined(WIN32) && !defined(_WIN32_WCE)+#include <sys/socket.h>+#endif++#if !defined(WIN32) && !defined(__WATCOMC__) && !defined(__VXWORKS__)+#include <sys/time.h>+#endif++#ifdef __BEOS__+#include <support/SupportDefs.h>+#endif++#ifdef  __cplusplus+extern "C" {+#endif++typedef void CURL;++/*+ * libcurl external API function linkage decorations.+ */++#ifdef CURL_STATICLIB+#  define CURL_EXTERN+#elif defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__)+#  if defined(BUILDING_LIBCURL)+#    define CURL_EXTERN  __declspec(dllexport)+#  else+#    define CURL_EXTERN  __declspec(dllimport)+#  endif+#elif defined(BUILDING_LIBCURL) && defined(CURL_HIDDEN_SYMBOLS)+#  define CURL_EXTERN CURL_EXTERN_SYMBOL+#else+#  define CURL_EXTERN+#endif++#ifndef curl_socket_typedef+/* socket typedef */+#if defined(WIN32) && !defined(__LWIP_OPT_H__)+typedef SOCKET curl_socket_t;+#define CURL_SOCKET_BAD INVALID_SOCKET+#else+typedef int curl_socket_t;+#define CURL_SOCKET_BAD -1+#endif+#define curl_socket_typedef+#endif /* curl_socket_typedef */++struct curl_httppost {+  struct curl_httppost *next;       /* next entry in the list */+  char *name;                       /* pointer to allocated name */+  long namelength;                  /* length of name length */+  char *contents;                   /* pointer to allocated data contents */+  long contentslength;              /* length of contents field */+  char *buffer;                     /* pointer to allocated buffer contents */+  long bufferlength;                /* length of buffer field */+  char *contenttype;                /* Content-Type */+  struct curl_slist* contentheader; /* list of extra headers for this form */+  struct curl_httppost *more;       /* if one field name has more than one+                                       file, this link should link to following+                                       files */+  long flags;                       /* as defined below */+#define HTTPPOST_FILENAME (1<<0)    /* specified content is a file name */+#define HTTPPOST_READFILE (1<<1)    /* specified content is a file name */+#define HTTPPOST_PTRNAME (1<<2)     /* name is only stored pointer+                                       do not free in formfree */+#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer+                                       do not free in formfree */+#define HTTPPOST_BUFFER (1<<4)      /* upload file from buffer */+#define HTTPPOST_PTRBUFFER (1<<5)   /* upload file from pointer contents */+#define HTTPPOST_CALLBACK (1<<6)    /* upload file contents by using the+                                       regular read callback to get the data+                                       and pass the given pointer as custom+                                       pointer */++  char *showfilename;               /* The file name to show. If not set, the+                                       actual file name will be used (if this+                                       is a file part) */+  void *userp;                      /* custom pointer used for+                                       HTTPPOST_CALLBACK posts */+};++typedef int (*curl_progress_callback)(void *clientp,+                                      double dltotal,+                                      double dlnow,+                                      double ultotal,+                                      double ulnow);++#ifndef CURL_MAX_WRITE_SIZE+  /* Tests have proven that 20K is a very bad buffer size for uploads on+     Windows, while 16K for some odd reason performed a lot better.+     We do the ifndef check to allow this value to easier be changed at build+     time for those who feel adventurous. The practical minimum is about+     400 bytes since libcurl uses a buffer of this size as a scratch area+     (unrelated to network send operations). */+#define CURL_MAX_WRITE_SIZE 16384+#endif++#ifndef CURL_MAX_HTTP_HEADER+/* The only reason to have a max limit for this is to avoid the risk of a bad+   server feeding libcurl with a never-ending header that will cause reallocs+   infinitely */+#define CURL_MAX_HTTP_HEADER (100*1024)+#endif++/* This is a magic return code for the write callback that, when returned,+   will signal libcurl to pause receiving on the current transfer. */+#define CURL_WRITEFUNC_PAUSE 0x10000001++typedef size_t (*curl_write_callback)(char *buffer,+                                      size_t size,+                                      size_t nitems,+                                      void *outstream);++++/* enumeration of file types */+typedef enum {+  CURLFILETYPE_FILE = 0,+  CURLFILETYPE_DIRECTORY,+  CURLFILETYPE_SYMLINK,+  CURLFILETYPE_DEVICE_BLOCK,+  CURLFILETYPE_DEVICE_CHAR,+  CURLFILETYPE_NAMEDPIPE,+  CURLFILETYPE_SOCKET,+  CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */++  CURLFILETYPE_UNKNOWN /* should never occur */+} curlfiletype;++#define CURLFINFOFLAG_KNOWN_FILENAME    (1<<0)+#define CURLFINFOFLAG_KNOWN_FILETYPE    (1<<1)+#define CURLFINFOFLAG_KNOWN_TIME        (1<<2)+#define CURLFINFOFLAG_KNOWN_PERM        (1<<3)+#define CURLFINFOFLAG_KNOWN_UID         (1<<4)+#define CURLFINFOFLAG_KNOWN_GID         (1<<5)+#define CURLFINFOFLAG_KNOWN_SIZE        (1<<6)+#define CURLFINFOFLAG_KNOWN_HLINKCOUNT  (1<<7)++/* Content of this structure depends on information which is known and is+   achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man+   page for callbacks returning this structure -- some fields are mandatory,+   some others are optional. The FLAG field has special meaning. */+struct curl_fileinfo {+  char *filename;+  curlfiletype filetype;+  time_t time;+  unsigned int perm;+  int uid;+  int gid;+  curl_off_t size;+  long int hardlinks;++  struct {+    /* If some of these fields is not NULL, it is a pointer to b_data. */+    char *time;+    char *perm;+    char *user;+    char *group;+    char *target; /* pointer to the target filename of a symlink */+  } strings;++  unsigned int flags;++  /* used internally */+  char * b_data;+  size_t b_size;+  size_t b_used;+};++/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */+#define CURL_CHUNK_BGN_FUNC_OK      0+#define CURL_CHUNK_BGN_FUNC_FAIL    1 /* tell the lib to end the task */+#define CURL_CHUNK_BGN_FUNC_SKIP    2 /* skip this chunk over */++/* if splitting of data transfer is enabled, this callback is called before+   download of an individual chunk started. Note that parameter "remains" works+   only for FTP wildcard downloading (for now), otherwise is not used */+typedef long (*curl_chunk_bgn_callback)(const void *transfer_info,+                                        void *ptr,+                                        int remains);++/* return codes for CURLOPT_CHUNK_END_FUNCTION */+#define CURL_CHUNK_END_FUNC_OK      0+#define CURL_CHUNK_END_FUNC_FAIL    1 /* tell the lib to end the task */++/* If splitting of data transfer is enabled this callback is called after+   download of an individual chunk finished.+   Note! After this callback was set then it have to be called FOR ALL chunks.+   Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC.+   This is the reason why we don't need "transfer_info" parameter in this+   callback and we are not interested in "remains" parameter too. */+typedef long (*curl_chunk_end_callback)(void *ptr);++/* return codes for FNMATCHFUNCTION */+#define CURL_FNMATCHFUNC_MATCH    0 /* string corresponds to the pattern */+#define CURL_FNMATCHFUNC_NOMATCH  1 /* pattern doesn't match the string */+#define CURL_FNMATCHFUNC_FAIL     2 /* an error occurred */++/* callback type for wildcard downloading pattern matching. If the+   string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */+typedef int (*curl_fnmatch_callback)(void *ptr,+                                     const char *pattern,+                                     const char *string);++/* These are the return codes for the seek callbacks */+#define CURL_SEEKFUNC_OK       0+#define CURL_SEEKFUNC_FAIL     1 /* fail the entire transfer */+#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so+                                    libcurl might try other means instead */+typedef int (*curl_seek_callback)(void *instream,+                                  curl_off_t offset,+                                  int origin); /* 'whence' */++/* This is a return code for the read callback that, when returned, will+   signal libcurl to immediately abort the current transfer. */+#define CURL_READFUNC_ABORT 0x10000000+/* This is a return code for the read callback that, when returned, will+   signal libcurl to pause sending data on the current transfer. */+#define CURL_READFUNC_PAUSE 0x10000001++typedef size_t (*curl_read_callback)(char *buffer,+                                      size_t size,+                                      size_t nitems,+                                      void *instream);++typedef enum  {+  CURLSOCKTYPE_IPCXN,  /* socket created for a specific IP connection */+  CURLSOCKTYPE_ACCEPT, /* socket created by accept() call */+  CURLSOCKTYPE_LAST    /* never use */+} curlsocktype;++/* The return code from the sockopt_callback can signal information back+   to libcurl: */+#define CURL_SOCKOPT_OK 0+#define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return+                                CURLE_ABORTED_BY_CALLBACK */+#define CURL_SOCKOPT_ALREADY_CONNECTED 2++typedef int (*curl_sockopt_callback)(void *clientp,+                                     curl_socket_t curlfd,+                                     curlsocktype purpose);++struct curl_sockaddr {+  int family;+  int socktype;+  int protocol;+  unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it+                           turned really ugly and painful on the systems that+                           lack this type */+  struct sockaddr addr;+};++typedef curl_socket_t+(*curl_opensocket_callback)(void *clientp,+                            curlsocktype purpose,+                            struct curl_sockaddr *address);++typedef int+(*curl_closesocket_callback)(void *clientp, curl_socket_t item);++typedef enum {+  CURLIOE_OK,            /* I/O operation successful */+  CURLIOE_UNKNOWNCMD,    /* command was unknown to callback */+  CURLIOE_FAILRESTART,   /* failed to restart the read */+  CURLIOE_LAST           /* never use */+} curlioerr;++typedef enum  {+  CURLIOCMD_NOP,         /* no operation */+  CURLIOCMD_RESTARTREAD, /* restart the read stream from start */+  CURLIOCMD_LAST         /* never use */+} curliocmd;++typedef curlioerr (*curl_ioctl_callback)(CURL *handle,+                                         int cmd,+                                         void *clientp);++/*+ * The following typedef's are signatures of malloc, free, realloc, strdup and+ * calloc respectively.  Function pointers of these types can be passed to the+ * curl_global_init_mem() function to set user defined memory management+ * callback routines.+ */+typedef void *(*curl_malloc_callback)(size_t size);+typedef void (*curl_free_callback)(void *ptr);+typedef void *(*curl_realloc_callback)(void *ptr, size_t size);+typedef char *(*curl_strdup_callback)(const char *str);+typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size);++/* the kind of data that is passed to information_callback*/+typedef enum {+  CURLINFO_TEXT = 0,+  CURLINFO_HEADER_IN,    /* 1 */+  CURLINFO_HEADER_OUT,   /* 2 */+  CURLINFO_DATA_IN,      /* 3 */+  CURLINFO_DATA_OUT,     /* 4 */+  CURLINFO_SSL_DATA_IN,  /* 5 */+  CURLINFO_SSL_DATA_OUT, /* 6 */+  CURLINFO_END+} curl_infotype;++typedef int (*curl_debug_callback)+       (CURL *handle,      /* the handle/transfer this concerns */+        curl_infotype type, /* what kind of data */+        char *data,        /* points to the data */+        size_t size,       /* size of the data pointed to */+        void *userptr);    /* whatever the user please */++/* All possible error codes from all sorts of curl functions. Future versions+   may return other values, stay prepared.++   Always add new return codes last. Never *EVER* remove any. The return+   codes must remain the same!+ */++typedef enum {+  CURLE_OK = 0,+  CURLE_UNSUPPORTED_PROTOCOL,    /* 1 */+  CURLE_FAILED_INIT,             /* 2 */+  CURLE_URL_MALFORMAT,           /* 3 */+  CURLE_NOT_BUILT_IN,            /* 4 - [was obsoleted in August 2007 for+                                    7.17.0, reused in April 2011 for 7.21.5] */+  CURLE_COULDNT_RESOLVE_PROXY,   /* 5 */+  CURLE_COULDNT_RESOLVE_HOST,    /* 6 */+  CURLE_COULDNT_CONNECT,         /* 7 */+  CURLE_FTP_WEIRD_SERVER_REPLY,  /* 8 */+  CURLE_REMOTE_ACCESS_DENIED,    /* 9 a service was denied by the server+                                    due to lack of access - when login fails+                                    this is not returned. */+  CURLE_FTP_ACCEPT_FAILED,       /* 10 - [was obsoleted in April 2006 for+                                    7.15.4, reused in Dec 2011 for 7.24.0]*/+  CURLE_FTP_WEIRD_PASS_REPLY,    /* 11 */+  CURLE_FTP_ACCEPT_TIMEOUT,      /* 12 - timeout occurred accepting server+                                    [was obsoleted in August 2007 for 7.17.0,+                                    reused in Dec 2011 for 7.24.0]*/+  CURLE_FTP_WEIRD_PASV_REPLY,    /* 13 */+  CURLE_FTP_WEIRD_227_FORMAT,    /* 14 */+  CURLE_FTP_CANT_GET_HOST,       /* 15 */+  CURLE_OBSOLETE16,              /* 16 - NOT USED */+  CURLE_FTP_COULDNT_SET_TYPE,    /* 17 */+  CURLE_PARTIAL_FILE,            /* 18 */+  CURLE_FTP_COULDNT_RETR_FILE,   /* 19 */+  CURLE_OBSOLETE20,              /* 20 - NOT USED */+  CURLE_QUOTE_ERROR,             /* 21 - quote command failure */+  CURLE_HTTP_RETURNED_ERROR,     /* 22 */+  CURLE_WRITE_ERROR,             /* 23 */+  CURLE_OBSOLETE24,              /* 24 - NOT USED */+  CURLE_UPLOAD_FAILED,           /* 25 - failed upload "command" */+  CURLE_READ_ERROR,              /* 26 - couldn't open/read from file */+  CURLE_OUT_OF_MEMORY,           /* 27 */+  /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error+           instead of a memory allocation error if CURL_DOES_CONVERSIONS+           is defined+  */+  CURLE_OPERATION_TIMEDOUT,      /* 28 - the timeout time was reached */+  CURLE_OBSOLETE29,              /* 29 - NOT USED */+  CURLE_FTP_PORT_FAILED,         /* 30 - FTP PORT operation failed */+  CURLE_FTP_COULDNT_USE_REST,    /* 31 - the REST command failed */+  CURLE_OBSOLETE32,              /* 32 - NOT USED */+  CURLE_RANGE_ERROR,             /* 33 - RANGE "command" didn't work */+  CURLE_HTTP_POST_ERROR,         /* 34 */+  CURLE_SSL_CONNECT_ERROR,       /* 35 - wrong when connecting with SSL */+  CURLE_BAD_DOWNLOAD_RESUME,     /* 36 - couldn't resume download */+  CURLE_FILE_COULDNT_READ_FILE,  /* 37 */+  CURLE_LDAP_CANNOT_BIND,        /* 38 */+  CURLE_LDAP_SEARCH_FAILED,      /* 39 */+  CURLE_OBSOLETE40,              /* 40 - NOT USED */+  CURLE_FUNCTION_NOT_FOUND,      /* 41 */+  CURLE_ABORTED_BY_CALLBACK,     /* 42 */+  CURLE_BAD_FUNCTION_ARGUMENT,   /* 43 */+  CURLE_OBSOLETE44,              /* 44 - NOT USED */+  CURLE_INTERFACE_FAILED,        /* 45 - CURLOPT_INTERFACE failed */+  CURLE_OBSOLETE46,              /* 46 - NOT USED */+  CURLE_TOO_MANY_REDIRECTS ,     /* 47 - catch endless re-direct loops */+  CURLE_UNKNOWN_OPTION,          /* 48 - User specified an unknown option */+  CURLE_TELNET_OPTION_SYNTAX ,   /* 49 - Malformed telnet option */+  CURLE_OBSOLETE50,              /* 50 - NOT USED */+  CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint+                                     wasn't verified fine */+  CURLE_GOT_NOTHING,             /* 52 - when this is a specific error */+  CURLE_SSL_ENGINE_NOTFOUND,     /* 53 - SSL crypto engine not found */+  CURLE_SSL_ENGINE_SETFAILED,    /* 54 - can not set SSL crypto engine as+                                    default */+  CURLE_SEND_ERROR,              /* 55 - failed sending network data */+  CURLE_RECV_ERROR,              /* 56 - failure in receiving network data */+  CURLE_OBSOLETE57,              /* 57 - NOT IN USE */+  CURLE_SSL_CERTPROBLEM,         /* 58 - problem with the local certificate */+  CURLE_SSL_CIPHER,              /* 59 - couldn't use specified cipher */+  CURLE_SSL_CACERT,              /* 60 - problem with the CA cert (path?) */+  CURLE_BAD_CONTENT_ENCODING,    /* 61 - Unrecognized/bad encoding */+  CURLE_LDAP_INVALID_URL,        /* 62 - Invalid LDAP URL */+  CURLE_FILESIZE_EXCEEDED,       /* 63 - Maximum file size exceeded */+  CURLE_USE_SSL_FAILED,          /* 64 - Requested FTP SSL level failed */+  CURLE_SEND_FAIL_REWIND,        /* 65 - Sending the data requires a rewind+                                    that failed */+  CURLE_SSL_ENGINE_INITFAILED,   /* 66 - failed to initialise ENGINE */+  CURLE_LOGIN_DENIED,            /* 67 - user, password or similar was not+                                    accepted and we failed to login */+  CURLE_TFTP_NOTFOUND,           /* 68 - file not found on server */+  CURLE_TFTP_PERM,               /* 69 - permission problem on server */+  CURLE_REMOTE_DISK_FULL,        /* 70 - out of disk space on server */+  CURLE_TFTP_ILLEGAL,            /* 71 - Illegal TFTP operation */+  CURLE_TFTP_UNKNOWNID,          /* 72 - Unknown transfer ID */+  CURLE_REMOTE_FILE_EXISTS,      /* 73 - File already exists */+  CURLE_TFTP_NOSUCHUSER,         /* 74 - No such user */+  CURLE_CONV_FAILED,             /* 75 - conversion failed */+  CURLE_CONV_REQD,               /* 76 - caller must register conversion+                                    callbacks using curl_easy_setopt options+                                    CURLOPT_CONV_FROM_NETWORK_FUNCTION,+                                    CURLOPT_CONV_TO_NETWORK_FUNCTION, and+                                    CURLOPT_CONV_FROM_UTF8_FUNCTION */+  CURLE_SSL_CACERT_BADFILE,      /* 77 - could not load CACERT file, missing+                                    or wrong format */+  CURLE_REMOTE_FILE_NOT_FOUND,   /* 78 - remote file not found */+  CURLE_SSH,                     /* 79 - error from the SSH layer, somewhat+                                    generic so the error message will be of+                                    interest when this has happened */++  CURLE_SSL_SHUTDOWN_FAILED,     /* 80 - Failed to shut down the SSL+                                    connection */+  CURLE_AGAIN,                   /* 81 - socket is not ready for send/recv,+                                    wait till it's ready and try again (Added+                                    in 7.18.2) */+  CURLE_SSL_CRL_BADFILE,         /* 82 - could not load CRL file, missing or+                                    wrong format (Added in 7.19.0) */+  CURLE_SSL_ISSUER_ERROR,        /* 83 - Issuer check failed.  (Added in+                                    7.19.0) */+  CURLE_FTP_PRET_FAILED,         /* 84 - a PRET command failed */+  CURLE_RTSP_CSEQ_ERROR,         /* 85 - mismatch of RTSP CSeq numbers */+  CURLE_RTSP_SESSION_ERROR,      /* 86 - mismatch of RTSP Session Ids */+  CURLE_FTP_BAD_FILE_LIST,       /* 87 - unable to parse FTP file list */+  CURLE_CHUNK_FAILED,            /* 88 - chunk callback reported error */+  CURLE_NO_CONNECTION_AVAILABLE, /* 89 - No connection available, the+                                    session will be queued */+  CURL_LAST /* never use! */+} CURLcode;++#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all+                          the obsolete stuff removed! */++/* Previously obsoletes error codes re-used in 7.24.0 */+#define CURLE_OBSOLETE10 CURLE_FTP_ACCEPT_FAILED+#define CURLE_OBSOLETE12 CURLE_FTP_ACCEPT_TIMEOUT++/*  compatibility with older names */+#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING++/* The following were added in 7.21.5, April 2011 */+#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION++/* The following were added in 7.17.1 */+/* These are scheduled to disappear by 2009 */+#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION++/* The following were added in 7.17.0 */+/* These are scheduled to disappear by 2009 */+#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */+#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46+#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44+#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10+#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16+#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32+#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29+#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12+#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20+#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40+#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24+#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57+#define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN++#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED+#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE+#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR+#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL+#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS+#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR+#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED++/* The following were added earlier */++#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT++#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR+#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED+#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED++#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE+#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME++/* This was the error code 50 in 7.7.3 and a few earlier versions, this+   is no longer used by libcurl but is instead #defined here only to not+   make programs break */+#define CURLE_ALREADY_COMPLETE 99999++#endif /*!CURL_NO_OLDIES*/++/* This prototype applies to all conversion callbacks */+typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length);++typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl,    /* easy handle */+                                          void *ssl_ctx, /* actually an+                                                            OpenSSL SSL_CTX */+                                          void *userptr);++typedef enum {+  CURLPROXY_HTTP = 0,   /* added in 7.10, new in 7.19.4 default is to use+                           CONNECT HTTP/1.1 */+  CURLPROXY_HTTP_1_0 = 1,   /* added in 7.19.4, force to use CONNECT+                               HTTP/1.0  */+  CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already+                           in 7.10 */+  CURLPROXY_SOCKS5 = 5, /* added in 7.10 */+  CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */+  CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the+                                   host name rather than the IP address. added+                                   in 7.18.0 */+} curl_proxytype;  /* this enum was added in 7.10 */++/*+ * Bitmasks for CURLOPT_HTTPAUTH and CURLOPT_PROXYAUTH options:+ *+ * CURLAUTH_NONE         - No HTTP authentication+ * CURLAUTH_BASIC        - HTTP Basic authentication (default)+ * CURLAUTH_DIGEST       - HTTP Digest authentication+ * CURLAUTH_GSSNEGOTIATE - HTTP GSS-Negotiate authentication+ * CURLAUTH_NTLM         - HTTP NTLM authentication+ * CURLAUTH_DIGEST_IE    - HTTP Digest authentication with IE flavour+ * CURLAUTH_NTLM_WB      - HTTP NTLM authentication delegated to winbind helper+ * CURLAUTH_ONLY         - Use together with a single other type to force no+ *                         authentication or just that single type+ * CURLAUTH_ANY          - All fine types set+ * CURLAUTH_ANYSAFE      - All fine types except Basic+ */++#define CURLAUTH_NONE         ((unsigned long)0)+#define CURLAUTH_BASIC        (((unsigned long)1)<<0)+#define CURLAUTH_DIGEST       (((unsigned long)1)<<1)+#define CURLAUTH_GSSNEGOTIATE (((unsigned long)1)<<2)+#define CURLAUTH_NTLM         (((unsigned long)1)<<3)+#define CURLAUTH_DIGEST_IE    (((unsigned long)1)<<4)+#define CURLAUTH_NTLM_WB      (((unsigned long)1)<<5)+#define CURLAUTH_ONLY         (((unsigned long)1)<<31)+#define CURLAUTH_ANY          (~CURLAUTH_DIGEST_IE)+#define CURLAUTH_ANYSAFE      (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE))++#define CURLSSH_AUTH_ANY       ~0     /* all types supported by the server */+#define CURLSSH_AUTH_NONE      0      /* none allowed, silly but complete */+#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */+#define CURLSSH_AUTH_PASSWORD  (1<<1) /* password */+#define CURLSSH_AUTH_HOST      (1<<2) /* host key files */+#define CURLSSH_AUTH_KEYBOARD  (1<<3) /* keyboard interactive */+#define CURLSSH_AUTH_AGENT     (1<<4) /* agent (ssh-agent, pageant...) */+#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY++#define CURLGSSAPI_DELEGATION_NONE        0      /* no delegation (default) */+#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */+#define CURLGSSAPI_DELEGATION_FLAG        (1<<1) /* delegate always */++#define CURL_ERROR_SIZE 256++struct curl_khkey {+  const char *key; /* points to a zero-terminated string encoded with base64+                      if len is zero, otherwise to the "raw" data */+  size_t len;+  enum type {+    CURLKHTYPE_UNKNOWN,+    CURLKHTYPE_RSA1,+    CURLKHTYPE_RSA,+    CURLKHTYPE_DSS+  } keytype;+};++/* this is the set of return values expected from the curl_sshkeycallback+   callback */+enum curl_khstat {+  CURLKHSTAT_FINE_ADD_TO_FILE,+  CURLKHSTAT_FINE,+  CURLKHSTAT_REJECT, /* reject the connection, return an error */+  CURLKHSTAT_DEFER,  /* do not accept it, but we can't answer right now so+                        this causes a CURLE_DEFER error but otherwise the+                        connection will be left intact etc */+  CURLKHSTAT_LAST    /* not for use, only a marker for last-in-list */+};++/* this is the set of status codes pass in to the callback */+enum curl_khmatch {+  CURLKHMATCH_OK,       /* match */+  CURLKHMATCH_MISMATCH, /* host found, key mismatch! */+  CURLKHMATCH_MISSING,  /* no matching host/key found */+  CURLKHMATCH_LAST      /* not for use, only a marker for last-in-list */+};++typedef int+  (*curl_sshkeycallback) (CURL *easy,     /* easy handle */+                          const struct curl_khkey *knownkey, /* known */+                          const struct curl_khkey *foundkey, /* found */+                          enum curl_khmatch, /* libcurl's view on the keys */+                          void *clientp); /* custom pointer passed from app */++/* parameter for the CURLOPT_USE_SSL option */+typedef enum {+  CURLUSESSL_NONE,    /* do not attempt to use SSL */+  CURLUSESSL_TRY,     /* try using SSL, proceed anyway otherwise */+  CURLUSESSL_CONTROL, /* SSL for the control connection or fail */+  CURLUSESSL_ALL,     /* SSL for all communication or fail */+  CURLUSESSL_LAST     /* not an option, never use */+} curl_usessl;++/* Definition of bits for the CURLOPT_SSL_OPTIONS argument: */++/* - ALLOW_BEAST tells libcurl to allow the BEAST SSL vulnerability in the+   name of improving interoperability with older servers. Some SSL libraries+   have introduced work-arounds for this flaw but those work-arounds sometimes+   make the SSL communication fail. To regain functionality with those broken+   servers, a user can this way allow the vulnerability back. */+#define CURLSSLOPT_ALLOW_BEAST (1<<0)++#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all+                          the obsolete stuff removed! */++/* Backwards compatibility with older names */+/* These are scheduled to disappear by 2009 */++#define CURLFTPSSL_NONE CURLUSESSL_NONE+#define CURLFTPSSL_TRY CURLUSESSL_TRY+#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL+#define CURLFTPSSL_ALL CURLUSESSL_ALL+#define CURLFTPSSL_LAST CURLUSESSL_LAST+#define curl_ftpssl curl_usessl+#endif /*!CURL_NO_OLDIES*/++/* parameter for the CURLOPT_FTP_SSL_CCC option */+typedef enum {+  CURLFTPSSL_CCC_NONE,    /* do not send CCC */+  CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */+  CURLFTPSSL_CCC_ACTIVE,  /* Initiate the shutdown */+  CURLFTPSSL_CCC_LAST     /* not an option, never use */+} curl_ftpccc;++/* parameter for the CURLOPT_FTPSSLAUTH option */+typedef enum {+  CURLFTPAUTH_DEFAULT, /* let libcurl decide */+  CURLFTPAUTH_SSL,     /* use "AUTH SSL" */+  CURLFTPAUTH_TLS,     /* use "AUTH TLS" */+  CURLFTPAUTH_LAST /* not an option, never use */+} curl_ftpauth;++/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */+typedef enum {+  CURLFTP_CREATE_DIR_NONE,  /* do NOT create missing dirs! */+  CURLFTP_CREATE_DIR,       /* (FTP/SFTP) if CWD fails, try MKD and then CWD+                               again if MKD succeeded, for SFTP this does+                               similar magic */+  CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD+                               again even if MKD failed! */+  CURLFTP_CREATE_DIR_LAST   /* not an option, never use */+} curl_ftpcreatedir;++/* parameter for the CURLOPT_FTP_FILEMETHOD option */+typedef enum {+  CURLFTPMETHOD_DEFAULT,   /* let libcurl pick */+  CURLFTPMETHOD_MULTICWD,  /* single CWD operation for each path part */+  CURLFTPMETHOD_NOCWD,     /* no CWD at all */+  CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */+  CURLFTPMETHOD_LAST       /* not an option, never use */+} curl_ftpmethod;++/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */+#define CURLPROTO_HTTP   (1<<0)+#define CURLPROTO_HTTPS  (1<<1)+#define CURLPROTO_FTP    (1<<2)+#define CURLPROTO_FTPS   (1<<3)+#define CURLPROTO_SCP    (1<<4)+#define CURLPROTO_SFTP   (1<<5)+#define CURLPROTO_TELNET (1<<6)+#define CURLPROTO_LDAP   (1<<7)+#define CURLPROTO_LDAPS  (1<<8)+#define CURLPROTO_DICT   (1<<9)+#define CURLPROTO_FILE   (1<<10)+#define CURLPROTO_TFTP   (1<<11)+#define CURLPROTO_IMAP   (1<<12)+#define CURLPROTO_IMAPS  (1<<13)+#define CURLPROTO_POP3   (1<<14)+#define CURLPROTO_POP3S  (1<<15)+#define CURLPROTO_SMTP   (1<<16)+#define CURLPROTO_SMTPS  (1<<17)+#define CURLPROTO_RTSP   (1<<18)+#define CURLPROTO_RTMP   (1<<19)+#define CURLPROTO_RTMPT  (1<<20)+#define CURLPROTO_RTMPE  (1<<21)+#define CURLPROTO_RTMPTE (1<<22)+#define CURLPROTO_RTMPS  (1<<23)+#define CURLPROTO_RTMPTS (1<<24)+#define CURLPROTO_GOPHER (1<<25)+#define CURLPROTO_ALL    (~0) /* enable everything */++/* long may be 32 or 64 bits, but we should never depend on anything else+   but 32 */+#define CURLOPTTYPE_LONG          0+#define CURLOPTTYPE_OBJECTPOINT   10000+#define CURLOPTTYPE_FUNCTIONPOINT 20000+#define CURLOPTTYPE_OFF_T         30000++/* name is uppercase CURLOPT_<name>,+   type is one of the defined CURLOPTTYPE_<type>+   number is unique identifier */+#ifdef CINIT+#undef CINIT+#endif++#ifdef CURL_ISOCPP+#define CINIT(na,t,nu) CURLOPT_ ## na = CURLOPTTYPE_ ## t + nu+#else+/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */+#define LONG          CURLOPTTYPE_LONG+#define OBJECTPOINT   CURLOPTTYPE_OBJECTPOINT+#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT+#define OFF_T         CURLOPTTYPE_OFF_T+#define CINIT(name,type,number) CURLOPT_/**/name = type + number+#endif++/*+ * This macro-mania below setups the CURLOPT_[what] enum, to be used with+ * curl_easy_setopt(). The first argument in the CINIT() macro is the [what]+ * word.+ */++typedef enum {+  /* This is the FILE * or void * the regular output should be written to. */+  CINIT(FILE, OBJECTPOINT, 1),++  /* The full URL to get/put */+  CINIT(URL,  OBJECTPOINT, 2),++  /* Port number to connect to, if other than default. */+  CINIT(PORT, LONG, 3),++  /* Name of proxy to use. */+  CINIT(PROXY, OBJECTPOINT, 4),++  /* "name:password" to use when fetching. */+  CINIT(USERPWD, OBJECTPOINT, 5),++  /* "name:password" to use with proxy. */+  CINIT(PROXYUSERPWD, OBJECTPOINT, 6),++  /* Range to get, specified as an ASCII string. */+  CINIT(RANGE, OBJECTPOINT, 7),++  /* not used */++  /* Specified file stream to upload from (use as input): */+  CINIT(INFILE, OBJECTPOINT, 9),++  /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE+   * bytes big. If this is not used, error messages go to stderr instead: */+  CINIT(ERRORBUFFER, OBJECTPOINT, 10),++  /* Function that will be called to store the output (instead of fwrite). The+   * parameters will use fwrite() syntax, make sure to follow them. */+  CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11),++  /* Function that will be called to read the input (instead of fread). The+   * parameters will use fread() syntax, make sure to follow them. */+  CINIT(READFUNCTION, FUNCTIONPOINT, 12),++  /* Time-out the read operation after this amount of seconds */+  CINIT(TIMEOUT, LONG, 13),++  /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about+   * how large the file being sent really is. That allows better error+   * checking and better verifies that the upload was successful. -1 means+   * unknown size.+   *+   * For large file support, there is also a _LARGE version of the key+   * which takes an off_t type, allowing platforms with larger off_t+   * sizes to handle larger files.  See below for INFILESIZE_LARGE.+   */+  CINIT(INFILESIZE, LONG, 14),++  /* POST static input fields. */+  CINIT(POSTFIELDS, OBJECTPOINT, 15),++  /* Set the referrer page (needed by some CGIs) */+  CINIT(REFERER, OBJECTPOINT, 16),++  /* Set the FTP PORT string (interface name, named or numerical IP address)+     Use i.e '-' to use default address. */+  CINIT(FTPPORT, OBJECTPOINT, 17),++  /* Set the User-Agent string (examined by some CGIs) */+  CINIT(USERAGENT, OBJECTPOINT, 18),++  /* If the download receives less than "low speed limit" bytes/second+   * during "low speed time" seconds, the operations is aborted.+   * You could i.e if you have a pretty high speed connection, abort if+   * it is less than 2000 bytes/sec during 20 seconds.+   */++  /* Set the "low speed limit" */+  CINIT(LOW_SPEED_LIMIT, LONG, 19),++  /* Set the "low speed time" */+  CINIT(LOW_SPEED_TIME, LONG, 20),++  /* Set the continuation offset.+   *+   * Note there is also a _LARGE version of this key which uses+   * off_t types, allowing for large file offsets on platforms which+   * use larger-than-32-bit off_t's.  Look below for RESUME_FROM_LARGE.+   */+  CINIT(RESUME_FROM, LONG, 21),++  /* Set cookie in request: */+  CINIT(COOKIE, OBJECTPOINT, 22),++  /* This points to a linked list of headers, struct curl_slist kind */+  CINIT(HTTPHEADER, OBJECTPOINT, 23),++  /* This points to a linked list of post entries, struct curl_httppost */+  CINIT(HTTPPOST, OBJECTPOINT, 24),++  /* name of the file keeping your private SSL-certificate */+  CINIT(SSLCERT, OBJECTPOINT, 25),++  /* password for the SSL or SSH private key */+  CINIT(KEYPASSWD, OBJECTPOINT, 26),++  /* send TYPE parameter? */+  CINIT(CRLF, LONG, 27),++  /* send linked-list of QUOTE commands */+  CINIT(QUOTE, OBJECTPOINT, 28),++  /* send FILE * or void * to store headers to, if you use a callback it+     is simply passed to the callback unmodified */+  CINIT(WRITEHEADER, OBJECTPOINT, 29),++  /* point to a file to read the initial cookies from, also enables+     "cookie awareness" */+  CINIT(COOKIEFILE, OBJECTPOINT, 31),++  /* What version to specifically try to use.+     See CURL_SSLVERSION defines below. */+  CINIT(SSLVERSION, LONG, 32),++  /* What kind of HTTP time condition to use, see defines */+  CINIT(TIMECONDITION, LONG, 33),++  /* Time to use with the above condition. Specified in number of seconds+     since 1 Jan 1970 */+  CINIT(TIMEVALUE, LONG, 34),++  /* 35 = OBSOLETE */++  /* Custom request, for customizing the get command like+     HTTP: DELETE, TRACE and others+     FTP: to use a different list command+     */+  CINIT(CUSTOMREQUEST, OBJECTPOINT, 36),++  /* HTTP request, for odd commands like DELETE, TRACE and others */+  CINIT(STDERR, OBJECTPOINT, 37),++  /* 38 is not used */++  /* send linked-list of post-transfer QUOTE commands */+  CINIT(POSTQUOTE, OBJECTPOINT, 39),++  CINIT(WRITEINFO, OBJECTPOINT, 40), /* DEPRECATED, do not use! */++  CINIT(VERBOSE, LONG, 41),      /* talk a lot */+  CINIT(HEADER, LONG, 42),       /* throw the header out too */+  CINIT(NOPROGRESS, LONG, 43),   /* shut off the progress meter */+  CINIT(NOBODY, LONG, 44),       /* use HEAD to get http document */+  CINIT(FAILONERROR, LONG, 45),  /* no output on http error codes >= 300 */+  CINIT(UPLOAD, LONG, 46),       /* this is an upload */+  CINIT(POST, LONG, 47),         /* HTTP POST method */+  CINIT(DIRLISTONLY, LONG, 48),  /* bare names when listing directories */++  CINIT(APPEND, LONG, 50),       /* Append instead of overwrite on upload! */++  /* Specify whether to read the user+password from the .netrc or the URL.+   * This must be one of the CURL_NETRC_* enums below. */+  CINIT(NETRC, LONG, 51),++  CINIT(FOLLOWLOCATION, LONG, 52),  /* use Location: Luke! */++  CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */+  CINIT(PUT, LONG, 54),          /* HTTP PUT */++  /* 55 = OBSOLETE */++  /* Function that will be called instead of the internal progress display+   * function. This function should be defined as the curl_progress_callback+   * prototype defines. */+  CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56),++  /* Data passed to the progress callback */+  CINIT(PROGRESSDATA, OBJECTPOINT, 57),++  /* We want the referrer field set automatically when following locations */+  CINIT(AUTOREFERER, LONG, 58),++  /* Port of the proxy, can be set in the proxy string as well with:+     "[host]:[port]" */+  CINIT(PROXYPORT, LONG, 59),++  /* size of the POST input data, if strlen() is not good to use */+  CINIT(POSTFIELDSIZE, LONG, 60),++  /* tunnel non-http operations through a HTTP proxy */+  CINIT(HTTPPROXYTUNNEL, LONG, 61),++  /* Set the interface string to use as outgoing network interface */+  CINIT(INTERFACE, OBJECTPOINT, 62),++  /* Set the krb4/5 security level, this also enables krb4/5 awareness.  This+   * is a string, 'clear', 'safe', 'confidential' or 'private'.  If the string+   * is set but doesn't match one of these, 'private' will be used.  */+  CINIT(KRBLEVEL, OBJECTPOINT, 63),++  /* Set if we should verify the peer in ssl handshake, set 1 to verify. */+  CINIT(SSL_VERIFYPEER, LONG, 64),++  /* The CApath or CAfile used to validate the peer certificate+     this option is used only if SSL_VERIFYPEER is true */+  CINIT(CAINFO, OBJECTPOINT, 65),++  /* 66 = OBSOLETE */+  /* 67 = OBSOLETE */++  /* Maximum number of http redirects to follow */+  CINIT(MAXREDIRS, LONG, 68),++  /* Pass a long set to 1 to get the date of the requested document (if+     possible)! Pass a zero to shut it off. */+  CINIT(FILETIME, LONG, 69),++  /* This points to a linked list of telnet options */+  CINIT(TELNETOPTIONS, OBJECTPOINT, 70),++  /* Max amount of cached alive connections */+  CINIT(MAXCONNECTS, LONG, 71),++  CINIT(CLOSEPOLICY, LONG, 72), /* DEPRECATED, do not use! */++  /* 73 = OBSOLETE */++  /* Set to explicitly use a new connection for the upcoming transfer.+     Do not use this unless you're absolutely sure of this, as it makes the+     operation slower and is less friendly for the network. */+  CINIT(FRESH_CONNECT, LONG, 74),++  /* Set to explicitly forbid the upcoming transfer's connection to be re-used+     when done. Do not use this unless you're absolutely sure of this, as it+     makes the operation slower and is less friendly for the network. */+  CINIT(FORBID_REUSE, LONG, 75),++  /* Set to a file name that contains random data for libcurl to use to+     seed the random engine when doing SSL connects. */+  CINIT(RANDOM_FILE, OBJECTPOINT, 76),++  /* Set to the Entropy Gathering Daemon socket pathname */+  CINIT(EGDSOCKET, OBJECTPOINT, 77),++  /* Time-out connect operations after this amount of seconds, if connects are+     OK within this time, then fine... This only aborts the connect phase. */+  CINIT(CONNECTTIMEOUT, LONG, 78),++  /* Function that will be called to store headers (instead of fwrite). The+   * parameters will use fwrite() syntax, make sure to follow them. */+  CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),++  /* Set this to force the HTTP request to get back to GET. Only really usable+     if POST, PUT or a custom request have been used first.+   */+  CINIT(HTTPGET, LONG, 80),++  /* Set if we should verify the Common name from the peer certificate in ssl+   * handshake, set 1 to check existence, 2 to ensure that it matches the+   * provided hostname. */+  CINIT(SSL_VERIFYHOST, LONG, 81),++  /* Specify which file name to write all known cookies in after completed+     operation. Set file name to "-" (dash) to make it go to stdout. */+  CINIT(COOKIEJAR, OBJECTPOINT, 82),++  /* Specify which SSL ciphers to use */+  CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83),++  /* Specify which HTTP version to use! This must be set to one of the+     CURL_HTTP_VERSION* enums set below. */+  CINIT(HTTP_VERSION, LONG, 84),++  /* Specifically switch on or off the FTP engine's use of the EPSV command. By+     default, that one will always be attempted before the more traditional+     PASV command. */+  CINIT(FTP_USE_EPSV, LONG, 85),++  /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */+  CINIT(SSLCERTTYPE, OBJECTPOINT, 86),++  /* name of the file keeping your private SSL-key */+  CINIT(SSLKEY, OBJECTPOINT, 87),++  /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */+  CINIT(SSLKEYTYPE, OBJECTPOINT, 88),++  /* crypto engine for the SSL-sub system */+  CINIT(SSLENGINE, OBJECTPOINT, 89),++  /* set the crypto engine for the SSL-sub system as default+     the param has no meaning...+   */+  CINIT(SSLENGINE_DEFAULT, LONG, 90),++  /* Non-zero value means to use the global dns cache */+  CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* DEPRECATED, do not use! */++  /* DNS cache timeout */+  CINIT(DNS_CACHE_TIMEOUT, LONG, 92),++  /* send linked-list of pre-transfer QUOTE commands */+  CINIT(PREQUOTE, OBJECTPOINT, 93),++  /* set the debug function */+  CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94),++  /* set the data for the debug function */+  CINIT(DEBUGDATA, OBJECTPOINT, 95),++  /* mark this as start of a cookie session */+  CINIT(COOKIESESSION, LONG, 96),++  /* The CApath directory used to validate the peer certificate+     this option is used only if SSL_VERIFYPEER is true */+  CINIT(CAPATH, OBJECTPOINT, 97),++  /* Instruct libcurl to use a smaller receive buffer */+  CINIT(BUFFERSIZE, LONG, 98),++  /* Instruct libcurl to not use any signal/alarm handlers, even when using+     timeouts. This option is useful for multi-threaded applications.+     See libcurl-the-guide for more background information. */+  CINIT(NOSIGNAL, LONG, 99),++  /* Provide a CURLShare for mutexing non-ts data */+  CINIT(SHARE, OBJECTPOINT, 100),++  /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default),+     CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */+  CINIT(PROXYTYPE, LONG, 101),++  /* Set the Accept-Encoding string. Use this to tell a server you would like+     the response to be compressed. Before 7.21.6, this was known as+     CURLOPT_ENCODING */+  CINIT(ACCEPT_ENCODING, OBJECTPOINT, 102),++  /* Set pointer to private data */+  CINIT(PRIVATE, OBJECTPOINT, 103),++  /* Set aliases for HTTP 200 in the HTTP Response header */+  CINIT(HTTP200ALIASES, OBJECTPOINT, 104),++  /* Continue to send authentication (user+password) when following locations,+     even when hostname changed. This can potentially send off the name+     and password to whatever host the server decides. */+  CINIT(UNRESTRICTED_AUTH, LONG, 105),++  /* Specifically switch on or off the FTP engine's use of the EPRT command (+     it also disables the LPRT attempt). By default, those ones will always be+     attempted before the good old traditional PORT command. */+  CINIT(FTP_USE_EPRT, LONG, 106),++  /* Set this to a bitmask value to enable the particular authentications+     methods you like. Use this in combination with CURLOPT_USERPWD.+     Note that setting multiple bits may cause extra network round-trips. */+  CINIT(HTTPAUTH, LONG, 107),++  /* Set the ssl context callback function, currently only for OpenSSL ssl_ctx+     in second argument. The function must be matching the+     curl_ssl_ctx_callback proto. */+  CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108),++  /* Set the userdata for the ssl context callback function's third+     argument */+  CINIT(SSL_CTX_DATA, OBJECTPOINT, 109),++  /* FTP Option that causes missing dirs to be created on the remote server.+     In 7.19.4 we introduced the convenience enums for this option using the+     CURLFTP_CREATE_DIR prefix.+  */+  CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110),++  /* Set this to a bitmask value to enable the particular authentications+     methods you like. Use this in combination with CURLOPT_PROXYUSERPWD.+     Note that setting multiple bits may cause extra network round-trips. */+  CINIT(PROXYAUTH, LONG, 111),++  /* FTP option that changes the timeout, in seconds, associated with+     getting a response.  This is different from transfer timeout time and+     essentially places a demand on the FTP server to acknowledge commands+     in a timely manner. */+  CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112),+#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT++  /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to+     tell libcurl to resolve names to those IP versions only. This only has+     affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */+  CINIT(IPRESOLVE, LONG, 113),++  /* Set this option to limit the size of a file that will be downloaded from+     an HTTP or FTP server.++     Note there is also _LARGE version which adds large file support for+     platforms which have larger off_t sizes.  See MAXFILESIZE_LARGE below. */+  CINIT(MAXFILESIZE, LONG, 114),++  /* See the comment for INFILESIZE above, but in short, specifies+   * the size of the file being uploaded.  -1 means unknown.+   */+  CINIT(INFILESIZE_LARGE, OFF_T, 115),++  /* Sets the continuation offset.  There is also a LONG version of this;+   * look above for RESUME_FROM.+   */+  CINIT(RESUME_FROM_LARGE, OFF_T, 116),++  /* Sets the maximum size of data that will be downloaded from+   * an HTTP or FTP server.  See MAXFILESIZE above for the LONG version.+   */+  CINIT(MAXFILESIZE_LARGE, OFF_T, 117),++  /* Set this option to the file name of your .netrc file you want libcurl+     to parse (using the CURLOPT_NETRC option). If not set, libcurl will do+     a poor attempt to find the user's home directory and check for a .netrc+     file in there. */+  CINIT(NETRC_FILE, OBJECTPOINT, 118),++  /* Enable SSL/TLS for FTP, pick one of:+     CURLUSESSL_TRY     - try using SSL, proceed anyway otherwise+     CURLUSESSL_CONTROL - SSL for the control connection or fail+     CURLUSESSL_ALL     - SSL for all communication or fail+  */+  CINIT(USE_SSL, LONG, 119),++  /* The _LARGE version of the standard POSTFIELDSIZE option */+  CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120),++  /* Enable/disable the TCP Nagle algorithm */+  CINIT(TCP_NODELAY, LONG, 121),++  /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */+  /* 123 OBSOLETE. Gone in 7.16.0 */+  /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */+  /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */+  /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */+  /* 127 OBSOLETE. Gone in 7.16.0 */+  /* 128 OBSOLETE. Gone in 7.16.0 */++  /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option+     can be used to change libcurl's default action which is to first try+     "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK+     response has been received.++     Available parameters are:+     CURLFTPAUTH_DEFAULT - let libcurl decide+     CURLFTPAUTH_SSL     - try "AUTH SSL" first, then TLS+     CURLFTPAUTH_TLS     - try "AUTH TLS" first, then SSL+  */+  CINIT(FTPSSLAUTH, LONG, 129),++  CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130),+  CINIT(IOCTLDATA, OBJECTPOINT, 131),++  /* 132 OBSOLETE. Gone in 7.16.0 */+  /* 133 OBSOLETE. Gone in 7.16.0 */++  /* zero terminated string for pass on to the FTP server when asked for+     "account" info */+  CINIT(FTP_ACCOUNT, OBJECTPOINT, 134),++  /* feed cookies into cookie engine */+  CINIT(COOKIELIST, OBJECTPOINT, 135),++  /* ignore Content-Length */+  CINIT(IGNORE_CONTENT_LENGTH, LONG, 136),++  /* Set to non-zero to skip the IP address received in a 227 PASV FTP server+     response. Typically used for FTP-SSL purposes but is not restricted to+     that. libcurl will then instead use the same IP address it used for the+     control connection. */+  CINIT(FTP_SKIP_PASV_IP, LONG, 137),++  /* Select "file method" to use when doing FTP, see the curl_ftpmethod+     above. */+  CINIT(FTP_FILEMETHOD, LONG, 138),++  /* Local port number to bind the socket to */+  CINIT(LOCALPORT, LONG, 139),++  /* Number of ports to try, including the first one set with LOCALPORT.+     Thus, setting it to 1 will make no additional attempts but the first.+  */+  CINIT(LOCALPORTRANGE, LONG, 140),++  /* no transfer, set up connection and let application use the socket by+     extracting it with CURLINFO_LASTSOCKET */+  CINIT(CONNECT_ONLY, LONG, 141),++  /* Function that will be called to convert from the+     network encoding (instead of using the iconv calls in libcurl) */+  CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142),++  /* Function that will be called to convert to the+     network encoding (instead of using the iconv calls in libcurl) */+  CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143),++  /* Function that will be called to convert from UTF8+     (instead of using the iconv calls in libcurl)+     Note that this is used only for SSL certificate processing */+  CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144),++  /* if the connection proceeds too quickly then need to slow it down */+  /* limit-rate: maximum number of bytes per second to send or receive */+  CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145),+  CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146),++  /* Pointer to command string to send if USER/PASS fails. */+  CINIT(FTP_ALTERNATIVE_TO_USER, OBJECTPOINT, 147),++  /* callback function for setting socket options */+  CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148),+  CINIT(SOCKOPTDATA, OBJECTPOINT, 149),++  /* set to 0 to disable session ID re-use for this transfer, default is+     enabled (== 1) */+  CINIT(SSL_SESSIONID_CACHE, LONG, 150),++  /* allowed SSH authentication methods */+  CINIT(SSH_AUTH_TYPES, LONG, 151),++  /* Used by scp/sftp to do public/private key authentication */+  CINIT(SSH_PUBLIC_KEYFILE, OBJECTPOINT, 152),+  CINIT(SSH_PRIVATE_KEYFILE, OBJECTPOINT, 153),++  /* Send CCC (Clear Command Channel) after authentication */+  CINIT(FTP_SSL_CCC, LONG, 154),++  /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */+  CINIT(TIMEOUT_MS, LONG, 155),+  CINIT(CONNECTTIMEOUT_MS, LONG, 156),++  /* set to zero to disable the libcurl's decoding and thus pass the raw body+     data to the application even when it is encoded/compressed */+  CINIT(HTTP_TRANSFER_DECODING, LONG, 157),+  CINIT(HTTP_CONTENT_DECODING, LONG, 158),++  /* Permission used when creating new files and directories on the remote+     server for protocols that support it, SFTP/SCP/FILE */+  CINIT(NEW_FILE_PERMS, LONG, 159),+  CINIT(NEW_DIRECTORY_PERMS, LONG, 160),++  /* Set the behaviour of POST when redirecting. Values must be set to one+     of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */+  CINIT(POSTREDIR, LONG, 161),++  /* used by scp/sftp to verify the host's public key */+  CINIT(SSH_HOST_PUBLIC_KEY_MD5, OBJECTPOINT, 162),++  /* Callback function for opening socket (instead of socket(2)). Optionally,+     callback is able change the address or refuse to connect returning+     CURL_SOCKET_BAD.  The callback should have type+     curl_opensocket_callback */+  CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163),+  CINIT(OPENSOCKETDATA, OBJECTPOINT, 164),++  /* POST volatile input fields. */+  CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165),++  /* set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy */+  CINIT(PROXY_TRANSFER_MODE, LONG, 166),++  /* Callback function for seeking in the input stream */+  CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167),+  CINIT(SEEKDATA, OBJECTPOINT, 168),++  /* CRL file */+  CINIT(CRLFILE, OBJECTPOINT, 169),++  /* Issuer certificate */+  CINIT(ISSUERCERT, OBJECTPOINT, 170),++  /* (IPv6) Address scope */+  CINIT(ADDRESS_SCOPE, LONG, 171),++  /* Collect certificate chain info and allow it to get retrievable with+     CURLINFO_CERTINFO after the transfer is complete. (Unfortunately) only+     working with OpenSSL-powered builds. */+  CINIT(CERTINFO, LONG, 172),++  /* "name" and "pwd" to use when fetching. */+  CINIT(USERNAME, OBJECTPOINT, 173),+  CINIT(PASSWORD, OBJECTPOINT, 174),++    /* "name" and "pwd" to use with Proxy when fetching. */+  CINIT(PROXYUSERNAME, OBJECTPOINT, 175),+  CINIT(PROXYPASSWORD, OBJECTPOINT, 176),++  /* Comma separated list of hostnames defining no-proxy zones. These should+     match both hostnames directly, and hostnames within a domain. For+     example, local.com will match local.com and www.local.com, but NOT+     notlocal.com or www.notlocal.com. For compatibility with other+     implementations of this, .local.com will be considered to be the same as+     local.com. A single * is the only valid wildcard, and effectively+     disables the use of proxy. */+  CINIT(NOPROXY, OBJECTPOINT, 177),++  /* block size for TFTP transfers */+  CINIT(TFTP_BLKSIZE, LONG, 178),++  /* Socks Service */+  CINIT(SOCKS5_GSSAPI_SERVICE, OBJECTPOINT, 179),++  /* Socks Service */+  CINIT(SOCKS5_GSSAPI_NEC, LONG, 180),++  /* set the bitmask for the protocols that are allowed to be used for the+     transfer, which thus helps the app which takes URLs from users or other+     external inputs and want to restrict what protocol(s) to deal+     with. Defaults to CURLPROTO_ALL. */+  CINIT(PROTOCOLS, LONG, 181),++  /* set the bitmask for the protocols that libcurl is allowed to follow to,+     as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs+     to be set in both bitmasks to be allowed to get redirected to. Defaults+     to all protocols except FILE and SCP. */+  CINIT(REDIR_PROTOCOLS, LONG, 182),++  /* set the SSH knownhost file name to use */+  CINIT(SSH_KNOWNHOSTS, OBJECTPOINT, 183),++  /* set the SSH host key callback, must point to a curl_sshkeycallback+     function */+  CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184),++  /* set the SSH host key callback custom pointer */+  CINIT(SSH_KEYDATA, OBJECTPOINT, 185),++  /* set the SMTP mail originator */+  CINIT(MAIL_FROM, OBJECTPOINT, 186),++  /* set the SMTP mail receiver(s) */+  CINIT(MAIL_RCPT, OBJECTPOINT, 187),++  /* FTP: send PRET before PASV */+  CINIT(FTP_USE_PRET, LONG, 188),++  /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */+  CINIT(RTSP_REQUEST, LONG, 189),++  /* The RTSP session identifier */+  CINIT(RTSP_SESSION_ID, OBJECTPOINT, 190),++  /* The RTSP stream URI */+  CINIT(RTSP_STREAM_URI, OBJECTPOINT, 191),++  /* The Transport: header to use in RTSP requests */+  CINIT(RTSP_TRANSPORT, OBJECTPOINT, 192),++  /* Manually initialize the client RTSP CSeq for this handle */+  CINIT(RTSP_CLIENT_CSEQ, LONG, 193),++  /* Manually initialize the server RTSP CSeq for this handle */+  CINIT(RTSP_SERVER_CSEQ, LONG, 194),++  /* The stream to pass to INTERLEAVEFUNCTION. */+  CINIT(INTERLEAVEDATA, OBJECTPOINT, 195),++  /* Let the application define a custom write method for RTP data */+  CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196),++  /* Turn on wildcard matching */+  CINIT(WILDCARDMATCH, LONG, 197),++  /* Directory matching callback called before downloading of an+     individual file (chunk) started */+  CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198),++  /* Directory matching callback called after the file (chunk)+     was downloaded, or skipped */+  CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199),++  /* Change match (fnmatch-like) callback for wildcard matching */+  CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200),++  /* Let the application define custom chunk data pointer */+  CINIT(CHUNK_DATA, OBJECTPOINT, 201),++  /* FNMATCH_FUNCTION user pointer */+  CINIT(FNMATCH_DATA, OBJECTPOINT, 202),++  /* send linked-list of name:port:address sets */+  CINIT(RESOLVE, OBJECTPOINT, 203),++  /* Set a username for authenticated TLS */+  CINIT(TLSAUTH_USERNAME, OBJECTPOINT, 204),++  /* Set a password for authenticated TLS */+  CINIT(TLSAUTH_PASSWORD, OBJECTPOINT, 205),++  /* Set authentication type for authenticated TLS */+  CINIT(TLSAUTH_TYPE, OBJECTPOINT, 206),++  /* Set to 1 to enable the "TE:" header in HTTP requests to ask for+     compressed transfer-encoded responses. Set to 0 to disable the use of TE:+     in outgoing requests. The current default is 0, but it might change in a+     future libcurl release.++     libcurl will ask for the compressed methods it knows of, and if that+     isn't any, it will not ask for transfer-encoding at all even if this+     option is set to 1.++  */+  CINIT(TRANSFER_ENCODING, LONG, 207),++  /* Callback function for closing socket (instead of close(2)). The callback+     should have type curl_closesocket_callback */+  CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208),+  CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209),++  /* allow GSSAPI credential delegation */+  CINIT(GSSAPI_DELEGATION, LONG, 210),++  /* Set the name servers to use for DNS resolution */+  CINIT(DNS_SERVERS, OBJECTPOINT, 211),++  /* Time-out accept operations (currently for FTP only) after this amount+     of miliseconds. */+  CINIT(ACCEPTTIMEOUT_MS, LONG, 212),++  /* Set TCP keepalive */+  CINIT(TCP_KEEPALIVE, LONG, 213),++  /* non-universal keepalive knobs (Linux, AIX, HP-UX, more) */+  CINIT(TCP_KEEPIDLE, LONG, 214),+  CINIT(TCP_KEEPINTVL, LONG, 215),++  /* Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* */+  CINIT(SSL_OPTIONS, LONG, 216),++  /* set the SMTP auth originator */+  CINIT(MAIL_AUTH, OBJECTPOINT, 217),++  CURLOPT_LASTENTRY /* the last unused */+} CURLoption;++#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all+                          the obsolete stuff removed! */++/* Backwards compatibility with older names */+/* These are scheduled to disappear by 2011 */++/* This was added in version 7.19.1 */+#define CURLOPT_POST301 CURLOPT_POSTREDIR++/* These are scheduled to disappear by 2009 */++/* The following were added in 7.17.0 */+#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD+#define CURLOPT_FTPAPPEND CURLOPT_APPEND+#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY+#define CURLOPT_FTP_SSL CURLOPT_USE_SSL++/* The following were added earlier */++#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD+#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL++#else+/* This is set if CURL_NO_OLDIES is defined at compile-time */+#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */+#endif+++  /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host+     name resolves addresses using more than one IP protocol version, this+     option might be handy to force libcurl to use a specific IP version. */+#define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP+                                     versions that your system allows */+#define CURL_IPRESOLVE_V4       1 /* resolve to ipv4 addresses */+#define CURL_IPRESOLVE_V6       2 /* resolve to ipv6 addresses */++  /* three convenient "aliases" that follow the name scheme better */+#define CURLOPT_WRITEDATA CURLOPT_FILE+#define CURLOPT_READDATA  CURLOPT_INFILE+#define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER+#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER++  /* These enums are for use with the CURLOPT_HTTP_VERSION option. */+enum {+  CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd+                             like the library to choose the best possible+                             for us! */+  CURL_HTTP_VERSION_1_0,  /* please use HTTP 1.0 in the request */+  CURL_HTTP_VERSION_1_1,  /* please use HTTP 1.1 in the request */++  CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */+};++/*+ * Public API enums for RTSP requests+ */+enum {+    CURL_RTSPREQ_NONE, /* first in list */+    CURL_RTSPREQ_OPTIONS,+    CURL_RTSPREQ_DESCRIBE,+    CURL_RTSPREQ_ANNOUNCE,+    CURL_RTSPREQ_SETUP,+    CURL_RTSPREQ_PLAY,+    CURL_RTSPREQ_PAUSE,+    CURL_RTSPREQ_TEARDOWN,+    CURL_RTSPREQ_GET_PARAMETER,+    CURL_RTSPREQ_SET_PARAMETER,+    CURL_RTSPREQ_RECORD,+    CURL_RTSPREQ_RECEIVE,+    CURL_RTSPREQ_LAST /* last in list */+};++  /* These enums are for use with the CURLOPT_NETRC option. */+enum CURL_NETRC_OPTION {+  CURL_NETRC_IGNORED,     /* The .netrc will never be read.+                           * This is the default. */+  CURL_NETRC_OPTIONAL,    /* A user:password in the URL will be preferred+                           * to one in the .netrc. */+  CURL_NETRC_REQUIRED,    /* A user:password in the URL will be ignored.+                           * Unless one is set programmatically, the .netrc+                           * will be queried. */+  CURL_NETRC_LAST+};++enum {+  CURL_SSLVERSION_DEFAULT,+  CURL_SSLVERSION_TLSv1,+  CURL_SSLVERSION_SSLv2,+  CURL_SSLVERSION_SSLv3,++  CURL_SSLVERSION_LAST /* never use, keep last */+};++enum CURL_TLSAUTH {+  CURL_TLSAUTH_NONE,+  CURL_TLSAUTH_SRP,+  CURL_TLSAUTH_LAST /* never use, keep last */+};++/* symbols to use with CURLOPT_POSTREDIR.+   CURL_REDIR_POST_301, CURL_REDIR_POST_302 and CURL_REDIR_POST_303+   can be bitwise ORed so that CURL_REDIR_POST_301 | CURL_REDIR_POST_302+   | CURL_REDIR_POST_303 == CURL_REDIR_POST_ALL */++#define CURL_REDIR_GET_ALL  0+#define CURL_REDIR_POST_301 1+#define CURL_REDIR_POST_302 2+#define CURL_REDIR_POST_303 4+#define CURL_REDIR_POST_ALL \+    (CURL_REDIR_POST_301|CURL_REDIR_POST_302|CURL_REDIR_POST_303)++typedef enum {+  CURL_TIMECOND_NONE,++  CURL_TIMECOND_IFMODSINCE,+  CURL_TIMECOND_IFUNMODSINCE,+  CURL_TIMECOND_LASTMOD,++  CURL_TIMECOND_LAST+} curl_TimeCond;+++/* curl_strequal() and curl_strnequal() are subject for removal in a future+   libcurl, see lib/README.curlx for details */+CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2);+CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n);++/* name is uppercase CURLFORM_<name> */+#ifdef CFINIT+#undef CFINIT+#endif++#ifdef CURL_ISOCPP+#define CFINIT(name) CURLFORM_ ## name+#else+/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */+#define CFINIT(name) CURLFORM_/**/name+#endif++typedef enum {+  CFINIT(NOTHING),        /********* the first one is unused ************/++  /*  */+  CFINIT(COPYNAME),+  CFINIT(PTRNAME),+  CFINIT(NAMELENGTH),+  CFINIT(COPYCONTENTS),+  CFINIT(PTRCONTENTS),+  CFINIT(CONTENTSLENGTH),+  CFINIT(FILECONTENT),+  CFINIT(ARRAY),+  CFINIT(OBSOLETE),+  CFINIT(FILE),++  CFINIT(BUFFER),+  CFINIT(BUFFERPTR),+  CFINIT(BUFFERLENGTH),++  CFINIT(CONTENTTYPE),+  CFINIT(CONTENTHEADER),+  CFINIT(FILENAME),+  CFINIT(END),+  CFINIT(OBSOLETE2),++  CFINIT(STREAM),++  CURLFORM_LASTENTRY /* the last unused */+} CURLformoption;++#undef CFINIT /* done */++/* structure to be used as parameter for CURLFORM_ARRAY */+struct curl_forms {+  CURLformoption option;+  const char     *value;+};++/* use this for multipart formpost building */+/* Returns code for curl_formadd()+ *+ * Returns:+ * CURL_FORMADD_OK             on success+ * CURL_FORMADD_MEMORY         if the FormInfo allocation fails+ * CURL_FORMADD_OPTION_TWICE   if one option is given twice for one Form+ * CURL_FORMADD_NULL           if a null pointer was given for a char+ * CURL_FORMADD_MEMORY         if the allocation of a FormInfo struct failed+ * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used+ * CURL_FORMADD_INCOMPLETE     if the some FormInfo is not complete (or error)+ * CURL_FORMADD_MEMORY         if a curl_httppost struct cannot be allocated+ * CURL_FORMADD_MEMORY         if some allocation for string copying failed.+ * CURL_FORMADD_ILLEGAL_ARRAY  if an illegal option is used in an array+ *+ ***************************************************************************/+typedef enum {+  CURL_FORMADD_OK, /* first, no error */++  CURL_FORMADD_MEMORY,+  CURL_FORMADD_OPTION_TWICE,+  CURL_FORMADD_NULL,+  CURL_FORMADD_UNKNOWN_OPTION,+  CURL_FORMADD_INCOMPLETE,+  CURL_FORMADD_ILLEGAL_ARRAY,+  CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */++  CURL_FORMADD_LAST /* last */+} CURLFORMcode;++/*+ * NAME curl_formadd()+ *+ * DESCRIPTION+ *+ * Pretty advanced function for building multi-part formposts. Each invoke+ * adds one part that together construct a full post. Then use+ * CURLOPT_HTTPPOST to send it off to libcurl.+ */+CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost,+                                      struct curl_httppost **last_post,+                                      ...);++/*+ * callback function for curl_formget()+ * The void *arg pointer will be the one passed as second argument to+ *   curl_formget().+ * The character buffer passed to it must not be freed.+ * Should return the buffer length passed to it as the argument "len" on+ *   success.+ */+typedef size_t (*curl_formget_callback)(void *arg, const char *buf,+                                        size_t len);++/*+ * NAME curl_formget()+ *+ * DESCRIPTION+ *+ * Serialize a curl_httppost struct built with curl_formadd().+ * Accepts a void pointer as second argument which will be passed to+ * the curl_formget_callback function.+ * Returns 0 on success.+ */+CURL_EXTERN int curl_formget(struct curl_httppost *form, void *arg,+                             curl_formget_callback append);+/*+ * NAME curl_formfree()+ *+ * DESCRIPTION+ *+ * Free a multipart formpost previously built with curl_formadd().+ */+CURL_EXTERN void curl_formfree(struct curl_httppost *form);++/*+ * NAME curl_getenv()+ *+ * DESCRIPTION+ *+ * Returns a malloc()'ed string that MUST be curl_free()ed after usage is+ * complete. DEPRECATED - see lib/README.curlx+ */+CURL_EXTERN char *curl_getenv(const char *variable);++/*+ * NAME curl_version()+ *+ * DESCRIPTION+ *+ * Returns a static ascii string of the libcurl version.+ */+CURL_EXTERN char *curl_version(void);++/*+ * NAME curl_easy_escape()+ *+ * DESCRIPTION+ *+ * Escapes URL strings (converts all letters consider illegal in URLs to their+ * %XX versions). This function returns a new allocated string or NULL if an+ * error occurred.+ */+CURL_EXTERN char *curl_easy_escape(CURL *handle,+                                   const char *string,+                                   int length);++/* the previous version: */+CURL_EXTERN char *curl_escape(const char *string,+                              int length);+++/*+ * NAME curl_easy_unescape()+ *+ * DESCRIPTION+ *+ * Unescapes URL encoding in strings (converts all %XX codes to their 8bit+ * versions). This function returns a new allocated string or NULL if an error+ * occurred.+ * Conversion Note: On non-ASCII platforms the ASCII %XX codes are+ * converted into the host encoding.+ */+CURL_EXTERN char *curl_easy_unescape(CURL *handle,+                                     const char *string,+                                     int length,+                                     int *outlength);++/* the previous version */+CURL_EXTERN char *curl_unescape(const char *string,+                                int length);++/*+ * NAME curl_free()+ *+ * DESCRIPTION+ *+ * Provided for de-allocation in the same translation unit that did the+ * allocation. Added in libcurl 7.10+ */+CURL_EXTERN void curl_free(void *p);++/*+ * NAME curl_global_init()+ *+ * DESCRIPTION+ *+ * curl_global_init() should be invoked exactly once for each application that+ * uses libcurl and before any call of other libcurl functions.+ *+ * This function is not thread-safe!+ */+CURL_EXTERN CURLcode curl_global_init(long flags);++/*+ * NAME curl_global_init_mem()+ *+ * DESCRIPTION+ *+ * curl_global_init() or curl_global_init_mem() should be invoked exactly once+ * for each application that uses libcurl.  This function can be used to+ * initialize libcurl and set user defined memory management callback+ * functions.  Users can implement memory management routines to check for+ * memory leaks, check for mis-use of the curl library etc.  User registered+ * callback routines with be invoked by this library instead of the system+ * memory management routines like malloc, free etc.+ */+CURL_EXTERN CURLcode curl_global_init_mem(long flags,+                                          curl_malloc_callback m,+                                          curl_free_callback f,+                                          curl_realloc_callback r,+                                          curl_strdup_callback s,+                                          curl_calloc_callback c);++/*+ * NAME curl_global_cleanup()+ *+ * DESCRIPTION+ *+ * curl_global_cleanup() should be invoked exactly once for each application+ * that uses libcurl+ */+CURL_EXTERN void curl_global_cleanup(void);++/* linked-list structure for the CURLOPT_QUOTE option (and other) */+struct curl_slist {+  char *data;+  struct curl_slist *next;+};++/*+ * NAME curl_slist_append()+ *+ * DESCRIPTION+ *+ * Appends a string to a linked list. If no list exists, it will be created+ * first. Returns the new list, after appending.+ */+CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *,+                                                 const char *);++/*+ * NAME curl_slist_free_all()+ *+ * DESCRIPTION+ *+ * free a previously built curl_slist.+ */+CURL_EXTERN void curl_slist_free_all(struct curl_slist *);++/*+ * NAME curl_getdate()+ *+ * DESCRIPTION+ *+ * Returns the time, in seconds since 1 Jan 1970 of the time string given in+ * the first argument. The time argument in the second parameter is unused+ * and should be set to NULL.+ */+CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused);++/* info about the certificate chain, only for OpenSSL builds. Asked+   for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */+struct curl_certinfo {+  int num_of_certs;             /* number of certificates with information */+  struct curl_slist **certinfo; /* for each index in this array, there's a+                                   linked list with textual information in the+                                   format "name: value" */+};++#define CURLINFO_STRING   0x100000+#define CURLINFO_LONG     0x200000+#define CURLINFO_DOUBLE   0x300000+#define CURLINFO_SLIST    0x400000+#define CURLINFO_MASK     0x0fffff+#define CURLINFO_TYPEMASK 0xf00000++typedef enum {+  CURLINFO_NONE, /* first, never use this */+  CURLINFO_EFFECTIVE_URL    = CURLINFO_STRING + 1,+  CURLINFO_RESPONSE_CODE    = CURLINFO_LONG   + 2,+  CURLINFO_TOTAL_TIME       = CURLINFO_DOUBLE + 3,+  CURLINFO_NAMELOOKUP_TIME  = CURLINFO_DOUBLE + 4,+  CURLINFO_CONNECT_TIME     = CURLINFO_DOUBLE + 5,+  CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,+  CURLINFO_SIZE_UPLOAD      = CURLINFO_DOUBLE + 7,+  CURLINFO_SIZE_DOWNLOAD    = CURLINFO_DOUBLE + 8,+  CURLINFO_SPEED_DOWNLOAD   = CURLINFO_DOUBLE + 9,+  CURLINFO_SPEED_UPLOAD     = CURLINFO_DOUBLE + 10,+  CURLINFO_HEADER_SIZE      = CURLINFO_LONG   + 11,+  CURLINFO_REQUEST_SIZE     = CURLINFO_LONG   + 12,+  CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG   + 13,+  CURLINFO_FILETIME         = CURLINFO_LONG   + 14,+  CURLINFO_CONTENT_LENGTH_DOWNLOAD   = CURLINFO_DOUBLE + 15,+  CURLINFO_CONTENT_LENGTH_UPLOAD     = CURLINFO_DOUBLE + 16,+  CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,+  CURLINFO_CONTENT_TYPE     = CURLINFO_STRING + 18,+  CURLINFO_REDIRECT_TIME    = CURLINFO_DOUBLE + 19,+  CURLINFO_REDIRECT_COUNT   = CURLINFO_LONG   + 20,+  CURLINFO_PRIVATE          = CURLINFO_STRING + 21,+  CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG   + 22,+  CURLINFO_HTTPAUTH_AVAIL   = CURLINFO_LONG   + 23,+  CURLINFO_PROXYAUTH_AVAIL  = CURLINFO_LONG   + 24,+  CURLINFO_OS_ERRNO         = CURLINFO_LONG   + 25,+  CURLINFO_NUM_CONNECTS     = CURLINFO_LONG   + 26,+  CURLINFO_SSL_ENGINES      = CURLINFO_SLIST  + 27,+  CURLINFO_COOKIELIST       = CURLINFO_SLIST  + 28,+  CURLINFO_LASTSOCKET       = CURLINFO_LONG   + 29,+  CURLINFO_FTP_ENTRY_PATH   = CURLINFO_STRING + 30,+  CURLINFO_REDIRECT_URL     = CURLINFO_STRING + 31,+  CURLINFO_PRIMARY_IP       = CURLINFO_STRING + 32,+  CURLINFO_APPCONNECT_TIME  = CURLINFO_DOUBLE + 33,+  CURLINFO_CERTINFO         = CURLINFO_SLIST  + 34,+  CURLINFO_CONDITION_UNMET  = CURLINFO_LONG   + 35,+  CURLINFO_RTSP_SESSION_ID  = CURLINFO_STRING + 36,+  CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG   + 37,+  CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG   + 38,+  CURLINFO_RTSP_CSEQ_RECV   = CURLINFO_LONG   + 39,+  CURLINFO_PRIMARY_PORT     = CURLINFO_LONG   + 40,+  CURLINFO_LOCAL_IP         = CURLINFO_STRING + 41,+  CURLINFO_LOCAL_PORT       = CURLINFO_LONG   + 42,+  /* Fill in new entries below here! */++  CURLINFO_LASTONE          = 42+} CURLINFO;++/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as+   CURLINFO_HTTP_CODE */+#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE++typedef enum {+  CURLCLOSEPOLICY_NONE, /* first, never use this */++  CURLCLOSEPOLICY_OLDEST,+  CURLCLOSEPOLICY_LEAST_RECENTLY_USED,+  CURLCLOSEPOLICY_LEAST_TRAFFIC,+  CURLCLOSEPOLICY_SLOWEST,+  CURLCLOSEPOLICY_CALLBACK,++  CURLCLOSEPOLICY_LAST /* last, never use this */+} curl_closepolicy;++#define CURL_GLOBAL_SSL (1<<0)+#define CURL_GLOBAL_WIN32 (1<<1)+#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32)+#define CURL_GLOBAL_NOTHING 0+#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL+#define CURL_GLOBAL_ACK_EINTR (1<<2)+++/*****************************************************************************+ * Setup defines, protos etc for the sharing stuff.+ */++/* Different data locks for a single share */+typedef enum {+  CURL_LOCK_DATA_NONE = 0,+  /*  CURL_LOCK_DATA_SHARE is used internally to say that+   *  the locking is just made to change the internal state of the share+   *  itself.+   */+  CURL_LOCK_DATA_SHARE,+  CURL_LOCK_DATA_COOKIE,+  CURL_LOCK_DATA_DNS,+  CURL_LOCK_DATA_SSL_SESSION,+  CURL_LOCK_DATA_CONNECT,+  CURL_LOCK_DATA_LAST+} curl_lock_data;++/* Different lock access types */+typedef enum {+  CURL_LOCK_ACCESS_NONE = 0,   /* unspecified action */+  CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */+  CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */+  CURL_LOCK_ACCESS_LAST        /* never use */+} curl_lock_access;++typedef void (*curl_lock_function)(CURL *handle,+                                   curl_lock_data data,+                                   curl_lock_access locktype,+                                   void *userptr);+typedef void (*curl_unlock_function)(CURL *handle,+                                     curl_lock_data data,+                                     void *userptr);++typedef void CURLSH;++typedef enum {+  CURLSHE_OK,  /* all is fine */+  CURLSHE_BAD_OPTION, /* 1 */+  CURLSHE_IN_USE,     /* 2 */+  CURLSHE_INVALID,    /* 3 */+  CURLSHE_NOMEM,      /* 4 out of memory */+  CURLSHE_NOT_BUILT_IN, /* 5 feature not present in lib */+  CURLSHE_LAST        /* never use */+} CURLSHcode;++typedef enum {+  CURLSHOPT_NONE,  /* don't use */+  CURLSHOPT_SHARE,   /* specify a data type to share */+  CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */+  CURLSHOPT_LOCKFUNC,   /* pass in a 'curl_lock_function' pointer */+  CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */+  CURLSHOPT_USERDATA,   /* pass in a user data pointer used in the lock/unlock+                           callback functions */+  CURLSHOPT_LAST  /* never use */+} CURLSHoption;++CURL_EXTERN CURLSH *curl_share_init(void);+CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...);+CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *);++/****************************************************************************+ * Structures for querying information about the curl library at runtime.+ */++typedef enum {+  CURLVERSION_FIRST,+  CURLVERSION_SECOND,+  CURLVERSION_THIRD,+  CURLVERSION_FOURTH,+  CURLVERSION_LAST /* never actually use this */+} CURLversion;++/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by+   basically all programs ever that want to get version information. It is+   meant to be a built-in version number for what kind of struct the caller+   expects. If the struct ever changes, we redefine the NOW to another enum+   from above. */+#define CURLVERSION_NOW CURLVERSION_FOURTH++typedef struct {+  CURLversion age;          /* age of the returned struct */+  const char *version;      /* LIBCURL_VERSION */+  unsigned int version_num; /* LIBCURL_VERSION_NUM */+  const char *host;         /* OS/host/cpu/machine when configured */+  int features;             /* bitmask, see defines below */+  const char *ssl_version;  /* human readable string */+  long ssl_version_num;     /* not used anymore, always 0 */+  const char *libz_version; /* human readable string */+  /* protocols is terminated by an entry with a NULL protoname */+  const char * const *protocols;++  /* The fields below this were added in CURLVERSION_SECOND */+  const char *ares;+  int ares_num;++  /* This field was added in CURLVERSION_THIRD */+  const char *libidn;++  /* These field were added in CURLVERSION_FOURTH */++  /* Same as '_libiconv_version' if built with HAVE_ICONV */+  int iconv_ver_num;++  const char *libssh_version; /* human readable string */++} curl_version_info_data;++#define CURL_VERSION_IPV6      (1<<0)  /* IPv6-enabled */+#define CURL_VERSION_KERBEROS4 (1<<1)  /* kerberos auth is supported */+#define CURL_VERSION_SSL       (1<<2)  /* SSL options are present */+#define CURL_VERSION_LIBZ      (1<<3)  /* libz features are present */+#define CURL_VERSION_NTLM      (1<<4)  /* NTLM auth is supported */+#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth support */+#define CURL_VERSION_DEBUG     (1<<6)  /* built with debug capabilities */+#define CURL_VERSION_ASYNCHDNS (1<<7)  /* asynchronous dns resolves */+#define CURL_VERSION_SPNEGO    (1<<8)  /* SPNEGO auth */+#define CURL_VERSION_LARGEFILE (1<<9)  /* supports files bigger than 2GB */+#define CURL_VERSION_IDN       (1<<10) /* International Domain Names support */+#define CURL_VERSION_SSPI      (1<<11) /* SSPI is supported */+#define CURL_VERSION_CONV      (1<<12) /* character conversions supported */+#define CURL_VERSION_CURLDEBUG (1<<13) /* debug memory tracking supported */+#define CURL_VERSION_TLSAUTH_SRP (1<<14) /* TLS-SRP auth is supported */+#define CURL_VERSION_NTLM_WB   (1<<15) /* NTLM delegating to winbind helper */++ /*+ * NAME curl_version_info()+ *+ * DESCRIPTION+ *+ * This function returns a pointer to a static copy of the version info+ * struct. See above.+ */+CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion);++/*+ * NAME curl_easy_strerror()+ *+ * DESCRIPTION+ *+ * The curl_easy_strerror function may be used to turn a CURLcode value+ * into the equivalent human readable error string.  This is useful+ * for printing meaningful error messages.+ */+CURL_EXTERN const char *curl_easy_strerror(CURLcode);++/*+ * NAME curl_share_strerror()+ *+ * DESCRIPTION+ *+ * The curl_share_strerror function may be used to turn a CURLSHcode value+ * into the equivalent human readable error string.  This is useful+ * for printing meaningful error messages.+ */+CURL_EXTERN const char *curl_share_strerror(CURLSHcode);++/*+ * NAME curl_easy_pause()+ *+ * DESCRIPTION+ *+ * The curl_easy_pause function pauses or unpauses transfers. Select the new+ * state by setting the bitmask, use the convenience defines below.+ *+ */+CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask);++#define CURLPAUSE_RECV      (1<<0)+#define CURLPAUSE_RECV_CONT (0)++#define CURLPAUSE_SEND      (1<<2)+#define CURLPAUSE_SEND_CONT (0)++#define CURLPAUSE_ALL       (CURLPAUSE_RECV|CURLPAUSE_SEND)+#define CURLPAUSE_CONT      (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT)++#ifdef  __cplusplus+}+#endif++/* unfortunately, the easy.h and multi.h include files need options and info+  stuff before they can be included! */+#include "easy.h" /* nothing in curl is fun without the easy stuff */+#include "multi.h"++/* the typechecker doesn't work in C++ (yet) */+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \+    ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \+    !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK)+#include "typecheck-gcc.h"+#else+#if defined(__STDC__) && (__STDC__ >= 1)+/* This preprocessor magic that replaces a call with the exact same call is+   only done to make sure application authors pass exactly three arguments+   to these functions. */+#define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param)+#define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg)+#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)+#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)+#endif /* __STDC__ >= 1 */+#endif /* gcc >= 4.3 && !__cplusplus */++#endif /* __CURL_CURL_H */

@@ -0,0 +1,585 @@+#ifndef __CURL_CURLBUILD_H+#define __CURL_CURLBUILD_H+/***************************************************************************+ *                                  _   _ ____  _+ *  Project                     ___| | | |  _ \| |+ *                             / __| | | | |_) | |+ *                            | (__| |_| |  _ <| |___+ *                             \___|\___/|_| \_\_____|+ *+ * Copyright (C) 1998 - 2013, Daniel Stenberg, <daniel@haxx.se>, et al.+ *+ * This software is licensed as described in the file COPYING, which+ * you should have received as part of this distribution. The terms+ * are also available at http://curl.haxx.se/docs/copyright.html.+ *+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell+ * copies of the Software, and permit persons to whom the Software is+ * furnished to do so, under the terms of the COPYING file.+ *+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY+ * KIND, either express or implied.+ *+ ***************************************************************************/++/* ================================================================ */+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */+/* ================================================================ */++/*+ * NOTE 1:+ * -------+ *+ * See file include/curl/curlbuild.h.in, run configure, and forget+ * that this file exists it is only used for non-configure systems.+ * But you can keep reading if you want ;-)+ *+ */++/* ================================================================ */+/*                 NOTES FOR NON-CONFIGURE SYSTEMS                  */+/* ================================================================ */++/*+ * NOTE 1:+ * -------+ *+ * Nothing in this file is intended to be modified or adjusted by the+ * curl library user nor by the curl library builder.+ *+ * If you think that something actually needs to be changed, adjusted+ * or fixed in this file, then, report it on the libcurl development+ * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/+ *+ * Try to keep one section per platform, compiler and architecture,+ * otherwise, if an existing section is reused for a different one and+ * later on the original is adjusted, probably the piggybacking one can+ * be adversely changed.+ *+ * In order to differentiate between platforms/compilers/architectures+ * use only compiler built in predefined preprocessor symbols.+ *+ * This header file shall only export symbols which are 'curl' or 'CURL'+ * prefixed, otherwise public name space would be polluted.+ *+ * NOTE 2:+ * -------+ *+ * For any given platform/compiler curl_off_t must be typedef'ed to a+ * 64-bit wide signed integral data type. The width of this data type+ * must remain constant and independent of any possible large file+ * support settings.+ *+ * As an exception to the above, curl_off_t shall be typedef'ed to a+ * 32-bit wide signed integral data type if there is no 64-bit type.+ *+ * As a general rule, curl_off_t shall not be mapped to off_t. This+ * rule shall only be violated if off_t is the only 64-bit data type+ * available and the size of off_t is independent of large file support+ * settings. Keep your build on the safe side avoiding an off_t gating.+ * If you have a 64-bit off_t then take for sure that another 64-bit+ * data type exists, dig deeper and you will find it.+ *+ * NOTE 3:+ * -------+ *+ * Right now you might be staring at file include/curl/curlbuild.h.dist or+ * at file include/curl/curlbuild.h, this is due to the following reason:+ * file include/curl/curlbuild.h.dist is renamed to include/curl/curlbuild.h+ * when the libcurl source code distribution archive file is created.+ *+ * File include/curl/curlbuild.h.dist is not included in the distribution+ * archive. File include/curl/curlbuild.h is not present in the git tree.+ *+ * The distributed include/curl/curlbuild.h file is only intended to be used+ * on systems which can not run the also distributed configure script.+ *+ * On systems capable of running the configure script, the configure process+ * will overwrite the distributed include/curl/curlbuild.h file with one that+ * is suitable and specific to the library being configured and built, which+ * is generated from the include/curl/curlbuild.h.in template file.+ *+ * If you check out from git on a non-configure platform, you must run the+ * appropriate buildconf* script to set up curlbuild.h and other local files.+ *+ */++/* ================================================================ */+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */+/* ================================================================ */++#ifdef CURL_SIZEOF_LONG+#  error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"+   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined+#endif++#ifdef CURL_TYPEOF_CURL_SOCKLEN_T+#  error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined+#endif++#ifdef CURL_SIZEOF_CURL_SOCKLEN_T+#  error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined+#endif++#ifdef CURL_TYPEOF_CURL_OFF_T+#  error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined+#endif++#ifdef CURL_FORMAT_CURL_OFF_T+#  error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined+#endif++#ifdef CURL_FORMAT_CURL_OFF_TU+#  error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined+#endif++#ifdef CURL_FORMAT_OFF_T+#  error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"+   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined+#endif++#ifdef CURL_SIZEOF_CURL_OFF_T+#  error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined+#endif++#ifdef CURL_SUFFIX_CURL_OFF_T+#  error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined+#endif++#ifdef CURL_SUFFIX_CURL_OFF_TU+#  error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined+#endif++/* ================================================================ */+/*    EXTERNAL INTERFACE SETTINGS FOR NON-CONFIGURE SYSTEMS ONLY    */+/* ================================================================ */++#if defined(__DJGPP__) || defined(__GO32__)+#  if defined(__DJGPP__) && (__DJGPP__ > 1)+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long long+#    define CURL_FORMAT_CURL_OFF_T     "lld"+#    define CURL_FORMAT_CURL_OFF_TU    "llu"+#    define CURL_FORMAT_OFF_T          "%lld"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     LL+#    define CURL_SUFFIX_CURL_OFF_TU    ULL+#  else+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long+#    define CURL_FORMAT_CURL_OFF_T     "ld"+#    define CURL_FORMAT_CURL_OFF_TU    "lu"+#    define CURL_FORMAT_OFF_T          "%ld"+#    define CURL_SIZEOF_CURL_OFF_T     4+#    define CURL_SUFFIX_CURL_OFF_T     L+#    define CURL_SUFFIX_CURL_OFF_TU    UL+#  endif+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__SALFORDC__)+#  define CURL_SIZEOF_LONG           4+#  define CURL_TYPEOF_CURL_OFF_T     long+#  define CURL_FORMAT_CURL_OFF_T     "ld"+#  define CURL_FORMAT_CURL_OFF_TU    "lu"+#  define CURL_FORMAT_OFF_T          "%ld"+#  define CURL_SIZEOF_CURL_OFF_T     4+#  define CURL_SUFFIX_CURL_OFF_T     L+#  define CURL_SUFFIX_CURL_OFF_TU    UL+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__BORLANDC__)+#  if (__BORLANDC__ < 0x520)+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long+#    define CURL_FORMAT_CURL_OFF_T     "ld"+#    define CURL_FORMAT_CURL_OFF_TU    "lu"+#    define CURL_FORMAT_OFF_T          "%ld"+#    define CURL_SIZEOF_CURL_OFF_T     4+#    define CURL_SUFFIX_CURL_OFF_T     L+#    define CURL_SUFFIX_CURL_OFF_TU    UL+#  else+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     __int64+#    define CURL_FORMAT_CURL_OFF_T     "I64d"+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"+#    define CURL_FORMAT_OFF_T          "%I64d"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     i64+#    define CURL_SUFFIX_CURL_OFF_TU    ui64+#  endif+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__TURBOC__)+#  define CURL_SIZEOF_LONG           4+#  define CURL_TYPEOF_CURL_OFF_T     long+#  define CURL_FORMAT_CURL_OFF_T     "ld"+#  define CURL_FORMAT_CURL_OFF_TU    "lu"+#  define CURL_FORMAT_OFF_T          "%ld"+#  define CURL_SIZEOF_CURL_OFF_T     4+#  define CURL_SUFFIX_CURL_OFF_T     L+#  define CURL_SUFFIX_CURL_OFF_TU    UL+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__WATCOMC__)+#  if defined(__386__)+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     __int64+#    define CURL_FORMAT_CURL_OFF_T     "I64d"+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"+#    define CURL_FORMAT_OFF_T          "%I64d"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     i64+#    define CURL_SUFFIX_CURL_OFF_TU    ui64+#  else+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long+#    define CURL_FORMAT_CURL_OFF_T     "ld"+#    define CURL_FORMAT_CURL_OFF_TU    "lu"+#    define CURL_FORMAT_OFF_T          "%ld"+#    define CURL_SIZEOF_CURL_OFF_T     4+#    define CURL_SUFFIX_CURL_OFF_T     L+#    define CURL_SUFFIX_CURL_OFF_TU    UL+#  endif+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__POCC__)+#  if (__POCC__ < 280)+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long+#    define CURL_FORMAT_CURL_OFF_T     "ld"+#    define CURL_FORMAT_CURL_OFF_TU    "lu"+#    define CURL_FORMAT_OFF_T          "%ld"+#    define CURL_SIZEOF_CURL_OFF_T     4+#    define CURL_SUFFIX_CURL_OFF_T     L+#    define CURL_SUFFIX_CURL_OFF_TU    UL+#  elif defined(_MSC_VER)+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     __int64+#    define CURL_FORMAT_CURL_OFF_T     "I64d"+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"+#    define CURL_FORMAT_OFF_T          "%I64d"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     i64+#    define CURL_SUFFIX_CURL_OFF_TU    ui64+#  else+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long long+#    define CURL_FORMAT_CURL_OFF_T     "lld"+#    define CURL_FORMAT_CURL_OFF_TU    "llu"+#    define CURL_FORMAT_OFF_T          "%lld"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     LL+#    define CURL_SUFFIX_CURL_OFF_TU    ULL+#  endif+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__LCC__)+#  define CURL_SIZEOF_LONG           4+#  define CURL_TYPEOF_CURL_OFF_T     long+#  define CURL_FORMAT_CURL_OFF_T     "ld"+#  define CURL_FORMAT_CURL_OFF_TU    "lu"+#  define CURL_FORMAT_OFF_T          "%ld"+#  define CURL_SIZEOF_CURL_OFF_T     4+#  define CURL_SUFFIX_CURL_OFF_T     L+#  define CURL_SUFFIX_CURL_OFF_TU    UL+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__SYMBIAN32__)+#  if defined(__EABI__)  /* Treat all ARM compilers equally */+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long long+#    define CURL_FORMAT_CURL_OFF_T     "lld"+#    define CURL_FORMAT_CURL_OFF_TU    "llu"+#    define CURL_FORMAT_OFF_T          "%lld"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     LL+#    define CURL_SUFFIX_CURL_OFF_TU    ULL+#  elif defined(__CW32__)+#    pragma longlong on+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long long+#    define CURL_FORMAT_CURL_OFF_T     "lld"+#    define CURL_FORMAT_CURL_OFF_TU    "llu"+#    define CURL_FORMAT_OFF_T          "%lld"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     LL+#    define CURL_SUFFIX_CURL_OFF_TU    ULL+#  elif defined(__VC32__)+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     __int64+#    define CURL_FORMAT_CURL_OFF_T     "lld"+#    define CURL_FORMAT_CURL_OFF_TU    "llu"+#    define CURL_FORMAT_OFF_T          "%lld"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     LL+#    define CURL_SUFFIX_CURL_OFF_TU    ULL+#  endif+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__MWERKS__)+#  define CURL_SIZEOF_LONG           4+#  define CURL_TYPEOF_CURL_OFF_T     long long+#  define CURL_FORMAT_CURL_OFF_T     "lld"+#  define CURL_FORMAT_CURL_OFF_TU    "llu"+#  define CURL_FORMAT_OFF_T          "%lld"+#  define CURL_SIZEOF_CURL_OFF_T     8+#  define CURL_SUFFIX_CURL_OFF_T     LL+#  define CURL_SUFFIX_CURL_OFF_TU    ULL+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(_WIN32_WCE)+#  define CURL_SIZEOF_LONG           4+#  define CURL_TYPEOF_CURL_OFF_T     __int64+#  define CURL_FORMAT_CURL_OFF_T     "I64d"+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"+#  define CURL_FORMAT_OFF_T          "%I64d"+#  define CURL_SIZEOF_CURL_OFF_T     8+#  define CURL_SUFFIX_CURL_OFF_T     i64+#  define CURL_SUFFIX_CURL_OFF_TU    ui64+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__MINGW32__)+#  define CURL_SIZEOF_LONG           4+#  define CURL_TYPEOF_CURL_OFF_T     long long+#  define CURL_FORMAT_CURL_OFF_T     "I64d"+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"+#  define CURL_FORMAT_OFF_T          "%I64d"+#  define CURL_SIZEOF_CURL_OFF_T     8+#  define CURL_SUFFIX_CURL_OFF_T     LL+#  define CURL_SUFFIX_CURL_OFF_TU    ULL+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__VMS)+#  if defined(__VAX)+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long+#    define CURL_FORMAT_CURL_OFF_T     "ld"+#    define CURL_FORMAT_CURL_OFF_TU    "lu"+#    define CURL_FORMAT_OFF_T          "%ld"+#    define CURL_SIZEOF_CURL_OFF_T     4+#    define CURL_SUFFIX_CURL_OFF_T     L+#    define CURL_SUFFIX_CURL_OFF_TU    UL+#  else+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long long+#    define CURL_FORMAT_CURL_OFF_T     "lld"+#    define CURL_FORMAT_CURL_OFF_TU    "llu"+#    define CURL_FORMAT_OFF_T          "%lld"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     LL+#    define CURL_SUFFIX_CURL_OFF_TU    ULL+#  endif+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++#elif defined(__OS400__)+#  if defined(__ILEC400__)+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long long+#    define CURL_FORMAT_CURL_OFF_T     "lld"+#    define CURL_FORMAT_CURL_OFF_TU    "llu"+#    define CURL_FORMAT_OFF_T          "%lld"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     LL+#    define CURL_SUFFIX_CURL_OFF_TU    ULL+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4+#    define CURL_PULL_SYS_TYPES_H      1+#    define CURL_PULL_SYS_SOCKET_H     1+#  endif++#elif defined(__MVS__)+#  if defined(__IBMC__) || defined(__IBMCPP__)+#    if defined(_ILP32)+#      define CURL_SIZEOF_LONG           4+#    elif defined(_LP64)+#      define CURL_SIZEOF_LONG           8+#    endif+#    if defined(_LONG_LONG)+#      define CURL_TYPEOF_CURL_OFF_T     long long+#      define CURL_FORMAT_CURL_OFF_T     "lld"+#      define CURL_FORMAT_CURL_OFF_TU    "llu"+#      define CURL_FORMAT_OFF_T          "%lld"+#      define CURL_SIZEOF_CURL_OFF_T     8+#      define CURL_SUFFIX_CURL_OFF_T     LL+#      define CURL_SUFFIX_CURL_OFF_TU    ULL+#    elif defined(_LP64)+#      define CURL_TYPEOF_CURL_OFF_T     long+#      define CURL_FORMAT_CURL_OFF_T     "ld"+#      define CURL_FORMAT_CURL_OFF_TU    "lu"+#      define CURL_FORMAT_OFF_T          "%ld"+#      define CURL_SIZEOF_CURL_OFF_T     8+#      define CURL_SUFFIX_CURL_OFF_T     L+#      define CURL_SUFFIX_CURL_OFF_TU    UL+#    else+#      define CURL_TYPEOF_CURL_OFF_T     long+#      define CURL_FORMAT_CURL_OFF_T     "ld"+#      define CURL_FORMAT_CURL_OFF_TU    "lu"+#      define CURL_FORMAT_OFF_T          "%ld"+#      define CURL_SIZEOF_CURL_OFF_T     4+#      define CURL_SUFFIX_CURL_OFF_T     L+#      define CURL_SUFFIX_CURL_OFF_TU    UL+#    endif+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4+#    define CURL_PULL_SYS_TYPES_H      1+#    define CURL_PULL_SYS_SOCKET_H     1+#  endif++#elif defined(__370__)+#  if defined(__IBMC__) || defined(__IBMCPP__)+#    if defined(_ILP32)+#      define CURL_SIZEOF_LONG           4+#    elif defined(_LP64)+#      define CURL_SIZEOF_LONG           8+#    endif+#    if defined(_LONG_LONG)+#      define CURL_TYPEOF_CURL_OFF_T     long long+#      define CURL_FORMAT_CURL_OFF_T     "lld"+#      define CURL_FORMAT_CURL_OFF_TU    "llu"+#      define CURL_FORMAT_OFF_T          "%lld"+#      define CURL_SIZEOF_CURL_OFF_T     8+#      define CURL_SUFFIX_CURL_OFF_T     LL+#      define CURL_SUFFIX_CURL_OFF_TU    ULL+#    elif defined(_LP64)+#      define CURL_TYPEOF_CURL_OFF_T     long+#      define CURL_FORMAT_CURL_OFF_T     "ld"+#      define CURL_FORMAT_CURL_OFF_TU    "lu"+#      define CURL_FORMAT_OFF_T          "%ld"+#      define CURL_SIZEOF_CURL_OFF_T     8+#      define CURL_SUFFIX_CURL_OFF_T     L+#      define CURL_SUFFIX_CURL_OFF_TU    UL+#    else+#      define CURL_TYPEOF_CURL_OFF_T     long+#      define CURL_FORMAT_CURL_OFF_T     "ld"+#      define CURL_FORMAT_CURL_OFF_TU    "lu"+#      define CURL_FORMAT_OFF_T          "%ld"+#      define CURL_SIZEOF_CURL_OFF_T     4+#      define CURL_SUFFIX_CURL_OFF_T     L+#      define CURL_SUFFIX_CURL_OFF_TU    UL+#    endif+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4+#    define CURL_PULL_SYS_TYPES_H      1+#    define CURL_PULL_SYS_SOCKET_H     1+#  endif++#elif defined(TPF)+#  define CURL_SIZEOF_LONG           8+#  define CURL_TYPEOF_CURL_OFF_T     long+#  define CURL_FORMAT_CURL_OFF_T     "ld"+#  define CURL_FORMAT_CURL_OFF_TU    "lu"+#  define CURL_FORMAT_OFF_T          "%ld"+#  define CURL_SIZEOF_CURL_OFF_T     8+#  define CURL_SUFFIX_CURL_OFF_T     L+#  define CURL_SUFFIX_CURL_OFF_TU    UL+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++/* ===================================== */+/*    KEEP MSVC THE PENULTIMATE ENTRY    */+/* ===================================== */++#elif defined(_MSC_VER)+#  if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     __int64+#    define CURL_FORMAT_CURL_OFF_T     "I64d"+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"+#    define CURL_FORMAT_OFF_T          "%I64d"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     i64+#    define CURL_SUFFIX_CURL_OFF_TU    ui64+#  else+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long+#    define CURL_FORMAT_CURL_OFF_T     "ld"+#    define CURL_FORMAT_CURL_OFF_TU    "lu"+#    define CURL_FORMAT_OFF_T          "%ld"+#    define CURL_SIZEOF_CURL_OFF_T     4+#    define CURL_SUFFIX_CURL_OFF_T     L+#    define CURL_SUFFIX_CURL_OFF_TU    UL+#  endif+#  define CURL_TYPEOF_CURL_SOCKLEN_T int+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4++/* ===================================== */+/*    KEEP GENERIC GCC THE LAST ENTRY    */+/* ===================================== */++#elif defined(__GNUC__)+#  if defined(__ILP32__) || \+      defined(__i386__) || defined(__ppc__) || defined(__arm__)+#    define CURL_SIZEOF_LONG           4+#    define CURL_TYPEOF_CURL_OFF_T     long long+#    define CURL_FORMAT_CURL_OFF_T     "lld"+#    define CURL_FORMAT_CURL_OFF_TU    "llu"+#    define CURL_FORMAT_OFF_T          "%lld"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     LL+#    define CURL_SUFFIX_CURL_OFF_TU    ULL+#  elif defined(__LP64__) || \+        defined(__x86_64__) || defined(__ppc64__)+#    define CURL_SIZEOF_LONG           8+#    define CURL_TYPEOF_CURL_OFF_T     long+#    define CURL_FORMAT_CURL_OFF_T     "ld"+#    define CURL_FORMAT_CURL_OFF_TU    "lu"+#    define CURL_FORMAT_OFF_T          "%ld"+#    define CURL_SIZEOF_CURL_OFF_T     8+#    define CURL_SUFFIX_CURL_OFF_T     L+#    define CURL_SUFFIX_CURL_OFF_TU    UL+#  endif+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4+#  define CURL_PULL_SYS_TYPES_H      1+#  define CURL_PULL_SYS_SOCKET_H     1++#else+#  error "Unknown non-configure build target!"+   Error Compilation_aborted_Unknown_non_configure_build_target+#endif++/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file  */+/* sys/types.h is required here to properly make type definitions below. */+#ifdef CURL_PULL_SYS_TYPES_H+#  include <sys/types.h>+#endif++/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file  */+/* sys/socket.h is required here to properly make type definitions below. */+#ifdef CURL_PULL_SYS_SOCKET_H+#  include <sys/socket.h>+#endif++/* Data type definition of curl_socklen_t. */++#ifdef CURL_TYPEOF_CURL_SOCKLEN_T+  typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;+#endif++/* Data type definition of curl_off_t. */++#ifdef CURL_TYPEOF_CURL_OFF_T+  typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;+#endif++#endif /* __CURL_CURLBUILD_H */

@@ -0,0 +1,262 @@+#ifndef __CURL_CURLRULES_H+#define __CURL_CURLRULES_H+/***************************************************************************+ *                                  _   _ ____  _+ *  Project                     ___| | | |  _ \| |+ *                             / __| | | | |_) | |+ *                            | (__| |_| |  _ <| |___+ *                             \___|\___/|_| \_\_____|+ *+ * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al.+ *+ * This software is licensed as described in the file COPYING, which+ * you should have received as part of this distribution. The terms+ * are also available at http://curl.haxx.se/docs/copyright.html.+ *+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell+ * copies of the Software, and permit persons to whom the Software is+ * furnished to do so, under the terms of the COPYING file.+ *+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY+ * KIND, either express or implied.+ *+ ***************************************************************************/++/* ================================================================ */+/*                    COMPILE TIME SANITY CHECKS                    */+/* ================================================================ */++/*+ * NOTE 1:+ * -------+ *+ * All checks done in this file are intentionally placed in a public+ * header file which is pulled by curl/curl.h when an application is+ * being built using an already built libcurl library. Additionally+ * this file is also included and used when building the library.+ *+ * If compilation fails on this file it is certainly sure that the+ * problem is elsewhere. It could be a problem in the curlbuild.h+ * header file, or simply that you are using different compilation+ * settings than those used to build the library.+ *+ * Nothing in this file is intended to be modified or adjusted by the+ * curl library user nor by the curl library builder.+ *+ * Do not deactivate any check, these are done to make sure that the+ * library is properly built and used.+ *+ * You can find further help on the libcurl development mailing list:+ * http://cool.haxx.se/mailman/listinfo/curl-library/+ *+ * NOTE 2+ * ------+ *+ * Some of the following compile time checks are based on the fact+ * that the dimension of a constant array can not be a negative one.+ * In this way if the compile time verification fails, the compilation+ * will fail issuing an error. The error description wording is compiler+ * dependent but it will be quite similar to one of the following:+ *+ *   "negative subscript or subscript is too large"+ *   "array must have at least one element"+ *   "-1 is an illegal array size"+ *   "size of array is negative"+ *+ * If you are building an application which tries to use an already+ * built libcurl library and you are getting this kind of errors on+ * this file, it is a clear indication that there is a mismatch between+ * how the library was built and how you are trying to use it for your+ * application. Your already compiled or binary library provider is the+ * only one who can give you the details you need to properly use it.+ */++/*+ * Verify that some macros are actually defined.+ */++#ifndef CURL_SIZEOF_LONG+#  error "CURL_SIZEOF_LONG definition is missing!"+   Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing+#endif++#ifndef CURL_TYPEOF_CURL_SOCKLEN_T+#  error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!"+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing+#endif++#ifndef CURL_SIZEOF_CURL_SOCKLEN_T+#  error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!"+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing+#endif++#ifndef CURL_TYPEOF_CURL_OFF_T+#  error "CURL_TYPEOF_CURL_OFF_T definition is missing!"+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing+#endif++#ifndef CURL_FORMAT_CURL_OFF_T+#  error "CURL_FORMAT_CURL_OFF_T definition is missing!"+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_is_missing+#endif++#ifndef CURL_FORMAT_CURL_OFF_TU+#  error "CURL_FORMAT_CURL_OFF_TU definition is missing!"+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_is_missing+#endif++#ifndef CURL_FORMAT_OFF_T+#  error "CURL_FORMAT_OFF_T definition is missing!"+   Error Compilation_aborted_CURL_FORMAT_OFF_T_is_missing+#endif++#ifndef CURL_SIZEOF_CURL_OFF_T+#  error "CURL_SIZEOF_CURL_OFF_T definition is missing!"+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_is_missing+#endif++#ifndef CURL_SUFFIX_CURL_OFF_T+#  error "CURL_SUFFIX_CURL_OFF_T definition is missing!"+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_is_missing+#endif++#ifndef CURL_SUFFIX_CURL_OFF_TU+#  error "CURL_SUFFIX_CURL_OFF_TU definition is missing!"+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_is_missing+#endif++/*+ * Macros private to this header file.+ */++#define CurlchkszEQ(t, s) sizeof(t) == s ? 1 : -1++#define CurlchkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1++/*+ * Verify that the size previously defined and expected for long+ * is the same as the one reported by sizeof() at compile time.+ */++typedef char+  __curl_rule_01__+    [CurlchkszEQ(long, CURL_SIZEOF_LONG)];++/*+ * Verify that the size previously defined and expected for+ * curl_off_t is actually the the same as the one reported+ * by sizeof() at compile time.+ */++typedef char+  __curl_rule_02__+    [CurlchkszEQ(curl_off_t, CURL_SIZEOF_CURL_OFF_T)];++/*+ * Verify at compile time that the size of curl_off_t as reported+ * by sizeof() is greater or equal than the one reported for long+ * for the current compilation.+ */++typedef char+  __curl_rule_03__+    [CurlchkszGE(curl_off_t, long)];++/*+ * Verify that the size previously defined and expected for+ * curl_socklen_t is actually the the same as the one reported+ * by sizeof() at compile time.+ */++typedef char+  __curl_rule_04__+    [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)];++/*+ * Verify at compile time that the size of curl_socklen_t as reported+ * by sizeof() is greater or equal than the one reported for int for+ * the current compilation.+ */++typedef char+  __curl_rule_05__+    [CurlchkszGE(curl_socklen_t, int)];++/* ================================================================ */+/*          EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS           */+/* ================================================================ */++/*+ * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow+ * these to be visible and exported by the external libcurl interface API,+ * while also making them visible to the library internals, simply including+ * curl_setup.h, without actually needing to include curl.h internally.+ * If some day this section would grow big enough, all this should be moved+ * to its own header file.+ */++/*+ * Figure out if we can use the ## preprocessor operator, which is supported+ * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__+ * or  __cplusplus so we need to carefully check for them too.+ */++#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \+  defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \+  defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \+  defined(__ILEC400__)+  /* This compiler is believed to have an ISO compatible preprocessor */+#define CURL_ISOCPP+#else+  /* This compiler is believed NOT to have an ISO compatible preprocessor */+#undef CURL_ISOCPP+#endif++/*+ * Macros for minimum-width signed and unsigned curl_off_t integer constants.+ */++#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551)+#  define __CURL_OFF_T_C_HLPR2(x) x+#  define __CURL_OFF_T_C_HLPR1(x) __CURL_OFF_T_C_HLPR2(x)+#  define CURL_OFF_T_C(Val)  __CURL_OFF_T_C_HLPR1(Val) ## \+                             __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T)+#  define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \+                             __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU)+#else+#  ifdef CURL_ISOCPP+#    define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix+#  else+#    define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix+#  endif+#  define __CURL_OFF_T_C_HLPR1(Val,Suffix) __CURL_OFF_T_C_HLPR2(Val,Suffix)+#  define CURL_OFF_T_C(Val)  __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T)+#  define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU)+#endif++/*+ * Get rid of macros private to this header file.+ */++#undef CurlchkszEQ+#undef CurlchkszGE++/*+ * Get rid of macros not intended to exist beyond this point.+ */++#undef CURL_PULL_WS2TCPIP_H+#undef CURL_PULL_SYS_TYPES_H+#undef CURL_PULL_SYS_SOCKET_H+#undef CURL_PULL_SYS_POLL_H+#undef CURL_PULL_STDINT_H+#undef CURL_PULL_INTTYPES_H++#undef CURL_TYPEOF_CURL_SOCKLEN_T+#undef CURL_TYPEOF_CURL_OFF_T++#ifdef CURL_NO_OLDIES+#undef CURL_FORMAT_OFF_T /* not required since 7.19.0 - obsoleted in 7.20.0 */+#endif++#endif /* __CURL_CURLRULES_H */

@@ -0,0 +1,69 @@+#ifndef __CURL_CURLVER_H+#define __CURL_CURLVER_H+/***************************************************************************+ *                                  _   _ ____  _+ *  Project                     ___| | | |  _ \| |+ *                             / __| | | | |_) | |+ *                            | (__| |_| |  _ <| |___+ *                             \___|\___/|_| \_\_____|+ *+ * Copyright (C) 1998 - 2013, Daniel Stenberg, <daniel@haxx.se>, et al.+ *+ * This software is licensed as described in the file COPYING, which+ * you should have received as part of this distribution. The terms+ * are also available at http://curl.haxx.se/docs/copyright.html.+ *+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell+ * copies of the Software, and permit persons to whom the Software is+ * furnished to do so, under the terms of the COPYING file.+ *+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY+ * KIND, either express or implied.+ *+ ***************************************************************************/++/* This header file contains nothing but libcurl version info, generated by+   a script at release-time. This was made its own header file in 7.11.2 */++/* This is the global package copyright */+#define LIBCURL_COPYRIGHT "1996 - 2013 Daniel Stenberg, <daniel@haxx.se>."++/* This is the version number of the libcurl package from which this header+   file origins: */+#define LIBCURL_VERSION "7.30.0"++/* The numeric version number is also available "in parts" by using these+   defines: */+#define LIBCURL_VERSION_MAJOR 7+#define LIBCURL_VERSION_MINOR 30+#define LIBCURL_VERSION_PATCH 0++/* This is the numeric version of the libcurl version number, meant for easier+   parsing and comparions by programs. The LIBCURL_VERSION_NUM define will+   always follow this syntax:++         0xXXYYZZ++   Where XX, YY and ZZ are the main version, release and patch numbers in+   hexadecimal (using 8 bits each). All three numbers are always represented+   using two digits.  1.2 would appear as "0x010200" while version 9.11.7+   appears as "0x090b07".++   This 6-digit (24 bits) hexadecimal number does not show pre-release number,+   and it is always a greater number in a more recent release. It makes+   comparisons with greater than and less than work.+*/+#define LIBCURL_VERSION_NUM 0x071e00++/*+ * This is the date and time when the full source package was created. The+ * timestamp is not stored in git, as the timestamp is properly set in the+ * tarballs by the maketgz script.+ *+ * The format of the date should follow this template:+ *+ * "Mon Feb 12 11:35:33 UTC 2007"+ */+#define LIBCURL_TIMESTAMP "Fri Apr 12 07:12:20 UTC 2013"++#endif /* __CURL_CURLVER_H */

@@ -0,0 +1,102 @@+#ifndef __CURL_EASY_H+#define __CURL_EASY_H+/***************************************************************************+ *                                  _   _ ____  _+ *  Project                     ___| | | |  _ \| |+ *                             / __| | | | |_) | |+ *                            | (__| |_| |  _ <| |___+ *                             \___|\___/|_| \_\_____|+ *+ * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.+ *+ * This software is licensed as described in the file COPYING, which+ * you should have received as part of this distribution. The terms+ * are also available at http://curl.haxx.se/docs/copyright.html.+ *+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell+ * copies of the Software, and permit persons to whom the Software is+ * furnished to do so, under the terms of the COPYING file.+ *+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY+ * KIND, either express or implied.+ *+ ***************************************************************************/+#ifdef  __cplusplus+extern "C" {+#endif++CURL_EXTERN CURL *curl_easy_init(void);+CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);+CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);+CURL_EXTERN void curl_easy_cleanup(CURL *curl);++/*+ * NAME curl_easy_getinfo()+ *+ * DESCRIPTION+ *+ * Request internal information from the curl session with this function.  The+ * third argument MUST be a pointer to a long, a pointer to a char * or a+ * pointer to a double (as the documentation describes elsewhere).  The data+ * pointed to will be filled in accordingly and can be relied upon only if the+ * function returns CURLE_OK.  This function is intended to get used *AFTER* a+ * performed transfer, all results from this function are undefined until the+ * transfer is completed.+ */+CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);+++/*+ * NAME curl_easy_duphandle()+ *+ * DESCRIPTION+ *+ * Creates a new curl session handle with the same options set for the handle+ * passed in. Duplicating a handle could only be a matter of cloning data and+ * options, internal state info and things like persistent connections cannot+ * be transferred. It is useful in multithreaded applications when you can run+ * curl_easy_duphandle() for each new thread to avoid a series of identical+ * curl_easy_setopt() invokes in every thread.+ */+CURL_EXTERN CURL* curl_easy_duphandle(CURL *curl);++/*+ * NAME curl_easy_reset()+ *+ * DESCRIPTION+ *+ * Re-initializes a CURL handle to the default values. This puts back the+ * handle to the same state as it was in when it was just created.+ *+ * It does keep: live connections, the Session ID cache, the DNS cache and the+ * cookies.+ */+CURL_EXTERN void curl_easy_reset(CURL *curl);++/*+ * NAME curl_easy_recv()+ *+ * DESCRIPTION+ *+ * Receives data from the connected socket. Use after successful+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.+ */+CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,+                                    size_t *n);++/*+ * NAME curl_easy_send()+ *+ * DESCRIPTION+ *+ * Sends data over the connected socket. Use after successful+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.+ */+CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer,+                                    size_t buflen, size_t *n);++#ifdef  __cplusplus+}+#endif++#endif