From Harald Welte:
[obnox/wireshark/wip.git] / epan / strutil.c
1 /* strutil.c
2  * String utility routines
3  *
4  * $Id$
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  */
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #include <stdlib.h>
30 #include <string.h>
31 #include <ctype.h>
32 #include <glib.h>
33 #include "strutil.h"
34 #include "emem.h"
35 #include <../isprint.h>
36
37
38 #ifdef _WIN32
39 #include <windows.h>
40 #include <tchar.h>
41 #include <wchar.h>
42 #endif
43
44 static const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
45                               '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
46
47 /*
48  * Given a pointer into a data buffer, and to the end of the buffer,
49  * find the end of the (putative) line at that position in the data
50  * buffer.
51  * Return a pointer to the EOL character(s) in "*eol".
52  */
53 const guchar *
54 find_line_end(const guchar *data, const guchar *dataend, const guchar **eol)
55 {
56   const guchar *lineend;
57
58   lineend = memchr(data, '\n', dataend - data);
59   if (lineend == NULL) {
60     /*
61      * No LF - line is probably continued in next TCP segment.
62      */
63     lineend = dataend;
64     *eol = dataend;
65   } else {
66     /*
67      * Is the LF at the beginning of the line?
68      */
69     if (lineend > data) {
70       /*
71        * No - is it preceded by a carriage return?
72        * (Perhaps it's supposed to be, but that's not guaranteed....)
73        */
74       if (*(lineend - 1) == '\r') {
75         /*
76          * Yes.  The EOL starts with the CR.
77          */
78         *eol = lineend - 1;
79       } else {
80         /*
81          * No.  The EOL starts with the LF.
82          */
83         *eol = lineend;
84
85         /*
86          * I seem to remember that we once saw lines ending with LF-CR
87          * in an HTTP request or response, so check if it's *followed*
88          * by a carriage return.
89          */
90         if (lineend < (dataend - 1) && *(lineend + 1) == '\r') {
91           /*
92            * It's <non-LF><LF><CR>; say it ends with the CR.
93            */
94           lineend++;
95         }
96       }
97     } else {
98       /*
99        * Yes - the EOL starts with the LF.
100        */
101       *eol = lineend;
102     }
103
104     /*
105      * Point to the character after the last character.
106      */
107     lineend++;
108   }
109   return lineend;
110 }
111
112 /*
113  * Get the length of the next token in a line, and the beginning of the
114  * next token after that (if any).
115  * Return 0 if there is no next token.
116  */
117 int
118 get_token_len(const guchar *linep, const guchar *lineend,
119               const guchar **next_token)
120 {
121   const guchar *tokenp;
122   int token_len;
123
124   tokenp = linep;
125
126   /*
127    * Search for a blank, a CR or an LF, or the end of the buffer.
128    */
129   while (linep < lineend && *linep != ' ' && *linep != '\r' && *linep != '\n')
130       linep++;
131   token_len = (int) (linep - tokenp);
132
133   /*
134    * Skip trailing blanks.
135    */
136   while (linep < lineend && *linep == ' ')
137     linep++;
138
139   *next_token = linep;
140
141   return token_len;
142 }
143
144
145 #define INITIAL_FMTBUF_SIZE     128
146
147 /*
148  * Given a string, generate a string from it that shows non-printable
149  * characters as C-style escapes, and return a pointer to it.
150  */
151 gchar *
152 format_text(const guchar *string, size_t len)
153 {
154   static gchar *fmtbuf[3];
155   static int fmtbuf_len[3];
156   static int idx;
157   int column;
158   const guchar *stringend = string + len;
159   guchar c;
160   int i;
161
162   idx = (idx + 1) % 3;
163
164   /*
165    * Allocate the buffer if it's not already allocated.
166    */
167   if (fmtbuf[idx] == NULL) {
168     fmtbuf[idx] = g_malloc(INITIAL_FMTBUF_SIZE);
169     fmtbuf_len[idx] = INITIAL_FMTBUF_SIZE;
170   }
171   column = 0;
172   while (string < stringend) {
173     /*
174      * Is there enough room for this character, if it expands to
175      * a backslash plus 3 octal digits (which is the most it can
176      * expand to), and also enough room for a terminating '\0'?
177      */
178     if (column+3+1 >= fmtbuf_len[idx]) {
179       /*
180        * Double the buffer's size if it's not big enough.
181        * The size of the buffer starts at 128, so doubling its size
182        * adds at least another 128 bytes, which is more than enough
183        * for one more character plus a terminating '\0'.
184        */
185       fmtbuf_len[idx] = fmtbuf_len[idx] * 2;
186       fmtbuf[idx] = g_realloc(fmtbuf[idx], fmtbuf_len[idx]);
187     }
188     c = *string++;
189
190     if (g_unichar_isprint(c)) {
191       fmtbuf[idx][column] = c;
192       column++;
193     } else {
194       fmtbuf[idx][column] =  '\\';
195       column++;
196       switch (c) {
197
198       case '\a':
199         fmtbuf[idx][column] = 'a';
200         column++;
201         break;
202
203       case '\b':
204         fmtbuf[idx][column] = 'b'; /* BS */
205         column++;
206         break;
207
208       case '\f':
209         fmtbuf[idx][column] = 'f'; /* FF */
210         column++;
211         break;
212
213       case '\n':
214         fmtbuf[idx][column] = 'n'; /* NL */
215         column++;
216         break;
217
218       case '\r':
219         fmtbuf[idx][column] = 'r'; /* CR */
220         column++;
221         break;
222
223       case '\t':
224         fmtbuf[idx][column] = 't'; /* tab */
225         column++;
226         break;
227
228       case '\v':
229         fmtbuf[idx][column] = 'v';
230         column++;
231         break;
232
233       default:
234         i = (c>>6)&03;
235         fmtbuf[idx][column] = i + '0';
236         column++;
237         i = (c>>3)&07;
238         fmtbuf[idx][column] = i + '0';
239         column++;
240         i = (c>>0)&07;
241         fmtbuf[idx][column] = i + '0';
242         column++;
243         break;
244       }
245     }
246   }
247   fmtbuf[idx][column] = '\0';
248   return fmtbuf[idx];
249 }
250
251 /*
252  * Given a string, generate a string from it that shows non-printable
253  * characters as C-style escapes except a whitespace character
254  * (space, tab, carriage return, new line, vertical tab, or formfeed)
255  * which will be replaced by a space, and return a pointer to it.
256  */
257 gchar *
258 format_text_wsp(const guchar *string, size_t len)
259 {
260   static gchar *fmtbuf[3];
261   static int fmtbuf_len[3];
262   static int idx;
263   int column;
264   const guchar *stringend = string + len;
265   guchar c;
266   int i;
267
268   idx = (idx + 1) % 3;
269
270   /*
271    * Allocate the buffer if it's not already allocated.
272    */
273   if (fmtbuf[idx] == NULL) {
274     fmtbuf[idx] = g_malloc(INITIAL_FMTBUF_SIZE);
275     fmtbuf_len[idx] = INITIAL_FMTBUF_SIZE;
276   }
277   column = 0;
278   while (string < stringend) {
279     /*
280      * Is there enough room for this character, if it expands to
281      * a backslash plus 3 octal digits (which is the most it can
282      * expand to), and also enough room for a terminating '\0'?
283      */
284     if (column+3+1 >= fmtbuf_len[idx]) {
285       /*
286        * Double the buffer's size if it's not big enough.
287        * The size of the buffer starts at 128, so doubling its size
288        * adds at least another 128 bytes, which is more than enough
289        * for one more character plus a terminating '\0'.
290        */
291       fmtbuf_len[idx] = fmtbuf_len[idx] * 2;
292       fmtbuf[idx] = g_realloc(fmtbuf[idx], fmtbuf_len[idx]);
293     }
294     c = *string++;
295
296     if (g_unichar_isprint(c)) {
297       fmtbuf[idx][column] = c;
298       column++;
299     } else if  (isspace(c)) {
300       fmtbuf[idx][column] = ' ';
301       column++;
302     } else {
303       fmtbuf[idx][column] =  '\\';
304       column++;
305       switch (c) {
306
307       case '\a':
308         fmtbuf[idx][column] = 'a';
309         column++;
310         break;
311
312       case '\b':
313         fmtbuf[idx][column] = 'b'; /* BS */
314         column++;
315         break;
316
317       case '\f':
318         fmtbuf[idx][column] = 'f'; /* FF */
319         column++;
320         break;
321
322       case '\n':
323         fmtbuf[idx][column] = 'n'; /* NL */
324         column++;
325         break;
326
327       case '\r':
328         fmtbuf[idx][column] = 'r'; /* CR */
329         column++;
330         break;
331
332       case '\t':
333         fmtbuf[idx][column] = 't'; /* tab */
334         column++;
335         break;
336
337       case '\v':
338         fmtbuf[idx][column] = 'v';
339         column++;
340         break;
341
342       default:
343         i = (c>>6)&03;
344         fmtbuf[idx][column] = i + '0';
345         column++;
346         i = (c>>3)&07;
347         fmtbuf[idx][column] = i + '0';
348         column++;
349         i = (c>>0)&07;
350         fmtbuf[idx][column] = i + '0';
351         column++;
352         break;
353       }
354     }
355   }
356   fmtbuf[idx][column] = '\0';
357   return fmtbuf[idx];
358 }
359
360 static gboolean
361 is_byte_sep(guint8 c)
362 {
363         return (c == '-' || c == ':' || c == '.');
364 }
365
366 /* Turn a string of hex digits with optional separators (defined by
367  * is_byte_sep() into a byte array.
368  */
369 gboolean
370 hex_str_to_bytes(const char *hex_str, GByteArray *bytes, gboolean force_separators) {
371         guint8          val;
372         const guchar    *p, *q, *r, *s, *punct;
373         char            four_digits_first_half[3];
374         char            four_digits_second_half[3];
375         char            two_digits[3];
376         char            one_digit[2];
377
378         if (! hex_str || ! bytes) {
379                 return FALSE;
380         }
381         g_byte_array_set_size(bytes, 0);
382         p = (const guchar *)hex_str;
383         while (*p) {
384                 q = p+1;
385                 r = p+2;
386                 s = p+3;
387
388                 if (*q && *r && *s
389                     && isxdigit(*p) && isxdigit(*q) &&
390                     isxdigit(*r) && isxdigit(*s)) {
391                         four_digits_first_half[0] = *p;
392                         four_digits_first_half[1] = *q;
393                         four_digits_first_half[2] = '\0';
394                         four_digits_second_half[0] = *r;
395                         four_digits_second_half[1] = *s;
396                         four_digits_second_half[2] = '\0';
397
398                         /*
399                          * Four or more hex digits in a row.
400                          */
401                         val = (guint8) strtoul(four_digits_first_half, NULL, 16);
402                         g_byte_array_append(bytes, &val, 1);
403                         val = (guint8) strtoul(four_digits_second_half, NULL, 16);
404                         g_byte_array_append(bytes, &val, 1);
405
406                         punct = s + 1;
407                         if (*punct) {
408                                 /*
409                                  * Make sure the character after
410                                  * the forth hex digit is a byte
411                                  * separator, i.e. that we don't have
412                                  * more than four hex digits, or a
413                                  * bogus character.
414                                  */
415                                 if (is_byte_sep(*punct)) {
416                                         p = punct + 1;
417                                         continue;
418                                 }
419                                 else if (force_separators) {
420                                         return FALSE;
421                                         break;
422                                 }
423                         }
424                         p = punct;
425                         continue;
426                 }
427
428                 else if (*q && isxdigit(*p) && isxdigit(*q)) {
429                         two_digits[0] = *p;
430                         two_digits[1] = *q;
431                         two_digits[2] = '\0';
432
433                         /*
434                          * Two hex digits in a row.
435                          */
436                         val = (guint8) strtoul(two_digits, NULL, 16);
437                         g_byte_array_append(bytes, &val, 1);
438                         punct = q + 1;
439                         if (*punct) {
440                                 /*
441                                  * Make sure the character after
442                                  * the second hex digit is a byte
443                                  * separator, i.e. that we don't have
444                                  * more than two hex digits, or a
445                                  * bogus character.
446                                  */
447                                 if (is_byte_sep(*punct)) {
448                                         p = punct + 1;
449                                         continue;
450                                 }
451                                 else if (force_separators) {
452                                         return FALSE;
453                                         break;
454                                 }
455                         }
456                         p = punct;
457                         continue;
458                 }
459                 else if (*q && isxdigit(*p) && is_byte_sep(*q)) {
460                         one_digit[0] = *p;
461                         one_digit[1] = '\0';
462
463                         /*
464                          * Only one hex digit (not at the end of the string)
465                          */
466                         val = (guint8) strtoul(one_digit, NULL, 16);
467                         g_byte_array_append(bytes, &val, 1);
468                         p = q + 1;
469                         continue;
470                 }
471                 else if (!*q && isxdigit(*p)) {
472                         one_digit[0] = *p;
473                         one_digit[1] = '\0';
474
475                         /*
476                          * Only one hex digit (at the end of the string)
477                          */
478                         val = (guint8) strtoul(one_digit, NULL, 16);
479                         g_byte_array_append(bytes, &val, 1);
480                         p = q;
481                         continue;
482                 }
483                 else {
484                         return FALSE;
485                 }
486         }
487         return TRUE;
488 }
489
490 /*
491  * Turn an RFC 3986 percent-encoded string into a byte array.
492  * XXX - We don't check for reserved characters.
493  */
494 #define HEX_DIGIT_BUF_LEN 3
495 gboolean
496 uri_str_to_bytes(const char *uri_str, GByteArray *bytes) {
497         guint8          val;
498         const guchar    *p;
499         guchar          hex_digit[HEX_DIGIT_BUF_LEN];
500
501         g_byte_array_set_size(bytes, 0);
502         if (! uri_str) {
503                 return FALSE;
504         }
505
506         p = (const guchar *)uri_str;
507
508         while (*p) {
509                 if (! isascii(*p) || ! isprint(*p))
510                         return FALSE;
511                 if (*p == '%') {
512                         p++;
513                         if (*p == '\0') return FALSE;
514                         hex_digit[0] = *p;
515                         p++;
516                         if (*p == '\0') return FALSE;
517                         hex_digit[1] = *p;
518                         hex_digit[2] = '\0';
519                         if (! isxdigit(hex_digit[0]) || ! isxdigit(hex_digit[1]))
520                                 return FALSE;
521                         val = (guint8) strtoul((char *)hex_digit, NULL, 16);
522                         g_byte_array_append(bytes, &val, 1);
523                 } else {
524                         g_byte_array_append(bytes, (guint8 *) p, 1);
525                 }
526                 p++;
527
528         }
529         return TRUE;
530 }
531
532 /*
533  * Given a GByteArray, generate a string from it that shows non-printable
534  * characters as percent-style escapes, and return a pointer to it.
535  */
536 gchar *
537 format_uri(const GByteArray *bytes, const gchar *reserved_chars)
538 {
539   static gchar *fmtbuf[3];
540   static guint fmtbuf_len[3];
541   static guint idx;
542   const guchar *reserved_def = ":/?#[]@!$&'()*+,;= ";
543   const guchar *reserved = reserved_def;
544   guint8 c;
545   guint column, i;
546   gboolean is_reserved = FALSE;
547
548   if (! bytes)
549     return "";
550
551   idx = (idx + 1) % 3;
552   if (reserved_chars)
553     reserved = reserved_chars;
554
555   /*
556    * Allocate the buffer if it's not already allocated.
557    */
558   if (fmtbuf[idx] == NULL) {
559     fmtbuf[idx] = g_malloc(INITIAL_FMTBUF_SIZE);
560     fmtbuf_len[idx] = INITIAL_FMTBUF_SIZE;
561   }
562   for (column = 0; column < bytes->len; column++) {
563     /*
564      * Is there enough room for this character, if it expands to
565      * a percent plus 2 hex digits (which is the most it can
566      * expand to), and also enough room for a terminating '\0'?
567      */
568     if (column+2+1 >= fmtbuf_len[idx]) {
569       /*
570        * Double the buffer's size if it's not big enough.
571        * The size of the buffer starts at 128, so doubling its size
572        * adds at least another 128 bytes, which is more than enough
573        * for one more character plus a terminating '\0'.
574        */
575       fmtbuf_len[idx] = fmtbuf_len[idx] * 2;
576       fmtbuf[idx] = g_realloc(fmtbuf[idx], fmtbuf_len[idx]);
577     }
578     c = bytes->data[column];
579
580     if (!isascii(c) || !isprint(c) || c == '%') {
581       is_reserved = TRUE;
582     }
583
584     for (i = 0; i < strlen(reserved); i++) {
585       if (c == reserved[i])
586         is_reserved = TRUE;
587     }
588
589     if (!is_reserved) {
590       fmtbuf[idx][column] = c;
591     } else {
592       fmtbuf[idx][column] = '%';
593       column++;
594       fmtbuf[idx][column] = hex[c >> 4];
595       column++;
596       fmtbuf[idx][column] = hex[c & 0xF];
597     }
598   }
599   fmtbuf[idx][column] = '\0';
600   return fmtbuf[idx];
601 }
602
603 /**
604  * Create a copy of a GByteArray
605  *
606  * @param ba The byte array to be copied.
607  * @return If ba exists, a freshly allocated copy.  NULL otherwise.
608  *
609  */
610 GByteArray *
611 byte_array_dup(GByteArray *ba) {
612     GByteArray *new_ba;
613
614     if (!ba)
615         return NULL;
616
617     new_ba = g_byte_array_new();
618     g_byte_array_append(new_ba, ba->data, ba->len);
619     return new_ba;
620 }
621
622 #define SUBID_BUF_LEN 5
623 gboolean
624 oid_str_to_bytes(const char *oid_str, GByteArray *bytes) {
625   guint32 subid0, subid, sicnt, i;
626   const char *p, *dot;
627   guint8 buf[SUBID_BUF_LEN];
628
629   g_byte_array_set_size(bytes, 0);
630
631   /* check syntax */
632   p = oid_str;
633   dot = NULL;
634   while (*p) {
635     if (!isdigit((guchar)*p) && (*p != '.')) return FALSE;
636     if (*p == '.') {
637       if (p == oid_str) return FALSE;
638       if (!*(p+1)) return FALSE;
639       if ((p-1) == dot) return FALSE;
640       dot = p;
641     }
642     p++;
643   }
644   if (!dot) return FALSE;
645
646   p = oid_str;
647   sicnt = 0;
648   subid0 = 0;   /* squelch GCC complaints */
649   while (*p) {
650     subid = 0;
651     while (isdigit((guchar)*p)) {
652       subid *= 10;
653       subid += *p - '0';
654       p++;
655     }
656     if (sicnt == 0) {
657       subid0 = subid;
658       if (subid0 > 2) return FALSE;
659     } else if (sicnt == 1) {
660       if ((subid0 < 2) && (subid > 39)) return FALSE;
661       subid += 40 * subid0;
662     }
663     if (sicnt) {
664       i = SUBID_BUF_LEN;
665       do {
666         i--;
667         buf[i] = 0x80 | (subid % 0x80);
668         subid >>= 7;
669       } while (subid && i);
670       buf[SUBID_BUF_LEN-1] &= 0x7F;
671       g_byte_array_append(bytes, buf + i, SUBID_BUF_LEN - i);
672     }
673     sicnt++;
674     if (*p) p++;
675   }
676
677   return TRUE;
678 }
679
680 /**
681  * Compare the contents of two GByteArrays
682  *
683  * @param ba1 A byte array
684  * @param ba2 A byte array
685  * @return If both arrays are non-NULL and their lengths are equal and
686  *         their contents are equal, returns TRUE.  Otherwise, returns
687  *         FALSE.
688  *
689  * XXX - Should this be in strutil.c?
690  */
691 gboolean
692 byte_array_equal(GByteArray *ba1, GByteArray *ba2) {
693     if (!ba1 || !ba2)
694         return FALSE;
695
696     if (ba1->len != ba2->len)
697         return FALSE;
698
699     if (memcmp(ba1->data, ba2->data, ba1->len) != 0)
700         return FALSE;
701
702     return TRUE;
703 }
704
705
706 /* Return a XML escaped representation of the unescaped string.
707  * The returned string must be freed when no longer in use. */
708 gchar *
709 xml_escape(const gchar *unescaped)
710 {
711         GString *buffer = g_string_sized_new(128);
712         const gchar *p;
713         gchar c;
714
715         p = unescaped;
716         while ( (c = *p++) ) {
717                 switch (c) {
718                         case '<':
719                                 g_string_append(buffer, "&lt;");
720                                 break;
721                         case '>':
722                                 g_string_append(buffer, "&gt;");
723                                 break;
724                         case '&':
725                                 g_string_append(buffer, "&amp;");
726                                 break;
727                         case '\'':
728                                 g_string_append(buffer, "&apos;");
729                                 break;
730                         case '"':
731                                 g_string_append(buffer, "&quot;");
732                                 break;
733                         default:
734                                 g_string_append_c(buffer, c);
735                                 break;
736                 }
737         }
738         /* Return the string value contained within the GString
739          * after getting rid of the GString structure.
740          * This is the way to do this, see the GLib reference. */
741         return g_string_free(buffer, FALSE);
742 }
743
744
745 /* Return the first occurrence of needle in haystack.
746  * If not found, return NULL.
747  * If either haystack or needle has 0 length, return NULL.
748  * Algorithm copied from GNU's glibc 2.3.2 memcmp() */
749 const guint8 *
750 epan_memmem(const guint8 *haystack, guint haystack_len,
751                 const guint8 *needle, guint needle_len)
752 {
753         const guint8 *begin;
754         const guint8 *const last_possible
755                 = haystack + haystack_len - needle_len;
756
757         if (needle_len == 0) {
758                 return NULL;
759         }
760
761         if (needle_len > haystack_len) {
762                 return NULL;
763         }
764
765         for (begin = haystack ; begin <= last_possible; ++begin) {
766                 if (begin[0] == needle[0] &&
767                         !memcmp(&begin[1], needle + 1,
768                                 needle_len - 1)) {
769                         return begin;
770                 }
771         }
772
773         return NULL;
774 }
775
776 /*
777  * Scan the search string to make sure it's valid hex.  Return the
778  * number of bytes in nbytes.
779  */
780 guint8 *
781 convert_string_to_hex(const char *string, size_t *nbytes)
782 {
783   size_t n_bytes;
784   const char *p;
785   guchar c;
786   guint8 *bytes, *q, byte_val;
787
788   n_bytes = 0;
789   p = &string[0];
790   for (;;) {
791     c = *p++;
792     if (c == '\0')
793       break;
794     if (isspace(c))
795       continue; /* allow white space */
796     if (c==':' || c=='.' || c=='-')
797       continue; /* skip any ':', '.', or '-' between bytes */
798     if (!isxdigit(c)) {
799       /* Not a valid hex digit - fail */
800       return NULL;
801     }
802
803     /*
804      * We can only match bytes, not nibbles; we must have a valid
805      * hex digit immediately after that hex digit.
806      */
807     c = *p++;
808     if (!isxdigit(c))
809       return NULL;
810
811     /* 2 hex digits = 1 byte */
812     n_bytes++;
813   }
814
815   /*
816    * Were we given any hex digits?
817    */
818   if (n_bytes == 0) {
819       /* No. */
820       return NULL;
821   }
822
823   /*
824    * OK, it's valid, and it generates "n_bytes" bytes; generate the
825    * raw byte array.
826    */
827   bytes = g_malloc(n_bytes);
828   p = &string[0];
829   q = &bytes[0];
830   for (;;) {
831     c = *p++;
832     if (c == '\0')
833       break;
834     if (isspace(c))
835       continue; /* allow white space */
836     if (c==':' || c=='.' || c=='-')
837       continue; /* skip any ':', '.', or '-' between bytes */
838     /* From the loop above, we know this is a hex digit */
839     if (isdigit(c))
840       byte_val = c - '0';
841     else if (c >= 'a')
842       byte_val = (c - 'a') + 10;
843     else
844       byte_val = (c - 'A') + 10;
845     byte_val <<= 4;
846
847     /* We also know this is a hex digit */
848     c = *p++;
849     if (isdigit(c))
850       byte_val |= c - '0';
851     else if (c >= 'a')
852       byte_val |= (c - 'a') + 10;
853     else if (c >= 'A')
854       byte_val |= (c - 'A') + 10;
855
856     *q++ = byte_val;
857   }
858   *nbytes = n_bytes;
859   return bytes;
860 }
861
862 /*
863  * Copy if if it's a case-sensitive search; uppercase it if it's
864  * a case-insensitive search.
865  */
866 char *
867 convert_string_case(const char *string, gboolean case_insensitive)
868 {
869
870   if (case_insensitive) {
871     return g_utf8_strup(string, -1);
872   } else {
873     return g_strdup(string);
874   }
875 }
876
877 char *
878 epan_strcasestr(const char *haystack, const char *needle)
879 {
880         gsize hlen = strlen(haystack);
881         gsize nlen = strlen(needle);
882
883         while (hlen-- >= nlen) {
884                 if (!g_ascii_strncasecmp(haystack, needle, nlen))
885                         return (char*) haystack;
886                 haystack++;
887         }
888         return NULL;
889 }
890
891 const char *
892 string_or_null(const char *string)
893 {
894   if (string)
895     return string;
896   return "[NULL]";
897 }
898
899 int
900 escape_string_len(const char *string)
901 {
902         const char *p;
903         gchar c;
904         int repr_len;
905
906         repr_len = 0;
907         for (p = string; (c = *p) != '\0'; p++) {
908                 /* Backslashes and double-quotes must
909                  * be escaped */
910                 if (c == '\\' || c == '"') {
911                         repr_len += 2;
912                 }
913                 /* Values that can't nicely be represented
914                  * in ASCII need to be escaped. */
915                 else if (!isprint((unsigned char)c)) {
916                         /* c --> \xNN */
917                         repr_len += 4;
918                 }
919                 /* Other characters are just passed through. */
920                 else {
921                         repr_len++;
922                 }
923         }
924         return repr_len + 2;    /* string plus leading and trailing quotes */
925 }
926
927 char *
928 escape_string(char *buf, const char *string)
929 {
930   const gchar *p;
931   gchar c;
932   char *bufp;
933   char hexbuf[3];
934
935   bufp = buf;
936   *bufp++ = '"';
937   for (p = string; (c = *p) != '\0'; p++) {
938         /* Backslashes and double-quotes must
939          * be escaped. */
940         if (c == '\\' || c == '"') {
941                 *bufp++ = '\\';
942                 *bufp++ = c;
943         }
944         /* Values that can't nicely be represented
945          * in ASCII need to be escaped. */
946         else if (!isprint((unsigned char)c)) {
947                 /* c --> \xNN */
948                 g_snprintf(hexbuf,sizeof(hexbuf), "%02x", (unsigned char) c);
949                 *bufp++ = '\\';
950                 *bufp++ = 'x';
951                 *bufp++ = hexbuf[0];
952                 *bufp++ = hexbuf[1];
953         }
954         /* Other characters are just passed through. */
955         else {
956                 *bufp++ = c;
957         }
958   }
959   *bufp++ = '"';
960   *bufp = '\0';
961   return buf;
962 }
963
964 #define GN_CHAR_ALPHABET_SIZE 128
965
966 static gunichar IA5_default_alphabet[GN_CHAR_ALPHABET_SIZE] = {
967
968     /*ITU-T recommendation T.50 specifies International Reference Alphabet 5 (IA5) */
969
970     '?', '?', '?', '?', '?', '?', '?', '?',
971     '?', '?', '?', '?', '?', '?', '?', '?',
972     '?', '?', '?', '?', '?', '?', '?', '?',
973     '?', '?', '?', '?', '?', '?', '?', '?',
974     ' ', '!', '\"','#', '$', '%', '&', '\'',
975     '(', ')', '*', '+', ',', '-', '.', '/',
976     '0', '1', '2', '3', '4', '5', '6', '7',
977     '8', '9', ':', ';', '<', '=', '>', '?',
978     '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
979     'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
980     'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
981     'X',  'Y',  'Z',  '[',  '\\',  ']',  '^',  '_',
982     '`', 'a',  'b',  'c',  'd',  'e',  'f',  'g',
983     'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
984     'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
985     'x',  'y',  'z',  '{',  '|',  '}',  '~',  '?'
986 };
987
988 static gunichar
989 char_def_ia5_alphabet_decode(unsigned char value)
990 {
991     if (value < GN_CHAR_ALPHABET_SIZE)
992     {
993                 return IA5_default_alphabet[value];
994     }
995     else
996     {
997                 return '?';
998     }
999 }
1000
1001 void
1002 IA5_7BIT_decode(unsigned char * dest, const unsigned char* src, int len)
1003 {
1004     int i, j;
1005     gunichar buf;
1006
1007
1008     for (i = 0, j = 0; j < len;  j++)
1009     {
1010             buf = char_def_ia5_alphabet_decode(src[j]);
1011             i += g_unichar_to_utf8(buf,&(dest[i]));
1012     }
1013     dest[i]=0;
1014     return;
1015 }
1016
1017 /*
1018  * This function takes a string and copies it, inserting a 'chr' before
1019  * every 'chr' in it.
1020  */
1021 gchar*
1022 ws_strdup_escape_char (const gchar *str, const gchar chr)
1023 {
1024         const gchar *p;
1025         gchar *q, *new_str;
1026
1027         if(!str)
1028                 return NULL;
1029
1030         p = str;
1031         /* Worst case: A string that is full of 'chr' */
1032         q = new_str = g_malloc (strlen(str) * 2 + 1);
1033
1034         while(*p != 0)
1035         {
1036                 if(*p == chr)
1037                         *q++ = chr;
1038
1039                 *q++ = *p++;
1040         }
1041         *q = '\0';
1042
1043         return new_str;
1044 }
1045
1046 /*
1047  * This function takes a string and copies it, removing any occurences of double
1048  * 'chr' with a single 'chr'.
1049  */
1050 gchar*
1051 ws_strdup_unescape_char (const gchar *str, const char chr)
1052 {
1053         const gchar *p;
1054         gchar *q, *new_str;
1055
1056         if(!str)
1057                 return NULL;
1058
1059         p = str;
1060         /* Worst case: A string that contains no 'chr' */
1061         q = new_str = g_malloc (strlen(str) + 1);
1062
1063         while(*p != 0)
1064         {
1065                 *q++ = *p;
1066                 if ((*p == chr) && (*(p+1) == chr))
1067                         p += 2;
1068                 else
1069                         p++;
1070         }
1071         *q = '\0';
1072
1073         return new_str;
1074 }
1075
1076 /* Create a newly-allocated string with replacement values. */
1077 gchar *string_replace(const gchar* str, const gchar *old_val, const gchar *new_val) {
1078         gchar **str_parts;
1079         gchar *new_str;
1080
1081         if (!str || !old_val) {
1082                 return NULL;
1083         }
1084
1085         str_parts = g_strsplit(str, old_val, 0);
1086         new_str = g_strjoinv(new_val, str_parts);
1087         g_strfreev(str_parts);
1088
1089         return new_str;
1090 }