See ChangeLog: Tue Feb 16 14:10:02 CET 1999 Werner Koch
[gnupg.git] / util / strgutil.c
1 /* strgutil.c -  miscellaneous utilities
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG 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 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <ctype.h>
25 #include "types.h"
26 #include "util.h"
27 #include "memory.h"
28
29
30 static int use_koi8 = 0;
31 static ushort koi82unicode[128] = {
32     0x2500,0x2502,0x250c,0x2510,0x2514,0x2518,0x251c,0x2524,
33     0x252c,0x2534,0x253c,0x2580,0x2584,0x2588,0x258c,0x2590,
34     0x2591,0x2592,0x2593,0x2320,0x25a0,0x2219,0x221a,0x2248,
35     0x2264,0x2265,0x00a0,0x2321,0x00b0,0x00b2,0x00b7,0x00f7,
36     0x2550,0x2551,0x2552,0x0451,0x2553,0x2554,0x2555,0x2556,
37     0x2557,0x2558,0x2559,0x255a,0x255b,0x255c,0x255d,0x255e,
38     0x255f,0x2560,0x2561,0x0401,0x2562,0x2563,0x2564,0x2565,
39     0x2566,0x2567,0x2568,0x2569,0x256a,0x256b,0x256c,0x00a9,
40     0x044e,0x0430,0x0431,0x0446,0x0434,0x0435,0x0444,0x0433,
41     0x0445,0x0438,0x0439,0x043a,0x043b,0x043c,0x043d,0x043e,
42     0x043f,0x044f,0x0440,0x0441,0x0442,0x0443,0x0436,0x0432,
43     0x044c,0x044b,0x0437,0x0448,0x044d,0x0449,0x0447,0x044a,
44     0x042e,0x0410,0x0411,0x0426,0x0414,0x0415,0x0424,0x0413,
45     0x0425,0x0418,0x0419,0x041a,0x041b,0x041c,0x041d,0x041e,
46     0x041f,0x042f,0x0420,0x0421,0x0422,0x0423,0x0416,0x0412,
47     0x042c,0x042b,0x0417,0x0428,0x042d,0x0429,0x0427,0x042a
48 };
49
50
51
52 void
53 free_strlist( STRLIST sl )
54 {
55     STRLIST sl2;
56
57     for(; sl; sl = sl2 ) {
58         sl2 = sl->next;
59         m_free(sl);
60     }
61 }
62
63
64 STRLIST
65 add_to_strlist( STRLIST *list, const char *string )
66 {
67     STRLIST sl;
68
69     sl = m_alloc( sizeof *sl + strlen(string));
70     sl->flags = 0;
71     strcpy(sl->d, string);
72     sl->next = *list;
73     *list = sl;
74     return sl;
75 }
76
77 STRLIST
78 append_to_strlist( STRLIST *list, const char *string )
79 {
80     STRLIST r, sl;
81
82     sl = m_alloc( sizeof *sl + strlen(string));
83     sl->flags = 0;
84     strcpy(sl->d, string);
85     sl->next = NULL;
86     if( !*list )
87         *list = sl;
88     else {
89         for( r = *list; r->next; r = r->next )
90             ;
91         r->next = sl;
92     }
93     return sl;
94 }
95
96
97
98 STRLIST
99 strlist_prev( STRLIST head, STRLIST node )
100 {
101     STRLIST n;
102
103     for(n=NULL; head && head != node; head = head->next )
104         n = head;
105     return n;
106 }
107
108 STRLIST
109 strlist_last( STRLIST node )
110 {
111     if( node )
112         for( ; node->next ; node = node->next )
113             ;
114     return node;
115 }
116
117
118
119 /****************
120  * look for the substring SUB in buffer and return a pointer to that
121  * substring in BUF or NULL if not found.
122  * Comparison is case-insensitive.
123  */
124 const char *
125 memistr( const char *buf, size_t buflen, const char *sub )
126 {
127     const byte *t, *s ;
128     size_t n;
129
130     for( t=buf, n=buflen, s=sub ; n ; t++, n-- )
131         if( toupper(*t) == toupper(*s) ) {
132             for( buf=t++, buflen = n--, s++;
133                  n && toupper(*t) == toupper(*s); t++, s++, n-- )
134                 ;
135             if( !*s )
136                 return buf;
137             t = buf; n = buflen; s = sub ;
138         }
139
140     return NULL ;
141 }
142
143 /****************
144  * Wie strncpy(), aber es werden maximal n-1 zeichen kopiert und ein
145  * '\0' angehängt. Ist n = 0, so geschieht nichts, ist Destination
146  * gleich NULL, so wird via m_alloc Speicher besorgt, ist dann nicht
147  * genügend Speicher vorhanden, so bricht die funktion ab.
148  */
149 char *
150 mem2str( char *dest , const void *src , size_t n )
151 {
152     char *d;
153     const char *s;
154
155     if( n ) {
156         if( !dest )
157             dest = m_alloc( n ) ;
158         d = dest;
159         s = src ;
160         for(n--; n && *s; n-- )
161             *d++ = *s++;
162         *d = '\0' ;
163     }
164
165     return dest ;
166 }
167
168
169 /****************
170  * remove leading and trailing white spaces
171  */
172 char *
173 trim_spaces( char *str )
174 {
175     char *string, *p, *mark;
176
177     string = str;
178     /* find first non space character */
179     for( p=string; *p && isspace( *(byte*)p ) ; p++ )
180         ;
181     /* move characters */
182     for( (mark = NULL); (*string = *p); string++, p++ )
183         if( isspace( *(byte*)p ) ) {
184             if( !mark )
185                 mark = string ;
186         }
187         else
188             mark = NULL ;
189     if( mark )
190         *mark = '\0' ;  /* remove trailing spaces */
191
192     return str ;
193 }
194
195
196
197 /****************
198  * remove trailing white spaces and return the length of the buffer
199  */
200 unsigned
201 trim_trailing_ws( byte *line, unsigned len )
202 {
203     byte *p, *mark;
204     unsigned n;
205
206     for(mark=NULL, p=line, n=0; n < len; n++, p++ ) {
207         if( strchr(" \t\r\n", *p ) ) {
208             if( !mark )
209                 mark = p;
210         }
211         else
212             mark = NULL;
213     }
214
215     if( mark ) {
216         *mark = 0;
217         return mark - line;
218     }
219     return len;
220 }
221
222
223
224 int
225 string_count_chr( const char *string, int c )
226 {
227     int count;
228     for(count=0; *string; string++ )
229         if( *string == c )
230             count++;
231     return count;
232 }
233
234
235 int
236 set_native_charset( const char *newset )
237 {
238     if( !stricmp( newset, "iso-8859-1" ) )
239         use_koi8 = 0;
240     else if( !stricmp( newset, "koi8-r" ) )
241         use_koi8 = 1;
242     else
243         return G10ERR_GENERAL;
244     return 0;
245 }
246
247 /****************
248  * Convert string, which is in native encoding to UTF8 and return the
249  * new allocated UTF8 string.
250  */
251 char *
252 native_to_utf8( const char *string )
253 {
254     const byte *s;
255     char *buffer;
256     byte *p;
257     size_t length=0;
258
259     if( use_koi8 ) {
260         for(s=string; *s; s++ ) {
261             length++;
262             if( *s & 0x80 )
263                 length += 2; /* we may need 3 bytes */
264         }
265         buffer = m_alloc( length + 1 );
266         for(p=buffer, s=string; *s; s++ ) {
267             if( *s & 0x80 ) {
268                 ushort val = koi82unicode[ *s & 0x7f ];
269                 if( val < 0x0800 ) {
270                     *p++ = 0xc0 | ( (val >> 6) & 0x1f );
271                     *p++ = 0x80 | (  val & 0x3f );
272                 }
273                 else {
274                     *p++ = 0xe0 | ( (val >> 12) & 0x0f );
275                     *p++ = 0x80 | ( (val >>  6) & 0x3f );
276                     *p++ = 0x80 | (  val & 0x3f );
277                 }
278             }
279             else
280                 *p++ = *s;
281         }
282         *p = 0;
283     }
284     else {
285         for(s=string; *s; s++ ) {
286             length++;
287             if( *s & 0x80 )
288                 length++;
289         }
290         buffer = m_alloc( length + 1 );
291         for(p=buffer, s=string; *s; s++ ) {
292             if( *s & 0x80 ) {
293                 *p++ = 0xc0 | ((*s >> 6) & 3);
294                 *p++ = 0x80 | ( *s & 0x3f );
295             }
296             else
297                 *p++ = *s;
298         }
299         *p = 0;
300     }
301     return buffer;
302 }
303
304
305 /****************
306  * Convert string, which is in UTF8 to native encoding.  Replace
307  * illegal encodings by some "\xnn".
308  */
309 char *
310 utf8_to_native( const char *string )
311 {
312   #if 0
313     const byte *s;
314     size_t n;
315     byte *buffer, *p;
316
317     /* quick check whether we actually have characters with bit 8 set */
318     for( s=string; *s; s++ )
319         if( *s & 0x80 )
320             break;
321     if( !*s ) /* that is easy */
322         return m_strdup(string);
323
324     /* count the extended utf-8 characters */
325         110x xxxx
326         1110 xxxx
327         1111 0xxx
328     for( n=1, s=string; *s; s++ ) {
329         if( !(*s & 0x80) )
330             n++;
331         else if( (*s & 0xe0) == 0xc0 )
332             n += 2;
333         else if( (*s & 0xf0) == 0xe0 )
334             n += 3;
335         else if( (*s & 0xf8) == 0xf0 )
336             n += 4;
337         else
338             n++; /* invalid encoding */
339     }
340
341     buffer = p = m_alloc( n );
342     for( s=string; *s; ) {
343         if( !(*s & 0x80) )
344             *p++ = *s++;
345         else if( (*s & 0xe0) == 0xc0 ) {
346             u32 val;
347             if( (s[1] & 0xc0) != 0x80 )
348                 ;
349             val = (*s << 6) | (s[1] & 0x3f);
350         }
351         else if( (*s & 0xf0) == 0xe0 )
352             n += 3;
353         else if( (*s & 0xf8) == 0xf0 )
354             n += 4;
355         else
356             n++; /* invalid encoding */
357     }
358    #endif
359      return m_strdup(string);
360
361 }
362
363
364 /****************
365  * check whether string is a valid UTF8 string.
366  * Returns 0 = Okay
367  *         1 = Too short
368  *         2 = invalid encoding
369  */
370 int
371 check_utf8_string( const char *string )
372 {
373     /*fixme */
374     return 0;
375 }
376
377
378 /*********************************************
379  ********** missing string functions *********
380  *********************************************/
381
382 #ifndef HAVE_STPCPY
383 char *
384 stpcpy(char *a,const char *b)
385 {
386     while( *b )
387         *a++ = *b++;
388     *a = 0;
389
390     return (char*)a;
391 }
392 #endif
393
394 #ifndef HAVE_STRLWR
395 char *
396 strlwr(char *s)
397 {
398     char *p;
399     for(p=s; *p; p++ )
400         *p = tolower(*p);
401     return s;
402 }
403 #endif
404
405 /****************
406  * mingw32/cpd has a memicmp()
407  */
408 #ifndef HAVE_MEMICMP
409 int
410 memicmp( const char *a, const char *b, size_t n )
411 {
412     for( ; n; n--, a++, b++ )
413         if( *a != *b  && toupper(*(const byte*)a) != toupper(*(const byte*)b) )
414             return *(const byte *)a - *(const byte*)b;
415     return 0;
416 }
417 #endif
418
419