C++ (Cpp) BUFerr Beispiele

Beispiel #1

Datei: buffer.c Projekt: SylvestreG/bitrig

int
BUF_MEM_grow(BUF_MEM *str, size_t len)
{
	char *ret;
	size_t n;

	if (str->length >= len) {
		str->length = len;
		return (len);
	}
	if (str->max >= len) {
		memset(&str->data[str->length], 0, len - str->length);
		str->length = len;
		return (len);
	}
	/* This limit is sufficient to ensure (len+3)/3*4 < 2**31 */
	if (len > LIMIT_BEFORE_EXPANSION) {
		BUFerr(BUF_F_BUF_MEM_GROW, ERR_R_MALLOC_FAILURE);
		return 0;
	}
	n = (len + 3) / 3 * 4;
	ret = realloc(str->data, n);
	if (ret == NULL) {
		BUFerr(BUF_F_BUF_MEM_GROW, ERR_R_MALLOC_FAILURE);
		len = 0;
	} else {
		str->data = ret;
		str->max = n;
		memset(&str->data[str->length], 0, len - str->length);
		str->length = len;
	}
	return (len);
}

Beispiel #2

Datei: buffer.c Projekt: Apple-FOSS-Mirror/Security

int BUF_MEM_grow(BUF_MEM *str, int len)
	{
	char *ret;
	unsigned int n;

	if (str->length >= len)
		{
		str->length=len;
		return(len);
		}
	if (str->max >= len)
		{
		memset(&str->data[str->length],0,len-str->length);
		str->length=len;
		return(len);
		}
	n=(len+3)/3*4;
	if (str->data == NULL)
		ret=Malloc(n);
	else
		ret=Realloc(str->data,n);
	if (ret == NULL)
		{
		BUFerr(BUF_F_BUF_MEM_GROW,ERR_R_MALLOC_FAILURE);
		len=0;
		}
	else
		{
		str->data=ret;
		str->length=len;
		str->max=n;
		}
	return(len);
	}

Beispiel #3

Datei: buf_str.c Projekt: awakecoding/libressl

char *
BUF_strndup(const char *str, size_t siz)
{
	char *ret = NULL;
	if (str != NULL) {
		if (!(ret = strndup(str, siz)))
			BUFerr(BUF_F_BUF_STRNDUP, ERR_R_MALLOC_FAILURE);
	}
	return ret;
}

Beispiel #4

Datei: buffer.c Projekt: 2007750219/openssl

BUF_MEM *BUF_MEM_new(void)
{
    BUF_MEM *ret;

    ret = OPENSSL_zalloc(sizeof(*ret));
    if (ret == NULL) {
        BUFerr(BUF_F_BUF_MEM_NEW, ERR_R_MALLOC_FAILURE);
        return (NULL);
    }
    return (ret);
}

Beispiel #5

Datei: buf_str.c Projekt: awakecoding/libressl

void *
BUF_memdup(const void *data, size_t siz)
{
	void *ret = NULL;
	if (data != NULL) {
		if (!(ret = malloc(siz)))
			BUFerr(BUF_F_BUF_MEMDUP, ERR_R_MALLOC_FAILURE);
		else
			(void) memcpy(ret, data, siz);
	}
	return ret;
}

Beispiel #6

Datei: buffer.c Projekt: SylvestreG/bitrig

int
BUF_MEM_grow_clean(BUF_MEM *str, size_t len)
{
	char *ret;
	size_t n;

	if (str->length >= len) {
		memset(&str->data[len], 0, str->length - len);
		str->length = len;
		return (len);
	}
	if (str->max >= len) {
		memset(&str->data[str->length], 0, len - str->length);
		str->length = len;
		return (len);
	}
	/* This limit is sufficient to ensure (len+3)/3*4 < 2**31 */
	if (len > LIMIT_BEFORE_EXPANSION) {
		BUFerr(BUF_F_BUF_MEM_GROW_CLEAN, ERR_R_MALLOC_FAILURE);
		return 0;
	}
	n = (len + 3) / 3 * 4;
	ret = malloc(n);
	/* we're not shrinking - that case returns above */
	if ((ret != NULL)  && (str->data != NULL)) {
		memcpy(ret, str->data, str->max);
		explicit_bzero(str->data, str->max);
		free(str->data);
	}
	if (ret == NULL) {
		BUFerr(BUF_F_BUF_MEM_GROW_CLEAN, ERR_R_MALLOC_FAILURE);
		len = 0;
	} else {
		str->data = ret;
		str->max = n;
		memset(&str->data[str->length], 0, len - str->length);
		str->length = len;
	}
	return (len);
}

Beispiel #7

Datei: buffer.c Projekt: GrayKing/Leakfix-on-OpenSSL

int BUF_MEM_grow_clean(BUF_MEM *str, int len)
{
    char *ret;
    unsigned int n;

    if (len < 0) {
        BUFerr(BUF_F_BUF_MEM_GROW_CLEAN, ERR_R_MALLOC_FAILURE);
        return 0;
    }
    if (str->length >= len) {
        memset(&str->data[len], 0, str->length - len);
        str->length = len;
        return (len);
    }
    if (str->max >= len) {
        memset(&str->data[str->length], 0, len - str->length);
        str->length = len;
        return (len);
    }
    /* This limit is sufficient to ensure (len+3)/3*4 < 2**31 */
    if (len > LIMIT_BEFORE_EXPANSION) {
        BUFerr(BUF_F_BUF_MEM_GROW_CLEAN, ERR_R_MALLOC_FAILURE);
        return 0;
    }
    n = (len + 3) / 3 * 4;
    if (str->data == NULL)
        ret = OPENSSL_malloc(n);
    else
        ret = OPENSSL_realloc_clean(str->data, str->max, n);
    if (ret == NULL) {
        BUFerr(BUF_F_BUF_MEM_GROW_CLEAN, ERR_R_MALLOC_FAILURE);
        len = 0;
    } else {
        str->data = ret;
        str->max = n;
        memset(&str->data[str->length], 0, len - str->length);
        str->length = len;
    }
    return (len);
}

Beispiel #8

Datei: buf_.c Projekt: PerfectlySoft/Perfect-OpenSSL

void *BUF_memdup(const void *data, size_t siz)
{
    void *ret;

    if (data == NULL || siz >= INT_MAX)
        return NULL;

    ret = OPENSSL_malloc(siz);
    if (ret == NULL) {
        BUFerr(BUF_F_BUF_MEMDUP, ERR_R_MALLOC_FAILURE);
        return NULL;
    }
    return memcpy(ret, data, siz);
}

Beispiel #9

Datei: buffer.c Projekt: 1Project/SafeBoardMessenger

BUF_MEM *BUF_MEM_new(void)
{
    BUF_MEM *ret;

    ret = OPENSSL_malloc(sizeof(BUF_MEM));
    if (ret == NULL) {
        BUFerr(BUF_F_BUF_MEM_NEW, ERR_R_MALLOC_FAILURE);
        return (NULL);
    }
    ret->length = 0;
    ret->max = 0;
    ret->data = NULL;
    return (ret);
}

Beispiel #10

Datei: buffer.c Projekt: 2007750219/openssl

size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len)
{
    char *ret;
    size_t n;

    if (str->length >= len) {
        if (str->data != NULL)
            memset(&str->data[len], 0, str->length - len);
        str->length = len;
        return (len);
    }
    if (str->max >= len) {
        memset(&str->data[str->length], 0, len - str->length);
        str->length = len;
        return (len);
    }
    /* This limit is sufficient to ensure (len+3)/3*4 < 2**31 */
    if (len > LIMIT_BEFORE_EXPANSION) {
        BUFerr(BUF_F_BUF_MEM_GROW_CLEAN, ERR_R_MALLOC_FAILURE);
        return 0;
    }
    n = (len + 3) / 3 * 4;
    if ((str->flags & BUF_MEM_FLAG_SECURE))
        ret = sec_alloc_realloc(str, n);
    else
        ret = OPENSSL_clear_realloc(str->data, str->max, n);
    if (ret == NULL) {
        BUFerr(BUF_F_BUF_MEM_GROW_CLEAN, ERR_R_MALLOC_FAILURE);
        len = 0;
    } else {
        str->data = ret;
        str->max = n;
        memset(&str->data[str->length], 0, len - str->length);
        str->length = len;
    }
    return (len);
}

Beispiel #11

Datei: buf_str.c Projekt: asgene/CryptoWrapperForCCode

char *BUF_strndup(const char *str, size_t siz)
	{
	char *ret;

	if (str == NULL) return(NULL);

	ret=OPENSSL_malloc(siz+1);
	if (ret == NULL) 
		{
		BUFerr(BUF_F_BUF_STRNDUP,ERR_R_MALLOC_FAILURE);
		return(NULL);
		}
	BUF_strlcpy(ret,str,siz+1);
	return(ret);
	}

Beispiel #12

Datei: buffer.c Projekt: Apple-FOSS-Mirror/Security

char *BUF_strdup(const char *str)
	{
	char *ret;
	int n;

	if (str == NULL) return(NULL);

	n=strlen(str);
	ret=Malloc(n+1);
	if (ret == NULL) 
		{
		BUFerr(BUF_F_BUF_STRDUP,ERR_R_MALLOC_FAILURE);
		return(NULL);
		}
	memcpy(ret,str,n+1);
	return(ret);
	}

Beispiel #13

Datei: buf_.c Projekt: PerfectlySoft/Perfect-OpenSSL

char *BUF_strndup(const char *str, size_t siz)
{
    char *ret;

    if (str == NULL)
        return NULL;

    siz = BUF_strnlen(str, siz);

    if (siz >= INT_MAX)
        return NULL;

    ret = OPENSSL_malloc(siz + 1);
    if (ret == NULL) {
        BUFerr(BUF_F_BUF_STRNDUP, ERR_R_MALLOC_FAILURE);
        return NULL;
    }

    memcpy(ret, str, siz);
    ret[siz] = '\0';

    return (ret);
}

Beispiel #14

Datei: buffer.c Projekt: CoryXie/BarrelfishOS

int BUF_MEM_grow_clean(BUF_MEM *str, size_t len)
	{
	char *ret;
	size_t n;

	if (str->length >= len)
		{
		memset(&str->data[len],0,str->length-len);
		str->length=len;
		return(len);
		}
	if (str->max >= len)
		{
		memset(&str->data[str->length],0,len-str->length);
		str->length=len;
		return(len);
		}
	n=(len+3)/3*4;
	if (str->data == NULL)
		ret=OPENSSL_malloc(n);
	else
		ret=OPENSSL_realloc_clean(str->data,str->max,n);
	if (ret == NULL)
		{
		BUFerr(BUF_F_BUF_MEM_GROW_CLEAN,ERR_R_MALLOC_FAILURE);
		len=0;
		}
	else
		{
		str->data=ret;
		str->max=n;
		memset(&str->data[str->length],0,len-str->length);
		str->length=len;
		}
	return(len);
	}