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, const char *entry,
  66                              size_t *strv_len, size_t *entry_len)
  67 {
  68         size_t len;
  69
  70         len = talloc_array_length(strv);
  71         if (len == 0) {
  72                 return false;
  73         }
  74         if (strv[len-1] != '\0') {
  75                 return false;
  76         }
  77
  78         if (entry < strv) {
  79                 return false;
  80         }
  81         if (entry >= (strv+len)) {
  82                 return false;
  83         }
  84
  85         *strv_len = len;
  86         *entry_len = strlen(entry);
  87
  88         return true;
  89 }
  90
  91 char *strv_next(char *strv, const char *entry)
  92 {
  93         size_t len, entry_len;
  94         char *result;
  95
  96         if (entry == NULL) {
  97                 if (strv_valid_entry(strv, strv, &len, &entry_len)) {
  98                         return strv;
  99                 }
 100                 return NULL;
 101         }
 102
 103         if (!strv_valid_entry(strv, entry, &len, &entry_len)) {
 104                 return NULL;
 105         }
 106         result = &strv[entry - strv]; /* avoid const problems with this stmt */
 107         result += entry_len + 1;
 108
 109         if (result >= (strv + len)) {
 110                 return NULL;
 111         }
 112         return result;
 113 }
 114
 115 size_t strv_count(char *strv)
 116 {
 117         char *entry;
 118         size_t count = 0;
 119
 120         for (entry = strv; entry != NULL; entry = strv_next(strv, entry)) {
 121                 count += 1;
 122         }
 123
 124         return count;
 125 }
 126
 127 char *strv_find(char *strv, const char *entry)
 128 {
 129         char *e = NULL;
 130
 131         while ((e = strv_next(strv, e)) != NULL) {
 132                 if (strcmp(e, entry) == 0) {
 133                         return e;
 134                 }
 135         }
 136
 137         return NULL;
 138 }
 139
 140 void strv_delete(char **strv, char *entry)
 141 {
 142         size_t len, entry_len;
 143
 144         if (entry == NULL) {
 145                 return;
 146         }
 147
 148         if (!strv_valid_entry(*strv, entry, &len, &entry_len)) {
 149                 return;
 150         }
 151         entry_len += 1;
 152
 153         memmove(entry, entry+entry_len,
 154                 len - entry_len - (entry - *strv));
 155
 156         *strv = talloc_realloc(NULL, *strv, char, len - entry_len);
 157 }
 158
 159 char * const *strv_to_env(TALLOC_CTX *mem_ctx, char *strv)
 160 {
 161        char **data;
 162        char *next = NULL;
 163        size_t i;
 164        size_t count = strv_count(strv);
 165
 166        if (strv == NULL) {
 167                return NULL;
 168        }
 169
 170        data = talloc_array(mem_ctx, char *, count + 1);
 171
 172        if (data == NULL) {
 173                return NULL;
 174        }
 175
 176        for(i = 0; i < count; i++) {
 177                next = strv_next(strv, next);
 178                data[i] = next;
 179        }
 180        data[count] = NULL;
 181
 182        return data;
 183 }