Compile with -DSTRICT_R_HEADERS -DR_NO_REMAP

Author: jeroen

openssl.Rproj

@@ -1,4 +1,5 @@
 Version: 1.0
+ProjectId: 94919da2-cd64-435c-ad4a-d22bcd028827
 
 RestoreWorkspace: Default
 SaveWorkspace: Default

src/Makevars.in

@@ -1,4 +1,4 @@
-PKG_CPPFLAGS = @cflags@
+PKG_CPPFLAGS = @cflags@ -DSTRICT_R_HEADERS -DR_NO_REMAP
 PKG_LIBS = -Lbcrypt -lstatbcrypt @libs@
 STATLIB = bcrypt/libstatbcrypt.a
 LIBBCRYPT = bcrypt/bcrypt_pbkdf.o bcrypt/blowfish.o

src/Makevars.win

@@ -13,7 +13,7 @@ endif
 
 STATLIB = bcrypt/libstatbcrypt.a
 LIBBCRYPT = bcrypt/bcrypt_pbkdf.o bcrypt/blowfish.o
-PKG_CPPFLAGS = $(OPENSSL_CFLAGS) -DOPENSSL_SUPPRESS_DEPRECATED
+PKG_CPPFLAGS = $(OPENSSL_CFLAGS) -DOPENSSL_SUPPRESS_DEPRECATED -DSTRICT_R_HEADERS -DR_NO_REMAP
 PKG_LIBS = $(OPENSSL_LIBS) -Lbcrypt -lstatbcrypt
 
 

src/aes.c

@@ -12,7 +12,7 @@
 SEXP R_aes_any(SEXP x, SEXP key, SEXP iv, SEXP encrypt, SEXP cipher) {
   int strength = LENGTH(key);
   if(strength != 16 && strength != 24 && strength != 32)
-    error("key must be of length 16 (aes-128), 24 (aes-192) or 32 (aes-256)");
+    Rf_error("key must be of length 16 (aes-128), 24 (aes-192) or 32 (aes-256)");
 
   EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
   const EVP_CIPHER *cph = EVP_get_cipherbyname(CHAR(STRING_ELT(cipher, 0)));
@@ -25,14 +25,14 @@ SEXP R_aes_any(SEXP x, SEXP key, SEXP iv, SEXP encrypt, SEXP cipher) {
       Rf_error("aes-gcm requires an iv of length 12");
     }
     //GCM mode has shorter IV from the others
-    bail(EVP_CipherInit_ex(ctx, cph, NULL, NULL, NULL, asLogical(encrypt)));
+    bail(EVP_CipherInit_ex(ctx, cph, NULL, NULL, NULL, Rf_asLogical(encrypt)));
     bail(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, LENGTH(iv), NULL));
   } else
 #endif //EVP_CIPH_GCM_MODE
   if(LENGTH(iv) != 16){
     Rf_error("aes requires an iv of length 16");
   }
-  bail(EVP_CipherInit_ex(ctx, cph, NULL, RAW(key), RAW(iv), asLogical(encrypt)));
+  bail(EVP_CipherInit_ex(ctx, cph, NULL, RAW(key), RAW(iv), Rf_asLogical(encrypt)));
 
   int blocksize = EVP_CIPHER_CTX_block_size(ctx);
   int remainder = LENGTH(x) % blocksize;
@@ -58,7 +58,7 @@ SEXP R_aes_any(SEXP x, SEXP key, SEXP iv, SEXP encrypt, SEXP cipher) {
   int total = cur - buf;
   EVP_CIPHER_CTX_cleanup(ctx);
   EVP_CIPHER_CTX_free(ctx);
-  SEXP out = allocVector(RAWSXP, total);
+  SEXP out = Rf_allocVector(RAWSXP, total);
   memcpy(RAW(out), buf, total);
   OPENSSL_free(buf);
   return out;

src/base64.c

@@ -11,7 +11,7 @@ SEXP R_base64_encode(SEXP bin, SEXP linebreaks){
   BIO *bio = BIO_push(BIO_new(BIO_f_base64()), BIO_new(BIO_s_mem()));
 
   //No linebreaks
-  if(!asLogical(linebreaks))
+  if(!Rf_asLogical(linebreaks))
     BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
 
   bail(BIO_set_close(bio, BIO_NOCLOSE));
@@ -23,8 +23,8 @@ SEXP R_base64_encode(SEXP bin, SEXP linebreaks){
   BIO_get_mem_ptr(bio, &buf);
 
   //return a character vector
-  SEXP out = PROTECT(allocVector(STRSXP, 1));
-  SET_STRING_ELT(out, 0, mkCharLen(buf->data, buf->length));
+  SEXP out = PROTECT(Rf_allocVector(STRSXP, 1));
+  SET_STRING_ELT(out, 0, Rf_mkCharLen(buf->data, buf->length));
   UNPROTECT(1);
 
   //Cleanup and return
@@ -49,7 +49,7 @@ SEXP R_base64_decode(SEXP text){
   }
 
   //create raw output vector
-  SEXP out = PROTECT(allocVector(RAWSXP, bin_len));
+  SEXP out = PROTECT(Rf_allocVector(RAWSXP, bin_len));
   memcpy(RAW(out), bin, bin_len);
   UNPROTECT(1);
 

src/bignum.c

@@ -6,17 +6,17 @@
 #include "utils.h"
 
 BIGNUM *r2bignum(SEXP x){
-  if(!inherits(x, "bignum"))
-    error("Argument is not valid bignum");
+  if(!Rf_inherits(x, "bignum"))
+    Rf_error("Argument is not valid bignum");
   BIGNUM *val = BN_bin2bn(RAW(x), LENGTH(x), NULL);
   bail(val != NULL);
   return val;
 }
 
 SEXP bignum2r(const BIGNUM *val){
-  SEXP out = PROTECT(allocVector(RAWSXP, BN_num_bytes(val)));
+  SEXP out = PROTECT(Rf_allocVector(RAWSXP, BN_num_bytes(val)));
   bail(BN_bn2bin(val, RAW(out)) >= 0);
-  setAttrib(out, R_ClassSymbol, mkString("bignum"));
+  Rf_setAttrib(out, R_ClassSymbol, Rf_mkString("bignum"));
   UNPROTECT(1);
   return out;
 }
@@ -25,7 +25,7 @@ SEXP R_parse_bignum(SEXP x, SEXP hex){
   BIGNUM *val = BN_new();
   if(TYPEOF(x) == RAWSXP){
     bail(NULL != BN_bin2bn(RAW(x), LENGTH(x), val));
-  } else if(asLogical(hex)){
+  } else if(Rf_asLogical(hex)){
     bail(BN_hex2bn(&val, CHAR(STRING_ELT(x, 0))));
   } else {
     bail(BN_dec2bn(&val, CHAR(STRING_ELT(x, 0))));
@@ -38,12 +38,12 @@ SEXP R_parse_bignum(SEXP x, SEXP hex){
 SEXP R_bignum_as_character(SEXP x, SEXP hex){
   BIGNUM *val = r2bignum(x);
   char *str;
-  if(asLogical(hex)){
+  if(Rf_asLogical(hex)){
     bail(!!(str = BN_bn2hex(val)));
   } else {
     bail(!!(str = BN_bn2dec(val)));
   }
-  SEXP res = mkString(str);
+  SEXP res = Rf_mkString(str);
   OPENSSL_free(str);
   BN_free(val);
   return res;
@@ -52,7 +52,7 @@ SEXP R_bignum_as_character(SEXP x, SEXP hex){
 SEXP R_bignum_as_integer(SEXP x){
   BIGNUM *val = r2bignum(x);
   int res = BN_div_word(val, (BN_ULONG) INT_MAX + 1);
-  return ScalarInteger(BN_num_bits(val) ? NA_INTEGER : res);
+  return Rf_ScalarInteger(BN_num_bits(val) ? NA_INTEGER : res);
 }
 
 SEXP R_bignum_add(SEXP x, SEXP y){
@@ -171,10 +171,10 @@ SEXP R_bignum_compare(SEXP x, SEXP y){
   int out = BN_cmp(val1, val2);
   BN_free(val1);
   BN_free(val2);
-  return ScalarInteger(out);
+  return Rf_ScalarInteger(out);
 }
 
 SEXP R_bignum_bits(SEXP x){
   BIGNUM *num = r2bignum(x);
-  return ScalarInteger(BN_num_bits(num));
+  return Rf_ScalarInteger(BN_num_bits(num));
 }

src/cert.c

@@ -19,7 +19,7 @@ SEXP R_cert_info(SEXP bin, SEXP name_format){
   int len;
   X509_NAME *name;
   BIO *b;
-  SEXP out = PROTECT(allocVector(VECSXP, 7));
+  SEXP out = PROTECT(Rf_allocVector(VECSXP, 7));
 
   //Note: for some reason XN_FLAG_MULTILINE messes up UTF8
   int flags = Rf_length(name_format) ? Rf_asInteger(name_format) : XN_FLAG_RFC2253;
@@ -30,8 +30,8 @@ SEXP R_cert_info(SEXP bin, SEXP name_format){
   bail(X509_NAME_print_ex(b, name, 0, flags & ~ASN1_STRFLGS_ESC_MSB));
   len = BIO_read(b, buf, bufsize);
   BIO_free(b);
-  SET_VECTOR_ELT(out, 0, allocVector(STRSXP, 1));
-  SET_STRING_ELT(VECTOR_ELT(out, 0), 0, mkCharLenCE(buf, len, CE_UTF8));
+  SET_VECTOR_ELT(out, 0, Rf_allocVector(STRSXP, 1));
+  SET_STRING_ELT(VECTOR_ELT(out, 0), 0, Rf_mkCharLenCE(buf, len, CE_UTF8));
   X509_NAME_free(name);
 
   //issuer name name
@@ -40,50 +40,50 @@ SEXP R_cert_info(SEXP bin, SEXP name_format){
   bail(X509_NAME_print_ex(b, name, 0, flags & ~ASN1_STRFLGS_ESC_MSB));
   len = BIO_read(b, buf, bufsize);
   BIO_free(b);
-  SET_VECTOR_ELT(out, 1, allocVector(STRSXP, 1));
-  SET_STRING_ELT(VECTOR_ELT(out, 1), 0, mkCharLenCE(buf, len, CE_UTF8));
+  SET_VECTOR_ELT(out, 1, Rf_allocVector(STRSXP, 1));
+  SET_STRING_ELT(VECTOR_ELT(out, 1), 0, Rf_mkCharLenCE(buf, len, CE_UTF8));
   X509_NAME_free(name);
 
   //sign algorithm
   const ASN1_BIT_STRING *signature;
   const X509_ALGOR *sig_alg;
   MY_X509_get0_signature(&signature, &sig_alg, cert);
   OBJ_obj2txt(buf, sizeof(buf), sig_alg->algorithm, 0);
-  SET_VECTOR_ELT(out, 2, mkString(buf));
+  SET_VECTOR_ELT(out, 2, Rf_mkString(buf));
 
   //signature
-  SET_VECTOR_ELT(out, 3, allocVector(RAWSXP, signature->length));
+  SET_VECTOR_ELT(out, 3, Rf_allocVector(RAWSXP, signature->length));
   memcpy(RAW(VECTOR_ELT(out, 3)), signature->data, signature->length);
 
   //start date
-  SET_VECTOR_ELT(out, 4, allocVector(STRSXP, 2));
+  SET_VECTOR_ELT(out, 4, Rf_allocVector(STRSXP, 2));
   b = BIO_new(BIO_s_mem());
   bail(ASN1_TIME_print(b, X509_get_notBefore(cert)));
   len = BIO_read(b, buf, bufsize);
   BIO_free(b);
-  SET_STRING_ELT(VECTOR_ELT(out, 4), 0, mkCharLen(buf, len));
+  SET_STRING_ELT(VECTOR_ELT(out, 4), 0, Rf_mkCharLen(buf, len));
 
   //expiration date
   b = BIO_new(BIO_s_mem());
   bail(ASN1_TIME_print(b, X509_get_notAfter(cert)));
   len = BIO_read(b, buf, bufsize);
   BIO_free(b);
-  SET_STRING_ELT(VECTOR_ELT(out, 4), 1, mkCharLen(buf, len));
+  SET_STRING_ELT(VECTOR_ELT(out, 4), 1, Rf_mkCharLen(buf, len));
 
   //test for self signed
-  SET_VECTOR_ELT(out, 5, ScalarLogical(X509_verify(cert, X509_get_pubkey(cert))));
+  SET_VECTOR_ELT(out, 5, Rf_ScalarLogical(X509_verify(cert, X509_get_pubkey(cert))));
 
   //check for alternative names (requires x509v3 extensions !!)
   GENERAL_NAMES *subjectAltNames = X509_get_ext_d2i (cert, NID_subject_alt_name, NULL, NULL);
   int numalts = sk_GENERAL_NAME_num (subjectAltNames);
   if(numalts > 0) {
-    SET_VECTOR_ELT(out, 6, allocVector(STRSXP, numalts));
+    SET_VECTOR_ELT(out, 6, Rf_allocVector(STRSXP, numalts));
     unsigned char *tmpbuf;
     for (int i = 0; i < numalts; i++) {
       const GENERAL_NAME *name = sk_GENERAL_NAME_value(subjectAltNames, i);
       len = ASN1_STRING_to_UTF8(&tmpbuf, name->d.ia5);
       if(len > 0){
-        SET_STRING_ELT(VECTOR_ELT(out, 6), i, mkCharLenCE((char*) tmpbuf, len, CE_UTF8));
+        SET_STRING_ELT(VECTOR_ELT(out, 6), i, Rf_mkCharLenCE((char*) tmpbuf, len, CE_UTF8));
         OPENSSL_free(tmpbuf);
       }
     }
@@ -104,7 +104,7 @@ SEXP R_pubkey_verify_cert(SEXP cert, SEXP pubkey){
   int res = X509_verify(crt, pkey);
   X509_free(crt);
   EVP_PKEY_free(pkey);
-  return ScalarLogical(res);
+  return Rf_ScalarLogical(res);
 }
 
 SEXP R_cert_verify_cert(SEXP cert, SEXP chain, SEXP bundle) {
@@ -145,7 +145,7 @@ SEXP R_cert_verify_cert(SEXP cert, SEXP chain, SEXP bundle) {
   X509_free(crt);
 
   if(err)
-    error("Certificate validation failed: %s", err);
+    Rf_error("Certificate validation failed: %s", err);
 
-  return ScalarLogical(TRUE);
+  return Rf_ScalarLogical(TRUE);
 }

src/diffie.c

@@ -28,7 +28,7 @@ SEXP R_diffie_hellman(SEXP key, SEXP peerkey){
   /* Determine buffer length */
   size_t skeylen = 0;
   bail(EVP_PKEY_derive(ctx, NULL, &skeylen) > 0);
-  SEXP out = allocVector(RAWSXP, skeylen);
+  SEXP out = Rf_allocVector(RAWSXP, skeylen);
   bail(EVP_PKEY_derive(ctx, RAW(out), &skeylen) > 0);
 
   /* cleanup */

src/envelope.c

@@ -41,10 +41,10 @@ SEXP R_envelope_encrypt(SEXP data, SEXP pubkey) {
   EVP_CIPHER_CTX_free(ctx);
 
   /* Create output vector */
-  SEXP res = PROTECT(allocVector(VECSXP, 3));
-  SET_VECTOR_ELT(res, 0, allocVector(RAWSXP, ivlen));
-  SET_VECTOR_ELT(res, 1, allocVector(RAWSXP, ekl[0]));
-  SET_VECTOR_ELT(res, 2, allocVector(RAWSXP, len1 + len2));
+  SEXP res = PROTECT(Rf_allocVector(VECSXP, 3));
+  SET_VECTOR_ELT(res, 0, Rf_allocVector(RAWSXP, ivlen));
+  SET_VECTOR_ELT(res, 1, Rf_allocVector(RAWSXP, ekl[0]));
+  SET_VECTOR_ELT(res, 2, Rf_allocVector(RAWSXP, len1 + len2));
   memcpy(RAW(VECTOR_ELT(res, 0)), iv, ivlen);
   memcpy(RAW(VECTOR_ELT(res, 1)), ek[0], ekl[0]);
   memcpy(RAW(VECTOR_ELT(res, 2)), out, len1 + len2);
@@ -66,14 +66,14 @@ SEXP R_envelope_decrypt(SEXP data, SEXP iv, SEXP session, SEXP key) {
 
   /* Verify key size */
   if(LENGTH(session) != EVP_PKEY_size(pkey))
-    error("Invalid Session key, must be %d bytes", EVP_PKEY_size(pkey));
+    Rf_error("Invalid Session key, must be %d bytes", EVP_PKEY_size(pkey));
 
 
   /* Alloc buffers and init */
   const EVP_CIPHER *cipher = EVP_aes_256_cbc();
   int ivlen = EVP_CIPHER_iv_length(cipher);
   if(ivlen != LENGTH(iv))
-    error("Invalid IV, must be %d bytes", ivlen);
+    Rf_error("Invalid IV, must be %d bytes", ivlen);
   bail(EVP_OpenInit(ctx, EVP_aes_256_cbc(), RAW(session), LENGTH(session), RAW(iv), pkey));
 
   /* This is an overestimate */
@@ -89,7 +89,7 @@ SEXP R_envelope_decrypt(SEXP data, SEXP iv, SEXP session, SEXP key) {
   EVP_CIPHER_CTX_free(ctx);
 
   /* Create RAW vector */
-  SEXP res = allocVector(RAWSXP, len1 + len2);
+  SEXP res = Rf_allocVector(RAWSXP, len1 + len2);
   memcpy(RAW(res), out,  len1 + len2);
   free(out);
   return res;

src/hash.c

@@ -22,7 +22,7 @@ unsigned int digest_string(unsigned char *x, int len, SEXP key, const char *algo
 #endif
 
   if(!md)
-    error("Unknown cryptographic algorithm %s\n", algo);
+    Rf_error("Unknown cryptographic algorithm %s\n", algo);
 
   if(key == R_NilValue){
     bail(EVP_Digest(x, len, md_value, &md_len, md, NULL));
@@ -35,27 +35,27 @@ unsigned int digest_string(unsigned char *x, int len, SEXP key, const char *algo
 SEXP R_digest_raw(SEXP x, SEXP algo, SEXP key){
   /* Check inputs */
   if(TYPEOF(x) != RAWSXP)
-    error("Argument 'x' must be a raw vector.");
+    Rf_error("Argument 'x' must be a raw vector.");
 
   /* Convert the Raw vector to an unsigned char */
   unsigned char md_value[EVP_MAX_MD_SIZE];
-  unsigned int md_len = digest_string(RAW(x), length(x), key, CHAR(asChar(algo)), md_value);
+  unsigned int md_len = digest_string(RAW(x), Rf_length(x), key, CHAR(Rf_asChar(algo)), md_value);
 
   /* create raw output vector */
-  SEXP out = PROTECT(allocVector(RAWSXP, md_len));
+  SEXP out = PROTECT(Rf_allocVector(RAWSXP, md_len));
   memcpy(RAW(out), md_value, md_len);
   UNPROTECT(1);
   return out;
 }
 
 SEXP R_digest(SEXP x, SEXP algo, SEXP key){
-  if(!isString(x))
-    error("Argument 'x' must be a character vector.");
-  if(!isString(algo))
-    error("Argument 'algo' must be a character vector.");
+  if(!Rf_isString(x))
+    Rf_error("Argument 'x' must be a character vector.");
+  if(!Rf_isString(algo))
+    Rf_error("Argument 'algo' must be a character vector.");
 
-  int len = length(x);
-  SEXP out = PROTECT(allocVector(STRSXP, len));
+  int len = Rf_length(x);
+  SEXP out = PROTECT(Rf_allocVector(STRSXP, len));
   for (int i = 0; i < len; i++) {
     /* check for NA */
     if(STRING_ELT(x, i) == NA_STRING) {
@@ -66,14 +66,14 @@ SEXP R_digest(SEXP x, SEXP algo, SEXP key){
     const char* str = CHAR(STRING_ELT(x, i));
     int stringlen = LENGTH(STRING_ELT(x, i));
     unsigned char md_value[EVP_MAX_MD_SIZE];
-    unsigned int md_len = digest_string( (unsigned char*) str, stringlen, key, CHAR(asChar(algo)), md_value);
+    unsigned int md_len = digest_string( (unsigned char*) str, stringlen, key, CHAR(Rf_asChar(algo)), md_value);
 
     /* create character vector */
     char strbuf[2*md_len+1];
     for (int i = 0; i < md_len; i++) {
       snprintf(strbuf + i*2, 3, "%02x", (unsigned int) md_value[i]);
     }
-    SET_STRING_ELT(out, i, mkChar(strbuf));
+    SET_STRING_ELT(out, i, Rf_mkChar(strbuf));
   }
   UNPROTECT(1);
   return out;