aremmell / libsir / 472

Committed 06 Sep 2023 02:06AM UTC coverage: 94.69% (+0.08%) from 94.608%

Build # 472

Build Type

Pull #258

gitlab-ci

Committed by

aremmell

Commit Message

make thread function warnings consistent

Pull Request Pull Request #258: Bug fix, new tests, portable set thread name functionality

Run Details

473 of 473 new or added lines in 10 files covered. (100.0%)

3103 of 3277 relevant lines covered (94.69%)

614006.78 hits per line

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

91.67

/src/sirhelpers.c

/*
 * sirhelpers.c
 *
 * Author:    Ryan M. Lederman <lederman@gmail.com>
 * Copyright: Copyright (c) 2018-2023
 * Version:   2.2.3
 * License:   The MIT License (MIT)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include "sir/helpers.h"
#include "sir/errors.h"

void __sir_safefree(void** pp) {
    if (!pp || !*pp)
        return;

    free(*pp);
    *pp = NULL;
}

void _sir_safeclose(int* restrict fd) {
    if (!fd || 0 > *fd)
        return;

    if (-1 == close(*fd))
        (void)_sir_handleerr(errno);

    *fd = -1;
}

void _sir_safefclose(FILE* restrict* restrict f) {
    if (!f || !*f)
        return;

    if (0 != fclose(*f))
        (void)_sir_handleerr(errno);

    *f = NULL;
}

bool _sir_validfd(int fd) {
    /** stdin, stdout, stderr use up 0, 1, 2 */
    if (2 >= fd)
        return _sir_handleerr(EBADF);

#if !defined(__WIN__)
    int ret = fcntl(fd, F_GETFL);
#else /* __WIN__ */
# if !defined(SIR_MSVCRT_MINGW)
    invalparamfn old = _set_thread_local_invalid_parameter_handler(_sir_invalidparameter);
# endif
    struct _stat st;
    int ret = _fstat(fd, &st);
# if !defined(SIR_MSVCRT_MINGW)
    _set_thread_local_invalid_parameter_handler(old);
# endif
#endif
    return (-1 != ret || EBADF != errno) ? true : _sir_handleerr(errno);
}

/** Validates a sir_update_config_data structure. */
bool _sir_validupdatedata(const sir_update_config_data* data) {
    if (!_sir_validptr(data))
        return false;

    bool valid = true;
    if ((data->fields & SIRU_ALL) == 0U || (data->fields & ~SIRU_ALL) != 0U)
        valid = false;

    if (valid && _sir_bittest(data->fields, SIRU_LEVELS))
        valid = _sir_validptrnofail(data->levels) &&
                _sir_validlevels(*data->levels);

    if (valid && _sir_bittest(data->fields, SIRU_OPTIONS))
        valid = _sir_validptrnofail(data->opts) &&
                _sir_validopts(*data->opts);

    if (valid && _sir_bittest(data->fields, SIRU_SYSLOG_ID))
        valid = _sir_validstrnofail(data->sl_identity);

    if (valid && _sir_bittest(data->fields, SIRU_SYSLOG_CAT))
        valid = _sir_validstrnofail(data->sl_category);

    if (!valid) {
        (void)_sir_seterror(_SIR_E_INVALID);
        SIR_ASSERT(!valid);
    }

    return valid;
}

bool _sir_validlevels(sir_levels levels) {
    if ((SIRL_ALL == levels || SIRL_NONE == levels) ||
        ((_sir_bittest(levels, SIRL_INFO)           ||
         _sir_bittest(levels, SIRL_DEBUG)           ||
         _sir_bittest(levels, SIRL_NOTICE)          ||
         _sir_bittest(levels, SIRL_WARN)            ||
         _sir_bittest(levels, SIRL_ERROR)           ||
         _sir_bittest(levels, SIRL_CRIT)            ||
         _sir_bittest(levels, SIRL_ALERT)           ||
         _sir_bittest(levels, SIRL_EMERG))          &&
         ((levels & ~SIRL_ALL) == 0U)))
         return true;

    _sir_selflog("invalid levels: %04"PRIx16, levels);
    return _sir_seterror(_SIR_E_LEVELS);
}

bool _sir_validlevel(sir_level level) {
    if (SIRL_INFO   == level || SIRL_DEBUG == level ||
        SIRL_NOTICE == level || SIRL_WARN  == level ||
        SIRL_ERROR  == level || SIRL_CRIT  == level ||
        SIRL_ALERT  == level || SIRL_EMERG == level)
        return true;

    _sir_selflog("invalid level: %04"PRIx16, level);
    return _sir_seterror(_SIR_E_LEVELS);
}

bool _sir_validopts(sir_options opts) {
    if ((SIRO_ALL == opts || SIRO_MSGONLY == opts) ||
        ((_sir_bittest(opts, SIRO_NOTIME)          ||
         _sir_bittest(opts, SIRO_NOHOST)           ||
         _sir_bittest(opts, SIRO_NOLEVEL)          ||
         _sir_bittest(opts, SIRO_NONAME)           ||
         _sir_bittest(opts, SIRO_NOMSEC)           ||
         _sir_bittest(opts, SIRO_NOPID)            ||
         _sir_bittest(opts, SIRO_NOTID)            ||
         _sir_bittest(opts, SIRO_NOHDR))           &&
         ((opts & ~(SIRO_MSGONLY | SIRO_NOHDR)) == 0U)))
         return true;

    _sir_selflog("invalid options: %08"PRIx32, opts);
    return _sir_seterror(_SIR_E_OPTIONS);
}

bool _sir_validtextattr(sir_textattr attr) {
    switch(attr) {
        case SIRTA_NORMAL:
        case SIRTA_BOLD:
        case SIRTA_DIM:
        case SIRTA_EMPH:
        case SIRTA_ULINE:
            return true;
        default: {
            _sir_selflog("invalid text attr: %d", attr);
            return _sir_seterror(_SIR_E_TEXTATTR);
        }
    }
}

bool _sir_validtextcolor(sir_colormode mode, sir_textcolor color) {
    bool valid = false;
    switch (mode) {
        case SIRCM_16:
            /* in 16-color mode:
             * compare to 30..37, 39, 40..47, 49, 90..97, 100..107. */
            valid = SIRTC_DEFAULT == color ||
                    (color >= 30U && color <= 37U) || color == 39U ||
                    (color >= 40U && color <= 47U) || color == 49U ||
                    (color >= 90U && color <= 97U) || (color >= 100U && color <= 107U);
            break;
        case SIRCM_256:
            /* in 256-color mode: compare to 0..255. sir_textcolor is unsigned,
             * so only need to ensure it's <= 255. */
            valid = SIRTC_DEFAULT == color || color <= 255U;
            break;
        case SIRCM_RGB: {
            /* in RGB-color mode: mask and compare to 0x00ffffff. */
            valid = SIRTC_DEFAULT == color || ((color & 0xff000000U) == 0U);
            break;
        }
        case SIRCM_INVALID: // GCOVR_EXCL_START
        default:
            valid = false;
            break;
    } // GCOVR_EXCL_STOP

    if (!valid) {
        _sir_selflog("invalid text color for mode %d %08"PRIx32" (%"PRIu32")",
            mode, color, color);
        (void)_sir_seterror(_SIR_E_TEXTCOLOR);
    }

    return valid;
}

bool _sir_validcolormode(sir_colormode mode) {
    switch (mode) {
        case SIRCM_16:
        case SIRCM_256:
        case SIRCM_RGB:
            return true;
        case SIRCM_INVALID:
        default: {
            _sir_selflog("invalid color mode: %d", mode);
            return _sir_seterror(_SIR_E_COLORMODE);
        }
    }
}

int _sir_strncpy(char* restrict dest, size_t destsz, const char* restrict src,
    size_t count) {
    if (_sir_validptr(dest) && _sir_validstr(src)) {
#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
        int ret = strncpy_s(dest, destsz, src, count);
        if (0 != ret) {
            (void)_sir_handleerr(ret);
            return -1;
        }
        return 0;
#else
        SIR_UNUSED(count);
        size_t cpy = strlcpy(dest, src, destsz);
        SIR_ASSERT_UNUSED(cpy < destsz, cpy);
        return 0;
#endif
    }

    return -1;
}

int _sir_strncat(char* restrict dest, size_t destsz, const char* restrict src,
    size_t count) {
    if (_sir_validptr(dest) && _sir_validstr(src)) {
#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
        int ret = strncat_s(dest, destsz, src, count);
        if (0 != ret) {
            (void)_sir_handleerr(ret);
            return -1;
        }
        return 0;
#else
        SIR_UNUSED(count);
        size_t cat = strlcat(dest, src, destsz);
        SIR_ASSERT_UNUSED(cat < destsz, cat);
        return 0;
#endif
    }

    return -1;
}

int _sir_fopen(FILE* restrict* restrict streamptr, const char* restrict filename,
    const char* restrict mode) {
    if (_sir_validptrptr(streamptr) && _sir_validstr(filename) && _sir_validstr(mode)) {
#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
        int ret = fopen_s(streamptr, filename, mode);
        if (0 != ret) {
            (void)_sir_handleerr(ret);
            return -1;
        }
        return 0;
#else
        *streamptr = fopen(filename, mode);
        if (!*streamptr) {
            (void)_sir_handleerr(errno);
            return -1;
        }
        return 0;
#endif
    }

    return -1;
}

bool _sir_getchar(char* input) {
    if (!_sir_validptr(input))
        return false;

#if defined(__WIN__)
# if defined(__EMBARCADEROC__)
     *input = (char)getch();
# else
     *input = (char)_getch();
# endif
     return true;
#else /* !__WIN__ */
    struct termios cur = {0};
    if (0 != tcgetattr(STDIN_FILENO, &cur))
        return _sir_handleerr(errno);

    struct termios new = {0};
    memcpy(&new, &cur, sizeof(struct termios));
    new.c_lflag &= ~(ICANON | ECHO);

    if (0 != tcsetattr(STDIN_FILENO, TCSANOW, &new))
        return _sir_handleerr(errno);

    *input = (char)getchar();

    return 0 == tcsetattr(STDIN_FILENO, TCSANOW, &cur) ? true
        : _sir_handleerr(errno);
#endif
}

1	/*
2	* sirhelpers.c
3	*
4	* Author: Ryan M. Lederman <lederman@gmail.com>
5	* Copyright: Copyright (c) 2018-2023
6	* Version: 2.2.3
7	* License: The MIT License (MIT)
8	*
9	* Permission is hereby granted, free of charge, to any person obtaining a copy of
10	* this software and associated documentation files (the "Software"), to deal in
11	* the Software without restriction, including without limitation the rights to
12	* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
13	* the Software, and to permit persons to whom the Software is furnished to do so,
14	* subject to the following conditions:
15	*
16	* The above copyright notice and this permission notice shall be included in all
17	* copies or substantial portions of the Software.
18	*
19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
21	* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
22	* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
23	* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25	*/
26	#include "sir/helpers.h"
27	#include "sir/errors.h"
28
29	void __sir_safefree(void** pp) {	941,986✔
30	if (!pp \|\| !*pp)	941,986✔
31	return;	267,750✔
32
33	free(*pp);	631,715✔
34	*pp = NULL;	631,715✔
35	}
36
37	void _sir_safeclose(int* restrict fd) {	210✔
38	if (!fd \|\| 0 > *fd)	210✔
39	return;	×
40
41	if (-1 == close(*fd))	210✔
42	(void)_sir_handleerr(errno);	×
43
44	*fd = -1;	210✔
45	}
46
47	void _sir_safefclose(FILE* restrict* restrict f) {	37,089✔
48	if (!f \|\| !*f)	37,089✔
49	return;	4✔
50
51	if (0 != fclose(*f))	37,085✔
52	(void)_sir_handleerr(errno);	×
53
54	*f = NULL;	37,085✔
55	}
56
57	bool _sir_validfd(int fd) {	111✔
58	/** stdin, stdout, stderr use up 0, 1, 2 */
59	if (2 >= fd)	111✔
60	return _sir_handleerr(EBADF);	69✔
61
62	#if !defined(__WIN__)
63	int ret = fcntl(fd, F_GETFL);	42✔
64	#else /* __WIN__ */
65	# if !defined(SIR_MSVCRT_MINGW)
66	invalparamfn old = _set_thread_local_invalid_parameter_handler(_sir_invalidparameter);
67	# endif
68	struct _stat st;
69	int ret = _fstat(fd, &st);
70	# if !defined(SIR_MSVCRT_MINGW)
71	_set_thread_local_invalid_parameter_handler(old);
72	# endif
73	#endif
74	return (-1 != ret \|\| EBADF != errno) ? true : _sir_handleerr(errno);	42✔
75	}
76
77	/** Validates a sir_update_config_data structure. */
78	bool _sir_validupdatedata(const sir_update_config_data* data) {	144,951✔
79	if (!_sir_validptr(data))	144,951✔
80	return false;	×
81
82	bool valid = true;	120,686✔
83	if ((data->fields & SIRU_ALL) == 0U \|\| (data->fields & ~SIRU_ALL) != 0U)	144,969✔
84	valid = false;	×
85
86	if (valid && _sir_bittest(data->fields, SIRU_LEVELS))	144,964✔
87	valid = _sir_validptrnofail(data->levels) &&	2,616✔
88	_sir_validlevels(*data->levels);	1,308✔
89
90	if (valid && _sir_bittest(data->fields, SIRU_OPTIONS))	144,958✔
91	valid = _sir_validptrnofail(data->opts) &&	286,526✔
92	_sir_validopts(*data->opts);	143,332✔
93
94	if (valid && _sir_bittest(data->fields, SIRU_SYSLOG_ID))	144,669✔
95	valid = _sir_validstrnofail(data->sl_identity);	119✔
96
97	if (valid && _sir_bittest(data->fields, SIRU_SYSLOG_CAT))	144,624✔
98	valid = _sir_validstrnofail(data->sl_category);	88✔
99
100	if (!valid) {	144,576✔
101	(void)_sir_seterror(_SIR_E_INVALID);	5✔
102	SIR_ASSERT(!valid);	×
103	}
104
105	return valid;	120,349✔
106	}
107
108	bool _sir_validlevels(sir_levels levels) {	78,001✔
109	if ((SIRL_ALL == levels \|\| SIRL_NONE == levels) \|\|	79,767✔
110	((_sir_bittest(levels, SIRL_INFO) \|\|	3,323✔
111	_sir_bittest(levels, SIRL_DEBUG) \|\|	2,443✔
112	_sir_bittest(levels, SIRL_NOTICE) \|\|	1,975✔
113	_sir_bittest(levels, SIRL_WARN) \|\|	1,630✔
114	_sir_bittest(levels, SIRL_ERROR) \|\|	1,095✔
115	_sir_bittest(levels, SIRL_CRIT) \|\|	602✔
116	_sir_bittest(levels, SIRL_ALERT) \|\|	362✔
117	_sir_bittest(levels, SIRL_EMERG)) &&	2,151✔
118	((levels & ~SIRL_ALL) == 0U)))
119	return true;	65,068✔
120
121	_sir_selflog("invalid levels: %04"PRIx16, levels);	52✔
122	return _sir_seterror(_SIR_E_LEVELS);	55✔
123	}
124
125	bool _sir_validlevel(sir_level level) {	4,518,637✔
126	if (SIRL_INFO == level \|\| SIRL_DEBUG == level \|\|	4,518,637✔
127	SIRL_NOTICE == level \|\| SIRL_WARN == level \|\|	7,325✔
128	SIRL_ERROR == level \|\| SIRL_CRIT == level \|\|	4,394✔
129	SIRL_ALERT == level \|\| SIRL_EMERG == level)	1,471✔
130	return true;	4,430,388✔
131
132	_sir_selflog("invalid level: %04"PRIx16, level);	21✔
133	return _sir_seterror(_SIR_E_LEVELS);	22✔
134	}
135
136	bool _sir_validopts(sir_options opts) {	220,153✔
137	if ((SIRO_ALL == opts \|\| SIRO_MSGONLY == opts) \|\|	341,404✔
138	((_sir_bittest(opts, SIRO_NOTIME) \|\|	235,268✔
139	_sir_bittest(opts, SIRO_NOHOST) \|\|	108,069✔
140	_sir_bittest(opts, SIRO_NOLEVEL) \|\|	682✔
141	_sir_bittest(opts, SIRO_NONAME) \|\|	560✔
142	_sir_bittest(opts, SIRO_NOMSEC) \|\|	443✔
143	_sir_bittest(opts, SIRO_NOPID) \|\|	312✔
144	_sir_bittest(opts, SIRO_NOTID) \|\|	186✔
145	_sir_bittest(opts, SIRO_NOHDR)) &&	88✔
146	((opts & ~(SIRO_MSGONLY \| SIRO_NOHDR)) == 0U)))	145,486✔
147	return true;	183,013✔
148
149	_sir_selflog("invalid options: %08"PRIx32, opts);	237✔
150	return _sir_seterror(_SIR_E_OPTIONS);	281✔
151	}
152
153	bool _sir_validtextattr(sir_textattr attr) {	167,006✔
154	switch(attr) {	167,006✔
155	case SIRTA_NORMAL:	139,612✔
156	case SIRTA_BOLD:
157	case SIRTA_DIM:
158	case SIRTA_EMPH:
159	case SIRTA_ULINE:
160	return true;	139,612✔
161	default: {	22✔
162	_sir_selflog("invalid text attr: %d", attr);	21✔
163	return _sir_seterror(_SIR_E_TEXTATTR);	22✔
164	}
165	}
166	}
167
168	bool _sir_validtextcolor(sir_colormode mode, sir_textcolor color) {	333,946✔
169	bool valid = false;	279,205✔
170	switch (mode) {	333,946✔
171	case SIRCM_16:	310,714✔
172	/* in 16-color mode:
173	* compare to 30..37, 39, 40..47, 49, 90..97, 100..107. */
174	valid = SIRTC_DEFAULT == color \|\|	310,714✔
175	(color >= 30U && color <= 37U) \|\| color == 39U \|\|	310,714✔
176	(color >= 40U && color <= 47U) \|\| color == 49U \|\|	133,189✔
177	(color >= 90U && color <= 97U) \|\| (color >= 100U && color <= 107U);	518,282✔
178	break;	259,141✔
179	case SIRCM_256:	11,572✔
180	/* in 256-color mode: compare to 0..255. sir_textcolor is unsigned,
181	* so only need to ensure it's <= 255. */
182	valid = SIRTC_DEFAULT == color \|\| color <= 255U;	11,572✔
183	break;	11,572✔
184	case SIRCM_RGB: {	11,660✔
185	/* in RGB-color mode: mask and compare to 0x00ffffff. */
186	valid = SIRTC_DEFAULT == color \|\| ((color & 0xff000000U) == 0U);	11,660✔
187	break;	11,660✔
188	}
189	case SIRCM_INVALID: // GCOVR_EXCL_START
190	default:
191	valid = false;
192	break;
193	} // GCOVR_EXCL_STOP
194
195	if (!valid) {	282,373✔
196	_sir_selflog("invalid text color for mode %d %08"PRIx32" (%"PRIu32")",	21✔
197	mode, color, color);
198	(void)_sir_seterror(_SIR_E_TEXTCOLOR);	22✔
199	}
200
201	return valid;	333,946✔
202	}
203
204	bool _sir_validcolormode(sir_colormode mode) {	167,758✔
205	switch (mode) {	167,758✔
206	case SIRCM_16:	140,247✔
207	case SIRCM_256:
208	case SIRCM_RGB:
209	return true;	140,247✔
210	case SIRCM_INVALID:	22✔
211	default: {
212	_sir_selflog("invalid color mode: %d", mode);	21✔
213	return _sir_seterror(_SIR_E_COLORMODE);	22✔
214	}
215	}
216	}
217
218	int _sir_strncpy(char* restrict dest, size_t destsz, const char* restrict src,	4,312,586✔
219	size_t count) {
220	if (_sir_validptr(dest) && _sir_validstr(src)) {	4,312,586✔
221	#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
222	int ret = strncpy_s(dest, destsz, src, count);
223	if (0 != ret) {
224	(void)_sir_handleerr(ret);
225	return -1;
226	}
227	return 0;
228	#else
229	SIR_UNUSED(count);
230	size_t cpy = strlcpy(dest, src, destsz);	4,217,571✔
231	SIR_ASSERT_UNUSED(cpy < destsz, cpy);	4,243,215✔
232	return 0;	4,256,037✔
233	#endif
234	}
235
236	return -1;	47,414✔
237	}
238
239	int _sir_strncat(char* restrict dest, size_t destsz, const char* restrict src,	29,212,792✔
240	size_t count) {
241	if (_sir_validptr(dest) && _sir_validstr(src)) {	29,212,792✔
242	#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
243	int ret = strncat_s(dest, destsz, src, count);
244	if (0 != ret) {
245	(void)_sir_handleerr(ret);
246	return -1;
247	}
248	return 0;
249	#else
250	SIR_UNUSED(count);
251	size_t cat = strlcat(dest, src, destsz);	28,828,565✔
252	SIR_ASSERT_UNUSED(cat < destsz, cat);	29,079,192✔
253	return 0;	29,206,376✔
254	#endif
255	}
256
257	return -1;	6,752✔
258	}
259
260	int _sir_fopen(FILE* restrict* restrict streamptr, const char* restrict filename,	37,114✔
261	const char* restrict mode) {
262	if (_sir_validptrptr(streamptr) && _sir_validstr(filename) && _sir_validstr(mode)) {	37,114✔
263	#if defined(__HAVE_STDC_SECURE_OR_EXT1__)
264	int ret = fopen_s(streamptr, filename, mode);
265	if (0 != ret) {
266	(void)_sir_handleerr(ret);
267	return -1;
268	}
269	return 0;
270	#else
271	*streamptr = fopen(filename, mode);	37,114✔
272	if (!*streamptr) {	37,114✔
273	(void)_sir_handleerr(errno);	65✔
274	return -1;	65✔
275	}
276	return 0;	30,910✔
277	#endif
278	}
279
280	return -1;	×
281	}
282
283	bool _sir_getchar(char* input) {	1✔
284	if (!_sir_validptr(input))	1✔
285	return false;	×
286
287	#if defined(__WIN__)
288	# if defined(__EMBARCADEROC__)
289	*input = (char)getch();
290	# else
291	*input = (char)_getch();
292	# endif
293	return true;
294	#else /* !__WIN__ */
295	struct termios cur = {0};	1✔
296	if (0 != tcgetattr(STDIN_FILENO, &cur))	1✔
297	return _sir_handleerr(errno);	×
298
299	struct termios new = {0};	×
300	memcpy(&new, &cur, sizeof(struct termios));	×
301	new.c_lflag &= ~(ICANON \| ECHO);	1✔
302
303	if (0 != tcsetattr(STDIN_FILENO, TCSANOW, &new))	1✔
304	return _sir_handleerr(errno);	×
305
306	*input = (char)getchar();	1✔
307
308	return 0 == tcsetattr(STDIN_FILENO, TCSANOW, &cur) ? true	1✔
309	: _sir_handleerr(errno);	1✔
310	#endif
311	}

aremmell / libsir / 472

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