curb 0.1.4 → 0.7.15

data/ext/curb_easy.h

@@ -1,7 +1,7 @@
 /* curb_easy.h - Curl easy mode
- * Copyright (c)2006 Ross Bamford. 
+ * Copyright (c)2006 Ross Bamford.
  * Licensed under the Ruby License. See LICENSE for details.
- * 
+ *
  * $Id: curb_easy.h 25 2006-12-07 23:38:25Z roscopeco $
  */
 #ifndef __CURB_EASY_H
@@ -11,33 +11,38 @@
 
 #include <curl/easy.h>
 
+#ifdef CURL_VERSION_SSL
+#if LIBCURL_VERSION_NUM >= 0x070b00
+#  if LIBCURL_VERSION_NUM <= 0x071004
+#    define CURB_FTPSSL         CURLOPT_FTP_SSL
+#    define CURB_FTPSSL_ALL     CURLFTPSSL_ALL
+#    define CURB_FTPSSL_TRY     CURLFTPSSL_TRY
+#    define CURB_FTPSSL_CONTROL CURLFTPSSL_CONTROL
+#    define CURB_FTPSSL_NONE    CURLFTPSSL_NONE
+#  else
+#    define CURB_FTPSSL         CURLOPT_USE_SSL
+#    define CURB_FTPSSL_ALL     CURLUSESSL_ALL
+#    define CURB_FTPSSL_TRY     CURLUSESSL_TRY
+#    define CURB_FTPSSL_CONTROL CURLUSESSL_CONTROL
+#    define CURB_FTPSSL_NONE    CURLUSESSL_NONE
+#  endif
+#endif
+#endif
+
 /* a lot of this *could* be kept in the handler itself,
  * but then we lose the ability to query it's status.
  */
 typedef struct {
   /* The handler */
   CURL *curl;
-  
-  /* Objects we associate */
-  VALUE url;  
-  VALUE proxy_url;
-  
-  VALUE body_proc;
-  VALUE header_proc;  
-  VALUE body_data;      /* These have the result from the last curl_easy_perform */
-  VALUE header_data;    /* unless a block is supplied (when they'll be nil)      */
-  VALUE progress_proc;
-  VALUE debug_proc;
-  VALUE interface;
-  VALUE userpwd;
-  VALUE proxypwd;
-  VALUE headers;        /* ruby array of strings with headers to set */
-  VALUE cookiejar;      /* filename */
-  
+
+  VALUE opts; /* rather then allocate everything we might need to store, allocate a Hash and only store objects we actually use... */
+  VALUE multi; /* keep a multi handle alive for each easy handle not being used by a multi handle.  This improves easy performance when not within a multi context */
+
   /* Other opts */
   unsigned short local_port;       // 0 is no port
   unsigned short local_port_range; // "  "  " "
-  unsigned short proxy_port;       // "  "  " " 
+  unsigned short proxy_port;       // "  "  " "
   int proxy_type;
   long http_auth_types;
   long proxy_auth_types;
@@ -46,8 +51,13 @@ typedef struct {
   unsigned long connect_timeout;
   long dns_cache_timeout;
   unsigned long ftp_response_timeout;
+  long low_speed_limit;
+  long low_speed_time;
+  long ssl_version;
+  long use_ssl;
+  long ftp_filemethod;
 
-  /* bool flags */  
+  /* bool flags */
   char proxy_tunnel;
   char fetch_file_time;
   char ssl_verify_peer;
@@ -56,19 +66,22 @@ typedef struct {
   char use_netrc;
   char follow_location;
   char unrestricted_auth;
-  char verbose;  
+  char verbose;
   char multipart_form_post;
   char enable_cookies;
-  
-  /* this is sometimes used as a buffer for a form data string,
-   * which we alloc in C and need to hang around for the call,
-   * and in case it's asked for before the next call.
-   */
-  VALUE postdata_buffer;  
+  char ignore_content_length;
+  struct curl_slist *curl_headers;
+  struct curl_slist *curl_ftp_commands;
+
+  int last_result; /* last result code from multi loop */
+
 } ruby_curl_easy;
 
 extern VALUE cCurlEasy;
 
+VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce);
+VALUE ruby_curl_easy_cleanup(VALUE self, ruby_curl_easy *rbce);
+
 void init_curb_easy();
 
 #endif

data/ext/curb_errors.c

@@ -1,7 +1,7 @@
 /* curb_errors.c - Ruby exception types for curl errors
- * Copyright (c)2006 Ross Bamford. 
+ * Copyright (c)2006 Ross Bamford.
  * Licensed under the Ruby License. See LICENSE for details.
- * 
+ *
  * $Id: curb_errors.c 10 2006-11-20 00:17:30Z roscopeco $
  */
 #include "curb_errors.h"
@@ -23,6 +23,7 @@ VALUE eCurlErrTelnetError;
 VALUE eCurlErrTFTPError;
 
 /* Specific libcurl errors */
+VALUE eCurlErrOK; /* not really an error but a return code */
 VALUE eCurlErrUnsupportedProtocol;
 VALUE eCurlErrFailedInit;
 VALUE eCurlErrMalformedURL;
@@ -98,263 +99,408 @@ VALUE eCurlErrTFTPUnknownID;
 VALUE eCurlErrTFTPFileExists;
 VALUE eCurlErrTFTPNoSuchUser;
 
+VALUE eCurlErrConvFailed;
+VALUE eCurlErrConvReqd;
+VALUE eCurlErrSSLCacertBadfile;
+VALUE eCurlErrRemoteFileNotFound;
+VALUE eCurlErrSSH;
+VALUE eCurlErrSSLShutdownFailed;
+VALUE eCurlErrAgain;
+VALUE eCurlErrSSLCRLBadfile;
+VALUE eCurlErrSSLIssuerError;
+
+/* multi errors */
+VALUE mCurlErrFailedInit;
+VALUE mCurlErrCallMultiPerform;
+VALUE mCurlErrBadHandle;
+VALUE mCurlErrBadEasyHandle;
+VALUE mCurlErrOutOfMemory;
+VALUE mCurlErrInternalError;
+VALUE mCurlErrBadSocket;
+VALUE mCurlErrUnknownOption;
+
 /* binding errors */
 VALUE eCurlErrInvalidPostField;
 
-/* rb_raise an approriate exception for the supplied CURLcode */
-void raise_curl_easy_error_exception(CURLcode code) {
+
+VALUE rb_curl_easy_error(CURLcode code) {
   VALUE exclz;
   const char *exmsg = NULL;
-  
+  VALUE results;
+
   switch (code) {
+    case CURLE_OK:                      /* 0 */
+      exclz = eCurlErrOK;
+      break;
     case CURLE_UNSUPPORTED_PROTOCOL:    /* 1 */
       exclz = eCurlErrUnsupportedProtocol;
-      break;      
+      break;
     case CURLE_FAILED_INIT:             /* 2 */
       exclz = eCurlErrFailedInit;
       break;
     case CURLE_URL_MALFORMAT:           /* 3 */
       exclz = eCurlErrMalformedURL;
-      break;          
+      break;
     case CURLE_URL_MALFORMAT_USER:      /* 4 (NOT USED) */
       exclz = eCurlErrMalformedURLUser;
-      break;          
+      break;
     case CURLE_COULDNT_RESOLVE_PROXY:   /* 5 */
       exclz = eCurlErrProxyResolution;
-      break;          
+      break;
     case CURLE_COULDNT_RESOLVE_HOST:    /* 6 */
       exclz = eCurlErrHostResolution;
-      break;          
+      break;
     case CURLE_COULDNT_CONNECT:         /* 7 */
       exclz = eCurlErrConnectFailed;
-      break;         
+      break;
     case CURLE_FTP_WEIRD_SERVER_REPLY:  /* 8 */
       exclz = eCurlErrFTPWierdReply;
-      break;      
+      break;
     case CURLE_FTP_ACCESS_DENIED:       /* 9 denied due to lack of access. */
       exclz = eCurlErrFTPAccessDenied;
-      break;          
+      break;
     case CURLE_FTP_USER_PASSWORD_INCORRECT: /* 10 */
       exclz = eCurlErrFTPBadPassword;
-      break;          
+      break;
     case CURLE_FTP_WEIRD_PASS_REPLY:    /* 11 */
       exclz = eCurlErrFTPWierdPassReply;
-      break;          
+      break;
     case CURLE_FTP_WEIRD_USER_REPLY:    /* 12 */
       exclz = eCurlErrFTPWierdUserReply;
-      break;            
+      break;
     case CURLE_FTP_WEIRD_PASV_REPLY:    /* 13 */
       exclz = eCurlErrFTPWierdPasvReply;
-      break;      
+      break;
     case CURLE_FTP_WEIRD_227_FORMAT:    /* 14 */
       exclz = eCurlErrFTPWierd227Format;
-      break;          
+      break;
     case CURLE_FTP_CANT_GET_HOST:       /* 15 */
       exclz = eCurlErrFTPCantGetHost;
-      break;      
+      break;
     case CURLE_FTP_CANT_RECONNECT:      /* 16 */
       exclz = eCurlErrFTPCantReconnect;
-      break;      
+      break;
     case CURLE_FTP_COULDNT_SET_BINARY:  /* 17 */
       exclz = eCurlErrFTPCouldntSetBinary;
-      break;      
+      break;
     case CURLE_PARTIAL_FILE:            /* 18 */
       exclz = eCurlErrPartialFile;
-      break;      
+      break;
     case CURLE_FTP_COULDNT_RETR_FILE:   /* 19 */
       exclz = eCurlErrFTPCouldntRetrFile;
-      break;      
+      break;
     case CURLE_FTP_WRITE_ERROR:         /* 20 */
       exclz = eCurlErrFTPWrite;
-      break;      
+      break;
     case CURLE_FTP_QUOTE_ERROR:         /* 21 */
       exclz = eCurlErrFTPQuote;
-      break;      
+      break;
     case CURLE_HTTP_RETURNED_ERROR:     /* 22 */
       exclz = eCurlErrHTTPFailed;
-      break;          
+      break;
     case CURLE_WRITE_ERROR:             /* 23 */
       exclz = eCurlErrWriteError;
-      break;          
+      break;
     case CURLE_MALFORMAT_USER:          /* 24 - NOT USED */
       exclz = eCurlErrMalformedUser;
-      break;          
+      break;
     case CURLE_FTP_COULDNT_STOR_FILE:   /* 25 - failed FTP upload */
       exclz = eCurlErrFTPCouldntStorFile;
-      break;          
+      break;
     case CURLE_READ_ERROR:              /* 26 - could open/read from file */
       exclz = eCurlErrReadError;
-      break;          
+      break;
     case CURLE_OUT_OF_MEMORY:           /* 27 */
       exclz = eCurlErrOutOfMemory;
-      break;          
+      break;
     case CURLE_OPERATION_TIMEOUTED:     /* 28 - the timeout time was reached */
       exclz = eCurlErrTimeout;
-      break;          
+      break;
     case CURLE_FTP_COULDNT_SET_ASCII:   /* 29 - TYPE A failed */
       exclz = eCurlErrFTPCouldntSetASCII;
-      break;          
+      break;
     case CURLE_FTP_PORT_FAILED:         /* 30 - FTP PORT operation failed */
       exclz = eCurlErrFTPPortFailed;
-      break;          
+      break;
     case CURLE_FTP_COULDNT_USE_REST:    /* 31 - the REST command failed */
       exclz = eCurlErrFTPCouldntUseRest;
-      break;          
+      break;
     case CURLE_FTP_COULDNT_GET_SIZE:    /* 32 - the SIZE command failed */
       exclz = eCurlErrFTPCouldntGetSize;
-      break;          
+      break;
     case CURLE_HTTP_RANGE_ERROR:        /* 33 - RANGE "command" didn't work */
       exclz = eCurlErrHTTPRange;
-      break;          
+      break;
     case CURLE_HTTP_POST_ERROR:         /* 34 */
       exclz = eCurlErrHTTPPost;
-      break;      
+      break;
     case CURLE_SSL_CONNECT_ERROR:       /* 35 - wrong when connecting with SSL */
       exclz = eCurlErrSSLConnectError;
-      break;      
+      break;
     case CURLE_BAD_DOWNLOAD_RESUME:     /* 36 - couldn't resume download */
       exclz = eCurlErrBadResume;
-      break;      
+      break;
     case CURLE_FILE_COULDNT_READ_FILE:  /* 37 */
       exclz = eCurlErrFileCouldntRead;
-      break;          
+      break;
     case CURLE_LDAP_CANNOT_BIND:        /* 38 */
       exclz = eCurlErrLDAPCouldntBind;
-      break;          
+      break;
     case CURLE_LDAP_SEARCH_FAILED:      /* 39 */
       exclz = eCurlErrLDAPSearchFailed;
-      break;      
+      break;
     case CURLE_LIBRARY_NOT_FOUND:       /* 40 */
       exclz = eCurlErrLibraryNotFound;
-      break;      
+      break;
     case CURLE_FUNCTION_NOT_FOUND:      /* 41 */
       exclz = eCurlErrFunctionNotFound;
-      break;      
+      break;
     case CURLE_ABORTED_BY_CALLBACK:     /* 42 */
       exclz = eCurlErrAbortedByCallback;
-      break;      
+      break;
     case CURLE_BAD_FUNCTION_ARGUMENT:   /* 43 */
       exclz = eCurlErrBadFunctionArgument;
-      break;      
+      break;
     case CURLE_BAD_CALLING_ORDER:       /* 44 - NOT USED */
       exclz = eCurlErrBadCallingOrder;
-      break;      
+      break;
     case CURLE_INTERFACE_FAILED:        /* 45 - CURLOPT_INTERFACE failed */
       exclz = eCurlErrInterfaceFailed;
-      break;      
+      break;
     case CURLE_BAD_PASSWORD_ENTERED:    /* 46 - NOT USED */
       exclz = eCurlErrBadPasswordEntered;
-      break;          
+      break;
     case CURLE_TOO_MANY_REDIRECTS:      /* 47 - catch endless re-direct loops */
       exclz = eCurlErrTooManyRedirects;
-      break;          
+      break;
     case CURLE_UNKNOWN_TELNET_OPTION:   /* 48 - User specified an unknown option */
       exclz = eCurlErrTelnetUnknownOption;
-      break;      
+      break;
     case CURLE_TELNET_OPTION_SYNTAX:    /* 49 - Malformed telnet option */
       exclz = eCurlErrTelnetBadOptionSyntax;
-      break;          
+      break;
     case CURLE_OBSOLETE:                /* 50 - NOT USED */
       exclz = eCurlErrObsolete;
-      break;          
+      break;
     case CURLE_SSL_PEER_CERTIFICATE:    /* 51 - peer's certificate wasn't ok */
       exclz = eCurlErrSSLPeerCertificate;
-      break;          
+      break;
     case CURLE_GOT_NOTHING:             /* 52 - when this is a specific error */
       exclz = eCurlErrGotNothing;
-      break;          
+      break;
     case CURLE_SSL_ENGINE_NOTFOUND:     /* 53 - SSL crypto engine not found */
       exclz = eCurlErrSSLEngineNotFound;
-      break;            
+      break;
     case CURLE_SSL_ENGINE_SETFAILED:    /* 54 - can not set SSL crypto engine as default */
       exclz = eCurlErrSSLEngineSetFailed;
-      break;          
+      break;
     case CURLE_SEND_ERROR:              /* 55 - failed sending network data */
       exclz = eCurlErrSendError;
-      break;      
+      break;
     case CURLE_RECV_ERROR:              /* 56 - failure in receiving network data */
       exclz = eCurlErrRecvError;
-      break;          
+      break;
     case CURLE_SHARE_IN_USE:            /* 57 - share is in use */
       exclz = eCurlErrShareInUse;
-      break;          
+      break;
     case CURLE_SSL_CERTPROBLEM:         /* 58 - problem with the local certificate */
       exclz = eCurlErrSSLCertificate;
-      break;          
+      break;
     case CURLE_SSL_CIPHER:              /* 59 - couldn't use specified cipher */
       exclz = eCurlErrSSLCipher;
-      break;          
+      break;
     case CURLE_SSL_CACERT:              /* 60 - problem with the CA cert (path?) */
       exclz = eCurlErrSSLCACertificate;
-      break;          
+      break;
     case CURLE_BAD_CONTENT_ENCODING:    /* 61 - Unrecognized transfer encoding */
       exclz = eCurlErrBadContentEncoding;
-      break;          
+      break;
     case CURLE_LDAP_INVALID_URL:        /* 62 - Invalid LDAP URL */
       exclz = eCurlErrLDAPInvalidURL;
-      break;          
+      break;
     case CURLE_FILESIZE_EXCEEDED:       /* 63 - Maximum file size exceeded */
       exclz = eCurlErrFileSizeExceeded;
-      break;          
+      break;
     case CURLE_FTP_SSL_FAILED:          /* 64 - Requested FTP SSL level failed */
       exclz = eCurlErrFTPSSLFailed;
-      break;          
+      break;
+#ifdef HAVE_CURLE_SEND_FAIL_REWIND
     case CURLE_SEND_FAIL_REWIND:        /* 65 - Sending the data requires a rewind that failed */
       exclz = eCurlErrSendFailedRewind;
-      break;          
+      break;
+#endif
+#ifdef HAVE_CURLE_SSL_ENGINE_INITFAILED
     case CURLE_SSL_ENGINE_INITFAILED:   /* 66 - failed to initialise ENGINE */
       exclz = eCurlErrSSLEngineInitFailed;
-      break;          
+      break;
+#endif
+#ifdef HAVE_CURLE_LOGIN_DENIED
     case CURLE_LOGIN_DENIED:            /* 67 - user, password or similar was not accepted and we failed to login */
       exclz = eCurlErrLoginDenied;
-      break;      
-      
+      break;
+#endif
+
       // recent additions, may not be present in all supported versions
-#ifdef CURLE_TFTP_NOTFOUND
+#ifdef HAVE_CURLE_TFTP_NOTFOUND
     case CURLE_TFTP_NOTFOUND:           /* 68 - file not found on server */
       exclz = eCurlErrTFTPNotFound;
-      break;          
+      break;
 #endif
-#ifdef CURLE_TFTP_PERM      
+#ifdef HAVE_CURLE_TFTP_PERM
     case CURLE_TFTP_PERM:               /* 69 - permission problem on server */
       exclz = eCurlErrTFTPPermission;
       break;
 #endif
-#ifdef CURLE_TFTP_DISKFULL
+#ifdef HAVE_CURLE_TFTP_DISKFULL
     case CURLE_TFTP_DISKFULL:           /* 70 - out of disk space on server */
       exclz = eCurlErrTFTPDiskFull;
-      break;    
+      break;
 #endif
-#ifdef CURLE_TFTP_ILLEGAL
+#ifdef HAVE_CURLE_TFTP_ILLEGAL
     case CURLE_TFTP_ILLEGAL:            /* 71 - Illegal TFTP operation */
       exclz = eCurlErrTFTPIllegalOperation;
-      break;    
-#endif     
-#ifdef CURLE_TFTP_UNKNOWNID
+      break;
+#endif
+#ifdef HAVE_CURLE_TFTP_UNKNOWNID
     case CURLE_TFTP_UNKNOWNID:          /* 72 - Unknown transfer ID */
       exclz = eCurlErrTFTPUnknownID;
       break;
 #endif
-#ifdef CURLE_TFTP_EXISTS
+#ifdef HAVE_CURLE_TFTP_EXISTS
     case CURLE_TFTP_EXISTS:             /* 73 - File already exists */
       exclz = eCurlErrTFTPFileExists;
-      break;    
+      break;
 #endif
-#ifdef CURLE_TFTP_NOSUCHUSER
+#ifdef HAVE_CURLE_TFTP_NOSUCHUSER
     case CURLE_TFTP_NOSUCHUSER:         /* 74 - No such user */
       exclz = eCurlErrTFTPNotFound;
       break;
+#endif
+#ifdef HAVE_CURLE_CONV_FAILED
+    case CURLE_CONV_FAILED:             /* 75 - conversion failed */
+      exclz = eCurlErrConvFailed;
+      break;
+#endif
+#ifdef HAVE_CURLE_CONV_REQD
+    case 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 */
+      exclz = eCurlErrConvReqd;
+      break;
+#endif
+#ifdef HAVE_CURLE_SSL_CACERT_BADFILE
+    case CURLE_SSL_CACERT_BADFILE:      /* 77 - could not load CACERT file, missing
+                                                or wrong format */
+      exclz = eCurlErrSSLCacertBadfile;
+      break;
+#endif
+#ifdef  HAVE_CURLE_REMOTE_FILE_NOT_FOUND
+    case CURLE_REMOTE_FILE_NOT_FOUND:   /* 78 - remote file not found */
+      exclz = eCurlErrRemoteFileNotFound;
+      break;
+#endif
+#ifdef  HAVE_CURLE_SSH
+    case CURLE_SSH:                     /* 79 - error from the SSH layer, somewhat
+                                    generic so the error message will be of
+                                    interest when this has happened */
+      exclz = eCurlErrSSH;
+      break;
+#endif
+#ifdef  HAVE_CURLE_SSL_SHUTDOWN_FAILED
+    case CURLE_SSL_SHUTDOWN_FAILED:     /* 80 - Failed to shut down the SSL
+                                    connection */
+      exclz = eCurlErrSSLShutdownFailed;
+      break;
+#endif
+#ifdef  HAVE_CURLE_AGAIN
+    case CURLE_AGAIN:                   /* 81 - socket is not ready for send/recv,
+                                    wait till it's ready and try again (Added
+                                    in 7.18.2) */
+      exclz = eCurlErrAgain;
+      break;
+#endif
+#ifdef  HAVE_CURLE_SSL_CRL_BADFILE
+    case CURLE_SSL_CRL_BADFILE:         /* 82 - could not load CRL file, missing or
+                                    wrong format (Added in 7.19.0) */
+      exclz = eCurlErrSSLCRLBadfile;
+      break;
+#endif
+#ifdef  HAVE_CURLE_SSL_ISSUER_ERROR
+    case CURLE_SSL_ISSUER_ERROR:        /* 83 - Issuer check failed.  (Added in
+                                    7.19.0) */
+      exclz = eCurlErrSSLIssuerError;
+      break;
 #endif
     default:
       exclz = eCurlErrError;
       exmsg = "Unknown error result from libcurl";
   }
-  
+
   if (!exmsg) {
     exmsg = curl_easy_strerror(code);
   }
-  
-  rb_raise(exclz, exmsg);
+
+  results = rb_ary_new2(2);
+  rb_ary_push(results, exclz);
+  rb_ary_push(results, rb_str_new2(exmsg));
+  return results;
+}
+/* rb_raise an approriate exception for the supplied CURLcode */
+void raise_curl_easy_error_exception(CURLcode code) {
+  VALUE obj = rb_curl_easy_error(code);
+  rb_raise(rb_ary_entry(obj,0), RSTRING_PTR(rb_ary_entry(obj,1)));
+}
+VALUE rb_curl_multi_error(CURLMcode code) {
+  VALUE exclz;
+  const char *exmsg = NULL;
+  VALUE results;
+
+  switch(code) {
+    case CURLM_CALL_MULTI_PERFORM: /* -1 */
+      exclz = mCurlErrCallMultiPerform;
+      break;
+    case CURLM_BAD_HANDLE: /* 1 */
+      exclz = mCurlErrBadHandle;
+      break;
+    case CURLM_BAD_EASY_HANDLE: /* 2 */
+      exclz = mCurlErrBadEasyHandle;
+      break;
+    case CURLM_OUT_OF_MEMORY: /* 3 */
+      exclz = mCurlErrOutOfMemory;
+      break;
+    case CURLM_INTERNAL_ERROR: /* 4 */
+      exclz = mCurlErrInternalError;
+      break;
+#if HAVE_CURLM_BAD_SOCKET
+    case CURLM_BAD_SOCKET: /* 5 */
+      exclz = mCurlErrBadSocket;
+      break;
+#endif
+#if HAVE_CURLM_UNKNOWN_OPTION
+    case CURLM_UNKNOWN_OPTION: /* 6 */
+      exclz = mCurlErrUnknownOption;
+      break;
+#endif
+    default:
+      exclz = eCurlErrError;
+      exmsg = "Unknown error result from libcurl";
+  }
+
+  if (!exmsg) {
+    exmsg = curl_multi_strerror(code);
+  }
+
+  results = rb_ary_new2(2);
+  rb_ary_push(results, exclz);
+  rb_ary_push(results, rb_str_new2(exmsg));
+
+  return results;
+}
+void raise_curl_multi_error_exception(CURLMcode code) {
+  VALUE obj = rb_curl_multi_error(code);
+  rb_raise(rb_ary_entry(obj,0), RSTRING_PTR(rb_ary_entry(obj,1)));
 }
 
 void init_curb_errors() {
@@ -367,7 +513,8 @@ void init_curb_errors() {
   eCurlErrLDAPError = rb_define_class_under(mCurlErr, "LDAPError", eCurlErrError);
   eCurlErrTelnetError = rb_define_class_under(mCurlErr, "TelnetError", eCurlErrError);
   eCurlErrTFTPError = rb_define_class_under(mCurlErr, "TFTPError", eCurlErrError);
-    
+
+  eCurlErrOK = rb_define_class_under(mCurlErr, "CurlOK", eCurlErrError);
   eCurlErrUnsupportedProtocol = rb_define_class_under(mCurlErr, "UnsupportedProtocolError", eCurlErrError);
   eCurlErrFailedInit = rb_define_class_under(mCurlErr, "FailedInitError", eCurlErrError);
   eCurlErrMalformedURL = rb_define_class_under(mCurlErr, "MalformedURLError", eCurlErrError);
@@ -411,7 +558,7 @@ void init_curb_errors() {
 
   eCurlErrHTTPRange = rb_define_class_under(mCurlErr, "HTTPRangeError", eCurlErrHTTPError);
   eCurlErrHTTPPost = rb_define_class_under(mCurlErr, "HTTPPostError", eCurlErrHTTPError);
-  
+
   eCurlErrSSLConnectError = rb_define_class_under(mCurlErr, "SSLConnectError", eCurlErrError);
   eCurlErrBadResume = rb_define_class_under(mCurlErr, "BadResumeError", eCurlErrError);
 
@@ -432,7 +579,7 @@ void init_curb_errors() {
 
   eCurlErrTelnetUnknownOption = rb_define_class_under(mCurlErr, "UnknownOptionError", eCurlErrTelnetError);
   eCurlErrTelnetBadOptionSyntax = rb_define_class_under(mCurlErr, "BadOptionSyntaxError", eCurlErrTelnetError);
-  
+
   eCurlErrObsolete = rb_define_class_under(mCurlErr, "ObsoleteError", eCurlErrError);
   eCurlErrSSLPeerCertificate = rb_define_class_under(mCurlErr, "SSLPeerCertificateError", eCurlErrError);
   eCurlErrGotNothing = rb_define_class_under(mCurlErr, "GotNothingError", eCurlErrError);
@@ -444,10 +591,29 @@ void init_curb_errors() {
   eCurlErrRecvError = rb_define_class_under(mCurlErr, "RecvError", eCurlErrError);
   eCurlErrShareInUse = rb_define_class_under(mCurlErr, "ShareInUseError", eCurlErrError);
 
+  eCurlErrConvFailed  = rb_define_class_under(mCurlErr, "ConvFailed", eCurlErrError);
+  eCurlErrConvReqd    = rb_define_class_under(mCurlErr, "ConvReqd", eCurlErrError);
+  eCurlErrRemoteFileNotFound  = rb_define_class_under(mCurlErr, "RemoteFileNotFound", eCurlErrError);
+  eCurlErrAgain  = rb_define_class_under(mCurlErr, "Again", eCurlErrError);
+
   eCurlErrSSLCertificate = rb_define_class_under(mCurlErr, "SSLCertificateError", eCurlErrError);
   eCurlErrSSLCipher = rb_define_class_under(mCurlErr, "SSLCypherError", eCurlErrError);
   eCurlErrSSLCACertificate = rb_define_class_under(mCurlErr, "SSLCACertificateError", eCurlErrError);
   eCurlErrBadContentEncoding = rb_define_class_under(mCurlErr, "BadContentEncodingError", eCurlErrError);
+  eCurlErrSSLCacertBadfile   = rb_define_class_under(mCurlErr, "SSLCaertBadFile", eCurlErrError);
+  eCurlErrSSLCRLBadfile      = rb_define_class_under(mCurlErr, "SSLCRLBadfile", eCurlErrError);
+  eCurlErrSSLIssuerError     = rb_define_class_under(mCurlErr, "SSLIssuerError", eCurlErrError);
+  eCurlErrSSLShutdownFailed  = rb_define_class_under(mCurlErr, "SSLShutdownFailed", eCurlErrError);
+  eCurlErrSSH                = rb_define_class_under(mCurlErr, "SSH", eCurlErrError);
+
+  mCurlErrFailedInit         = rb_define_class_under(mCurlErr, "MultiInitError", eCurlErrError);
+  mCurlErrCallMultiPerform   = rb_define_class_under(mCurlErr, "MultiPerform", eCurlErrError);
+  mCurlErrBadHandle          = rb_define_class_under(mCurlErr, "MultiBadHandle", eCurlErrError);
+  mCurlErrBadEasyHandle      = rb_define_class_under(mCurlErr, "MultiBadEasyHandle", eCurlErrError);
+  mCurlErrOutOfMemory        = rb_define_class_under(mCurlErr, "MultiOutOfMemory", eCurlErrError);
+  mCurlErrInternalError      = rb_define_class_under(mCurlErr, "MultiInternalError", eCurlErrError);
+  mCurlErrBadSocket          = rb_define_class_under(mCurlErr, "MultiBadSocket", eCurlErrError);
+  mCurlErrUnknownOption      = rb_define_class_under(mCurlErr, "MultiUnknownOption", eCurlErrError);
 
   eCurlErrLDAPInvalidURL = rb_define_class_under(mCurlErr, "InvalidLDAPURLError", eCurlErrLDAPError);
 
@@ -466,6 +632,6 @@ void init_curb_errors() {
   eCurlErrTFTPUnknownID = rb_define_class_under(mCurlErr, "UnknownIDError", eCurlErrTFTPError);
   eCurlErrTFTPFileExists = rb_define_class_under(mCurlErr, "FileExistsError", eCurlErrTFTPError);
   eCurlErrTFTPNoSuchUser = rb_define_class_under(mCurlErr, "NoSuchUserError", eCurlErrTFTPError);
-  
+
   eCurlErrInvalidPostField = rb_define_class_under(mCurlErr, "InvalidPostFieldError", eCurlErrError);
-}  
+}