2 Unix SMB/Netbios implementation.
4 Samba utility functions
5 Copyright (C) Andrew Tridgell 1992-2001
6 Copyright (C) Simo Sorce 2001
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 /* these 3 tables define the unicode case handling. They are loaded
30 at startup either via mmap() or read() from the lib directory */
31 static smb_ucs2_t *upcase_table;
32 static smb_ucs2_t *lowcase_table;
33 static uint8 *valid_table;
36 /*******************************************************************
37 load the case handling tables
38 ********************************************************************/
39 void load_case_tables(void)
41 static int initialised;
44 if (initialised) return;
47 upcase_table = map_file(lib_path("upcase.dat"), 0x20000);
48 lowcase_table = map_file(lib_path("lowcase.dat"), 0x20000);
50 /* we would like Samba to limp along even if these tables are
53 DEBUG(1,("creating lame upcase table\n"));
54 upcase_table = malloc(0x20000);
55 for (i=0;i<0x10000;i++) upcase_table[i] = i;
56 for (i=0;i<256;i++) upcase_table[UCS2_CHAR(i)] = UCS2_CHAR(islower(i)?toupper(i):i);
60 DEBUG(1,("creating lame lowcase table\n"));
61 lowcase_table = malloc(0x20000);
62 for (i=0;i<0x10000;i++) lowcase_table[i] = i;
63 for (i=0;i<256;i++) lowcase_table[UCS2_CHAR(i)] = UCS2_CHAR(isupper(i)?tolower(i):i);
68 see if a ucs2 character can be mapped correctly to a dos character
69 and mapped back to the same character in ucs2
71 static int check_dos_char(smb_ucs2_t c)
76 len1 = convert_string(CH_UCS2, CH_DOS, &c, 2, buf, sizeof(buf));
77 if (len1 == 0) return 0;
78 len2 = convert_string(CH_DOS, CH_UCS2, buf, len1, &c2, 2);
79 if (len2 != 2) return 0;
83 /*******************************************************************
84 load the valid character map table
85 ********************************************************************/
86 void init_valid_table(void)
88 static int initialised;
89 static int mapped_file;
91 const char *allowed = ".!#$%&'()_-@^`~";
93 if (initialised && mapped_file) return;
96 valid_table = map_file(lib_path("valid.dat"), 0x10000);
102 if (valid_table) free(valid_table);
104 DEBUG(2,("creating default valid table\n"));
105 valid_table = malloc(0x10000);
106 for (i=0;i<128;i++) valid_table[UCS2_CHAR(i)] = isalnum(i) ||
108 for (;i<0x10000;i++) {
111 valid_table[c] = check_dos_char(c);
116 /*******************************************************************
117 Write a string in (little-endian) unicode format. src is in
118 the current DOS codepage. len is the length in bytes of the
119 string pointed to by dst.
121 if null_terminate is True then null terminate the packet (adds 2 bytes)
123 the return value is the length in bytes consumed by the string, including the
124 null termination if applied
125 ********************************************************************/
127 size_t dos_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminate)
129 return push_ucs2(NULL, dst, src, len,
130 STR_UNICODE|STR_NOALIGN | (null_terminate?STR_TERMINATE:0));
134 /*******************************************************************
135 Skip past a unicode string, but not more than len. Always move
136 past a terminating zero if found.
137 ********************************************************************/
139 char *skip_unibuf(char *src, size_t len)
141 char *srcend = src + len;
143 while (src < srcend && SVAL(src,0))
152 /* Copy a string from little-endian or big-endian unicode source (depending
153 * on flags) to internal samba format destination
155 int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags)
157 if(dest_len==-1) dest_len=MAXUNI-3;
158 return pull_ucs2(NULL, dest, src, dest_len, src_len, flags|STR_UNICODE|STR_NOALIGN);
161 /* Copy a string from a unistr2 source to internal samba format
162 destination. Use this instead of direct calls to rpcstr_pull() to avoid
163 having to determine whether the source string is null terminated. */
165 int rpcstr_pull_unistr2_fstring(char *dest, UNISTR2 *src)
167 return pull_ucs2(NULL, dest, src->buffer, sizeof(fstring),
168 src->uni_str_len * 2, 0);
171 /* Converts a string from internal samba format to unicode
173 int rpcstr_push(void* dest, const char *src, int dest_len, int flags)
175 return push_ucs2(NULL, dest, src, dest_len, flags|STR_UNICODE|STR_NOALIGN);
178 /*******************************************************************
179 Return a DOS codepage version of a little-endian unicode string.
180 len is the filename length (ignoring any terminating zero) in uin16
181 units. Always null terminates.
182 Hack alert: uses fixed buffer(s).
183 ********************************************************************/
184 char *dos_unistrn2(const uint16 *src, int len)
186 static char lbufs[8][MAXUNI];
188 char *lbuf = lbufs[nexti];
190 pull_ucs2(NULL, lbuf, src, MAXUNI-3, len*2, STR_NOALIGN);
194 /*******************************************************************
195 Convert a (little-endian) UNISTR2 structure to an ASCII string
196 ********************************************************************/
197 void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen)
203 pull_ucs2(NULL, dest, str->buffer, maxlen, str->uni_str_len*2, STR_NOALIGN);
207 /*******************************************************************
208 duplicate a UNISTR2 string into a null terminated char*
209 using a talloc context
210 ********************************************************************/
211 char *unistr2_tdup(TALLOC_CTX *ctx, const UNISTR2 *str)
214 int maxlen = (str->uni_str_len+1)*4;
215 if (!str->buffer) return NULL;
216 s = (char *)talloc(ctx, maxlen); /* convervative */
218 pull_ucs2(NULL, s, str->buffer, maxlen, str->uni_str_len*2,
224 /*******************************************************************
225 Return a number stored in a buffer
226 ********************************************************************/
228 uint32 buffer2_to_uint32(BUFFER2 *str)
230 if (str->buf_len == 4)
231 return IVAL(str->buffer, 0);
236 /*******************************************************************
237 Convert a wchar to upper case.
238 ********************************************************************/
240 smb_ucs2_t toupper_w(smb_ucs2_t val)
242 return upcase_table[val];
245 /*******************************************************************
246 Convert a wchar to lower case.
247 ********************************************************************/
249 smb_ucs2_t tolower_w( smb_ucs2_t val )
251 return lowcase_table[val];
254 /*******************************************************************
255 determine if a character is lowercase
256 ********************************************************************/
257 BOOL islower_w(smb_ucs2_t c)
259 return upcase_table[c] != c;
262 /*******************************************************************
263 determine if a character is uppercase
264 ********************************************************************/
265 BOOL isupper_w(smb_ucs2_t c)
267 return lowcase_table[c] != c;
271 /*******************************************************************
272 determine if a character is valid in a 8.3 name
273 ********************************************************************/
274 BOOL isvalid83_w(smb_ucs2_t c)
276 return valid_table[c] != 0;
279 /*******************************************************************
280 Count the number of characters in a smb_ucs2_t string.
281 ********************************************************************/
282 size_t strlen_w(const smb_ucs2_t *src)
286 for(len = 0; *src++; len++) ;
291 /*******************************************************************
292 Count up to max number of characters in a smb_ucs2_t string.
293 ********************************************************************/
294 size_t strnlen_w(const smb_ucs2_t *src, size_t max)
298 for(len = 0; *src++ && (len < max); len++) ;
303 /*******************************************************************
305 ********************************************************************/
306 smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
309 if (c == *s) return (smb_ucs2_t *)s;
315 smb_ucs2_t *strchr_wa(const smb_ucs2_t *s, char c)
317 return strchr_w(s, UCS2_CHAR(c));
320 smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
322 const smb_ucs2_t *p = s;
323 int len = strlen_w(s);
324 if (len == 0) return NULL;
327 if (c == *p) return (smb_ucs2_t *)p;
332 /*******************************************************************
334 ********************************************************************/
335 smb_ucs2_t *strstr_w(const smb_ucs2_t *s, const smb_ucs2_t *ins)
340 if (!s || !*s || !ins || !*ins) return NULL;
342 inslen = strlen_w(ins);
344 while ((r = strchr_w(r, *ins))) {
345 if (strncmp_w(r, ins, inslen) == 0) return r;
351 /*******************************************************************
352 Convert a string to lower case.
353 return True if any char is converted
354 ********************************************************************/
355 BOOL strlower_w(smb_ucs2_t *s)
359 smb_ucs2_t v = tolower_w(*s);
369 /*******************************************************************
370 Convert a string to upper case.
371 return True if any char is converted
372 ********************************************************************/
373 BOOL strupper_w(smb_ucs2_t *s)
377 smb_ucs2_t v = toupper_w(*s);
387 /*******************************************************************
388 convert a string to "normal" form
389 ********************************************************************/
390 void strnorm_w(smb_ucs2_t *s)
392 extern int case_default;
393 if (case_default == CASE_UPPER)
399 int strcmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
401 while (*b && *a == *b) { a++; b++; }
403 /* warning: if *a != *b and both are not 0 we retrun a random
404 greater or lesser than 0 number not realted to which
408 int strncmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
411 while ((n < len) && *b && *a == *b) { a++; b++; n++;}
412 return (len - n)?(*a - *b):0;
415 /*******************************************************************
416 case insensitive string comparison
417 ********************************************************************/
418 int strcasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
420 while (*b && toupper_w(*a) == toupper_w(*b)) { a++; b++; }
421 return (tolower_w(*a) - tolower_w(*b));
424 /*******************************************************************
425 case insensitive string comparison, lenght limited
426 ********************************************************************/
427 int strncasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
430 while ((n < len) && *b && (toupper_w(*a) == toupper_w(*b))) { a++; b++; n++; }
431 return (len - n)?(tolower_w(*a) - tolower_w(*b)):0;
434 /*******************************************************************
436 ********************************************************************/
437 BOOL strequal_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2)
439 if (s1 == s2) return(True);
440 if (!s1 || !s2) return(False);
442 return(strcasecmp_w(s1,s2)==0);
445 /*******************************************************************
446 compare 2 strings up to and including the nth char.
447 ******************************************************************/
448 BOOL strnequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2,size_t n)
450 if (s1 == s2) return(True);
451 if (!s1 || !s2 || !n) return(False);
453 return(strncasecmp_w(s1,s2,n)==0);
456 /*******************************************************************
458 ********************************************************************/
459 smb_ucs2_t *strdup_w(const smb_ucs2_t *src)
461 return strndup_w(src, 0);
464 /* if len == 0 then duplicate the whole string */
465 smb_ucs2_t *strndup_w(const smb_ucs2_t *src, size_t len)
469 if (!len) len = strlen_w(src);
470 dest = (smb_ucs2_t *)malloc((len + 1) * sizeof(smb_ucs2_t));
472 DEBUG(0,("strdup_w: out of memory!\n"));
476 memcpy(dest, src, len * sizeof(smb_ucs2_t));
482 /*******************************************************************
483 copy a string with max len
484 ********************************************************************/
486 smb_ucs2_t *strncpy_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
490 if (!dest || !src) return NULL;
492 for (len = 0; (src[len] != 0) && (len < max); len++)
493 dest[len] = src[len];
501 /*******************************************************************
502 append a string of len bytes and add a terminator
503 ********************************************************************/
505 smb_ucs2_t *strncat_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
510 if (!dest || !src) return NULL;
512 start = strlen_w(dest);
513 len = strnlen_w(src, max);
515 memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));
521 smb_ucs2_t *strcat_w(smb_ucs2_t *dest, const smb_ucs2_t *src)
526 if (!dest || !src) return NULL;
528 start = strlen_w(dest);
531 memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));
538 /*******************************************************************
539 replace any occurence of oldc with newc in unicode string
540 ********************************************************************/
542 void string_replace_w(smb_ucs2_t *s, smb_ucs2_t oldc, smb_ucs2_t newc)
545 if(*s==oldc) *s=newc;
549 /*******************************************************************
551 ********************************************************************/
553 BOOL trim_string_w(smb_ucs2_t *s, const smb_ucs2_t *front,
554 const smb_ucs2_t *back)
557 size_t len, front_len, back_len;
559 if (!s || !*s) return False;
563 if (front && *front) {
564 front_len = strlen_w(front);
565 while (len && strncmp_w(s, front, front_len) == 0) {
566 memmove(s, (s + front_len), (len - front_len + 1) * sizeof(smb_ucs2_t));
573 back_len = strlen_w(back);
574 while (len && strncmp_w((s + (len - back_len)), back, back_len) == 0) {
575 s[len - back_len] = 0;
585 The *_wa() functions take a combination of 7 bit ascii
586 and wide characters They are used so that you can use string
587 functions combining C string constants with ucs2 strings
589 The char* arguments must NOT be multibyte - to be completely sure
590 of this only pass string constants */
593 void pstrcpy_wa(smb_ucs2_t *dest, const char *src)
596 for (i=0;i<PSTRING_LEN;i++) {
597 dest[i] = UCS2_CHAR(src[i]);
598 if (src[i] == 0) return;
602 int strcmp_wa(const smb_ucs2_t *a, const char *b)
604 while (*b && *a == UCS2_CHAR(*b)) { a++; b++; }
605 return (*a - UCS2_CHAR(*b));
608 int strncmp_wa(const smb_ucs2_t *a, const char *b, size_t len)
611 while ((n < len) && *b && *a == UCS2_CHAR(*b)) { a++; b++; n++;}
612 return (len - n)?(*a - UCS2_CHAR(*b)):0;
615 smb_ucs2_t *strpbrk_wa(const smb_ucs2_t *s, const char *p)
619 for (i=0; p[i] && *s != UCS2_CHAR(p[i]); i++)
621 if (p[i]) return (smb_ucs2_t *)s;
627 smb_ucs2_t *strstr_wa(const smb_ucs2_t *s, const char *ins)
632 if (!s || !*s || !ins || !*ins) return NULL;
634 inslen = strlen(ins);
636 while ((r = strchr_w(r, UCS2_CHAR(*ins)))) {
637 if (strncmp_wa(r, ins, inslen) == 0) return r;
643 /*******************************************************************
644 copy a string with max len
645 ********************************************************************/
647 smb_ucs2_t *strncpy_wa(smb_ucs2_t *dest, const char *src, const size_t max)
649 smb_ucs2_t *ucs2_src;
651 if (!dest || !src) return NULL;
652 if (!(ucs2_src = acnv_uxu2(src)))
655 strncpy_w(dest, ucs2_src, max);
660 /*******************************************************************
661 convert and duplicate an ascii string
662 ********************************************************************/
663 smb_ucs2_t *strdup_wa(const char *src)
665 return strndup_wa(src, 0);
668 /* if len == 0 then duplicate the whole string */
669 smb_ucs2_t *strndup_wa(const char *src, size_t len)
671 smb_ucs2_t *dest, *s;
674 if (!len) len = strlen_w(s);
675 dest = (smb_ucs2_t *)malloc((len + 1) * sizeof(smb_ucs2_t));
677 DEBUG(0,("strdup_w: out of memory!\n"));
682 memcpy(dest, src, len * sizeof(smb_ucs2_t));
689 /*******************************************************************
690 append a string of len bytes and add a terminator
691 ********************************************************************/
693 smb_ucs2_t *strncat_wa(smb_ucs2_t *dest, const char *src, const size_t max)
695 smb_ucs2_t *ucs2_src;
697 if (!dest || !src) return NULL;
698 if (!(ucs2_src = acnv_uxu2(src)))
701 strncat_w(dest, ucs2_src, max);
706 smb_ucs2_t *strcat_wa(smb_ucs2_t *dest, const char *src)
708 smb_ucs2_t *ucs2_src;
710 if (!dest || !src) return NULL;
711 if (!(ucs2_src = acnv_uxu2(src)))
714 strcat_w(dest, ucs2_src);
719 BOOL trim_string_wa(smb_ucs2_t *s, const char *front,
724 if (front) push_ucs2(NULL, f, front, sizeof(wpstring) - 1, STR_TERMINATE);
726 if (back) push_ucs2(NULL, b, back, sizeof(wpstring) - 1, STR_TERMINATE);
728 return trim_string_w(s, f, b);