From edb7fc727a29f4ae8dcd6fee02fb5c08286808c5 Mon Sep 17 00:00:00 2001

From: "Richard W.M. Jones" <rjones@redhat.com>

Date: Thu, 9 Mar 2017 13:25:33 +0000

Subject: [PATCH 09/26] common/strbuf.c: Use size_t and ssize_t.

On 64 bit machines, strings can be longer than 2^32 characters.

size_t or ssize_t should be used to handle all offsets and lengths of

such strings to avoid overflow.

This makes the fairly mechanical change int32_t -> ssize_t and

uint32_t -> size_t.

Signed-off-by: Richard W.M. Jones <rjones@redhat.com>

---

 common/strbuf.c | 80 ++++++++++++++++++++++++++++-----------------------------

 common/strbuf.h | 50 ++++++++++++++++++------------------

 2 files changed, 65 insertions(+), 65 deletions(-)

diff --git a/common/strbuf.c b/common/strbuf.c

index 5c42873..cf90d5a 100644

--- a/common/strbuf.c

+++ b/common/strbuf.c

@@ -36,12 +36,12 @@

 #define DEFAULT_STRBUF_CAPACITY 16

-#define SWAP_INT32(a,b) { int32_t _t = (a); (a) = (b); (b) = _t; }

+#define SWAP_SSIZE_T(a,b) { ssize_t _t = (a); (a) = (b); (b) = _t; }

-static int32_t

-normalize_strbuf_pos(StrBuf *sb, int32_t pos)

+static ssize_t

+normalize_strbuf_pos(StrBuf *sb, ssize_t pos)

 {

-    if (pos >= sb->len)

+    if (pos >= (ssize_t) sb->len)

         return sb->len;

     if (pos >= 0)

         return pos;

@@ -51,8 +51,8 @@ normalize_strbuf_pos(StrBuf *sb, int32_t pos)

     return 0;

 }

-static int32_t

-normalize_str_pos(const char *str, int32_t pos)

+static ssize_t

+normalize_str_pos(const char *str, ssize_t pos)

 {

     if (str == NULL)

         return 0;

@@ -70,13 +70,13 @@ strbuf_buffer(StrBuf *sb)

     return sb->buf;

 }

-uint32_t

+size_t

 strbuf_length(StrBuf *sb)

 {

     return sb->len;

 }

-uint32_t

+size_t

 strbuf_capacity(StrBuf *sb)

 {

     return sb->capacity;

@@ -89,7 +89,7 @@ strbuf_new(void)

 }

 StrBuf *

-strbuf_new_with_capacity(uint32_t capacity)

+strbuf_new_with_capacity(size_t capacity)

 {

     StrBuf *sb;

     sb = xmalloc(sizeof(StrBuf));

@@ -102,24 +102,24 @@ strbuf_new_with_capacity(uint32_t capacity)

 }

 StrBuf *

-strbuf_new_from_char_n(uint32_t times, char ch)

+strbuf_new_from_char_n(size_t times, char ch)

 {

     return strbuf_new_from_substring_n(times, &ch, 0, 1);

 }

 StrBuf *

-strbuf_new_from_substring_n(uint32_t times, const char *substr, int32_t subsp, int32_t subep)

+strbuf_new_from_substring_n(size_t times, const char *substr, ssize_t subsp, ssize_t subep)

 {

     subsp = normalize_str_pos(substr, subsp);

     subep = normalize_str_pos(substr, subep);

     if (subsp > subep)

-    	SWAP_INT32(subsp, subep);

+    	SWAP_SSIZE_T(subsp, subep);

     return strbuf_new_from_data_n(times, substr+subsp, subep-subsp);

 }

 StrBuf *

-strbuf_new_from_data_n(uint32_t times, const void *mem, uint32_t len)

+strbuf_new_from_data_n(size_t times, const void *mem, size_t len)

 {

     StrBuf *sb;

@@ -133,7 +133,7 @@ strbuf_new_from_data_n(uint32_t times, const void *mem, uint32_t len)

 }

 StrBuf *

-strbuf_newf_n(uint32_t times, const char *fmt, ...)

+strbuf_newf_n(size_t times, const char *fmt, ...)

 {

     va_list ap;

     StrBuf *buf;

@@ -146,7 +146,7 @@ strbuf_newf_n(uint32_t times, const char *fmt, ...)

 }

 StrBuf *

-strbuf_vnewf_n(uint32_t times, const char *fmt, va_list ap)

+strbuf_vnewf_n(size_t times, const char *fmt, va_list ap)

 {

     char *str;

     int len;

@@ -171,7 +171,7 @@ strbuf_free(StrBuf *sb)

 }

 char *

-strbuf_free_to_substring(StrBuf *sb, int32_t sp, int32_t ep)

+strbuf_free_to_substring(StrBuf *sb, ssize_t sp, ssize_t ep)

 {

     char *buf;

@@ -182,7 +182,7 @@ strbuf_free_to_substring(StrBuf *sb, int32_t sp, int32_t ep)

     sb->buf[ep-sp] = '\0';

     /* Call realloc so that unused memory can be used for other purpose. */

-    if (sp == 0 && ep == sb->len)

+    if (sp == 0 && ep == (ssize_t) sb->len)

 	buf = sb->buf;

     else

 	buf = xrealloc(sb->buf, ep-sp+1);

@@ -191,21 +191,21 @@ strbuf_free_to_substring(StrBuf *sb, int32_t sp, int32_t ep)

 }

 void

-strbuf_replace_char_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, char ch)

+strbuf_replace_char_n(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times, char ch)

 {

     strbuf_replace_substring_n(sb, sp, ep, times, &ch, 0, 1);

 }

 void

-strbuf_replace_data_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const void *mem, uint32_t len)

+strbuf_replace_data_n(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times, const void *mem, size_t len)

 {

-    uint32_t addlen;

-    uint32_t dellen;

+    size_t addlen;

+    size_t dellen;

     sp = normalize_strbuf_pos(sb, sp);

     ep = normalize_strbuf_pos(sb, ep);

     if (sp > ep)

-    	SWAP_INT32(sp, ep);

+    	SWAP_SSIZE_T(sp, ep);

     addlen = len * times;

     dellen = ep-sp;

@@ -223,18 +223,18 @@ strbuf_replace_data_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const

 }

 void

-strbuf_replace_substring_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const char *substr, int32_t subsp, int32_t subep)

+strbuf_replace_substring_n(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times, const char *substr, ssize_t subsp, ssize_t subep)

 {

     subsp = normalize_str_pos(substr, subsp);

     subep = normalize_str_pos(substr, subep);

     if (subsp > subep)

-    	SWAP_INT32(subsp, subep);

+    	SWAP_SSIZE_T(subsp, subep);

     strbuf_replace_data_n(sb, sp, ep, times, substr+subsp, subep-subsp);

 }

 int

-strbuf_replacef_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const char *fmt, ...)

+strbuf_replacef_n(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times, const char *fmt, ...)

 {

     va_list ap;

     int len;

@@ -247,7 +247,7 @@ strbuf_replacef_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const char

 }

 int

-strbuf_vreplacef_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const char *fmt, va_list ap)

+strbuf_vreplacef_n(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times, const char *fmt, va_list ap)

 {

     char *str;

     int len;

@@ -255,7 +255,7 @@ strbuf_vreplacef_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const cha

     sp = normalize_strbuf_pos(sb, sp);

     ep = normalize_strbuf_pos(sb, ep);

     if (sp > ep)

-    	SWAP_INT32(sp, ep);

+    	SWAP_SSIZE_T(sp, ep);

     len = vasprintf(&str, fmt, ap);

     if (len < 0)

@@ -267,29 +267,29 @@ strbuf_vreplacef_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const cha

 }

 void

-strbuf_reverse_substring(StrBuf *sb, int32_t sp, int32_t ep)

+strbuf_reverse_substring(StrBuf *sb, ssize_t sp, ssize_t ep)

 {

     sp = normalize_strbuf_pos(sb, sp);

     ep = normalize_strbuf_pos(sb, ep);

     while (sp < ep) {

-    	SWAP_INT32(sb->buf[sp], sb->buf[ep]);

+    	SWAP_SSIZE_T(sb->buf[sp], sb->buf[ep]);

     	sp++;

 	ep--;

     }

 }

 void

-strbuf_repeat_substring(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times)

+strbuf_repeat_substring(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times)

 {

-    int32_t addlen;

+    ssize_t addlen;

     sp = normalize_strbuf_pos(sb, sp);

     ep = normalize_strbuf_pos(sb, ep);

     addlen = (ep-sp) * (times - 1);

     if (addlen != 0) {

-    	uint32_t p;

+    	size_t p;

     	strbuf_ensure_capacity(sb, sb->len+1+addlen);

 	memmove(sb->buf+sp+addlen, sb->buf+ep, sb->len+1-ep);

@@ -304,7 +304,7 @@ strbuf_repeat_substring(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times)

 }

 void

-strbuf_set_length(StrBuf *sb, uint32_t new_length)

+strbuf_set_length(StrBuf *sb, size_t new_length)

 {

     strbuf_ensure_capacity(sb, new_length+1);

     sb->buf[new_length] = '\0';

@@ -313,7 +313,7 @@ strbuf_set_length(StrBuf *sb, uint32_t new_length)

 /* Note: The terminating null-byte counts as 1 in min_capacity */

 void

-strbuf_ensure_capacity(StrBuf *sb, uint32_t min_capacity)

+strbuf_ensure_capacity(StrBuf *sb, size_t min_capacity)

 {

     if (min_capacity > sb->capacity) {

 	sb->capacity = MAX(min_capacity, sb->len*2+2); /* MAX -> max */

@@ -324,14 +324,14 @@ strbuf_ensure_capacity(StrBuf *sb, uint32_t min_capacity)

 }

 char *

-strbuf_substring(StrBuf *sb, int32_t sp, int32_t ep)

+strbuf_substring(StrBuf *sb, ssize_t sp, ssize_t ep)

 {

     char *str;

     sp = normalize_strbuf_pos(sb, sp);

     ep = normalize_strbuf_pos(sb, ep);

     if (sp > ep)

-    	SWAP_INT32(sp, ep);

+    	SWAP_SSIZE_T(sp, ep);

     str = xmalloc((ep-sp+1) * sizeof(char));

     memcpy(str, sb->buf+sp, (ep-sp+1) * sizeof(char));

@@ -341,14 +341,14 @@ strbuf_substring(StrBuf *sb, int32_t sp, int32_t ep)

 }

 char

-strbuf_char_at(StrBuf *sb, int32_t sp)

+strbuf_char_at(StrBuf *sb, ssize_t sp)

 {

     return sb->buf[normalize_strbuf_pos(sb, sp)];

 }

 #if 0

 char

-strbuf_set_char_at(StrBuf *sb, int32_t sp, char chr)

+strbuf_set_char_at(StrBuf *sb, ssize_t sp, char chr)

 {

     char old;

@@ -364,13 +364,13 @@ strbuf_set_char_at(StrBuf *sb, int32_t sp, char chr)

 }

 void

-strbuf_replace_strbuf(StrBuf *sb, int32_t sp, int32_t ep, StrBuf *strbuf)

+strbuf_replace_strbuf(StrBuf *sb, ssize_t sp, ssize_t ep, StrBuf *strbuf)

 {

     strbuf_replace_data_n(sb,sp,ep,1,strbuf->buf,strbuf->len);

 }

 char

-strbuf_delete_char(StrBuf *sb, int32_t sp)

+strbuf_delete_char(StrBuf *sb, ssize_t sp)

 {

 }

diff --git a/common/strbuf.h b/common/strbuf.h

index 67a523d..6cd0d58 100644

--- a/common/strbuf.h

+++ b/common/strbuf.h

@@ -28,16 +28,16 @@ typedef struct _StrBuf StrBuf;

 struct _StrBuf {

     char *buf;

-    uint32_t len;

-    uint32_t capacity;

+    size_t len;

+    size_t capacity;

 };

 void strbuf_free(StrBuf *sb);

 #define strbuf_free_to_string(sb)			strbuf_free_to_substring(sb,0,-1)

-char *strbuf_free_to_substring(StrBuf *sb, int32_t sp, int32_t ep);

+char *strbuf_free_to_substring(StrBuf *sb, ssize_t sp, ssize_t ep);

 StrBuf *strbuf_new(void);

-StrBuf *strbuf_new_with_capacity(uint32_t capacity);

+StrBuf *strbuf_new_with_capacity(size_t capacity);

 #define strbuf_new_from_char(chr)			strbuf_new_from_char_n(1,chr)

 #define strbuf_new_from_string(str) 	    	    	strbuf_new_from_substring(str,0,-1)

@@ -46,12 +46,12 @@ StrBuf *strbuf_new_with_capacity(uint32_t capacity);

 #define strbuf_new_from_substring(str,ssp,sep)		strbuf_new_from_substring_n(1,str,ssp,sep)

 #define strbuf_newf(fmt...)				strbuf_newf_n(1,fmt)

 #define strbuf_vnewf(fmt,ap)				strbuf_vnewf_n(1,fmt,ap)

-StrBuf *strbuf_new_from_char_n(uint32_t times, char ch);

+StrBuf *strbuf_new_from_char_n(size_t times, char ch);

 #define strbuf_new_from_string_n(n,str)			strbuf_new_from_substring_n(n,str,0,-1)

-StrBuf *strbuf_new_from_substring_n(uint32_t times, const char *str, int32_t sp, int32_t ep);

-StrBuf *strbuf_new_from_data_n(uint32_t times, const void *mem, uint32_t len);

-StrBuf *strbuf_newf_n(uint32_t times, const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));

-StrBuf *strbuf_vnewf_n(uint32_t times, const char *fmt, va_list ap) __attribute__ ((format (printf, 2, 0)));

+StrBuf *strbuf_new_from_substring_n(size_t times, const char *str, ssize_t sp, ssize_t ep);

+StrBuf *strbuf_new_from_data_n(size_t times, const void *mem, size_t len);

+StrBuf *strbuf_newf_n(size_t times, const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));

+StrBuf *strbuf_vnewf_n(size_t times, const char *fmt, va_list ap) __attribute__ ((format (printf, 2, 0)));

 #define strbuf_append_char(sb,chr)   	    	        strbuf_append_char_n(sb,1,chr)

 #define strbuf_append(sb,str) 	    	    	        strbuf_append_n(sb,1,str)

@@ -116,38 +116,38 @@ StrBuf *strbuf_vnewf_n(uint32_t times, const char *fmt, va_list ap) __attribute_

 #define strbuf_replace_char(sb,sp,ep,ch)                strbuf_replace_char_n(sb,sp,ep,1,ch)

 #define strbuf_replace(sb,sp,ep,str)	    	        strbuf_replace_n(sb,sp,ep,1,str)

 #define strbuf_replace_data(sb,sp,ep,mem,len)	    	strbuf_replace_data_n(sb,sp,ep,1,mem,len)

-void strbuf_replace_strbuf(StrBuf *sb, int32_t sp, int32_t ep, StrBuf *strbuf); /* or strbuf_replace_data_n(sb,sp,ep,1,strbuf_buffer(strbuf),strbuf_length(strbuf))*/

+void strbuf_replace_strbuf(StrBuf *sb, ssize_t sp, ssize_t ep, StrBuf *strbuf); /* or strbuf_replace_data_n(sb,sp,ep,1,strbuf_buffer(strbuf),strbuf_length(strbuf))*/

 #define strbuf_replace_substring(sb,sp,ep,str,ssp,sep)  strbuf_replace_substring_n(sb,sp,ep,1,str,ssp,sep)

 #define strbuf_replacef(sb,sp,ep,fmt...)                strbuf_replacef_n(sb,sp,ep,1,fmt)

 #define strbuf_vreplacef(sb,sp,ep,fmt,ap)               strbuf_vreplacef_n(sb,sp,ep,1,fmt,ap)

-void strbuf_replace_char_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, char ch);

+void strbuf_replace_char_n(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times, char ch);

 #define strbuf_replace_n(sb,sp,ep,n,str)	    	strbuf_replace_substring_n(sb,sp,ep,n,str,0,-1)

-void strbuf_replace_substring_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const char *str, int32_t ssp, int32_t sep);

-void strbuf_replace_data_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const void *mem, uint32_t len);

-int strbuf_replacef_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const char *fmt, ...) __attribute__ ((format (printf, 5, 6)));

-int strbuf_vreplacef_n(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times, const char *fmt, va_list ap) __attribute__ ((format (printf, 5, 0)));

+void strbuf_replace_substring_n(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times, const char *str, ssize_t ssp, ssize_t sep);

+void strbuf_replace_data_n(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times, const void *mem, size_t len);

+int strbuf_replacef_n(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times, const char *fmt, ...) __attribute__ ((format (printf, 5, 6)));

+int strbuf_vreplacef_n(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times, const char *fmt, va_list ap) __attribute__ ((format (printf, 5, 0)));

-char strbuf_set_char_at(StrBuf *sb, int32_t sp, char chr); 	/* or strbuf_replace_char(sb,sp,strbuf_next_pos(sb,sp),chr) */

-char strbuf_delete_char(StrBuf *sb, int32_t sp); 		/* or strbuf_replace(sb,sp,strbuf_next_pos(sb,sp),NULL) */

+char strbuf_set_char_at(StrBuf *sb, ssize_t sp, char chr); 	/* or strbuf_replace_char(sb,sp,strbuf_next_pos(sb,sp),chr) */

+char strbuf_delete_char(StrBuf *sb, ssize_t sp); 		/* or strbuf_replace(sb,sp,strbuf_next_pos(sb,sp),NULL) */

 #define strbuf_delete(sb,sp,ep)   	    	        strbuf_replace(sb,sp,ep,NULL)

 #define strbuf_clear(sb)   	    	    	        strbuf_replace(sb,0,-1,NULL)

-void strbuf_reverse_substring(StrBuf *sb, int32_t sp, int32_t ep);

+void strbuf_reverse_substring(StrBuf *sb, ssize_t sp, ssize_t ep);

 #define strbuf_reverse(sb)  	    	    	        strbuf_reverse_substring(sb,0,-1)

-void strbuf_repeat_substring(StrBuf *sb, int32_t sp, int32_t ep, uint32_t times);

+void strbuf_repeat_substring(StrBuf *sb, ssize_t sp, ssize_t ep, size_t times);

 #define strbuf_repeat(sb,n)  	    	    	        strbuf_repeat_substring(sb,0,-1,n)

-uint32_t strbuf_length(StrBuf *sb);

-uint32_t strbuf_capacity(StrBuf *sb);

+size_t strbuf_length(StrBuf *sb);

+size_t strbuf_capacity(StrBuf *sb);

 char *strbuf_buffer(StrBuf *sb);

 #define strbuf_is_empty(sb)				(strbuf_length(sb) == 0)

-void strbuf_set_length(StrBuf *sb, uint32_t new_length);

-void strbuf_ensure_capacity(StrBuf *sb, uint32_t minimum_capacity); /* minimum_capacity should account for null-byte */

+void strbuf_set_length(StrBuf *sb, size_t new_length);

+void strbuf_ensure_capacity(StrBuf *sb, size_t minimum_capacity); /* minimum_capacity should account for null-byte */

-char *strbuf_substring(StrBuf *sb, int32_t sp, int32_t ep);

+char *strbuf_substring(StrBuf *sb, ssize_t sp, ssize_t ep);

 #define strbuf_to_string(sb)	    	    	        strbuf_substring(sb,0,-1)

-char strbuf_char_at(StrBuf *sb, int32_t index);

+char strbuf_char_at(StrBuf *sb, ssize_t index);

 #endif

-- 

2.10.2