lib/util/util_str_common.c

   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 _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         if (psz1 == psz2)
  36                 return (0);
  37         else if (psz1 == NULL)
  38                 return (-1);
  39         else if (psz2 == NULL)
  40                 return (1);
  41
  42         /* sync the strings on first non-whitespace */
  43         while (1) {
  44                 while (isspace((int)*psz1))
  45                         psz1++;
  46                 while (isspace((int)*psz2))
  47                         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                 if (toupper_m((unsigned char)*psz1) != toupper_m((unsigned char)*psz2)
  55                     || *psz1 == '\0'
  56                     || *psz2 == '\0')
  57                         break;
  58                 psz1++;
  59                 psz2++;
  60         }
  61         return (*psz1 - *psz2);
  62 }
  63
  64 /**
  65  String replace.
  66  NOTE: oldc and newc must be 7 bit characters
  67 **/
  68 void string_replace( char *s, char oldc, char newc )
  69 {
  70         while (*s != '\0') {
  71                 size_t c_size;
  72                 next_codepoint(s, &c_size);
  73
  74                 if (c_size == 1) {
  75                         if (*s == oldc) {
  76                                 *s = newc;
  77                         }
  78                 }
  79                 s += c_size;
  80         }
  81 }
  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 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         if (!dest) {
 101                 smb_panic("ERROR: NULL dest in alpha_strcpy");
 102         }
 103
 104         if (!src) {
 105                 *dest = 0;
 106                 return dest;
 107         }
 108
 109         len = strlen(src);
 110         if (len >= maxlength)
 111                 len = maxlength - 1;
 112
 113         if (!other_safe_chars)
 114                 other_safe_chars = "";
 115
 116         for(i = 0; i < len; i++) {
 117                 int val = (src[i] & 0xff);
 118                 if (val > 0x7f) {
 119                         dest[i] = '_';
 120                         continue;
 121                 }
 122                 if (isupper(val) || islower(val) ||
 123                                 isdigit(val) || strchr(other_safe_chars, val))
 124                         dest[i] = src[i];
 125                 else
 126                         dest[i] = '_';
 127         }
 128
 129         dest[i] = '\0';
 130
 131         return dest;
 132 }
 133
 134 char *talloc_alpha_strcpy(TALLOC_CTX *mem_ctx,
 135                           const char *src,
 136                           const char *other_safe_chars)
 137 {
 138         char *dest = NULL;
 139         size_t slen;
 140
 141         if (src == NULL) {
 142                 return NULL;
 143         }
 144
 145         slen = strlen(src);
 146
 147         dest = talloc_zero_size(mem_ctx, slen + 1);
 148         if (dest == NULL) {
 149                 return NULL;
 150         }
 151
 152         alpha_strcpy(dest, src, other_safe_chars, slen + 1);
 153         return dest;
 154 }