ze-filter  (ze-filter-0.8.0-develop-180218)
zeStrConvert.c
Go to the documentation of this file.
1 
2 /*
3  *
4  * ze-filter - Mail Server Filter for sendmail
5  *
6  * Copyright (c) 2001-2018 - Jose-Marcio Martins da Cruz
7  *
8  * Auteur : Jose Marcio Martins da Cruz
9  * jose.marcio.mc@gmail.org
10  *
11  * Historique :
12  * Creation : Fri Oct 27 10:46:40 CEST 2006
13  *
14  * This program is free software, but with restricted license :
15  *
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
20  *
21  * More details about ze-filter license can be found at ze-filter
22  * web site : http://foss.jose-marcio.org
23  */
24 
25 
26 #include <ze-sys.h>
27 #include <libze.h>
28 
29 
30 /* ****************************************************************************
31  * *
32  * *
33  ******************************************************************************/
34 long
35 zeStr2long(s, eno, dval)
36  char *s;
37  int *eno;
38  long dval;
39 {
40  char *eptr;
41  long r = 0;
42 
43  if (s == NULL)
44  return 0;
45 
46  errno = 0;
47 #if HAVE_STRTOL
48  r = strtol(s, &eptr, 10);
49 
50  if (eno != NULL)
51  *eno = errno;
52  switch (errno) {
53  case ERANGE:
54  case EINVAL:
55  return dval;
56  break;
57  }
58 
59  if (strlen(eptr) > 0) {
60  eptr += strspn(eptr, " \t");
61  switch (*eptr) {
62  case 'K':
63  r *= 1024;
64  break;
65  case 'M':
66  r *= 1024 * 1024;
67  break;
68  case 'G':
69  r *= 1024 * 1024 * 1024;
70  break;
71  case 's':
72  r *= 1;
73  break;
74  case 'm':
75  r *= 60;
76  break;
77  case 'h':
78  r *= 60 * 60;
79  break;
80  case 'd':
81  r *= 60 * 60 * 24;
82  break;
83  case 'w':
84  r *= 7 * 60 * 60 * 24;
85  break;
86  }
87  }
88 #else
89  r = atol(s);
90 #endif
91 
92  return r;
93 }
94 
95 /* ****************************************************************************
96  * *
97  * *
98  ******************************************************************************/
99 unsigned long
100 zeStr2ulong(s, eno, dval)
101  char *s;
102  int *eno;
103  unsigned long dval;
104 {
105  unsigned long r = 0;
106 
107  if (s == NULL)
108  return 0;
109 
110  errno = 0;
111 #if HAVE_STRTOUL
112  r = strtoul(s, NULL, 10);
113 
114  if (eno != NULL)
115  *eno = errno;
116  switch (errno) {
117  case ERANGE:
118  case EINVAL:
119  return dval;
120  break;
121  }
122 #else
123  r = atoul(s);
124 #endif
125 
126  return r;
127 }
128 
129 /* ****************************************************************************
130  * *
131  * *
132  ******************************************************************************/
133 unsigned long long
134 zeStr2ulonglong(s, eno, dval)
135  char *s;
136  int *eno;
137  unsigned long long dval;
138 {
139  unsigned long long r = 0;
140 
141  if (s == NULL)
142  return 0;
143 
144  errno = 0;
145 #if HAVE_STRTOULL
146  r = strtoull(s, NULL, 10);
147 
148  if (eno != NULL)
149  *eno = errno;
150  switch (errno) {
151  case ERANGE:
152  case EINVAL:
153  return dval;
154  break;
155  }
156 #else
157  r = (unsigned long long) atoll(s);
158 #endif
159 
160  return r;
161 }
162 
163 /* ****************************************************************************
164  * *
165  * *
166  ******************************************************************************/
167 long long
168 zeStr2longlong(s, eno, dval)
169  char *s;
170  int *eno;
171  long long dval;
172 {
173  long long r = 0;
174 
175  if (s == NULL)
176  return 0;
177 
178  errno = 0;
179 #if HAVE_STRTOLL
180  r = strtoll(s, NULL, 10);
181 
182  if (eno != NULL)
183  *eno = errno;
184  switch (errno) {
185  case ERANGE:
186  case EINVAL:
187  return dval;
188  break;
189  }
190 #else
191  r = atoll(s);
192 #endif
193 
194  return r;
195 }
196 
197 /* ****************************************************************************
198  * *
199  * *
200  ******************************************************************************/
201 double
202 zeStr2double(s, eno, dval)
203  char *s;
204  int *eno;
205  double dval;
206 {
207  double r = 0;
208 
209  if (s == NULL)
210  return 0;
211 
212  errno = 0;
213 #if HAVE_STRTOD
214  r = strtod(s, NULL);
215 
216  if (eno != NULL)
217  *eno = errno;
218  switch (errno) {
219  case ERANGE:
220  case EINVAL:
221  return dval;
222  break;
223  }
224 #else
225  r = atof(s);
226 #endif
227 
228  return r;
229 }
230 
231 
232 /* ****************************************************************************
233  * *
234  * *
235  ******************************************************************************/
236 size_t
237 zeStr2size(s, eno, dval)
238  char *s;
239  int *eno;
240  size_t dval;
241 {
242  char *eptr;
243  size_t r = 0;
244 
245  if (s == NULL)
246  return 0;
247 
248  errno = 0;
249 #if HAVE_STRTOUL
250  r = strtoul(s, &eptr, 10);
251 
252  if (eno != NULL)
253  *eno = errno;
254  switch (errno) {
255  case ERANGE:
256  case EINVAL:
257  return dval;
258  break;
259  }
260 #else
261  r = atoul(s);
262  eptr = s + strspn(s, "01234567890");
263 #endif
264 
265  if (strlen(eptr) > 0) {
266  eptr += strspn(eptr, " \t");
267  switch (*eptr) {
268  case 'K':
269  case 'k':
270  r *= 1024;
271  break;
272  case 'M':
273  case 'm':
274  r *= 1024 * 1024;
275  break;
276  case 'G':
277  case 'g':
278  r *= 1024 * 1024 * 1024;
279  break;
280  }
281  }
282 
283  return r;
284 }
285 
286 /* ****************************************************************************
287  * *
288  * *
289  ******************************************************************************/
290 time_t
291 zeStr2time(s, eno, dval)
292  char *s;
293  int *eno;
294  time_t dval;
295 {
296  char *eptr;
297  time_t r = 0;
298 
299  if (s == NULL)
300  return 0;
301 
302  errno = 0;
303 #if HAVE_STRTOUL
304  r = strtoul(s, &eptr, 10);
305 
306  if (eno != NULL)
307  *eno = errno;
308  switch (errno) {
309  case ERANGE:
310  case EINVAL:
311  return dval;
312  break;
313  }
314 #else
315  r = atoul(s);
316  eptr = s + strspn(s, "01234567890");
317 #endif
318 
319  if (strlen(eptr) > 0) {
320  eptr += strspn(eptr, " \t");
321  switch (*eptr) {
322  case 's':
323  r *= 1;
324  break;
325  case 'm':
326  r *= 60;
327  break;
328  case 'h':
329  r *= 60 * 60;
330  break;
331  case 'd':
332  r *= 60 * 60 * 24;
333  break;
334  case 'w':
335  r *= 7 * 60 * 60 * 24;
336  break;
337  }
338  }
339 
340  return r;
341 }
double zeStr2double(char *s, int *eno, double dval)
Definition: zeStrConvert.c:202
long long zeStr2longlong(char *s, int *eno, long long dval)
Definition: zeStrConvert.c:168
unsigned long long zeStr2ulonglong(char *s, int *eno, unsigned long long dval)
Definition: zeStrConvert.c:134
#define strtoull
Definition: ze-sys.h:604
unsigned long zeStr2ulong(char *s, int *eno, unsigned long dval)
Definition: zeStrConvert.c:100
long zeStr2long(char *s, int *eno, long dval)
Definition: zeStrConvert.c:35
time_t zeStr2time(char *s, int *eno, time_t dval)
Definition: zeStrConvert.c:291
size_t zeStr2size(char *s, int *eno, size_t dval)
Definition: zeStrConvert.c:237