11291766b14fa1f4891f3133cba1368ee876e281
[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 #if 0
51 static ushort latin2_unicode[128] = {
52     0x0080,0x0081,0x0082,0x0083,0x0084,0x0085,0x0086,0x0087,
53     0x0088,0x0089,0x008A,0x008B,0x008C,0x008D,0x008E,0x008F,
54     0x0090,0x0091,0x0092,0x0093,0x0094,0x0095,0x0096,0x0097,
55     0x0098,0x0099,0x009A,0x009B,0x009C,0x009D,0x009E,0x009F,
56     0x00A0,0x0104,0x02D8,0x0141,0x00A4,0x013D,0x015A,0x00A7,
57     0x00A8,0x0160,0x015E,0x0164,0x0179,0x00AD,0x017D,0x017B,
58     0x00B0,0x0105,0x02DB,0x0142,0x00B4,0x013E,0x015B,0x02C7,
59     0x00B8,0x0161,0x015F,0x0165,0x017A,0x02DD,0x017E,0x017C,
60     0x0154,0x00C1,0x00C2,0x0102,0x00C4,0x0139,0x0106,0x00C7,
61     0x010C,0x00C9,0x0118,0x00CB,0x011A,0x00CD,0x00CE,0x010E,
62     0x0110,0x0143,0x0147,0x00D3,0x00D4,0x0150,0x00D6,0x00D7,
63     0x0158,0x016E,0x00DA,0x0170,0x00DC,0x00DD,0x0162,0x00DF,
64     0x0155,0x00E1,0x00E2,0x0103,0x00E4,0x013A,0x0107,0x00E7,
65     0x010D,0x00E9,0x0119,0x00EB,0x011B,0x00ED,0x00EE,0x010F,
66     0x0111,0x0144,0x0148,0x00F3,0x00F4,0x0151,0x00F6,0x00F7,
67     0x0159,0x016F,0x00FA,0x0171,0x00FC,0x00FD,0x0163,0x02D9
68 };
69 #endif
70
71
72 void
73 free_strlist( STRLIST sl )
74 {
75     STRLIST sl2;
76
77     for(; sl; sl = sl2 ) {
78         sl2 = sl->next;
79         m_free(sl);
80     }
81 }
82
83
84 STRLIST
85 add_to_strlist( STRLIST *list, const char *string )
86 {
87     STRLIST sl;
88
89     sl = m_alloc( sizeof *sl + strlen(string));
90     sl->flags = 0;
91     strcpy(sl->d, string);
92     sl->next = *list;
93     *list = sl;
94     return sl;
95 }
96
97 STRLIST
98 append_to_strlist( STRLIST *list, const char *string )
99 {
100     STRLIST r, sl;
101
102     sl = m_alloc( sizeof *sl + strlen(string));
103     sl->flags = 0;
104     strcpy(sl->d, string);
105     sl->next = NULL;
106     if( !*list )
107         *list = sl;
108     else {
109         for( r = *list; r->next; r = r->next )
110             ;
111         r->next = sl;
112     }
113     return sl;
114 }
115
116
117
118 STRLIST
119 strlist_prev( STRLIST head, STRLIST node )
120 {
121     STRLIST n;
122
123     for(n=NULL; head && head != node; head = head->next )
124         n = head;
125     return n;
126 }
127
128 STRLIST
129 strlist_last( STRLIST node )
130 {
131     if( node )
132         for( ; node->next ; node = node->next )
133             ;
134     return node;
135 }
136
137
138
139 /****************
140  * look for the substring SUB in buffer and return a pointer to that
141  * substring in BUF or NULL if not found.
142  * Comparison is case-insensitive.
143  */
144 const char *
145 memistr( const char *buf, size_t buflen, const char *sub )
146 {
147     const byte *t, *s ;
148     size_t n;
149
150     for( t=buf, n=buflen, s=sub ; n ; t++, n-- )
151         if( toupper(*t) == toupper(*s) ) {
152             for( buf=t++, buflen = n--, s++;
153                  n && toupper(*t) == toupper(*s); t++, s++, n-- )
154                 ;
155             if( !*s )
156                 return buf;
157             t = buf; n = buflen; s = sub ;
158         }
159
160     return NULL ;
161 }
162
163 /****************
164  * Wie strncpy(), aber es werden maximal n-1 zeichen kopiert und ein
165  * '\0' angehängt. Ist n = 0, so geschieht nichts, ist Destination
166  * gleich NULL, so wird via m_alloc Speicher besorgt, ist dann nicht
167  * genügend Speicher vorhanden, so bricht die funktion ab.
168  */
169 char *
170 mem2str( char *dest , const void *src , size_t n )
171 {
172     char *d;
173     const char *s;
174
175     if( n ) {
176         if( !dest )
177             dest = m_alloc( n ) ;
178         d = dest;
179         s = src ;
180         for(n--; n && *s; n-- )
181             *d++ = *s++;
182         *d = '\0' ;
183     }
184
185     return dest ;
186 }
187
188
189 /****************
190  * remove leading and trailing white spaces
191  */
192 char *
193 trim_spaces( char *str )
194 {
195     char *string, *p, *mark;
196
197     string = str;
198     /* find first non space character */
199     for( p=string; *p && isspace( *(byte*)p ) ; p++ )
200         ;
201     /* move characters */
202     for( (mark = NULL); (*string = *p); string++, p++ )
203         if( isspace( *(byte*)p ) ) {
204             if( !mark )
205                 mark = string ;
206         }
207         else
208             mark = NULL ;
209     if( mark )
210         *mark = '\0' ;  /* remove trailing spaces */
211
212     return str ;
213 }
214
215
216
217 unsigned
218 trim_trailing_chars( byte *line, unsigned len, const char *trimchars )
219 {
220     byte *p, *mark;
221     unsigned n;
222
223     for(mark=NULL, p=line, n=0; n < len; n++, p++ ) {
224         if( strchr(trimchars, *p ) ) {
225             if( !mark )
226                 mark = p;
227         }
228         else
229             mark = NULL;
230     }
231
232     if( mark ) {
233         *mark = 0;
234         return mark - line;
235     }
236     return len;
237 }
238
239 /****************
240  * remove trailing white spaces and return the length of the buffer
241  */
242 unsigned
243 trim_trailing_ws( byte *line, unsigned len )
244 {
245     return trim_trailing_chars( line, len, " \t\r\n" );
246 }
247
248
249
250 int
251 string_count_chr( const char *string, int c )
252 {
253     int count;
254     for(count=0; *string; string++ )
255         if( *string == c )
256             count++;
257     return count;
258 }
259
260
261 int
262 set_native_charset( const char *newset )
263 {
264     if( !stricmp( newset, "iso-8859-1" ) )
265         use_koi8 = 0;
266     else if( !stricmp( newset, "koi8-r" ) )
267         use_koi8 = 1;
268     else
269         return G10ERR_GENERAL;
270     return 0;
271 }
272
273 const char*
274 get_native_charset()
275 {
276     return use_koi8? "koi8-r" : "iso-8859-1";
277 }
278
279 /****************
280  * Convert string, which is in native encoding to UTF8 and return the
281  * new allocated UTF8 string.
282  */
283 char *
284 native_to_utf8( const char *string )
285 {
286     const byte *s;
287     char *buffer;
288     byte *p;
289     size_t length=0;
290
291     if( use_koi8 ) {
292         for(s=string; *s; s++ ) {
293             length++;
294             if( *s & 0x80 )
295                 length += 2; /* we may need 3 bytes */
296         }
297         buffer = m_alloc( length + 1 );
298         for(p=buffer, s=string; *s; s++ ) {
299             if( *s & 0x80 ) {
300                 ushort val = koi82unicode[ *s & 0x7f ];
301                 if( val < 0x0800 ) {
302                     *p++ = 0xc0 | ( (val >> 6) & 0x1f );
303                     *p++ = 0x80 | (  val & 0x3f );
304                 }
305                 else {
306                     *p++ = 0xe0 | ( (val >> 12) & 0x0f );
307                     *p++ = 0x80 | ( (val >>  6) & 0x3f );
308                     *p++ = 0x80 | (  val & 0x3f );
309                 }
310             }
311             else
312                 *p++ = *s;
313         }
314         *p = 0;
315     }
316     else {
317         for(s=string; *s; s++ ) {
318             length++;
319             if( *s & 0x80 )
320                 length++;
321         }
322         buffer = m_alloc( length + 1 );
323         for(p=buffer, s=string; *s; s++ ) {
324             if( *s & 0x80 ) {
325                 *p++ = 0xc0 | ((*s >> 6) & 3);
326                 *p++ = 0x80 | ( *s & 0x3f );
327             }
328             else
329                 *p++ = *s;
330         }
331         *p = 0;
332     }
333     return buffer;
334 }
335
336
337 /****************
338  * Convert string, which is in UTF8 to native encoding.  Replace
339  * illegal encodings by some "\xnn".
340  */
341 char *
342 utf8_to_native( const char *string )
343 {
344   #if 0
345     const byte *s;
346     size_t n;
347     byte *buffer, *p;
348
349     /* quick check whether we actually have characters with bit 8 set */
350     for( s=string; *s; s++ )
351         if( *s & 0x80 )
352             break;
353     if( !*s ) /* that is easy */
354         return m_strdup(string);
355
356     /* count the extended utf-8 characters */
357         110x xxxx
358         1110 xxxx
359         1111 0xxx
360     for( n=1, s=string; *s; s++ ) {
361         if( !(*s & 0x80) )
362             n++;
363         else if( (*s & 0xe0) == 0xc0 )
364             n += 2;
365         else if( (*s & 0xf0) == 0xe0 )
366             n += 3;
367         else if( (*s & 0xf8) == 0xf0 )
368             n += 4;
369         else
370             n++; /* invalid encoding */
371     }
372
373     buffer = p = m_alloc( n );
374     for( s=string; *s; ) {
375         if( !(*s & 0x80) )
376             *p++ = *s++;
377         else if( (*s & 0xe0) == 0xc0 ) {
378             u32 val;
379             if( (s[1] & 0xc0) != 0x80 )
380                 ;
381             val = (*s << 6) | (s[1] & 0x3f);
382         }
383         else if( (*s & 0xf0) == 0xe0 )
384             n += 3;
385         else if( (*s & 0xf8) == 0xf0 )
386             n += 4;
387         else
388             n++; /* invalid encoding */
389     }
390    #endif
391      return m_strdup(string);
392
393 }
394
395
396 /****************
397  * check whether string is a valid UTF8 string.
398  * Returns 0 = Okay
399  *         1 = Too short
400  *         2 = invalid encoding
401  */
402 int
403 check_utf8_string( const char *string )
404 {
405     /*fixme */
406     return 0;
407 }
408
409
410 /*********************************************
411  ********** missing string functions *********
412  *********************************************/
413
414 #ifndef HAVE_STPCPY
415 char *
416 stpcpy(char *a,const char *b)
417 {
418     while( *b )
419         *a++ = *b++;
420     *a = 0;
421
422     return (char*)a;
423 }
424 #endif
425
426 #ifndef HAVE_STRLWR
427 char *
428 strlwr(char *s)
429 {
430     char *p;
431     for(p=s; *p; p++ )
432         *p = tolower(*p);
433     return s;
434 }
435 #endif
436
437 /****************
438  * mingw32/cpd has a memicmp()
439  */
440 #ifndef HAVE_MEMICMP
441 int
442 memicmp( const char *a, const char *b, size_t n )
443 {
444     for( ; n; n--, a++, b++ )
445         if( *a != *b  && toupper(*(const byte*)a) != toupper(*(const byte*)b) )
446             return *(const byte *)a - *(const byte*)b;
447     return 0;
448 }
449 #endif
450
451