lib/util/strv.c

   1 /*
   2  * String Vector functions modeled after glibc argv_* functions
   3  *
   4  * Copyright Volker Lendecke <vl@samba.org> 2014
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "replace.h"
  21 #include "strv.h"
  22 #include "talloc.h"
  23 #include <string.h>
  24
  25 static int _strv_append(TALLOC_CTX *mem_ctx, char **dst, const char *src,
  26                         size_t srclen)
  27 {
  28         size_t dstlen = talloc_array_length(*dst);
  29         size_t newlen = dstlen + srclen;
  30         char *new_dst;
  31
  32         if ((newlen < srclen) || (newlen < dstlen)) {
  33                 return ERANGE;
  34         }
  35
  36         new_dst = talloc_realloc(mem_ctx, *dst, char, newlen);
  37         if (new_dst == NULL) {
  38                 return ENOMEM;
  39         }
  40         memcpy(&new_dst[dstlen], src, srclen);
  41
  42         *dst = new_dst;
  43         return 0;
  44 }
  45
  46 int strv_add(TALLOC_CTX *mem_ctx, char **strv, const char *string)
  47 {
  48         return _strv_append(mem_ctx, strv, string, strlen(string)+1);
  49 }
  50
  51 int strv_addn(TALLOC_CTX *mem_ctx, char **strv, const char *string, size_t n)
  52 {
  53         char t[n+1];
  54
  55         memcpy(t, string, n);
  56         t[n] = '\0';
  57         return _strv_append(mem_ctx, strv, t, n+1);
  58 }
  59
  60 int strv_append(TALLOC_CTX *mem_ctx, char **strv, const char *src)
  61 {
  62         return _strv_append(mem_ctx, strv, src, talloc_array_length(src));
  63 }
  64
  65 static bool strv_valid_entry(const char *strv, size_t strv_len,
  66                              const char *entry, size_t *entry_len)
  67 {
  68         if (strv_len == 0) {
  69                 return false;
  70         }
  71         if (strv[strv_len-1] != '\0') {
  72                 return false;
  73         }
  74
  75         if (entry < strv) {
  76                 return false;
  77         }
  78         if (entry >= (strv+strv_len)) {
  79                 return false;
  80         }
  81
  82         if (entry_len != NULL) {
  83                 *entry_len = strlen(entry);
  84         }
  85
  86         return true;
  87 }
  88
  89 const char *strv_len_next(const char *strv, size_t strv_len,
  90                           const char *entry)
  91 {
  92         size_t entry_len;
  93
  94         if (entry == NULL) {
  95                 if (strv_valid_entry(strv, strv_len, strv, NULL)) {
  96                         return strv;
  97                 }
  98                 return NULL;
  99         }
 100
 101         if (!strv_valid_entry(strv, strv_len, entry, &entry_len)) {
 102                 return NULL;
 103         }
 104
 105         entry += entry_len+1;
 106
 107         if (entry >= (strv + strv_len)) {
 108                 return NULL;
 109         }
 110         return entry;
 111 }
 112
 113 char *strv_next(char *strv, const char *entry)
 114 {
 115         size_t len = talloc_array_length(strv);
 116         const char *result;
 117
 118         result = strv_len_next(strv, len, entry);
 119         return discard_const_p(char, result);
 120 }
 121
 122 size_t strv_count(char *strv)
 123 {
 124         char *entry;
 125         size_t count = 0;
 126
 127         for (entry = strv; entry != NULL; entry = strv_next(strv, entry)) {
 128                 count += 1;
 129         }
 130
 131         return count;
 132 }
 133
 134 char *strv_find(char *strv, const char *entry)
 135 {
 136         char *e = NULL;
 137
 138         while ((e = strv_next(strv, e)) != NULL) {
 139                 if (strcmp(e, entry) == 0) {
 140                         return e;
 141                 }
 142         }
 143
 144         return NULL;
 145 }
 146
 147 void strv_delete(char **strv, char *entry)
 148 {
 149         size_t len = talloc_array_length(*strv);
 150         size_t entry_len;
 151
 152         if (entry == NULL) {
 153                 return;
 154         }
 155
 156         if (!strv_valid_entry(*strv, len, entry, &entry_len)) {
 157                 return;
 158         }
 159         entry_len += 1;
 160
 161         memmove(entry, entry+entry_len,
 162                 len - entry_len - (entry - *strv));
 163
 164         *strv = talloc_realloc(NULL, *strv, char, len - entry_len);
 165 }
 166
 167 char * const *strv_to_env(TALLOC_CTX *mem_ctx, char *strv)
 168 {
 169        char **data;
 170        char *next = NULL;
 171        size_t i;
 172        size_t count = strv_count(strv);
 173
 174        if (strv == NULL) {
 175                return NULL;
 176        }
 177
 178        data = talloc_array(mem_ctx, char *, count + 1);
 179
 180        if (data == NULL) {
 181                return NULL;
 182        }
 183
 184        for(i = 0; i < count; i++) {
 185                next = strv_next(strv, next);
 186                data[i] = next;
 187        }
 188        data[count] = NULL;
 189
 190        return data;
 191 }