15155

pending completion

Build # 15155

Build Type

push

travis-ci

Committed by

locker

Commit Message

<a href="https://github.com/tarantool/tarantool/commit/<a class=hub.com/tarantool/tarantool/commit/36ab64812588d43d82ed70505a0079aef13f1a0a">36ab64812<a href="https://github.com/tarantool/tarantool/commit/36ab64812588d43d82ed70505a0079aef13f1a0a">&quot;&gt;vinyl: ignore unknown .run, .index and .vylog keys

Currently, if we encounter an unknown key while parsing a .run, .index,
or .vylog file we raise an error. As a result, if we add a new key to
either of those entities, we will break forward compatibility although
there&amp;#39;s actually no reason for that. To avoid that, let&amp;#39;s silently
ignore unknown keys, as we do in case of xrow header keys.

(cherry picked from commit </a><a class="double-link" href="https://github.com/tarantool/tarantool/commit/<a class="double-link" href="https://github.com/tarantool/tarantool/commit/7bd128ae62de561ce9f851985eeee03b8e10b1cb">7bd128ae6</a>">7bd128ae6</a><a href="https://github.com/tarantool/tarantool/commit/36ab64812588d43d82ed70505a0079aef13f1a0a">)

Run Details

6 of 6 new or added lines in 2 files covered. (100.0%)

41113 of 50016 relevant lines covered (82.2%)

844724.97 hits per line

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

50.68

/src/util.c

/*
 * Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * 1. Redistributions of source code must retain the above
 *    copyright notice, this list of conditions and the
 *    following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include "trivia/util.h"

#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/resource.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
#include <limits.h>

#include <msgpuck/msgpuck.h> /* mp_char2escape[] table */

#include "say.h"

/** Find a string in an array of strings.
 *
 * @param haystack  Array of strings. Either NULL
 *                  pointer terminated (for arrays of
 *                  unknown size) or of size hmax.
 * @param needle    string to look for
 * @param hmax      the index to use if nothing is found
 *                  also limits the size of the array
 * @return  string index or hmax if the string is not found.
 */
uint32_t
strindex(const char **haystack, const char *needle, uint32_t hmax)
{
        for (unsigned index = 0; index != hmax && haystack[index]; index++)
                if (strcasecmp(haystack[index], needle) == 0)
                        return index;
        return hmax;
}

/**
 * Same as strindex(), but with a specified length of @a needle.
 * Used, when @a needle is not 0 terminated.
 */
uint32_t
strnindex(const char **haystack, const char *needle, uint32_t len, uint32_t hmax)
{
        if (len == 0)
                return hmax;
        for (unsigned index = 0; index != hmax && haystack[index]; index++) {
                if (strncasecmp(haystack[index], needle, len) == 0 &&
                    strlen(haystack[index]) == len)
                        return index;
        }
        return hmax;
}

void
close_all_xcpt(int fdc, ...)
{
        unsigned keep[fdc];
        va_list ap;
        struct rlimit nofile;

        va_start(ap, fdc);
        for (int j = 0; j < fdc; j++) {
                keep[j] = va_arg(ap, unsigned);
        }
        va_end(ap);

        if (getrlimit(RLIMIT_NOFILE, &nofile) != 0)
                nofile.rlim_cur = 10000;

        for (unsigned i = 3; i < nofile.rlim_cur; i++) {
                bool found = false;
                for (int j = 0; j < fdc; j++) {
                        if (keep[j] == i) {
                                found = true;
                                break;
                        }
                }
                if (!found)
                        close(i);
        }
}

static int
itoa(int val, char *buf)
{
        char *p = buf;

        if (val < 0) {
                *p++ = '-';
                val = -val;
        }
        /* Print full range if it is an unsigned number. */
        unsigned uval = val;
        char *start = p;
        do {
                *p++ = '0' + uval % 10;
                uval /= 10;
        } while (uval > 0);

        int len = (int)(p - buf);

        *p-- = '\0';

        /* Reverse the resulting string. */
        do {
                char tmp = *p;
                *p = *start;
                *start = tmp;
        } while (++start < --p);

        return len;
}

/**
 * Async-signal-safe implementation of printf() into an fd, to be
 * able to write messages into the error log inside a signal
 * handler. Only supports %s and %d, %u, format specifiers.
 */
ssize_t
fdprintf(int fd, const char *format, ...)
{
        ssize_t total = 0;
        char buf[22];
        va_list args;
        va_start(args, format);

        while (*format) {
                const char *start = format;
                ssize_t len, res;
                if (*format++ != '%') {
                        while (*format != '\0' && *format != '%')
                                format++;
                        len = format - start;
                        goto out;
                }
                switch (*format++) {
                case '%':
                        len = 1;
                        break;
                case 's':
                        start = va_arg(args, char *);
                        if (start == NULL)
                                start = "(null)";
                        len = strlen(start);
                        break;
                case 'd':
                case 'u':
                        start = buf;
                        len = itoa(va_arg(args, int), buf);
                        break;
                default:
                        len = 2;
                        break;
                }
out:
                res = write(fd, start, len);
                if (res > 0)
                        total += res;
                if (res != len)
                        break;
        }
        va_end(args);
        return total;
}

/** Allocate and fill an absolute path to a file. */
char *
abspath(const char *filename)
{
        if (filename[0] == '/')
                return strdup(filename);

        char *abspath = (char *) malloc(PATH_MAX + 1);
        if (abspath == NULL)
                return NULL;

        if (getcwd(abspath, PATH_MAX - strlen(filename) - 1) == NULL)
                say_syserror("getcwd");
        else {
                strcat(abspath, "/");
        }
        strcat(abspath, filename);
        return abspath;
}

char *
int2str(long long int val)
{
        static __thread char buf[22];
        snprintf(buf, sizeof(buf), "%lld", val);
        return buf;
}

int
utf8_check_printable(const char *start, size_t length)
{
        const unsigned char *end = (const unsigned char *) start + length;
        const unsigned char *pointer = (const unsigned char *) start;

        while (pointer < end) {
                unsigned char octet;
                unsigned int width;
                unsigned int value;
                size_t k;

                octet = pointer[0];
                width = (octet & 0x80) == 0x00 ? 1 :
                        (octet & 0xE0) == 0xC0 ? 2 :
                        (octet & 0xF0) == 0xE0 ? 3 :
                        (octet & 0xF8) == 0xF0 ? 4 : 0;
                value = (octet & 0x80) == 0x00 ? octet & 0x7F :
                        (octet & 0xE0) == 0xC0 ? octet & 0x1F :
                        (octet & 0xF0) == 0xE0 ? octet & 0x0F :
                        (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
                if (!width)
                        return 0;
                if (pointer + width > end)
                        return 0;
                for (k = 1; k < width; k++) {
                        octet = pointer[k];
                        if ((octet & 0xC0) != 0x80) return 0;
                        value = (value << 6) + (octet & 0x3F);
                }
                if (!((width == 1) ||
                      (width == 2 && value >= 0x80) ||
                      (width == 3 && value >= 0x800) ||
                      (width == 4 && value >= 0x10000)))
                        return 0;

                /*
                 * gh-354: yaml incorrectly escapes special characters in a string
                 * Check that the string can be actually printed unescaped.
                 */
                if (*pointer > 0x7F &&
                    !((pointer[0] == 0x0A) ||
                      (pointer[0] >= 0x20 && pointer[0] <= 0x7E) ||
                      (pointer[0] == 0xC2 && pointer[1] >= 0xA0) ||
                      (pointer[0]  > 0xC2 && pointer[0]  < 0xED) ||
                      (pointer[0] == 0xED && pointer[1]  < 0xA0) ||
                      (pointer[0] == 0xEE) ||
                      (pointer[0] == 0xEF &&
                       !(pointer[1] == 0xBB && pointer[2] == 0xBF) &&
                       !(pointer[1] == 0xBF &&
                         (pointer[2] == 0xBE || pointer[2] == 0xBF)))
                      )
                    ) {
                        return 0;
                }
                pointer += width;
        }
        return 1;
}

int
json_escape(char *buf, int size, const char *data)
{
        int total = 0;
        int data_len = strlen(data);
        for (int i = 0; i < data_len; i++) {
                unsigned char c = (unsigned char ) data[i];
                if (c < 128 && mp_char2escape[c] != NULL) {
                        /* Escape character */
                        SNPRINT(total, snprintf, buf, size, "%s",
                                          mp_char2escape[c]);
                } else {
                        SNPRINT(total, snprintf, buf, size, "%c", c);
                }
        }
        return total;
}

const char *precision_fmts[] = {
        "%.0lg", "%.1lg", "%.2lg", "%.3lg", "%.4lg", "%.5lg", "%.6lg", "%.7lg",
        "%.8lg", "%.9lg", "%.10lg", "%.11lg", "%.12lg", "%.13lg", "%.14lg"
};

void
fpconv_check()
{
        char buf[8];

        snprintf(buf, sizeof(buf), "%g", 0.5);

        /* Failing this test might imply the platform has a buggy dtoa
         * implementation or wide characters */
        assert(buf[0] == '0' && buf[2] == '5' && buf[3] == 0);

        /*
         * Currently Tarantool doesn't support user locales (see main()).
         * Just check that locale decimal point is '.'.
         */
        assert(buf[1] == '.');
}

1	/*
2	* Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
3	*
4	* Redistribution and use in source and binary forms, with or
5	* without modification, are permitted provided that the following
6	* conditions are met:
7	*
8	* 1. Redistributions of source code must retain the above
9	* copyright notice, this list of conditions and the
10	* following disclaimer.
11	*
12	* 2. Redistributions in binary form must reproduce the above
13	* copyright notice, this list of conditions and the following
14	* disclaimer in the documentation and/or other materials
15	* provided with the distribution.
16	*
17	* THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21	* <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
22	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
28	* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29	* SUCH DAMAGE.
30	*/
31	#include "trivia/util.h"
32
33	#include <stdarg.h>
34	#include <stdbool.h>
35	#include <stdio.h>
36	#include <stdlib.h>
37	#include <string.h>
38	#include <sys/resource.h>
39	#include <sys/time.h>
40	#include <time.h>
41	#include <unistd.h>
42	#include <limits.h>
43
44	#include <msgpuck/msgpuck.h> /* mp_char2escape[] table */
45
46	#include "say.h"
47
48	/** Find a string in an array of strings.
49	*
50	* @param haystack Array of strings. Either NULL
51	* pointer terminated (for arrays of
52	* unknown size) or of size hmax.
53	* @param needle string to look for
54	* @param hmax the index to use if nothing is found
55	* also limits the size of the array
56	* @return string index or hmax if the string is not found.
57	*/
58	uint32_t
59	strindex(const char *haystack, const char needle, uint32_t hmax)	201,585✔
60	{
61	for (unsigned index = 0; index != hmax && haystack[index]; index++)	490,164✔
62	if (strcasecmp(haystack[index], needle) == 0)	490,158✔
63	return index;	201,579✔
64	return hmax;	6✔
65	}
66
67	/**
68	* Same as strindex(), but with a specified length of @a needle.
69	* Used, when @a needle is not 0 terminated.
70	*/
71	uint32_t
72	strnindex(const char *haystack, const char needle, uint32_t len, uint32_t hmax)	130,114✔
73	{
74	if (len == 0)	130,114✔
75	return hmax;	×
76	for (unsigned index = 0; index != hmax && haystack[index]; index++) {	410,179✔
77	if (strncasecmp(haystack[index], needle, len) == 0 &&	539,958✔
78	strlen(haystack[index]) == len)	130,094✔
79	return index;	129,799✔
80	}
81	return hmax;	315✔
82	}
83
84	void
85	close_all_xcpt(int fdc, ...)	×
86	{	×
87	unsigned keep[fdc];	×
88	va_list ap;
89	struct rlimit nofile;
90
91	va_start(ap, fdc);	×
92	for (int j = 0; j < fdc; j++) {	×
93	keep[j] = va_arg(ap, unsigned);	×
94	}
95	va_end(ap);	×
96
97	if (getrlimit(RLIMIT_NOFILE, &nofile) != 0)	×
98	nofile.rlim_cur = 10000;	×
99
100	for (unsigned i = 3; i < nofile.rlim_cur; i++) {	×
101	bool found = false;	×
102	for (int j = 0; j < fdc; j++) {	×
103	if (keep[j] == i) {	×
104	found = true;	×
105	break;	×
106	}
107	}
108	if (!found)	×
109	close(i);	×
110	}
111	}	×
112
113	static int
114	itoa(int val, char *buf)	×
115	{
116	char *p = buf;	×
117
118	if (val < 0) {	×
119	*p++ = '-';	×
120	val = -val;	×
121	}
122	/* Print full range if it is an unsigned number. */
123	unsigned uval = val;	×
124	char *start = p;	×
125	do {
126	*p++ = '0' + uval % 10;	×
127	uval /= 10;	×
128	} while (uval > 0);	×
129
130	int len = (int)(p - buf);	×
131
132	*p-- = '\0';	×
133
134	/* Reverse the resulting string. */
135	do {
136	char tmp = *p;	×
137	p = start;	×
138	*start = tmp;	×
139	} while (++start < --p);	×
140
141	return len;	×
142	}
143
144	/**
145	* Async-signal-safe implementation of printf() into an fd, to be
146	* able to write messages into the error log inside a signal
147	* handler. Only supports %s and %d, %u, format specifiers.
148	*/
149	ssize_t
150	fdprintf(int fd, const char *format, ...)	×
151	{
152	ssize_t total = 0;	×
153	char buf[22];
154	va_list args;
155	va_start(args, format);	×
156
157	while (*format) {	×
158	const char *start = format;	×
159	ssize_t len, res;
160	if (*format++ != '%') {	×
161	while (format != '\0' && format != '%')	×
162	format++;	×
163	len = format - start;	×
164	goto out;	×
165	}
166	switch (*format++) {	×
167	case '%':
168	len = 1;	×
169	break;	×
170	case 's':
171	start = va_arg(args, char *);	×
172	if (start == NULL)	×
173	start = "(null)";	×
174	len = strlen(start);	×
175	break;	×
176	case 'd':
177	case 'u':
178	start = buf;	×
179	len = itoa(va_arg(args, int), buf);	×
180	break;	×
181	default:
182	len = 2;	×
183	break;	×
184	}
185	out:
186	res = write(fd, start, len);	×
187	if (res > 0)	×
188	total += res;	×
189	if (res != len)	×
190	break;	×
191	}
192	va_end(args);	×
193	return total;	×
194	}
195
196	/** Allocate and fill an absolute path to a file. */
197	char *
198	abspath(const char *filename)	1,428✔
199	{
200	if (filename[0] == '/')	1,428✔
201	return strdup(filename);	1,390✔
202
203	char abspath = (char ) malloc(PATH_MAX + 1);	38✔
204	if (abspath == NULL)	38✔
205	return NULL;	×
206
207	if (getcwd(abspath, PATH_MAX - strlen(filename) - 1) == NULL)	38✔
208	say_syserror("getcwd");	×
209	else {
210	strcat(abspath, "/");	38✔
211	}
212	strcat(abspath, filename);	38✔
213	return abspath;	38✔
214	}
215
216	char *
217	int2str(long long int val)	10✔
218	{
219	static __thread char buf[22];
220	snprintf(buf, sizeof(buf), "%lld", val);	10✔
221	return buf;	10✔
222	}
223
224	int
225	utf8_check_printable(const char *start, size_t length)	70,977✔
226	{
227	const unsigned char end = (const unsigned char ) start + length;	70,977✔
228	const unsigned char pointer = (const unsigned char ) start;	70,977✔
229
230	while (pointer < end) {	591,816✔
231	unsigned char octet;
232	unsigned int width;
233	unsigned int value;
234	size_t k;
235
236	octet = pointer[0];	480,781✔
237	width = (octet & 0x80) == 0x00 ? 1 :	559,435✔
238	(octet & 0xE0) == 0xC0 ? 2 :	33,489✔
239	(octet & 0xF0) == 0xE0 ? 3 :	24,666✔
240	(octet & 0xF8) == 0xF0 ? 4 : 0;	20,499✔
241	value = (octet & 0x80) == 0x00 ? octet & 0x7F :	559,435✔
242	(octet & 0xE0) == 0xC0 ? octet & 0x1F :	33,489✔
243	(octet & 0xF0) == 0xE0 ? octet & 0x0F :	24,666✔
244	(octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;	20,499✔
245	if (!width)	480,781✔
246	return 0;	18,451✔
247	if (pointer + width > end)	462,330✔
248	return 0;	1,024✔
249	for (k = 1; k < width; k++) {	465,645✔
250	octet = pointer[k];	15,619✔
251	if ((octet & 0xC0) != 0x80) return 0;	15,619✔
252	value = (value << 6) + (octet & 0x3F);	4,339✔
253	}
254	if (!((width == 1) \|\|	450,155✔
255	(width == 2 && value >= 0x80) \|\|	2,666✔
256	(width == 3 && value >= 0x800) \|\|	68✔
257	(width == 4 && value >= 0x10000)))	×
258	return 0;	129✔
259
260	/*
261	* gh-354: yaml incorrectly escapes special characters in a string
262	* Check that the string can be actually printed unescaped.
263	*/
264	if (*pointer > 0x7F &&	452,502✔
265	!((pointer[0] == 0x0A) \|\|	5,245✔
266	(pointer[0] >= 0x20 && pointer[0] <= 0x7E) \|\|	7,815✔
267	(pointer[0] == 0xC2 && pointer[1] >= 0xA0) \|\|	5,245✔
268	(pointer[0] > 0xC2 && pointer[0] < 0xED) \|\|	5,146✔
269	(pointer[0] == 0xED && pointer[1] < 0xA0) \|\|	70✔
270	(pointer[0] == 0xEE) \|\|	35✔
271	(pointer[0] == 0xEF &&	35✔
272	!(pointer[1] == 0xBB && pointer[2] == 0xBF) &&	×
273	!(pointer[1] == 0xBF &&	×
274	(pointer[2] == 0xBE \|\| pointer[2] == 0xBF)))	×
275	)
276	) {
277	return 0;	35✔
278	}
279	pointer += width;	449,862✔
280	}
281	return 1;	40,058✔
282	}
283
284	int
285	json_escape(char buf, int size, const char data)	28✔
286	{
287	int total = 0;	28✔
288	int data_len = strlen(data);	28✔
289	for (int i = 0; i < data_len; i++) {	1,513✔
290	unsigned char c = (unsigned char ) data[i];	1,485✔
291	if (c < 128 && mp_char2escape[c] != NULL) {	1,485✔
292	/* Escape character */
293	SNPRINT(total, snprintf, buf, size, "%s",	28✔
294	mp_char2escape[c]);
295	} else {
296	SNPRINT(total, snprintf, buf, size, "%c", c);	1,457✔
297	}
298	}
299	return total;	28✔
300	}
301
302	const char *precision_fmts[] = {
303	"%.0lg", "%.1lg", "%.2lg", "%.3lg", "%.4lg", "%.5lg", "%.6lg", "%.7lg",
304	"%.8lg", "%.9lg", "%.10lg", "%.11lg", "%.12lg", "%.13lg", "%.14lg"
305	};
306
307	void
308	fpconv_check()	1,812✔
309	{
310	char buf[8];
311
312	snprintf(buf, sizeof(buf), "%g", 0.5);	1,812✔
313
314	/* Failing this test might imply the platform has a buggy dtoa
315	* implementation or wide characters */
316	assert(buf[0] == '0' && buf[2] == '5' && buf[3] == 0);	1,812✔
317
318	/*
319	* Currently Tarantool doesn't support user locales (see main()).
320	* Just check that locale decimal point is '.'.
321	*/
322	assert(buf[1] == '.');	1,812✔
323	}	1,812✔

tarantool / tarantool / 15155

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