git.ozlabs.org Git - ccan/blob - ccan/tal/str/str.c

   1 /* Licensed under BSD-MIT - see LICENSE file for details */
   2 #include <unistd.h>
   3 #include <stdint.h>
   4 #include <string.h>
   5 #include <limits.h>
   6 #include <stdlib.h>
   7 #include "str.h"
   8 #include <sys/types.h>
   9 #include <regex.h>
  10 #include <stdarg.h>
  11 #include <unistd.h>
  12 #include <stdio.h>
  13 #include <ccan/str/str.h>
  14 #include <ccan/take/take.h>
  15
  16 char *tal_strdup(const tal_t *ctx, const char *p)
  17 {
  18         /* We have to let through NULL for take(). */
  19         return tal_dup_(ctx, p, 1, p ? strlen(p) + 1: 1, 0, false,
  20                         TAL_LABEL(char, "[]"));
  21 }
  22
  23 char *tal_strndup(const tal_t *ctx, const char *p, size_t n)
  24 {
  25         size_t len;
  26         char *ret;
  27
  28         /* We have to let through NULL for take(). */
  29         if (likely(p))
  30                 len = strnlen(p, n);
  31         else
  32                 len = n;
  33
  34         ret = tal_dup_(ctx, p, 1, len, 1, false, TAL_LABEL(char, "[]"));
  35         if (ret)
  36                 ret[len] = '\0';
  37         return ret;
  38 }
  39
  40 char *tal_fmt(const tal_t *ctx, const char *fmt, ...)
  41 {
  42         va_list ap;
  43         char *ret;
  44
  45         va_start(ap, fmt);
  46         ret = tal_vfmt(ctx, fmt, ap);
  47         va_end(ap);
  48
  49         return ret;
  50 }
  51
  52 static bool do_vfmt(char **buf, size_t off, const char *fmt, va_list ap)
  53 {
  54         /* A decent guess to start. */
  55         size_t max = strlen(fmt) * 2 + 1;
  56         bool ok;
  57
  58         for (;;) {
  59                 va_list ap2;
  60                 int ret;
  61
  62                 if (!tal_resize(buf, off + max)) {
  63                         ok = false;
  64                         break;
  65                 }
  66
  67                 va_copy(ap2, ap);
  68                 ret = vsnprintf(*buf + off, max, fmt, ap2);
  69                 va_end(ap2);
  70
  71                 if (ret < max) {
  72                         ok = true;
  73                         break;
  74                 }
  75                 max *= 2;
  76         }
  77
  78         if (taken(fmt))
  79                 tal_free(fmt);
  80         return ok;
  81 }
  82
  83 char *tal_vfmt(const tal_t *ctx, const char *fmt, va_list ap)
  84 {
  85         char *buf;
  86
  87         if (!fmt && taken(fmt))
  88                 return NULL;
  89
  90         /* A decent guess to start. */
  91         buf = tal_arr(ctx, char, strlen(fmt) * 2);
  92         if (!do_vfmt(&buf, 0, fmt, ap))
  93                 buf = tal_free(buf);
  94         return buf;
  95 }
  96
  97 bool tal_append_vfmt(char **baseptr, const char *fmt, va_list ap)
  98 {
  99         if (!fmt && taken(fmt))
 100                 return false;
 101
 102         return do_vfmt(baseptr, strlen(*baseptr), fmt, ap);
 103 }
 104
 105 bool tal_append_fmt(char **baseptr, const char *fmt, ...)
 106 {
 107         va_list ap;
 108         bool ret;
 109
 110         va_start(ap, fmt);
 111         ret = tal_append_vfmt(baseptr, fmt, ap);
 112         va_end(ap);
 113
 114         return ret;
 115 }
 116
 117 char *tal_strcat(const tal_t *ctx, const char *s1, const char *s2)
 118 {
 119         size_t len1, len2;
 120         char *ret;
 121
 122         if (unlikely(!s2) && taken(s2)) {
 123                 if (taken(s1))
 124                         tal_free(s1);
 125                 return NULL;
 126         }
 127         /* We have to let through NULL for take(). */
 128         len1 = s1 ? strlen(s1) : 0;
 129         len2 = strlen(s2);
 130
 131         /* We use tal_dup_ here to avoid attaching a length property. */
 132         ret = tal_dup_(ctx, s1, 1, len1, len2 + 1, false,
 133                        TAL_LABEL(char, "[]"));
 134         if (likely(ret))
 135                 memcpy(ret + len1, s2, len2 + 1);
 136
 137         if (taken(s2))
 138                 tal_free(s2);
 139         return ret;
 140 }
 141
 142 char **tal_strsplit(const tal_t *ctx,
 143                     const char *string, const char *delims, enum strsplit flags)
 144 {
 145         char **parts, *str;
 146         size_t max = 64, num = 0;
 147
 148         parts = tal_arr(ctx, char *, max + 1);
 149         if (unlikely(!parts)) {
 150                 if (taken(string))
 151                         tal_free(string);
 152                 if (taken(delims))
 153                         tal_free(delims);
 154                 return NULL;
 155         }
 156         str = tal_strdup(parts, string);
 157         if (unlikely(!str))
 158                 goto fail;
 159         if (unlikely(!delims) && is_taken(delims))
 160                 goto fail;
 161
 162         if (flags == STR_NO_EMPTY)
 163                 str += strspn(str, delims);
 164
 165         while (*str != '\0') {
 166                 size_t len = strcspn(str, delims), dlen;
 167
 168                 parts[num] = str;
 169                 dlen = strspn(str + len, delims);
 170                 parts[num][len] = '\0';
 171                 if (flags == STR_EMPTY_OK && dlen)
 172                         dlen = 1;
 173                 str += len + dlen;
 174                 if (++num == max && !tal_resize(&parts, max*=2 + 1))
 175                         goto fail;
 176         }
 177         parts[num] = NULL;
 178
 179         /* Ensure that tal_count() is correct. */
 180         if (unlikely(!tal_resize(&parts, num+1)))
 181                 goto fail;
 182
 183         if (taken(delims))
 184                 tal_free(delims);
 185         return parts;
 186
 187 fail:
 188         tal_free(parts);
 189         if (taken(delims))
 190                 tal_free(delims);
 191         return NULL;
 192 }
 193
 194 char *tal_strjoin(const tal_t *ctx,
 195                   char *strings[], const char *delim, enum strjoin flags)
 196 {
 197         unsigned int i;
 198         char *ret = NULL;
 199         size_t totlen = 0, dlen;
 200
 201         if (unlikely(!strings) && is_taken(strings))
 202                 goto fail;
 203
 204         if (unlikely(!delim) && is_taken(delim))
 205                 goto fail;
 206
 207         dlen = strlen(delim);
 208         ret = tal_arr(ctx, char, dlen*2+1);
 209         if (!ret)
 210                 goto fail;
 211
 212         ret[0] = '\0';
 213         for (i = 0; strings[i]; i++) {
 214                 size_t len = strlen(strings[i]);
 215
 216                 if (flags == STR_NO_TRAIL && !strings[i+1])
 217                         dlen = 0;
 218                 if (!tal_resize(&ret, totlen + len + dlen + 1))
 219                         goto fail;
 220                 memcpy(ret + totlen, strings[i], len);
 221                 totlen += len;
 222                 memcpy(ret + totlen, delim, dlen);
 223                 totlen += dlen;
 224         }
 225         ret[totlen] = '\0';
 226 out:
 227         if (taken(strings))
 228                 tal_free(strings);
 229         if (taken(delim))
 230                 tal_free(delim);
 231         return ret;
 232 fail:
 233         ret = tal_free(ret);
 234         goto out;
 235 }
 236
 237 static size_t count_open_braces(const char *string)
 238 {
 239 #if 1
 240         size_t num = 0, esc = 0;
 241
 242         while (*string) {
 243                 if (*string == '\\')
 244                         esc++;
 245                 else {
 246                         /* An odd number of \ means it's escaped. */
 247                         if (*string == '(' && (esc & 1) == 0)
 248                                 num++;
 249                         esc = 0;
 250                 }
 251                 string++;
 252         }
 253         return num;
 254 #else
 255         return strcount(string, "(");
 256 #endif
 257 }
 258
 259 bool tal_strreg(const tal_t *ctx, const char *string, const char *regex, ...)
 260 {
 261         size_t nmatch = 1 + count_open_braces(regex);
 262         regmatch_t matches[nmatch];
 263         regex_t r;
 264         bool ret = false;
 265         unsigned int i;
 266         va_list ap;
 267
 268         if (unlikely(!regex) && is_taken(regex))
 269                 goto fail_no_re;
 270
 271         if (regcomp(&r, regex, REG_EXTENDED) != 0)
 272                 goto fail_no_re;
 273
 274         if (unlikely(!string) && is_taken(string))
 275                 goto fail;
 276
 277         if (regexec(&r, string, nmatch, matches, 0) != 0)
 278                 goto fail;
 279
 280         ret = true;
 281         va_start(ap, regex);
 282         for (i = 1; i < nmatch; i++) {
 283                 char **arg = va_arg(ap, char **);
 284                 if (arg) {
 285                         /* eg. ([a-z])? can give "no match". */
 286                         if (matches[i].rm_so == -1)
 287                                 *arg = NULL;
 288                         else {
 289                                 *arg = tal_strndup(ctx,
 290                                                    string + matches[i].rm_so,
 291                                                    matches[i].rm_eo
 292                                                    - matches[i].rm_so);
 293                                 /* FIXME: If we fail, we set some and leak! */
 294                                 if (!*arg) {
 295                                         ret = false;
 296                                         break;
 297                                 }
 298                         }
 299                 }
 300         }
 301         va_end(ap);
 302 fail:
 303         regfree(&r);
 304 fail_no_re:
 305         if (taken(regex))
 306                 tal_free(regex);
 307         if (taken(string))
 308                 tal_free(string);
 309         return ret;
 310 }