Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/ssh/lib/../xmalloc.c	Lines:	16	35	45.7 %
Date:	2017-11-13	Branches:	6	18	33.3 %


/* $OpenBSD: xmalloc.c,v 1.34 2017/05/31 09:15:42 deraadt Exp $ */
/*
 * Author: Tatu Ylonen <ylo@cs.hut.fi>
 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
 *                    All rights reserved
 * Versions of malloc and friends that check their results, and never return
 * failure (they call fatal if they encounter an error).
 *
 * As far as I am concerned, the code I have written for this software
 * can be used freely for any purpose.  Any derived versions of this
 * software must be clearly marked as such, and if the derived work is
 * incompatible with the protocol description in the RFC file, it must be
 * called by a name other than "ssh" or "Secure Shell".
 */

#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "xmalloc.h"
#include "log.h"

void
ssh_malloc_init(void)
{
	extern char *malloc_options;

	malloc_options = "S";
}

void *
xmalloc(size_t size)
{
	void *ptr;

	if (size == 0)
		fatal("xmalloc: zero size");
	ptr = malloc(size);
	if (ptr == NULL)
		fatal("xmalloc: out of memory (allocating %zu bytes)", size);
	return ptr;
}

void *
xcalloc(size_t nmemb, size_t size)
{
	void *ptr;

	if (size == 0 || nmemb == 0)
		fatal("xcalloc: zero size");
	if (SIZE_MAX / nmemb < size)
		fatal("xcalloc: nmemb * size > SIZE_MAX");
	ptr = calloc(nmemb, size);
	if (ptr == NULL)
		fatal("xcalloc: out of memory (allocating %zu bytes)",
		    size * nmemb);
	return ptr;
}

void *
xreallocarray(void *ptr, size_t nmemb, size_t size)
{
	void *new_ptr;

	new_ptr = reallocarray(ptr, nmemb, size);
	if (new_ptr == NULL)
		fatal("xreallocarray: out of memory (%zu elements of %zu bytes)",
		    nmemb, size);
	return new_ptr;
}

void *
xrecallocarray(void *ptr, size_t onmemb, size_t nmemb, size_t size)
{
	void *new_ptr;

	new_ptr = recallocarray(ptr, onmemb, nmemb, size);
	if (new_ptr == NULL)
		fatal("xrecallocarray: out of memory (%zu elements of %zu bytes)",
		    nmemb, size);
	return new_ptr;
}

char *
xstrdup(const char *str)
{
	size_t len;
	char *cp;

	len = strlen(str) + 1;
	cp = xmalloc(len);
	strlcpy(cp, str, len);
	return cp;
}

int
xasprintf(char **ret, const char *fmt, ...)
{
	va_list ap;
	int i;

	va_start(ap, fmt);
	i = vasprintf(ret, fmt, ap);
	va_end(ap);

	if (i < 0 || *ret == NULL)
		fatal("xasprintf: could not allocate memory");

	return (i);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: xmalloc.c,v 1.34 2017/05/31 09:15:42 deraadt Exp $ */
2			/*
3			* Author: Tatu Ylonen <ylo@cs.hut.fi>
4			* Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
5			* All rights reserved
6			* Versions of malloc and friends that check their results, and never return
7			* failure (they call fatal if they encounter an error).
8			*
9			* As far as I am concerned, the code I have written for this software
10			* can be used freely for any purpose. Any derived versions of this
11			* software must be clearly marked as such, and if the derived work is
12			* incompatible with the protocol description in the RFC file, it must be
13			* called by a name other than "ssh" or "Secure Shell".
14			*/
15
16			#include <stdarg.h>
17			#include <stdint.h>
18			#include <stdio.h>
19			#include <stdlib.h>
20			#include <string.h>
21
22			#include "xmalloc.h"
23			#include "log.h"
24
25			void
26			ssh_malloc_init(void)
27			{
28			extern char *malloc_options;
29
30			malloc_options = "S";
31			}
32
33			void *
34			xmalloc(size_t size)
35			{
36			void *ptr;
37
38	✗✓	28764	if (size == 0)
39			fatal("xmalloc: zero size");
40		14382	ptr = malloc(size);
41	✗✓	14382	if (ptr == NULL)
42			fatal("xmalloc: out of memory (allocating %zu bytes)", size);
43		14382	return ptr;
44			}
45
46			void *
47			xcalloc(size_t nmemb, size_t size)
48			{
49			void *ptr;
50
51	✗✓	10	if (size == 0 \|\| nmemb == 0)
52			fatal("xcalloc: zero size");
53	✗✓	5	if (SIZE_MAX / nmemb < size)
54			fatal("xcalloc: nmemb * size > SIZE_MAX");
55		5	ptr = calloc(nmemb, size);
56	✗✓	5	if (ptr == NULL)
57			fatal("xcalloc: out of memory (allocating %zu bytes)",
58			size * nmemb);
59		5	return ptr;
60			}
61
62			void *
63			xreallocarray(void *ptr, size_t nmemb, size_t size)
64			{
65			void *new_ptr;
66
67			new_ptr = reallocarray(ptr, nmemb, size);
68			if (new_ptr == NULL)
69			fatal("xreallocarray: out of memory (%zu elements of %zu bytes)",
70			nmemb, size);
71			return new_ptr;
72			}
73
74			void *
75			xrecallocarray(void *ptr, size_t onmemb, size_t nmemb, size_t size)
76			{
77			void *new_ptr;
78
79		60	new_ptr = recallocarray(ptr, onmemb, nmemb, size);
80	✗✓	30	if (new_ptr == NULL)
81			fatal("xrecallocarray: out of memory (%zu elements of %zu bytes)",
82			nmemb, size);
83		30	return new_ptr;
84			}
85
86			char *
87			xstrdup(const char *str)
88			{
89			size_t len;
90			char *cp;
91
92		28764	len = strlen(str) + 1;
93		14382	cp = xmalloc(len);
94		14382	strlcpy(cp, str, len);
95		14382	return cp;
96			}
97
98			int
99			xasprintf(char *ret, const char fmt, ...)
100			{
101			va_list ap;
102			int i;
103
104			va_start(ap, fmt);
105			i = vasprintf(ret, fmt, ap);
106			va_end(ap);
107
108			if (i < 0 \|\| *ret == NULL)
109			fatal("xasprintf: could not allocate memory");
110
111			return (i);
112			}