lib/frrstr.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * FRR string processing utilities.
   4  * Copyright (C) 2018  Cumulus Networks, Inc.
   5  *                     Quentin Young
   6  */
   7
   8 #include "zebra.h"
   9
  10 #include <string.h>
  11 #include <ctype.h>
  12 #include <sys/types.h>
  13 #ifdef HAVE_LIBPCRE2_POSIX
  14 #ifndef _FRR_PCRE2_POSIX
  15 #define _FRR_PCRE2_POSIX
  16 #include <pcre2posix.h>
  17 #endif /* _FRR_PCRE2_POSIX */
  18 #elif defined(HAVE_LIBPCREPOSIX)
  19 #include <pcreposix.h>
  20 #else
  21 #include <regex.h>
  22 #endif /* HAVE_LIBPCRE2_POSIX */
  23
  24 #include "frrstr.h"
  25 #include "memory.h"
  26 #include "vector.h"
  27
  28 void frrstr_split(const char *string, const char *delimiter, char ***result,
  29                   int *argc)
  30 {
  31         if (!string)
  32                 return;
  33
  34         unsigned int sz = 4, idx = 0;
  35         char *copy, *copystart;
  36         *result = XCALLOC(MTYPE_TMP, sizeof(char *) * sz);
  37         copystart = copy = XSTRDUP(MTYPE_TMP, string);
  38         *argc = 0;
  39
  40         const char *tok = NULL;
  41
  42         while (copy) {
  43                 tok = strsep(&copy, delimiter);
  44                 (*result)[idx] = XSTRDUP(MTYPE_TMP, tok);
  45                 if (++idx == sz)
  46                         *result = XREALLOC(MTYPE_TMP, *result,
  47                                            (sz *= 2) * sizeof(char *));
  48                 (*argc)++;
  49         }
  50
  51         XFREE(MTYPE_TMP, copystart);
  52 }
  53
  54 vector frrstr_split_vec(const char *string, const char *delimiter)
  55 {
  56         char **result;
  57         int argc;
  58
  59         if (!string)
  60                 return NULL;
  61
  62         frrstr_split(string, delimiter, &result, &argc);
  63
  64         vector v = array_to_vector((void **)result, argc);
  65
  66         XFREE(MTYPE_TMP, result);
  67
  68         return v;
  69 }
  70
  71 char *frrstr_join(const char **parts, int argc, const char *join)
  72 {
  73         int i;
  74         char *str;
  75         char *p;
  76         size_t len = 0;
  77         size_t joinlen = join ? strlen(join) : 0;
  78
  79         if (!argc)
  80                 return NULL;
  81
  82         for (i = 0; i < argc; i++)
  83                 len += strlen(parts[i]);
  84         len += argc * joinlen + 1;
  85
  86         if (!len)
  87                 return NULL;
  88
  89         p = str = XMALLOC(MTYPE_TMP, len);
  90
  91         for (i = 0; i < argc; i++) {
  92                 size_t arglen = strlen(parts[i]);
  93
  94                 memcpy(p, parts[i], arglen);
  95                 p += arglen;
  96                 if (i + 1 != argc && join) {
  97                         memcpy(p, join, joinlen);
  98                         p += joinlen;
  99                 }
 100         }
 101
 102         *p = '\0';
 103
 104         return str;
 105 }
 106
 107 char *frrstr_join_vec(vector v, const char *join)
 108 {
 109         char **argv;
 110         int argc;
 111
 112         vector_to_array(v, (void ***)&argv, &argc);
 113
 114         char *ret = frrstr_join((const char **)argv, argc, join);
 115
 116         XFREE(MTYPE_TMP, argv);
 117
 118         return ret;
 119 }
 120
 121 void frrstr_filter_vec(vector v, regex_t *filter)
 122 {
 123         regmatch_t ignored[1];
 124
 125         for (unsigned int i = 0; i < vector_active(v); i++) {
 126                 if (regexec(filter, vector_slot(v, i), 0, ignored, 0)) {
 127                         XFREE(MTYPE_TMP, vector_slot(v, i));
 128                         vector_unset(v, i);
 129                 }
 130         }
 131 }
 132
 133 void frrstr_strvec_free(vector v)
 134 {
 135         unsigned int i;
 136         char *cp;
 137
 138         if (!v)
 139                 return;
 140
 141         for (i = 0; i < vector_active(v); i++) {
 142                 cp = vector_slot(v, i);
 143                 XFREE(MTYPE_TMP, cp);
 144         }
 145
 146         vector_free(v);
 147 }
 148
 149 char *frrstr_replace(const char *str, const char *find, const char *replace)
 150 {
 151         char *ch;
 152         char *nustr = XSTRDUP(MTYPE_TMP, str);
 153
 154         size_t findlen = strlen(find);
 155         size_t repllen = strlen(replace);
 156
 157         while ((ch = strstr(nustr, find))) {
 158                 if (repllen > findlen) {
 159                         size_t nusz = strlen(nustr) + repllen - findlen + 1;
 160                         nustr = XREALLOC(MTYPE_TMP, nustr, nusz);
 161                         ch = strstr(nustr, find);
 162                 }
 163
 164                 size_t nustrlen = strlen(nustr);
 165                 size_t taillen = (nustr + nustrlen) - (ch + findlen);
 166
 167                 memmove(ch + findlen + (repllen - findlen), ch + findlen,
 168                         taillen + 1);
 169                 memcpy(ch, replace, repllen);
 170         }
 171
 172         return nustr;
 173 }
 174
 175 bool frrstr_startswith(const char *str, const char *prefix)
 176 {
 177         if (!str || !prefix)
 178                 return false;
 179
 180         size_t lenstr = strlen(str);
 181         size_t lenprefix = strlen(prefix);
 182
 183         if (lenprefix > lenstr)
 184                 return false;
 185
 186         return strncmp(str, prefix, lenprefix) == 0;
 187 }
 188
 189 bool frrstr_endswith(const char *str, const char *suffix)
 190 {
 191         if (!str || !suffix)
 192                 return false;
 193
 194         size_t lenstr = strlen(str);
 195         size_t lensuffix = strlen(suffix);
 196
 197         if (lensuffix > lenstr)
 198                 return false;
 199
 200         return strncmp(&str[lenstr - lensuffix], suffix, lensuffix) == 0;
 201 }
 202
 203 int all_digit(const char *str)
 204 {
 205         for (; *str != '\0'; str++)
 206                 if (!isdigit((unsigned char)*str))
 207                         return 0;
 208         return 1;
 209 }
 210
 211
 212 char *frrstr_hex(char *buff, size_t bufsiz, const uint8_t *str, size_t num)
 213 {
 214         if (bufsiz == 0)
 215                 return buff;
 216
 217         char tmp[3];
 218
 219         buff[0] = '\0';
 220
 221         for (size_t i = 0; i < num; i++) {
 222                 snprintf(tmp, sizeof(tmp), "%02x", (unsigned char)str[i]);
 223                 strlcat(buff, tmp, bufsiz);
 224         }
 225
 226         return buff;
 227 }