git.maemo.org Git - cinaest/blob - vapi/libcurl.vapi

   1 [CCode (cheader_filename = "curl/curl.h")]
   2 namespace Curl {
   3         [CCode (cname = "CURL_GLOBAL_SSL")]
   4         public const long GLOBAL_SSL;
   5         [CCode (cname = "CURL_GLOBAL_WIN32")]
   6         public const long GLOBAL_WIN32;
   7         [CCode (cname = "CURL_GLOBAL_ALL")]
   8         public const long GLOBAL_ALL;
   9         [CCode (cname = "CURL_GLOBAL_NOTHING")]
  10         public const long GLOBAL_NOTHING;
  11         [CCode (cname = "CURL_GLOBAL_DEFAULT")]
  12         public const int GLOBAL_DEFAULT;
  13         public Curl.Code global_init (long flags);
  14         public Curl.Code global_init_mem (long flags, Curl.MallocCallback m, Curl.FreeCallback f, Curl.ReallocCallback r, Curl.StrdupCallback s, Curl.CallocCallback c);
  15         public static void global_cleanup ();
  16         [CCode (cname = "CURL", cprefix = "curl_easy_", unref_function = "curl_easy_cleanup")]
  17         public class EasyHandle {
  18                 [CCode (cname = "curl_easy_init")]
  19                 public EasyHandle ();
  20                 [PrintfFormat]
  21                 public Curl.Code setopt (Curl.Option option, ...);
  22                 public Curl.Code perform ();
  23                 [PrintfFormat]
  24                 public Curl.Code getinfo (Curl.Info info, ...);
  25                 public Curl.EasyHandle duphandle ();
  26                 public void reset ();
  27                 public Curl.Code recv (void *buffer, size_t buflen, out size_t n);
  28                 public Curl.Code send (void *buffer, size_t buflen, out size_t n);
  29                 public string escape (string @string, int length);
  30                 public string unescape (string @string, int length, out int outlength);
  31         }
  32         [CCode (cname = "CURLcode", cprefix = "CURLE_")]
  33         public enum Code {
  34                 OK,
  35                 UNSUPPORTED_PROTOCOL,
  36                 FAILED_INIT,
  37                 URL_MALFORMAT,
  38                 COULDNT_RESOLVE_PROXY,
  39                 COULDNT_RESOLVE_HOST,
  40                 COULDNT_CONNECT,
  41                 FTP_WEIRD_SERVER_REPLY,
  42                 REMOTE_ACCESS_DENIED,
  43                 FTP_WEIRD_PASS_REPLY,
  44                 FTP_WEIRD_PASV_REPLY,
  45                 FTP_WEIRD_227_FORMAT,
  46                 FTP_CANT_GET_HOST,
  47                 FTP_COULDNT_SET_TYPE,
  48                 PARTIAL_FILE,
  49                 FTP_COULDNT_RETR_FILE,
  50                 QUOTE_ERROR,
  51                 HTTP_RETURNED_ERROR,
  52                 WRITE_ERROR,
  53                 UPLOAD_FAILED,
  54                 READ_ERROR,
  55                 OUT_OF_MEMORY,
  56                 OPERATION_TIMEDOUT,
  57                 FTP_PORT_FAILED,
  58                 FTP_COULDNT_USE_REST,
  59                 RANGE_ERROR,
  60                 HTTP_POST_ERROR,
  61                 SSL_CONNECT_ERROR,
  62                 BAD_DOWNLOAD_RESUME,
  63                 FILE_COULDNT_READ_FILE,
  64                 LDAP_CANNOT_BIND,
  65                 LDAP_SEARCH_FAILED,
  66                 FUNCTION_NOT_FOUND,
  67                 ABORTED_BY_CALLBACK,
  68                 BAD_FUNCTION_ARGUMENT,
  69                 INTERFACE_FAILED,
  70                 TOO_MANY_REDIRECTS,
  71                 UNKNOWN_TELNET_OPTION,
  72                 TELNET_OPTION_SYNTAX,
  73                 PEER_FAILED_VERIFICATION,
  74                 GOT_NOTHING,
  75                 SSL_ENGINE_NOTFOUND,
  76                 SSL_ENGINE_SETFAILED,
  77                 SEND_ERROR,
  78                 RECV_ERROR,
  79                 SSL_CERTPROBLEM,
  80                 SSL_CIPHER,
  81                 SSL_CACERT,
  82                 BAD_CONTENT_ENCODING,
  83                 LDAP_INVALID_URL,
  84                 FILESIZE_EXCEEDED,
  85                 USE_SSL_FAILED,
  86                 SEND_FAIL_REWIND,
  87                 SSL_ENGINE_INITFAILED,
  88                 LOGIN_DENIED,
  89                 TFTP_NOTFOUND,
  90                 TFTP_PERM,
  91                 REMOTE_DISK_FULL,
  92                 TFTP_ILLEGAL,
  93                 TFTP_UNKNOWNID,
  94                 REMOTE_FILE_EXISTS,
  95                 TFTP_NOSUCHUSER,
  96                 CONV_FAILED,
  97                 CONV_REQD,
  98                 SSL_CACERT_BADFILE,
  99                 REMOTE_FILE_NOT_FOUND,
 100                 SSH,
 101                 SSL_SHUTDOWN_FAILED,
 102                 AGAIN,
 103                 SSL_CRL_BADFILE,
 104                 SSL_ISSUER_ERROR,
 105                 [CCode (cname = "CURL_LAST")]
 106                 LAST
 107         }
 108         [CCode (name = "CURLoption", cprefix = "CURLOPT_")]
 109         public enum Option {
 110                 FILE,
 111                 URL,
 112                 PORT,
 113                 PROXY,
 114                 USERPWD,
 115                 PROXYUSERPWD,
 116                 RANGE,
 117                 INFILE,
 118                 WRITEDATA,
 119                 READDATA,
 120                 ERRORBUFFER,
 121                 WRITEFUNCTION,
 122                 READFUNCTION,
 123                 TIMEOUT,
 124                 INFILESIZE,
 125                 POSTFIELDS,
 126                 REFERER,
 127                 FTPPORT,
 128                 USERAGENT,
 129                 LOW_SPEED_LIMIT,
 130                 LOW_SPEED_TIME,
 131                 RESUME_FROM,
 132                 COOKIE,
 133                 HTTPHEADER,
 134                 HTTPPOST,       // struct HTTPPost
 135                 SSLCERT,
 136                 KEYPASSWD,
 137                 CRLF,
 138                 QUOTE,
 139                 WRITEHEADER,
 140                 HEADERDATA,
 141                 COOKIEFILE,
 142                 SSLVERSION,
 143                 TIMECONDITION,
 144                 TIMEVALUE,
 145                 CUSTOMREQUEST,
 146                 STDERR,
 147                 POSTQUOTE,
 148                 WRITEINFO,
 149                 VERBOSE,
 150                 HEADER,
 151                 NOPROGRESS,
 152                 NOBODY,
 153                 FAILONERROR,
 154                 UPLOAD,
 155                 POST,
 156                 DIRLISTONLY,
 157                 APPEND,
 158                 NETRC,
 159                 FOLLOWLOCATION,
 160                 TRANSFERTEXT,
 161                 PUT,
 162                 PROGRESSFUNCTION,
 163                 PROGRESSDATA,
 164                 AUTOREFERER,
 165                 PROXYPORT,
 166                 POSTFIELDSIZE,
 167                 HTTPPROXYTUNNEL,
 168                 INTERFACE,
 169                 KRBLEVEL,
 170                 SSL_VERIFYPEER,
 171                 CAINFO,
 172                 MAXREDIRS,
 173                 FILETIME,
 174                 TELNETOPTIONS,
 175                 MAXCONNECTS,
 176                 CLOSEPOLICY,
 177                 FRESH_CONNECT,
 178                 FORBID_REUSE,
 179                 RANDOM_FILE,
 180                 EGDSOCKET,
 181                 CONNECTTIMEOUT,
 182                 HEADERFUNCTION,
 183                 HTTPGET,
 184                 SSL_VERIFYHOST,
 185                 COOKIEJAR,
 186                 SSL_CIPHER_LIST,
 187                 HTTP_VERSION,
 188                 FTP_USE_EPSV,
 189                 SSLCERTTYPE,
 190                 SSLKEY,
 191                 SSLKEYTYPE,
 192                 SSLENGINE,
 193                 SSLENGINE_DEFAULT,
 194                 DNS_USE_GLOBAL_CACHE,
 195                 DNS_CACHE_TIMEOUT,
 196                 PREQUOTE,
 197                 DEBUGFUNCTION,
 198                 DEBUGDATA,
 199                 COOKIESESSION,
 200                 CAPATH,
 201                 BUFFERSIZE,
 202                 NOSIGNAL,
 203                 SHARE,
 204                 PROXYTYPE ,
 205                 ENCODING,
 206                 PRIVATE,
 207                 HTTP200ALIASES,
 208                 UNRESTRICTED_AUTH,
 209                 FTP_USE_EPRT,
 210                 HTTPAUTH,
 211                 SSL_CTX_FUNCTION,
 212                 SSL_CTX_DATA,
 213                 FTP_CREATE_MISSING_DIRS,
 214                 PROXYAUTH,
 215                 FTP_RESPONSE_TIMEOUT,
 216                 IPRESOLVE,
 217                 MAXFILESIZE,
 218                 INFILESIZE_LARGE,
 219                 RESUME_FROM_LARGE,
 220                 MAXFILESIZE_LARGE,
 221                 NETRC_FILE,
 222                 USE_SSL,
 223                 POSTFIELDSIZE_LARGE,
 224                 TCP_NODELAY,
 225                 FTPSSLAUTH,
 226                 IOCTLFUNCTION,
 227                 IOCTLDATA,
 228                 FTP_ACCOUNT,
 229                 COOKIELIST,
 230                 IGNORE_CONTENT_LENGTH,
 231                 FTP_SKIP_PASV_IP,
 232                 FTP_FILEMETHOD,
 233                 LOCALPORT,
 234                 LOCALPORTRANGE,
 235                 CONNECT_ONLY,
 236                 CONV_FROM_NETWORK_FUNCTION,
 237                 CONV_TO_NETWORK_FUNCTION,
 238                 CONV_FROM_UTF8_FUNCTION,
 239                 MAX_SEND_SPEED_LARGE,
 240                 MAX_RECV_SPEED_LARGE,
 241                 FTP_ALTERNATIVE_TO_USER,
 242                 SOCKOPTFUNCTION,
 243                 SOCKOPTDATA,
 244                 SSL_SESSIONID_CACHE,
 245                 SSH_AUTH_TYPES,
 246                 SSH_PUBLIC_KEYFILE,
 247                 SSH_PRIVATE_KEYFILE,
 248                 FTP_SSL_CCC,
 249                 TIMEOUT_MS,
 250                 CONNECTTIMEOUT_MS,
 251                 HTTP_TRANSFER_DECODING,
 252                 HTTP_CONTENT_DECODING,
 253                 NEW_FILE_PERMS,
 254                 NEW_DIRECTORY_PERMS,
 255                 POSTREDIR,
 256                 SSH_HOST_PUBLIC_KEY_MD5,
 257                 OPENSOCKETFUNCTION,
 258                 OPENSOCKETDATA,
 259                 COPYPOSTFIELDS,
 260                 PROXY_TRANSFER_MODE,
 261                 SEEKFUNCTION,
 262                 SEEKDATA,
 263                 CRLFILE,
 264                 ISSUERCERT,
 265                 ADDRESS_SCOPE,
 266                 CERTINFO,
 267                 USERNAME,
 268                 PASSWORD,
 269                 PROXYUSERNAME,
 270                 PROXYPASSWORD,
 271                 NOPROXY,
 272                 TFTP_BLKSIZE,
 273                 SOCKS5_GSSAPI_SERVICE,
 274                 SOCKS5_GSSAPI_NEC,
 275                 PROTOCOLS,
 276                 REDIR_PROTOCOLS,
 277                 SSH_KNOWNHOSTS,
 278                 SSH_KEYFUNCTION,
 279                 SSH_KEYDATA,
 280                 LASTENTRY
 281         }
 282         [CCode (name = "CURLINFO", cprefix = "CURLINFO_")]
 283         public enum Info {
 284                 STRING,
 285                 LONG,
 286                 DOUBLE,
 287                 SLIST,
 288                 EFFECTIVE_URL,
 289                 RESPONSE_CODE,
 290                 TOTAL_TIME,
 291                 NAMELOOKUP_TIME,
 292                 CONNECT_TIME,
 293                 PRETRANSFER_TIME,
 294                 SIZE_UPLOAD,
 295                 SIZE_DOWNLOAD,
 296                 SPEED_DOWNLOAD,
 297                 SPEED_UPLOAD,
 298                 HEADER_SIZE,
 299                 REQUEST_SIZE,
 300                 SSL_VERIFYRESULT,
 301                 FILETIME,
 302                 CONTENT_LENGTH_DOWNLOAD,
 303                 CONTENT_LENGTH_UPLOAD,
 304                 STARTTRANSFER_TIME,
 305                 CONTENT_TYPE,
 306                 REDIRECT_TIME,
 307                 REDIRECT_COUNT,
 308                 PRIVATE,
 309                 HTTP_CONNECTCODE,
 310                 HTTPAUTH_AVAIL,
 311                 PROXYAUTH_AVAIL,
 312                 OS_ERRNO,
 313                 NUM_CONNECTS,
 314                 SSL_ENGINES,
 315                 COOKIELIST,
 316                 LASTSOCKET,
 317                 FTP_ENTRY_PATH,
 318                 REDIRECT_URL,
 319                 PRIMARY_IP,
 320                 APPCONNECT_TIME,
 321                 CERTINFO,
 322                 CONDITION_UNMET,
 323                 LASTONE
 324         }
 325         [CCode (cname = "curl_progress_callback")]
 326         public delegate int ProgressCallback (void* clientp, double dltotal, double dlnow, double ultotal, double ulnow);
 327         [CCode (cname = "CURL_WRITEFUNC_PAUSE")]
 328         public const size_t WRITEFUNC_PAUSE;
 329         [CCode (cname = "curl_write_callback")]
 330         public delegate size_t WriteCallback (char* buffer, size_t size, size_t nitems, void *outstream);
 331         [CCode (cname = "CURL_SEEKFUNC_OK")]
 332         public const int SEEKFUNC_OK;
 333         [CCode (cname = "CURL_SEEKFUNC_FAIL")]
 334         public const int SEEKFUNC_FAIL;
 335         [CCode (cname = "CURL_SEEKFUNC_CANTSEEK")]
 336         public const int SEEKFUNC_CANTSEEK;
 337         [Ccode (cname = "curl_seek_callback")]
 338         public delegate int SeekCallback (void* instream, Curl.Offset offset, int origin);
 339         [CCode (cname = "CURL_READFUNC_ABORT")]
 340         public const size_t READFUNC_ABORT;
 341         [CCode (cname = "CURL_READFUNC_PAUSE")]
 342         public const size_t READFUNC_PAUSE;
 343         [CCode (cname = "curl_read_callback")]
 344         public delegate size_t ReadCallback (char* buffer, size_t size, size_t nitems, void *instream);
 345         [CCode (cname = "curlsocktype", cprefix = "CURLSOCKTYPE_")]
 346         public enum SocketType {
 347                 IPCXN,
 348                 LAST
 349         }
 350         [CCode (cname = "curl_sockopt_callback")]
 351         public delegate size_t SockoptCallback (void* clientp, Curl.Socket curlfd, Curl.SocketType purpose);
 352         [CCode (cname = "curlioerr", cprefix = "CURLIOE_")]
 353         public enum IOError {
 354                 OK,
 355                 UNKNOWNCMD,
 356                 FAILRESTART,
 357                 LAST
 358         }
 359         [CCode (cname = "curliocmd", cprefix = "CURLIOCMD_")]
 360         public enum IOCmd {
 361                 NOP,
 362                 RESTARTREAD,
 363                 LAST
 364         }
 365         [CCode (cname = "curl_ioctl_callback")]
 366         public delegate Curl.IOError IoctlCallback (Curl.EasyHandle handle, int cmd, void* clientp);
 367         [CCode (cname = "curl_malloc_callback")]
 368         public delegate void* MallocCallback (size_t size);
 369         [CCode (cname = "curl_free_callback")]
 370         public delegate void FreeCallback (void* ptr);
 371         [CCode (cname = "curl_realloc_callback")]
 372         public delegate void* ReallocCallback (void* ptr, size_t size);
 373         [CCode (cname = "curl_strdup_callback")]
 374         public delegate string StrdupCallback (string str);
 375         [CCode (cname = "curl_calloc_callback")]
 376         public delegate void* CallocCallback (size_t nmemb, size_t size);
 377         [CCode (cname = "curl_infotype", cprefix = "CURLINFO_")]
 378         public enum InfoType {
 379                 TEXT,
 380                 HEADER_IN,
 381                 HEADER_OUT,
 382                 DATA_IN,
 383                 DATA_OUT,
 384                 SSL_DATA_IN,
 385                 SSL_DATA_OUT
 386         }
 387         [CCode (cname = "curl_debug_callback")]
 388         public delegate int DebugCallback (Curl.EasyHandle handle, Curl.InfoType type, [CCode (array_length_type = "size_t")] char[] data, void* userptr);
 389         [CCode (cname = "curl_conv_callback")]
 390         public delegate Curl.Code ConvCallback ([CCode (array_length_type = "size_t")] char[] buffer);
 391         [CCode (cname = "curl_ssl_ctx_callback")]
 392         public delegate Curl.Code SSLCtxCallback (Curl.EasyHandle curl, void* ssl_ctx, void* userptr);
 393         [CCode (cname = "curl_proxytype", cprefix = "CURLPROXY_")]
 394         public enum ProxyType {
 395                 HTTP,
 396                 HTTP_1_0,
 397                 SOCKS4,
 398                 SOCKS5,
 399                 SOCKS4A,
 400                 SOCKS5_HOSTNAME
 401         }
 402         namespace AuthType {
 403                 [CCode (cname = "CURLAUTH_NONE")]
 404                 public const int NONE;
 405                 [CCode (cname = "CURLAUTH_BASIC")]
 406                 public const int BASIC;
 407                 [CCode (cname = "CURLAUTH_DIGEST")]
 408                 public const int DIGEST;
 409                 [CCode (cname = "CURLAUTH_GSSNEGOTIATE")]
 410                 public const int GSSNEGOTIATE;
 411                 [CCode (cname = "CURLAUTH_NTLM")]
 412                 public const int NTLM;
 413                 [CCode (cname = "CURLAUTH_DIGEST_IE")]
 414                 public const int DIGEST_IE;
 415                 [CCode (cname = "CURLAUTH_ANY")]
 416                 public const int ANY;
 417                 [CCode (cname = "CURLAUTH_ANYSAFE")]
 418                 public const int ANYSAFE;
 419         }
 420         namespace SSHAuthType {
 421                 [CCode (cname = "CURLSSH_AUTH_ANY")]
 422                 public const int ANY;
 423                 [CCode (cname = "CURLSSH_AUTH_NONE")]
 424                 public const int NONE;
 425                 [CCode (cname = "CURLSSH_AUTH_PUBLICKEY")]
 426                 public const int PUBLICKEY;
 427                 [CCode (cname = "CURLSSH_AUTH_PASSWORD")]
 428                 public const int PASSWORD;
 429                 [CCode (cname = "CURLSSH_AUTH_HOST")]
 430                 public const int HOST;
 431                 [CCode (cname = "CURLSSH_AUTH_KEYBOARD")]
 432                 public const int KEYBOARD;
 433                 [CCode (cname = "CURLSSH_AUTH_DEFAULT")]
 434                 public const int DEFAULT;
 435         }
 436         public const int ERROR_SIZE;
 437         [CCode (cname = "curl_usessl", cprefix = "CURLUSESSL_")]
 438         public enum UseSSL {
 439                 NONE,
 440                 TRY,
 441                 CONTROL,
 442                 ALL
 443         }
 444         [CCode (cname = "curl_ftpccc", cprefix = "CURLFTPSSL_")]
 445         enum FTPSSL {
 446                 CCC_NONE,
 447                 CCC_PASSIVE,
 448                 CCC_ACTIVE
 449         }
 450         [CCode (cname = "curl_ftpauth", cprefix = "CURLFTPAUTH_")]
 451         enum FTPAuthType {
 452                 DEFAULT,
 453                 SSL,
 454                 TLS
 455         }
 456         [CCode (cname = "curl_ftpcreatedir", cprefix = "CURLFTP_CREATE_DIR_")]
 457         enum FTPCreateDir {
 458                 NONE,
 459                 [CCode (cname = "CURLFTP_CREATE_DIR")]
 460                 CREATE,
 461                 RETRY
 462         }
 463         [CCode (cname = "curl_ftpmethod", cprefix = "CURLFTPMETHOD_")]
 464         enum FTPMethod {
 465                 DEFAULT,
 466                 MULTICWD,
 467                 NOCWD,
 468                 SINGLECWD
 469         }
 470         namespace Proto {
 471                 [CCode (cname = "CURLPROTO_HTTP")]
 472                 public const int HTTP;
 473                 [CCode (cname = "CURLPROTO_HTTPS")]
 474                 public const int HTTPS;
 475                 [CCode (cname = "CURLPROTO_FTP")]
 476                 public const int FTP;
 477                 [CCode (cname = "CURLPROTO_FTPS")]
 478                 public const int FTPS;
 479                 [CCode (cname = "CURLPROTO_SCP")]
 480                 public const int SCP;
 481                 [CCode (cname = "CURLPROTO_SFTP")]
 482                 public const int SFTP;
 483                 [CCode (cname = "CURLPROTO_TELNET")]
 484                 public const int TELNET;
 485                 [CCode (cname = "CURLPROTO_LDAP")]
 486                 public const int LDAP;
 487                 [CCode (cname = "CURLPROTO_LDAPS")]
 488                 public const int LDAPS;
 489                 [CCode (cname = "CURLPROTO_DICT")]
 490                 public const int DICT;
 491                 [CCode (cname = "CURLPROTO_FILE")]
 492                 public const int FILE;
 493                 [CCode (cname = "CURLPROTO_TFTP")]
 494                 public const int TFTP;
 495                 [CCode (cname = "CURLPROTO_ALL")]
 496                 public const int ALL;
 497         }
 498         public const int IPRESOLVE_WHATEVER;
 499         public const int IPRESOLVE_V4;
 500         public const int IPRESOLVE_V6;
 501         public const int REDIR_GET_ALL;
 502         public const int REDIR_POST_301;
 503         public const int REDIR_POST_302;
 504         public const int REDIR_POST_ALL;
 505         [CCode (cname = "curl_TimeCond", cprefix = "CURL_TIMECOND_")]
 506         public enum TimeCond {
 507                 NONE,
 508                 IFMODSINCE,
 509                 IFUNMODSINCE,
 510                 LASTMOD
 511         }
 512         [CCode (cname = "CURLformoption", cprefix = "CURLFORM_")]
 513         public enum FormOption {
 514                 COPYNAME,
 515                 PTRNAME,
 516                 NAMELENGTH,
 517                 COPYCONTENTS,
 518                 PTRCONTENTS,
 519                 CONTENTSLENGTH,
 520                 FILECONTENT,
 521                 ARRAY,
 522                 OBSOLETE,
 523                 FILE,
 524                 BUFFER,
 525                 BUFFERPTR,
 526                 BUFFERLENGTH,
 527                 CONTENTTYPE,
 528                 CONTENTHEADER,
 529                 FILENAME,
 530                 END,
 531                 OBSOLETE2,
 532                 STREAM
 533         }
 534         [CCode (cname = "struct curl_forms")]
 535         public struct Forms {
 536                 public Curl.FormOption option;
 537                 public string value;
 538         }
 539         [CCode (cname = "CURLFORMcode", cprefix = "CURL_FORMADD_")]
 540         public enum FormCode {
 541                 OK,
 542                 MEMORY,
 543                 OPTION_TWICE,
 544                 NULL,
 545                 UNKNOWN_OPTION,
 546                 INCOMPLETE,
 547                 ILLEGAL_ARRAY,
 548                 DISABLED
 549         }
 550         public Curl.FormCode formadd (ref Curl.HTTPPost httppost, ref Curl.HTTPPost last_post, ...);
 551         [CCode (cname = "curl_formget_callback")]
 552         public delegate size_t FormgetCallback (void* arg, [CCode (array_size_type = "size_t")] char[] buf);
 553         public int formget (Curl.HTTPPost form, void* arg, Curl.FormgetCallback append);
 554         public weak string version ();
 555         public void free (void* p);
 556         [Compact]
 557         [CCode (cname = "struct curl_slist", cprefix = "curl_slist_", free_function = "curl_slist_free_all")]
 558         public class SList {
 559                 public char* data;
 560                 public Curl.SList next;
 561                 public SList append (string data);
 562         }
 563         [CCode (cname = "CURLMcode", cprefix = "CURLM_")]
 564         public enum MultiCode {
 565                 CALL_MULTI_PERFORM,
 566                 CALL_MULTI_SOCKET,
 567                 OK,
 568                 BAD_HANDLE,
 569                 BAD_EASY_HANDLE,
 570                 OUT_OF_MEMORY,
 571                 INTERNAL_ERROR,
 572                 BAD_SOCKET,
 573                 UNKNOWN_OPTION
 574         }
 575         [CCode (cname = "CURLMSG", cprefix = "CURLMSG_")]
 576         public enum MessageType {
 577                 NONE,
 578                 DONE
 579         }
 580         [CCode (cname = "CURLMsg")]
 581         public struct Message {
 582                 public Curl.MessageType msg;
 583                 public Curl.EasyHandle easy_handle;
 584                 [CCode (cname = "data.whatever")]
 585                 public void* whatever;
 586                 [CCode (cname = "data.result")]
 587                 public Curl.Code result;
 588         }
 589         [CCode (cname = "CURLM", cprefix = "curl_multi_", destroy_function = "curl_multi_cleanup")]
 590         public class MultiHandle {
 591                 [CCode (cname = "curl_multi_init")]
 592                 public MultiHandle ();
 593                 public Curl.MultiCode add_handle (Curl.EasyHandle curl_handle);
 594                 public Curl.MultiCode remove_handle (Curl.EasyHandle curl_handle);
 595                 public Curl.MultiCode fdset (Posix.fd_set? read_fd_set, Posix.fd_set? write_fd_set, Posix.fd_set? exc_fd_set, out int max_fd);
 596                 public Curl.MultiCode perform (out int running_handles);
 597                 public unowned Curl.Message info_read (out int msgs_in_queue);
 598                 public unowned string strerror (Curl.MultiCode code);
 599                 public Curl.MultiCode socket_action (Curl.Socket s, int ev_bitmask, out int running_handles);
 600                 public Curl.MultiCode socket_all (out int running_handles);
 601                 public Curl.MultiCode timeout (out long milliseconds);
 602                 [Printf]
 603                 public Curl.MultiCode setopt (Curl.MultiOption option, ...);
 604                 public Curl.MultiCode assign (Curl.Socket sockfd, void* sockp);
 605         }
 606         public static delegate int TimerCallback (Curl.MultiHandle multi, long timeout_ms, void* userp);
 607         public static delegate int SocketCallback (Curl.EasyHandle easy, Curl.Socket s, int what, void* userp, void *socketp);
 608         [SimpleType]
 609         [CCode (cname = "curl_socket_t")]
 610         public struct Socket {
 611         }
 612         [SimpleType]
 613         [CCode (cname = "curl_off_t")]
 614         public struct Offset {
 615         }
 616         [CCode (cname = "CURL_SOCKET_BAD")]
 617         public const Curl.Socket SOCKET_BAD;
 618         [CCode (cname = "CURL_POLL_NONE")]
 619         public const int POLL_NONE;
 620         [CCode (cname = "CURL_POLL_IN")]
 621         public const int POLL_IN;
 622         [CCode (cname = "CURL_POLL_OUT")]
 623         public const int POLL_OUT;
 624         [CCode (cname = "CURL_POLL_INOUT")]
 625         public const int POLL_INOUT;
 626         [CCode (cname = "CURL_POLL_REMOVE")]
 627         public const int POLL_REMOVE;
 628         [CCode (cname = "CURL_SOCKET_TIMEOUT")]
 629         public const int SOCKET_TIMEOUT;
 630         [CCode (cname = "CURL_CSELECT_IN")]
 631         public const int CSELECT_IN;
 632         [CCode (cname = "CURL_CSELECT_OUT")]
 633         public const int CSELECT_OUT;
 634         [CCode (cname = "CURL_CSELECT_ERR")]
 635         public const int CSELECT_ERR;
 636         [CCode (cname = "CURLMoption")]
 637         public enum MultiOption {
 638                 SOCKETFUNCTION,
 639                 SOCKETDATA,
 640                 PIPELINING,
 641                 TIMERFUNCTION,
 642                 TIMERDATA,
 643                 MAXCONNECTS
 644         }
 645         [Compact]
 646         [CCode (cname = "curl_httppost", unref_function = "curl_formfree")]
 647         public class HTTPPost {
 648                 public Curl.HTTPPost next;
 649                 [CCode (array_length_cname = "namelength", array_length_type = "long")]
 650                 public weak char[] name;
 651                 [CCode (array_length_cname = "contentslength", array_length_type = "long")]
 652                 public weak char[] contents;
 653                 [CCode (array_length_cname = "bufferlength", array_length_type = "long")]
 654                 public weak char[] buffer;
 655                 public string contenttype;
 656                 public Curl.SList contentheader;
 657                 public Curl.HTTPPost more;
 658                 public long flags;
 659                 public string showfilename;
 660                 public void* userp;
 661                 [CCode (cname = "HTTPPOST_FILENAME")]
 662                 public const long FILENAME;
 663                 [CCode (cname = "HTTPPOST_READFILE")]
 664                 public const long READFILE;
 665                 [CCode (cname = "HTTPPOST_PTRCONTENTS")]
 666                 public const long PTRCONTENTS;
 667                 [CCode (cname = "HTTPPOST_BUFFER")]
 668                 public const long BUFFER;
 669                 [CCode (cname = "HTTPPOST_PTRBUFFER")]
 670                 public const long PTRBUFFER;
 671                 [CCode (cname = "HTTPPOST_CALLBACK")]
 672                 public const long CALLBACK;
 673         }
 674         [CCode (cname = "LIBCURL_COPYRIGHT")]
 675         public const string COPYRIGHT;
 676         [CCode (cname = "LIBCURL_VERSION")]
 677         public const string VERSION;
 678         [CCode (cname = "LIBCURL_VERSION_MAJOR")]
 679         public const int VERSION_MAJOR;
 680         [CCode (cname = "LIBCURL_VERSION_MINOR")]
 681         public const int VERSION_MINOR;
 682         [CCode (cname = "LIBCURL_VERSION_PATCH")]
 683         public const int VERSION_PATCH;
 684         [CCode (cname = "LIBCURL_VERSION_NUM")]
 685         public const int VERSION_NUM;
 686         [CCode (cname = "LIBCURL_TIMESTAMP")]
 687         public const string TIMESTAMP;
 688 }