/src/libyang/compat/compat.c

Source (jump to first uncovered line)
/**
 * @file compat.c
 * @author Michal Vasko <mvasko@cesnet.cz>
 * @brief compatibility functions
 *
 * Copyright (c) 2021 CESNET, z.s.p.o.
 *
 * This source code is licensed under BSD 3-Clause License (the "License").
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://opensource.org/licenses/BSD-3-Clause
 */
#define _POSIX_C_SOURCE 200809L /* fdopen, _POSIX_PATH_MAX, strdup */
#define _ISOC99_SOURCE /* vsnprintf */

#include "compat.h"

#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <pthread.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef _MSC_VER
#include <sys/time.h>
#endif
#include <time.h>
#include <unistd.h>

#ifndef HAVE_VDPRINTF
int
vdprintf(int fd, const char *format, va_list ap)
{
    FILE *stream;
    int count = 0;

    stream = fdopen(dup(fd), "a+");
    if (stream) {
        count = vfprintf(stream, format, ap);
        fclose(stream);
    }
    return count;
}

#endif

#ifndef HAVE_ASPRINTF
int
asprintf(char **strp, const char *fmt, ...)
{
    int ret;
    va_list ap;

    va_start(ap, fmt);
    ret = vasprintf(strp, fmt, ap);
    va_end(ap);
    return ret;
}

#endif

#ifndef HAVE_VASPRINTF
int
vasprintf(char **strp, const char *fmt, va_list ap)
{
    va_list ap2;

    va_copy(ap2, ap);
    int l = vsnprintf(0, 0, fmt, ap2);

    va_end(ap2);

    if ((l < 0) || !(*strp = malloc(l + 1U))) {
        return -1;
    }

    return vsnprintf(*strp, l + 1U, fmt, ap);
}

#endif

#ifndef HAVE_GETLINE
ssize_t
getline(char **lineptr, size_t *n, FILE *stream)
{
    static char line[256];
    char *ptr;
    ssize_t len;

    if (!lineptr || !n) {
        errno = EINVAL;
        return -1;
    }

    if (ferror(stream) || feof(stream)) {
        return -1;
    }

    if (!fgets(line, 256, stream)) {
        return -1;
    }

    ptr = strchr(line, '\n');
    if (ptr) {
        *ptr = '\0';
    }

    len = strlen(line);

    if (len + 1 < 256) {
        ptr = realloc(*lineptr, 256);
        if (!ptr) {
            return -1;
        }
        *lineptr = ptr;
        *n = 256;
    }

    strcpy(*lineptr, line);
    return len;
}

#endif

#ifndef HAVE_STRNDUP
char *
strndup(const char *s, size_t n)
{
    char *buf;
    size_t len = 0;

    /* strnlen */
    for ( ; (len < n) && (s[len] != '\0'); ++len) {}

    if (!(buf = malloc(len + 1U))) {
        return NULL;
    }

    memcpy(buf, s, len);
    buf[len] = '\0';
    return buf;
}

#endif

#ifndef HAVE_STRNSTR
char *
strnstr(const char *s, const char *find, size_t slen)
{
    char c, sc;
    size_t len;

    if ((c = *find++) != '\0') {
        len = strlen(find);
        do {
            do {
                if ((slen-- < 1) || ((sc = *s++) == '\0')) {
                    return NULL;
                }
            } while (sc != c);
            if (len > slen) {
                return NULL;
            }
        } while (strncmp(s, find, len));
        s--;
    }
    return (char *)s;
}

#endif

#ifndef HAVE_STRCHRNUL
char *
strchrnul(const char *s, int c)
{
    char *p = strchr(s, c);

    return p ? p : (char *)s + strlen(s);
}

#endif

#ifndef HAVE_GET_CURRENT_DIR_NAME
char *
get_current_dir_name(void)
{
    char tmp[_POSIX_PATH_MAX];
    char *retval = NULL;

    if (getcwd(tmp, sizeof(tmp))) {
        retval = strdup(tmp);
        if (!retval) {
            errno = ENOMEM;
        }
    }

    return retval;
}

#endif

#ifndef _MSC_VER
#ifndef HAVE_PTHREAD_MUTEX_TIMEDLOCK
int
pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *abstime)
{
    int64_t nsec_diff;
    int32_t diff;
    struct timespec cur, dur;
    int rc;

    /* try to acquire the lock and, if we fail, sleep for 5ms. */
    while ((rc = pthread_mutex_trylock(mutex)) == EBUSY) {
        /* get real time */
#ifdef CLOCK_REALTIME
        clock_gettime(CLOCK_REALTIME, &cur);
#else
        struct timeval tv;

        gettimeofday(&tv, NULL);
        cur.tv_sec = (time_t)tv.tv_sec;
        cur.tv_nsec = 1000L * (long)tv.tv_usec;
#endif

        /* get time diff */
        nsec_diff = 0;
        nsec_diff += (((int64_t)abstime->tv_sec) - ((int64_t)cur.tv_sec)) * 1000000000L;
        nsec_diff += ((int64_t)abstime->tv_nsec) - ((int64_t)cur.tv_nsec);
        diff = (nsec_diff ? nsec_diff / 1000000L : 0);

        if (diff < 1) {
            /* timeout */
            break;
        } else if (diff < 5) {
            /* sleep until timeout */
            dur.tv_sec = 0;
            dur.tv_nsec = (long)diff * 1000000;
        } else {
            /* sleep 5 ms */
            dur.tv_sec = 0;
            dur.tv_nsec = 5000000;
        }

        nanosleep(&dur, NULL);
    }

    return rc;
}

#endif
#endif

#ifndef HAVE_REALPATH
#ifdef _WIN32
char *
realpath(const char *path, char *resolved_path)
{
    char *resolved = _fullpath(resolved_path, path, PATH_MAX);

    if ((_access(resolved, 0) == -1) && (errno == ENOENT)) {
        return NULL;
    }
    return resolved;
}

#elif defined (__NetBSD__)
char *
realpath(const char *path, char *resolved_path)
{
    ssize_t nbytes;

    nbytes = readlink(path, resolved_path, PATH_MAX);
    if (nbytes == -1) {
        return NULL;
    }
    return resolved_path;
}

#else
#error No realpath() implementation for this platform is available.
#endif
#endif

#ifndef HAVE_LOCALTIME_R
#ifdef _WIN32
struct tm *
localtime_r(const time_t *timep, struct tm *result)
{
    errno_t res = localtime_s(result, timep);

    if (res) {
        return NULL;
    } else {
        return result;
    }
}

#else
#error No localtime_r() implementation for this platform is available.
#endif
#endif

#ifndef HAVE_GMTIME_R
#ifdef _WIN32
struct tm *
gmtime_r(const time_t *timep, struct tm *result)
{
    errno_t res = gmtime_s(result, timep);

    if (res) {
        return NULL;
    } else {
        return result;
    }
}

#else
#error No gmtime_r() implementation for this platform is available.
#endif
#endif

#ifndef HAVE_SETENV
#ifdef _WIN32
int
setenv(const char *name, const char *value, int overwrite)
{
    int errcode = 0;

    if (!overwrite) {
        size_t envsize = 0;

        errcode = getenv_s(&envsize, NULL, 0, name);
        if (errcode || envsize) {
            return errcode;
        }
    }
    return _putenv_s(name, value);
}

#else
#error No setenv() implementation for this platform is available.
#endif
#endif

Coverage Report

Created: 2023-06-07 06:27

Line	Count	Source (jump to first uncovered line)
1		/**
2		* @file compat.c
3		* @author Michal Vasko <mvasko@cesnet.cz>
4		* @brief compatibility functions
5		*
6		* Copyright (c) 2021 CESNET, z.s.p.o.
7		*
8		* This source code is licensed under BSD 3-Clause License (the "License").
9		* You may not use this file except in compliance with the License.
10		* You may obtain a copy of the License at
11		*
12		* https://opensource.org/licenses/BSD-3-Clause
13		*/
14		#define _POSIX_C_SOURCE 200809L /* fdopen, _POSIX_PATH_MAX, strdup */
15		#define _ISOC99_SOURCE /* vsnprintf */
16
17		#include "compat.h"
18
19		#include <errno.h>
20		#include <inttypes.h>
21		#include <limits.h>
22		#include <pthread.h>
23		#include <stdarg.h>
24		#include <stdio.h>
25		#include <stdlib.h>
26		#include <string.h>
27		#ifndef _MSC_VER
28		#include <sys/time.h>
29		#endif
30		#include <time.h>
31		#include <unistd.h>
32
33		#ifndef HAVE_VDPRINTF
34		int
35		vdprintf(int fd, const char *format, va_list ap)
36		{
37		FILE *stream;
38		int count = 0;
39
40		stream = fdopen(dup(fd), "a+");
41		if (stream) {
42		count = vfprintf(stream, format, ap);
43		fclose(stream);
44		}
45		return count;
46		}
47
48		#endif
49
50		#ifndef HAVE_ASPRINTF
51		int
52		asprintf(char *strp, const char fmt, ...)
53		{
54		int ret;
55		va_list ap;
56
57		va_start(ap, fmt);
58		ret = vasprintf(strp, fmt, ap);
59		va_end(ap);
60		return ret;
61		}
62
63		#endif
64
65		#ifndef HAVE_VASPRINTF
66		int
67		vasprintf(char *strp, const char fmt, va_list ap)
68		{
69		va_list ap2;
70
71		va_copy(ap2, ap);
72		int l = vsnprintf(0, 0, fmt, ap2);
73
74		va_end(ap2);
75
76		if ((l < 0) \|\| !(*strp = malloc(l + 1U))) {
77		return -1;
78		}
79
80		return vsnprintf(*strp, l + 1U, fmt, ap);
81		}
82
83		#endif
84
85		#ifndef HAVE_GETLINE
86		ssize_t
87		getline(char *lineptr, size_t n, FILE *stream)
88		{
89		static char line[256];
90		char *ptr;
91		ssize_t len;
92
93		if (!lineptr \|\| !n) {
94		errno = EINVAL;
95		return -1;
96		}
97
98		if (ferror(stream) \|\| feof(stream)) {
99		return -1;
100		}
101
102		if (!fgets(line, 256, stream)) {
103		return -1;
104		}
105
106		ptr = strchr(line, '\n');
107		if (ptr) {
108		*ptr = '\0';
109		}
110
111		len = strlen(line);
112
113		if (len + 1 < 256) {
114		ptr = realloc(*lineptr, 256);
115		if (!ptr) {
116		return -1;
117		}
118		*lineptr = ptr;
119		*n = 256;
120		}
121
122		strcpy(*lineptr, line);
123		return len;
124		}
125
126		#endif
127
128		#ifndef HAVE_STRNDUP
129		char *
130		strndup(const char *s, size_t n)
131		{
132		char *buf;
133		size_t len = 0;
134
135		/* strnlen */
136		for ( ; (len < n) && (s[len] != '\0'); ++len) {}
137
138		if (!(buf = malloc(len + 1U))) {
139		return NULL;
140		}
141
142		memcpy(buf, s, len);
143		buf[len] = '\0';
144		return buf;
145		}
146
147		#endif
148
149		#ifndef HAVE_STRNSTR
150		char *
151		strnstr(const char s, const char find, size_t slen)
152	281k	{
153	281k	char c, sc;
154	281k	size_t len;
155
156	281k	if ((c = *find++) != '\0') {
157	281k	len = strlen(find);
158	281k	do {
159	2.02M	do {
160	2.02M	if ((slen-- < 1) \|\| ((sc = *s++) == '\0')) {
161	168k	return NULL;
162	168k	}
163	2.02M	} while (sc != c);
164	112k	if (len > slen) {
165	0	return NULL;
166	0	}
167	112k	} while (strncmp(s, find, len));
168	112k	s--;
169	112k	}
170	112k	return (char *)s;
171	281k	}
172
173		#endif
174
175		#ifndef HAVE_STRCHRNUL
176		char *
177		strchrnul(const char *s, int c)
178		{
179		char *p = strchr(s, c);
180
181		return p ? p : (char *)s + strlen(s);
182		}
183
184		#endif
185
186		#ifndef HAVE_GET_CURRENT_DIR_NAME
187		char *
188		get_current_dir_name(void)
189		{
190		char tmp[_POSIX_PATH_MAX];
191		char *retval = NULL;
192
193		if (getcwd(tmp, sizeof(tmp))) {
194		retval = strdup(tmp);
195		if (!retval) {
196		errno = ENOMEM;
197		}
198		}
199
200		return retval;
201		}
202
203		#endif
204
205		#ifndef _MSC_VER
206		#ifndef HAVE_PTHREAD_MUTEX_TIMEDLOCK
207		int
208		pthread_mutex_timedlock(pthread_mutex_t mutex, const struct timespec abstime)
209		{
210		int64_t nsec_diff;
211		int32_t diff;
212		struct timespec cur, dur;
213		int rc;
214
215		/* try to acquire the lock and, if we fail, sleep for 5ms. */
216		while ((rc = pthread_mutex_trylock(mutex)) == EBUSY) {
217		/* get real time */
218		#ifdef CLOCK_REALTIME
219		clock_gettime(CLOCK_REALTIME, &cur);
220		#else
221		struct timeval tv;
222
223		gettimeofday(&tv, NULL);
224		cur.tv_sec = (time_t)tv.tv_sec;
225		cur.tv_nsec = 1000L * (long)tv.tv_usec;
226		#endif
227
228		/* get time diff */
229		nsec_diff = 0;
230		nsec_diff += (((int64_t)abstime->tv_sec) - ((int64_t)cur.tv_sec)) * 1000000000L;
231		nsec_diff += ((int64_t)abstime->tv_nsec) - ((int64_t)cur.tv_nsec);
232		diff = (nsec_diff ? nsec_diff / 1000000L : 0);
233
234		if (diff < 1) {
235		/* timeout */
236		break;
237		} else if (diff < 5) {
238		/* sleep until timeout */
239		dur.tv_sec = 0;
240		dur.tv_nsec = (long)diff * 1000000;
241		} else {
242		/* sleep 5 ms */
243		dur.tv_sec = 0;
244		dur.tv_nsec = 5000000;
245		}
246
247		nanosleep(&dur, NULL);
248		}
249
250		return rc;
251		}
252
253		#endif
254		#endif
255
256		#ifndef HAVE_REALPATH
257		#ifdef _WIN32
258		char *
259		realpath(const char path, char resolved_path)
260		{
261		char *resolved = _fullpath(resolved_path, path, PATH_MAX);
262
263		if ((_access(resolved, 0) == -1) && (errno == ENOENT)) {
264		return NULL;
265		}
266		return resolved;
267		}
268
269		#elif defined (__NetBSD__)
270		char *
271		realpath(const char path, char resolved_path)
272		{
273		ssize_t nbytes;
274
275		nbytes = readlink(path, resolved_path, PATH_MAX);
276		if (nbytes == -1) {
277		return NULL;
278		}
279		return resolved_path;
280		}
281
282		#else
283		#error No realpath() implementation for this platform is available.
284		#endif
285		#endif
286
287		#ifndef HAVE_LOCALTIME_R
288		#ifdef _WIN32
289		struct tm *
290		localtime_r(const time_t timep, struct tm result)
291		{
292		errno_t res = localtime_s(result, timep);
293
294		if (res) {
295		return NULL;
296		} else {
297		return result;
298		}
299		}
300
301		#else
302		#error No localtime_r() implementation for this platform is available.
303		#endif
304		#endif
305
306		#ifndef HAVE_GMTIME_R
307		#ifdef _WIN32
308		struct tm *
309		gmtime_r(const time_t timep, struct tm result)
310		{
311		errno_t res = gmtime_s(result, timep);
312
313		if (res) {
314		return NULL;
315		} else {
316		return result;
317		}
318		}
319
320		#else
321		#error No gmtime_r() implementation for this platform is available.
322		#endif
323		#endif
324
325		#ifndef HAVE_SETENV
326		#ifdef _WIN32
327		int
328		setenv(const char name, const char value, int overwrite)
329		{
330		int errcode = 0;
331
332		if (!overwrite) {
333		size_t envsize = 0;
334
335		errcode = getenv_s(&envsize, NULL, 0, name);
336		if (errcode \|\| envsize) {
337		return errcode;
338		}
339		}
340		return _putenv_s(name, value);
341		}
342
343		#else
344		#error No setenv() implementation for this platform is available.
345		#endif
346		#endif