15263807472

/* SPDX-License-Identifier: LGPL-2.1-or-later */

/*
 * Concatenates/copies strings. In any case, terminates in all cases
 * with '\0' and moves the @dest pointer forward to the added '\0'.
 * Returns the remaining size, and 0 if the string was truncated.
 *
 * Due to the intended usage, these helpers silently noop invocations
 * having zero size.  This is technically an exception to the above
 * statement "terminates in all cases".  It's unexpected for such calls to
 * occur outside of a loop where this is the preferred behavior.
 */

#include <stdio.h>
#include <string.h>

#include "strxcpyx.h"

size_t strnpcpy_full(char **dest, size_t size, const char *src, size_t len, bool *ret_truncated) {
        bool truncated = false;

        assert(dest);
        assert(src);

        if (size == 0) {
                if (ret_truncated)
                        *ret_truncated = len > 0;
                return 0;
        }

        if (len >= size) {
                if (size > 1)
                        *dest = mempcpy(*dest, src, size-1);
                size = 0;
                truncated = true;
        } else if (len > 0) {
                *dest = mempcpy(*dest, src, len);
                size -= len;
        }

        if (ret_truncated)
                *ret_truncated = truncated;

        *dest[0] = '\0';
        return size;
}

size_t strpcpy_full(char **dest, size_t size, const char *src, bool *ret_truncated) {
        assert(dest);
        assert(src);

        return strnpcpy_full(dest, size, src, strlen(src), ret_truncated);
}

size_t strpcpyf_full(char **dest, size_t size, bool *ret_truncated, const char *src, ...) {
        bool truncated = false;
        va_list va;
        int i;

        assert(dest);
        assert(src);

        va_start(va, src);
        i = vsnprintf(*dest, size, src, va);
        va_end(va);

        if (i < (int) size) {
                *dest += i;
                size -= i;
        } else {
                size = 0;
                truncated = i > 0;
        }

        if (ret_truncated)
                *ret_truncated = truncated;

        return size;
}

size_t strpcpyl_full(char **dest, size_t size, bool *ret_truncated, const char *src, ...) {
        bool truncated = false;
        va_list va;

        assert(dest);
        assert(src);

        va_start(va, src);
        do {
                bool t;

                size = strpcpy_full(dest, size, src, &t);
                truncated = truncated || t;
                src = va_arg(va, char *);
        } while (src);
        va_end(va);

        if (ret_truncated)
                *ret_truncated = truncated;
        return size;
}

size_t strnscpy_full(char *dest, size_t size, const char *src, size_t len, bool *ret_truncated) {
        char *s;

        assert(dest);
        assert(src);

        s = dest;
        return strnpcpy_full(&s, size, src, len, ret_truncated);
}

size_t strscpy_full(char *dest, size_t size, const char *src, bool *ret_truncated) {
        assert(dest);
        assert(src);

        return strnscpy_full(dest, size, src, strlen(src), ret_truncated);
}

size_t strscpyl_full(char *dest, size_t size, bool *ret_truncated, const char *src, ...) {
        bool truncated = false;
        va_list va;
        char *s;

        assert(dest);
        assert(src);

        va_start(va, src);
        s = dest;
        do {
                bool t;

                size = strpcpy_full(&s, size, src, &t);
                truncated = truncated || t;
                src = va_arg(va, char *);
        } while (src);
        va_end(va);

        if (ret_truncated)
                *ret_truncated = truncated;

        return size;
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	/*
4	* Concatenates/copies strings. In any case, terminates in all cases
5	* with '\0' and moves the @dest pointer forward to the added '\0'.
6	* Returns the remaining size, and 0 if the string was truncated.
7	*
8	* Due to the intended usage, these helpers silently noop invocations
9	* having zero size. This is technically an exception to the above
10	* statement "terminates in all cases". It's unexpected for such calls to
11	* occur outside of a loop where this is the preferred behavior.
12	*/
13
14	#include <stdio.h>
15	#include <string.h>
16
17	#include "strxcpyx.h"
18
19	size_t strnpcpy_full(char *dest, size_t size, const char src, size_t len, bool *ret_truncated) {	8,041,803✔
20	bool truncated = false;	8,041,803✔
21
22	assert(dest);	8,041,803✔
23	assert(src);	8,041,803✔
24
25	if (size == 0) {	8,041,803✔
26	if (ret_truncated)	4✔
27	*ret_truncated = len > 0;	4✔
28	return 0;	4✔
29	}
30
31	if (len >= size) {	8,041,799✔
32	if (size > 1)	2✔
UNCOV 33	dest = mempcpy(dest, src, size-1);	×
34	size = 0;
35	truncated = true;
36	} else if (len > 0) {	8,041,797✔
37	dest = mempcpy(dest, src, len);	8,025,053✔
38	size -= len;	8,025,053✔
39	}
40
41	if (ret_truncated)	8,041,799✔
42	*ret_truncated = truncated;	7,666,117✔
43
44	*dest[0] = '\0';	8,041,799✔
45	return size;	8,041,799✔
46	}
47
48	size_t strpcpy_full(char *dest, size_t size, const char src, bool *ret_truncated) {	7,632,620✔
49	assert(dest);	7,632,620✔
50	assert(src);	7,632,620✔
51
52	return strnpcpy_full(dest, size, src, strlen(src), ret_truncated);	7,632,620✔
53	}
54
55	size_t strpcpyf_full(char *dest, size_t size, bool ret_truncated, const char *src, ...) {	27,198✔
56	bool truncated = false;	27,198✔
57	va_list va;	27,198✔
58	int i;	27,198✔
59
60	assert(dest);	27,198✔
61	assert(src);	27,198✔
62
63	va_start(va, src);	27,198✔
64	i = vsnprintf(*dest, size, src, va);	27,198✔
65	va_end(va);	27,198✔
66
67	if (i < (int) size) {	27,198✔
68	*dest += i;	27,194✔
69	size -= i;	27,194✔
70	} else {
71	size = 0;	4✔
72	truncated = i > 0;	4✔
73	}
74
75	if (ret_truncated)	27,198✔
76	*ret_truncated = truncated;	27,098✔
77
78	return size;	27,198✔
79	}
80
81	size_t strpcpyl_full(char *dest, size_t size, bool ret_truncated, const char *src, ...) {	19✔
82	bool truncated = false;	19✔
83	va_list va;	19✔
84
85	assert(dest);	19✔
86	assert(src);	19✔
87
88	va_start(va, src);	19✔
89	do {	39✔
90	bool t;	39✔
91
92	size = strpcpy_full(dest, size, src, &t);	39✔
93	truncated = truncated \|\| t;	39✔
94	src = va_arg(va, char *);	39✔
95	} while (src);	39✔
96	va_end(va);	19✔
97
98	if (ret_truncated)	19✔
99	*ret_truncated = truncated;	19✔
100	return size;	19✔
101	}
102
103	size_t strnscpy_full(char dest, size_t size, const char src, size_t len, bool *ret_truncated) {	408,930✔
104	char *s;	408,930✔
105
106	assert(dest);	408,930✔
107	assert(src);	408,930✔
108
109	s = dest;	408,930✔
110	return strnpcpy_full(&s, size, src, len, ret_truncated);	408,930✔
111	}
112
113	size_t strscpy_full(char dest, size_t size, const char src, bool *ret_truncated) {	74,501✔
114	assert(dest);	74,501✔
115	assert(src);	74,501✔
116
117	return strnscpy_full(dest, size, src, strlen(src), ret_truncated);	74,501✔
118	}
119
120	size_t strscpyl_full(char dest, size_t size, bool ret_truncated, const char *src, ...) {	2,464,300✔
121	bool truncated = false;	2,464,300✔
122	va_list va;	2,464,300✔
123	char *s;	2,464,300✔
124
125	assert(dest);	2,464,300✔
126	assert(src);	2,464,300✔
127
128	va_start(va, src);	2,464,300✔
129	s = dest;	2,464,300✔
130	do {	7,314,583✔
131	bool t;	7,314,583✔
132
133	size = strpcpy_full(&s, size, src, &t);	7,314,583✔
134	truncated = truncated \|\| t;	7,314,583✔
135	src = va_arg(va, char *);	7,314,583✔
136	} while (src);	7,314,583✔
137	va_end(va);	2,464,300✔
138
139	if (ret_truncated)	2,464,300✔
140	*ret_truncated = truncated;	29,250✔
141
142	return size;	2,464,300✔
143	}

systemd / systemd / 15263807472

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous