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 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 * This table says which Unicode characters are valid dos
39 * Each value is just a single bit.
41 static uint8 doschar_table[8192]; /* 65536 characters / 8 bits/byte */
45 * Load or generate the case handling tables.
47 * The case tables are defined in UCS2 and don't depend on any
48 * configured parameters, so they never need to be reloaded.
51 void load_case_tables(void)
53 static int initialised;
61 upcase_table = map_file(lib_path("upcase.dat"), 0x20000);
62 lowcase_table = map_file(lib_path("lowcase.dat"), 0x20000);
64 /* we would like Samba to limp along even if these tables are
67 DEBUG(1,("creating lame upcase table\n"));
68 upcase_table = SMB_MALLOC(0x20000);
69 for (i=0;i<0x10000;i++) {
76 SSVAL(&v, 0, UCS2_CHAR(i));
77 upcase_table[v] = UCS2_CHAR(islower(i)?toupper(i):i);
82 DEBUG(1,("creating lame lowcase table\n"));
83 lowcase_table = SMB_MALLOC(0x20000);
84 for (i=0;i<0x10000;i++) {
91 SSVAL(&v, 0, UCS2_CHAR(i));
92 lowcase_table[v] = UCS2_CHAR(isupper(i)?tolower(i):i);
98 see if a ucs2 character can be mapped correctly to a dos character
99 and mapped back to the same character in ucs2
102 int check_dos_char(smb_ucs2_t c)
104 lazy_initialize_conv();
106 /* Find the right byte, and right bit within the byte; return
108 return (doschar_table[(c & 0xffff) / 8] & (1 << (c & 7))) != 0;
112 static int check_dos_char_slowly(smb_ucs2_t c)
118 len1 = convert_string(CH_UCS2, CH_DOS, &c, 2, buf, sizeof(buf),False);
122 len2 = convert_string(CH_DOS, CH_UCS2, buf, len1, &c2, 2,False);
131 * Fill out doschar table the hard way, by examining each character
134 void init_doschar_table(void)
138 /* For each byte of packed table */
140 for (i = 0; i <= 0xffff; i += 8) {
142 for (j = 0; j <= 7; j++) {
147 if (check_dos_char_slowly(c)) {
151 doschar_table[i/8] = byteval;
157 * Load the valid character map table from <tt>valid.dat</tt> or
158 * create from the configured codepage.
160 * This function is called whenever the configuration is reloaded.
161 * However, the valid character table is not changed if it's loaded
162 * from a file, because we can't unmap files.
165 void init_valid_table(void)
167 static int mapped_file;
169 const char *allowed = ".!#$%&'()_-@^`~";
173 /* Can't unmap files, so stick with what we have */
177 valid_file = map_file(lib_path("valid.dat"), 0x10000);
179 valid_table = valid_file;
184 /* Otherwise, we're using a dynamically created valid_table.
185 * It might need to be regenerated if the code page changed.
186 * We know that we're not using a mapped file, so we can
187 * free() the old one. */
188 if (valid_table) free(valid_table);
190 DEBUG(2,("creating default valid table\n"));
191 valid_table = SMB_MALLOC(0x10000);
192 for (i=0;i<128;i++) {
193 valid_table[i] = isalnum(i) || strchr(allowed,i);
196 for (;i<0x10000;i++) {
199 valid_table[i] = check_dos_char(c);
203 /*******************************************************************
204 Write a string in (little-endian) unicode format. src is in
205 the current DOS codepage. len is the length in bytes of the
206 string pointed to by dst.
208 if null_terminate is True then null terminate the packet (adds 2 bytes)
210 the return value is the length in bytes consumed by the string, including the
211 null termination if applied
212 ********************************************************************/
214 size_t dos_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminate)
216 int flags = null_terminate ? STR_UNICODE|STR_NOALIGN|STR_TERMINATE
217 : STR_UNICODE|STR_NOALIGN;
218 return push_ucs2(NULL, dst, src, len, flags);
222 /*******************************************************************
223 Skip past a unicode string, but not more than len. Always move
224 past a terminating zero if found.
225 ********************************************************************/
227 char *skip_unibuf(char *src, size_t len)
229 char *srcend = src + len;
231 while (src < srcend && SVAL(src,0)) {
242 /* Copy a string from little-endian or big-endian unicode source (depending
243 * on flags) to internal samba format destination
246 int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags)
255 return pull_ucs2(NULL, dest, src, dest_len, src_len, flags|STR_UNICODE|STR_NOALIGN);
258 /* Copy a string from a unistr2 source to internal samba format
259 destination. Use this instead of direct calls to rpcstr_pull() to avoid
260 having to determine whether the source string is null terminated. */
262 int rpcstr_pull_unistr2_fstring(char *dest, UNISTR2 *src)
264 return pull_ucs2(NULL, dest, src->buffer, sizeof(fstring),
265 src->uni_str_len * 2, 0);
268 /* Helper function to return a talloc'ed string. I have implemented it with a
269 * copy because I don't really know how pull_ucs2 and friends calculate the
270 * target size. If this turns out to be a major bottleneck someone with deeper
271 * multi-byte knowledge needs to revisit this.
272 * My (VL) use is dsr_getdcname, which returns 6 strings, the alternative would
273 * have been to manually talloc_strdup them in rpc_client/cli_netlogon.c.
276 size_t rpcstr_pull_unistr2_talloc(TALLOC_CTX *mem_ctx, char **dest,
282 result = pull_ucs2(NULL, tmp, src->buffer, sizeof(tmp),
283 src->uni_str_len * 2, 0);
288 *dest = talloc_strdup(mem_ctx, tmp);
296 /* Converts a string from internal samba format to unicode
299 int rpcstr_push(void* dest, const char *src, int dest_len, int flags)
301 return push_ucs2(NULL, dest, src, dest_len, flags|STR_UNICODE|STR_NOALIGN);
304 /*******************************************************************
305 Convert a (little-endian) UNISTR2 structure to an ASCII string.
306 ********************************************************************/
308 void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen)
314 pull_ucs2(NULL, dest, str->buffer, maxlen, str->uni_str_len*2, STR_NOALIGN);
317 /*******************************************************************
318 Convert a (little-endian) UNISTR3 structure to an ASCII string.
319 ********************************************************************/
321 void unistr3_to_ascii(char *dest, const UNISTR3 *str, size_t maxlen)
327 pull_ucs2(NULL, dest, str->str.buffer, maxlen, str->uni_str_len*2,
331 /*******************************************************************
332 Give a static string for displaying a UNISTR2.
333 ********************************************************************/
335 const char *unistr2_static(const UNISTR2 *str)
338 unistr2_to_ascii(ret, str, sizeof(ret));
342 /*******************************************************************
343 Duplicate a UNISTR2 string into a null terminated char*
344 using a talloc context.
345 ********************************************************************/
347 char *unistr2_tdup(TALLOC_CTX *ctx, const UNISTR2 *str)
350 int maxlen = (str->uni_str_len+1)*4;
354 s = (char *)TALLOC(ctx, maxlen); /* convervative */
358 pull_ucs2(NULL, s, str->buffer, maxlen, str->uni_str_len*2, STR_NOALIGN);
362 /*******************************************************************
363 Convert a wchar to upper case.
364 ********************************************************************/
366 smb_ucs2_t toupper_w(smb_ucs2_t val)
368 return upcase_table[SVAL(&val,0)];
371 /*******************************************************************
372 Convert a wchar to lower case.
373 ********************************************************************/
375 smb_ucs2_t tolower_w( smb_ucs2_t val )
377 return lowcase_table[SVAL(&val,0)];
380 /*******************************************************************
381 Determine if a character is lowercase.
382 ********************************************************************/
384 BOOL islower_w(smb_ucs2_t c)
386 return upcase_table[SVAL(&c,0)] != c;
389 /*******************************************************************
390 Determine if a character is uppercase.
391 ********************************************************************/
393 BOOL isupper_w(smb_ucs2_t c)
395 return lowcase_table[SVAL(&c,0)] != c;
398 /*******************************************************************
399 Determine if a character is valid in a 8.3 name.
400 ********************************************************************/
402 BOOL isvalid83_w(smb_ucs2_t c)
404 return valid_table[SVAL(&c,0)] != 0;
407 /*******************************************************************
408 Count the number of characters in a smb_ucs2_t string.
409 ********************************************************************/
411 size_t strlen_w(const smb_ucs2_t *src)
416 for(len = 0; *(COPY_UCS2_CHAR(&c,src)); src++, len++) {
423 /*******************************************************************
424 Count up to max number of characters in a smb_ucs2_t string.
425 ********************************************************************/
427 size_t strnlen_w(const smb_ucs2_t *src, size_t max)
432 for(len = 0; *(COPY_UCS2_CHAR(&c,src)) && (len < max); src++, len++) {
439 /*******************************************************************
441 ********************************************************************/
443 smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
446 while (*(COPY_UCS2_CHAR(&cp,s))) {
448 return (smb_ucs2_t *)s;
453 return (smb_ucs2_t *)s;
459 smb_ucs2_t *strchr_wa(const smb_ucs2_t *s, char c)
461 return strchr_w(s, UCS2_CHAR(c));
464 /*******************************************************************
466 ********************************************************************/
468 smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
471 const smb_ucs2_t *p = s;
472 int len = strlen_w(s);
479 if (c == *(COPY_UCS2_CHAR(&cp,p))) {
480 return (smb_ucs2_t *)p;
486 /*******************************************************************
487 Wide version of strrchr that returns after doing strrchr 'n' times.
488 ********************************************************************/
490 smb_ucs2_t *strnrchr_w(const smb_ucs2_t *s, smb_ucs2_t c, unsigned int n)
493 const smb_ucs2_t *p = s;
494 int len = strlen_w(s);
496 if (len == 0 || !n) {
501 if (c == *(COPY_UCS2_CHAR(&cp,p))) {
506 return (smb_ucs2_t *)p;
512 /*******************************************************************
514 ********************************************************************/
516 smb_ucs2_t *strstr_w(const smb_ucs2_t *s, const smb_ucs2_t *ins)
521 if (!s || !*s || !ins || !*ins) {
525 inslen = strlen_w(ins);
528 while ((r = strchr_w(r, *ins))) {
529 if (strncmp_w(r, ins, inslen) == 0) {
538 /*******************************************************************
539 Convert a string to lower case.
540 return True if any char is converted
541 ********************************************************************/
543 BOOL strlower_w(smb_ucs2_t *s)
548 while (*(COPY_UCS2_CHAR(&cp,s))) {
549 smb_ucs2_t v = tolower_w(cp);
551 COPY_UCS2_CHAR(s,&v);
559 /*******************************************************************
560 Convert a string to upper case.
561 return True if any char is converted
562 ********************************************************************/
564 BOOL strupper_w(smb_ucs2_t *s)
568 while (*(COPY_UCS2_CHAR(&cp,s))) {
569 smb_ucs2_t v = toupper_w(cp);
571 COPY_UCS2_CHAR(s,&v);
579 /*******************************************************************
580 Convert a string to "normal" form.
581 ********************************************************************/
583 void strnorm_w(smb_ucs2_t *s, int case_default)
585 if (case_default == CASE_UPPER) {
592 int strcmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
596 while ((*(COPY_UCS2_CHAR(&cpb,b))) && (*(COPY_UCS2_CHAR(&cpa,a)) == cpb)) {
600 return (*(COPY_UCS2_CHAR(&cpa,a)) - *(COPY_UCS2_CHAR(&cpb,b)));
601 /* warning: if *a != *b and both are not 0 we return a random
602 greater or lesser than 0 number not realted to which
606 int strncmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
611 while ((n < len) && (*(COPY_UCS2_CHAR(&cpb,b))) && (*(COPY_UCS2_CHAR(&cpa,a)) == cpb)) {
616 return (len - n)?(*(COPY_UCS2_CHAR(&cpa,a)) - *(COPY_UCS2_CHAR(&cpb,b))):0;
619 /*******************************************************************
620 Case insensitive string comparison.
621 ********************************************************************/
623 int strcasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
627 while ((*COPY_UCS2_CHAR(&cpb,b)) && toupper_w(*(COPY_UCS2_CHAR(&cpa,a))) == toupper_w(cpb)) {
631 return (tolower_w(*(COPY_UCS2_CHAR(&cpa,a))) - tolower_w(*(COPY_UCS2_CHAR(&cpb,b))));
634 /*******************************************************************
635 Case insensitive string comparison, length limited.
636 ********************************************************************/
638 int strncasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
643 while ((n < len) && *COPY_UCS2_CHAR(&cpb,b) && (toupper_w(*(COPY_UCS2_CHAR(&cpa,a))) == toupper_w(cpb))) {
648 return (len - n)?(tolower_w(*(COPY_UCS2_CHAR(&cpa,a))) - tolower_w(*(COPY_UCS2_CHAR(&cpb,b)))):0;
651 /*******************************************************************
653 ********************************************************************/
655 BOOL strequal_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2)
664 return(strcasecmp_w(s1,s2)==0);
667 /*******************************************************************
668 Compare 2 strings up to and including the nth char.
669 ******************************************************************/
671 BOOL strnequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2,size_t n)
676 if (!s1 || !s2 || !n) {
680 return(strncasecmp_w(s1,s2,n)==0);
683 /*******************************************************************
685 ********************************************************************/
687 smb_ucs2_t *strdup_w(const smb_ucs2_t *src)
689 return strndup_w(src, 0);
692 /* if len == 0 then duplicate the whole string */
694 smb_ucs2_t *strndup_w(const smb_ucs2_t *src, size_t len)
701 dest = SMB_MALLOC_ARRAY(smb_ucs2_t, len + 1);
703 DEBUG(0,("strdup_w: out of memory!\n"));
707 memcpy(dest, src, len * sizeof(smb_ucs2_t));
712 /*******************************************************************
713 Copy a string with max len.
714 ********************************************************************/
716 smb_ucs2_t *strncpy_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
725 for (len = 0; (*COPY_UCS2_CHAR(&cp,(src+len))) && (len < max); len++) {
726 cp = *COPY_UCS2_CHAR(dest+len,src+len);
729 for ( /*nothing*/ ; len < max; len++ ) {
730 cp = *COPY_UCS2_CHAR(dest+len,&cp);
736 /*******************************************************************
737 Append a string of len bytes and add a terminator.
738 ********************************************************************/
740 smb_ucs2_t *strncat_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
750 start = strlen_w(dest);
751 len = strnlen_w(src, max);
753 memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));
754 z = *COPY_UCS2_CHAR(dest+start+len,&z);
759 smb_ucs2_t *strcat_w(smb_ucs2_t *dest, const smb_ucs2_t *src)
769 start = strlen_w(dest);
772 memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));
773 z = *COPY_UCS2_CHAR(dest+start+len,&z);
779 /*******************************************************************
780 Replace any occurence of oldc with newc in unicode string.
781 ********************************************************************/
783 void string_replace_w(smb_ucs2_t *s, smb_ucs2_t oldc, smb_ucs2_t newc)
787 for(;*(COPY_UCS2_CHAR(&cp,s));s++) {
789 COPY_UCS2_CHAR(s,&newc);
794 /*******************************************************************
796 ********************************************************************/
798 BOOL trim_string_w(smb_ucs2_t *s, const smb_ucs2_t *front,
799 const smb_ucs2_t *back)
802 size_t len, front_len, back_len;
810 if (front && *front) {
811 front_len = strlen_w(front);
812 while (len && strncmp_w(s, front, front_len) == 0) {
813 memmove(s, (s + front_len), (len - front_len + 1) * sizeof(smb_ucs2_t));
820 back_len = strlen_w(back);
821 while (len && strncmp_w((s + (len - back_len)), back, back_len) == 0) {
822 s[len - back_len] = 0;
832 The *_wa() functions take a combination of 7 bit ascii
833 and wide characters They are used so that you can use string
834 functions combining C string constants with ucs2 strings
836 The char* arguments must NOT be multibyte - to be completely sure
837 of this only pass string constants */
839 int strcmp_wa(const smb_ucs2_t *a, const char *b)
843 while (*b && *(COPY_UCS2_CHAR(&cp,a)) == UCS2_CHAR(*b)) {
847 return (*(COPY_UCS2_CHAR(&cp,a)) - UCS2_CHAR(*b));
850 int strncmp_wa(const smb_ucs2_t *a, const char *b, size_t len)
855 while ((n < len) && *b && *(COPY_UCS2_CHAR(&cp,a)) == UCS2_CHAR(*b)) {
860 return (len - n)?(*(COPY_UCS2_CHAR(&cp,a)) - UCS2_CHAR(*b)):0;
863 smb_ucs2_t *strpbrk_wa(const smb_ucs2_t *s, const char *p)
867 while (*(COPY_UCS2_CHAR(&cp,s))) {
869 for (i=0; p[i] && cp != UCS2_CHAR(p[i]); i++)
872 return (smb_ucs2_t *)s;
879 smb_ucs2_t *strstr_wa(const smb_ucs2_t *s, const char *ins)
888 inslen = strlen(ins);
891 while ((r = strchr_w(r, UCS2_CHAR(*ins)))) {
892 if (strncmp_wa(r, ins, inslen) == 0)
900 BOOL trim_string_wa(smb_ucs2_t *s, const char *front,
906 push_ucs2(NULL, f, front, sizeof(wpstring) - 1, STR_TERMINATE);
911 push_ucs2(NULL, b, back, sizeof(wpstring) - 1, STR_TERMINATE);
915 return trim_string_w(s, f, b);
918 /*******************************************************************
919 Returns the length in number of wide characters.
920 ******************************************************************/
922 int unistrlen(uint16 *s)
930 for (len=0; SVAL(s,0); s++,len++) {
937 /*******************************************************************
938 Strcpy for unicode strings. Returns length (in num of wide chars).
940 ********************************************************************/
942 int unistrcpy(uint16 *dst, uint16 *src)
946 while (SVAL(src,0)) {
956 * Samba ucs2 type to UNISTR2 conversion
958 * @param ctx Talloc context to create the dst strcture (if null) and the
959 * contents of the unicode string.
960 * @param dst UNISTR2 destination. If equals null, then it's allocated.
961 * @param src smb_ucs2_t source.
962 * @param max_len maximum number of unicode characters to copy. If equals
963 * null, then null-termination of src is taken
965 * @return copied UNISTR2 destination
968 UNISTR2* ucs2_to_unistr2(TALLOC_CTX *ctx, UNISTR2* dst, smb_ucs2_t* src)
978 /* allocate UNISTR2 destination if not given */
980 dst = TALLOC_P(ctx, UNISTR2);
985 dst->buffer = TALLOC_ARRAY(ctx, uint16, len + 1);
990 /* set UNISTR2 parameters */
991 dst->uni_max_len = len + 1;
993 dst->uni_str_len = len;
995 /* copy the actual unicode string */
996 strncpy_w(dst->buffer, src, dst->uni_max_len);