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 "includes.h"
  25
  26 /**
  27 Do a case-insensitive, whitespace-ignoring string compare.
  28 **/
  29 _PUBLIC_ int strwicmp(const char *psz1, const char *psz2)
  30 {
  31         /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
  32         /* appropriate value. */
  33         if (psz1 == psz2)
  34                 return (0);
  35         else if (psz1 == NULL)
  36                 return (-1);
  37         else if (psz2 == NULL)
  38                 return (1);
  39
  40         /* sync the strings on first non-whitespace */
  41         while (1) {
  42                 while (isspace((int)*psz1))
  43                         psz1++;
  44                 while (isspace((int)*psz2))
  45                         psz2++;
  46                 if (toupper_m((unsigned char)*psz1) != toupper_m((unsigned char)*psz2)
  47                     || *psz1 == '\0'
  48                     || *psz2 == '\0')
  49                         break;
  50                 psz1++;
  51                 psz2++;
  52         }
  53         return (*psz1 - *psz2);
  54 }
  55
  56 _PUBLIC_ size_t ucs2_align(const void *base_ptr, const void *p, int flags)
  57 {
  58         if (flags & (STR_NOALIGN|STR_ASCII))
  59                 return 0;
  60         return PTR_DIFF(p, base_ptr) & 1;
  61 }
  62
  63 /**
  64  String replace.
  65  NOTE: oldc and newc must be 7 bit characters
  66 **/
  67 void string_replace( char *s, char oldc, char newc )
  68 {
  69         char *p;
  70
  71         /* this is quite a common operation, so we want it to be
  72            fast. We optimise for the ascii case, knowing that all our
  73            supported multi-byte character sets are ascii-compatible
  74            (ie. they match for the first 128 chars) */
  75
  76         for (p = s; *p; p++) {
  77                 if (*p & 0x80) /* mb string - slow path. */
  78                         break;
  79                 if (*p == oldc) {
  80                         *p = newc;
  81                 }
  82         }
  83
  84         if (!*p)
  85                 return;
  86
  87         /* Slow (mb) path. */
  88 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
  89         /* With compose characters we must restart from the beginning. JRA. */
  90         p = s;
  91 #endif
  92
  93         while (*p) {
  94                 size_t c_size;
  95                 next_codepoint(p, &c_size);
  96
  97                 if (c_size == 1) {
  98                         if (*p == oldc) {
  99                                 *p = newc;
 100                         }
 101                 }
 102                 p += c_size;
 103         }
 104 }
 105
 106
 107 /**
 108  Paranoid strcpy into a buffer of given length (includes terminating
 109  zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
 110  and replaces with '_'. Deliberately does *NOT* check for multibyte
 111  characters. Treats src as an array of bytes, not as a multibyte
 112  string. Any byte >0x7f is automatically converted to '_'.
 113  other_safe_chars must also contain an ascii string (bytes<0x7f).
 114 **/
 115
 116 char *alpha_strcpy(char *dest,
 117                    const char *src,
 118                    const char *other_safe_chars,
 119                    size_t maxlength)
 120 {
 121         size_t len, i;
 122
 123         if (!dest) {
 124                 smb_panic("ERROR: NULL dest in alpha_strcpy");
 125         }
 126
 127         if (!src) {
 128                 *dest = 0;
 129                 return dest;
 130         }
 131
 132         len = strlen(src);
 133         if (len >= maxlength)
 134                 len = maxlength - 1;
 135
 136         if (!other_safe_chars)
 137                 other_safe_chars = "";
 138
 139         for(i = 0; i < len; i++) {
 140                 int val = (src[i] & 0xff);
 141                 if (val > 0x7f) {
 142                         dest[i] = '_';
 143                         continue;
 144                 }
 145                 if (isupper(val) || islower(val) ||
 146                                 isdigit(val) || strchr(other_safe_chars, val))
 147                         dest[i] = src[i];
 148                 else
 149                         dest[i] = '_';
 150         }
 151
 152         dest[i] = '\0';
 153
 154         return dest;
 155 }