/**
Do a case-insensitive, whitespace-ignoring string compare.
**/
_PUBLIC_ int strwicmp(const char *psz1, const char *psz2)
{
/* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
/* appropriate value. */
if (psz1 == psz2)
return (0);
else if (psz1 == NULL)
return (-1);
else if (psz2 == NULL)
return (1);
/* sync the strings on first non-whitespace */
while (1) {
while (isspace((int)*psz1))
psz1++;
while (isspace((int)*psz2))
psz2++;
if (toupper_ascii((unsigned char)*psz1) != toupper_ascii((unsigned char)*psz2)
|| *psz1 == '\0'
|| *psz2 == '\0')
break;
psz1++;
psz2++;
}
return (*psz1 - *psz2);
}
void
sanei_init_debug (const char * backend, int * var)
{
char ch, buf[256] = "SANE_DEBUG_";
const char * val;
unsigned int i;
*var = 0;
for (i = 11; (ch = backend[i - 11]) != 0; ++i)
{
if (i >= sizeof (buf) - 1)
break;
buf[i] = toupper_ascii(ch);
}
buf[i] = '\0';
val = getenv (buf);
if (!val)
return;
*var = atoi (val);
DBG (0, "Setting debug level of %s to %d.\n", backend, *var);
}
/* ************************************************************************** **
* Return True if the name *could be* a mangled name.
*
* Input: s - A path name - in UNIX pathname format.
*
* Output: True if the name matches the pattern described below in the
* notes, else False.
*
* Notes: The input name is *not* tested for 8.3 compliance. This must be
* done separately. This function returns true if the name contains
* a magic character followed by excactly two characters from the
* basechars list (above), which in turn are followed either by the
* nul (end of string) byte or a dot (extension) or by a '/' (end of
* a directory name).
*
* ************************************************************************** **
*/
static BOOL is_mangled(const char *s, int snum)
{
char *magic;
magic_char = lp_magicchar(snum);
if( !ct_initialized )
init_chartest();
magic = strchr_m( s, magic_char );
while( magic && magic[1] && magic[2] ) { /* 3 chars, 1st is magic. */
if( ('.' == magic[3] || '/' == magic[3] || !(magic[3])) /* Ends with '.' or nul or '/' ? */
&& isbasechar( toupper_ascii(magic[1]) ) /* is 2nd char basechar? */
&& isbasechar( toupper_ascii(magic[2]) ) ) /* is 3rd char basechar? */
return( True ); /* If all above, then true, */
magic = strchr_m( magic+1, magic_char ); /* else seek next magic. */
}
return( False );
}
static bool is_mangled(const char *s, const struct share_params *p)
{
char *magic;
char magic_char;
magic_char = lp_magicchar(p);
if (chartest == NULL) {
init_chartest();
}
magic = strchr_m( s, magic_char );
while( magic && magic[1] && magic[2] ) { /* 3 chars, 1st is magic. */
if( ('.' == magic[3] || '/' == magic[3] || !(magic[3])) /* Ends with '.' or nul or '/' ? */
&& isbasechar( toupper_ascii(magic[1]) ) /* is 2nd char basechar? */
&& isbasechar( toupper_ascii(magic[2]) ) ) /* is 3rd char basechar? */
return( True ); /* If all above, then true, */
magic = strchr_m( magic+1, magic_char ); /* else seek next magic. */
}
return( False );
}
char *strdup_upper(const char *s)
{
pstring out_buffer;
const unsigned char *p = (const unsigned char *)s;
unsigned char *q = (unsigned char *)out_buffer;
/* this is quite a common operation, so we want it to be
fast. We optimise for the ascii case, knowing that all our
supported multi-byte character sets are ascii-compatible
(ie. they match for the first 128 chars) */
while (1) {
if (*p & 0x80)
break;
*q++ = toupper_ascii(*p);
if (!*p)
break;
p++;
if (p - ( const unsigned char *)s >= sizeof(pstring))
break;
}
if (*p) {
/* MB case. */
size_t size;
wpstring buffer;
size = convert_string(CH_UNIX, CH_UTF16LE, s, -1, buffer, sizeof(buffer), True);
if (size == (size_t)-1) {
return NULL;
}
strupper_w(buffer);
size = convert_string(CH_UTF16LE, CH_UNIX, buffer, -1, out_buffer, sizeof(out_buffer), True);
if (size == (size_t)-1) {
return NULL;
}
}
return SMB_STRDUP(out_buffer);
}
