Convert a string to "normal" form.
**/
-void strnorm(char *s, int case_default)
+bool strnorm(char *s, int case_default)
{
if (case_default == CASE_UPPER)
- strupper_m(s);
+ return strupper_m(s);
else
- strlower_m(s);
+ return strlower_m(s);
}
/**
if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_UTF16LE, src, srclen,
(void **)(void *)&buffer, &size))
{
- smb_panic("failed to create UCS2 buffer");
+ return false;
}
if (!strlower_w(buffer) && (dest == src)) {
TALLOC_FREE(buffer);
- return srclen;
+ return true;
}
ret = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, &size);
TALLOC_FREE(buffer);
Convert a string to lower case.
**/
-void strlower_m(char *s)
+bool strlower_m(char *s)
{
size_t len;
int errno_save;
+ bool ret = false;
/* this is quite a common operation, so we want it to be
fast. We optimise for the ascii case, knowing that all our
}
if (!*s)
- return;
+ return true;
/* I assume that lowercased string takes the same number of bytes
* as source string even in UTF-8 encoding. (VIV) */
len = strlen(s) + 1;
errno_save = errno;
errno = 0;
- unix_strlower(s,len,s,len);
+ ret = unix_strlower(s,len,s,len);
/* Catch mb conversion errors that may not terminate. */
- if (errno)
+ if (errno) {
s[len-1] = '\0';
+ }
errno = errno_save;
+ return ret;
}
static bool unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen)
bool ret;
if (!push_ucs2_talloc(talloc_tos(), &buffer, src, &size)) {
- return (size_t)-1;
+ return false;
}
if (!strupper_w(buffer) && (dest == src)) {
TALLOC_FREE(buffer);
- return srclen;
+ return true;
}
ret = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, &size);
Convert a string to upper case.
**/
-void strupper_m(char *s)
+bool strupper_m(char *s)
{
size_t len;
- int errno_save;
+ bool ret = false;
/* this is quite a common operation, so we want it to be
fast. We optimise for the ascii case, knowing that all our
}
if (!*s)
- return;
+ return true;
/* I assume that lowercased string takes the same number of bytes
* as source string even in multibyte encoding. (VIV) */
len = strlen(s) + 1;
- errno_save = errno;
- errno = 0;
- unix_strupper(s,len,s,len);
+ ret = unix_strupper(s,len,s,len);
/* Catch mb conversion errors that may not terminate. */
- if (errno)
+ if (!ret) {
s[len-1] = '\0';
- errno = errno_save;
+ }
+ return ret;
}
/**
while (*p && isspace(*p))
p++;
- sscanf(p,"%"PRIu64,&val);
+ sscanf(p,"%"SCNu64,&val);
if (entptr) {
while (*p && isdigit(*p))
p++;
if (ret == -1)
return -1;
- strupper_m(result);
+ if (!strupper_m(result)) {
+ SAFE_FREE(result);
+ return -1;
+ }
+
*strp = result;
return ret;
}
if (ret == NULL) {
return NULL;
}
- strupper_m(ret);
+ if (!strupper_m(ret)) {
+ TALLOC_FREE(ret);
+ return NULL;
+ }
return ret;
}
if (ret == NULL) {
return NULL;
}
- strlower_m(ret);
+ if (!strlower_m(ret)) {
+ TALLOC_FREE(ret);
+ return NULL;
+ }
return ret;
}
return ret;
}
-/***************************************************
- str_list_make, v3 version. The v4 version does not
- look at quoted strings with embedded blanks, so
- do NOT merge this function please!
-***************************************************/
-
-#define S_LIST_ABS 16 /* List Allocation Block Size */
+/*
+ * This routine improves performance for operations temporarily acting on a
+ * full path. It is equivalent to the much more expensive
+ *
+ * talloc_asprintf(talloc_tos(), "%s/%s", dir, name)
+ *
+ * This actually does make a difference in metadata-heavy workloads (i.e. the
+ * "standard" client.txt nbench run.
+ */
-char **str_list_make_v3(TALLOC_CTX *mem_ctx, const char *string,
- const char *sep)
+ssize_t full_path_tos(const char *dir, const char *name,
+ char *tmpbuf, size_t tmpbuf_len,
+ char **pdst, char **to_free)
{
- char **list;
- const char *str;
- char *s, *tok;
- int num, lsize;
-
- if (!string || !*string)
- return NULL;
-
- list = talloc_array(mem_ctx, char *, S_LIST_ABS+1);
- if (list == NULL) {
- return NULL;
- }
- lsize = S_LIST_ABS;
-
- s = talloc_strdup(list, string);
- if (s == NULL) {
- DEBUG(0,("str_list_make: Unable to allocate memory"));
- TALLOC_FREE(list);
- return NULL;
- }
- if (!sep) sep = LIST_SEP;
-
- num = 0;
- str = s;
-
- while (next_token_talloc(list, &str, &tok, sep)) {
+ size_t dirlen, namelen, len;
+ char *dst;
- if (num == lsize) {
- char **tmp;
+ dirlen = strlen(dir);
+ namelen = strlen(name);
+ len = dirlen + namelen + 1;
- lsize += S_LIST_ABS;
-
- tmp = talloc_realloc(mem_ctx, list, char *,
- lsize + 1);
- if (tmp == NULL) {
- DEBUG(0,("str_list_make: "
- "Unable to allocate memory"));
- TALLOC_FREE(list);
- return NULL;
- }
-
- list = tmp;
-
- memset (&list[num], 0,
- ((sizeof(char**)) * (S_LIST_ABS +1)));
+ if (len < tmpbuf_len) {
+ dst = tmpbuf;
+ *to_free = NULL;
+ } else {
+ dst = talloc_array(talloc_tos(), char, len+1);
+ if (dst == NULL) {
+ return -1;
}
-
- list[num] = tok;
- num += 1;
+ *to_free = dst;
}
- list[num] = NULL;
-
- TALLOC_FREE(s);
- return list;
+ memcpy(dst, dir, dirlen);
+ dst[dirlen] = '/';
+ memcpy(dst+dirlen+1, name, namelen+1);
+ *pdst = dst;
+ return len;
}
git.samba.org / samba.git / blobdiff