Changeset 77 for trunk/samba/source/lib/util_str.c

Timestamp:

Sep 30, 2007, 3:42:50 AM (18 years ago)

Author:

Paul Smedley

Message:

Update trunk to 3.2.0pre1

File:

• trunk/samba/source/lib/util_str.c (modified) (24 diffs)

trunk/samba/source/lib/util_str.c

@@ -7 +7 @@
    Copyright (C) Martin Pool     2003
    Copyright (C) James Peach     2006
+   Copyright (C) Jeremy Allison  1992-2007
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
@@ -19 +20 @@
    
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
@@ -126 +126 @@
         return ret;     
 }
-
-static uint16 tmpbuf[sizeof(pstring)];
 
 void set_first_token(char *ptr)
@@ -268 +266 @@
  Case insensitive string compararison, length limited.
 **/
-int StrnCaseCmp(const char *s, const char *t, size_t n)
-{
-        pstring buf1, buf2;
-        unix_strupper(s, strlen(s)+1, buf1, sizeof(buf1));
-        unix_strupper(t, strlen(t)+1, buf2, sizeof(buf2));
-        return strncmp(buf1,buf2,n);
+int StrnCaseCmp(const char *s, const char *t, size_t len)
+{
+        size_t n = 0;
+        const char *ps, *pt;
+        size_t size;
+        smb_ucs2_t *buffer_s, *buffer_t;
+        int ret;
+
+        for (ps = s, pt = t; n < len ; ps++, pt++, n++) {
+                char us, ut;
+
+                if (!*ps && !*pt)
+                        return 0; /* both ended */
+                else if (!*ps)
+                        return -1; /* s is a prefix */
+                else if (!*pt)
+                        return +1; /* t is a prefix */
+                else if ((*ps & 0x80) || (*pt & 0x80))
+                        /* not ascii anymore, do it the
+                         * hard way from here on in */
+                        break;
+
+                us = toupper_ascii(*ps);
+                ut = toupper_ascii(*pt);
+                if (us == ut)
+                        continue;
+                else if (us < ut)
+                        return -1;
+                else if (us > ut)
+                        return +1;
+        }
+
+        if (n == len) {
+                return 0;
+        }
+
+        size = push_ucs2_allocate(&buffer_s, ps);
+        if (size == (size_t)-1) {
+                return strncmp(ps, pt, len-n);
+                /* Not quite the right answer, but finding the right one
+                   under this failure case is expensive,
+                   and it's pretty close */
+        }
+
+        size = push_ucs2_allocate(&buffer_t, pt);
+        if (size == (size_t)-1) {
+                SAFE_FREE(buffer_s);
+                return strncmp(ps, pt, len-n);
+                /* Not quite the right answer, but finding the right one
+                   under this failure case is expensive,
+                   and it's pretty close */
+        }
+
+        ret = strncasecmp_w(buffer_s, buffer_t, len-n);
+        SAFE_FREE(buffer_s);
+        SAFE_FREE(buffer_t);
+        return ret;
 }
 
@@ -287 +336 @@
         if (!s1 || !s2)
                 return(False);
-  
+
         return(StrCaseCmp(s1,s2)==0);
 }
@@ -302 +351 @@
         if (!s1 || !s2 || !n)
                 return(False);
-  
+
         return(StrnCaseCmp(s1,s2,n)==0);
 }
@@ -357 +406 @@
 char *strupper_static(const char *s)
 {
-        static pstring str;
-
-        pstrcpy(str, s);
+        static char *str = NULL;
+
+        if (str) {
+                SAFE_FREE(str);
+        }
+        str = SMB_STRDUP(s);
+        if (!str) {
+                return CONST_DISCARD(char *,s);
+        }
         strupper_m(str);
-
         return str;
 }
@@ -385 +439 @@
         if (case_default == CASE_UPPER)
                 return(!strhaslower(s));
-        
+
         return(!strhasupper(s));
 }
@@ -394 +448 @@
  NOTE: oldc and newc must be 7 bit characters
 **/
-
-void string_replace( pstring s, char oldc, char newc )
+void string_replace( char *s, char oldc, char newc )
 {
         char *p;
@@ -407 +460 @@
                 if (*p & 0x80) /* mb string - slow path. */
                         break;
-                if (*p == oldc)
+                if (*p == oldc) {
                         *p = newc;
+                }
         }
 
@@ -419 +473 @@
         p = s;
 #endif
-        push_ucs2(NULL, tmpbuf, p, sizeof(tmpbuf), STR_TERMINATE);
-        string_replace_w(tmpbuf, UCS2_CHAR(oldc), UCS2_CHAR(newc));
-        pull_ucs2(NULL, p, tmpbuf, -1, sizeof(tmpbuf), STR_TERMINATE);
+
+        while (*p) {
+                size_t c_size;
+                next_codepoint(p, &c_size);
+
+                if (c_size == 1) {
+                        if (*p == oldc) {
+                                *p = newc;
+                        }
+                }
+                p += c_size;
+        }
 }
 
@@ -468 +531 @@
 size_t str_charnum(const char *s)
 {
-        uint16 tmpbuf2[sizeof(pstring)];
-        push_ucs2(NULL, tmpbuf2,s, sizeof(tmpbuf2), STR_TERMINATE);
-        return strlen_w(tmpbuf2);
+        size_t ret;
+        smb_ucs2_t *tmpbuf2 = NULL;
+        if (push_ucs2_allocate(&tmpbuf2, s) == (size_t)-1) {
+                return 0;
+        }
+        ret = strlen_w(tmpbuf2);
+        SAFE_FREE(tmpbuf2);
+        return ret;
 }
 
@@ -481 +549 @@
 size_t str_ascii_charnum(const char *s)
 {
-        pstring tmpbuf2;
-        push_ascii(tmpbuf2, s, sizeof(tmpbuf2), STR_TERMINATE);
-        return strlen(tmpbuf2);
+        size_t ret;
+        char *tmpbuf2 = NULL;
+        if (push_ascii_allocate(&tmpbuf2, s) == (size_t)-1) {
+                return 0;
+        }
+        ret = strlen(tmpbuf2);
+        SAFE_FREE(tmpbuf2);
+        return ret;
 }
 
@@ -585 +658 @@
 BOOL strhasupper(const char *s)
 {
-        smb_ucs2_t *ptr;
-        push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
-        for(ptr=tmpbuf;*ptr;ptr++)
-                if(isupper_w(*ptr))
-                        return True;
-        return(False);
+        smb_ucs2_t *tmp, *p;
+        BOOL ret;
+
+        if (push_ucs2_allocate(&tmp, s) == -1) {
+                return False;
+        }
+
+        for(p = tmp; *p != 0; p++) {
+                if(isupper_w(*p)) {
+                        break;
+                }
+        }
+
+        ret = (*p != 0);
+        SAFE_FREE(tmp);
+        return ret;
 }
 
@@ -599 +682 @@
 BOOL strhaslower(const char *s)
 {
-        smb_ucs2_t *ptr;
-        push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
-        for(ptr=tmpbuf;*ptr;ptr++)
-                if(islower_w(*ptr))
-                        return True;
-        return(False);
+        smb_ucs2_t *tmp, *p;
+        BOOL ret;
+
+        if (push_ucs2_allocate(&tmp, s) == -1) {
+                return False;
+        }
+
+        for(p = tmp; *p != 0; p++) {
+                if(islower_w(*p)) {
+                        break;
+                }
+        }
+
+        ret = (*p != 0);
+        SAFE_FREE(tmp);
+        return ret;
 }
 
@@ -891 +984 @@
 BOOL in_list(const char *s, const char *list, BOOL casesensitive)
 {
-        pstring tok;
+        char *tok;
         const char *p=list;
+        size_t bufsize = strlen(list);
+        BOOL ret = False;
 
         if (!list)
                 return(False);
 
-        while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
+        /* We know a token can't be larger
+         * than the entire list. */
+
+        tok = SMB_MALLOC_ARRAY(char, bufsize+1);
+        if (!tok) {
+                return False;
+        }
+
+        while (next_token(&p,tok,LIST_SEP,bufsize+1)) {
                 if (casesensitive) {
-                        if (strcmp(tok,s) == 0)
-                                return(True);
+                        if (strcmp(tok,s) == 0) {
+                                ret = True;
+                                break;
+                        }
                 } else {
-                        if (StrCaseCmp(tok,s) == 0)
-                                return(True);
-                }
-        }
-        return(False);
+                        if (StrCaseCmp(tok,s) == 0) {
+                                ret = True;
+                                break;
+                        }
+                }
+        }
+
+        SAFE_FREE(tok);
+        return ret;
 }
 
@@ -1354 +1463 @@
 char *strchr_m(const char *src, char c)
 {
-        wpstring ws;
-        pstring s2;
+        smb_ucs2_t *ws = NULL;
+        char *s2 = NULL;
         smb_ucs2_t *p;
         const char *s;
+        char *ret;
 
         /* characters below 0x3F are guaranteed to not appear in
@@ -1383 +1493 @@
 #endif
 
-        push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
+        if (push_ucs2_allocate(&ws, s)==(size_t)-1) {
+                /* Wrong answer, but what can we do... */
+                return strchr(src, c);
+        }
         p = strchr_w(ws, UCS2_CHAR(c));
-        if (!p)
-                return NULL;
+        if (!p) {
+                SAFE_FREE(ws);
+                return NULL;
+        }
         *p = 0;
-        pull_ucs2_pstring(s2, ws);
-        return (char *)(s+strlen(s2));
+        if (pull_ucs2_allocate(&s2, ws)==(size_t)-1) {
+                SAFE_FREE(ws);
+                /* Wrong answer, but what can we do... */
+                return strchr(src, c);
+        }
+        ret = (char *)(s+strlen(s2));
+        SAFE_FREE(ws);
+        SAFE_FREE(s2);
+        return ret;
 }
 
@@ -1435 +1557 @@
         /* String contained a non-ascii char. Slow path. */
         {
-                wpstring ws;
-                pstring s2;
+                smb_ucs2_t *ws = NULL;
+                char *s2 = NULL;
                 smb_ucs2_t *p;
-
-                push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
+                char *ret;
+
+                if (push_ucs2_allocate(&ws,s)==(size_t)-1) {
+                        /* Wrong answer, but what can we do. */
+                        return strrchr(s, c);
+                }
                 p = strrchr_w(ws, UCS2_CHAR(c));
-                if (!p)
+                if (!p) {
+                        SAFE_FREE(ws);
                         return NULL;
+                }
                 *p = 0;
-                pull_ucs2_pstring(s2, ws);
-                return (char *)(s+strlen(s2));
+                if (pull_ucs2_allocate(&s2,ws)==(size_t)-1) {
+                        SAFE_FREE(ws);
+                        /* Wrong answer, but what can we do. */
+                        return strrchr(s, c);
+                }
+                ret = (char *)(s+strlen(s2));
+                SAFE_FREE(ws);
+                SAFE_FREE(s2);
+                return ret;
         }
 }
@@ -1456 +1591 @@
 char *strnrchr_m(const char *s, char c, unsigned int n)
 {
-        wpstring ws;
-        pstring s2;
+        smb_ucs2_t *ws = NULL;
+        char *s2 = NULL;
         smb_ucs2_t *p;
-
-        push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
+        char *ret;
+
+        if (push_ucs2_allocate(&ws,s)==(size_t)-1) {
+                /* Too hard to try and get right. */
+                return NULL;
+        }
         p = strnrchr_w(ws, UCS2_CHAR(c), n);
-        if (!p)
-                return NULL;
+        if (!p) {
+                SAFE_FREE(ws);
+                return NULL;
+        }
         *p = 0;
-        pull_ucs2_pstring(s2, ws);
-        return (char *)(s+strlen(s2));
+        if (pull_ucs2_allocate(&s2,ws)==(size_t)-1) {
+                SAFE_FREE(ws);
+                /* Too hard to try and get right. */
+                return NULL;
+        }
+        ret = (char *)(s+strlen(s2));
+        SAFE_FREE(ws);
+        SAFE_FREE(s2);
+        return ret;
 }
 
@@ -1772 +1920 @@
         int num, lsize;
         pstring tok;
-        
+
         if (!string || !*string)
                 return NULL;
@@ -1785 +1933 @@
         }
         if (!sep) sep = LIST_SEP;
-        
+
         num = lsize = 0;
         list = NULL;
-        
+
         str = s;
-        while (next_token(&str, tok, sep, sizeof(tok))) {               
+        while (next_token(&str, tok, sep, sizeof(tok))) {
                 if (num == lsize) {
                         lsize += S_LIST_ABS;
@@ -1820 +1968 @@
                         list[num] = SMB_STRDUP(tok);
                 }
-                
+
                 if (!list[num]) {
                         DEBUG(0,("str_list_make: Unable to allocate memory"));
@@ -2629 +2777 @@
 {
         size_t srclen = strlen(src);
-        char *ret = SMB_MALLOC((srclen * 2) + 1);
+        char *ret = SMB_MALLOC_ARRAY(char, (srclen * 2) + 1);
         char *dest = ret;
         BOOL in_s_quote = False;