2 Unix SMB/Netbios implementation.
4 Samba utility functions
5 Copyright (C) Andrew Tridgell 1992-1998
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 static const char *last_ptr
=NULL
;
26 void set_first_token(char *ptr
)
31 /****************************************************************************
32 Get the next token from a string, return False if none found
33 handles double-quotes.
34 Based on a routine by GJC@VILLAGE.COM.
35 Extensively modified by Andrew.Tridgell@anu.edu.au
36 ****************************************************************************/
38 BOOL
next_token(const char **ptr
,char *buff
,const char *sep
, size_t bufsize
)
51 /* default to simple separators */
55 /* find the first non sep char */
56 while(*s
&& strchr(sep
,*s
))
63 /* copy over the token */
64 for (quoted
= False
; len
< bufsize
&& *s
&& (quoted
|| !strchr(sep
,*s
)); s
++) {
73 *ptr
= (*s
) ? s
+1 : s
;
80 /****************************************************************************
81 Convert list of tokens to array; dependent on above routine.
82 Uses last_ptr from above - bit of a hack.
83 ****************************************************************************/
84 char **toktocliplist(int *ctok
, const char *sep
)
86 char *s
= (char *)last_ptr
;
90 if (!sep
) sep
= " \t\n\r";
92 while(*s
&& strchr(sep
,*s
)) s
++;
95 if (!*s
) return(NULL
);
99 while(*s
&& (!strchr(sep
,*s
))) s
++;
100 while(*s
&& strchr(sep
,*s
)) *s
++=0;
106 if (!(ret
=iret
=malloc(ictok
*sizeof(char *)))) return NULL
;
118 /*******************************************************************
119 case insensitive string compararison
120 ********************************************************************/
121 int StrCaseCmp(const char *s
, const char *t
)
123 /* compare until we run out of string, either t or s, or find a difference */
124 /* We *must* use toupper rather than tolower here due to the
125 asynchronous upper to lower mapping.
127 #if !defined(KANJI_WIN95_COMPATIBILITY)
129 * For completeness we should put in equivalent code for code pages
130 * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
131 * doubt anyone wants Samba to behave differently from Win95 and WinNT
132 * here. They both treat full width ascii characters as case senstive
133 * filenames (ie. they don't do the work we do here).
137 if(lp_client_code_page() == KANJI_CODEPAGE
)
139 /* Win95 treats full width ascii characters as case sensitive. */
144 return toupper (*s
) - toupper (*t
);
145 else if (is_sj_alph (*s
) && is_sj_alph (*t
))
147 diff
= sj_toupper2 (*(s
+1)) - sj_toupper2 (*(t
+1));
153 else if (is_shift_jis (*s
) && is_shift_jis (*t
))
155 diff
= ((int) (unsigned char) *s
) - ((int) (unsigned char) *t
);
158 diff
= ((int) (unsigned char) *(s
+1)) - ((int) (unsigned char) *(t
+1));
164 else if (is_shift_jis (*s
))
166 else if (is_shift_jis (*t
))
170 diff
= toupper (*s
) - toupper (*t
);
179 #endif /* KANJI_WIN95_COMPATIBILITY */
181 while (*s
&& *t
&& toupper(*s
) == toupper(*t
))
187 return(toupper(*s
) - toupper(*t
));
191 /*******************************************************************
192 case insensitive string compararison, length limited
193 ********************************************************************/
194 int StrnCaseCmp(const char *s
, const char *t
, size_t n
)
196 /* compare until we run out of string, either t or s, or chars */
197 /* We *must* use toupper rather than tolower here due to the
198 asynchronous upper to lower mapping.
200 #if !defined(KANJI_WIN95_COMPATIBILITY)
202 * For completeness we should put in equivalent code for code pages
203 * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
204 * doubt anyone wants Samba to behave differently from Win95 and WinNT
205 * here. They both treat full width ascii characters as case senstive
206 * filenames (ie. they don't do the work we do here).
210 if(lp_client_code_page() == KANJI_CODEPAGE
)
212 /* Win95 treats full width ascii characters as case sensitive. */
217 return toupper (*s
) - toupper (*t
);
218 else if (is_sj_alph (*s
) && is_sj_alph (*t
))
220 diff
= sj_toupper2 (*(s
+1)) - sj_toupper2 (*(t
+1));
227 else if (is_shift_jis (*s
) && is_shift_jis (*t
))
229 diff
= ((int) (unsigned char) *s
) - ((int) (unsigned char) *t
);
232 diff
= ((int) (unsigned char) *(s
+1)) - ((int) (unsigned char) *(t
+1));
239 else if (is_shift_jis (*s
))
241 else if (is_shift_jis (*t
))
245 diff
= toupper (*s
) - toupper (*t
);
256 #endif /* KANJI_WIN95_COMPATIBILITY */
258 while (n
&& *s
&& *t
&& toupper(*s
) == toupper(*t
))
265 /* not run out of chars - strings are different lengths */
267 return(toupper(*s
) - toupper(*t
));
269 /* identical up to where we run out of chars,
270 and strings are same length */
275 /*******************************************************************
276 compare 2 strings - DOS codepage.
277 ********************************************************************/
278 BOOL
strequal(const char *s1
, const char *s2
)
280 if (s1
== s2
) return(True
);
281 if (!s1
|| !s2
) return(False
);
283 return(StrCaseCmp(s1
,s2
)==0);
286 /*******************************************************************
287 compare 2 strings - UNIX codepage.
288 ********************************************************************/
289 BOOL
strequal_unix(const char *s1
, const char *s2
)
291 pstring dos_s1
, dos_s2
;
292 if (s1
== s2
) return(True
);
293 if (!s1
|| !s2
) return(False
);
295 pstrcpy(dos_s1
, unix_to_dos_static(s1
));
296 pstrcpy(dos_s2
, unix_to_dos_static(s2
));
297 return(StrCaseCmp(dos_s1
,dos_s2
)==0);
300 /*******************************************************************
301 compare 2 strings up to and including the nth char.
302 ******************************************************************/
303 BOOL
strnequal(const char *s1
,const char *s2
,size_t n
)
305 if (s1
== s2
) return(True
);
306 if (!s1
|| !s2
|| !n
) return(False
);
308 return(StrnCaseCmp(s1
,s2
,n
)==0);
311 /*******************************************************************
312 compare 2 strings (case sensitive)
313 ********************************************************************/
314 BOOL
strcsequal(const char *s1
,const char *s2
)
316 if (s1
== s2
) return(True
);
317 if (!s1
|| !s2
) return(False
);
319 return(strcmp(s1
,s2
)==0);
322 /***************************************************************************
323 Do a case-insensitive, whitespace-ignoring string compare.
324 ***************************************************************************/
325 int strwicmp(const char *psz1
, const char *psz2
)
327 /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
328 /* appropriate value. */
331 else if (psz1
== NULL
)
333 else if (psz2
== NULL
)
336 /* sync the strings on first non-whitespace */
339 while (isspace((int)*psz1
))
341 while (isspace((int)*psz2
))
343 if (toupper(*psz1
) != toupper(*psz2
) || *psz1
== '\0'
349 return (*psz1
- *psz2
);
353 /*******************************************************************
354 convert a string to lower case
355 ********************************************************************/
356 void strlower(char *s
)
360 #if !defined(KANJI_WIN95_COMPATIBILITY)
362 * For completeness we should put in equivalent code for code pages
363 * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
364 * doubt anyone wants Samba to behave differently from Win95 and WinNT
365 * here. They both treat full width ascii characters as case senstive
366 * filenames (ie. they don't do the work we do here).
370 if(lp_client_code_page() == KANJI_CODEPAGE
)
372 /* Win95 treats full width ascii characters as case sensitive. */
373 if (is_shift_jis (*s
))
375 if (is_sj_upper (s
[0], s
[1]))
376 s
[1] = sj_tolower2 (s
[1]);
379 else if (is_kana (*s
))
391 #endif /* KANJI_WIN95_COMPATIBILITY */
393 size_t skip
= get_character_len( *s
);
406 /*******************************************************************
407 convert a string to upper case
408 ********************************************************************/
409 void strupper(char *s
)
413 #if !defined(KANJI_WIN95_COMPATIBILITY)
415 * For completeness we should put in equivalent code for code pages
416 * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
417 * doubt anyone wants Samba to behave differently from Win95 and WinNT
418 * here. They both treat full width ascii characters as case senstive
419 * filenames (ie. they don't do the work we do here).
423 if(lp_client_code_page() == KANJI_CODEPAGE
)
425 /* Win95 treats full width ascii characters as case sensitive. */
426 if (is_shift_jis (*s
))
428 if (is_sj_lower (s
[0], s
[1]))
429 s
[1] = sj_toupper2 (s
[1]);
432 else if (is_kana (*s
))
444 #endif /* KANJI_WIN95_COMPATIBILITY */
446 size_t skip
= get_character_len( *s
);
459 /* Convert a string to upper case, but don't modify it */
461 char *strupper_static(const char *s
)
471 /*******************************************************************
472 convert a string to "normal" form
473 ********************************************************************/
474 void strnorm(char *s
)
476 extern int case_default
;
477 if (case_default
== CASE_UPPER
)
483 /*******************************************************************
484 check if a string is in "normal" case
485 ********************************************************************/
486 BOOL
strisnormal(char *s
)
488 extern int case_default
;
489 if (case_default
== CASE_UPPER
)
490 return(!strhaslower(s
));
492 return(!strhasupper(s
));
496 /****************************************************************************
498 ****************************************************************************/
499 void string_replace(char *s
,char oldc
,char newc
)
506 if(!global_is_multibyte_codepage
) {
515 skip
= get_character_len( *s
);
529 /*******************************************************************
530 skip past some strings in a buffer
531 ********************************************************************/
532 char *skip_string(char *buf
,size_t n
)
535 buf
+= strlen(buf
) + 1;
539 /*******************************************************************
540 Count the number of characters in a string. Normally this will
541 be the same as the number of bytes in a string for single byte strings,
542 but will be different for multibyte.
543 16.oct.98, jdblair@cobaltnet.com.
544 ********************************************************************/
546 size_t str_charnum(const char *s
)
553 if(!global_is_multibyte_codepage
) {
557 int skip
= get_character_len(*s
);
558 s
+= (skip
? skip
: 1);
565 /*******************************************************************
566 trim the specified elements off the front and back of a string
567 ********************************************************************/
569 BOOL
trim_string(char *s
,const char *front
,const char *back
)
577 /* Ignore null or empty strings. */
579 if ( !s
|| (s
[0] == '\0'))
583 s_len
= strlen( s
) + 1;
584 front_len
= (front
) ? strlen( front
) + 1 : 0;
585 back_len
= (back
) ? strlen( back
) + 1 : 0;
588 * remove "front" string from given "s", if it matches front part,
591 if ( front
&& front_len
> 1 ) {
592 while (( s_len
>= front_len
)&&
593 ( memcmp( sP
, front
, front_len
- 1 )) == 0 ) {
595 sP
+= ( front_len
- 1 );
596 s_len
-= ( front_len
- 1 );
601 * we'll memmove sP to s later, after we're done with
602 * back part removal, for minimizing copy.
607 * We split out the multibyte code page
608 * case here for speed purposes. Under a
609 * multibyte code page we need to walk the
610 * string forwards only and multiple times.
611 * Thanks to John Blair for finding this
615 * This JRA's comment is partly correct, but partly wrong.
616 * You can always check from "end" part, and if it did not match,
617 * it means there is no possibility of finding one.
618 * If you found matching point, mark them, then look from front
619 * if marking point suits multi-byte string rule.
623 if ( back
&& back_len
> 1 && s_len
>= back_len
) {
624 char *bP
= sP
+ s_len
- back_len
;
627 while (( b_len
>= back_len
)&&
628 ( memcmp( bP
, back
, back_len
- 1 ) == 0 )) {
629 bP
-= ( back_len
- 1 );
630 b_len
-= ( back_len
- 1 );
634 * You're here, means you ether have found match multiple times,
635 * or you found none. If you've found match, then bP should be
638 if ( bP
!= sP
+ s_len
- back_len
) {
639 bP
+= ( back_len
- 1 ); /* slide bP to first matching point. */
641 if( !global_is_multibyte_codepage
) {
642 /* simply terminate */
647 /* trace string from start. */
649 while ( cP
< sP
+ s_len
- back_len
) {
651 skip
= skip_multibyte_char( *cP
);
652 cP
+= ( skip
? skip
: 1 );
654 /* you found the match */
660 while (( cP
> bP
)&&( bP
< sP
+ s_len
- back_len
)) {
661 bP
+= ( back_len
- 1 );
662 b_len
+= ( back_len
- 1 );
669 /* if front found matching point */
671 /* slide string to buffer top */
672 memmove( s
, sP
, s_len
);
678 /****************************************************************************
679 does a string have any uppercase chars in it?
680 ****************************************************************************/
681 BOOL
strhasupper(const char *s
)
685 #if !defined(KANJI_WIN95_COMPATIBILITY)
687 * For completeness we should put in equivalent code for code pages
688 * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
689 * doubt anyone wants Samba to behave differently from Win95 and WinNT
690 * here. They both treat full width ascii characters as case senstive
691 * filenames (ie. they don't do the work we do here).
695 if(lp_client_code_page() == KANJI_CODEPAGE
)
697 /* Win95 treats full width ascii characters as case sensitive. */
698 if (is_shift_jis (*s
))
700 else if (is_kana (*s
))
710 #endif /* KANJI_WIN95_COMPATIBILITY */
712 size_t skip
= get_character_len( *s
);
725 /****************************************************************************
726 does a string have any lowercase chars in it?
727 ****************************************************************************/
728 BOOL
strhaslower(const char *s
)
732 #if !defined(KANJI_WIN95_COMPATIBILITY)
734 * For completeness we should put in equivalent code for code pages
735 * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
736 * doubt anyone wants Samba to behave differently from Win95 and WinNT
737 * here. They both treat full width ascii characters as case senstive
738 * filenames (ie. they don't do the work we do here).
742 if(lp_client_code_page() == KANJI_CODEPAGE
)
744 /* Win95 treats full width ascii characters as case sensitive. */
745 if (is_shift_jis (*s
))
747 if (is_sj_upper (s
[0], s
[1]))
749 if (is_sj_lower (s
[0], s
[1]))
753 else if (is_kana (*s
))
765 #endif /* KANJI_WIN95_COMPATIBILITY */
767 size_t skip
= get_character_len( *s
);
780 /****************************************************************************
781 find the number of chars in a string
782 ****************************************************************************/
783 size_t count_chars(const char *s
,char c
)
787 #if !defined(KANJI_WIN95_COMPATIBILITY)
789 * For completeness we should put in equivalent code for code pages
790 * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
791 * doubt anyone wants Samba to behave differently from Win95 and WinNT
792 * here. They both treat full width ascii characters as case senstive
793 * filenames (ie. they don't do the work we do here).
797 if(lp_client_code_page() == KANJI_CODEPAGE
)
799 /* Win95 treats full width ascii characters as case sensitive. */
802 if (is_shift_jis (*s
))
813 #endif /* KANJI_WIN95_COMPATIBILITY */
817 size_t skip
= get_character_len( *s
);
830 /*******************************************************************
831 Return True if a string consists only of one particular character.
832 ********************************************************************/
834 BOOL
str_is_all(const char *s
,char c
)
841 #if !defined(KANJI_WIN95_COMPATIBILITY)
843 * For completeness we should put in equivalent code for code pages
844 * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
845 * doubt anyone wants Samba to behave differently from Win95 and WinNT
846 * here. They both treat full width ascii characters as case senstive
847 * filenames (ie. they don't do the work we do here).
851 if(lp_client_code_page() == KANJI_CODEPAGE
)
853 /* Win95 treats full width ascii characters as case sensitive. */
856 if (is_shift_jis (*s
))
867 #endif /* KANJI_WIN95_COMPATIBILITY */
871 size_t skip
= get_character_len( *s
);
884 /*******************************************************************
885 safe string copy into a known length string. maxlength does not
886 include the terminating zero.
887 ********************************************************************/
889 char *safe_strcpy(char *dest
,const char *src
, size_t maxlength
)
894 DEBUG(0,("ERROR: NULL dest in safe_strcpy\n"));
905 if (len
> maxlength
) {
906 DEBUG(0,("ERROR: string overflow by %d in safe_strcpy [%.50s]\n",
907 (int)(len
-maxlength
), src
));
911 memcpy(dest
, src
, len
);
916 /*******************************************************************
917 safe string cat into a string. maxlength does not
918 include the terminating zero.
919 ********************************************************************/
921 char *safe_strcat(char *dest
, const char *src
, size_t maxlength
)
923 size_t src_len
, dest_len
;
926 DEBUG(0,("ERROR: NULL dest in safe_strcat\n"));
933 src_len
= strlen(src
);
934 dest_len
= strlen(dest
);
936 if (src_len
+ dest_len
> maxlength
) {
937 DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
938 (int)(src_len
+ dest_len
- maxlength
), src
));
939 if (maxlength
> dest_len
) {
940 memcpy(&dest
[dest_len
], src
, maxlength
- dest_len
);
946 memcpy(&dest
[dest_len
], src
, src_len
);
947 dest
[dest_len
+ src_len
] = 0;
951 /*******************************************************************
952 Paranoid strcpy into a buffer of given length (includes terminating
953 zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
954 and replaces with '_'. Deliberately does *NOT* check for multibyte
955 characters. Don't change it !
956 ********************************************************************/
958 char *alpha_strcpy(char *dest
, const char *src
, const char *other_safe_chars
, size_t maxlength
)
962 smb_ucs2_t
*str_ucs
, *other_ucs
;
965 DEBUG(0,("ERROR: NULL dest in alpha_strcpy\n"));
974 /* Get UCS2 version of src string*/
976 buflen
=2*strlen(src
)+2;
977 if (buflen
>= (2*maxlength
))
978 buflen
= 2*(maxlength
- 1);
980 str_ucs
= (smb_ucs2_t
*)malloc(buflen
);
985 unix_to_unicode(str_ucs
, src
, buflen
);
986 len
= strlen_w(str_ucs
);
988 if (!other_safe_chars
)
989 other_safe_chars
= "";
991 /* Get UCS2 version of other_safe_chars string*/
992 buflen
=2*strlen(other_safe_chars
)+2;
993 other_ucs
= (smb_ucs2_t
*)malloc(buflen
);
999 unix_to_unicode(other_ucs
, other_safe_chars
, buflen
);
1001 for(i
= 0; i
< len
; i
++) {
1002 if(isupper_w(str_ucs
[i
]) || islower_w(str_ucs
[i
]) || isdigit_w(str_ucs
[i
]) || strchr_w(other_ucs
, str_ucs
[i
]))
1005 str_ucs
[i
] = (smb_ucs2_t
)'_'; /*This will work*/
1008 unicode_to_unix(dest
, str_ucs
, maxlength
);
1010 SAFE_FREE(other_ucs
);
1016 /****************************************************************************
1017 Like strncpy but always null terminates. Make sure there is room!
1018 The variable n should always be one less than the available size.
1019 ****************************************************************************/
1021 char *StrnCpy(char *dest
,const char *src
,size_t n
)
1024 if (!dest
) return(NULL
);
1029 while (n
-- && (*d
++ = *src
++)) ;
1034 /****************************************************************************
1035 like strncpy but copies up to the character marker. always null terminates.
1036 returns a pointer to the character marker in the source string (src).
1037 ****************************************************************************/
1038 char *strncpyn(char *dest
, const char *src
,size_t n
, char c
)
1046 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c
));
1050 str_len
= PTR_DIFF(p
, src
);
1051 strncpy(dest
, src
, MIN(n
, str_len
));
1052 dest
[str_len
] = '\0';
1058 /*************************************************************
1059 Routine to get hex characters and turn them into a 16 byte array.
1060 the array can be variable length, and any non-hex-numeric
1061 characters are skipped. "0xnn" or "0Xnn" is specially catered
1064 valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
1066 **************************************************************/
1067 size_t strhex_to_str(char *p
, size_t len
, const char *strhex
)
1070 size_t num_chars
= 0;
1071 unsigned char lonybble
, hinybble
;
1072 const char *hexchars
= "0123456789ABCDEF";
1073 char *p1
= NULL
, *p2
= NULL
;
1075 for (i
= 0; i
< len
&& strhex
[i
] != 0; i
++)
1077 if (strnequal(hexchars
, "0x", 2))
1079 i
++; /* skip two chars */
1083 if (!(p1
= strchr(hexchars
, toupper(strhex
[i
]))))
1088 i
++; /* next hex digit */
1090 if (!(p2
= strchr(hexchars
, toupper(strhex
[i
]))))
1095 /* get the two nybbles */
1096 hinybble
= PTR_DIFF(p1
, hexchars
);
1097 lonybble
= PTR_DIFF(p2
, hexchars
);
1099 p
[num_chars
] = (hinybble
<< 4) | lonybble
;
1108 /****************************************************************************
1109 check if a string is part of a list
1110 ****************************************************************************/
1111 BOOL
in_list(char *s
,char *list
,BOOL casesensitive
)
1116 if (!list
) return(False
);
1118 while (next_token(&p
,tok
,LIST_SEP
,sizeof(tok
))) {
1119 if (casesensitive
) {
1120 if (strcmp(tok
,s
) == 0)
1123 if (StrCaseCmp(tok
,s
) == 0)
1130 /* this is used to prevent lots of mallocs of size 1 */
1131 static char *null_string
= NULL
;
1133 /****************************************************************************
1134 set a string value, allocing the space for the string
1135 ****************************************************************************/
1136 static BOOL
string_init(char **dest
,const char *src
)
1147 if((null_string
= (char *)malloc(1)) == NULL
) {
1148 DEBUG(0,("string_init: malloc fail for null_string.\n"));
1153 *dest
= null_string
;
1157 (*dest
) = (char *)malloc(l
+1);
1158 if ((*dest
) == NULL
) {
1159 DEBUG(0,("Out of memory in string_init\n"));
1168 /****************************************************************************
1170 ****************************************************************************/
1171 void string_free(char **s
)
1173 if (!s
|| !(*s
)) return;
1174 if (*s
== null_string
)
1179 /****************************************************************************
1180 set a string value, allocing the space for the string, and deallocating any
1182 ****************************************************************************/
1183 BOOL
string_set(char **dest
,const char *src
)
1187 return(string_init(dest
,src
));
1191 /****************************************************************************
1192 substitute a string for a pattern in another string. Make sure there is
1195 This routine looks for pattern in s and replaces it with
1196 insert. It may do multiple replacements.
1198 any of " ; ' $ or ` in the insert string are replaced with _
1199 if len==0 then no expansion is permitted.
1200 ****************************************************************************/
1201 void string_sub(char *s
,const char *pattern
,const char *insert
, size_t len
)
1204 ssize_t ls
,lp
,li
, i
;
1206 if (!insert
|| !pattern
|| !s
) return;
1208 ls
= (ssize_t
)strlen(s
);
1209 lp
= (ssize_t
)strlen(pattern
);
1210 li
= (ssize_t
)strlen(insert
);
1212 if (!*pattern
) return;
1215 len
= ls
+ 1; /* len is number of *bytes* */
1217 while (lp
<= ls
&& (p
= strstr(s
,pattern
))) {
1218 if (ls
+ (li
-lp
) >= len
) {
1219 DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n",
1220 (int)(ls
+ (li
-lp
) - len
),
1221 pattern
, (int)len
));
1225 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
1227 for (i
=0;i
<li
;i
++) {
1228 switch (insert
[i
]) {
1248 void fstring_sub(char *s
,const char *pattern
,const char *insert
)
1250 string_sub(s
, pattern
, insert
, sizeof(fstring
));
1253 void pstring_sub(char *s
,const char *pattern
,const char *insert
)
1255 string_sub(s
, pattern
, insert
, sizeof(pstring
));
1258 /****************************************************************************
1259 similar to string_sub() but allows for any character to be substituted.
1261 if len==0 then no expansion is permitted.
1262 ****************************************************************************/
1263 void all_string_sub(char *s
,const char *pattern
,const char *insert
, size_t len
)
1268 if (!insert
|| !pattern
|| !s
) return;
1270 ls
= (ssize_t
)strlen(s
);
1271 lp
= (ssize_t
)strlen(pattern
);
1272 li
= (ssize_t
)strlen(insert
);
1274 if (!*pattern
) return;
1277 len
= ls
+ 1; /* len is number of *bytes* */
1279 while (lp
<= ls
&& (p
= strstr(s
,pattern
))) {
1280 if (ls
+ (li
-lp
) >= len
) {
1281 DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n",
1282 (int)(ls
+ (li
-lp
) - len
),
1283 pattern
, (int)len
));
1287 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
1289 memcpy(p
, insert
, li
);
1295 /****************************************************************************
1296 splits out the front and back at a separator.
1297 ****************************************************************************/
1298 void split_at_last_component(char *path
, char *front
, char sep
, char *back
)
1300 char *p
= strrchr(path
, sep
);
1308 pstrcpy(front
, path
);
1328 /****************************************************************************
1329 write an octal as a string
1330 ****************************************************************************/
1331 const char *octal_string(int i
)
1333 static char ret
[64];
1337 slprintf(ret
, sizeof(ret
)-1, "0%o", i
);
1342 /****************************************************************************
1343 truncate a string at a specified length
1344 ****************************************************************************/
1345 char *string_truncate(char *s
, int length
)
1347 if (s
&& strlen(s
) > length
) {
1354 return a RFC2254 binary string representation of a buffer
1355 used in LDAP filters
1358 char *binary_string(char *buf
, int len
)
1362 const char *hex
= "0123456789ABCDEF";
1363 s
= malloc(len
* 3 + 1);
1364 if (!s
) return NULL
;
1365 for (j
=i
=0;i
<len
;i
++) {
1367 s
[j
+1] = hex
[((unsigned char)buf
[i
]) >> 4];
1368 s
[j
+2] = hex
[((unsigned char)buf
[i
]) & 0xF];
1375 #ifndef HAVE_STRNLEN
1376 /*******************************************************************
1377 Some platforms don't have strnlen
1378 ********************************************************************/
1380 size_t strnlen(const char *s
, size_t n
)
1383 for (i
=0; s
[i
] && i
<n
; i
++)
1389 #ifndef HAVE_STRNDUP
1390 /*******************************************************************
1391 Some platforms don't have strndup.
1392 ********************************************************************/
1394 char *strndup(const char *s
, size_t n
)