escape_utils 0.2.4 → 0.3.0

data/ext/escape_utils/buffer.h

@@ -1,91 +1,113 @@
 /*
- * Copyright (c) 2008, Natacha Porté
- * Copyright (c) 2011, Vicent Martí
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
  */
+#ifndef INCLUDE_buffer_h__
+#define INCLUDE_buffer_h__
 
-#ifndef __GEN_BUFFER_H__
-#define __GEN_BUFFER_H__
-
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdarg.h>
+#include <sys/types.h>
 #include <stdint.h>
 
-#if defined(_MSC_VER)
-#define __attribute__(x)
-#define inline
-#endif
-
-typedef enum {
-	BUF_OK = 0,
-	BUF_ENOMEM = -1,
-} buferror_t;
-
-/* struct buf: character array buffer */
-struct buf {
-	uint8_t *data;		/* actual character data */
-	size_t size;	/* size of the string */
-	size_t asize;	/* allocated size (0 = volatile buffer) */
-	size_t unit;	/* reallocation unit size (0 = read-only buffer) */
-};
+typedef struct {
+	char *ptr;
+	size_t asize, size;
+} gh_buf;
 
-/* CONST_BUF: global buffer from a string litteral */
-#define BUF_STATIC(string) \
-	{ (uint8_t *)string, sizeof string -1, sizeof string, 0, 0 }
+extern char gh_buf__initbuf[];
+extern char gh_buf__oom[];
 
-/* VOLATILE_BUF: macro for creating a volatile buffer on the stack */
-#define BUF_VOLATILE(strname) \
-	{ (uint8_t *)strname, strlen(strname), 0, 0, 0 }
+#define GH_BUF_INIT { gh_buf__initbuf, 0, 0 }
 
-/* BUFPUTSL: optimized bufputs of a string litteral */
-#define BUFPUTSL(output, literal) \
-	bufput(output, literal, sizeof literal - 1)
-
-/* bufgrow: increasing the allocated size to the given value */
-int bufgrow(struct buf *, size_t);
-
-/* bufnew: allocation of a new buffer */
-struct buf *bufnew(size_t) __attribute__ ((malloc));
+/**
+ * Initialize a gh_buf structure.
+ *
+ * For the cases where GH_BUF_INIT cannot be used to do static
+ * initialization.
+ */
+extern void gh_buf_init(gh_buf *buf, size_t initial_size);
 
-/* bufnullterm: NUL-termination of the string array (making a C-string) */
-const char *bufcstr(struct buf *);
+/**
+ * Attempt to grow the buffer to hold at least `target_size` bytes.
+ *
+ * If the allocation fails, this will return an error.  If mark_oom is true,
+ * this will mark the buffer as invalid for future operations; if false,
+ * existing buffer content will be preserved, but calling code must handle
+ * that buffer was not expanded.
+ */
+extern int gh_buf_try_grow(gh_buf *buf, size_t target_size, bool mark_oom);
 
-/* bufprefix: compare the beginning of a buffer with a string */
-int bufprefix(const struct buf *buf, const char *prefix);
+/**
+ * Grow the buffer to hold at least `target_size` bytes.
+ *
+ * If the allocation fails, this will return an error and the buffer will be
+ * marked as invalid for future operations, invaliding contents.
+ *
+ * @return 0 on success or -1 on failure
+ */
+static inline int gh_buf_grow(gh_buf *buf, size_t target_size)
+{
+	return gh_buf_try_grow(buf, target_size, true);
+}
 
-/* bufput: appends raw data to a buffer */
-void bufput(struct buf *, const void *, size_t);
+extern void gh_buf_free(gh_buf *buf);
+extern void gh_buf_swap(gh_buf *buf_a, gh_buf *buf_b);
 
-/* bufputs: appends a NUL-terminated string to a buffer */
-void bufputs(struct buf *, const char *);
+/**
+ * Test if there have been any reallocation failures with this gh_buf.
+ *
+ * Any function that writes to a gh_buf can fail due to memory allocation
+ * issues.  If one fails, the gh_buf will be marked with an OOM error and
+ * further calls to modify the buffer will fail.  Check gh_buf_oom() at the
+ * end of your sequence and it will be true if you ran out of memory at any
+ * point with that buffer.
+ *
+ * @return false if no error, true if allocation error
+ */
+static inline bool gh_buf_oom(const gh_buf *buf)
+{
+	return (buf->ptr == gh_buf__oom);
+}
 
-/* bufputc: appends a single char to a buffer */
-void bufputc(struct buf *, int);
 
-/* bufrelease: decrease the reference count and free the buffer if needed */
-void bufrelease(struct buf *);
+static inline size_t gh_buf_len(const gh_buf *buf)
+{
+	return buf->size;
+}
 
-/* bufreset: frees internal data of the buffer */
-void bufreset(struct buf *);
+extern int gh_buf_cmp(const gh_buf *a, const gh_buf *b);
 
-/* bufslurp: removes a given number of bytes from the head of the array */
-void bufslurp(struct buf *, size_t);
+extern void gh_buf_attach(gh_buf *buf, char *ptr, size_t asize);
+extern char *gh_buf_detach(gh_buf *buf);
+extern void gh_buf_copy_cstr(char *data, size_t datasize, const gh_buf *buf);
 
-/* bufprintf: formatted printing to a buffer */
-void bufprintf(struct buf *, const char *, ...) __attribute__ ((format (printf, 2, 3)));
+static inline const char *gh_buf_cstr(const gh_buf *buf)
+{
+	return buf->ptr;
+}
 
-/* vbufprintf: stdarg variant of formatted printing into a buffer */
-void vbufprintf(struct buf *, const char * , va_list);
+/*
+ * Functions below that return int value error codes will return 0 on
+ * success or -1 on failure (which generally means an allocation failed).
+ * Using a gh_buf where the allocation has failed with result in -1 from
+ * all further calls using that buffer.  As a result, you can ignore the
+ * return code of these functions and call them in a series then just call
+ * gh_buf_oom at the end.
+ */
+extern int gh_buf_set(gh_buf *buf, const char *data, size_t len);
+extern int gh_buf_sets(gh_buf *buf, const char *string);
+extern int gh_buf_putc(gh_buf *buf, char c);
+extern int gh_buf_put(gh_buf *buf, const void *data, size_t len);
+extern int gh_buf_puts(gh_buf *buf, const char *string);
+extern int gh_buf_printf(gh_buf *buf, const char *format, ...)
+	__attribute__((format (printf, 2, 3)));
+extern int gh_buf_vprintf(gh_buf *buf, const char *format, va_list ap);
+extern void gh_buf_clear(gh_buf *buf);
+
+#define gh_buf_PUTS(buf, str) gh_buf_put(buf, str, sizeof(str) - 1)
 
 #endif

data/ext/escape_utils/escape_utils.c

@@ -4,16 +4,48 @@
 #define RSTRING_NOT_MODIFIED
 
 #include <ruby.h>
+#include "houdini.h"
+
 #if RB_CVAR_SET_ARITY == 4
 #  define rb_cvar_set(a,b,c) rb_cvar_set(a,b,c,0)
 #endif
+
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>
-#endif
+static VALUE rb_eEncodingCompatibilityError;
 
-#include "houdini.h"
+static VALUE eu_new_str(const char *str, size_t len)
+{
+	return rb_enc_str_new(str, len, rb_utf8_encoding());
+}
 
-typedef void (*houdini_cb)(struct buf *, const uint8_t *, size_t);
+static void check_utf8_encoding(VALUE str)
+{
+	static rb_encoding *_cached[3] = {NULL, NULL, NULL};
+	rb_encoding *enc;
+
+	if (_cached[0] == NULL) {
+		_cached[0] = rb_utf8_encoding();
+		_cached[1] = rb_usascii_encoding();
+		_cached[2] = rb_ascii8bit_encoding();
+	}
+
+	enc = rb_enc_get(str);
+	if (enc != _cached[0] && enc != _cached[1] && enc != _cached[2]) {
+		rb_raise(rb_eEncodingCompatibilityError,
+			"Input must be UTF-8 or US-ASCII, %s given", rb_enc_name(enc));
+	}
+}
+#else
+static VALUE eu_new_str(const char *str, size_t len)
+{
+	return rb_str_new(str, len);
+}
+
+static void check_utf8_encoding(VALUE str) {}
+#endif
+
+typedef int (*houdini_cb)(gh_buf *, const uint8_t *, size_t);
 
 static VALUE rb_mEscapeUtils;
 
@@ -35,34 +67,27 @@ static VALUE rb_eu_set_html_secure(VALUE self, VALUE val)
 	return val;
 }
 
-
 /**
  * Generic template
  */
 static VALUE
-rb_eu__generic(
-	VALUE self, VALUE str,
-	houdini_cb callback,
-	size_t chunk_size)
+rb_eu__generic(VALUE str, houdini_cb do_escape)
 {
-	VALUE result;
-	struct buf *out_buf;
+	gh_buf buf = GH_BUF_INIT;
 
 	if (NIL_P(str))
-		return rb_str_new2("");
+		return eu_new_str("", 0);
 
 	Check_Type(str, T_STRING);
-	out_buf = bufnew(chunk_size);
+	check_utf8_encoding(str);
 
-	callback(out_buf, (uint8_t *)RSTRING_PTR(str), RSTRING_LEN(str));
-	result = rb_str_new((char *)out_buf->data, out_buf->size);
-	bufrelease(out_buf);
-
-#ifdef HAVE_RUBY_ENCODING_H
-	rb_enc_copy(result, str);
-#endif
+	if (do_escape(&buf, (const uint8_t *)RSTRING_PTR(str), RSTRING_LEN(str))) {
+		VALUE result = eu_new_str(buf.ptr, buf.size);
+		gh_buf_free(&buf);
+		return result;
+	}
 
-	return result;
+	return str;
 }
 
 
@@ -71,8 +96,8 @@ rb_eu__generic(
  */
 static VALUE rb_eu_escape_html(int argc, VALUE *argv, VALUE self)
 {
-	VALUE rb_out_buf, str, rb_secure;
-	struct buf *out_buf;
+	VALUE str, rb_secure;
+	gh_buf buf = GH_BUF_INIT;
 	int secure = g_html_secure;
 
 	if (rb_scan_args(argc, argv, "11", &str, &rb_secure) == 2) {
@@ -82,23 +107,29 @@ static VALUE rb_eu_escape_html(int argc, VALUE *argv, VALUE self)
 	}
 
 	Check_Type(str, T_STRING);
-	out_buf = bufnew(128);
-
-	houdini_escape_html(out_buf, (uint8_t *)RSTRING_PTR(str), RSTRING_LEN(str), secure);
+	check_utf8_encoding(str);
 
-	rb_out_buf = rb_str_new((char *)out_buf->data, out_buf->size);
-	bufrelease(out_buf);
-
-#ifdef HAVE_RUBY_ENCODING_H
-	rb_enc_copy(rb_out_buf, str);
-#endif
+	if (houdini_escape_html0(&buf, (const uint8_t *)RSTRING_PTR(str), RSTRING_LEN(str), secure)) {
+		VALUE result = eu_new_str(buf.ptr, buf.size);
+		gh_buf_free(&buf);
+		return result;
+	}
 
-	return rb_out_buf;
+	return str;
 }
 
 static VALUE rb_eu_unescape_html(VALUE self, VALUE str)
 {
-	return rb_eu__generic(self, str, &houdini_unescape_html, 128);
+	return rb_eu__generic(str, &houdini_unescape_html);
+}
+
+
+/**
+ * XML methods
+ */
+static VALUE rb_eu_escape_xml(VALUE self, VALUE str)
+{
+	return rb_eu__generic(str, &houdini_escape_xml);
 }
 
 
@@ -107,12 +138,12 @@ static VALUE rb_eu_unescape_html(VALUE self, VALUE str)
  */
 static VALUE rb_eu_escape_js(VALUE self, VALUE str)
 {
-	return rb_eu__generic(self, str, &houdini_escape_js, 128);
+	return rb_eu__generic(str, &houdini_escape_js);
 }
 
 static VALUE rb_eu_unescape_js(VALUE self, VALUE str)
 {
-	return rb_eu__generic(self, str, &houdini_unescape_js, 128);
+	return rb_eu__generic(str, &houdini_unescape_js);
 }
 
 
@@ -121,12 +152,12 @@ static VALUE rb_eu_unescape_js(VALUE self, VALUE str)
  */
 static VALUE rb_eu_escape_url(VALUE self, VALUE str)
 {
-	return rb_eu__generic(self, str, &houdini_escape_url, 32);
+	return rb_eu__generic(str, &houdini_escape_url);
 }
 
 static VALUE rb_eu_unescape_url(VALUE self, VALUE str)
 {
-	return rb_eu__generic(self, str, &houdini_unescape_url, 32);
+	return rb_eu__generic(str, &houdini_unescape_url);
 }
 
 
@@ -135,12 +166,12 @@ static VALUE rb_eu_unescape_url(VALUE self, VALUE str)
  */
 static VALUE rb_eu_escape_uri(VALUE self, VALUE str)
 {
-	return rb_eu__generic(self, str, &houdini_escape_uri, 32);
+	return rb_eu__generic(str, &houdini_escape_uri);
 }
 
 static VALUE rb_eu_unescape_uri(VALUE self, VALUE str)
 {
-	return rb_eu__generic(self, str, &houdini_unescape_uri, 32);
+	return rb_eu__generic(str, &houdini_unescape_uri);
 }
 
 
@@ -149,9 +180,16 @@ static VALUE rb_eu_unescape_uri(VALUE self, VALUE str)
  */
 void Init_escape_utils()
 {
+#ifdef HAVE_RUBY_ENCODING_H
+	VALUE rb_cEncoding = rb_const_get(rb_cObject, rb_intern("Encoding"));
+	rb_eEncodingCompatibilityError = rb_const_get(rb_cEncoding, rb_intern("CompatibilityError"));
+#endif
+
 	rb_mEscapeUtils = rb_define_module("EscapeUtils");
+
 	rb_define_method(rb_mEscapeUtils, "escape_html", rb_eu_escape_html, -1);
 	rb_define_method(rb_mEscapeUtils, "unescape_html", rb_eu_unescape_html, 1);
+	rb_define_method(rb_mEscapeUtils, "escape_xml", rb_eu_escape_xml, 1);
 	rb_define_method(rb_mEscapeUtils, "escape_javascript", rb_eu_escape_js, 1);
 	rb_define_method(rb_mEscapeUtils, "unescape_javascript", rb_eu_unescape_js, 1);
 	rb_define_method(rb_mEscapeUtils, "escape_url", rb_eu_escape_url, 1);

data/ext/escape_utils/extconf.rb

@@ -14,4 +14,4 @@ else
   $CFLAGS << " -DRB_CVAR_SET_ARITY=4 "
 end
 
-create_makefile("escape_utils")
+create_makefile("escape_utils/escape_utils")

data/ext/escape_utils/houdini.h

@@ -1,15 +1,44 @@
 #ifndef __HOUDINI_H__
 #define __HOUDINI_H__
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
 #include "buffer.h"
 
-extern void houdini_escape_html(struct buf *ob, const uint8_t *src, size_t size, int secure);
-extern void houdini_unescape_html(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_escape_uri(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_escape_url(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_unescape_uri(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_unescape_url(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_escape_js(struct buf *ob, const uint8_t *src, size_t size);
-extern void houdini_unescape_js(struct buf *ob, const uint8_t *src, size_t size);
+#define likely(x)       __builtin_expect((x),1)
+#define unlikely(x)     __builtin_expect((x),0)
+
+#ifdef HOUDINI_USE_LOCALE
+#	define _isxdigit(c) isxdigit(c)
+#	define _isdigit(c) isdigit(c)
+#else
+/*
+ * Helper _isdigit methods -- do not trust the current locale
+ * */
+#	define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL)
+#	define _isdigit(c) ((c) >= '0' && (c) <= '9')
+#endif
+
+#define HOUDINI_ESCAPED_SIZE(x) (((x) * 12) / 10)
+#define HOUDINI_UNESCAPED_SIZE(x) (x)
+
+extern int houdini_escape_html(gh_buf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_html0(gh_buf *ob, const uint8_t *src, size_t size, int secure);
+extern int houdini_unescape_html(gh_buf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_xml(gh_buf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_uri(gh_buf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_url(gh_buf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_href(gh_buf *ob, const uint8_t *src, size_t size);
+extern int houdini_unescape_uri(gh_buf *ob, const uint8_t *src, size_t size);
+extern int houdini_unescape_url(gh_buf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_js(gh_buf *ob, const uint8_t *src, size_t size);
+extern int houdini_unescape_js(gh_buf *ob, const uint8_t *src, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif