1 #include "debug.h" 2 #include "cache.h" 3 #include <linux/kernel.h> 4 5 int prefixcmp(const char *str, const char *prefix) 6 { 7 for (; ; str++, prefix++) 8 if (!*prefix) 9 return 0; 10 else if (*str != *prefix) 11 return (unsigned char)*prefix - (unsigned char)*str; 12 } 13 14 /* 15 * Used as the default ->buf value, so that people can always assume 16 * buf is non NULL and ->buf is NUL terminated even for a freshly 17 * initialized strbuf. 18 */ 19 char strbuf_slopbuf[1]; 20 21 int strbuf_init(struct strbuf *sb, ssize_t hint) 22 { 23 sb->alloc = sb->len = 0; 24 sb->buf = strbuf_slopbuf; 25 if (hint) 26 return strbuf_grow(sb, hint); 27 return 0; 28 } 29 30 void strbuf_release(struct strbuf *sb) 31 { 32 if (sb->alloc) { 33 zfree(&sb->buf); 34 strbuf_init(sb, 0); 35 } 36 } 37 38 char *strbuf_detach(struct strbuf *sb, size_t *sz) 39 { 40 char *res = sb->alloc ? sb->buf : NULL; 41 if (sz) 42 *sz = sb->len; 43 strbuf_init(sb, 0); 44 return res; 45 } 46 47 int strbuf_grow(struct strbuf *sb, size_t extra) 48 { 49 char *buf; 50 size_t nr = sb->len + extra + 1; 51 52 if (nr < sb->alloc) 53 return 0; 54 55 if (nr <= sb->len) 56 return -E2BIG; 57 58 if (alloc_nr(sb->alloc) > nr) 59 nr = alloc_nr(sb->alloc); 60 61 /* 62 * Note that sb->buf == strbuf_slopbuf if sb->alloc == 0, and it is 63 * a static variable. Thus we have to avoid passing it to realloc. 64 */ 65 buf = realloc(sb->alloc ? sb->buf : NULL, nr * sizeof(*buf)); 66 if (!buf) 67 return -ENOMEM; 68 69 sb->buf = buf; 70 sb->alloc = nr; 71 return 0; 72 } 73 74 int strbuf_addch(struct strbuf *sb, int c) 75 { 76 int ret = strbuf_grow(sb, 1); 77 if (ret) 78 return ret; 79 80 sb->buf[sb->len++] = c; 81 sb->buf[sb->len] = '\0'; 82 return 0; 83 } 84 85 int strbuf_add(struct strbuf *sb, const void *data, size_t len) 86 { 87 int ret = strbuf_grow(sb, len); 88 if (ret) 89 return ret; 90 91 memcpy(sb->buf + sb->len, data, len); 92 return strbuf_setlen(sb, sb->len + len); 93 } 94 95 static int strbuf_addv(struct strbuf *sb, const char *fmt, va_list ap) 96 { 97 int len, ret; 98 va_list ap_saved; 99 100 if (!strbuf_avail(sb)) { 101 ret = strbuf_grow(sb, 64); 102 if (ret) 103 return ret; 104 } 105 106 va_copy(ap_saved, ap); 107 len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap); 108 if (len < 0) 109 return len; 110 if (len > strbuf_avail(sb)) { 111 ret = strbuf_grow(sb, len); 112 if (ret) 113 return ret; 114 len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap_saved); 115 va_end(ap_saved); 116 if (len > strbuf_avail(sb)) { 117 pr_debug("this should not happen, your vsnprintf is broken"); 118 return -EINVAL; 119 } 120 } 121 return strbuf_setlen(sb, sb->len + len); 122 } 123 124 int strbuf_addf(struct strbuf *sb, const char *fmt, ...) 125 { 126 va_list ap; 127 int ret; 128 129 va_start(ap, fmt); 130 ret = strbuf_addv(sb, fmt, ap); 131 va_end(ap); 132 return ret; 133 } 134 135 ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint) 136 { 137 size_t oldlen = sb->len; 138 size_t oldalloc = sb->alloc; 139 int ret; 140 141 ret = strbuf_grow(sb, hint ? hint : 8192); 142 if (ret) 143 return ret; 144 145 for (;;) { 146 ssize_t cnt; 147 148 cnt = read(fd, sb->buf + sb->len, sb->alloc - sb->len - 1); 149 if (cnt < 0) { 150 if (oldalloc == 0) 151 strbuf_release(sb); 152 else 153 strbuf_setlen(sb, oldlen); 154 return cnt; 155 } 156 if (!cnt) 157 break; 158 sb->len += cnt; 159 ret = strbuf_grow(sb, 8192); 160 if (ret) 161 return ret; 162 } 163 164 sb->buf[sb->len] = '\0'; 165 return sb->len - oldlen; 166 } 167