Line data    Source code

       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             :    Samba utility functions
       4             : 
       5             :    Copyright (C) Andrew Tridgell 1992-2001
       6             :    Copyright (C) Simo Sorce      2001-2002
       7             :    Copyright (C) Martin Pool     2003
       8             :    Copyright (C) James Peach     2005
       9             : 
      10             :    This program is free software; you can redistribute it and/or modify
      11             :    it under the terms of the GNU General Public License as published by
      12             :    the Free Software Foundation; either version 3 of the License, or
      13             :    (at your option) any later version.
      14             : 
      15             :    This program is distributed in the hope that it will be useful,
      16             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      17             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      18             :    GNU General Public License for more details.
      19             : 
      20             :    You should have received a copy of the GNU General Public License
      21             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      22             : */
      23             : 
      24             : #include "replace.h"
      25             : #include "system/locale.h"
      26             : #include "lib/util/samba_util.h"
      27             : 
      28             : /**
      29             : Do a case-insensitive, whitespace-ignoring ASCII string compare.
      30             : **/
      31  1865506487 : _PUBLIC_ int strwicmp(const char *psz1, const char *psz2)
      32             : {
      33             :         /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
      34             :         /* appropriate value. */
      35  1865506487 :         if (psz1 == psz2)
      36         608 :                 return (0);
      37  1865505879 :         else if (psz1 == NULL)
      38           0 :                 return (-1);
      39  1865505879 :         else if (psz2 == NULL)
      40           0 :                 return (1);
      41             : 
      42             :         /* sync the strings on first non-whitespace */
      43             :         while (1) {
      44  4217127975 :                 while (isspace((int)*psz1))
      45    24756755 :                         psz1++;
      46  3947448169 :                 while (isspace((int)*psz2))
      47    24000830 :                         psz2++;
      48             : 
      49             :                 /*
      50             :                  * This does not do a genuine multi-byte comparison,
      51             :                  * instead it just uses the fast-path for ASCII in
      52             :                  * these common routines
      53             :                  */
      54  2193442829 :                 if (toupper_m((unsigned char)*psz1) != toupper_m((unsigned char)*psz2)
      55   335149447 :                     || *psz1 == '\0'
      56   327936950 :                     || *psz2 == '\0')
      57             :                         break;
      58   327936950 :                 psz1++;
      59   327936950 :                 psz2++;
      60             :         }
      61  1865505879 :         return (*psz1 - *psz2);
      62             : }
      63             : 
      64             : /**
      65             :  String replace.
      66             :  NOTE: oldc and newc must be 7 bit characters
      67             : **/
      68       32576 : void string_replace( char *s, char oldc, char newc )
      69             : {
      70     1939600 :         while (*s != '\0') {
      71             :                 size_t c_size;
      72     1885926 :                 next_codepoint(s, &c_size);
      73             : 
      74     1885926 :                 if (c_size == 1) {
      75     1885926 :                         if (*s == oldc) {
      76      224732 :                                 *s = newc;
      77             :                         }
      78             :                 }
      79     1885926 :                 s += c_size;
      80             :         }
      81       32576 : }
      82             : 
      83             : 
      84             : /**
      85             :  Paranoid strcpy into a buffer of given length (includes terminating
      86             :  zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
      87             :  and replaces with '_'. Deliberately does *NOT* check for multibyte
      88             :  characters. Treats src as an array of bytes, not as a multibyte
      89             :  string. Any byte >0x7f is automatically converted to '_'.
      90             :  other_safe_chars must also contain an ascii string (bytes<0x7f).
      91             : **/
      92             : 
      93       13744 : char *alpha_strcpy(char *dest,
      94             :                    const char *src,
      95             :                    const char *other_safe_chars,
      96             :                    size_t maxlength)
      97             : {
      98             :         size_t len, i;
      99             : 
     100       13744 :         if (!dest) {
     101           0 :                 smb_panic("ERROR: NULL dest in alpha_strcpy");
     102             :         }
     103             : 
     104       13744 :         if (!src) {
     105           0 :                 *dest = 0;
     106           0 :                 return dest;
     107             :         }
     108             : 
     109       13744 :         len = strlen(src);
     110       13744 :         if (len >= maxlength)
     111           0 :                 len = maxlength - 1;
     112             : 
     113       13744 :         if (!other_safe_chars)
     114           0 :                 other_safe_chars = "";
     115             : 
     116      155173 :         for(i = 0; i < len; i++) {
     117      141429 :                 int val = (src[i] & 0xff);
     118      141429 :                 if (val > 0x7f) {
     119           0 :                         dest[i] = '_';
     120           0 :                         continue;
     121             :                 }
     122      183278 :                 if (isupper(val) || islower(val) ||
     123       72567 :                                 isdigit(val) || strchr(other_safe_chars, val))
     124      140863 :                         dest[i] = src[i];
     125             :                 else
     126         566 :                         dest[i] = '_';
     127             :         }
     128             : 
     129       13744 :         dest[i] = '\0';
     130             : 
     131       13744 :         return dest;
     132             : }
     133             : 
     134        7033 : char *talloc_alpha_strcpy(TALLOC_CTX *mem_ctx,
     135             :                           const char *src,
     136             :                           const char *other_safe_chars)
     137             : {
     138        7033 :         char *dest = NULL;
     139             :         size_t slen;
     140             : 
     141        7033 :         if (src == NULL) {
     142           0 :                 return NULL;
     143             :         }
     144             : 
     145        7033 :         slen = strlen(src);
     146             : 
     147        7033 :         dest = talloc_zero_size(mem_ctx, slen + 1);
     148        7033 :         if (dest == NULL) {
     149           0 :                 return NULL;
     150             :         }
     151             : 
     152        7033 :         alpha_strcpy(dest, src, other_safe_chars, slen + 1);
     153        7033 :         return dest;
     154             : }