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_append(TALLOC_CTX *mem_ctx, char **strv, const char *src)
  52 {
  53         return _strv_append(mem_ctx, strv, src, talloc_array_length(src));
  54 }
  55
  56 static bool strv_valid_entry(const char *strv, const char *entry,
  57                              size_t *strv_len, size_t *entry_len)
  58 {
  59         size_t len;
  60
  61         len = talloc_array_length(strv);
  62         if (len == 0) {
  63                 return false;
  64         }
  65         if (strv[len-1] != '\0') {
  66                 return false;
  67         }
  68
  69         if (entry < strv) {
  70                 return false;
  71         }
  72         if (entry >= (strv+len)) {
  73                 return false;
  74         }
  75
  76         *strv_len = len;
  77         *entry_len = strlen(entry);
  78
  79         return true;
  80 }
  81
  82 char *strv_next(char *strv, const char *entry)
  83 {
  84         size_t len, entry_len;
  85         char *result;
  86
  87         if (!strv_valid_entry(strv, entry, &len, &entry_len)) {
  88                 return NULL;
  89         }
  90         result = &strv[entry - strv]; /* avoid const problems with this stmt */
  91         result += entry_len + 1;
  92
  93         if (result >= (strv + len)) {
  94                 return NULL;
  95         }
  96         return result;
  97 }
  98
  99 size_t strv_count(char *strv)
 100 {
 101         char *entry;
 102         size_t count = 0;
 103
 104         for (entry = strv; entry != NULL; entry = strv_next(strv, entry)) {
 105                 count += 1;
 106         }
 107
 108         return count;
 109 }
 110
 111 char *strv_find(char *strv, const char *entry)
 112 {
 113         char *e = NULL;
 114
 115         while ((e = strv_next(strv, e)) != NULL) {
 116                 if (strcmp(e, entry) == 0) {
 117                         return e;
 118                 }
 119         }
 120
 121         return NULL;
 122 }
 123
 124 void strv_delete(char **strv, char *entry)
 125 {
 126         size_t len, entry_len;
 127
 128         if (entry == NULL) {
 129                 return;
 130         }
 131
 132         if (!strv_valid_entry(*strv, entry, &len, &entry_len)) {
 133                 return;
 134         }
 135         entry_len += 1;
 136
 137         memmove(entry, entry+entry_len,
 138                 len - entry_len - (entry - *strv));
 139
 140         *strv = talloc_realloc(NULL, *strv, char, len - entry_len);
 141 }