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