source: branches/samba-3.2.x/source/lib/util_str.c@ 201

Last change on this file since 201 was 141, checked in by Paul Smedley, 17 years ago

Update trunk to 3.2.1
File size: 60.6 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Samba utility functions
4
5 Copyright (C) Andrew Tridgell 1992-2001
6 Copyright (C) Simo Sorce 2001-2002
7 Copyright (C) Martin Pool 2003
8 Copyright (C) James Peach 2006
9 Copyright (C) Jeremy Allison 1992-2007
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
23*/
24
25#include "includes.h"
26
27char toupper_ascii_fast_table[128] = {
28 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
29 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
30 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
31 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
32 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
33 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
34 0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
35 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
36};
37
38/**
39 * @file
40 * @brief String utilities.
41 **/
42
43static bool next_token_internal_talloc(TALLOC_CTX *ctx,
44 const char **ptr,
45 char **pp_buff,
46 const char *sep,
47 bool ltrim)
48{
49 char *s;
50 char *saved_s;
51 char *pbuf;
52 bool quoted;
53 size_t len=1;
54
55 *pp_buff = NULL;
56 if (!ptr) {
57 return(false);
58 }
59
60 s = (char *)*ptr;
61
62 /* default to simple separators */
63 if (!sep) {
64 sep = " \t\n\r";
65 }
66
67 /* find the first non sep char, if left-trimming is requested */
68 if (ltrim) {
69 while (*s && strchr_m(sep,*s)) {
70 s++;
71 }
72 }
73
74 /* nothing left? */
75 if (!*s) {
76 return false;
77 }
78
79 /* When restarting we need to go from here. */
80 saved_s = s;
81
82 /* Work out the length needed. */
83 for (quoted = false; *s &&
84 (quoted || !strchr_m(sep,*s)); s++) {
85 if (*s == '\"') {
86 quoted = !quoted;
87 } else {
88 len++;
89 }
90 }
91
92 /* We started with len = 1 so we have space for the nul. */
93 *pp_buff = TALLOC_ARRAY(ctx, char, len);
94 if (!*pp_buff) {
95 return false;
96 }
97
98 /* copy over the token */
99 pbuf = *pp_buff;
100 s = saved_s;
101 for (quoted = false; *s &&
102 (quoted || !strchr_m(sep,*s)); s++) {
103 if ( *s == '\"' ) {
104 quoted = !quoted;
105 } else {
106 *pbuf++ = *s;
107 }
108 }
109
110 *ptr = (*s) ? s+1 : s;
111 *pbuf = 0;
112
113 return true;
114}
115
116#if 0
117/*
118 * Get the next token from a string, return false if none found. Handles
119 * double-quotes. This version trims leading separator characters before
120 * looking for a token.
121 */
122bool next_token(const char **ptr, char *buff, const char *sep, size_t bufsize)
123{
124 return next_token_internal(ptr, buff, sep, bufsize, true);
125}
126#endif
127
128bool next_token_talloc(TALLOC_CTX *ctx,
129 const char **ptr,
130 char **pp_buff,
131 const char *sep)
132{
133 return next_token_internal_talloc(ctx, ptr, pp_buff, sep, true);
134}
135
136/*
137 * Get the next token from a string, return false if none found. Handles
138 * double-quotes. This version does not trim leading separator characters
139 * before looking for a token.
140 */
141
142bool next_token_no_ltrim_talloc(TALLOC_CTX *ctx,
143 const char **ptr,
144 char **pp_buff,
145 const char *sep)
146{
147 return next_token_internal_talloc(ctx, ptr, pp_buff, sep, false);
148}
149
150/**
151 * Case insensitive string compararison.
152 *
153 * iconv does not directly give us a way to compare strings in
154 * arbitrary unix character sets -- all we can is convert and then
155 * compare. This is expensive.
156 *
157 * As an optimization, we do a first pass that considers only the
158 * prefix of the strings that is entirely 7-bit. Within this, we
159 * check whether they have the same value.
160 *
161 * Hopefully this will often give the answer without needing to copy.
162 * In particular it should speed comparisons to literal ascii strings
163 * or comparisons of strings that are "obviously" different.
164 *
165 * If we find a non-ascii character we fall back to converting via
166 * iconv.
167 *
168 * This should never be slower than convering the whole thing, and
169 * often faster.
170 *
171 * A different optimization would be to compare for bitwise equality
172 * in the binary encoding. (It would be possible thought hairy to do
173 * both simultaneously.) But in that case if they turn out to be
174 * different, we'd need to restart the whole thing.
175 *
176 * Even better is to implement strcasecmp for each encoding and use a
177 * function pointer.
178 **/
179int StrCaseCmp(const char *s, const char *t)
180{
181
182 const char *ps, *pt;
183 size_t size;
184 smb_ucs2_t *buffer_s, *buffer_t;
185 int ret;
186
187 for (ps = s, pt = t; ; ps++, pt++) {
188 char us, ut;
189
190 if (!*ps && !*pt)
191 return 0; /* both ended */
192 else if (!*ps)
193 return -1; /* s is a prefix */
194 else if (!*pt)
195 return +1; /* t is a prefix */
196 else if ((*ps & 0x80) || (*pt & 0x80))
197 /* not ascii anymore, do it the hard way
198 * from here on in */
199 break;
200
201 us = toupper_ascii_fast(*ps);
202 ut = toupper_ascii_fast(*pt);
203 if (us == ut)
204 continue;
205 else if (us < ut)
206 return -1;
207 else if (us > ut)
208 return +1;
209 }
210
211 size = push_ucs2_allocate(&buffer_s, ps);
212 if (size == (size_t)-1) {
213 return strcmp(ps, pt);
214 /* Not quite the right answer, but finding the right one
215 under this failure case is expensive, and it's pretty
216 close */
217 }
218
219 size = push_ucs2_allocate(&buffer_t, pt);
220 if (size == (size_t)-1) {
221 SAFE_FREE(buffer_s);
222 return strcmp(ps, pt);
223 /* Not quite the right answer, but finding the right one
224 under this failure case is expensive, and it's pretty
225 close */
226 }
227
228 ret = strcasecmp_w(buffer_s, buffer_t);
229 SAFE_FREE(buffer_s);
230 SAFE_FREE(buffer_t);
231 return ret;
232}
233
234
235/**
236 Case insensitive string compararison, length limited.
237**/
238int StrnCaseCmp(const char *s, const char *t, size_t len)
239{
240 size_t n = 0;
241 const char *ps, *pt;
242 size_t size;
243 smb_ucs2_t *buffer_s, *buffer_t;
244 int ret;
245
246 for (ps = s, pt = t; n < len ; ps++, pt++, n++) {
247 char us, ut;
248
249 if (!*ps && !*pt)
250 return 0; /* both ended */
251 else if (!*ps)
252 return -1; /* s is a prefix */
253 else if (!*pt)
254 return +1; /* t is a prefix */
255 else if ((*ps & 0x80) || (*pt & 0x80))
256 /* not ascii anymore, do it the
257 * hard way from here on in */
258 break;
259
260 us = toupper_ascii_fast(*ps);
261 ut = toupper_ascii_fast(*pt);
262 if (us == ut)
263 continue;
264 else if (us < ut)
265 return -1;
266 else if (us > ut)
267 return +1;
268 }
269
270 if (n == len) {
271 return 0;
272 }
273
274 size = push_ucs2_allocate(&buffer_s, ps);
275 if (size == (size_t)-1) {
276 return strncmp(ps, pt, len-n);
277 /* Not quite the right answer, but finding the right one
278 under this failure case is expensive,
279 and it's pretty close */
280 }
281
282 size = push_ucs2_allocate(&buffer_t, pt);
283 if (size == (size_t)-1) {
284 SAFE_FREE(buffer_s);
285 return strncmp(ps, pt, len-n);
286 /* Not quite the right answer, but finding the right one
287 under this failure case is expensive,
288 and it's pretty close */
289 }
290
291 ret = strncasecmp_w(buffer_s, buffer_t, len-n);
292 SAFE_FREE(buffer_s);
293 SAFE_FREE(buffer_t);
294 return ret;
295}
296
297/**
298 * Compare 2 strings.
299 *
300 * @note The comparison is case-insensitive.
301 **/
302bool strequal(const char *s1, const char *s2)
303{
304 if (s1 == s2)
305 return(true);
306 if (!s1 || !s2)
307 return(false);
308
309 return(StrCaseCmp(s1,s2)==0);
310}
311
312/**
313 * Compare 2 strings up to and including the nth char.
314 *
315 * @note The comparison is case-insensitive.
316 **/
317bool strnequal(const char *s1,const char *s2,size_t n)
318{
319 if (s1 == s2)
320 return(true);
321 if (!s1 || !s2 || !n)
322 return(false);
323
324 return(StrnCaseCmp(s1,s2,n)==0);
325}
326
327/**
328 Compare 2 strings (case sensitive).
329**/
330
331bool strcsequal(const char *s1,const char *s2)
332{
333 if (s1 == s2)
334 return(true);
335 if (!s1 || !s2)
336 return(false);
337
338 return(strcmp(s1,s2)==0);
339}
340
341/**
342Do a case-insensitive, whitespace-ignoring string compare.
343**/
344
345int strwicmp(const char *psz1, const char *psz2)
346{
347 /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
348 /* appropriate value. */
349 if (psz1 == psz2)
350 return (0);
351 else if (psz1 == NULL)
352 return (-1);
353 else if (psz2 == NULL)
354 return (1);
355
356 /* sync the strings on first non-whitespace */
357 while (1) {
358 while (isspace((int)*psz1))
359 psz1++;
360 while (isspace((int)*psz2))
361 psz2++;
362 if (toupper_ascii(*psz1) != toupper_ascii(*psz2) ||
363 *psz1 == '\0' || *psz2 == '\0')
364 break;
365 psz1++;
366 psz2++;
367 }
368 return (*psz1 - *psz2);
369}
370
371/**
372 Convert a string to "normal" form.
373**/
374
375void strnorm(char *s, int case_default)
376{
377 if (case_default == CASE_UPPER)
378 strupper_m(s);
379 else
380 strlower_m(s);
381}
382
383/**
384 Check if a string is in "normal" case.
385**/
386
387bool strisnormal(const char *s, int case_default)
388{
389 if (case_default == CASE_UPPER)
390 return(!strhaslower(s));
391
392 return(!strhasupper(s));
393}
394
395
396/**
397 String replace.
398 NOTE: oldc and newc must be 7 bit characters
399**/
400void string_replace( char *s, char oldc, char newc )
401{
402 char *p;
403
404 /* this is quite a common operation, so we want it to be
405 fast. We optimise for the ascii case, knowing that all our
406 supported multi-byte character sets are ascii-compatible
407 (ie. they match for the first 128 chars) */
408
409 for (p = s; *p; p++) {
410 if (*p & 0x80) /* mb string - slow path. */
411 break;
412 if (*p == oldc) {
413 *p = newc;
414 }
415 }
416
417 if (!*p)
418 return;
419
420 /* Slow (mb) path. */
421#ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
422 /* With compose characters we must restart from the beginning. JRA. */
423 p = s;
424#endif
425
426 while (*p) {
427 size_t c_size;
428 next_codepoint(p, &c_size);
429
430 if (c_size == 1) {
431 if (*p == oldc) {
432 *p = newc;
433 }
434 }
435 p += c_size;
436 }
437}
438
439/**
440 * Skip past some strings in a buffer - old version - no checks.
441 * **/
442
443char *push_skip_string(char *buf)
444{
445 buf += strlen(buf) + 1;
446 return(buf);
447}
448
449/**
450 Skip past a string in a buffer. Buffer may not be
451 null terminated. end_ptr points to the first byte after
452 then end of the buffer.
453**/
454
455char *skip_string(const char *base, size_t len, char *buf)
456{
457 const char *end_ptr = base + len;
458
459 if (end_ptr < base || !base || !buf || buf >= end_ptr) {
460 return NULL;
461 }
462
463 /* Skip the string */
464 while (*buf) {
465 buf++;
466 if (buf >= end_ptr) {
467 return NULL;
468 }
469 }
470 /* Skip the '\0' */
471 buf++;
472 return buf;
473}
474
475/**
476 Count the number of characters in a string. Normally this will
477 be the same as the number of bytes in a string for single byte strings,
478 but will be different for multibyte.
479**/
480
481size_t str_charnum(const char *s)
482{
483 size_t ret;
484 smb_ucs2_t *tmpbuf2 = NULL;
485 if (push_ucs2_allocate(&tmpbuf2, s) == (size_t)-1) {
486 return 0;
487 }
488 ret = strlen_w(tmpbuf2);
489 SAFE_FREE(tmpbuf2);
490 return ret;
491}
492
493/**
494 Count the number of characters in a string. Normally this will
495 be the same as the number of bytes in a string for single byte strings,
496 but will be different for multibyte.
497**/
498
499size_t str_ascii_charnum(const char *s)
500{
501 size_t ret;
502 char *tmpbuf2 = NULL;
503 if (push_ascii_allocate(&tmpbuf2, s) == (size_t)-1) {
504 return 0;
505 }
506 ret = strlen(tmpbuf2);
507 SAFE_FREE(tmpbuf2);
508 return ret;
509}
510
511bool trim_char(char *s,char cfront,char cback)
512{
513 bool ret = false;
514 char *ep;
515 char *fp = s;
516
517 /* Ignore null or empty strings. */
518 if (!s || (s[0] == '\0'))
519 return false;
520
521 if (cfront) {
522 while (*fp && *fp == cfront)
523 fp++;
524 if (!*fp) {
525 /* We ate the string. */
526 s[0] = '\0';
527 return true;
528 }
529 if (fp != s)
530 ret = true;
531 }
532
533 ep = fp + strlen(fp) - 1;
534 if (cback) {
535 /* Attempt ascii only. Bail for mb strings. */
536 while ((ep >= fp) && (*ep == cback)) {
537 ret = true;
538 if ((ep > fp) && (((unsigned char)ep[-1]) & 0x80)) {
539 /* Could be mb... bail back to tim_string. */
540 char fs[2], bs[2];
541 if (cfront) {
542 fs[0] = cfront;
543 fs[1] = '\0';
544 }
545 bs[0] = cback;
546 bs[1] = '\0';
547 return trim_string(s, cfront ? fs : NULL, bs);
548 } else {
549 ep--;
550 }
551 }
552 if (ep < fp) {
553 /* We ate the string. */
554 s[0] = '\0';
555 return true;
556 }
557 }
558
559 ep[1] = '\0';
560 memmove(s, fp, ep-fp+2);
561 return ret;
562}
563
564/**
565 Trim the specified elements off the front and back of a string.
566**/
567
568bool trim_string(char *s,const char *front,const char *back)
569{
570 bool ret = false;
571 size_t front_len;
572 size_t back_len;
573 size_t len;
574
575 /* Ignore null or empty strings. */
576 if (!s || (s[0] == '\0'))
577 return false;
578
579 front_len = front? strlen(front) : 0;
580 back_len = back? strlen(back) : 0;
581
582 len = strlen(s);
583
584 if (front_len) {
585 while (len && strncmp(s, front, front_len)==0) {
586 /* Must use memmove here as src & dest can
587 * easily overlap. Found by valgrind. JRA. */
588 memmove(s, s+front_len, (len-front_len)+1);
589 len -= front_len;
590 ret=true;
591 }
592 }
593
594 if (back_len) {
595 while ((len >= back_len) &&
596 strncmp(s+len-back_len,back,back_len)==0) {
597 s[len-back_len]='\0';
598 len -= back_len;
599 ret=true;
600 }
601 }
602 return ret;
603}
604
605/**
606 Does a string have any uppercase chars in it?
607**/
608
609bool strhasupper(const char *s)
610{
611 smb_ucs2_t *tmp, *p;
612 bool ret;
613
614 if (push_ucs2_allocate(&tmp, s) == -1) {
615 return false;
616 }
617
618 for(p = tmp; *p != 0; p++) {
619 if(isupper_w(*p)) {
620 break;
621 }
622 }
623
624 ret = (*p != 0);
625 SAFE_FREE(tmp);
626 return ret;
627}
628
629/**
630 Does a string have any lowercase chars in it?
631**/
632
633bool strhaslower(const char *s)
634{
635 smb_ucs2_t *tmp, *p;
636 bool ret;
637
638 if (push_ucs2_allocate(&tmp, s) == -1) {
639 return false;
640 }
641
642 for(p = tmp; *p != 0; p++) {
643 if(islower_w(*p)) {
644 break;
645 }
646 }
647
648 ret = (*p != 0);
649 SAFE_FREE(tmp);
650 return ret;
651}
652
653/**
654 Find the number of 'c' chars in a string
655**/
656
657size_t count_chars(const char *s,char c)
658{
659 smb_ucs2_t *ptr;
660 int count;
661 smb_ucs2_t *alloc_tmpbuf = NULL;
662
663 if (push_ucs2_allocate(&alloc_tmpbuf, s) == (size_t)-1) {
664 return 0;
665 }
666
667 for(count=0,ptr=alloc_tmpbuf;*ptr;ptr++)
668 if(*ptr==UCS2_CHAR(c))
669 count++;
670
671 SAFE_FREE(alloc_tmpbuf);
672 return(count);
673}
674
675/**
676 Safe string copy into a known length string. maxlength does not
677 include the terminating zero.
678**/
679
680char *safe_strcpy_fn(const char *fn,
681 int line,
682 char *dest,
683 const char *src,
684 size_t maxlength)
685{
686 size_t len;
687
688 if (!dest) {
689 DEBUG(0,("ERROR: NULL dest in safe_strcpy, "
690 "called from [%s][%d]\n", fn, line));
691 return NULL;
692 }
693
694#ifdef DEVELOPER
695 clobber_region(fn,line,dest, maxlength+1);
696#endif
697
698 if (!src) {
699 *dest = 0;
700 return dest;
701 }
702
703 len = strnlen(src, maxlength+1);
704
705 if (len > maxlength) {
706 DEBUG(0,("ERROR: string overflow by "
707 "%lu (%lu - %lu) in safe_strcpy [%.50s]\n",
708 (unsigned long)(len-maxlength), (unsigned long)len,
709 (unsigned long)maxlength, src));
710 len = maxlength;
711 }
712
713 memmove(dest, src, len);
714 dest[len] = 0;
715 return dest;
716}
717
718/**
719 Safe string cat into a string. maxlength does not
720 include the terminating zero.
721**/
722char *safe_strcat_fn(const char *fn,
723 int line,
724 char *dest,
725 const char *src,
726 size_t maxlength)
727{
728 size_t src_len, dest_len;
729
730 if (!dest) {
731 DEBUG(0,("ERROR: NULL dest in safe_strcat, "
732 "called from [%s][%d]\n", fn, line));
733 return NULL;
734 }
735
736 if (!src)
737 return dest;
738
739 src_len = strnlen(src, maxlength + 1);
740 dest_len = strnlen(dest, maxlength + 1);
741
742#ifdef DEVELOPER
743 clobber_region(fn, line, dest + dest_len, maxlength + 1 - dest_len);
744#endif
745
746 if (src_len + dest_len > maxlength) {
747 DEBUG(0,("ERROR: string overflow by %d "
748 "in safe_strcat [%.50s]\n",
749 (int)(src_len + dest_len - maxlength), src));
750 if (maxlength > dest_len) {
751 memcpy(&dest[dest_len], src, maxlength - dest_len);
752 }
753 dest[maxlength] = 0;
754 return NULL;
755 }
756
757 memcpy(&dest[dest_len], src, src_len);
758 dest[dest_len + src_len] = 0;
759 return dest;
760}
761
762/**
763 Paranoid strcpy into a buffer of given length (includes terminating
764 zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
765 and replaces with '_'. Deliberately does *NOT* check for multibyte
766 characters. Don't change it !
767**/
768
769char *alpha_strcpy_fn(const char *fn,
770 int line,
771 char *dest,
772 const char *src,
773 const char *other_safe_chars,
774 size_t maxlength)
775{
776 size_t len, i;
777
778#ifdef DEVELOPER
779 clobber_region(fn, line, dest, maxlength);
780#endif
781
782 if (!dest) {
783 DEBUG(0,("ERROR: NULL dest in alpha_strcpy, "
784 "called from [%s][%d]\n", fn, line));
785 return NULL;
786 }
787
788 if (!src) {
789 *dest = 0;
790 return dest;
791 }
792
793 len = strlen(src);
794 if (len >= maxlength)
795 len = maxlength - 1;
796
797 if (!other_safe_chars)
798 other_safe_chars = "";
799
800 for(i = 0; i < len; i++) {
801 int val = (src[i] & 0xff);
802 if (isupper_ascii(val) || islower_ascii(val) ||
803 isdigit(val) || strchr_m(other_safe_chars, val))
804 dest[i] = src[i];
805 else
806 dest[i] = '_';
807 }
808
809 dest[i] = '\0';
810
811 return dest;
812}
813
814/**
815 Like strncpy but always null terminates. Make sure there is room!
816 The variable n should always be one less than the available size.
817**/
818char *StrnCpy_fn(const char *fn, int line,char *dest,const char *src,size_t n)
819{
820 char *d = dest;
821
822#ifdef DEVELOPER
823 clobber_region(fn, line, dest, n+1);
824#endif
825
826 if (!dest) {
827 DEBUG(0,("ERROR: NULL dest in StrnCpy, "
828 "called from [%s][%d]\n", fn, line));
829 return(NULL);
830 }
831
832 if (!src) {
833 *dest = 0;
834 return(dest);
835 }
836
837 while (n-- && (*d = *src)) {
838 d++;
839 src++;
840 }
841
842 *d = 0;
843 return(dest);
844}
845
846#if 0
847/**
848 Like strncpy but copies up to the character marker. always null terminates.
849 returns a pointer to the character marker in the source string (src).
850**/
851
852static char *strncpyn(char *dest, const char *src, size_t n, char c)
853{
854 char *p;
855 size_t str_len;
856
857#ifdef DEVELOPER
858 clobber_region(dest, n+1);
859#endif
860 p = strchr_m(src, c);
861 if (p == NULL) {
862 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
863 return NULL;
864 }
865
866 str_len = PTR_DIFF(p, src);
867 strncpy(dest, src, MIN(n, str_len));
868 dest[str_len] = '\0';
869
870 return p;
871}
872#endif
873
874/**
875 Routine to get hex characters and turn them into a 16 byte array.
876 the array can be variable length, and any non-hex-numeric
877 characters are skipped. "0xnn" or "0Xnn" is specially catered
878 for.
879
880 valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
881
882**/
883
884size_t strhex_to_str(char *buf, size_t buf_len, const char *strhex, size_t strhex_len)
885{
886 size_t i;
887 size_t num_chars = 0;
888 unsigned char lonybble, hinybble;
889 const char *hexchars = "0123456789ABCDEF";
890 char *p1 = NULL, *p2 = NULL;
891
892 for (i = 0; i < strhex_len && strhex[i] != 0; i++) {
893 if (strnequal(hexchars, "0x", 2)) {
894 i++; /* skip two chars */
895 continue;
896 }
897
898 if (!(p1 = strchr_m(hexchars, toupper_ascii(strhex[i]))))
899 break;
900
901 i++; /* next hex digit */
902
903 if (!(p2 = strchr_m(hexchars, toupper_ascii(strhex[i]))))
904 break;
905
906 /* get the two nybbles */
907 hinybble = PTR_DIFF(p1, hexchars);
908 lonybble = PTR_DIFF(p2, hexchars);
909
910 if (num_chars >= buf_len) {
911 break;
912 }
913 buf[num_chars] = (hinybble << 4) | lonybble;
914 num_chars++;
915
916 p1 = NULL;
917 p2 = NULL;
918 }
919 return num_chars;
920}
921
922DATA_BLOB strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *strhex)
923{
924 DATA_BLOB ret_blob;
925
926 if (mem_ctx != NULL)
927 ret_blob = data_blob_talloc(mem_ctx, NULL, strlen(strhex)/2+1);
928 else
929 ret_blob = data_blob(NULL, strlen(strhex)/2+1);
930
931 ret_blob.length = strhex_to_str((char*)ret_blob.data,
932 ret_blob.length,
933 strhex,
934 strlen(strhex));
935
936 return ret_blob;
937}
938
939/**
940 * Routine to print a buffer as HEX digits, into an allocated string.
941 */
942
943char *hex_encode(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len)
944{
945 int i;
946 char *hex_buffer;
947
948 hex_buffer = TALLOC_ARRAY(mem_ctx, char, (len*2)+1);
949
950 for (i = 0; i < len; i++)
951 slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
952
953 return hex_buffer;
954}
955
956/**
957 Check if a string is part of a list.
958**/
959
960bool in_list(const char *s, const char *list, bool casesensitive)
961{
962 char *tok = NULL;
963 bool ret = false;
964 TALLOC_CTX *frame;
965
966 if (!list) {
967 return false;
968 }
969
970 frame = talloc_stackframe();
971 while (next_token_talloc(frame, &list, &tok,LIST_SEP)) {
972 if (casesensitive) {
973 if (strcmp(tok,s) == 0) {
974 ret = true;
975 break;
976 }
977 } else {
978 if (StrCaseCmp(tok,s) == 0) {
979 ret = true;
980 break;
981 }
982 }
983 }
984 TALLOC_FREE(frame);
985 return ret;
986}
987
988/* this is used to prevent lots of mallocs of size 1 */
989static const char null_string[] = "";
990
991/**
992 Set a string value, allocing the space for the string
993**/
994
995static bool string_init(char **dest,const char *src)
996{
997 size_t l;
998
999 if (!src)
1000 src = "";
1001
1002 l = strlen(src);
1003
1004 if (l == 0) {
1005 *dest = CONST_DISCARD(char*, null_string);
1006 } else {
1007 (*dest) = SMB_STRDUP(src);
1008 if ((*dest) == NULL) {
1009 DEBUG(0,("Out of memory in string_init\n"));
1010 return false;
1011 }
1012 }
1013 return(true);
1014}
1015
1016/**
1017 Free a string value.
1018**/
1019
1020void string_free(char **s)
1021{
1022 if (!s || !(*s))
1023 return;
1024 if (*s == null_string)
1025 *s = NULL;
1026 SAFE_FREE(*s);
1027}
1028
1029/**
1030 Set a string value, deallocating any existing space, and allocing the space
1031 for the string
1032**/
1033
1034bool string_set(char **dest,const char *src)
1035{
1036 string_free(dest);
1037 return(string_init(dest,src));
1038}
1039
1040/**
1041 Substitute a string for a pattern in another string. Make sure there is
1042 enough room!
1043
1044 This routine looks for pattern in s and replaces it with
1045 insert. It may do multiple replacements or just one.
1046
1047 Any of " ; ' $ or ` in the insert string are replaced with _
1048 if len==0 then the string cannot be extended. This is different from the old
1049 use of len==0 which was for no length checks to be done.
1050**/
1051
1052void string_sub2(char *s,const char *pattern, const char *insert, size_t len,
1053 bool remove_unsafe_characters, bool replace_once,
1054 bool allow_trailing_dollar)
1055{
1056 char *p;
1057 ssize_t ls,lp,li, i;
1058
1059 if (!insert || !pattern || !*pattern || !s)
1060 return;
1061
1062 ls = (ssize_t)strlen(s);
1063 lp = (ssize_t)strlen(pattern);
1064 li = (ssize_t)strlen(insert);
1065
1066 if (len == 0)
1067 len = ls + 1; /* len is number of *bytes* */
1068
1069 while (lp <= ls && (p = strstr_m(s,pattern))) {
1070 if (ls + (li-lp) >= len) {
1071 DEBUG(0,("ERROR: string overflow by "
1072 "%d in string_sub(%.50s, %d)\n",
1073 (int)(ls + (li-lp) - len),
1074 pattern, (int)len));
1075 break;
1076 }
1077 if (li != lp) {
1078 memmove(p+li,p+lp,strlen(p+lp)+1);
1079 }
1080 for (i=0;i<li;i++) {
1081 switch (insert[i]) {
1082 case '`':
1083 case '"':
1084 case '\'':
1085 case ';':
1086 case '$':
1087 /* allow a trailing $
1088 * (as in machine accounts) */
1089 if (allow_trailing_dollar && (i == li - 1 )) {
1090 p[i] = insert[i];
1091 break;
1092 }
1093 case '%':
1094 case '\r':
1095 case '\n':
1096 if ( remove_unsafe_characters ) {
1097 p[i] = '_';
1098 /* yes this break should be here
1099 * since we want to fall throw if
1100 * not replacing unsafe chars */
1101 break;
1102 }
1103 default:
1104 p[i] = insert[i];
1105 }
1106 }
1107 s = p + li;
1108 ls += (li-lp);
1109
1110 if (replace_once)
1111 break;
1112 }
1113}
1114
1115void string_sub_once(char *s, const char *pattern,
1116 const char *insert, size_t len)
1117{
1118 string_sub2( s, pattern, insert, len, true, true, false );
1119}
1120
1121void string_sub(char *s,const char *pattern, const char *insert, size_t len)
1122{
1123 string_sub2( s, pattern, insert, len, true, false, false );
1124}
1125
1126void fstring_sub(char *s,const char *pattern,const char *insert)
1127{
1128 string_sub(s, pattern, insert, sizeof(fstring));
1129}
1130
1131/**
1132 Similar to string_sub2, but it will accept only allocated strings
1133 and may realloc them so pay attention at what you pass on no
1134 pointers inside strings, no const may be passed
1135 as string.
1136**/
1137
1138char *realloc_string_sub2(char *string,
1139 const char *pattern,
1140 const char *insert,
1141 bool remove_unsafe_characters,
1142 bool allow_trailing_dollar)
1143{
1144 char *p, *in;
1145 char *s;
1146 ssize_t ls,lp,li,ld, i;
1147
1148 if (!insert || !pattern || !*pattern || !string || !*string)
1149 return NULL;
1150
1151 s = string;
1152
1153 in = SMB_STRDUP(insert);
1154 if (!in) {
1155 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1156 return NULL;
1157 }
1158 ls = (ssize_t)strlen(s);
1159 lp = (ssize_t)strlen(pattern);
1160 li = (ssize_t)strlen(insert);
1161 ld = li - lp;
1162 for (i=0;i<li;i++) {
1163 switch (in[i]) {
1164 case '`':
1165 case '"':
1166 case '\'':
1167 case ';':
1168 case '$':
1169 /* allow a trailing $
1170 * (as in machine accounts) */
1171 if (allow_trailing_dollar && (i == li - 1 )) {
1172 break;
1173 }
1174 case '%':
1175 case '\r':
1176 case '\n':
1177 if ( remove_unsafe_characters ) {
1178 in[i] = '_';
1179 break;
1180 }
1181 default:
1182 /* ok */
1183 break;
1184 }
1185 }
1186
1187 while ((p = strstr_m(s,pattern))) {
1188 if (ld > 0) {
1189 int offset = PTR_DIFF(s,string);
1190 string = (char *)SMB_REALLOC(string, ls + ld + 1);
1191 if (!string) {
1192 DEBUG(0, ("realloc_string_sub: "
1193 "out of memory!\n"));
1194 SAFE_FREE(in);
1195 return NULL;
1196 }
1197 p = string + offset + (p - s);
1198 }
1199 if (li != lp) {
1200 memmove(p+li,p+lp,strlen(p+lp)+1);
1201 }
1202 memcpy(p, in, li);
1203 s = p + li;
1204 ls += ld;
1205 }
1206 SAFE_FREE(in);
1207 return string;
1208}
1209
1210char *realloc_string_sub(char *string,
1211 const char *pattern,
1212 const char *insert)
1213{
1214 return realloc_string_sub2(string, pattern, insert, true, false);
1215}
1216
1217/*
1218 * Internal guts of talloc_string_sub and talloc_all_string_sub.
1219 * talloc version of string_sub2.
1220 */
1221
1222char *talloc_string_sub2(TALLOC_CTX *mem_ctx, const char *src,
1223 const char *pattern,
1224 const char *insert,
1225 bool remove_unsafe_characters,
1226 bool replace_once,
1227 bool allow_trailing_dollar)
1228{
1229 char *p, *in;
1230 char *s;
1231 char *string;
1232 ssize_t ls,lp,li,ld, i;
1233
1234 if (!insert || !pattern || !*pattern || !src) {
1235 return NULL;
1236 }
1237
1238 string = talloc_strdup(mem_ctx, src);
1239 if (string == NULL) {
1240 DEBUG(0, ("talloc_string_sub2: "
1241 "talloc_strdup failed\n"));
1242 return NULL;
1243 }
1244
1245 s = string;
1246
1247 in = SMB_STRDUP(insert);
1248 if (!in) {
1249 DEBUG(0, ("talloc_string_sub2: ENOMEM\n"));
1250 return NULL;
1251 }
1252 ls = (ssize_t)strlen(s);
1253 lp = (ssize_t)strlen(pattern);
1254 li = (ssize_t)strlen(insert);
1255 ld = li - lp;
1256
1257 for (i=0;i<li;i++) {
1258 switch (in[i]) {
1259 case '`':
1260 case '"':
1261 case '\'':
1262 case ';':
1263 case '$':
1264 /* allow a trailing $
1265 * (as in machine accounts) */
1266 if (allow_trailing_dollar && (i == li - 1 )) {
1267 break;
1268 }
1269 case '%':
1270 case '\r':
1271 case '\n':
1272 if (remove_unsafe_characters) {
1273 in[i] = '_';
1274 break;
1275 }
1276 default:
1277 /* ok */
1278 break;
1279 }
1280 }
1281
1282 while ((p = strstr_m(s,pattern))) {
1283 if (ld > 0) {
1284 int offset = PTR_DIFF(s,string);
1285 string = (char *)TALLOC_REALLOC(mem_ctx, string,
1286 ls + ld + 1);
1287 if (!string) {
1288 DEBUG(0, ("talloc_string_sub: out of "
1289 "memory!\n"));
1290 SAFE_FREE(in);
1291 return NULL;
1292 }
1293 p = string + offset + (p - s);
1294 }
1295 if (li != lp) {
1296 memmove(p+li,p+lp,strlen(p+lp)+1);
1297 }
1298 memcpy(p, in, li);
1299 s = p + li;
1300 ls += ld;
1301
1302 if (replace_once) {
1303 break;
1304 }
1305 }
1306 SAFE_FREE(in);
1307 return string;
1308}
1309
1310/* Same as string_sub, but returns a talloc'ed string */
1311
1312char *talloc_string_sub(TALLOC_CTX *mem_ctx,
1313 const char *src,
1314 const char *pattern,
1315 const char *insert)
1316{
1317 return talloc_string_sub2(mem_ctx, src, pattern, insert,
1318 true, false, false);
1319}
1320
1321/**
1322 Similar to string_sub() but allows for any character to be substituted.
1323 Use with caution!
1324 if len==0 then the string cannot be extended. This is different from the old
1325 use of len==0 which was for no length checks to be done.
1326**/
1327
1328void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
1329{
1330 char *p;
1331 ssize_t ls,lp,li;
1332
1333 if (!insert || !pattern || !s)
1334 return;
1335
1336 ls = (ssize_t)strlen(s);
1337 lp = (ssize_t)strlen(pattern);
1338 li = (ssize_t)strlen(insert);
1339
1340 if (!*pattern)
1341 return;
1342
1343 if (len == 0)
1344 len = ls + 1; /* len is number of *bytes* */
1345
1346 while (lp <= ls && (p = strstr_m(s,pattern))) {
1347 if (ls + (li-lp) >= len) {
1348 DEBUG(0,("ERROR: string overflow by "
1349 "%d in all_string_sub(%.50s, %d)\n",
1350 (int)(ls + (li-lp) - len),
1351 pattern, (int)len));
1352 break;
1353 }
1354 if (li != lp) {
1355 memmove(p+li,p+lp,strlen(p+lp)+1);
1356 }
1357 memcpy(p, insert, li);
1358 s = p + li;
1359 ls += (li-lp);
1360 }
1361}
1362
1363char *talloc_all_string_sub(TALLOC_CTX *ctx,
1364 const char *src,
1365 const char *pattern,
1366 const char *insert)
1367{
1368 return talloc_string_sub2(ctx, src, pattern, insert,
1369 false, false, false);
1370}
1371
1372/**
1373 Write an octal as a string.
1374**/
1375
1376char *octal_string(int i)
1377{
1378 char *result;
1379 if (i == -1) {
1380 result = talloc_strdup(talloc_tos(), "-1");
1381 }
1382 else {
1383 result = talloc_asprintf(talloc_tos(), "0%o", i);
1384 }
1385 SMB_ASSERT(result != NULL);
1386 return result;
1387}
1388
1389
1390/**
1391 Truncate a string at a specified length.
1392**/
1393
1394char *string_truncate(char *s, unsigned int length)
1395{
1396 if (s && strlen(s) > length)
1397 s[length] = 0;
1398 return s;
1399}
1400
1401/**
1402 Strchr and strrchr_m are very hard to do on general multi-byte strings.
1403 We convert via ucs2 for now.
1404**/
1405
1406char *strchr_m(const char *src, char c)
1407{
1408 smb_ucs2_t *ws = NULL;
1409 char *s2 = NULL;
1410 smb_ucs2_t *p;
1411 const char *s;
1412 char *ret;
1413
1414 /* characters below 0x3F are guaranteed to not appear in
1415 non-initial position in multi-byte charsets */
1416 if ((c & 0xC0) == 0) {
1417 return strchr(src, c);
1418 }
1419
1420 /* this is quite a common operation, so we want it to be
1421 fast. We optimise for the ascii case, knowing that all our
1422 supported multi-byte character sets are ascii-compatible
1423 (ie. they match for the first 128 chars) */
1424
1425 for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1426 if (*s == c)
1427 return (char *)s;
1428 }
1429
1430 if (!*s)
1431 return NULL;
1432
1433#ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
1434 /* With compose characters we must restart from the beginning. JRA. */
1435 s = src;
1436#endif
1437
1438 if (push_ucs2_allocate(&ws, s)==(size_t)-1) {
1439 /* Wrong answer, but what can we do... */
1440 return strchr(src, c);
1441 }
1442 p = strchr_w(ws, UCS2_CHAR(c));
1443 if (!p) {
1444 SAFE_FREE(ws);
1445 return NULL;
1446 }
1447 *p = 0;
1448 if (pull_ucs2_allocate(&s2, ws)==(size_t)-1) {
1449 SAFE_FREE(ws);
1450 /* Wrong answer, but what can we do... */
1451 return strchr(src, c);
1452 }
1453 ret = (char *)(s+strlen(s2));
1454 SAFE_FREE(ws);
1455 SAFE_FREE(s2);
1456 return ret;
1457}
1458
1459char *strrchr_m(const char *s, char c)
1460{
1461 /* characters below 0x3F are guaranteed to not appear in
1462 non-initial position in multi-byte charsets */
1463 if ((c & 0xC0) == 0) {
1464 return strrchr(s, c);
1465 }
1466
1467 /* this is quite a common operation, so we want it to be
1468 fast. We optimise for the ascii case, knowing that all our
1469 supported multi-byte character sets are ascii-compatible
1470 (ie. they match for the first 128 chars). Also, in Samba
1471 we only search for ascii characters in 'c' and that
1472 in all mb character sets with a compound character
1473 containing c, if 'c' is not a match at position
1474 p, then p[-1] > 0x7f. JRA. */
1475
1476 {
1477 size_t len = strlen(s);
1478 const char *cp = s;
1479 bool got_mb = false;
1480
1481 if (len == 0)
1482 return NULL;
1483 cp += (len - 1);
1484 do {
1485 if (c == *cp) {
1486 /* Could be a match. Part of a multibyte ? */
1487 if ((cp > s) &&
1488 (((unsigned char)cp[-1]) & 0x80)) {
1489 /* Yep - go slow :-( */
1490 got_mb = true;
1491 break;
1492 }
1493 /* No - we have a match ! */
1494 return (char *)cp;
1495 }
1496 } while (cp-- != s);
1497 if (!got_mb)
1498 return NULL;
1499 }
1500
1501 /* String contained a non-ascii char. Slow path. */
1502 {
1503 smb_ucs2_t *ws = NULL;
1504 char *s2 = NULL;
1505 smb_ucs2_t *p;
1506 char *ret;
1507
1508 if (push_ucs2_allocate(&ws,s)==(size_t)-1) {
1509 /* Wrong answer, but what can we do. */
1510 return strrchr(s, c);
1511 }
1512 p = strrchr_w(ws, UCS2_CHAR(c));
1513 if (!p) {
1514 SAFE_FREE(ws);
1515 return NULL;
1516 }
1517 *p = 0;
1518 if (pull_ucs2_allocate(&s2,ws)==(size_t)-1) {
1519 SAFE_FREE(ws);
1520 /* Wrong answer, but what can we do. */
1521 return strrchr(s, c);
1522 }
1523 ret = (char *)(s+strlen(s2));
1524 SAFE_FREE(ws);
1525 SAFE_FREE(s2);
1526 return ret;
1527 }
1528}
1529
1530/***********************************************************************
1531 Return the equivalent of doing strrchr 'n' times - always going
1532 backwards.
1533***********************************************************************/
1534
1535char *strnrchr_m(const char *s, char c, unsigned int n)
1536{
1537 smb_ucs2_t *ws = NULL;
1538 char *s2 = NULL;
1539 smb_ucs2_t *p;
1540 char *ret;
1541
1542 if (push_ucs2_allocate(&ws,s)==(size_t)-1) {
1543 /* Too hard to try and get right. */
1544 return NULL;
1545 }
1546 p = strnrchr_w(ws, UCS2_CHAR(c), n);
1547 if (!p) {
1548 SAFE_FREE(ws);
1549 return NULL;
1550 }
1551 *p = 0;
1552 if (pull_ucs2_allocate(&s2,ws)==(size_t)-1) {
1553 SAFE_FREE(ws);
1554 /* Too hard to try and get right. */
1555 return NULL;
1556 }
1557 ret = (char *)(s+strlen(s2));
1558 SAFE_FREE(ws);
1559 SAFE_FREE(s2);
1560 return ret;
1561}
1562
1563/***********************************************************************
1564 strstr_m - We convert via ucs2 for now.
1565***********************************************************************/
1566
1567char *strstr_m(const char *src, const char *findstr)
1568{
1569 smb_ucs2_t *p;
1570 smb_ucs2_t *src_w, *find_w;
1571 const char *s;
1572 char *s2;
1573 char *retp;
1574
1575 size_t findstr_len = 0;
1576
1577 /* for correctness */
1578 if (!findstr[0]) {
1579 return (char*)src;
1580 }
1581
1582 /* Samba does single character findstr calls a *lot*. */
1583 if (findstr[1] == '\0')
1584 return strchr_m(src, *findstr);
1585
1586 /* We optimise for the ascii case, knowing that all our
1587 supported multi-byte character sets are ascii-compatible
1588 (ie. they match for the first 128 chars) */
1589
1590 for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1591 if (*s == *findstr) {
1592 if (!findstr_len)
1593 findstr_len = strlen(findstr);
1594
1595 if (strncmp(s, findstr, findstr_len) == 0) {
1596 return (char *)s;
1597 }
1598 }
1599 }
1600
1601 if (!*s)
1602 return NULL;
1603
1604#if 1 /* def BROKEN_UNICODE_COMPOSE_CHARACTERS */
1605 /* 'make check' fails unless we do this */
1606
1607 /* With compose characters we must restart from the beginning. JRA. */
1608 s = src;
1609#endif
1610
1611 if (push_ucs2_allocate(&src_w, src) == (size_t)-1) {
1612 DEBUG(0,("strstr_m: src malloc fail\n"));
1613 return NULL;
1614 }
1615
1616 if (push_ucs2_allocate(&find_w, findstr) == (size_t)-1) {
1617 SAFE_FREE(src_w);
1618 DEBUG(0,("strstr_m: find malloc fail\n"));
1619 return NULL;
1620 }
1621
1622 p = strstr_w(src_w, find_w);
1623
1624 if (!p) {
1625 SAFE_FREE(src_w);
1626 SAFE_FREE(find_w);
1627 return NULL;
1628 }
1629
1630 *p = 0;
1631 if (pull_ucs2_allocate(&s2, src_w) == (size_t)-1) {
1632 SAFE_FREE(src_w);
1633 SAFE_FREE(find_w);
1634 DEBUG(0,("strstr_m: dest malloc fail\n"));
1635 return NULL;
1636 }
1637 retp = (char *)(s+strlen(s2));
1638 SAFE_FREE(src_w);
1639 SAFE_FREE(find_w);
1640 SAFE_FREE(s2);
1641 return retp;
1642}
1643
1644/**
1645 Convert a string to lower case.
1646**/
1647
1648void strlower_m(char *s)
1649{
1650 size_t len;
1651 int errno_save;
1652
1653 /* this is quite a common operation, so we want it to be
1654 fast. We optimise for the ascii case, knowing that all our
1655 supported multi-byte character sets are ascii-compatible
1656 (ie. they match for the first 128 chars) */
1657
1658 while (*s && !(((unsigned char)s[0]) & 0x80)) {
1659 *s = tolower_ascii((unsigned char)*s);
1660 s++;
1661 }
1662
1663 if (!*s)
1664 return;
1665
1666 /* I assume that lowercased string takes the same number of bytes
1667 * as source string even in UTF-8 encoding. (VIV) */
1668 len = strlen(s) + 1;
1669 errno_save = errno;
1670 errno = 0;
1671 unix_strlower(s,len,s,len);
1672 /* Catch mb conversion errors that may not terminate. */
1673 if (errno)
1674 s[len-1] = '\0';
1675 errno = errno_save;
1676}
1677
1678/**
1679 Convert a string to upper case.
1680**/
1681
1682void strupper_m(char *s)
1683{
1684 size_t len;
1685 int errno_save;
1686
1687 /* this is quite a common operation, so we want it to be
1688 fast. We optimise for the ascii case, knowing that all our
1689 supported multi-byte character sets are ascii-compatible
1690 (ie. they match for the first 128 chars) */
1691
1692 while (*s && !(((unsigned char)s[0]) & 0x80)) {
1693 *s = toupper_ascii_fast((unsigned char)*s);
1694 s++;
1695 }
1696
1697 if (!*s)
1698 return;
1699
1700 /* I assume that lowercased string takes the same number of bytes
1701 * as source string even in multibyte encoding. (VIV) */
1702 len = strlen(s) + 1;
1703 errno_save = errno;
1704 errno = 0;
1705 unix_strupper(s,len,s,len);
1706 /* Catch mb conversion errors that may not terminate. */
1707 if (errno)
1708 s[len-1] = '\0';
1709 errno = errno_save;
1710}
1711
1712/**
1713 Count the number of UCS2 characters in a string. Normally this will
1714 be the same as the number of bytes in a string for single byte strings,
1715 but will be different for multibyte.
1716**/
1717
1718size_t strlen_m(const char *s)
1719{
1720 size_t count = 0;
1721
1722 if (!s) {
1723 return 0;
1724 }
1725
1726 while (*s && !(((uint8_t)*s) & 0x80)) {
1727 s++;
1728 count++;
1729 }
1730
1731 if (!*s) {
1732 return count;
1733 }
1734
1735 while (*s) {
1736 size_t c_size;
1737 codepoint_t c = next_codepoint(s, &c_size);
1738 if (c < 0x10000) {
1739 /* Unicode char fits into 16 bits. */
1740 count += 1;
1741 } else {
1742 /* Double-width unicode char - 32 bits. */
1743 count += 2;
1744 }
1745 s += c_size;
1746 }
1747
1748 return count;
1749}
1750
1751/**
1752 Count the number of UCS2 characters in a string including the null
1753 terminator.
1754**/
1755
1756size_t strlen_m_term(const char *s)
1757{
1758 if (!s) {
1759 return 0;
1760 }
1761 return strlen_m(s) + 1;
1762}
1763
1764/*
1765 * Weird helper routine for the winreg pipe: If nothing is around, return 0,
1766 * if a string is there, include the terminator.
1767 */
1768
1769size_t strlen_m_term_null(const char *s)
1770{
1771 size_t len;
1772 if (!s) {
1773 return 0;
1774 }
1775 len = strlen_m(s);
1776 if (len == 0) {
1777 return 0;
1778 }
1779
1780 return len+1;
1781}
1782/**
1783 Return a RFC2254 binary string representation of a buffer.
1784 Used in LDAP filters.
1785 Caller must free.
1786**/
1787
1788char *binary_string_rfc2254(char *buf, int len)
1789{
1790 char *s;
1791 int i, j;
1792 const char *hex = "0123456789ABCDEF";
1793 s = (char *)SMB_MALLOC(len * 3 + 1);
1794 if (!s)
1795 return NULL;
1796 for (j=i=0;i<len;i++) {
1797 s[j] = '\\';
1798 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1799 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1800 j += 3;
1801 }
1802 s[j] = 0;
1803 return s;
1804}
1805
1806char *binary_string(char *buf, int len)
1807{
1808 char *s;
1809 int i, j;
1810 const char *hex = "0123456789ABCDEF";
1811 s = (char *)SMB_MALLOC(len * 2 + 1);
1812 if (!s)
1813 return NULL;
1814 for (j=i=0;i<len;i++) {
1815 s[j] = hex[((unsigned char)buf[i]) >> 4];
1816 s[j+1] = hex[((unsigned char)buf[i]) & 0xF];
1817 j += 2;
1818 }
1819 s[j] = 0;
1820 return s;
1821}
1822
1823/**
1824 Just a typesafety wrapper for snprintf into a fstring.
1825**/
1826
1827int fstr_sprintf(fstring s, const char *fmt, ...)
1828{
1829 va_list ap;
1830 int ret;
1831
1832 va_start(ap, fmt);
1833 ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
1834 va_end(ap);
1835 return ret;
1836}
1837
1838/**
1839 List of Strings manipulation functions
1840**/
1841
1842#define S_LIST_ABS 16 /* List Allocation Block Size */
1843
1844char **str_list_make(TALLOC_CTX *mem_ctx, const char *string, const char *sep)
1845{
1846 char **list;
1847 const char *str;
1848 char *s;
1849 int num, lsize;
1850 char *tok;
1851
1852 if (!string || !*string)
1853 return NULL;
1854
1855 list = TALLOC_ARRAY(mem_ctx, char *, S_LIST_ABS+1);
1856 if (list == NULL) {
1857 return NULL;
1858 }
1859 lsize = S_LIST_ABS;
1860
1861 s = talloc_strdup(list, string);
1862 if (s == NULL) {
1863 DEBUG(0,("str_list_make: Unable to allocate memory"));
1864 TALLOC_FREE(list);
1865 return NULL;
1866 }
1867 if (!sep) sep = LIST_SEP;
1868
1869 num = 0;
1870 str = s;
1871
1872 while (next_token_talloc(list, &str, &tok, sep)) {
1873
1874 if (num == lsize) {
1875 char **tmp;
1876
1877 lsize += S_LIST_ABS;
1878
1879 tmp = TALLOC_REALLOC_ARRAY(mem_ctx, list, char *,
1880 lsize + 1);
1881 if (tmp == NULL) {
1882 DEBUG(0,("str_list_make: "
1883 "Unable to allocate memory"));
1884 TALLOC_FREE(list);
1885 return NULL;
1886 }
1887
1888 list = tmp;
1889
1890 memset (&list[num], 0,
1891 ((sizeof(char**)) * (S_LIST_ABS +1)));
1892 }
1893
1894 list[num] = tok;
1895 num += 1;
1896 }
1897
1898 list[num] = NULL;
1899
1900 TALLOC_FREE(s);
1901 return list;
1902}
1903
1904bool str_list_copy(TALLOC_CTX *mem_ctx, char ***dest, const char **src)
1905{
1906 char **list;
1907 int i, num;
1908
1909 *dest = NULL;
1910 if (!src)
1911 return false;
1912
1913 num = 0;
1914 while (src[num] != NULL) {
1915 num += 1;
1916 }
1917
1918 list = TALLOC_ARRAY(mem_ctx, char *, num+1);
1919 if (list == NULL) {
1920 return false;
1921 }
1922
1923 for (i=0; i<num; i++) {
1924 list[i] = talloc_strdup(list, src[i]);
1925 if (list[i] == NULL) {
1926 TALLOC_FREE(list);
1927 return false;
1928 }
1929 }
1930 list[i] = NULL;
1931 *dest = list;
1932 return true;
1933}
1934
1935/**
1936 * Return true if all the elements of the list match exactly.
1937 **/
1938bool str_list_compare(char **list1, char **list2)
1939{
1940 int num;
1941
1942 if (!list1 || !list2)
1943 return (list1 == list2);
1944
1945 for (num = 0; list1[num]; num++) {
1946 if (!list2[num])
1947 return false;
1948 if (!strcsequal(list1[num], list2[num]))
1949 return false;
1950 }
1951 if (list2[num])
1952 return false; /* if list2 has more elements than list1 fail */
1953
1954 return true;
1955}
1956
1957/******************************************************************************
1958 *****************************************************************************/
1959
1960int str_list_count( const char **list )
1961{
1962 int i = 0;
1963
1964 if ( ! list )
1965 return 0;
1966
1967 /* count the number of list members */
1968
1969 for ( i=0; *list; i++, list++ );
1970
1971 return i;
1972}
1973
1974/******************************************************************************
1975 version of standard_sub_basic() for string lists; uses talloc_sub_basic()
1976 for the work
1977 *****************************************************************************/
1978
1979bool str_list_sub_basic( char **list, const char *smb_name,
1980 const char *domain_name )
1981{
1982 TALLOC_CTX *ctx = list;
1983 char *s, *tmpstr;
1984
1985 while ( *list ) {
1986 s = *list;
1987 tmpstr = talloc_sub_basic(ctx, smb_name, domain_name, s);
1988 if ( !tmpstr ) {
1989 DEBUG(0,("str_list_sub_basic: "
1990 "alloc_sub_basic() return NULL!\n"));
1991 return false;
1992 }
1993
1994 TALLOC_FREE(*list);
1995 *list = tmpstr;
1996
1997 list++;
1998 }
1999
2000 return true;
2001}
2002
2003/******************************************************************************
2004 substritute a specific pattern in a string list
2005 *****************************************************************************/
2006
2007bool str_list_substitute(char **list, const char *pattern, const char *insert)
2008{
2009 char *p, *s, *t;
2010 ssize_t ls, lp, li, ld, i, d;
2011
2012 if (!list)
2013 return false;
2014 if (!pattern)
2015 return false;
2016 if (!insert)
2017 return false;
2018
2019 lp = (ssize_t)strlen(pattern);
2020 li = (ssize_t)strlen(insert);
2021 ld = li -lp;
2022
2023 while (*list) {
2024 s = *list;
2025 ls = (ssize_t)strlen(s);
2026
2027 while ((p = strstr_m(s, pattern))) {
2028 t = *list;
2029 d = p -t;
2030 if (ld) {
2031 t = (char *) SMB_MALLOC(ls +ld +1);
2032 if (!t) {
2033 DEBUG(0,("str_list_substitute: "
2034 "Unable to allocate memory"));
2035 return false;
2036 }
2037 memcpy(t, *list, d);
2038 memcpy(t +d +li, p +lp, ls -d -lp +1);
2039 SAFE_FREE(*list);
2040 *list = t;
2041 ls += ld;
2042 s = t +d +li;
2043 }
2044
2045 for (i = 0; i < li; i++) {
2046 switch (insert[i]) {
2047 case '`':
2048 case '"':
2049 case '\'':
2050 case ';':
2051 case '$':
2052 case '%':
2053 case '\r':
2054 case '\n':
2055 t[d +i] = '_';
2056 break;
2057 default:
2058 t[d +i] = insert[i];
2059 }
2060 }
2061 }
2062
2063 list++;
2064 }
2065
2066 return true;
2067}
2068
2069
2070#define IPSTR_LIST_SEP ","
2071#define IPSTR_LIST_CHAR ','
2072
2073/**
2074 * Add ip string representation to ipstr list. Used also
2075 * as part of @function ipstr_list_make
2076 *
2077 * @param ipstr_list pointer to string containing ip list;
2078 * MUST BE already allocated and IS reallocated if necessary
2079 * @param ipstr_size pointer to current size of ipstr_list (might be changed
2080 * as a result of reallocation)
2081 * @param ip IP address which is to be added to list
2082 * @return pointer to string appended with new ip and possibly
2083 * reallocated to new length
2084 **/
2085
2086static char *ipstr_list_add(char **ipstr_list, const struct ip_service *service)
2087{
2088 char *new_ipstr = NULL;
2089 char addr_buf[INET6_ADDRSTRLEN];
2090 int ret;
2091
2092 /* arguments checking */
2093 if (!ipstr_list || !service) {
2094 return NULL;
2095 }
2096
2097 print_sockaddr(addr_buf,
2098 sizeof(addr_buf),
2099 &service->ss);
2100
2101 /* attempt to convert ip to a string and append colon separator to it */
2102 if (*ipstr_list) {
2103 if (service->ss.ss_family == AF_INET) {
2104 /* IPv4 */
2105 ret = asprintf(&new_ipstr, "%s%s%s:%d", *ipstr_list,
2106 IPSTR_LIST_SEP, addr_buf,
2107 service->port);
2108 } else {
2109 /* IPv6 */
2110 ret = asprintf(&new_ipstr, "%s%s[%s]:%d", *ipstr_list,
2111 IPSTR_LIST_SEP, addr_buf,
2112 service->port);
2113 }
2114 SAFE_FREE(*ipstr_list);
2115 } else {
2116 if (service->ss.ss_family == AF_INET) {
2117 /* IPv4 */
2118 ret = asprintf(&new_ipstr, "%s:%d", addr_buf,
2119 service->port);
2120 } else {
2121 /* IPv6 */
2122 ret = asprintf(&new_ipstr, "[%s]:%d", addr_buf,
2123 service->port);
2124 }
2125 }
2126 if (ret == -1) {
2127 return NULL;
2128 }
2129 *ipstr_list = new_ipstr;
2130 return *ipstr_list;
2131}
2132
2133/**
2134 * Allocate and initialise an ipstr list using ip adresses
2135 * passed as arguments.
2136 *
2137 * @param ipstr_list pointer to string meant to be allocated and set
2138 * @param ip_list array of ip addresses to place in the list
2139 * @param ip_count number of addresses stored in ip_list
2140 * @return pointer to allocated ip string
2141 **/
2142
2143char *ipstr_list_make(char **ipstr_list,
2144 const struct ip_service *ip_list,
2145 int ip_count)
2146{
2147 int i;
2148
2149 /* arguments checking */
2150 if (!ip_list || !ipstr_list) {
2151 return 0;
2152 }
2153
2154 *ipstr_list = NULL;
2155
2156 /* process ip addresses given as arguments */
2157 for (i = 0; i < ip_count; i++) {
2158 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
2159 }
2160
2161 return (*ipstr_list);
2162}
2163
2164
2165/**
2166 * Parse given ip string list into array of ip addresses
2167 * (as ip_service structures)
2168 * e.g. [IPv6]:port,192.168.1.100:389,192.168.1.78, ...
2169 *
2170 * @param ipstr ip string list to be parsed
2171 * @param ip_list pointer to array of ip addresses which is
2172 * allocated by this function and must be freed by caller
2173 * @return number of successfully parsed addresses
2174 **/
2175
2176int ipstr_list_parse(const char *ipstr_list, struct ip_service **ip_list)
2177{
2178 TALLOC_CTX *frame;
2179 char *token_str = NULL;
2180 size_t count;
2181 int i;
2182
2183 if (!ipstr_list || !ip_list)
2184 return 0;
2185
2186 count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
2187 if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
2188 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n",
2189 (unsigned long)count));
2190 return 0;
2191 }
2192
2193 frame = talloc_stackframe();
2194 for ( i=0; next_token_talloc(frame, &ipstr_list, &token_str,
2195 IPSTR_LIST_SEP) && i<count; i++ ) {
2196 char *s = token_str;
2197 char *p = strrchr(token_str, ':');
2198
2199 if (p) {
2200 *p = 0;
2201 (*ip_list)[i].port = atoi(p+1);
2202 }
2203
2204 /* convert single token to ip address */
2205 if (token_str[0] == '[') {
2206 /* IPv6 address. */
2207 s++;
2208 p = strchr(token_str, ']');
2209 if (!p) {
2210 continue;
2211 }
2212 *p = '\0';
2213 }
2214 if (!interpret_string_addr(&(*ip_list)[i].ss,
2215 s,
2216 AI_NUMERICHOST)) {
2217 continue;
2218 }
2219 }
2220 TALLOC_FREE(frame);
2221 return count;
2222}
2223
2224/**
2225 * Safely free ip string list
2226 *
2227 * @param ipstr_list ip string list to be freed
2228 **/
2229
2230void ipstr_list_free(char* ipstr_list)
2231{
2232 SAFE_FREE(ipstr_list);
2233}
2234
2235/**
2236 Unescape a URL encoded string, in place.
2237**/
2238
2239void rfc1738_unescape(char *buf)
2240{
2241 char *p=buf;
2242
2243 while (p && *p && (p=strchr_m(p,'%'))) {
2244 int c1 = p[1];
2245 int c2 = p[2];
2246
2247 if (c1 >= '0' && c1 <= '9')
2248 c1 = c1 - '0';
2249 else if (c1 >= 'A' && c1 <= 'F')
2250 c1 = 10 + c1 - 'A';
2251 else if (c1 >= 'a' && c1 <= 'f')
2252 c1 = 10 + c1 - 'a';
2253 else {p++; continue;}
2254
2255 if (c2 >= '0' && c2 <= '9')
2256 c2 = c2 - '0';
2257 else if (c2 >= 'A' && c2 <= 'F')
2258 c2 = 10 + c2 - 'A';
2259 else if (c2 >= 'a' && c2 <= 'f')
2260 c2 = 10 + c2 - 'a';
2261 else {p++; continue;}
2262
2263 *p = (c1<<4) | c2;
2264
2265 memmove(p+1, p+3, strlen(p+3)+1);
2266 p++;
2267 }
2268}
2269
2270static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
2271
2272/**
2273 * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
2274 **/
2275DATA_BLOB base64_decode_data_blob(const char *s)
2276{
2277 int bit_offset, byte_offset, idx, i, n;
2278 DATA_BLOB decoded = data_blob(s, strlen(s)+1);
2279 unsigned char *d = decoded.data;
2280 char *p;
2281
2282 n=i=0;
2283
2284 while (*s && (p=strchr_m(b64,*s))) {
2285 idx = (int)(p - b64);
2286 byte_offset = (i*6)/8;
2287 bit_offset = (i*6)%8;
2288 d[byte_offset] &= ~((1<<(8-bit_offset))-1);
2289 if (bit_offset < 3) {
2290 d[byte_offset] |= (idx << (2-bit_offset));
2291 n = byte_offset+1;
2292 } else {
2293 d[byte_offset] |= (idx >> (bit_offset-2));
2294 d[byte_offset+1] = 0;
2295 d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
2296 n = byte_offset+2;
2297 }
2298 s++; i++;
2299 }
2300
2301 if ((n > 0) && (*s == '=')) {
2302 n -= 1;
2303 }
2304
2305 /* fix up length */
2306 decoded.length = n;
2307 return decoded;
2308}
2309
2310/**
2311 * Decode a base64 string in-place - wrapper for the above
2312 **/
2313void base64_decode_inplace(char *s)
2314{
2315 DATA_BLOB decoded = base64_decode_data_blob(s);
2316
2317 if ( decoded.length != 0 ) {
2318 memcpy(s, decoded.data, decoded.length);
2319
2320 /* null terminate */
2321 s[decoded.length] = '\0';
2322 } else {
2323 *s = '\0';
2324 }
2325
2326 data_blob_free(&decoded);
2327}
2328
2329/**
2330 * Encode a base64 string into a talloc()ed string caller to free.
2331 *
2332 * From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c
2333 * with adjustments
2334 **/
2335
2336char *base64_encode_data_blob(TALLOC_CTX *mem_ctx, DATA_BLOB data)
2337{
2338 int bits = 0;
2339 int char_count = 0;
2340 size_t out_cnt, len, output_len;
2341 char *result;
2342
2343 if (!data.length || !data.data)
2344 return NULL;
2345
2346 out_cnt = 0;
2347 len = data.length;
2348 output_len = data.length * 2 + 4; /* Account for closing bytes. 4 is
2349 * random but should be enough for
2350 * the = and \0 */
2351 result = TALLOC_ARRAY(mem_ctx, char, output_len); /* get us plenty of space */
2352 SMB_ASSERT(result != NULL);
2353
2354 while (len-- && out_cnt < (data.length * 2) - 5) {
2355 int c = (unsigned char) *(data.data++);
2356 bits += c;
2357 char_count++;
2358 if (char_count == 3) {
2359 result[out_cnt++] = b64[bits >> 18];
2360 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2361 result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2362 result[out_cnt++] = b64[bits & 0x3f];
2363 bits = 0;
2364 char_count = 0;
2365 } else {
2366 bits <<= 8;
2367 }
2368 }
2369 if (char_count != 0) {
2370 bits <<= 16 - (8 * char_count);
2371 result[out_cnt++] = b64[bits >> 18];
2372 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2373 if (char_count == 1) {
2374 result[out_cnt++] = '=';
2375 result[out_cnt++] = '=';
2376 } else {
2377 result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2378 result[out_cnt++] = '=';
2379 }
2380 }
2381 result[out_cnt] = '\0'; /* terminate */
2382 return result;
2383}
2384
2385/* read a SMB_BIG_UINT from a string */
2386SMB_BIG_UINT STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
2387{
2388
2389 SMB_BIG_UINT val = -1;
2390 const char *p = nptr;
2391
2392 if (!p) {
2393 if (entptr) {
2394 *entptr = p;
2395 }
2396 return val;
2397 }
2398
2399 while (*p && isspace(*p))
2400 p++;
2401
2402#ifdef LARGE_SMB_OFF_T
2403 sscanf(p,"%llu",&val);
2404#else /* LARGE_SMB_OFF_T */
2405 sscanf(p,"%lu",&val);
2406#endif /* LARGE_SMB_OFF_T */
2407 if (entptr) {
2408 while (*p && isdigit(*p))
2409 p++;
2410 *entptr = p;
2411 }
2412
2413 return val;
2414}
2415
2416/* Convert a size specification to a count of bytes. We accept the following
2417 * suffixes:
2418 * bytes if there is no suffix
2419 * kK kibibytes
2420 * mM mebibytes
2421 * gG gibibytes
2422 * tT tibibytes
2423 * pP whatever the ISO name for petabytes is
2424 *
2425 * Returns 0 if the string can't be converted.
2426 */
2427SMB_OFF_T conv_str_size(const char * str)
2428{
2429 SMB_OFF_T lval;
2430 char * end;
2431
2432 if (str == NULL || *str == '\0') {
2433 return 0;
2434 }
2435
2436#ifdef HAVE_STRTOULL
2437 if (sizeof(SMB_OFF_T) == 8) {
2438 lval = strtoull(str, &end, 10 /* base */);
2439 } else {
2440 lval = strtoul(str, &end, 10 /* base */);
2441 }
2442#else
2443 lval = strtoul(str, &end, 10 /* base */);
2444#endif
2445
2446 if (end == NULL || end == str) {
2447 return 0;
2448 }
2449
2450 if (*end) {
2451 SMB_OFF_T lval_orig = lval;
2452
2453 if (strwicmp(end, "K") == 0) {
2454 lval *= (SMB_OFF_T)1024;
2455 } else if (strwicmp(end, "M") == 0) {
2456 lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024);
2457 } else if (strwicmp(end, "G") == 0) {
2458 lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2459 (SMB_OFF_T)1024);
2460 } else if (strwicmp(end, "T") == 0) {
2461 lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2462 (SMB_OFF_T)1024 * (SMB_OFF_T)1024);
2463 } else if (strwicmp(end, "P") == 0) {
2464 lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2465 (SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2466 (SMB_OFF_T)1024);
2467 } else {
2468 return 0;
2469 }
2470
2471 /* Primitive attempt to detect wrapping on platforms with
2472 * 4-byte SMB_OFF_T. It's better to let the caller handle
2473 * a failure than some random number.
2474 */
2475 if (lval_orig <= lval) {
2476 return 0;
2477 }
2478 }
2479
2480 return lval;
2481}
2482
2483void string_append(char **left, const char *right)
2484{
2485 int new_len = strlen(right) + 1;
2486
2487 if (*left == NULL) {
2488 *left = (char *)SMB_MALLOC(new_len);
2489 *left[0] = '\0';
2490 } else {
2491 new_len += strlen(*left);
2492 *left = (char *)SMB_REALLOC(*left, new_len);
2493 }
2494
2495 if (*left == NULL) {
2496 return;
2497 }
2498
2499 safe_strcat(*left, right, new_len-1);
2500}
2501
2502bool add_string_to_array(TALLOC_CTX *mem_ctx,
2503 const char *str, const char ***strings,
2504 int *num)
2505{
2506 char *dup_str = talloc_strdup(mem_ctx, str);
2507
2508 *strings = TALLOC_REALLOC_ARRAY(mem_ctx, *strings,
2509 const char *, (*num)+1);
2510
2511 if ((*strings == NULL) || (dup_str == NULL)) {
2512 *num = 0;
2513 return false;
2514 }
2515
2516 (*strings)[*num] = dup_str;
2517 *num += 1;
2518 return true;
2519}
2520
2521/* Append an sprintf'ed string. Double buffer size on demand. Usable without
2522 * error checking in between. The indiation that something weird happened is
2523 * string==NULL */
2524
2525void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
2526 size_t *bufsize, const char *fmt, ...)
2527{
2528 va_list ap;
2529 char *newstr;
2530 int ret;
2531 bool increased;
2532
2533 /* len<0 is an internal marker that something failed */
2534 if (*len < 0)
2535 goto error;
2536
2537 if (*string == NULL) {
2538 if (*bufsize == 0)
2539 *bufsize = 128;
2540
2541 *string = TALLOC_ARRAY(mem_ctx, char, *bufsize);
2542 if (*string == NULL)
2543 goto error;
2544 }
2545
2546 va_start(ap, fmt);
2547 ret = vasprintf(&newstr, fmt, ap);
2548 va_end(ap);
2549
2550 if (ret < 0)
2551 goto error;
2552
2553 increased = false;
2554
2555 while ((*len)+ret >= *bufsize) {
2556 increased = true;
2557 *bufsize *= 2;
2558 if (*bufsize >= (1024*1024*256))
2559 goto error;
2560 }
2561
2562 if (increased) {
2563 *string = TALLOC_REALLOC_ARRAY(mem_ctx, *string, char,
2564 *bufsize);
2565 if (*string == NULL) {
2566 goto error;
2567 }
2568 }
2569
2570 StrnCpy((*string)+(*len), newstr, ret);
2571 (*len) += ret;
2572 free(newstr);
2573 return;
2574
2575 error:
2576 *len = -1;
2577 *string = NULL;
2578}
2579
2580/*
2581 * asprintf into a string and strupper_m it after that.
2582 */
2583
2584int asprintf_strupper_m(char **strp, const char *fmt, ...)
2585{
2586 va_list ap;
2587 char *result;
2588 int ret;
2589
2590 va_start(ap, fmt);
2591 ret = vasprintf(&result, fmt, ap);
2592 va_end(ap);
2593
2594 if (ret == -1)
2595 return -1;
2596
2597 strupper_m(result);
2598 *strp = result;
2599 return ret;
2600}
2601
2602char *talloc_asprintf_strupper_m(TALLOC_CTX *t, const char *fmt, ...)
2603{
2604 va_list ap;
2605 char *ret;
2606
2607 va_start(ap, fmt);
2608 ret = talloc_vasprintf(t, fmt, ap);
2609 va_end(ap);
2610
2611 if (ret == NULL) {
2612 return NULL;
2613 }
2614 strupper_m(ret);
2615 return ret;
2616}
2617
2618/*
2619 Returns the substring from src between the first occurrence of
2620 the char "front" and the first occurence of the char "back".
2621 Mallocs the return string which must be freed. Not for use
2622 with wide character strings.
2623*/
2624char *sstring_sub(const char *src, char front, char back)
2625{
2626 char *temp1, *temp2, *temp3;
2627 ptrdiff_t len;
2628
2629 temp1 = strchr(src, front);
2630 if (temp1 == NULL) return NULL;
2631 temp2 = strchr(src, back);
2632 if (temp2 == NULL) return NULL;
2633 len = temp2 - temp1;
2634 if (len <= 0) return NULL;
2635 temp3 = (char*)SMB_MALLOC(len);
2636 if (temp3 == NULL) {
2637 DEBUG(1,("Malloc failure in sstring_sub\n"));
2638 return NULL;
2639 }
2640 memcpy(temp3, temp1+1, len-1);
2641 temp3[len-1] = '\0';
2642 return temp3;
2643}
2644
2645/********************************************************************
2646 Check a string for any occurrences of a specified list of invalid
2647 characters.
2648********************************************************************/
2649
2650bool validate_net_name( const char *name,
2651 const char *invalid_chars,
2652 int max_len)
2653{
2654 int i;
2655
2656 for ( i=0; i<max_len && name[i]; i++ ) {
2657 /* fail if strchr_m() finds one of the invalid characters */
2658 if ( name[i] && strchr_m( invalid_chars, name[i] ) ) {
2659 return false;
2660 }
2661 }
2662
2663 return true;
2664}
2665
2666
2667/**
2668return the number of bytes occupied by a buffer in ASCII format
2669the result includes the null termination
2670limited by 'n' bytes
2671**/
2672size_t ascii_len_n(const char *src, size_t n)
2673{
2674 size_t len;
2675
2676 len = strnlen(src, n);
2677 if (len+1 <= n) {
2678 len += 1;
2679 }
2680
2681 return len;
2682}
2683
2684/**
2685return the number of bytes occupied by a buffer in CH_UTF16 format
2686the result includes the null termination
2687**/
2688size_t utf16_len(const void *buf)
2689{
2690 size_t len;
2691
2692 for (len = 0; SVAL(buf,len); len += 2) ;
2693
2694 return len + 2;
2695}
2696
2697/**
2698return the number of bytes occupied by a buffer in CH_UTF16 format
2699the result includes the null termination
2700limited by 'n' bytes
2701**/
2702size_t utf16_len_n(const void *src, size_t n)
2703{
2704 size_t len;
2705
2706 for (len = 0; (len+2 < n) && SVAL(src, len); len += 2) ;
2707
2708 if (len+2 <= n) {
2709 len += 2;
2710 }
2711
2712 return len;
2713}
2714
2715/*******************************************************************
2716 Add a shell escape character '\' to any character not in a known list
2717 of characters. UNIX charset format.
2718*******************************************************************/
2719
2720#define INCLUDE_LIST "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_/ \t.,"
2721#define INSIDE_DQUOTE_LIST "$`\n\"\\"
2722
2723char *escape_shell_string(const char *src)
2724{
2725 size_t srclen = strlen(src);
2726 char *ret = SMB_MALLOC_ARRAY(char, (srclen * 2) + 1);
2727 char *dest = ret;
2728 bool in_s_quote = false;
2729 bool in_d_quote = false;
2730 bool next_escaped = false;
2731
2732 if (!ret) {
2733 return NULL;
2734 }
2735
2736 while (*src) {
2737 size_t c_size;
2738 codepoint_t c = next_codepoint(src, &c_size);
2739
2740 if (c == INVALID_CODEPOINT) {
2741 SAFE_FREE(ret);
2742 return NULL;
2743 }
2744
2745 if (c_size > 1) {
2746 memcpy(dest, src, c_size);
2747 src += c_size;
2748 dest += c_size;
2749 next_escaped = false;
2750 continue;
2751 }
2752
2753 /*
2754 * Deal with backslash escaped state.
2755 * This only lasts for one character.
2756 */
2757
2758 if (next_escaped) {
2759 *dest++ = *src++;
2760 next_escaped = false;
2761 continue;
2762 }
2763
2764 /*
2765 * Deal with single quote state. The
2766 * only thing we care about is exiting
2767 * this state.
2768 */
2769
2770 if (in_s_quote) {
2771 if (*src == '\'') {
2772 in_s_quote = false;
2773 }
2774 *dest++ = *src++;
2775 continue;
2776 }
2777
2778 /*
2779 * Deal with double quote state. The most
2780 * complex state. We must cope with \, meaning
2781 * possibly escape next char (depending what it
2782 * is), ", meaning exit this state, and possibly
2783 * add an \ escape to any unprotected character
2784 * (listed in INSIDE_DQUOTE_LIST).
2785 */
2786
2787 if (in_d_quote) {
2788 if (*src == '\\') {
2789 /*
2790 * Next character might be escaped.
2791 * We have to peek. Inside double
2792 * quotes only INSIDE_DQUOTE_LIST
2793 * characters are escaped by a \.
2794 */
2795
2796 char nextchar;
2797
2798 c = next_codepoint(&src[1], &c_size);
2799 if (c == INVALID_CODEPOINT) {
2800 SAFE_FREE(ret);
2801 return NULL;
2802 }
2803 if (c_size > 1) {
2804 /*
2805 * Don't escape the next char.
2806 * Just copy the \.
2807 */
2808 *dest++ = *src++;
2809 continue;
2810 }
2811
2812 nextchar = src[1];
2813
2814 if (nextchar && strchr(INSIDE_DQUOTE_LIST,
2815 (int)nextchar)) {
2816 next_escaped = true;
2817 }
2818 *dest++ = *src++;
2819 continue;
2820 }
2821
2822 if (*src == '\"') {
2823 /* Exit double quote state. */
2824 in_d_quote = false;
2825 *dest++ = *src++;
2826 continue;
2827 }
2828
2829 /*
2830 * We know the character isn't \ or ",
2831 * so escape it if it's any of the other
2832 * possible unprotected characters.
2833 */
2834
2835 if (strchr(INSIDE_DQUOTE_LIST, (int)*src)) {
2836 *dest++ = '\\';
2837 }
2838 *dest++ = *src++;
2839 continue;
2840 }
2841
2842 /*
2843 * From here to the end of the loop we're
2844 * not in the single or double quote state.
2845 */
2846
2847 if (*src == '\\') {
2848 /* Next character must be escaped. */
2849 next_escaped = true;
2850 *dest++ = *src++;
2851 continue;
2852 }
2853
2854 if (*src == '\'') {
2855 /* Go into single quote state. */
2856 in_s_quote = true;
2857 *dest++ = *src++;
2858 continue;
2859 }
2860
2861 if (*src == '\"') {
2862 /* Go into double quote state. */
2863 in_d_quote = true;
2864 *dest++ = *src++;
2865 continue;
2866 }
2867
2868 /* Check if we need to escape the character. */
2869
2870 if (!strchr(INCLUDE_LIST, (int)*src)) {
2871 *dest++ = '\\';
2872 }
2873 *dest++ = *src++;
2874 }
2875 *dest++ = '\0';
2876 return ret;
2877}
Note: See TracBrowser for help on using the repository browser.