curb 0.8.5 → 1.3.6

data/ext/curb_easy.h

@@ -11,6 +11,18 @@
 
 #include <curl/easy.h>
 
+#define CURB_NETWORK_POLICY_NONE 0
+#define CURB_NETWORK_POLICY_PUBLIC 1
+
+#define CURB_CIDR_FAMILY_IPV4 4
+#define CURB_CIDR_FAMILY_IPV6 6
+
+typedef struct {
+  unsigned char family;
+  unsigned char prefix_bits;
+  unsigned char address[16];
+} curb_cidr_rule;
+
 #ifdef CURL_VERSION_SSL
 #if LIBCURL_VERSION_NUM >= 0x070b00
 #  if LIBCURL_VERSION_NUM <= 0x071004
@@ -36,8 +48,14 @@ typedef struct {
   /* The handler */
   CURL *curl;
 
+  /* Buffer for error details from CURLOPT_ERRORBUFFER */
+  char err_buf[CURL_ERROR_SIZE];
+  char unsafe_destination_error[CURL_ERROR_SIZE];
+
+  VALUE self; /* owning Ruby object */
   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 */
+  VALUE callback_error; /* preserves body/header callback exceptions without mutating the Ruby object */
 
   /* Other opts */
   unsigned short local_port;       // 0 is no port
@@ -48,15 +66,21 @@ typedef struct {
   long proxy_auth_types;
   long max_redirs;
   unsigned long timeout;
+  unsigned long timeout_ms;
   unsigned long connect_timeout;
+  unsigned long connect_timeout_ms;
   long dns_cache_timeout;
   unsigned long ftp_response_timeout;
   long low_speed_limit;
   long low_speed_time;
+  long max_send_speed_large;
+  long max_recv_speed_large;
   long ssl_version;
   long use_ssl;
   long ftp_filemethod;
+  long http_version;
   unsigned short resolve_mode;
+  unsigned short network_policy;
 
   /* bool flags */
   char proxy_tunnel;
@@ -70,20 +94,38 @@ typedef struct {
   char verbose;
   char multipart_form_post;
   char enable_cookies;
+  char cookielist_engine_enabled; /* track if CURLOPT_COOKIELIST was used with a non-command to enable engine */
   char ignore_content_length;
   char callback_active;
+  char unsafe_destination_blocked;
+  char allow_proxy;
+  char allow_unix_socket;
+  char forbid_reuse_set;
+  unsigned int native_active;
+  long forbid_reuse;
 
   struct curl_slist *curl_headers;
+  struct curl_slist *curl_proxy_headers;
   struct curl_slist *curl_ftp_commands;
+  struct curl_slist *curl_resolve;
+  struct curl_slist *curl_connect_to;
+  curb_cidr_rule *network_allowed_cidr_rules;
+  char **network_allowed_hosts;
 
+  unsigned long multi_attachment_generation;
+  curl_off_t downloaded_body_bytes;
+  size_t network_allowed_cidr_rule_count;
+  size_t network_allowed_host_count;
   int last_result; /* last result code from multi loop */
 
 } ruby_curl_easy;
 
 extern VALUE cCurlEasy;
+extern const rb_data_type_t ruby_curl_easy_data_type;
 
 VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce);
 VALUE ruby_curl_easy_cleanup(VALUE self, ruby_curl_easy *rbce);
+VALUE rb_curl_easy_take_callback_error(ruby_curl_easy *rbce);
 
 void init_curb_easy();
 

data/ext/curb_errors.c

@@ -21,6 +21,7 @@ VALUE eCurlErrFileError;
 VALUE eCurlErrLDAPError;
 VALUE eCurlErrTelnetError;
 VALUE eCurlErrTFTPError;
+VALUE eCurlErrRTSPError;
 
 /* Specific libcurl errors */
 VALUE eCurlErrOK; /* not really an error but a return code */
@@ -32,13 +33,13 @@ VALUE eCurlErrNotBuiltIn;
 VALUE eCurlErrProxyResolution;
 VALUE eCurlErrHostResolution;
 VALUE eCurlErrConnectFailed;
-VALUE eCurlErrFTPWierdReply;
+VALUE eCurlErrFTPWeirdReply;
 VALUE eCurlErrFTPAccessDenied;
 VALUE eCurlErrFTPBadPassword;
-VALUE eCurlErrFTPWierdPassReply;
-VALUE eCurlErrFTPWierdUserReply;
-VALUE eCurlErrFTPWierdPasvReply;
-VALUE eCurlErrFTPWierd227Format;
+VALUE eCurlErrFTPWeirdPassReply;
+VALUE eCurlErrFTPWeirdUserReply;
+VALUE eCurlErrFTPWeirdPasvReply;
+VALUE eCurlErrFTPWeird227Format;
 VALUE eCurlErrFTPCantGetHost;
 VALUE eCurlErrFTPCantReconnect;
 VALUE eCurlErrFTPCouldntSetBinary;
@@ -109,6 +110,7 @@ VALUE eCurlErrSSLShutdownFailed;
 VALUE eCurlErrAgain;
 VALUE eCurlErrSSLCRLBadfile;
 VALUE eCurlErrSSLIssuerError;
+VALUE eCurlErrUnsafeDestination;
 
 /* multi errors */
 VALUE mCurlErrFailedInit;
@@ -118,12 +120,27 @@ VALUE mCurlErrBadEasyHandle;
 VALUE mCurlErrOutOfMemory;
 VALUE mCurlErrInternalError;
 VALUE mCurlErrBadSocket;
+#ifdef HAVE_CURLM_ADDED_ALREADY
+VALUE mCurlErrAddedAlready;
+#endif
 VALUE mCurlErrUnknownOption;
 
 /* binding errors */
 VALUE eCurlErrInvalidPostField;
 
 
+/* new errors */
+VALUE eCurlErrFTPPRETFailed;
+VALUE eCurlErrRTSPCseqError;
+VALUE eCurlErrRTSPSessionError;
+VALUE eCurlErrFTPBadFileList;
+VALUE eCurlErrChunkFailed;
+VALUE eCurlErrNoConnectionAvailable;
+VALUE eCurlErrSSLPinnedPubKeyNotMatch;
+VALUE eCurlErrSSLInvalidCertStatus;
+VALUE eCurlErrHTTP2Stream;
+
+
 VALUE rb_curl_easy_error(CURLcode code) {
   VALUE exclz;
   const char *exmsg = NULL;
@@ -161,7 +178,7 @@ VALUE rb_curl_easy_error(CURLcode code) {
       exclz = eCurlErrConnectFailed;
       break;
     case CURLE_FTP_WEIRD_SERVER_REPLY:  /* 8 */
-      exclz = eCurlErrFTPWierdReply;
+      exclz = eCurlErrFTPWeirdReply;
       break;
     case CURLE_FTP_ACCESS_DENIED:       /* 9 denied due to lack of access. */
       exclz = eCurlErrFTPAccessDenied;
@@ -170,16 +187,16 @@ VALUE rb_curl_easy_error(CURLcode code) {
       exclz = eCurlErrFTPBadPassword;
       break;
     case CURLE_FTP_WEIRD_PASS_REPLY:    /* 11 */
-      exclz = eCurlErrFTPWierdPassReply;
+      exclz = eCurlErrFTPWeirdPassReply;
       break;
     case CURLE_FTP_WEIRD_USER_REPLY:    /* 12 */
-      exclz = eCurlErrFTPWierdUserReply;
+      exclz = eCurlErrFTPWeirdUserReply;
       break;
     case CURLE_FTP_WEIRD_PASV_REPLY:    /* 13 */
-      exclz = eCurlErrFTPWierdPasvReply;
+      exclz = eCurlErrFTPWeirdPasvReply;
       break;
     case CURLE_FTP_WEIRD_227_FORMAT:    /* 14 */
-      exclz = eCurlErrFTPWierd227Format;
+      exclz = eCurlErrFTPWeird227Format;
       break;
     case CURLE_FTP_CANT_GET_HOST:       /* 15 */
       exclz = eCurlErrFTPCantGetHost;
@@ -291,9 +308,11 @@ VALUE rb_curl_easy_error(CURLcode code) {
       exclz = eCurlErrObsolete;
       break;
 #endif
+#if LIBCURL_VERSION_NUM < 0x073e00
     case CURLE_SSL_PEER_CERTIFICATE:    /* 51 - peer's certificate wasn't ok */
       exclz = eCurlErrSSLPeerCertificate;
       break;
+#endif
     case CURLE_GOT_NOTHING:             /* 52 - when this is a specific error */
       exclz = eCurlErrGotNothing;
       break;
@@ -318,8 +337,13 @@ VALUE rb_curl_easy_error(CURLcode code) {
     case CURLE_SSL_CIPHER:              /* 59 - couldn't use specified cipher */
       exclz = eCurlErrSSLCipher;
       break;
+#if LIBCURL_VERSION_NUM >= 0x073e00
+    case CURLE_PEER_FAILED_VERIFICATION:              /* 60 - problem with the CA cert (path?) */
+      exclz = eCurlErrSSLPeerCertificate;
+#else
     case CURLE_SSL_CACERT:              /* 60 - problem with the CA cert (path?) */
       exclz = eCurlErrSSLCACertificate;
+#endif
       break;
     case CURLE_BAD_CONTENT_ENCODING:    /* 61 - Unrecognized transfer encoding */
       exclz = eCurlErrBadContentEncoding;
@@ -442,6 +466,61 @@ VALUE rb_curl_easy_error(CURLcode code) {
       exclz = eCurlErrSSLIssuerError;
       break;
 #endif
+
+#ifdef  HAVE_CURLE_FTP_PRET_FAILED
+    case CURLE_FTP_PRET_FAILED:  /* 84 */
+      exclz = eCurlErrFTPPRETFailed;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_RTSP_CSEQ_ERROR
+    case CURLE_RTSP_CSEQ_ERROR:  /* 85 */
+      exclz = eCurlErrRTSPCseqError;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_RTSP_SESSION_ERROR
+    case CURLE_RTSP_SESSION_ERROR:  /* 86 */
+      exclz = eCurlErrRTSPSessionError;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_FTP_BAD_FILE_LIST
+    case CURLE_FTP_BAD_FILE_LIST:  /* 87 */
+      exclz = eCurlErrFTPBadFileList;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_CHUNK_FAILED
+    case CURLE_CHUNK_FAILED:  /* 88 */
+      exclz = eCurlErrChunkFailed;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_NO_CONNECTION_AVAILABLE
+    case CURLE_NO_CONNECTION_AVAILABLE:  /* 89 */
+      exclz = eCurlErrNoConnectionAvailable;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_SSL_PINNEDPUBKEYNOTMATCH
+    case CURLE_SSL_PINNEDPUBKEYNOTMATCH:  /* 90 */
+      exclz = eCurlErrSSLPinnedPubKeyNotMatch;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_SSL_INVALIDCERTSTATUS
+    case CURLE_SSL_INVALIDCERTSTATUS:  /* 91 */
+      exclz = eCurlErrSSLInvalidCertStatus;
+      break;
+#endif
+
+#ifdef  HAVE_CURLE_HTTP2_STREAM
+    case CURLE_HTTP2_STREAM:  /* 92 */
+      exclz = eCurlErrHTTP2Stream;
+      break;
+#endif
+
     default:
       exclz = eCurlErrError;
       exmsg = "Unknown error result from libcurl";
@@ -483,15 +562,20 @@ VALUE rb_curl_multi_error(CURLMcode code) {
     case CURLM_INTERNAL_ERROR: /* 4 */
       exclz = mCurlErrInternalError;
       break;
-#if HAVE_CURLM_BAD_SOCKET
+#ifdef HAVE_CURLM_BAD_SOCKET
     case CURLM_BAD_SOCKET: /* 5 */
       exclz = mCurlErrBadSocket;
       break;
 #endif
-#if HAVE_CURLM_UNKNOWN_OPTION
+#ifdef HAVE_CURLM_UNKNOWN_OPTION
     case CURLM_UNKNOWN_OPTION: /* 6 */
       exclz = mCurlErrUnknownOption;
       break;
+#endif
+#ifdef HAVE_CURLM_ADDED_ALREADY
+    case CURLM_ADDED_ALREADY: /* 7 */
+      exclz = mCurlErrAddedAlready;
+      break;
 #endif
     default:
       exclz = eCurlErrError;
@@ -524,6 +608,7 @@ 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);
+  eCurlErrRTSPError = rb_define_class_under(mCurlErr, "RTSPError", eCurlErrError);
 
   eCurlErrOK = rb_define_class_under(mCurlErr, "CurlOK", eCurlErrError);
   eCurlErrUnsupportedProtocol = rb_define_class_under(mCurlErr, "UnsupportedProtocolError", eCurlErrError);
@@ -535,13 +620,13 @@ void init_curb_errors() {
   eCurlErrHostResolution = rb_define_class_under(mCurlErr, "HostResolutionError", eCurlErrError);
   eCurlErrConnectFailed = rb_define_class_under(mCurlErr, "ConnectionFailedError", eCurlErrError);
 
-  eCurlErrFTPWierdReply = rb_define_class_under(mCurlErr, "WierdReplyError", eCurlErrFTPError);
+  eCurlErrFTPWeirdReply = rb_define_class_under(mCurlErr, "WeirdReplyError", eCurlErrFTPError);
   eCurlErrFTPAccessDenied = rb_define_class_under(mCurlErr, "AccessDeniedError", eCurlErrFTPError);
-  eCurlErrFTPBadPassword = rb_define_class_under(mCurlErr, "BadBasswordError", eCurlErrFTPError);
-  eCurlErrFTPWierdPassReply = rb_define_class_under(mCurlErr, "WierdPassReplyError", eCurlErrFTPError);
-  eCurlErrFTPWierdUserReply = rb_define_class_under(mCurlErr, "WierdUserReplyError", eCurlErrFTPError);
-  eCurlErrFTPWierdPasvReply = rb_define_class_under(mCurlErr, "WierdPasvReplyError", eCurlErrFTPError);
-  eCurlErrFTPWierd227Format = rb_define_class_under(mCurlErr, "Wierd227FormatError", eCurlErrFTPError);
+  eCurlErrFTPBadPassword = rb_define_class_under(mCurlErr, "BadPasswordError", eCurlErrFTPError);
+  eCurlErrFTPWeirdPassReply = rb_define_class_under(mCurlErr, "WeirdPassReplyError", eCurlErrFTPError);
+  eCurlErrFTPWeirdUserReply = rb_define_class_under(mCurlErr, "WeirdUserReplyError", eCurlErrFTPError);
+  eCurlErrFTPWeirdPasvReply = rb_define_class_under(mCurlErr, "WeirdPasvReplyError", eCurlErrFTPError);
+  eCurlErrFTPWeird227Format = rb_define_class_under(mCurlErr, "Weird227FormatError", eCurlErrFTPError);
   eCurlErrFTPCantGetHost = rb_define_class_under(mCurlErr, "CantGetHostError", eCurlErrFTPError);
   eCurlErrFTPCantReconnect = rb_define_class_under(mCurlErr, "CantReconnectError", eCurlErrFTPError);
   eCurlErrFTPCouldntSetBinary = rb_define_class_under(mCurlErr, "CouldntSetBinaryError", eCurlErrFTPError);
@@ -615,6 +700,7 @@ void init_curb_errors() {
   eCurlErrSSLCacertBadfile   = rb_define_class_under(mCurlErr, "SSLCaertBadFile", eCurlErrError);
   eCurlErrSSLCRLBadfile      = rb_define_class_under(mCurlErr, "SSLCRLBadfile", eCurlErrError);
   eCurlErrSSLIssuerError     = rb_define_class_under(mCurlErr, "SSLIssuerError", eCurlErrError);
+  eCurlErrUnsafeDestination  = rb_define_class_under(mCurlErr, "UnsafeDestinationError", eCurlErrError);
   eCurlErrSSLShutdownFailed  = rb_define_class_under(mCurlErr, "SSLShutdownFailed", eCurlErrError);
   eCurlErrSSH                = rb_define_class_under(mCurlErr, "SSH", eCurlErrError);
 
@@ -625,6 +711,9 @@ void init_curb_errors() {
   mCurlErrOutOfMemory        = rb_define_class_under(mCurlErr, "MultiOutOfMemory", eCurlErrError);
   mCurlErrInternalError      = rb_define_class_under(mCurlErr, "MultiInternalError", eCurlErrError);
   mCurlErrBadSocket          = rb_define_class_under(mCurlErr, "MultiBadSocket", eCurlErrError);
+#ifdef HAVE_CURLM_ADDED_ALREADY
+  mCurlErrAddedAlready       = rb_define_class_under(mCurlErr, "MultiAddedAlready", eCurlErrError);
+#endif
   mCurlErrUnknownOption      = rb_define_class_under(mCurlErr, "MultiUnknownOption", eCurlErrError);
 
   eCurlErrLDAPInvalidURL = rb_define_class_under(mCurlErr, "InvalidLDAPURLError", eCurlErrLDAPError);
@@ -646,4 +735,14 @@ void init_curb_errors() {
   eCurlErrTFTPNoSuchUser = rb_define_class_under(mCurlErr, "NoSuchUserError", eCurlErrTFTPError);
 
   eCurlErrInvalidPostField = rb_define_class_under(mCurlErr, "InvalidPostFieldError", eCurlErrError);
+
+  eCurlErrFTPPRETFailed = rb_define_class_under(mCurlErr, "PPRETFailedError", eCurlErrFTPError);
+  eCurlErrRTSPCseqError = rb_define_class_under(mCurlErr, "CseqError", eCurlErrRTSPError);
+  eCurlErrRTSPSessionError = rb_define_class_under(mCurlErr, "SessionError", eCurlErrRTSPError);
+  eCurlErrFTPBadFileList = rb_define_class_under(mCurlErr, "BadFileListError", eCurlErrFTPError);
+  eCurlErrChunkFailed = rb_define_class_under(mCurlErr, "ChunkFailedError", eCurlErrError);
+  eCurlErrNoConnectionAvailable = rb_define_class_under(mCurlErr, "NoConnectionAvailableError", eCurlErrError);
+  eCurlErrSSLPinnedPubKeyNotMatch = rb_define_class_under(mCurlErr, "SSLPinnedPubKeyNotMatchError", eCurlErrError);
+  eCurlErrSSLInvalidCertStatus = rb_define_class_under(mCurlErr, "SSLInvalidCertStatusError", eCurlErrError);
+  eCurlErrHTTP2Stream = rb_define_class_under(mCurlErr, "HTTP2StreamError", eCurlErrHTTPError);
 }

data/ext/curb_errors.h

@@ -30,13 +30,13 @@ extern VALUE eCurlErrMalformedURLUser;
 extern VALUE eCurlErrProxyResolution;
 extern VALUE eCurlErrHostResolution;
 extern VALUE eCurlErrConnectFailed;
-extern VALUE eCurlErrFTPWierdReply;
+extern VALUE eCurlErrFTPWeirdReply;
 extern VALUE eCurlErrFTPAccessDenied;
 extern VALUE eCurlErrFTPBadPassword;
-extern VALUE eCurlErrFTPWierdPassReply;
-extern VALUE eCurlErrFTPWierdUserReply;
-extern VALUE eCurlErrFTPWierdPasvReply;
-extern VALUE eCurlErrFTPWierd227Format;
+extern VALUE eCurlErrFTPWeirdPassReply;
+extern VALUE eCurlErrFTPWeirdUserReply;
+extern VALUE eCurlErrFTPWeirdPasvReply;
+extern VALUE eCurlErrFTPWeird227Format;
 extern VALUE eCurlErrFTPCantGetHost;
 extern VALUE eCurlErrFTPCantReconnect;
 extern VALUE eCurlErrFTPCouldntSetBinary;
@@ -106,6 +106,7 @@ extern VALUE eCurlErrSSLShutdownFailed;
 extern VALUE eCurlErrAgain;
 extern VALUE eCurlErrSSLCRLBadfile;
 extern VALUE eCurlErrSSLIssuerError;
+extern VALUE eCurlErrUnsafeDestination;
 
 /* multi errors */
 extern VALUE mCurlErrFailedInit;
@@ -116,6 +117,9 @@ extern VALUE mCurlErrOutOfMemory;
 extern VALUE mCurlErrInternalError;
 extern VALUE mCurlErrBadSocket;
 extern VALUE mCurlErrUnknownOption;
+#ifdef HAVE_CURLM_ADDED_ALREADY
+extern VALUE mCurlErrAddedAlready;
+#endif
 
 /* binding errors */
 extern VALUE eCurlErrInvalidPostField;

data/ext/curb_macros.h

@@ -25,7 +25,7 @@
 #define CURB_OBJECT_SETTER(type, attr)                              \
             type *ptr;                                              \
                                                                     \
-            Data_Get_Struct(self, type, ptr);                       \
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
             ptr->attr = attr;                                       \
                                                                     \
             return attr;
@@ -34,14 +34,14 @@
 #define CURB_OBJECT_GETTER(type, attr)                              \
             type *ptr;                                              \
                                                                     \
-            Data_Get_Struct(self, type, ptr);                       \
-            return ptr->attr; 
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            return ptr->attr;
 
 /* setter for anything that stores a ruby VALUE in the struct opts hash */
 #define CURB_OBJECT_HSETTER(type, attr)                             \
             type *ptr;                                              \
                                                                     \
-            Data_Get_Struct(self, type, ptr);                       \
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
             rb_hash_aset(ptr->opts, rb_easy_hkey(#attr), attr);       \
                                                                     \
             return attr;
@@ -50,13 +50,13 @@
 #define CURB_OBJECT_HGETTER(type, attr)                              \
             type *ptr;                                              \
                                                                     \
-            Data_Get_Struct(self, type, ptr);                       \
-            return rb_hash_aref(ptr->opts, rb_easy_hkey(#attr)); 
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
+            return rb_hash_aref(ptr->opts, rb_easy_hkey(#attr));
 
 /* setter for bool flags */
 #define CURB_BOOLEAN_SETTER(type, attr)                             \
             type *ptr;                                              \
-            Data_Get_Struct(self, type, ptr);                       \
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
                                                                     \
             if (attr == Qnil || attr == Qfalse) {                   \
               ptr->attr = 0;                                        \
@@ -69,7 +69,7 @@
 /* getter for bool flags */
 #define CURB_BOOLEAN_GETTER(type, attr)                             \
             type *ptr;                                              \
-            Data_Get_Struct(self, type, ptr);                       \
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
                                                                     \
             return((ptr->attr) ? Qtrue : Qfalse);
 
@@ -78,7 +78,7 @@
             type *ptr;                                              \
             VALUE oldproc;                                          \
                                                                     \
-            Data_Get_Struct(self, type, ptr);                       \
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
                                                                     \
             oldproc = ptr->handler;                                 \
             rb_scan_args(argc, argv, "0&", &ptr->handler);          \
@@ -90,7 +90,7 @@
             type *ptr;                                                  \
             VALUE oldproc, newproc;                                     \
                                                                         \
-            Data_Get_Struct(self, type, ptr);                           \
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr);   \
                                                                         \
             oldproc = rb_hash_aref(ptr->opts, rb_easy_hkey(#handler));   \
             rb_scan_args(argc, argv, "0&", &newproc);                   \
@@ -99,39 +99,39 @@
                                                                         \
             return oldproc;
 
-/* setter for numerics that are kept in c ints */
+/* setter for numerics that are kept in c longs */
 #define CURB_IMMED_SETTER(type, attr, nilval)                       \
             type *ptr;                                              \
                                                                     \
-            Data_Get_Struct(self, type, ptr);                       \
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
             if (attr == Qnil) {                                     \
               ptr->attr = nilval;                                   \
             } else {                                                \
-              ptr->attr = NUM2INT(attr);                            \
+              ptr->attr = NUM2LONG(attr);                           \
             }                                                       \
                                                                     \
             return attr;                                            \
 
-/* setter for numerics that are kept in c ints */
+/* setter for numerics that are kept in c longs */
 #define CURB_IMMED_GETTER(type, attr, nilval)                       \
             type *ptr;                                              \
                                                                     \
-            Data_Get_Struct(self, type, ptr);                       \
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
             if (ptr->attr == nilval) {                              \
               return Qnil;                                          \
             } else {                                                \
-              return INT2NUM(ptr->attr);                            \
+              return LONG2NUM(ptr->attr);                           \
             }
 
 /* special setter for port / port ranges */
 #define CURB_IMMED_PORT_SETTER(type, attr, msg)                     \
             type *ptr;                                              \
                                                                     \
-            Data_Get_Struct(self, type, ptr);                       \
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
             if (attr == Qnil) {                                     \
               ptr->attr = 0;                                        \
             } else {                                                \
-              int port = FIX2INT(attr);                             \
+              int port = NUM2INT(attr);                             \
                                                                     \
               if ((port) && ((port & 0xFFFF) == port)) {            \
                 ptr->attr = port;                                   \
@@ -146,14 +146,26 @@
 #define CURB_IMMED_PORT_GETTER(type, attr)                          \
             type *ptr;                                              \
                                                                     \
-            Data_Get_Struct(self, type, ptr);                       \
+            TypedData_Get_Struct(self, type, &type##_data_type, ptr); \
             if (ptr->attr == 0) {                                   \
               return Qnil;                                          \
             } else {                                                \
-              return INT2FIX(ptr->attr);                            \
+              return INT2NUM(ptr->attr);                            \
             }
 
 #define CURB_DEFINE(name) \
-  rb_define_const(mCurl, #name, INT2FIX(name))
+  rb_define_const(mCurl, #name, LONG2NUM(name))
+
+/* copy and raise exception */
+#define CURB_CHECK_RB_CALLBACK_RAISE(did_raise) \
+  VALUE exception = rb_hash_aref(did_raise, rb_easy_hkey("error")); \
+  if (FIX2INT(rb_hash_size(did_raise)) > 0 && exception != Qnil) { \
+    rb_hash_clear(did_raise); \
+    VALUE message   = rb_funcall(exception, rb_intern("message"), 0); \
+    VALUE aborted_exception = rb_exc_new_str(eCurlErrAbortedByCallback, message); \
+    VALUE backtrace = rb_funcall(exception, rb_intern("backtrace"), 0); \
+    rb_funcall(aborted_exception,  rb_intern("set_backtrace"), 1, backtrace); \
+    rb_exc_raise(aborted_exception); \
+  }
 
 #endif