2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-2001
5 Copyright (C) Simo Sorce 2001
6 Copyright (C) Jeremy Allison 2005
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 3 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, see <http://www.gnu.org/licenses/>.
28 /* these 3 tables define the unicode case handling. They are loaded
29 at startup either via mmap() or read() from the lib directory */
30 static smb_ucs2_t *upcase_table;
31 static smb_ucs2_t *lowcase_table;
32 static uint8 *valid_table;
33 static bool upcase_table_use_unmap;
34 static bool lowcase_table_use_unmap;
35 static bool valid_table_use_unmap;
38 * Destroy global objects allocated by load_case_tables()
40 void gfree_case_tables(void)
43 if ( upcase_table_use_unmap )
44 unmap_file(upcase_table, 0x20000);
46 SAFE_FREE(upcase_table);
49 if ( lowcase_table ) {
50 if ( lowcase_table_use_unmap )
51 unmap_file(lowcase_table, 0x20000);
53 SAFE_FREE(lowcase_table);
57 if ( valid_table_use_unmap )
58 unmap_file(valid_table, 0x10000);
60 SAFE_FREE(valid_table);
65 * Load or generate the case handling tables.
67 * The case tables are defined in UCS2 and don't depend on any
68 * configured parameters, so they never need to be reloaded.
71 void load_case_tables(void)
73 static int initialised;
74 char *old_locale = NULL, *saved_locale = NULL;
76 TALLOC_CTX *frame = NULL;
83 frame = talloc_stackframe();
85 upcase_table = (smb_ucs2_t *)map_file(data_path("upcase.dat"),
87 upcase_table_use_unmap = ( upcase_table != NULL );
89 lowcase_table = (smb_ucs2_t *)map_file(data_path("lowcase.dat"),
91 lowcase_table_use_unmap = ( lowcase_table != NULL );
94 /* Get the name of the current locale. */
95 old_locale = setlocale(LC_ALL, NULL);
98 /* Save it as it is in static storage. */
99 saved_locale = SMB_STRDUP(old_locale);
102 /* We set back the locale to C to get ASCII-compatible toupper/lower functions. */
103 setlocale(LC_ALL, "C");
106 /* we would like Samba to limp along even if these tables are
109 DEBUG(1,("creating lame upcase table\n"));
110 upcase_table = (smb_ucs2_t *)SMB_MALLOC(0x20000);
111 for (i=0;i<0x10000;i++) {
116 for (i=0;i<256;i++) {
118 SSVAL(&v, 0, UCS2_CHAR(i));
119 upcase_table[v] = UCS2_CHAR(islower(i)?toupper(i):i);
123 if (!lowcase_table) {
124 DEBUG(1,("creating lame lowcase table\n"));
125 lowcase_table = (smb_ucs2_t *)SMB_MALLOC(0x20000);
126 for (i=0;i<0x10000;i++) {
129 lowcase_table[v] = i;
131 for (i=0;i<256;i++) {
133 SSVAL(&v, 0, UCS2_CHAR(i));
134 lowcase_table[v] = UCS2_CHAR(isupper(i)?tolower(i):i);
138 #ifdef HAVE_SETLOCALE
139 /* Restore the old locale. */
141 setlocale (LC_ALL, saved_locale);
142 SAFE_FREE(saved_locale);
148 static int check_dos_char_slowly(smb_ucs2_t c)
154 len1 = convert_string(CH_UTF16LE, CH_DOS, &c, 2, buf, sizeof(buf),False);
158 len2 = convert_string(CH_DOS, CH_UTF16LE, buf, len1, &c2, 2,False);
166 * Load the valid character map table from <tt>valid.dat</tt> or
167 * create from the configured codepage.
169 * This function is called whenever the configuration is reloaded.
170 * However, the valid character table is not changed if it's loaded
171 * from a file, because we can't unmap files.
174 void init_valid_table(void)
176 static int mapped_file;
178 const char *allowed = ".!#$%&'()_-@^`~";
182 /* Can't unmap files, so stick with what we have */
186 valid_file = (uint8 *)map_file(data_path("valid.dat"), 0x10000);
188 valid_table = valid_file;
190 valid_table_use_unmap = True;
194 /* Otherwise, we're using a dynamically created valid_table.
195 * It might need to be regenerated if the code page changed.
196 * We know that we're not using a mapped file, so we can
197 * free() the old one. */
198 SAFE_FREE(valid_table);
200 /* use free rather than unmap */
201 valid_table_use_unmap = False;
203 DEBUG(2,("creating default valid table\n"));
204 valid_table = (uint8 *)SMB_MALLOC(0x10000);
205 SMB_ASSERT(valid_table != NULL);
206 for (i=0;i<128;i++) {
207 valid_table[i] = isalnum(i) || strchr(allowed,i);
210 lazy_initialize_conv();
212 for (;i<0x10000;i++) {
215 valid_table[i] = check_dos_char_slowly(c);
219 /*******************************************************************
220 Write a string in (little-endian) unicode format. src is in
221 the current DOS codepage. len is the length in bytes of the
222 string pointed to by dst.
224 if null_terminate is True then null terminate the packet (adds 2 bytes)
226 the return value is the length in bytes consumed by the string, including the
227 null termination if applied
228 ********************************************************************/
230 size_t dos_PutUniCode(char *dst,const char *src, size_t len, bool null_terminate)
232 int flags = null_terminate ? STR_UNICODE|STR_NOALIGN|STR_TERMINATE
233 : STR_UNICODE|STR_NOALIGN;
234 return push_ucs2(NULL, dst, src, len, flags);
238 /*******************************************************************
239 Skip past a unicode string, but not more than len. Always move
240 past a terminating zero if found.
241 ********************************************************************/
243 char *skip_unibuf(char *src, size_t len)
245 char *srcend = src + len;
247 while (src < srcend && SVAL(src,0)) {
258 /* Copy a string from little-endian or big-endian unicode source (depending
259 * on flags) to internal samba format destination
262 int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags)
271 return pull_ucs2(NULL, dest, src, dest_len, src_len, flags|STR_UNICODE|STR_NOALIGN);
274 /* Copy a string from little-endian or big-endian unicode source (depending
275 * on flags) to internal samba format destination. Allocates on talloc ctx.
278 int rpcstr_pull_talloc(TALLOC_CTX *ctx,
284 return pull_ucs2_base_talloc(ctx,
289 flags|STR_UNICODE|STR_NOALIGN);
293 /* Copy a string from a unistr2 source to internal samba format
294 destination. Use this instead of direct calls to rpcstr_pull() to avoid
295 having to determine whether the source string is null terminated. */
297 int rpcstr_pull_unistr2_fstring(char *dest, UNISTR2 *src)
299 return pull_ucs2(NULL, dest, src->buffer, sizeof(fstring),
300 src->uni_str_len * 2, 0);
303 /* Helper function to return a talloc'ed string. I have implemented it with a
304 * copy because I don't really know how pull_ucs2 and friends calculate the
305 * target size. If this turns out to be a major bottleneck someone with deeper
306 * multi-byte knowledge needs to revisit this.
307 * I just did (JRA :-). No longer uses copy.
308 * My (VL) use is dsr_getdcname, which returns 6 strings, the alternative would
309 * have been to manually talloc_strdup them in rpc_client/cli_netlogon.c.
312 char *rpcstr_pull_unistr2_talloc(TALLOC_CTX *ctx, const UNISTR2 *src)
317 if (!convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src->buffer,
318 src->uni_str_len * 2, (void *)&dest,
324 /* Ensure we're returning a null terminated string. */
326 /* Did we already process the terminating zero ? */
327 if (dest[dest_len-1] != 0) {
328 size_t size = talloc_get_size(dest);
329 /* Have we got space to append the '\0' ? */
330 if (size <= dest_len) {
332 dest = TALLOC_REALLOC_ARRAY(ctx, dest, char,
336 dest_len = (size_t)-1;
341 dest[dest_len] = '\0';
351 /* Converts a string from internal samba format to unicode
354 int rpcstr_push(void *dest, const char *src, size_t dest_len, int flags)
356 return push_ucs2(NULL, dest, src, dest_len, flags|STR_UNICODE|STR_NOALIGN);
359 /* Converts a string from internal samba format to unicode. Always terminates.
360 * Actually just a wrapper round push_ucs2_talloc().
363 int rpcstr_push_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
366 if (push_ucs2_talloc(ctx, dest, src, &size))
372 /*******************************************************************
373 Convert a (little-endian) UNISTR2 structure to an ASCII string.
374 ********************************************************************/
376 void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen)
378 if ((str == NULL) || (str->uni_str_len == 0)) {
382 pull_ucs2(NULL, dest, str->buffer, maxlen, str->uni_str_len*2, STR_NOALIGN);
386 /*******************************************************************
387 Convert a (little-endian) UNISTR3 structure to an ASCII string.
388 ********************************************************************/
390 void unistr3_to_ascii(char *dest, const UNISTR3 *str, size_t maxlen)
392 if ((str == NULL) || (str->uni_str_len == 0)) {
396 pull_ucs2(NULL, dest, str->str.buffer, maxlen, str->uni_str_len*2,
401 /*******************************************************************
402 Duplicate a UNISTR2 string into a null terminated char*
403 using a talloc context.
404 ********************************************************************/
406 char *unistr2_to_ascii_talloc(TALLOC_CTX *ctx, const UNISTR2 *str)
410 if (!str || !str->buffer) {
413 if (pull_ucs2_base_talloc(ctx,
418 STR_NOALIGN) == (size_t)-1) {
424 /*******************************************************************
425 Return a string for displaying a UNISTR2. Guarentees to return a
426 valid string - "" if nothing else.
427 Changed to use talloc_tos() under the covers.... JRA.
428 ********************************************************************/
430 const char *unistr2_static(const UNISTR2 *str)
434 if ((str == NULL) || (str->uni_str_len == 0)) {
438 dest = unistr2_to_ascii_talloc(talloc_tos(), str);
446 /*******************************************************************
447 Convert a wchar to upper case.
448 ********************************************************************/
450 smb_ucs2_t toupper_w(smb_ucs2_t val)
452 return upcase_table[SVAL(&val,0)];
455 /*******************************************************************
456 Convert a wchar to lower case.
457 ********************************************************************/
459 smb_ucs2_t tolower_w( smb_ucs2_t val )
461 return lowcase_table[SVAL(&val,0)];
464 /*******************************************************************
465 Determine if a character is lowercase.
466 ********************************************************************/
468 bool islower_w(smb_ucs2_t c)
470 return upcase_table[SVAL(&c,0)] != c;
473 /*******************************************************************
474 Determine if a character is uppercase.
475 ********************************************************************/
477 bool isupper_w(smb_ucs2_t c)
479 return lowcase_table[SVAL(&c,0)] != c;
482 /*******************************************************************
483 Determine if a character is valid in a 8.3 name.
484 ********************************************************************/
486 bool isvalid83_w(smb_ucs2_t c)
488 return valid_table[SVAL(&c,0)] != 0;
491 /*******************************************************************
492 Count the number of characters in a smb_ucs2_t string.
493 ********************************************************************/
495 size_t strlen_w(const smb_ucs2_t *src)
500 for(len = 0; *(COPY_UCS2_CHAR(&c,src)); src++, len++) {
507 /*******************************************************************
508 Count up to max number of characters in a smb_ucs2_t string.
509 ********************************************************************/
511 size_t strnlen_w(const smb_ucs2_t *src, size_t max)
516 for(len = 0; (len < max) && *(COPY_UCS2_CHAR(&c,src)); src++, len++) {
523 /*******************************************************************
525 ********************************************************************/
527 smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
530 while (*(COPY_UCS2_CHAR(&cp,s))) {
532 return (smb_ucs2_t *)s;
537 return (smb_ucs2_t *)s;
543 smb_ucs2_t *strchr_wa(const smb_ucs2_t *s, char c)
545 return strchr_w(s, UCS2_CHAR(c));
548 /*******************************************************************
550 ********************************************************************/
552 smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
555 const smb_ucs2_t *p = s;
556 int len = strlen_w(s);
563 if (c == *(COPY_UCS2_CHAR(&cp,p))) {
564 return (smb_ucs2_t *)p;
570 /*******************************************************************
571 Wide version of strrchr that returns after doing strrchr 'n' times.
572 ********************************************************************/
574 smb_ucs2_t *strnrchr_w(const smb_ucs2_t *s, smb_ucs2_t c, unsigned int n)
577 const smb_ucs2_t *p = s;
578 int len = strlen_w(s);
580 if (len == 0 || !n) {
585 if (c == *(COPY_UCS2_CHAR(&cp,p))) {
590 return (smb_ucs2_t *)p;
596 /*******************************************************************
598 ********************************************************************/
600 smb_ucs2_t *strstr_w(const smb_ucs2_t *s, const smb_ucs2_t *ins)
605 if (!s || !*s || !ins || !*ins) {
609 inslen = strlen_w(ins);
612 while ((r = strchr_w(r, *ins))) {
613 if (strncmp_w(r, ins, inslen) == 0) {
622 /*******************************************************************
623 Convert a string to lower case.
624 return True if any char is converted
625 ********************************************************************/
627 bool strlower_w(smb_ucs2_t *s)
632 while (*(COPY_UCS2_CHAR(&cp,s))) {
633 smb_ucs2_t v = tolower_w(cp);
635 COPY_UCS2_CHAR(s,&v);
643 /*******************************************************************
644 Convert a string to upper case.
645 return True if any char is converted
646 ********************************************************************/
648 bool strupper_w(smb_ucs2_t *s)
652 while (*(COPY_UCS2_CHAR(&cp,s))) {
653 smb_ucs2_t v = toupper_w(cp);
655 COPY_UCS2_CHAR(s,&v);
663 /*******************************************************************
664 Convert a string to "normal" form.
665 ********************************************************************/
667 void strnorm_w(smb_ucs2_t *s, int case_default)
669 if (case_default == CASE_UPPER) {
676 int strcmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
680 while ((*(COPY_UCS2_CHAR(&cpb,b))) && (*(COPY_UCS2_CHAR(&cpa,a)) == cpb)) {
684 return (*(COPY_UCS2_CHAR(&cpa,a)) - *(COPY_UCS2_CHAR(&cpb,b)));
685 /* warning: if *a != *b and both are not 0 we return a random
686 greater or lesser than 0 number not realted to which
690 int strncmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
695 while ((n < len) && (*(COPY_UCS2_CHAR(&cpb,b))) && (*(COPY_UCS2_CHAR(&cpa,a)) == cpb)) {
700 return (len - n)?(*(COPY_UCS2_CHAR(&cpa,a)) - *(COPY_UCS2_CHAR(&cpb,b))):0;
703 /*******************************************************************
704 Case insensitive string comparison.
705 ********************************************************************/
707 int strcasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
711 while ((*COPY_UCS2_CHAR(&cpb,b)) && toupper_w(*(COPY_UCS2_CHAR(&cpa,a))) == toupper_w(cpb)) {
715 return (tolower_w(*(COPY_UCS2_CHAR(&cpa,a))) - tolower_w(*(COPY_UCS2_CHAR(&cpb,b))));
718 /*******************************************************************
719 Case insensitive string comparison, length limited.
720 ********************************************************************/
722 int strncasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
727 while ((n < len) && *COPY_UCS2_CHAR(&cpb,b) && (toupper_w(*(COPY_UCS2_CHAR(&cpa,a))) == toupper_w(cpb))) {
732 return (len - n)?(tolower_w(*(COPY_UCS2_CHAR(&cpa,a))) - tolower_w(*(COPY_UCS2_CHAR(&cpb,b)))):0;
735 /*******************************************************************
737 ********************************************************************/
739 bool strequal_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2)
748 return(strcasecmp_w(s1,s2)==0);
751 /*******************************************************************
752 Compare 2 strings up to and including the nth char.
753 ******************************************************************/
755 bool strnequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2,size_t n)
760 if (!s1 || !s2 || !n) {
764 return(strncasecmp_w(s1,s2,n)==0);
767 /*******************************************************************
769 ********************************************************************/
771 smb_ucs2_t *strdup_w(const smb_ucs2_t *src)
773 return strndup_w(src, 0);
776 /* if len == 0 then duplicate the whole string */
778 smb_ucs2_t *strndup_w(const smb_ucs2_t *src, size_t len)
785 dest = SMB_MALLOC_ARRAY(smb_ucs2_t, len + 1);
787 DEBUG(0,("strdup_w: out of memory!\n"));
791 memcpy(dest, src, len * sizeof(smb_ucs2_t));
796 /*******************************************************************
797 Copy a string with max len.
798 ********************************************************************/
800 smb_ucs2_t *strncpy_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
809 for (len = 0; (*COPY_UCS2_CHAR(&cp,(src+len))) && (len < max); len++) {
810 cp = *COPY_UCS2_CHAR(dest+len,src+len);
813 for ( /*nothing*/ ; len < max; len++ ) {
814 cp = *COPY_UCS2_CHAR(dest+len,&cp);
820 /*******************************************************************
821 Append a string of len bytes and add a terminator.
822 ********************************************************************/
824 smb_ucs2_t *strncat_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
834 start = strlen_w(dest);
835 len = strnlen_w(src, max);
837 memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));
838 z = *COPY_UCS2_CHAR(dest+start+len,&z);
843 smb_ucs2_t *strcat_w(smb_ucs2_t *dest, const smb_ucs2_t *src)
853 start = strlen_w(dest);
856 memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));
857 z = *COPY_UCS2_CHAR(dest+start+len,&z);
863 /*******************************************************************
864 Replace any occurence of oldc with newc in unicode string.
865 ********************************************************************/
867 void string_replace_w(smb_ucs2_t *s, smb_ucs2_t oldc, smb_ucs2_t newc)
871 for(;*(COPY_UCS2_CHAR(&cp,s));s++) {
873 COPY_UCS2_CHAR(s,&newc);
878 /*******************************************************************
880 ********************************************************************/
882 bool trim_string_w(smb_ucs2_t *s, const smb_ucs2_t *front,
883 const smb_ucs2_t *back)
886 size_t len, front_len, back_len;
894 if (front && *front) {
895 front_len = strlen_w(front);
896 while (len && strncmp_w(s, front, front_len) == 0) {
897 memmove(s, (s + front_len), (len - front_len + 1) * sizeof(smb_ucs2_t));
904 back_len = strlen_w(back);
905 while (len && strncmp_w((s + (len - back_len)), back, back_len) == 0) {
906 s[len - back_len] = 0;
916 The *_wa() functions take a combination of 7 bit ascii
917 and wide characters They are used so that you can use string
918 functions combining C string constants with ucs2 strings
920 The char* arguments must NOT be multibyte - to be completely sure
921 of this only pass string constants */
923 int strcmp_wa(const smb_ucs2_t *a, const char *b)
927 while (*b && *(COPY_UCS2_CHAR(&cp,a)) == UCS2_CHAR(*b)) {
931 return (*(COPY_UCS2_CHAR(&cp,a)) - UCS2_CHAR(*b));
934 int strncmp_wa(const smb_ucs2_t *a, const char *b, size_t len)
939 while ((n < len) && *b && *(COPY_UCS2_CHAR(&cp,a)) == UCS2_CHAR(*b)) {
944 return (len - n)?(*(COPY_UCS2_CHAR(&cp,a)) - UCS2_CHAR(*b)):0;
947 smb_ucs2_t *strpbrk_wa(const smb_ucs2_t *s, const char *p)
951 while (*(COPY_UCS2_CHAR(&cp,s))) {
953 for (i=0; p[i] && cp != UCS2_CHAR(p[i]); i++)
956 return (smb_ucs2_t *)s;
963 smb_ucs2_t *strstr_wa(const smb_ucs2_t *s, const char *ins)
972 inslen = strlen(ins);
975 while ((r = strchr_w(r, UCS2_CHAR(*ins)))) {
976 if (strncmp_wa(r, ins, inslen) == 0)
984 /*******************************************************************
985 Returns the length in number of wide characters.
986 ******************************************************************/
988 int unistrlen(uint16 *s)
996 for (len=0; SVAL(s,0); s++,len++) {
1003 /*******************************************************************
1004 Strcpy for unicode strings. Returns length (in num of wide chars).
1006 ********************************************************************/
1008 int unistrcpy(uint16 *dst, uint16 *src)
1012 while (SVAL(src,0)) {
1022 * Samba ucs2 type to UNISTR2 conversion
1024 * @param ctx Talloc context to create the dst strcture (if null) and the
1025 * contents of the unicode string.
1026 * @param dst UNISTR2 destination. If equals null, then it's allocated.
1027 * @param src smb_ucs2_t source.
1028 * @param max_len maximum number of unicode characters to copy. If equals
1029 * null, then null-termination of src is taken
1031 * @return copied UNISTR2 destination
1034 UNISTR2* ucs2_to_unistr2(TALLOC_CTX *ctx, UNISTR2* dst, smb_ucs2_t* src)
1042 len = strlen_w(src);
1044 /* allocate UNISTR2 destination if not given */
1046 dst = TALLOC_P(ctx, UNISTR2);
1051 dst->buffer = TALLOC_ARRAY(ctx, uint16, len + 1);
1056 /* set UNISTR2 parameters */
1057 dst->uni_max_len = len + 1;
1059 dst->uni_str_len = len;
1061 /* copy the actual unicode string */
1062 strncpy_w(dst->buffer, src, dst->uni_max_len);
1067 /*************************************************************
1068 ascii only toupper - saves the need for smbd to be in C locale.
1069 *************************************************************/
1071 int toupper_ascii(int c)
1073 smb_ucs2_t uc = toupper_w(UCS2_CHAR(c));
1074 return UCS2_TO_CHAR(uc);
1077 /*************************************************************
1078 ascii only tolower - saves the need for smbd to be in C locale.
1079 *************************************************************/
1081 int tolower_ascii(int c)
1083 smb_ucs2_t uc = tolower_w(UCS2_CHAR(c));
1084 return UCS2_TO_CHAR(uc);
1087 /*************************************************************
1088 ascii only isupper - saves the need for smbd to be in C locale.
1089 *************************************************************/
1091 int isupper_ascii(int c)
1093 return isupper_w(UCS2_CHAR(c));
1096 /*************************************************************
1097 ascii only islower - saves the need for smbd to be in C locale.
1098 *************************************************************/
1100 int islower_ascii(int c)
1102 return islower_w(UCS2_CHAR(c));