{-# LINE 1 "Network/CURL000/LibCC.hsc" #-}
-------------------------------------------------------------------------------
{-# LINE 2 "Network/CURL000/LibCC.hsc" #-}
-- |
-- Module      :  Network.CURL000.LibCC
-- Copyright   :  Copyright (c) 2012-2015 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_header_callback, wrapCURL_header_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

import System.IO.Unsafe (unsafePerformIO)
import System.RTLD

import Prelude


{-# LINE 114 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------
foreign import ccall "&curlADRTAB" curlADRTAB :: Ptr (FunPtr ())
foreign import ccall "&curlSYMTAB" curlSYMTAB :: Ptr SYMTABENTRY

curlTABLEN :: Int
curlTABLEN = 59
{-# LINE 122 "Network/CURL000/LibCC.hsc" #-}

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 _    = (16)
{-# LINE 180 "Network/CURL000/LibCC.hsc" #-}
  alignment _ = (8)
{-# LINE 181 "Network/CURL000/LibCC.hsc" #-}
  poke _ _    = undefined
  peek ptr    = CURLslist
    <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
{-# LINE 184 "Network/CURL000/LibCC.hsc" #-}
    <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
{-# LINE 185 "Network/CURL000/LibCC.hsc" #-}


data CURLcerts = CURLcerts CInt (Ptr (Ptr CURLslist))

instance Storable CURLcerts where
  sizeOf _    = (16)
{-# LINE 191 "Network/CURL000/LibCC.hsc" #-}
  alignment _ = (8)
{-# LINE 192 "Network/CURL000/LibCC.hsc" #-}
  poke _ _    = undefined
  peek ptr    = CURLcerts
    <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
{-# LINE 195 "Network/CURL000/LibCC.hsc" #-}
    <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
{-# LINE 196 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------

{-# NOINLINE curl_easy_cleanup #-}
curl_easy_cleanup :: Ptr CURL {- ^ handle -} -> IO ()
curl_easy_cleanup a = peekFP (0) >>= \fp -> curl_easy_cleanupFC fp a

type FTcurl_easy_cleanup = Ptr CURL {- ^ handle -} -> IO ()
foreign import ccall safe "dynamic"
  curl_easy_cleanupFC :: FunPtr FTcurl_easy_cleanup -> FTcurl_easy_cleanup

{-# LINE 202 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_easy_duphandle #-}
curl_easy_duphandle :: Ptr CURL {- ^ handle -} -> IO (Ptr CURL) {- ^ handle -}
curl_easy_duphandle a = peekFP (1) >>= \fp -> curl_easy_duphandleFC fp a

type FTcurl_easy_duphandle = Ptr CURL {- ^ handle -} -> IO (Ptr CURL) {- ^ handle -}
foreign import ccall safe "dynamic"
  curl_easy_duphandleFC :: FunPtr FTcurl_easy_duphandle -> FTcurl_easy_duphandle

{-# LINE 206 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_easy_escape #-}
curl_easy_escape :: Ptr CURL {- ^ handle -} -> Ptr CChar {- ^ const string (url) -} -> CInt {- ^ length -} -> IO (Ptr CChar) {- ^ URL encoded string -}
curl_easy_escape a b c = peekFP (2) >>= \fp -> curl_easy_escapeFC fp a b c

type FTcurl_easy_escape = Ptr CURL {- ^ handle -} -> Ptr CChar {- ^ const string (url) -} -> CInt {- ^ length -} -> IO (Ptr CChar) {- ^ URL encoded string -}
foreign import ccall safe "dynamic"
  curl_easy_escapeFC :: FunPtr FTcurl_easy_escape -> FTcurl_easy_escape

{-# LINE 212 "Network/CURL000/LibCC.hsc" #-}

-- #{SAFECALL curl_easy_getinfo \
-- , Ptr CURL    {- ^ handle -} \
-- , CURLinfo    {- ^ info   -} \
-- , Ptr ()      {- ^ param  -} \
-- , IO CURLcode {- ^ status -} }


{-# NOINLINE curl_easy_init #-}
curl_easy_init :: IO (Ptr CURL) {- ^ handle -}
curl_easy_init  = peekFP (4) >>= \fp -> curl_easy_initFC fp 

type FTcurl_easy_init = IO (Ptr CURL) {- ^ handle -}
foreign import ccall safe "dynamic"
  curl_easy_initFC :: FunPtr FTcurl_easy_init -> FTcurl_easy_init

{-# LINE 221 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_easy_pause #-}
curl_easy_pause :: Ptr CURL {- ^ handle -} -> CInt {- ^ bitmask -} -> IO CURLcode {- ^ status -}
curl_easy_pause a b = peekFP (5) >>= \fp -> curl_easy_pauseFC fp a b

type FTcurl_easy_pause = Ptr CURL {- ^ handle -} -> CInt {- ^ bitmask -} -> IO CURLcode {- ^ status -}
foreign import ccall safe "dynamic"
  curl_easy_pauseFC :: FunPtr FTcurl_easy_pause -> FTcurl_easy_pause

{-# LINE 226 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_easy_perform #-}
curl_easy_perform :: Ptr CURL {- ^ handle -} -> IO CURLcode {- ^ status -}
curl_easy_perform a = peekFP (6) >>= \fp -> curl_easy_performFC fp a

type FTcurl_easy_perform = Ptr CURL {- ^ handle -} -> IO CURLcode {- ^ status -}
foreign import ccall safe "dynamic"
  curl_easy_performFC :: FunPtr FTcurl_easy_perform -> FTcurl_easy_perform

{-# LINE 230 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_easy_recv #-}
curl_easy_recv :: Ptr CURL {- ^ handle -} -> Ptr () {- ^ buffer -} -> CSize {- ^ buflen -} -> Ptr CSize {- ^ n -} -> IO CURLcode {- ^ status -}
curl_easy_recv a b c d = peekFP (7) >>= \fp -> curl_easy_recvFC fp a b c d

type FTcurl_easy_recv = Ptr CURL {- ^ handle -} -> Ptr () {- ^ buffer -} -> CSize {- ^ buflen -} -> Ptr CSize {- ^ n -} -> IO CURLcode {- ^ status -}
foreign import ccall safe "dynamic"
  curl_easy_recvFC :: FunPtr FTcurl_easy_recv -> FTcurl_easy_recv

{-# LINE 237 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_easy_reset #-}
curl_easy_reset :: Ptr CURL {- ^ handle -} -> IO ()
curl_easy_reset a = peekFP (8) >>= \fp -> curl_easy_resetFC fp a

type FTcurl_easy_reset = Ptr CURL {- ^ handle -} -> IO ()
foreign import ccall safe "dynamic"
  curl_easy_resetFC :: FunPtr FTcurl_easy_reset -> FTcurl_easy_reset

{-# LINE 241 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_easy_send #-}
curl_easy_send :: Ptr CURL {- ^ handle -} -> Ptr () {- ^ const buffer -} -> CSize {- ^ buflen -} -> Ptr CSize {- ^ n -} -> IO CURLcode {- ^ status -}
curl_easy_send a b c d = peekFP (9) >>= \fp -> curl_easy_sendFC fp a b c d

type FTcurl_easy_send = Ptr CURL {- ^ handle -} -> Ptr () {- ^ const buffer -} -> CSize {- ^ buflen -} -> Ptr CSize {- ^ n -} -> IO CURLcode {- ^ status -}
foreign import ccall safe "dynamic"
  curl_easy_sendFC :: FunPtr FTcurl_easy_send -> FTcurl_easy_send

{-# LINE 248 "Network/CURL000/LibCC.hsc" #-}

-- #{SAFECALL curl_easy_setopt  \
-- , Ptr CURL    {- ^ handle -} \
-- , CURLoption  {- ^ option -} \
-- , Ptr ()      {- ^ param  -} \
-- , IO CURLcode {- ^ status -} }


{-# NOINLINE curl_easy_strerror #-}
curl_easy_strerror :: CURLcode {- ^ errornum -} -> IO (Ptr CChar) {- ^ const string -}
curl_easy_strerror a = peekFP (11) >>= \fp -> curl_easy_strerrorFC fp a

type FTcurl_easy_strerror = CURLcode {- ^ errornum -} -> IO (Ptr CChar) {- ^ const string -}
foreign import ccall safe "dynamic"
  curl_easy_strerrorFC :: FunPtr FTcurl_easy_strerror -> FTcurl_easy_strerror

{-# LINE 258 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_easy_unescape #-}
curl_easy_unescape :: Ptr CURL {- ^ handle -} -> Ptr CChar {- ^ const string -} -> CInt {- ^ inlength -} -> Ptr CInt {- ^ outlength -} -> IO (Ptr CChar) {- ^ decoded string -}
curl_easy_unescape a b c d = peekFP (12) >>= \fp -> curl_easy_unescapeFC fp a b c d

type FTcurl_easy_unescape = Ptr CURL {- ^ handle -} -> Ptr CChar {- ^ const string -} -> CInt {- ^ inlength -} -> Ptr CInt {- ^ outlength -} -> IO (Ptr CChar) {- ^ decoded string -}
foreign import ccall safe "dynamic"
  curl_easy_unescapeFC :: FunPtr FTcurl_easy_unescape -> FTcurl_easy_unescape

{-# LINE 265 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------

{-# NOINLINE curl_formadd #-}
curl_formadd :: Ptr (Ptr CURLhttppost) {- ^ httppost -} -> Ptr (Ptr CURLhttppost) {- ^ lastpost -} -> CURLformoption {- ^ option -} -> Ptr () {- ^ value -} -> IO CURLformcode {- ^ status -}
curl_formadd a b c d = peekFP (14) >>= \fp -> curl_formaddFC fp a b c d

type FTcurl_formadd = Ptr (Ptr CURLhttppost) {- ^ httppost -} -> Ptr (Ptr CURLhttppost) {- ^ lastpost -} -> CURLformoption {- ^ option -} -> Ptr () {- ^ value -} -> IO CURLformcode {- ^ status -}
foreign import ccall safe "dynamic"
  curl_formaddFC :: FunPtr FTcurl_formadd -> FTcurl_formadd

{-# LINE 274 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_formfree #-}
curl_formfree :: Ptr CURLhttppost {- ^ form -} -> IO ()
curl_formfree a = peekFP (15) >>= \fp -> curl_formfreeFC fp a

type FTcurl_formfree = Ptr CURLhttppost {- ^ form -} -> IO ()
foreign import ccall safe "dynamic"
  curl_formfreeFC :: FunPtr FTcurl_formfree -> FTcurl_formfree

{-# LINE 278 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_formget #-}
curl_formget :: Ptr CURLhttppost {- ^ form -} -> Ptr () {- ^ userp -} -> FunPtr CURL_formget_callback {- ^ append -} -> IO CInt {- ^ status -}
curl_formget a b c = peekFP (16) >>= \fp -> curl_formgetFC fp a b c

type FTcurl_formget = Ptr CURLhttppost {- ^ form -} -> Ptr () {- ^ userp -} -> FunPtr CURL_formget_callback {- ^ append -} -> IO CInt {- ^ status -}
foreign import ccall safe "dynamic"
  curl_formgetFC :: FunPtr FTcurl_formget -> FTcurl_formget

{-# LINE 284 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------

{-# NOINLINE curl_free #-}
curl_free :: Ptr () {- ^ ptr -} -> IO ()
curl_free a = peekFP (17) >>= \fp -> curl_freeFC fp a

type FTcurl_free = Ptr () {- ^ ptr -} -> IO ()
foreign import ccall safe "dynamic"
  curl_freeFC :: FunPtr FTcurl_free -> FTcurl_free

{-# LINE 290 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------

{-# NOINLINE curl_getdate #-}
curl_getdate :: Ptr CChar {- ^ const datestring -} -> Ptr CTime {- ^ const now (unused) -} -> IO CTime {- ^ time -}
curl_getdate a b = peekFP (18) >>= \fp -> curl_getdateFC fp a b

type FTcurl_getdate = Ptr CChar {- ^ const datestring -} -> Ptr CTime {- ^ const now (unused) -} -> IO CTime {- ^ time -}
foreign import ccall safe "dynamic"
  curl_getdateFC :: FunPtr FTcurl_getdate -> FTcurl_getdate

{-# LINE 297 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------

{-# NOINLINE curl_global_cleanup #-}
curl_global_cleanup :: IO ()
curl_global_cleanup  = peekFP (20) >>= \fp -> curl_global_cleanupFC fp 

type FTcurl_global_cleanup = IO ()
foreign import ccall safe "dynamic"
  curl_global_cleanupFC :: FunPtr FTcurl_global_cleanup -> FTcurl_global_cleanup

{-# LINE 302 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_global_init #-}
curl_global_init :: CLong {- ^ flags -} -> IO CURLcode {- ^ status -}
curl_global_init a = peekFP (21) >>= \fp -> curl_global_initFC fp a

type FTcurl_global_init = CLong {- ^ flags -} -> IO CURLcode {- ^ status -}
foreign import ccall safe "dynamic"
  curl_global_initFC :: FunPtr FTcurl_global_init -> FTcurl_global_init

{-# LINE 306 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_global_init_mem #-}
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 -}
curl_global_init_mem a b c d e f = peekFP (22) >>= \fp -> curl_global_init_memFC fp a b c d e f

type FTcurl_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 -}
foreign import ccall safe "dynamic"
  curl_global_init_memFC :: FunPtr FTcurl_global_init_mem -> FTcurl_global_init_mem

{-# LINE 315 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------

{-# NOINLINE curl_multi_add_handle #-}
curl_multi_add_handle :: Ptr CURLM {- ^ multi handle -} -> Ptr CURL {- ^ easy handle -} -> IO CURLMcode {- ^ multi status -}
curl_multi_add_handle a b = peekFP (28) >>= \fp -> curl_multi_add_handleFC fp a b

type FTcurl_multi_add_handle = Ptr CURLM {- ^ multi handle -} -> Ptr CURL {- ^ easy handle -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_add_handleFC :: FunPtr FTcurl_multi_add_handle -> FTcurl_multi_add_handle

{-# LINE 322 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_assign #-}
curl_multi_assign :: Ptr CURLM {- ^ multi handle -} -> CURLsocket {- ^ sockfd -} -> Ptr () {- ^ sockptr -} -> IO CURLMcode {- ^ multi status -}
curl_multi_assign a b c = peekFP (29) >>= \fp -> curl_multi_assignFC fp a b c

type FTcurl_multi_assign = Ptr CURLM {- ^ multi handle -} -> CURLsocket {- ^ sockfd -} -> Ptr () {- ^ sockptr -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_assignFC :: FunPtr FTcurl_multi_assign -> FTcurl_multi_assign

{-# LINE 328 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_cleanup #-}
curl_multi_cleanup :: Ptr CURLM {- ^ multi handle -} -> IO CURLMcode {- ^ multi status -}
curl_multi_cleanup a = peekFP (30) >>= \fp -> curl_multi_cleanupFC fp a

type FTcurl_multi_cleanup = Ptr CURLM {- ^ multi handle -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_cleanupFC :: FunPtr FTcurl_multi_cleanup -> FTcurl_multi_cleanup

{-# LINE 332 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_fdset #-}
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 -}
curl_multi_fdset a b c d e = peekFP (31) >>= \fp -> curl_multi_fdsetFC fp a b c d e

type FTcurl_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 -}
foreign import ccall safe "dynamic"
  curl_multi_fdsetFC :: FunPtr FTcurl_multi_fdset -> FTcurl_multi_fdset

{-# LINE 340 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_info_read #-}
curl_multi_info_read :: Ptr CURLM {- ^ multi handle -} -> Ptr CInt {- ^ msgs_in_queue -} -> IO (Ptr CURLmsg) {- ^ message -}
curl_multi_info_read a b = peekFP (32) >>= \fp -> curl_multi_info_readFC fp a b

type FTcurl_multi_info_read = Ptr CURLM {- ^ multi handle -} -> Ptr CInt {- ^ msgs_in_queue -} -> IO (Ptr CURLmsg) {- ^ message -}
foreign import ccall safe "dynamic"
  curl_multi_info_readFC :: FunPtr FTcurl_multi_info_read -> FTcurl_multi_info_read

{-# LINE 345 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_init #-}
curl_multi_init :: IO (Ptr CURLM) {- ^ multi handle -}
curl_multi_init  = peekFP (33) >>= \fp -> curl_multi_initFC fp 

type FTcurl_multi_init = IO (Ptr CURLM) {- ^ multi handle -}
foreign import ccall safe "dynamic"
  curl_multi_initFC :: FunPtr FTcurl_multi_init -> FTcurl_multi_init

{-# LINE 348 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_perform #-}
curl_multi_perform :: Ptr CURLM {- ^ multi handle -} -> Ptr CInt {- ^ running handles -} -> IO CURLMcode {- ^ multi status -}
curl_multi_perform a b = peekFP (34) >>= \fp -> curl_multi_performFC fp a b

type FTcurl_multi_perform = Ptr CURLM {- ^ multi handle -} -> Ptr CInt {- ^ running handles -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_performFC :: FunPtr FTcurl_multi_perform -> FTcurl_multi_perform

{-# LINE 353 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_remove_handle #-}
curl_multi_remove_handle :: Ptr CURLM {- ^ multi handle -} -> Ptr CURL {- ^ easy handle -} -> IO CURLMcode {- ^ multi status -}
curl_multi_remove_handle a b = peekFP (35) >>= \fp -> curl_multi_remove_handleFC fp a b

type FTcurl_multi_remove_handle = Ptr CURLM {- ^ multi handle -} -> Ptr CURL {- ^ easy handle -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_remove_handleFC :: FunPtr FTcurl_multi_remove_handle -> FTcurl_multi_remove_handle

{-# LINE 358 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_setopt #-}
curl_multi_setopt :: Ptr CURLM {- ^ multi handle -} -> CURLMoption {- ^ option -} -> Ptr () {- ^ value -} -> IO CURLMcode {- ^ multi status -}
curl_multi_setopt a b c = peekFP (36) >>= \fp -> curl_multi_setoptFC fp a b c

type FTcurl_multi_setopt = Ptr CURLM {- ^ multi handle -} -> CURLMoption {- ^ option -} -> Ptr () {- ^ value -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_setoptFC :: FunPtr FTcurl_multi_setopt -> FTcurl_multi_setopt

{-# LINE 364 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_socket #-}
curl_multi_socket :: Ptr CURLM {- ^ multi handle -} -> CURLsocket {- ^ sockfd -} -> Ptr CInt {- ^ running handles -} -> IO CURLMcode {- ^ multi status -}
curl_multi_socket a b c = peekFP (37) >>= \fp -> curl_multi_socketFC fp a b c

type FTcurl_multi_socket = Ptr CURLM {- ^ multi handle -} -> CURLsocket {- ^ sockfd -} -> Ptr CInt {- ^ running handles -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_socketFC :: FunPtr FTcurl_multi_socket -> FTcurl_multi_socket

{-# LINE 370 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_socket_action #-}
curl_multi_socket_action :: Ptr CURLM {- ^ multi handle -} -> CURLsocket {- ^ sockfd -} -> CInt {- ^ ev_bitmask -} -> Ptr CInt {- ^ running handles -} -> IO CURLMcode {- ^ multi status -}
curl_multi_socket_action a b c d = peekFP (38) >>= \fp -> curl_multi_socket_actionFC fp a b c d

type FTcurl_multi_socket_action = Ptr CURLM {- ^ multi handle -} -> CURLsocket {- ^ sockfd -} -> CInt {- ^ ev_bitmask -} -> Ptr CInt {- ^ running handles -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_socket_actionFC :: FunPtr FTcurl_multi_socket_action -> FTcurl_multi_socket_action

{-# LINE 377 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_socket_all #-}
curl_multi_socket_all :: Ptr CURLM {- ^ multi handle -} -> Ptr CInt {- ^ running handles -} -> IO CURLMcode {- ^ multi status -}
curl_multi_socket_all a b = peekFP (39) >>= \fp -> curl_multi_socket_allFC fp a b

type FTcurl_multi_socket_all = Ptr CURLM {- ^ multi handle -} -> Ptr CInt {- ^ running handles -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_socket_allFC :: FunPtr FTcurl_multi_socket_all -> FTcurl_multi_socket_all

{-# LINE 382 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_strerror #-}
curl_multi_strerror :: CURLMcode {- ^ errornum -} -> IO (Ptr CChar) {- ^ const string -}
curl_multi_strerror a = peekFP (40) >>= \fp -> curl_multi_strerrorFC fp a

type FTcurl_multi_strerror = CURLMcode {- ^ errornum -} -> IO (Ptr CChar) {- ^ const string -}
foreign import ccall safe "dynamic"
  curl_multi_strerrorFC :: FunPtr FTcurl_multi_strerror -> FTcurl_multi_strerror

{-# LINE 386 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_timeout #-}
curl_multi_timeout :: Ptr CURLM {- ^ multi handle -} -> Ptr CLong {- ^ timeout -} -> IO CURLMcode {- ^ multi status -}
curl_multi_timeout a b = peekFP (41) >>= \fp -> curl_multi_timeoutFC fp a b

type FTcurl_multi_timeout = Ptr CURLM {- ^ multi handle -} -> Ptr CLong {- ^ timeout -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_timeoutFC :: FunPtr FTcurl_multi_timeout -> FTcurl_multi_timeout

{-# LINE 391 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_multi_wait #-}
curl_multi_wait :: Ptr CURLM {- ^ multi handle -} -> Ptr CURLwaitfd {- ^ extra_fds[] -} -> CUInt {- ^ extra_nfds -} -> CInt {- ^ timeout_ms -} -> Ptr CInt {- ^ numfds -} -> IO CURLMcode {- ^ multi status -}
curl_multi_wait a b c d e = peekFP (42) >>= \fp -> curl_multi_waitFC fp a b c d e

type FTcurl_multi_wait = Ptr CURLM {- ^ multi handle -} -> Ptr CURLwaitfd {- ^ extra_fds[] -} -> CUInt {- ^ extra_nfds -} -> CInt {- ^ timeout_ms -} -> Ptr CInt {- ^ numfds -} -> IO CURLMcode {- ^ multi status -}
foreign import ccall safe "dynamic"
  curl_multi_waitFC :: FunPtr FTcurl_multi_wait -> FTcurl_multi_wait

{-# LINE 399 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------

{-# NOINLINE curl_share_cleanup #-}
curl_share_cleanup :: Ptr CURLSH {- ^ share handle -} -> IO CURLSHcode {- ^ share status -}
curl_share_cleanup a = peekFP (48) >>= \fp -> curl_share_cleanupFC fp a

type FTcurl_share_cleanup = Ptr CURLSH {- ^ share handle -} -> IO CURLSHcode {- ^ share status -}
foreign import ccall safe "dynamic"
  curl_share_cleanupFC :: FunPtr FTcurl_share_cleanup -> FTcurl_share_cleanup

{-# LINE 405 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_share_init #-}
curl_share_init :: IO (Ptr CURLSH) {- ^ share handle -}
curl_share_init  = peekFP (49) >>= \fp -> curl_share_initFC fp 

type FTcurl_share_init = IO (Ptr CURLSH) {- ^ share handle -}
foreign import ccall safe "dynamic"
  curl_share_initFC :: FunPtr FTcurl_share_init -> FTcurl_share_init

{-# LINE 408 "Network/CURL000/LibCC.hsc" #-}

-- #{SAFECALL curl_share_setopt         \
-- , Ptr CURLSH    {- ^ share handle -} \
-- , CURLSHopt  {- ^ option       -} \
-- , Ptr ()        {- ^ value        -} \
-- , IO CURLSHcode {- ^ share status -} }


{-# NOINLINE curl_share_strerror #-}
curl_share_strerror :: CURLSHcode {- ^ errornum -} -> IO (Ptr CChar) {- ^ const string -}
curl_share_strerror a = peekFP (51) >>= \fp -> curl_share_strerrorFC fp a

type FTcurl_share_strerror = CURLSHcode {- ^ errornum -} -> IO (Ptr CChar) {- ^ const string -}
foreign import ccall safe "dynamic"
  curl_share_strerrorFC :: FunPtr FTcurl_share_strerror -> FTcurl_share_strerror

{-# LINE 418 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------

{-# NOINLINE curl_slist_append #-}
curl_slist_append :: Ptr CURLslist {- ^ list -} -> Ptr CChar {- ^ const string -} -> IO (Ptr CURLslist) {- ^ list -}
curl_slist_append a b = peekFP (52) >>= \fp -> curl_slist_appendFC fp a b

type FTcurl_slist_append = Ptr CURLslist {- ^ list -} -> Ptr CChar {- ^ const string -} -> IO (Ptr CURLslist) {- ^ list -}
foreign import ccall safe "dynamic"
  curl_slist_appendFC :: FunPtr FTcurl_slist_append -> FTcurl_slist_append

{-# LINE 425 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_slist_free_all #-}
curl_slist_free_all :: Ptr CURLslist {- ^ list -} -> IO ()
curl_slist_free_all a = peekFP (53) >>= \fp -> curl_slist_free_allFC fp a

type FTcurl_slist_free_all = Ptr CURLslist {- ^ list -} -> IO ()
foreign import ccall safe "dynamic"
  curl_slist_free_allFC :: FunPtr FTcurl_slist_free_all -> FTcurl_slist_free_all

{-# LINE 429 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------

{-# NOINLINE curl_version #-}
curl_version :: IO (Ptr CChar) {- ^ string -}
curl_version  = peekFP (57) >>= \fp -> curl_versionFC fp 

type FTcurl_version = IO (Ptr CChar) {- ^ string -}
foreign import ccall safe "dynamic"
  curl_versionFC :: FunPtr FTcurl_version -> FTcurl_version

{-# LINE 434 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_version_info #-}
curl_version_info :: CURLversion {- ^ type/age -} -> IO (Ptr CURLvinfo)
curl_version_info a = peekFP (58) >>= \fp -> curl_version_infoFC fp a

type FTcurl_version_info = CURLversion {- ^ type/age -} -> IO (Ptr CURLvinfo)
foreign import ccall safe "dynamic"
  curl_version_infoFC :: FunPtr FTcurl_version_info -> FTcurl_version_info

{-# LINE 438 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------
-- Callbacks
-------------------------------------------------------------------------------

type CURL_write_callback = Ptr CChar -> CSize -> CSize -> Ptr () -> IO CSize

foreign import ccall "wrapper"
  wrapCURL_write_callback :: CURL_write_callback -> IO (FunPtr CURL_write_callback)

{-# LINE 444 "Network/CURL000/LibCC.hsc" #-}

type CURL_read_callback = Ptr CChar -> CSize -> CSize -> Ptr () -> IO CSize

foreign import ccall "wrapper"
  wrapCURL_read_callback :: CURL_read_callback -> IO (FunPtr CURL_read_callback)

{-# LINE 445 "Network/CURL000/LibCC.hsc" #-}

type CURL_header_callback = Ptr CChar -> CSize -> CSize -> Ptr () -> IO CSize

foreign import ccall "wrapper"
  wrapCURL_header_callback :: CURL_header_callback -> IO (FunPtr CURL_header_callback)

{-# LINE 446 "Network/CURL000/LibCC.hsc" #-}



type CURL_lock_function = Ptr CURL -> CURL_lock_data -> CURL_lock_access -> Ptr () -> IO ()

foreign import ccall "wrapper"
  wrapCURL_lock_function :: CURL_lock_function -> IO (FunPtr CURL_lock_function)

{-# LINE 450 "Network/CURL000/LibCC.hsc" #-}


type CURL_unlock_function = Ptr CURL -> CURL_lock_data -> Ptr () -> IO ()

foreign import ccall "wrapper"
  wrapCURL_unlock_function :: CURL_unlock_function -> IO (FunPtr CURL_unlock_function)

{-# LINE 453 "Network/CURL000/LibCC.hsc" #-}


-------------------------------------------------------------------------------
-- Wrappers for variadic functions
-------------------------------------------------------------------------------
{-# NOINLINE curl_easy_getinfo #-}
curl_easy_getinfo :: Ptr CURL -> CURLinfo -> Ptr () -> IO CURLcode
curl_easy_getinfo a b c =
  peekFP (3) >>= \fp -> curlOptDPtr fp (castPtr a) b c
{-# LINE 462 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_easy_setopt'Long #-}
curl_easy_setopt'Long :: Ptr CURL -> CURLoption -> CLong -> IO CURLcode
curl_easy_setopt'Long a b c =
  peekFP (10) >>= \fp -> curlOptLong fp (castPtr a) b c
{-# LINE 468 "Network/CURL000/LibCC.hsc" #-}

{-# 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 (10) >>= \fp -> curlOptCOff fp (castPtr a) b c
{-# LINE 473 "Network/CURL000/LibCC.hsc" #-}

{-# NOINLINE curl_easy_setopt'DPtr #-}
curl_easy_setopt'DPtr :: Ptr CURL -> CURLoption -> Ptr () -> IO CURLcode
curl_easy_setopt'DPtr a b c =
  peekFP (10) >>= \fp -> curlOptDPtr fp (castPtr a) b c
{-# LINE 478 "Network/CURL000/LibCC.hsc" #-}

{-# NOINLINE curl_easy_setopt'FPtr #-}
curl_easy_setopt'FPtr :: Ptr CURL -> CURLoption -> FunPtr () -> IO CURLcode
curl_easy_setopt'FPtr a b c =
  peekFP (10) >>= \fp -> curlOptFPtr fp (castPtr a) b c
{-# LINE 483 "Network/CURL000/LibCC.hsc" #-}


{-# NOINLINE curl_share_setopt'Long #-}
curl_share_setopt'Long :: Ptr CURLSH -> CURLSHopt -> CLong -> IO CURLSHcode
curl_share_setopt'Long a b c =
  peekFP (50) >>= \fp -> curlOptLong fp (castPtr a) b c
{-# LINE 489 "Network/CURL000/LibCC.hsc" #-}

{-# NOINLINE curl_share_setopt'FPtr #-}
curl_share_setopt'FPtr :: Ptr CURLSH -> CURLSHopt -> FunPtr () -> IO CURLSHcode
curl_share_setopt'FPtr a b c =
  peekFP (50) >>= \fp -> curlOptFPtr fp (castPtr a) b c
{-# LINE 494 "Network/CURL000/LibCC.hsc" #-}


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