diff options
Diffstat (limited to 'source4/lib')
| -rw-r--r-- | source4/lib/system.c | 171 | ||||
| -rw-r--r-- | source4/lib/util_unistr.c | 390 | ||||
| -rw-r--r-- | source4/lib/util_uuid.c | 31 |
3 files changed, 11 insertions, 581 deletions
diff --git a/source4/lib/system.c b/source4/lib/system.c index f79386eed1..98d975aa50 100644 --- a/source4/lib/system.c +++ b/source4/lib/system.c @@ -699,177 +699,6 @@ struct group *sys_getgrgid(gid_t gid) return getgrgid(gid); } -#if 0 /* NOT CURRENTLY USED - JRA */ -/************************************************************************** - The following are the UNICODE versions of *all* system interface functions - called within Samba. Ok, ok, the exceptions are the gethostbyXX calls, - which currently are left as ascii as they are not used other than in name - resolution. -****************************************************************************/ - -/************************************************************************** - Wide stat. Just narrow and call sys_xxx. -****************************************************************************/ - -int wsys_stat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf) -{ - pstring fname; - return sys_stat(unicode_to_unix(fname,wfname,sizeof(fname)), sbuf); -} - -/************************************************************************** - Wide lstat. Just narrow and call sys_xxx. -****************************************************************************/ - -int wsys_lstat(const smb_ucs2_t *wfname,SMB_STRUCT_STAT *sbuf) -{ - pstring fname; - return sys_lstat(unicode_to_unix(fname,wfname,sizeof(fname)), sbuf); -} - -/************************************************************************** - Wide creat. Just narrow and call sys_xxx. -****************************************************************************/ - -int wsys_creat(const smb_ucs2_t *wfname, mode_t mode) -{ - pstring fname; - return sys_creat(unicode_to_unix(fname,wfname,sizeof(fname)), mode); -} - -/************************************************************************** - Wide open. Just narrow and call sys_xxx. -****************************************************************************/ - -int wsys_open(const smb_ucs2_t *wfname, int oflag, mode_t mode) -{ - pstring fname; - return sys_open(unicode_to_unix(fname,wfname,sizeof(fname)), oflag, mode); -} - -/************************************************************************** - Wide fopen. Just narrow and call sys_xxx. -****************************************************************************/ - -FILE *wsys_fopen(const smb_ucs2_t *wfname, const char *type) -{ - pstring fname; - return sys_fopen(unicode_to_unix(fname,wfname,sizeof(fname)), type); -} - -/************************************************************************** - Wide opendir. Just narrow and call sys_xxx. -****************************************************************************/ - -DIR *wsys_opendir(const smb_ucs2_t *wfname) -{ - pstring fname; - return opendir(unicode_to_unix(fname,wfname,sizeof(fname))); -} - -/************************************************************************** - Wide readdir. Return a structure pointer containing a wide filename. -****************************************************************************/ - -SMB_STRUCT_WDIRENT *wsys_readdir(DIR *dirp) -{ - static SMB_STRUCT_WDIRENT retval; - SMB_STRUCT_DIRENT *dirval = sys_readdir(dirp); - - if(!dirval) - return NULL; - - /* - * The only POSIX defined member of this struct is d_name. - */ - - unix_to_unicode(retval.d_name,dirval->d_name,sizeof(retval.d_name)); - - return &retval; -} - -/************************************************************************** - Wide getwd. Call sys_xxx and widen. Assumes s points to a wpstring. -****************************************************************************/ - -smb_ucs2_t *wsys_getwd(smb_ucs2_t *s) -{ - pstring fname; - char *p = sys_getwd(fname); - - if(!p) - return NULL; - - return unix_to_unicode(s, p, sizeof(wpstring)); -} - -/************************************************************************** - Wide chown. Just narrow and call sys_xxx. -****************************************************************************/ - -int wsys_chown(const smb_ucs2_t *wfname, uid_t uid, gid_t gid) -{ - pstring fname; - return chown(unicode_to_unix(fname,wfname,sizeof(fname)), uid, gid); -} - -/************************************************************************** - Wide chroot. Just narrow and call sys_xxx. -****************************************************************************/ - -int wsys_chroot(const smb_ucs2_t *wfname) -{ - pstring fname; - return chroot(unicode_to_unix(fname,wfname,sizeof(fname))); -} - -/************************************************************************** - Wide getpwnam. Return a structure pointer containing wide names. -****************************************************************************/ - -SMB_STRUCT_WPASSWD *wsys_getpwnam(const smb_ucs2_t *wname) -{ - static SMB_STRUCT_WPASSWD retval; - fstring name; - struct passwd *pwret = sys_getpwnam(unicode_to_unix(name,wname,sizeof(name))); - - if(!pwret) - return NULL; - - unix_to_unicode(retval.pw_name, pwret->pw_name, sizeof(retval.pw_name)); - retval.pw_passwd = pwret->pw_passwd; - retval.pw_uid = pwret->pw_uid; - retval.pw_gid = pwret->pw_gid; - unix_to_unicode(retval.pw_gecos, pwret->pw_gecos, sizeof(retval.pw_gecos)); - unix_to_unicode(retval.pw_dir, pwret->pw_dir, sizeof(retval.pw_dir)); - unix_to_unicode(retval.pw_shell, pwret->pw_shell, sizeof(retval.pw_shell)); - - return &retval; -} - -/************************************************************************** - Wide getpwuid. Return a structure pointer containing wide names. -****************************************************************************/ - -SMB_STRUCT_WPASSWD *wsys_getpwuid(uid_t uid) -{ - static SMB_STRUCT_WPASSWD retval; - struct passwd *pwret = sys_getpwuid(uid); - - if(!pwret) - return NULL; - - unix_to_unicode(retval.pw_name, pwret->pw_name, sizeof(retval.pw_name)); - retval.pw_passwd = pwret->pw_passwd; - retval.pw_uid = pwret->pw_uid; - retval.pw_gid = pwret->pw_gid; - unix_to_unicode(retval.pw_gecos, pwret->pw_gecos, sizeof(retval.pw_gecos)); - unix_to_unicode(retval.pw_dir, pwret->pw_dir, sizeof(retval.pw_dir)); - unix_to_unicode(retval.pw_shell, pwret->pw_shell, sizeof(retval.pw_shell)); - - return &retval; -} -#endif /* NOT CURRENTLY USED - JRA */ /************************************************************************** Extract a command into an arg list. Uses a static pstring for storage. diff --git a/source4/lib/util_unistr.c b/source4/lib/util_unistr.c index 3ab04eda1f..3e3430d147 100644 --- a/source4/lib/util_unistr.c +++ b/source4/lib/util_unistr.c @@ -21,10 +21,6 @@ #include "includes.h" -#ifndef MAXUNI -#define MAXUNI 1024 -#endif - /* these 3 tables define the unicode case handling. They are loaded at startup either via mmap() or read() from the lib directory */ static smb_ucs2_t *upcase_table; @@ -162,74 +158,10 @@ void init_valid_table(void) } - -/******************************************************************* - Write a string in (little-endian) unicode format. src is in - the current DOS codepage. len is the length in bytes of the - string pointed to by dst. - - if null_terminate is True then null terminate the packet (adds 2 bytes) - - the return value is the length in bytes consumed by the string, including the - null termination if applied -********************************************************************/ - -size_t dos_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminate) -{ - return push_ucs2(NULL, dst, src, len, - STR_UNICODE|STR_NOALIGN | (null_terminate?STR_TERMINATE:0)); -} - - -/******************************************************************* - Skip past a unicode string, but not more than len. Always move - past a terminating zero if found. -********************************************************************/ - -char *skip_unibuf(char *src, size_t len) -{ - char *srcend = src + len; - - while (src < srcend && SVAL(src,0)) - src += 2; - - if(!SVAL(src,0)) - src += 2; - - return src; -} - -/* Copy a string from little-endian or big-endian unicode source (depending - * on flags) to internal samba format destination - */ -int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags) -{ - if (!src) return 0; - if(dest_len==-1) dest_len=MAXUNI-3; - return pull_ucs2(NULL, dest, src, dest_len, src_len, flags|STR_UNICODE|STR_NOALIGN); -} - -/* Copy a string from a unistr2 source to internal samba format - destination. Use this instead of direct calls to rpcstr_pull() to avoid - having to determine whether the source string is null terminated. */ - -int rpcstr_pull_unistr2_fstring(char *dest, UNISTR2 *src) -{ - return pull_ucs2(NULL, dest, src->buffer, sizeof(fstring), - src->uni_str_len * 2, 0); -} - -/* Converts a string from internal samba format to unicode - */ -int rpcstr_push(void* dest, const char *src, int dest_len, int flags) -{ - return push_ucs2(NULL, dest, src, dest_len, flags|STR_UNICODE|STR_NOALIGN); -} - /******************************************************************* Convert a (little-endian) UNISTR2 structure to an ASCII string ********************************************************************/ -void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen) +static void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen) { if (str == NULL) { *dest='\0'; @@ -267,22 +199,10 @@ char *unistr2_tdup(TALLOC_CTX *ctx, const UNISTR2 *str) /******************************************************************* -Return a number stored in a buffer -********************************************************************/ - -uint32 buffer2_to_uint32(BUFFER2 *str) -{ - if (str->buf_len == 4) - return IVAL(str->buffer, 0); - else - return 0; -} - -/******************************************************************* Convert a wchar to upper case. ********************************************************************/ -smb_ucs2_t toupper_w(smb_ucs2_t val) +static smb_ucs2_t toupper_w(smb_ucs2_t val) { return upcase_table[SVAL(&val,0)]; } @@ -291,7 +211,7 @@ smb_ucs2_t toupper_w(smb_ucs2_t val) Convert a wchar to lower case. ********************************************************************/ -smb_ucs2_t tolower_w( smb_ucs2_t val ) +static smb_ucs2_t tolower_w( smb_ucs2_t val ) { return lowcase_table[SVAL(&val,0)]; @@ -315,14 +235,6 @@ BOOL isupper_w(smb_ucs2_t c) /******************************************************************* -determine if a character is valid in a 8.3 name -********************************************************************/ -BOOL isvalid83_w(smb_ucs2_t c) -{ - return valid_table[SVAL(&c,0)] != 0; -} - -/******************************************************************* Count the number of characters in a smb_ucs2_t string. ********************************************************************/ size_t strlen_w(const smb_ucs2_t *src) @@ -377,6 +289,14 @@ const smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c) return NULL; } +static int strncmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len) +{ + size_t n = 0; + while ((n < len) && *b && *a == *b) { a++; b++; n++;} + return (len - n)?(*a - *b):0; +} + + /******************************************************************* wide strstr() ********************************************************************/ @@ -431,22 +351,6 @@ BOOL strupper_w(smb_ucs2_t *s) return ret; } -int strcmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b) -{ - while (*b && *a == *b) { a++; b++; } - return (*a - *b); - /* warning: if *a != *b and both are not 0 we retrun a random - greater or lesser than 0 number not realted to which - string is longer */ -} - -int strncmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len) -{ - size_t n = 0; - while ((n < len) && *b && *a == *b) { a++; b++; n++;} - return (len - n)?(*a - *b):0; -} - /******************************************************************* case insensitive string comparison ********************************************************************/ @@ -457,64 +361,6 @@ int strcasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b) } /******************************************************************* -case insensitive string comparison, lenght limited -********************************************************************/ -int strncasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len) -{ - size_t n = 0; - while ((n < len) && *b && (toupper_w(*a) == toupper_w(*b))) { a++; b++; n++; } - return (len - n)?(tolower_w(*a) - tolower_w(*b)):0; -} - -/******************************************************************* - compare 2 strings -********************************************************************/ -BOOL strequal_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2) -{ - if (s1 == s2) return(True); - if (!s1 || !s2) return(False); - - return(strcasecmp_w(s1,s2)==0); -} - -/******************************************************************* - compare 2 strings up to and including the nth char. - ******************************************************************/ -BOOL strnequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2,size_t n) -{ - if (s1 == s2) return(True); - if (!s1 || !s2 || !n) return(False); - - return(strncasecmp_w(s1,s2,n)==0); -} - -/******************************************************************* -duplicate string -********************************************************************/ -smb_ucs2_t *strdup_w(const smb_ucs2_t *src) -{ - return strndup_w(src, 0); -} - -/* if len == 0 then duplicate the whole string */ -smb_ucs2_t *strndup_w(const smb_ucs2_t *src, size_t len) -{ - smb_ucs2_t *dest; - - if (!len) len = strlen_w(src); - dest = (smb_ucs2_t *)malloc((len + 1) * sizeof(smb_ucs2_t)); - if (!dest) { - DEBUG(0,("strdup_w: out of memory!\n")); - return NULL; - } - - memcpy(dest, src, len * sizeof(smb_ucs2_t)); - dest[len] = 0; - - return dest; -} - -/******************************************************************* copy a string with max len ********************************************************************/ @@ -534,43 +380,6 @@ smb_ucs2_t *strncpy_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max) /******************************************************************* -append a string of len bytes and add a terminator -********************************************************************/ - -smb_ucs2_t *strncat_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max) -{ - size_t start; - size_t len; - - if (!dest || !src) return NULL; - - start = strlen_w(dest); - len = strnlen_w(src, max); - - memcpy(&dest[start], src, len*sizeof(smb_ucs2_t)); - dest[start+len] = 0; - - return dest; -} - -smb_ucs2_t *strcat_w(smb_ucs2_t *dest, const smb_ucs2_t *src) -{ - size_t start; - size_t len; - - if (!dest || !src) return NULL; - - start = strlen_w(dest); - len = strlen_w(src); - - memcpy(&dest[start], src, len*sizeof(smb_ucs2_t)); - dest[start+len] = 0; - - return dest; -} - - -/******************************************************************* replace any occurence of oldc with newc in unicode string ********************************************************************/ @@ -581,40 +390,6 @@ void string_replace_w(smb_ucs2_t *s, smb_ucs2_t oldc, smb_ucs2_t newc) } } -/******************************************************************* -trim unicode string -********************************************************************/ - -BOOL trim_string_w(smb_ucs2_t *s, const smb_ucs2_t *front, - const smb_ucs2_t *back) -{ - BOOL ret = False; - size_t len, front_len, back_len; - - if (!s || !*s) return False; - - len = strlen_w(s); - - if (front && *front) { - front_len = strlen_w(front); - while (len && strncmp_w(s, front, front_len) == 0) { - memmove(s, (s + front_len), (len - front_len + 1) * sizeof(smb_ucs2_t)); - len -= front_len; - ret = True; - } - } - - if (back && *back) { - back_len = strlen_w(back); - while (len && strncmp_w((s + (len - back_len)), back, back_len) == 0) { - s[len - back_len] = 0; - len -= back_len; - ret = True; - } - } - - return ret; -} /* The *_wa() functions take a combination of 7 bit ascii @@ -640,13 +415,6 @@ int strcmp_wa(const smb_ucs2_t *a, const char *b) return (*a - UCS2_CHAR(*b)); } -int strncmp_wa(const smb_ucs2_t *a, const char *b, size_t len) -{ - size_t n = 0; - while ((n < len) && *b && *a == UCS2_CHAR(*b)) { a++; b++; n++;} - return (len - n)?(*a - UCS2_CHAR(*b)):0; -} - const smb_ucs2_t *strpbrk_wa(const smb_ucs2_t *s, const char *p) { while (*s != 0) { @@ -659,139 +427,3 @@ const smb_ucs2_t *strpbrk_wa(const smb_ucs2_t *s, const char *p) return NULL; } -const smb_ucs2_t *strstr_wa(const smb_ucs2_t *s, const char *ins) -{ - const smb_ucs2_t *r; - size_t inslen; - - if (!s || !*s || !ins || !*ins) return NULL; - inslen = strlen(ins); - r = s; - while ((r = strchr_w(r, UCS2_CHAR(*ins)))) { - if (strncmp_wa(r, ins, inslen) == 0) return r; - r++; - } - return NULL; -} - -/******************************************************************* -copy a string with max len -********************************************************************/ - -smb_ucs2_t *strncpy_wa(smb_ucs2_t *dest, const char *src, const size_t max) -{ - smb_ucs2_t *ucs2_src; - - if (!dest || !src) return NULL; - if (!(ucs2_src = acnv_uxu2(src))) - return NULL; - - strncpy_w(dest, ucs2_src, max); - SAFE_FREE(ucs2_src); - return dest; -} - -/******************************************************************* -convert and duplicate an ascii string -********************************************************************/ -smb_ucs2_t *strdup_wa(const char *src) -{ - return strndup_wa(src, 0); -} - -/* if len == 0 then duplicate the whole string */ -smb_ucs2_t *strndup_wa(const char *src, size_t len) -{ - smb_ucs2_t *dest, *s; - - s = acnv_dosu2(src); - if (!len) len = strlen_w(s); - dest = (smb_ucs2_t *)malloc((len + 1) * sizeof(smb_ucs2_t)); - if (!dest) { - DEBUG(0,("strdup_w: out of memory!\n")); - SAFE_FREE(s); - return NULL; - } - - memcpy(dest, src, len * sizeof(smb_ucs2_t)); - dest[len] = 0; - - SAFE_FREE(s); - return dest; -} - -/******************************************************************* -append a string of len bytes and add a terminator -********************************************************************/ - -smb_ucs2_t *strncat_wa(smb_ucs2_t *dest, const char *src, const size_t max) -{ - smb_ucs2_t *ucs2_src; - - if (!dest || !src) return NULL; - if (!(ucs2_src = acnv_uxu2(src))) - return NULL; - - strncat_w(dest, ucs2_src, max); - SAFE_FREE(ucs2_src); - return dest; -} - -smb_ucs2_t *strcat_wa(smb_ucs2_t *dest, const char *src) -{ - smb_ucs2_t *ucs2_src; - - if (!dest || !src) return NULL; - if (!(ucs2_src = acnv_uxu2(src))) - return NULL; - - strcat_w(dest, ucs2_src); - SAFE_FREE(ucs2_src); - return dest; -} - -BOOL trim_string_wa(smb_ucs2_t *s, const char *front, - const char *back) -{ - wpstring f, b; - - if (front) push_ucs2(NULL, f, front, sizeof(wpstring) - 1, STR_TERMINATE); - else *f = 0; - if (back) push_ucs2(NULL, b, back, sizeof(wpstring) - 1, STR_TERMINATE); - else *b = 0; - return trim_string_w(s, f, b); -} - -/******************************************************************* - returns the length in number of wide characters - ******************************************************************/ -int unistrlen(uint16 *s) -{ - int len; - - if (!s) - return -1; - - for (len=0; *s; s++,len++); - - return len; -} - -/******************************************************************* - Strcpy for unicode strings. returns length (in num of wide chars) -********************************************************************/ - -int unistrcpy(uint16 *dst, uint16 *src) -{ - int num_wchars = 0; - - while (*src) { - *dst++ = *src++; - num_wchars++; - } - *dst = 0; - - return num_wchars; -} - - diff --git a/source4/lib/util_uuid.c b/source4/lib/util_uuid.c index 25b51af6ba..1b8c7572c7 100644 --- a/source4/lib/util_uuid.c +++ b/source4/lib/util_uuid.c @@ -70,34 +70,3 @@ void uuid_generate_random(GUID *out) uu.time_hi_and_version = (uu.time_hi_and_version & 0x0FFF) | 0x4000; uuid_pack(&uu, out); } - -char *guid_to_string(const GUID in) -{ - struct uuid uu; - char *out; - - uuid_unpack(in, &uu); - - asprintf(&out, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", - uu.time_low, uu.time_mid, uu.time_hi_and_version, - uu.clock_seq[0], uu.clock_seq[1], - uu.node[0], uu.node[1], uu.node[2], - uu.node[3], uu.node[4], uu.node[5]); - - return out; -} - -const char *uuid_string(TALLOC_CTX *mem_ctx, const GUID in) -{ - struct uuid uu; - char *out; - - uuid_unpack(in, &uu); - out = talloc_asprintf(mem_ctx, - "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", - uu.time_low, uu.time_mid, uu.time_hi_and_version, - uu.clock_seq[0], uu.clock_seq[1], - uu.node[0], uu.node[1], uu.node[2], - uu.node[3], uu.node[4], uu.node[5]); - return out; -} |