]>
Commit | Line | Data |
---|---|---|
60918275 LP |
1 | /*-*- Mode: C; c-basic-offset: 8 -*-*/ |
2 | ||
3 | #include <assert.h> | |
4 | #include <string.h> | |
5 | #include <unistd.h> | |
6 | #include <errno.h> | |
85261803 | 7 | #include <stdlib.h> |
60918275 LP |
8 | |
9 | #include "macro.h" | |
10 | #include "util.h" | |
11 | ||
12 | usec_t now(clockid_t clock) { | |
13 | struct timespec ts; | |
14 | ||
15 | assert_se(clock_gettime(clock, &ts) == 0); | |
16 | ||
17 | return timespec_load(&ts); | |
18 | } | |
19 | ||
20 | usec_t timespec_load(const struct timespec *ts) { | |
21 | assert(ts); | |
22 | ||
23 | return | |
24 | (usec_t) ts->tv_sec * USEC_PER_SEC + | |
25 | (usec_t) ts->tv_nsec / NSEC_PER_USEC; | |
26 | } | |
27 | ||
28 | struct timespec *timespec_store(struct timespec *ts, usec_t u) { | |
29 | assert(ts); | |
30 | ||
31 | ts->tv_sec = (time_t) (u / USEC_PER_SEC); | |
32 | ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC); | |
33 | ||
34 | return ts; | |
35 | } | |
36 | ||
37 | usec_t timeval_load(const struct timeval *tv) { | |
38 | assert(tv); | |
39 | ||
40 | return | |
41 | (usec_t) tv->tv_sec * USEC_PER_SEC + | |
42 | (usec_t) tv->tv_usec; | |
43 | } | |
44 | ||
45 | struct timeval *timeval_store(struct timeval *tv, usec_t u) { | |
46 | assert(tv); | |
47 | ||
48 | tv->tv_sec = (time_t) (u / USEC_PER_SEC); | |
49 | tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC); | |
50 | ||
51 | return tv; | |
52 | } | |
53 | ||
54 | bool endswith(const char *s, const char *postfix) { | |
55 | size_t sl, pl; | |
56 | ||
57 | assert(s); | |
58 | assert(postfix); | |
59 | ||
60 | sl = strlen(s); | |
61 | pl = strlen(postfix); | |
62 | ||
63 | if (sl < pl) | |
64 | return false; | |
65 | ||
66 | return memcmp(s + sl - pl, postfix, pl) == 0; | |
67 | } | |
68 | ||
69 | bool startswith(const char *s, const char *prefix) { | |
70 | size_t sl, pl; | |
71 | ||
72 | assert(s); | |
73 | assert(prefix); | |
74 | ||
75 | sl = strlen(s); | |
76 | pl = strlen(prefix); | |
77 | ||
78 | if (sl < pl) | |
79 | return false; | |
80 | ||
81 | return memcmp(s, prefix, pl) == 0; | |
82 | } | |
83 | ||
84 | int nointr_close(int fd) { | |
85 | assert(fd >= 0); | |
86 | ||
87 | for (;;) { | |
88 | int r; | |
89 | ||
90 | if ((r = close(fd)) >= 0) | |
91 | return r; | |
92 | ||
93 | if (errno != EINTR) | |
94 | return r; | |
95 | } | |
96 | } | |
85261803 LP |
97 | |
98 | int parse_boolean(const char *v) { | |
99 | assert(v); | |
100 | ||
101 | if (!strcmp(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on")) | |
102 | return 1; | |
103 | else if (!strcmp(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off")) | |
104 | return 0; | |
105 | ||
106 | return -EINVAL; | |
107 | } | |
108 | ||
109 | int safe_atou(const char *s, unsigned *ret_u) { | |
110 | char *x = NULL; | |
111 | unsigned l; | |
112 | ||
113 | assert(s); | |
114 | assert(ret_u); | |
115 | ||
116 | errno = 0; | |
117 | l = strtoul(s, &x, 0); | |
118 | ||
119 | if (!x || *x || errno) | |
120 | return errno ? -errno : -EINVAL; | |
121 | ||
122 | if ((unsigned) l != l) | |
123 | return -ERANGE; | |
124 | ||
125 | *ret_u = (unsigned) l; | |
126 | return 0; | |
127 | } | |
128 | ||
129 | int safe_atoi(const char *s, int *ret_i) { | |
130 | char *x = NULL; | |
131 | int l; | |
132 | ||
133 | assert(s); | |
134 | assert(ret_i); | |
135 | ||
136 | errno = 0; | |
137 | l = strtol(s, &x, 0); | |
138 | ||
139 | if (!x || *x || errno) | |
140 | return errno ? -errno : -EINVAL; | |
141 | ||
142 | if ((int) l != l) | |
143 | return -ERANGE; | |
144 | ||
145 | *ret_i = (unsigned) l; | |
146 | return 0; | |
147 | } |