"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "src/lib/strfuncs.c" between
dovecot-2.3.16.tar.gz and dovecot-2.3.17.tar.gz

About: Dovecot is an IMAP and POP3 server, written with security primarily in mind.

strfuncs.c  (dovecot-2.3.16)	:	strfuncs.c  (dovecot-2.3.17)
skipping to change at line 90		skipping to change at line 90
size = (size_t) ((const char *) end - (const char *) start);		size = (size_t) ((const char *) end - (const char *) start);
mem = p_malloc(pool, size + 1);		mem = p_malloc(pool, size + 1);
memcpy(mem, start, size);		memcpy(mem, start, size);
return mem;		return mem;
}		}
char *p_strndup(pool_t pool, const void *str, size_t max_chars)		char *p_strndup(pool_t pool, const void *str, size_t max_chars)
{		{
		const char *p;
char *mem;		char *mem;
size_t len;		size_t len;
i_assert(str != NULL);		i_assert(str != NULL);
i_assert(max_chars != SIZE_MAX);		i_assert(max_chars != SIZE_MAX);
len = 0;		p = memchr(str, '\0', max_chars);
while (len < max_chars && ((const char *) str)[len] != '\0')		if (p == NULL)
len++;		len = max_chars;
		else
		len = p - (const char *)str;
mem = p_malloc(pool, len+1);		mem = p_malloc(pool, len+1);
memcpy(mem, str, len);		memcpy(mem, str, len);
mem[len] = '\0';
return mem;		return mem;
}		}
char *p_strdup_printf(pool_t pool, const char *format, ...)		char *p_strdup_printf(pool_t pool, const char *format, ...)
{		{
va_list args;		va_list args;
char *ret;		char *ret;
va_start(args, format);		va_start(args, format);
ret = p_strdup_vprintf(pool, format, args);		ret = p_strdup_vprintf(pool, format, args);
skipping to change at line 232		skipping to change at line 234
} else {		} else {
temp = vstrconcat(str1, args, &len);		temp = vstrconcat(str1, args, &len);
ret = p_malloc(pool, len);		ret = p_malloc(pool, len);
memcpy(ret, temp, len);		memcpy(ret, temp, len);
}		}
va_end(args);		va_end(args);
return ret;		return ret;
}		}
		static void *t_memdup(const void *data, size_t size)
		{
		void *mem = t_malloc_no0(size);
		memcpy(mem, data, size);
		return mem;
		}
const char *t_strdup(const char *str)		const char *t_strdup(const char *str)
{		{
return p_strdup(unsafe_data_stack_pool, str);		return t_strdup_noconst(str);
}		}
char *t_strdup_noconst(const char *str)		char *t_strdup_noconst(const char *str)
{		{
return p_strdup(unsafe_data_stack_pool, str);		if (str == NULL)
		return NULL;
		return t_memdup(str, strlen(str) + 1);
}		}
const char *t_strdup_empty(const char *str)		const char *t_strdup_empty(const char *str)
{		{
return p_strdup_empty(unsafe_data_stack_pool, str);		if (str == NULL || *str == '\0')
		return NULL;
		return t_strdup(str);
}		}
const char *t_strdup_until(const void *start, const void *end)		const char *t_strdup_until(const void *start, const void *end)
{		{
return p_strdup_until(unsafe_data_stack_pool, start, end);		char *mem;
		size_t size;
		i_assert((const char *) start <= (const char *) end);
		size = (size_t)((const char *)end - (const char *)start);
		mem = t_malloc_no0(size + 1);
		memcpy(mem, start, size);
		mem[size] = '\0';
		return mem;
}		}
const char *t_strndup(const void *str, size_t max_chars)		const char *t_strndup(const void *str, size_t max_chars)
{		{
i_assert(str != NULL);		i_assert(str != NULL);
return p_strndup(unsafe_data_stack_pool, str, max_chars);		return p_strndup(unsafe_data_stack_pool, str, max_chars);
}		}
const char *t_strdup_printf(const char *format, ...)		const char *t_strdup_printf(const char *format, ...)
{		{
skipping to change at line 612		skipping to change at line 636
str_match(const char *p1, const char *p2)		str_match(const char *p1, const char *p2)
{		{
size_t i = 0;		size_t i = 0;
while(p1[i] != '\0' && p1[i] == p2[i])		while(p1[i] != '\0' && p1[i] == p2[i])
i++;		i++;
return i;		return i;
}		}
		size_t i_memspn(const void *data, size_t data_len,
		const void *accept, size_t accept_len)
		{
		const unsigned char *start = data;
		i_assert(data != NULL || data_len == 0);
		i_assert(accept != NULL || accept_len == 0);
		size_t pos = 0;
		/* nothing to accept */
		if (accept_len == 0)
		return 0;
		for (; pos < data_len; pos++) {
		if (memchr(accept, start[pos], accept_len) == NULL)
		break;
		}
		return pos;
		}
		size_t i_memcspn(const void *data, size_t data_len,
		const void *reject, size_t reject_len)
		{
		const unsigned char *start = data;
		const unsigned char *r = reject;
		const unsigned char *ptr = CONST_PTR_OFFSET(data, data_len);
		i_assert(data != NULL || data_len == 0);
		i_assert(reject != NULL || reject_len == 0);
		/* nothing to reject */
		if (reject_len == 0 || data_len == 0)
		return data_len;
		/* Doing repeated memchr's over the data is faster than
		going over it once byte by byte, as long as reject
		is reasonably short. */
		for (size_t i = 0; i < reject_len; i++) {
		const unsigned char *kand =
		memchr(start, r[i], data_len);
		if (kand != NULL && kand < ptr)
		ptr = kand;
		}
		return ptr - start;
		}
static char **		static char **
split_str_slow(pool_t pool, const char *data, const char *separators, bool space s)		split_str_slow(pool_t pool, const char *data, const char *separators, bool space s)
{		{
char **array;		char **array;
char *str;		char *str;
unsigned int count, alloc_count, new_alloc_count;		unsigned int count, alloc_count, new_alloc_count;
if (spaces) {		if (spaces) {
/* skip leading separators */		/* skip leading separators */
while (*data != '\0' && strchr(separators, *data) != NULL)		while (*data != '\0' && strchr(separators, *data) != NULL)
End of changes. 9 change blocks.
8 lines changed or deleted		72 lines changed or added

---