ob64 0.5.0 → 0.7.0

data/ext/ob64/ob64_ext.c

@@ -2,55 +2,82 @@
 #include "ob64.h"
 
 VALUE mOb64 = Qnil;
-VALUE mOb64_LibBase64 = Qnil;
+VALUE mOb64_Ext = Qnil;
 
-VALUE Ob64_encode_string(VALUE self, VALUE bin);
-VALUE Ob64_decode_string(VALUE self, VALUE string);
+/* Indexed by enum pack_codec */
+static const char *const codec_names[PACK_CODECS] = { "scalar", "avx2", "avx512", "neon64" };
+static ID codec_ids[PACK_CODECS];
+
+VALUE Ob64_encode_string(VALUE self, VALUE bin, VALUE urlsafe, VALUE padding);
+VALUE Ob64_decode_string(VALUE self, VALUE string, VALUE urlsafe, VALUE loose);
 VALUE Ob64_encoded_length_of(VALUE self, VALUE bin, VALUE withPadding);
 VALUE Ob64_decoded_length_of(VALUE self, VALUE string);
+VALUE Ob64_codec(VALUE self);
+VALUE Ob64_set_codec(VALUE self, VALUE codec);
+VALUE Ob64_codecs(VALUE self);
 
-size_t __encoded_length_of(VALUE string, bool withPadding);
+size_t __encoded_length_of(size_t bin_len, bool withPadding);
 size_t __decoded_length_of(VALUE string);
 
 void
 Init_ob64_ext(void)
 {
+  rb_ext_ractor_safe(true);
+  pack_base64_init();
+  for (int i = 0; i < PACK_CODECS; i++) {
+    codec_ids[i] = rb_intern(codec_names[i]);
+  }
+
   mOb64 = rb_define_module("Ob64");
-  mOb64_LibBase64 = rb_define_module_under(mOb64, "LibBase64");
+  mOb64_Ext = rb_define_module_under(mOb64, "Ext");
 
-  rb_define_private_method(mOb64_LibBase64, "__encode", Ob64_encode_string, 1);
-  rb_define_private_method(mOb64_LibBase64, "__decode", Ob64_decode_string, 1);
-  rb_define_private_method(mOb64_LibBase64, "__encoded_length_of", Ob64_encoded_length_of, 2);
-  rb_define_private_method(mOb64_LibBase64, "__decoded_length_of", Ob64_decoded_length_of, 1);
+  rb_define_private_method(mOb64_Ext, "__encode", Ob64_encode_string, 3);
+  rb_define_private_method(mOb64_Ext, "__decode", Ob64_decode_string, 3);
+  rb_define_private_method(mOb64_Ext, "__encoded_length_of", Ob64_encoded_length_of, 2);
+  rb_define_private_method(mOb64_Ext, "__decoded_length_of", Ob64_decoded_length_of, 1);
+  rb_define_private_method(mOb64_Ext, "__codec", Ob64_codec, 0);
+  rb_define_private_method(mOb64_Ext, "__set_codec", Ob64_set_codec, 1);
+  rb_define_private_method(mOb64_Ext, "__codecs", Ob64_codecs, 0);
+
+  Init_ob64_pack(mOb64_Ext);
 }
 
-VALUE Ob64_encode_string(VALUE self, VALUE bin)
+VALUE Ob64_encode_string(VALUE self, VALUE bin, VALUE urlsafe, VALUE padding)
 {
-  VALUE result = rb_str_buf_new(__encoded_length_of(bin, true));
-  size_t nout;
+  StringValue(bin);
+  size_t bin_len = RSTRING_LEN(bin);
+  VALUE result = rb_str_buf_new(__encoded_length_of(bin_len, true));
+  int flags = RTEST(urlsafe) ? PACK_BASE64_URL_SAFE : 0;
 
-  base64_encode(StringValuePtr(bin), RSTRING_LEN(bin), StringValuePtr(result), &nout, 0);
-  rb_str_set_len(result, nout);
+  pack_base64_encode(RSTRING_PTR(bin), bin_len, RSTRING_PTR(result), flags);
+  rb_str_set_len(result, __encoded_length_of(bin_len, RTEST(padding)));
+  RB_GC_GUARD(bin);
 
   return result;
 }
 
-VALUE Ob64_decode_string(VALUE self, VALUE string)
+VALUE Ob64_decode_string(VALUE self, VALUE string, VALUE urlsafe, VALUE loose)
 {
-  VALUE result = rb_str_buf_new(__decoded_length_of(string));
+  StringValue(string);
+  size_t string_len = RSTRING_LEN(string);
+  /* Room for unpadded input */
+  VALUE result = rb_str_buf_new((string_len + 3) / 4 * 3);
+  int flags = (RTEST(urlsafe) ? PACK_BASE64_URL_SAFE : 0) | (RTEST(loose) ? PACK_BASE64_LOOSE : 0);
   size_t nout;
 
-  if (!base64_decode(StringValuePtr(string), RSTRING_LEN(string), StringValuePtr(result), &nout, 0)) {
+  if (!pack_base64_decode(RSTRING_PTR(string), string_len, RSTRING_PTR(result), &nout, flags)) {
     rb_raise(rb_eArgError, "invalid base64");
   }
   rb_str_set_len(result, nout);
+  RB_GC_GUARD(string);
 
   return result;
 }
 
 VALUE Ob64_encoded_length_of(VALUE self, VALUE bin, VALUE withPadding)
 {
-  return ULONG2NUM((unsigned long)__encoded_length_of(bin, withPadding != Qnil && withPadding != Qfalse ? true : false));
+  StringValue(bin);
+  return ULONG2NUM((unsigned long)__encoded_length_of(RSTRING_LEN(bin), RTEST(withPadding)));
 }
 
 VALUE Ob64_decoded_length_of(VALUE self, VALUE string)
@@ -58,12 +85,12 @@ VALUE Ob64_decoded_length_of(VALUE self, VALUE string)
   return ULONG2NUM((unsigned long)__decoded_length_of(string));
 }
 
-size_t __encoded_length_of(VALUE bin, bool withPadding)
+size_t __encoded_length_of(size_t bin_len, bool withPadding)
 {
   if (withPadding) {
-    return (RSTRING_LEN(bin) + 2) / 3 * 4;
+    return (bin_len + 2) / 3 * 4;
   } else {
-    return ((RSTRING_LEN(bin) * 8) + 5) / 6;
+    return ((bin_len * 8) + 5) / 6;
   }
 }
 
@@ -72,8 +99,8 @@ size_t __decoded_length_of(VALUE string)
   char *string_ptr = StringValuePtr(string);
   size_t string_len = RSTRING_LEN(string);
   size_t padding = 0;
-  if (string_ptr[string_len - 1] == '=') padding++;
-  if (string_ptr[string_len - 2] == '=') padding++;
+  if (string_len >= 1 && string_ptr[string_len - 1] == '=') padding++;
+  if (string_len >= 2 && string_ptr[string_len - 2] == '=') padding++;
 
   if ((string_len - padding) % 4 == 1) {
     rb_raise(rb_eArgError, "invalid base64");
@@ -81,3 +108,33 @@ size_t __decoded_length_of(VALUE string)
 
   return (3 * (string_len - padding)) / 4;
 }
+
+VALUE Ob64_codec(VALUE self)
+{
+  return ID2SYM(codec_ids[pack_codec_current()]);
+}
+
+VALUE Ob64_set_codec(VALUE self, VALUE codec)
+{
+  for (int i = 0; i < PACK_CODECS; i++) {
+    if (codec == ID2SYM(codec_ids[i])) {
+      if (!pack_codec_runnable(i)) {
+        rb_raise(rb_eArgError, "%s is not supported by this CPU", codec_names[i]);
+      }
+      pack_codec_set(i);
+      return codec;
+    }
+  }
+  rb_raise(rb_eArgError, "unknown codec: %+"PRIsVALUE, codec);
+}
+
+VALUE Ob64_codecs(VALUE self)
+{
+  VALUE codecs = rb_ary_new();
+
+  for (int i = 0; i < PACK_CODECS; i++) {
+    if (pack_codec_runnable(i)) rb_ary_push(codecs, ID2SYM(codec_ids[i]));
+  }
+
+  return codecs;
+}

data/ext/ob64/ob64_pack.c

@@ -0,0 +1,289 @@
+#include <limits.h>
+#include "ob64.h"
+#include "pack_uuencode.h"
+#include "ruby/encoding.h"
+
+#define COUNT_STAR (-1)
+
+/*
+ * Returns 'm' or 'u' if fmt is a String matching \A[mu](\d{1,9}|\*)?\z in an
+ * ASCII-compatible encoding, 0 otherwise. *count: 1 if absent, COUNT_STAR for '*'.
+ */
+static int
+parse_format(VALUE fmt, long *count)
+{
+  if (!RB_TYPE_P(fmt, T_STRING) || !rb_enc_str_asciicompat_p(fmt)) return 0;
+
+  const char *p = RSTRING_PTR(fmt);
+  long len = RSTRING_LEN(fmt);
+
+  if (len < 1 || len > 10 || (p[0] != 'm' && p[0] != 'u')) return 0;
+  if (len == 1) {
+    *count = 1;
+  }
+  else if (len == 2 && p[1] == '*') {
+    *count = COUNT_STAR;
+  }
+  else {
+    *count = 0;
+    for (long i = 1; i < len; i++) {
+      if (p[i] < '0' || p[i] > '9') return 0;
+      *count = *count * 10 + (p[i] - '0');
+    }
+  }
+
+  return p[0];
+}
+
+/* Sets res's length to n and makes it a US-ASCII String, as native pack does */
+static VALUE
+ascii_result(VALUE res, size_t n)
+{
+  rb_str_set_len(res, (long)n);
+  ENCODING_CODERANGE_SET(res, rb_usascii_encindex(), ENC_CODERANGE_7BIT);
+
+  return res;
+}
+
+static VALUE
+uuencode(VALUE from, long line_len)
+{
+  long plen = RSTRING_LEN(from);
+  /* A length byte and a newline per line */
+  long lines = (plen + line_len - 1) / line_len;
+  VALUE res = rb_str_buf_new((plen + 2) / 3 * 4 + lines * 2);
+  const char *src = RSTRING_PTR(from);
+  char *out = RSTRING_PTR(res);
+  size_t n = pack_uuencode_lines(src, (size_t)plen, out, (size_t)line_len);
+  RB_GC_GUARD(from);
+
+  return ascii_result(res, n);
+}
+
+/* line_len: bytes per line, a multiple of 3; crlf: lines end in "\r\n" */
+static VALUE
+base64_encode_rfc2045(VALUE from, long line_len, int crlf)
+{
+  long plen = RSTRING_LEN(from);
+  /* A line break per line */
+  long lines = (plen + line_len - 1) / line_len;
+  VALUE res = rb_str_buf_new((plen + 2) / 3 * 4 + lines * (crlf ? 2 : 1));
+  size_t n = pack_base64_encode_rfc2045(RSTRING_PTR(from), (size_t)plen, RSTRING_PTR(res), (int)line_len, crlf);
+  RB_GC_GUARD(from);
+
+  return ascii_result(res, n);
+}
+
+static VALUE
+Ob64_pack(int argc, VALUE *argv, VALUE ary)
+{
+  long count, plen;
+  int type;
+  VALUE from;
+
+  if (argc != 1 || rb_keyword_given_p() || rb_block_given_p() ||
+      !(type = parse_format(argv[0], &count)) ||
+      RARRAY_LEN(ary) < 1 || !RB_TYPE_P(from = RARRAY_AREF(ary, 0), T_STRING) ||
+      /* Bound plen so the output size below cannot overflow */
+      (plen = RSTRING_LEN(from)) > LONG_MAX / 4) {
+    return rb_call_super_kw(argc, argv, RB_PASS_CALLED_KEYWORDS);
+  }
+
+  if (type == 'm' && count == 0) {
+    VALUE res = rb_str_buf_new((plen + 2) / 3 * 4);
+    size_t n = pack_base64_encode(RSTRING_PTR(from), (size_t)plen, RSTRING_PTR(res), 0);
+    RB_GC_GUARD(from);
+
+    return ascii_result(res, n);
+  }
+
+  long len = count;
+
+  /* '*' gets 45, as natively */
+  if (len <= 2) len = 45;
+  else if (len > 63 && type == 'u') len = 63;
+  else len = len / 3 * 3;
+
+  return type == 'u' ? uuencode(from, len) : base64_encode_rfc2045(from, len, 0);
+}
+
+static VALUE
+uudecode(VALUE str)
+{
+  long len = RSTRING_LEN(str);
+  /* +3: the decoder stores up to 3 bytes past a line's decoded length */
+  VALUE buf = rb_str_buf_new((long)pack_uudecode_cap((size_t)len) + 3);
+  size_t total = pack_uudecode_lines(RSTRING_PTR(str), (size_t)len, RSTRING_PTR(buf));
+  RB_GC_GUARD(str);
+
+  rb_str_set_len(buf, (long)total);
+
+  return buf;
+}
+
+static VALUE
+base64_decode(VALUE str, long count)
+{
+  long len = RSTRING_LEN(str);
+  /* Room for unpadded input and decoder overruns */
+  VALUE buf = rb_str_buf_new(len / 4 * 3 + 3);
+  size_t n;
+
+  if (count == 0) {
+    if (!pack_base64_decode(RSTRING_PTR(str), (size_t)len, RSTRING_PTR(buf), &n, 0)) {
+      rb_raise(rb_eArgError, "invalid base64");
+    }
+  }
+  else {
+    n = pack_base64_decode_rfc2045(RSTRING_PTR(str), (size_t)len, RSTRING_PTR(buf));
+  }
+  RB_GC_GUARD(str);
+
+  rb_str_set_len(buf, (long)n);
+
+  return buf;
+}
+
+/* Returns the decoded String, or Qundef when native Ruby must handle the call */
+static VALUE
+unpack_fast(int argc, VALUE *argv, VALUE str)
+{
+  long count;
+  int type;
+
+  if (argc != 1 || rb_keyword_given_p() || rb_block_given_p() ||
+      !(type = parse_format(argv[0], &count))) {
+    return Qundef;
+  }
+
+  return type == 'm' ? base64_decode(str, count) : uudecode(str);
+}
+
+static VALUE
+Ob64_unpack(int argc, VALUE *argv, VALUE str)
+{
+  VALUE res = unpack_fast(argc, argv, str);
+
+  if (RB_UNDEF_P(res)) return rb_call_super_kw(argc, argv, RB_PASS_CALLED_KEYWORDS);
+
+  return rb_ary_new_from_values(1, &res);
+}
+
+static VALUE
+Ob64_unpack1(int argc, VALUE *argv, VALUE str)
+{
+  VALUE res = unpack_fast(argc, argv, str);
+
+  if (RB_UNDEF_P(res)) return rb_call_super_kw(argc, argv, RB_PASS_CALLED_KEYWORDS);
+
+  return res;
+}
+
+/* Bytes per line for a line_length in chars; validates both arguments */
+static long
+rfc2045_line_bytes(VALUE bin, VALUE line_length)
+{
+  long chars = NUM2LONG(line_length);
+
+  StringValue(bin);
+  if (chars < 4 || chars % 4 || chars / 4 * 3 > INT_MAX) {
+    rb_raise(rb_eArgError, "line length must be a positive multiple of 4: %ld", chars);
+  }
+  /* Bound the output size */
+  if (RSTRING_LEN(bin) > LONG_MAX / 4) rb_raise(rb_eArgError, "argument too big");
+
+  return chars / 4 * 3;
+}
+
+static VALUE
+Ob64_encode_rfc_2045(VALUE self, VALUE bin, VALUE line_length, VALUE crlf)
+{
+  long line_bytes = rfc2045_line_bytes(bin, line_length);
+
+  return base64_encode_rfc2045(bin, line_bytes, RTEST(crlf));
+}
+
+static VALUE
+Ob64_decode_rfc_2045(VALUE self, VALUE string)
+{
+  StringValue(string);
+
+  return base64_decode(string, 1);
+}
+
+static VALUE
+Ob64_encoded_length_of_rfc_2045(VALUE self, VALUE bin, VALUE line_length, VALUE crlf)
+{
+  long line_bytes = rfc2045_line_bytes(bin, line_length);
+  long plen = RSTRING_LEN(bin);
+
+  /* 4 chars per 3 bytes, a line break per line */
+  return LONG2NUM((plen + 2) / 3 * 4 + (plen + line_bytes - 1) / line_bytes * (RTEST(crlf) ? 2 : 1));
+}
+
+static VALUE
+Ob64_decoded_length_of_rfc_2045(VALUE self, VALUE string)
+{
+  StringValue(string);
+  size_t n = pack_base64_decoded_length_rfc2045(RSTRING_PTR(string), (size_t)RSTRING_LEN(string));
+  RB_GC_GUARD(string);
+
+  return SIZET2NUM(n);
+}
+
+static VALUE
+Ob64_uuencode(VALUE self, VALUE bin)
+{
+  StringValue(bin);
+
+  return uuencode(bin, 45);
+}
+
+static VALUE
+Ob64_uudecode(VALUE self, VALUE string)
+{
+  StringValue(string);
+
+  return uudecode(string);
+}
+
+static VALUE
+Ob64_uuencoded_length_of(VALUE self, VALUE bin)
+{
+  StringValue(bin);
+  long plen = RSTRING_LEN(bin);
+  /* Per line: a length byte, 4 chars per 3 bytes and a newline */
+  long full = plen / 45, rest = plen % 45;
+
+  return LONG2NUM(full * 62 + (rest ? (rest + 2) / 3 * 4 + 2 : 0));
+}
+
+static VALUE
+Ob64_uudecoded_length_of(VALUE self, VALUE string)
+{
+  StringValue(string);
+  size_t total = pack_uudecode_lines(RSTRING_PTR(string), (size_t)RSTRING_LEN(string), NULL);
+  RB_GC_GUARD(string);
+
+  return LONG2NUM((long)total);
+}
+
+void
+Init_ob64_pack(VALUE mExt)
+{
+  VALUE mPack = rb_define_module_under(mExt, "Pack");
+  VALUE mUnpack = rb_define_module_under(mExt, "Unpack");
+
+  rb_define_method(mPack, "pack", Ob64_pack, -1);
+  rb_define_method(mUnpack, "unpack", Ob64_unpack, -1);
+  rb_define_method(mUnpack, "unpack1", Ob64_unpack1, -1);
+
+  rb_define_private_method(mExt, "__encode_rfc_2045", Ob64_encode_rfc_2045, 3);
+  rb_define_private_method(mExt, "__decode_rfc_2045", Ob64_decode_rfc_2045, 1);
+  rb_define_private_method(mExt, "__encoded_length_of_rfc_2045", Ob64_encoded_length_of_rfc_2045, 3);
+  rb_define_private_method(mExt, "__decoded_length_of_rfc_2045", Ob64_decoded_length_of_rfc_2045, 1);
+  rb_define_private_method(mExt, "__uuencode", Ob64_uuencode, 1);
+  rb_define_private_method(mExt, "__uudecode", Ob64_uudecode, 1);
+  rb_define_private_method(mExt, "__uuencoded_length_of", Ob64_uuencoded_length_of, 1);
+  rb_define_private_method(mExt, "__uudecoded_length_of", Ob64_uudecoded_length_of, 1);
+}