gpg: Fix build on Windows.
[gnupg.git] / common / strlist.c
1 /* strlist.c -  string helpers
2  * Copyright (C) 1998, 2000, 2001, 2006 Free Software Foundation, Inc.
3  * Copyright (C) 2015  g10 Code GmbH
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute and/or modify this
8  * part of GnuPG under the terms of either
9  *
10  *   - the GNU Lesser General Public License as published by the Free
11  *     Software Foundation; either version 3 of the License, or (at
12  *     your option) any later version.
13  *
14  * or
15  *
16  *   - the GNU General Public License as published by the Free
17  *     Software Foundation; either version 2 of the License, or (at
18  *     your option) any later version.
19  *
20  * or both in parallel, as here.
21  *
22  * GnuPG is distributed in the hope that it will be useful, but
23  * WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * General Public License for more details.
26  *
27  * You should have received a copies of the GNU General Public License
28  * and the GNU Lesser General Public License along with this program;
29  * if not, see <https://www.gnu.org/licenses/>.
30  */
31
32 #include <config.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdarg.h>
36 #include <ctype.h>
37
38 #include "util.h"
39 #include "common-defs.h"
40 #include "strlist.h"
41 #include "utf8conv.h"
42 #include "mischelp.h"
43
44 void
45 free_strlist( strlist_t sl )
46 {
47     strlist_t sl2;
48
49     for(; sl; sl = sl2 ) {
50         sl2 = sl->next;
51         xfree(sl);
52     }
53 }
54
55
56 void
57 free_strlist_wipe (strlist_t sl)
58 {
59     strlist_t sl2;
60
61     for(; sl; sl = sl2 ) {
62         sl2 = sl->next;
63         wipememory (sl, sizeof *sl + strlen (sl->d));
64         xfree(sl);
65     }
66 }
67
68
69 /* Add STRING to the LIST at the front.  This function terminates the
70    process on memory shortage.  */
71 strlist_t
72 add_to_strlist( strlist_t *list, const char *string )
73 {
74     strlist_t sl;
75
76     sl = xmalloc( sizeof *sl + strlen(string));
77     sl->flags = 0;
78     strcpy(sl->d, string);
79     sl->next = *list;
80     *list = sl;
81     return sl;
82 }
83
84
85 /* Add STRING to the LIST at the front.  This function returns NULL
86    and sets ERRNO on memory shortage.  */
87 strlist_t
88 add_to_strlist_try (strlist_t *list, const char *string)
89 {
90   strlist_t sl;
91
92   sl = xtrymalloc (sizeof *sl + strlen (string));
93   if (sl)
94     {
95       sl->flags = 0;
96       strcpy (sl->d, string);
97       sl->next = *list;
98       *list = sl;
99     }
100   return sl;
101 }
102
103
104 /* Same as add_to_strlist() but if IS_UTF8 is *not* set, a conversion
105    to UTF-8 is done.  This function terminates the process on memory
106    shortage.  */
107 strlist_t
108 add_to_strlist2( strlist_t *list, const char *string, int is_utf8 )
109 {
110   strlist_t sl;
111
112   if (is_utf8)
113     sl = add_to_strlist( list, string );
114   else
115     {
116       char *p = native_to_utf8( string );
117       sl = add_to_strlist( list, p );
118       xfree ( p );
119     }
120   return sl;
121 }
122
123
124 /* Add STRING to the LIST at the end.  This function terminates the
125    process on memory shortage.  */
126 strlist_t
127 append_to_strlist( strlist_t *list, const char *string )
128 {
129   strlist_t sl;
130   sl = append_to_strlist_try (list, string);
131   if (!sl)
132     xoutofcore ();
133   return sl;
134 }
135
136
137 /* Add STRING to the LIST at the end.  */
138 strlist_t
139 append_to_strlist_try (strlist_t *list, const char *string)
140 {
141     strlist_t r, sl;
142
143     sl = xtrymalloc( sizeof *sl + strlen(string));
144     if (sl == NULL)
145       return NULL;
146
147     sl->flags = 0;
148     strcpy(sl->d, string);
149     sl->next = NULL;
150     if( !*list )
151         *list = sl;
152     else {
153         for( r = *list; r->next; r = r->next )
154             ;
155         r->next = sl;
156     }
157     return sl;
158 }
159
160
161 strlist_t
162 append_to_strlist2( strlist_t *list, const char *string, int is_utf8 )
163 {
164   strlist_t sl;
165
166   if( is_utf8 )
167     sl = append_to_strlist( list, string );
168   else
169     {
170       char *p = native_to_utf8 (string);
171       sl = append_to_strlist( list, p );
172       xfree( p );
173     }
174   return sl;
175 }
176
177
178 /* Return a copy of LIST.  This function terminates the process on
179    memory shortage.*/
180 strlist_t
181 strlist_copy (strlist_t list)
182 {
183   strlist_t newlist = NULL, sl, *last;
184
185   last = &newlist;
186   for (; list; list = list->next)
187     {
188       sl = xmalloc (sizeof *sl + strlen (list->d));
189       sl->flags = list->flags;
190       strcpy(sl->d, list->d);
191       sl->next = NULL;
192       *last = sl;
193       last = &sl;
194     }
195   return newlist;
196 }
197
198
199
200 strlist_t
201 strlist_prev( strlist_t head, strlist_t node )
202 {
203     strlist_t n;
204
205     for(n=NULL; head && head != node; head = head->next )
206         n = head;
207     return n;
208 }
209
210 strlist_t
211 strlist_last( strlist_t node )
212 {
213     if( node )
214         for( ; node->next ; node = node->next )
215             ;
216     return node;
217 }
218
219
220 /* Remove the first item from LIST and return its content in an
221    allocated buffer.  This function terminates the process on memory
222    shortage.  */
223 char *
224 strlist_pop (strlist_t *list)
225 {
226   char *str=NULL;
227   strlist_t sl=*list;
228
229   if(sl)
230     {
231       str = xmalloc(strlen(sl->d)+1);
232       strcpy(str,sl->d);
233
234       *list=sl->next;
235       xfree(sl);
236     }
237
238   return str;
239 }
240
241 /* Return the first element of the string list HAYSTACK whose string
242    matches NEEDLE.  If no elements match, return NULL.  */
243 strlist_t
244 strlist_find (strlist_t haystack, const char *needle)
245 {
246   for (;
247        haystack;
248        haystack = haystack->next)
249     if (strcmp (haystack->d, needle) == 0)
250       return haystack;
251   return NULL;
252 }
253
254 int
255 strlist_length (strlist_t list)
256 {
257   int i;
258   for (i = 0; list; list = list->next)
259     i ++;
260
261   return i;
262 }
263
264 /* Reverse the list *LIST in place.  */
265 strlist_t
266 strlist_rev (strlist_t *list)
267 {
268   strlist_t l = *list;
269   strlist_t lrev = NULL;
270
271   while (l)
272     {
273       strlist_t tail = l->next;
274       l->next = lrev;
275       lrev = l;
276       l = tail;
277     }
278
279   *list = lrev;
280   return lrev;
281 }