ox 2.14.13 → 2.14.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9742d803f0730d6e9724d0f08809ec291b474beae8e966cf3b9ab3c95e165fa
-  data.tar.gz: 102f6dc50ee242f5a7cbb4e8395aa4004d826679b5b02f0e9734d3e8d206d7ec
+  metadata.gz: 673ab7acb7140b9e29888304ab457c13558c2f774dbd4364d1899349b6f68210
+  data.tar.gz: 7eebc70a320a14359ba774c22700764916fd1b3399b1e3bf9e555e43f1643a5b
 SHA512:
-  metadata.gz: 754fe3197d3944d4b398ba0334d62bc45d066448885e9a47ac8216c0a292203f273c4f0ab764a3ec4e5e49ebc472282ac89821aa0f03929491c60c659494e02b
-  data.tar.gz: 31f01b2ca8b2440511c9eda13fe590937bfd266173d83befcc81e228c0e8516545a29369755f1575c2e8bdb11aac791e463a397035fafed8e13848a23c8fb255
+  metadata.gz: 6019b22adf12fe6390280281705552a171c62e5863f74281f658ceb1743401f429b9324716bbb7eaa96a79ea06f1d8a1f205c8706fb00685c3fe45bdeed00f9d
+  data.tar.gz: f64209e6be760b0f6a1606c7ecbcbd51769ddd70bc908b21b1b935ab99ce5ba9f7049015171f7b9fd6ec2801d20823b40b5546a80d1736ce84ddfa7a2acb7278

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All changes to the Ox gem are documented here. Releases follow semantic versioning.
 
+## [2.14.15] - 2023-04-10
+
+### Fixed
+
+- Fixed free on moved pointer.
+
+## [2.14.14] - 2023-01-26
+
+### Fixed
+
+- Change free to xfree on ruby alloced memory.
+
 ## [2.14.13] - 2023-01-16
 
 ### Fixed

data/README.md

@@ -1,7 +1,7 @@
 # Ox gem
 A fast XML parser and Object marshaller as a Ruby gem.
 
-[![Build Status](https://img.shields.io/github/workflow/status/ohler55/ox/CI?logo=github)](https://github.com/ohler55/ox/actions/workflows/CI.yml)
+[![CI](https://github.com/ohler55/ox/actions/workflows/CI.yml/badge.svg)](https://github.com/ohler55/ox/actions/workflows/CI.yml)
 
 ## Installation
     gem install ox

data/ext/ox/attr.h

@@ -6,77 +6,71 @@
 #ifndef OX_ATTR_H
 #define OX_ATTR_H
 
-#include "ox.h"
+#include <ruby.h>
 
-#define ATTR_STACK_INC	8
+#define ATTR_STACK_INC 8
 
 typedef struct _attr {
-    const char	*name;
-    const char	*value;
+    const char *name;
+    const char *value;
 } *Attr;
 
 typedef struct _attrStack {
-    struct _attr	base[ATTR_STACK_INC];
-    Attr		head;	/* current stack */
-    Attr		end;	/* stack end */
-    Attr		tail;	/* pointer to one past last element name on stack */
+    struct _attr base[ATTR_STACK_INC];
+    Attr         head; /* current stack */
+    Attr         end;  /* stack end */
+    Attr         tail; /* pointer to one past last element name on stack */
 } *AttrStack;
 
-inline static void
-attr_stack_init(AttrStack stack) {
-    stack->head = stack->base;
-    stack->end = stack->base + sizeof(stack->base) / sizeof(struct _attr);
-    stack->tail = stack->head;
+inline static void attr_stack_init(AttrStack stack) {
+    stack->head       = stack->base;
+    stack->end        = stack->base + sizeof(stack->base) / sizeof(struct _attr);
+    stack->tail       = stack->head;
     stack->head->name = 0;
 }
 
-inline static int
-attr_stack_empty(AttrStack stack) {
+inline static int attr_stack_empty(AttrStack stack) {
     return (stack->head == stack->tail);
 }
 
-inline static void
-attr_stack_cleanup(AttrStack stack) {
+inline static void attr_stack_cleanup(AttrStack stack) {
     if (stack->base != stack->head) {
         xfree(stack->head);
-	stack->head = stack->base;
+        stack->head = stack->base;
     }
 }
 
-inline static void
-attr_stack_push(AttrStack stack, const char *name, const char *value) {
+inline static void attr_stack_push(AttrStack stack, const char *name, const char *value) {
     if (stack->end <= stack->tail + 1) {
-	size_t	len = stack->end - stack->head;
-	size_t	toff = stack->tail - stack->head;
+        size_t len  = stack->end - stack->head;
+        size_t toff = stack->tail - stack->head;
 
-	if (stack->base == stack->head) {
-	    stack->head = ALLOC_N(struct _attr, len + ATTR_STACK_INC);
-	    memcpy(stack->head, stack->base, sizeof(struct _attr) * len);
-	} else {
-	    REALLOC_N(stack->head, struct _attr, len + ATTR_STACK_INC);
-	}
-	stack->tail = stack->head + toff;
-	stack->end = stack->head + len + ATTR_STACK_INC;
+        if (stack->base == stack->head) {
+            stack->head = ALLOC_N(struct _attr, len + ATTR_STACK_INC);
+            memcpy(stack->head, stack->base, sizeof(struct _attr) * len);
+        } else {
+            REALLOC_N(stack->head, struct _attr, len + ATTR_STACK_INC);
+        }
+        stack->tail = stack->head + toff;
+        stack->end  = stack->head + len + ATTR_STACK_INC;
     }
-    stack->tail->name = name;
+    stack->tail->name  = name;
     stack->tail->value = value;
     stack->tail++;
-    stack->tail->name = 0; // terminate
+    stack->tail->name = 0;  // terminate
 }
 
-inline static Attr
-attr_stack_peek(AttrStack stack) {
+inline static Attr attr_stack_peek(AttrStack stack) {
     if (stack->head < stack->tail) {
-	return stack->tail - 1;
+        return stack->tail - 1;
     }
     return 0;
 }
 
-inline static Attr
-attr_stack_pop(AttrStack stack) {
+inline static Attr attr_stack_pop(AttrStack stack) {
     if (stack->head < stack->tail) {
-	stack->tail--;
-	return stack->tail;
+        stack->tail--;
+        return stack->tail;
     }
     return 0;
 }

data/ext/ox/base64.c

@@ -3,15 +3,15 @@
  * All rights reserved.
  */
 
-#include <stdlib.h>
-#include <stdio.h>
-
 #include "base64.h"
 
-static char	digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+#include <stdio.h>
+#include <stdlib.h>
+
+static char digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 /* invalid or terminating characters are set to 'X' or \x58 */
-static uchar	s_digits[256] = "\
+static uchar s_digits[256] = "\
 \x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
 \x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
 \x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x3E\x58\x58\x58\x3F\
@@ -29,46 +29,45 @@ static uchar	s_digits[256] = "\
 \x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
 \x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58";
 
-void
-to_base64(const uchar *src, int len, char *b64) {
-    const uchar	*end3;
-    int		len3 = len % 3;
-    uchar	b1, b2, b3;
-    
+void to_base64(const uchar *src, int len, char *b64) {
+    const uchar *end3;
+    int          len3 = len % 3;
+    uchar        b1, b2, b3;
+
     end3 = src + (len - len3);
     while (src < end3) {
-	b1 = *src++;
-	b2 = *src++;
-	b3 = *src++;
-	*b64++ = digits[(uchar)(b1 >> 2)];
-	*b64++ = digits[(uchar)(((b1 & 0x03) << 4) | (b2 >> 4))];
-	*b64++ = digits[(uchar)(((b2 & 0x0F) << 2) | (b3 >> 6))];
-	*b64++ = digits[(uchar)(b3 & 0x3F)];
+        b1     = *src++;
+        b2     = *src++;
+        b3     = *src++;
+        *b64++ = digits[(uchar)(b1 >> 2)];
+        *b64++ = digits[(uchar)(((b1 & 0x03) << 4) | (b2 >> 4))];
+        *b64++ = digits[(uchar)(((b2 & 0x0F) << 2) | (b3 >> 6))];
+        *b64++ = digits[(uchar)(b3 & 0x3F)];
     }
     if (1 == len3) {
-	b1 = *src++;
-	*b64++ = digits[b1 >> 2];
-	*b64++ = digits[(b1 & 0x03) << 4];
-	*b64++ = '=';
-	*b64++ = '=';
+        b1     = *src++;
+        *b64++ = digits[b1 >> 2];
+        *b64++ = digits[(b1 & 0x03) << 4];
+        *b64++ = '=';
+        *b64++ = '=';
     } else if (2 == len3) {
-	b1 = *src++;
-	b2 = *src++;
-	*b64++ = digits[b1 >> 2];
-	*b64++ = digits[((b1 & 0x03) << 4) | (b2 >> 4)];
-	*b64++ = digits[(b2 & 0x0F) << 2];
-	*b64++ = '=';
+        b1     = *src++;
+        b2     = *src++;
+        *b64++ = digits[b1 >> 2];
+        *b64++ = digits[((b1 & 0x03) << 4) | (b2 >> 4)];
+        *b64++ = digits[(b2 & 0x0F) << 2];
+        *b64++ = '=';
     }
     *b64 = '\0';
 }
 
-unsigned long
-b64_orig_size(const char *text) {
-    const char          *start = text;
-    unsigned long        size = 0;
+unsigned long b64_orig_size(const char *text) {
+    const char   *start = text;
+    unsigned long size  = 0;
 
     if ('\0' != *text) {
-        for (; 0 != *text; text++) { }
+        for (; 0 != *text; text++) {
+        }
         size = (text - start) * 3 / 4;
         text--;
         if ('=' == *text) {
@@ -82,17 +81,24 @@ b64_orig_size(const char *text) {
     return size;
 }
 
-void
-from_base64(const char *b64, uchar *str) {
-    uchar	b0, b1, b2, b3;
-    
+void from_base64(const char *b64, uchar *str) {
+    uchar b0, b1, b2, b3;
+
     while (1) {
-        if ('X' == (b0 = s_digits[(uchar)*b64++])) { break; }
-        if ('X' == (b1 = s_digits[(uchar)*b64++])) { break; }
+        if ('X' == (b0 = s_digits[(uchar)*b64++])) {
+            break;
+        }
+        if ('X' == (b1 = s_digits[(uchar)*b64++])) {
+            break;
+        }
         *str++ = (b0 << 2) | ((b1 >> 4) & 0x03);
-        if ('X' == (b2 = s_digits[(uchar)*b64++])) { break; }
+        if ('X' == (b2 = s_digits[(uchar)*b64++])) {
+            break;
+        }
         *str++ = (b1 << 4) | ((b2 >> 2) & 0x0F);
-        if ('X' == (b3 = s_digits[(uchar)*b64++])) { break; }
+        if ('X' == (b3 = s_digits[(uchar)*b64++])) {
+            break;
+        }
         *str++ = (b2 << 6) | b3;
     }
     *str = '\0';

data/ext/ox/base64.h

@@ -6,13 +6,13 @@
 #ifndef BASE64_H
 #define BASE64_H
 
-typedef unsigned char	uchar;
+typedef unsigned char uchar;
 
 #define b64_size(len) ((len + 2) / 3 * 4)
 
-extern unsigned long    b64_orig_size(const char *text);
+extern unsigned long b64_orig_size(const char *text);
 
-extern void	        to_base64(const uchar *src, int len, char *b64);
-extern void             from_base64(const char *b64, uchar *str);
+extern void to_base64(const uchar *src, int len, char *b64);
+extern void from_base64(const char *b64, uchar *str);
 
 #endif /* BASE64_H */

data/ext/ox/buf.h

@@ -31,137 +31,131 @@
 #ifndef OX_BUF_H
 #define OX_BUF_H
 
+#include <ruby.h>
 #include <stdbool.h>
 #include <unistd.h>
 
 typedef struct _buf {
-    char	*head;
-    char	*end;
-    char	*tail;
-    int		fd;
-    bool	err;
-    char	base[16384];
+    char *head;
+    char *end;
+    char *tail;
+    int   fd;
+    bool  err;
+    char  base[16384];
 } *Buf;
 
-inline static void
-buf_init(Buf buf, int fd, long initial_size) {
+inline static void buf_init(Buf buf, int fd, long initial_size) {
     if (sizeof(buf->base) < (size_t)initial_size) {
-	buf->head = ALLOC_N(char, initial_size);
-	buf->end = buf->head + initial_size - 1;
+        buf->head = ALLOC_N(char, initial_size);
+        buf->end  = buf->head + initial_size - 1;
     } else {
-	buf->head = buf->base;
-	buf->end = buf->base + sizeof(buf->base) - 1;
+        buf->head = buf->base;
+        buf->end  = buf->base + sizeof(buf->base) - 1;
     }
     buf->tail = buf->head;
-    buf->fd = fd;
-    buf->err = false;
+    buf->fd   = fd;
+    buf->err  = false;
 }
 
-inline static void
-buf_reset(Buf buf) {
+inline static void buf_reset(Buf buf) {
     buf->head = buf->base;
     buf->tail = buf->head;
 }
 
-inline static void
-buf_cleanup(Buf buf) {
+inline static void buf_cleanup(Buf buf) {
     if (buf->base != buf->head) {
         free(buf->head);
     }
 }
 
-inline static size_t
-buf_len(Buf buf) {
+inline static size_t buf_len(Buf buf) {
     return buf->tail - buf->head;
 }
 
-inline static void
-buf_append_string(Buf buf, const char *s, size_t slen) {
+inline static void buf_append_string(Buf buf, const char *s, size_t slen) {
     if (buf->err) {
-	return;
+        return;
     }
     if (buf->end <= buf->tail + slen) {
-	if (0 != buf->fd) {
-	    size_t	len = buf->tail - buf->head;
-
-	    if (len != (size_t)write(buf->fd, buf->head, len)) {
-		buf->err = true;
-		return;
-	    }
-	    buf->tail = buf->head;
-	    if (sizeof(buf->base) <= slen) {
-		if (slen != (size_t)write(buf->fd, s, slen)) {
-		    buf->err = true;
-		    return;
-		}
-		return;
-	    }
-	} else {
-	    size_t	len = buf->end - buf->head;
-	    size_t	toff = buf->tail - buf->head;
-	    size_t	new_len = len + slen + len / 2;
-
-	    if (buf->base == buf->head) {
-		buf->head = ALLOC_N(char, new_len);
-		memcpy(buf->head, buf->base, len);
-	    } else {
-		REALLOC_N(buf->head, char, new_len);
-	    }
-	    buf->tail = buf->head + toff;
-	    buf->end = buf->head + new_len - 2;
-	}
+        if (0 != buf->fd) {
+            size_t len = buf->tail - buf->head;
+
+            if (len != (size_t)write(buf->fd, buf->head, len)) {
+                buf->err = true;
+                return;
+            }
+            buf->tail = buf->head;
+            if (sizeof(buf->base) <= slen) {
+                if (slen != (size_t)write(buf->fd, s, slen)) {
+                    buf->err = true;
+                    return;
+                }
+                return;
+            }
+        } else {
+            size_t len     = buf->end - buf->head;
+            size_t toff    = buf->tail - buf->head;
+            size_t new_len = len + slen + len / 2;
+
+            if (buf->base == buf->head) {
+                buf->head = ALLOC_N(char, new_len);
+                memcpy(buf->head, buf->base, len);
+            } else {
+                REALLOC_N(buf->head, char, new_len);
+            }
+            buf->tail = buf->head + toff;
+            buf->end  = buf->head + new_len - 2;
+        }
     }
     if (0 < slen) {
-	memcpy(buf->tail, s, slen);
+        memcpy(buf->tail, s, slen);
     }
     buf->tail += slen;
 }
 
-inline static void
-buf_append(Buf buf, char c) {
+inline static void buf_append(Buf buf, char c) {
     if (buf->err) {
-	return;
+        return;
     }
     if (buf->end <= buf->tail) {
-	if (0 != buf->fd) {
-	    size_t	len = buf->tail - buf->head;
-
-	    if (len != (size_t)write(buf->fd, buf->head, len)) {
-		buf->err = true;
-	    }
-	    buf->tail = buf->head;
-	} else {
-	    size_t	len = buf->end - buf->head;
-	    size_t	toff = buf->tail - buf->head;
-	    size_t	new_len = len + len / 2;
-
-	    if (buf->base == buf->head) {
-		buf->head = ALLOC_N(char, new_len);
-		memcpy(buf->head, buf->base, len);
-	    } else {
-		REALLOC_N(buf->head, char, new_len);
-	    }
-	    buf->tail = buf->head + toff;
-	    buf->end = buf->head + new_len - 2;
-	}
+        if (0 != buf->fd) {
+            size_t len = buf->tail - buf->head;
+
+            if (len != (size_t)write(buf->fd, buf->head, len)) {
+                buf->err = true;
+            }
+            buf->tail = buf->head;
+        } else {
+            size_t len     = buf->end - buf->head;
+            size_t toff    = buf->tail - buf->head;
+            size_t new_len = len + len / 2;
+
+            if (buf->base == buf->head) {
+                buf->head = ALLOC_N(char, new_len);
+                memcpy(buf->head, buf->base, len);
+            } else {
+                REALLOC_N(buf->head, char, new_len);
+            }
+            buf->tail = buf->head + toff;
+            buf->end  = buf->head + new_len - 2;
+        }
     }
     *buf->tail++ = c;
     //*buf->tail = '\0'; // for debugging
 }
 
-inline static void
-buf_finish(Buf buf) {
+inline static void buf_finish(Buf buf) {
     if (buf->err) {
-	return;
+        return;
     }
     if (0 != buf->fd) {
-	size_t	len = buf->tail - buf->head;
+        size_t len = buf->tail - buf->head;
 
-	if (0 < len && len != (size_t)write(buf->fd, buf->head, len)) {
-	    buf->err = true;
-	}
-	fsync(buf->fd);
-	buf->tail = buf->head;
+        if (0 < len && len != (size_t)write(buf->fd, buf->head, len)) {
+            buf->err = true;
+        }
+        fsync(buf->fd);
+        buf->tail = buf->head;
     }
 }