ze-filter  (ze-filter-0.8.0-develop-180218)
zeStrings.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 : Sun Jun 15 21:10:02 CEST 2014
13  *
14  * This program is free software - GPL v2.,
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19  *
20  */
21 
22 
23 #include <ze-sys.h>
24 #include <libze.h>
25 #include <zeStrings.h>
26 
27 /* #include <ze-filter.h> */
28 
29 /* ****************************************************************************
30  * *
31  * *
32  ******************************************************************************/
33 char *
35  char *s;
36 {
37  int len, i;
38 
39  if (s == NULL)
40  return s;
41 
42  len = strlen(s) - 1;
43  for (i = 0; i <= len / 2; i++)
44  {
45  char t = s[i];
46 
47  s[i] = s[len - i];
48  s[len - i] = t;
49  }
50 
51  return s;
52 }
53 
54 /* ****************************************************************************
55  * *
56  * *
57  **************************************************************************** */
58 char *
60  char *s;
61 {
62  char *p;
63 
64  if (s == NULL)
65  return s;
66 
67  if ((p = strdup(s)) == NULL)
68  {
69  ZE_LogSysError("strdup(%s)", s);
70  return p;
71  }
72 
73  return zeStrRev(p);
74 }
75 
76 /* ****************************************************************************
77  * *
78  * *
79  **************************************************************************** */
80 int
81 zeStrlEqual(sa, sb)
82  char *sa;
83  char *sb;
84 {
85  int nb = 0;
86  int lm, lb;
87 
88  if ((sa == NULL) || (sb == NULL))
89  return 0;
90 
91  lm = strlen(sa);
92  lb = strlen(sb);
93  if (lb < lm)
94  lm = lb;
95 
96  for (nb = 0; (lm > 0) && (*sa == *sb); sa++, sb++, lm--)
97  nb++;
98 
99  return nb;
100 }
101 
102 /* ****************************************************************************
103  * *
104  * *
105  **************************************************************************** */
106 int
107 zeSafeStrnCat(out, sz, in, n)
108  char *out;
109  size_t sz;
110  char *in;
111  size_t n;
112 {
113  char *p;
114  size_t i;
115 
116  if ((out == NULL) || (in == NULL) || (sz == 0))
117  return 0;
118 
119  i = strlen(out);
120  p = out + i;
121  sz -= i;
122 
123  if (--sz < n)
124  n = sz;
125  memcpy(p, in, n);
126  p[n] = '\0';
127 
128  return n;
129 }
130 
131 /* ****************************************************************************
132  * *
133  * *
134  **************************************************************************** */
135 int
136 zeSafeStrnCpy(out, sz, in, n)
137  char *out;
138  size_t sz;
139  char *in;
140  size_t n;
141 {
142  if ((out == NULL) || (in == NULL) || (sz == 0))
143  return 0;
144 
145  if (--sz < n)
146  n = sz;
147  memcpy(out, in, n);
148  out[n] = '\0';
149 
150  return n;
151 }
152 
153 /* ****************************************************************************
154  * *
155  * *
156  **************************************************************************** */
157 char *
158 zeStrnDup(sin, n)
159  const char *sin;
160  size_t n;
161 {
162  char *p = NULL;
163 
164  if (sin == NULL || n == 0)
165  return NULL;
166 
167  if ((p = zeMalloc(n + 1)) != NULL)
168  zeSafeStrnCpy((char *) p, n + 1, (char *) sin, n);
169  else
170  ZE_LogSysError("malloc error");
171 
172  return p;
173 }
174 
175 /* ****************************************************************************
176  * *
177  * *
178  **************************************************************************** */
179 char *
180 zeStrCatDup(s1, s2)
181  char *s1;
182  char *s2;
183 {
184  char *p = NULL;
185  size_t sz;
186 
187  if (s1 == NULL && s2 == NULL)
188  return NULL;
189  s1 = STRNULL(s1, "");
190  s2 = STRNULL(s2, "");
191  sz = strlen(s1) + strlen(s2) + 1;
192  if ((p = malloc(sz)) != NULL)
193  snprintf(p, sz, "%s%s", s1, s2);
194  return p;
195 }
196 
197 /* ****************************************************************************
198  * *
199  * *
200  **************************************************************************** */
201 int
203  char *s;
204  int c;
205 {
206  int n = 0;
207  char *p;
208 
209  if (s == NULL)
210  return 0;
211  for (p = s; *p != '\0'; p++)
212  if (*p == '.')
213  n++;
214 
215  return n;
216 }
217 
218 
219 /* ****************************************************************************
220  * *
221  * *
222  ******************************************************************************/
223 char *
224 zeStrJoin(sep, argc, argv)
225  char *sep;
226  int argc;
227  char **argv;
228 {
229  size_t nlen = 0;
230  int i;
231  char *s = NULL;
232 
233  for (i = 0, nlen = 0; i < argc && argv[i] != NULL; i++)
234  nlen += strlen(argv[i]);
235  nlen += (argc - 1) * strlen(sep);
236 
237  s = (char *) malloc(nlen + 1);
238  strlcpy(s, argv[0], nlen + 1);
239  for (i = 1; i < argc; i++) {
240  strlcat(s, sep, nlen + 1);
241  strlcat(s, argv[i], nlen + 1);
242  }
243  return s;
244 }
245 
246 
247 /* ****************************************************************************
248  * *
249  * *
250  ******************************************************************************/
251 char *
253  char *s;
254 {
255  char *p;
256  size_t sz = 0;
257 
258  if (s == NULL)
259  return NULL;
260 
261  sz = strlen(s) + 1;
262  p = malloc(sz);
263  if (p != NULL)
264  strlcpy(p, s, sz);
265  else
266  ZE_LogSysError("malloc(s)");
267 
268  return p;
269 }
270 
271 /* ****************************************************************************
272  * *
273  * *
274  ******************************************************************************/
275 void *
277  size_t sz;
278 {
279  void *p;
280  size_t xtra = (8 - sz % 8) % 8;
281 
282  p = malloc(sz + xtra);
283  if (p == NULL) {
284  ZE_LogSysError("malloc(%lu)", (unsigned long) (sz + xtra));
285  }
286 
287  return p;
288 }
289 
290 /* ****************************************************************************
291  * *
292  * *
293  ******************************************************************************/
294 char *
296  char *s;
297 {
298  char *p;
299 
300  if (s == NULL)
301  return NULL;
302  for (p = s; *p != '\0'; p++)
303  *p = tolower(*p);
304  return s;
305 }
306 
307 /* ****************************************************************************
308  * *
309  * *
310  ******************************************************************************/
311 char *
313  char *s;
314 {
315  char *p;
316 
317  if (s == NULL)
318  return NULL;
319  for (p = s; *p != '\0'; p++)
320  *p = toupper(*p);
321  return s;
322 }
323 
324 
325 /* ****************************************************************************
326  * *
327  * *
328  ******************************************************************************/
329 char *
330 zeStrSet(dst, c, len)
331  char *dst;
332  int c;
333  int len;
334 {
335  if (dst != NULL) {
336  memset(dst, (int) c, len);
337  dst[len] = '\0';
338  }
339  return dst;
340 }
341 
342 /* ****************************************************************************
343  * *
344  * *
345  ******************************************************************************/
346 void
348  char *s;
349  int len;
350 {
351  char *p = s;
352 
353  if (s == NULL)
354  return;
355 
356  while (len-- > 0) {
357  if (*p == '\0')
358  *p = ' ';
359  p++;
360  }
361 }
362 
363 /* ****************************************************************************
364  * *
365  * *
366  ******************************************************************************/
367 size_t
369  char *s;
370  size_t sz;
371 {
372  size_t nsz = 0;
373  char *p, *q;
374  size_t i;
375 
376  if (s == NULL)
377  return 0;
378 
379  p = q = s;
380  for (i = 0; i < sz; i++, p++) {
381  switch (*p) {
382  case '\0':
383  break;
384  default:
385  *q++ = *p;
386  nsz++;
387  break;
388  }
389  }
390  *q = '\0';
391 
392  return nsz;
393 }
394 
395 /* ****************************************************************************
396  * *
397  * *
398  ******************************************************************************/
399 char *
401  char *s;
402  size_t size;
403 {
404  char *p, *q;
405 
406  if (s == NULL)
407  return NULL;
408 
409  p = q = s;
410  while ((*p != '\0') && (size-- > 0)) {
411  if (!isblank(*p))
412  *q++ = *p;
413  p++;
414  }
415  *q = '\0';
416 
417  return s;
418 }
419 
420 /* ****************************************************************************
421  * *
422  * *
423  ******************************************************************************/
424 char *
426  char *s;
427  size_t size;
428 {
429  char *p, *q;
430 
431  if (s == NULL)
432  return NULL;
433 
434  p = q = s;
435  while ((*p != '\0') && (size-- > 0)) {
436  if (!isblank(*p))
437  *q++ = *p;
438  p++;
439  }
440  *q = '\0';
441 
442  return s;
443 }
444 
445 /* ****************************************************************************
446  * *
447  * *
448  ******************************************************************************/
449 char *
451  char *s;
452  size_t size;
453 {
454  char *p, *q;
455 
456  if (s == NULL)
457  return NULL;
458 
459  p = q = s;
460  while ((*p != '\0') && (size-- > 0)) {
461  if (!isblank(*p))
462  *q++ = *p;
463  p++;
464  }
465  *q = '\0';
466 
467  return s;
468 }
469 
470 
471 /* ****************************************************************************
472  * *
473  * *
474  ******************************************************************************/
475 char *
477  char *s;
478 {
479  char *p, *last;
480  size_t n;
481 
482  if (s == NULL || strlen(s) == 0)
483  return s;
484 
485  for (p = last = s; *p != '\0'; p++)
486  if (isblank(*p) == 0)
487  last = p;
488 
489  if (isblank(*last) == 0)
490  last++;
491  *last = '\0';
492 
493  return s;
494 }
495 
496 /* ****************************************************************************
497  * *
498  * *
499  **************************************************************************** */
500 char *
502  char *s;
503 {
504  int n;
505 
506  if ((s == NULL) || (strlen(s) == 0))
507  return s;
508 
509  n = strlen(s) - 1;
510 
511 #if 0
512  {
513  char *p;
514 
515  for (p = s + n; (n >= 0) && (*p != '\0'); p--, n--)
516  {
517  if ((*p != '\n') && (*p != '\r'))
518  break;
519  *p = '\0';
520  }
521  }
522 #else
523  while ((n = strlen(s)) > 0)
524  {
525  if ((s[n - 1] != '\n') && (s[n - 1] != '\r'))
526  break;
527  s[n - 1] = '\0';
528  }
529 #endif
530  return s;
531 }
532 
533 /* ****************************************************************************
534  * *
535  * *
536  ******************************************************************************/
537 #if defined(REGCOMP_FLAGS)
538 #undef REGCOMP_FLAGS
539 #endif
540 
541 #define REGCOMP_FLAGS (REG_ICASE | REG_EXTENDED)
542 
543 bool
544 zeStrRegex(s, expr, pi, pf, icase)
545  char *s;
546  char *expr;
547  long *pi;
548  long *pf;
549  bool icase;
550 {
551  regex_t re;
552  bool found = FALSE;
553  int rerror;
554  int flags;
555 
556  if ((s == NULL) || (expr == NULL))
557  return FALSE;
558 
559  flags = REG_EXTENDED | (icase ? REG_ICASE : 0);
560  if ((rerror = regcomp(&re, expr, flags)) == 0) {
561  regmatch_t pm;
562 
563  if (regexec(&re, s, 1, &pm, 0) == 0) {
564  if (pi != NULL)
565  *pi = pm.rm_so;
566  if (pf != NULL)
567  *pf = pm.rm_eo;
568  found = TRUE;
569  }
570  regfree(&re);
571  } else {
572  char s[256];
573 
574  if (regerror(rerror, &re, s, sizeof (s)) > 0)
575  ZE_LogMsgError(0, "regcomp(%s) error : %s", expr, s);
576  }
577 
578  return found;
579 }
580 
581 /* ****************************************************************************
582  * *
583  * *
584  ******************************************************************************/
585 void
586 zeStrCenter(dst, org, ldst)
587  char *dst;
588  char *org;
589  int ldst;
590 {
591  char *p;
592  size_t lorg;
593 
594  memset(dst, 0, ldst);
595  lorg = strlen(org);
596  if (ldst <= lorg + 1) {
597  strlcpy(dst, org, ldst);
598  return;
599  }
600  if (ldst > lorg + 1)
601  memset(dst, ' ', (ldst - lorg) / 2);
602  strlcat(dst, org, ldst);
603 }
604 
605 /* ****************************************************************************
606  * *
607  * *
608  ******************************************************************************/
609 int
610 zeStr2Tokens(s, sz, argv, sep)
611  char *s;
612  int sz;
613  char **argv;
614  char *sep;
615 {
616  int i;
617  char *p, *ptr;
618 
619  if (s == NULL || argv == NULL || sz == 0)
620  return 0;
621 
622  sep = STRNULL(sep, ":,");
623 
624  for (i = 0; i < sz; i++)
625  argv[i] = NULL;
626  for (p = strtok_r(s, sep, &ptr), i = 0;
627  p != NULL && i < sz - 1; p = strtok_r(NULL, sep, &ptr), i++) {
628  argv[i] = p;
629  }
630  argv[i] = NULL;
631 
632  return i;
633 }
634 
635 /* ****************************************************************************
636  * *
637  * *
638  **************************************************************************** */
639 #if NEED_SM_SNPRINTF
640 /* Inserted and modified by Jose Marcio Martins da Cruz to
641  replace need to include libsm or libsmutil from sendmail
642  versions older than 8.12.2 */
643 
644 /* Copyright (C) 1991, 1995, 1997, 1998 Free Software Foundation, Inc.
645  This file is part of the GNU C Library.
646 
647  The GNU C Library is free software; you can redistribute it and/or
648  modify it under the terms of the GNU Lesser General Public
649  License as published by the Free Software Foundation; either
650  version 2.1 of the License, or (at your option) any later version.
651 
652  The GNU C Library is distributed in the hope that it will be useful,
653  but WITHOUT ANY WARRANTY; without even the implied warranty of
654  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
655  Lesser General Public License for more details.
656 
657  You should have received a copy of the GNU Lesser General Public
658  License along with the GNU C Library; if not, write to the Free
659  Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
660  02111-1307 USA. */
661 
662 
663 /* Write formatted output into S, according to the format
664  string FORMAT, writing no more than MAXLEN characters. */
665 /* VARARGS3 */
666 
667 int
668 zm_snprintf(char *s, size_t maxlen, const char *format, ...)
669 {
670  va_list arg;
671  int done;
672 
673  va_start(arg, format);
674  done = vsnprintf(s, maxlen, format, arg);
675  va_end(arg);
676  return done;
677 }
678 
679 #endif
680 
681 /* ****************************************************************************
682  * *
683  * *
684  ******************************************************************************/
685 time_t
687  char *s;
688 {
689  int l;
690  time_t n;
691  char strn[16];
692 
693  if ((s == NULL) || (strlen(s) == 0))
694  return 3600;
695 
696  if ((l = strspn(s, "0123456789")) == 0)
697  return 3600;
698 
699  if (l >= (sizeof (strn)))
700  return 3600;
701 
702  memset(strn, 0, sizeof (strn));
703  strncpy(strn, s, l);
704 
705 #if HAVE_STRTOL
706  errno = 0;
707  n = strtol(strn, (char **) NULL, 10);
708  if (errno == ERANGE || errno == EINVAL || n <= 0)
709  n = 3600;
710 #else
711  n = atoi(strn);
712  if (n <= 0 | n > 32)
713  n = 3600;
714 #endif
715  s += l;
716 
717  if (strlen(s) == 0)
718  return n;
719 
720  switch (*s) {
721  case 's':
722  case 'S':
723  return n;
724  break;
725  case 'm':
726  case 'M':
727  return 60 * n;
728  break;
729  case 'h':
730  case 'H':
731  return 3600 * n;
732  break;
733  case 'd':
734  case 'D':
735  return 86400 * n;
736  break;
737  }
738  return 3600;
739 }
740 
741 
char * zeStrDupRev(char *s)
Definition: zeStrings.c:59
char * zeStrChomp(char *s)
Definition: zeStrings.c:501
char * zeStrSet(char *dst, int c, int len)
Definition: zeStrings.c:330
void zeStrCenter(char *dst, char *org, int ldst)
Definition: zeStrings.c:586
#define STRNULL(x, r)
Definition: macros.h:81
char * zeStrnDup(char *sin, size_t n) const
Definition: zeStrings.c:158
char * zeStrRmHeadBlanks(char *s, size_t size)
Definition: zeStrings.c:425
#define FALSE
Definition: macros.h:160
#define strlcpy
Definition: zeString.h:32
#define ZE_LogMsgError(level,...)
Definition: zeSyslog.h:113
int zeSafeStrnCat(char *out, size_t sz, char *in, size_t n)
Definition: zeStrings.c:107
char * zeStrRev(char *s)
Definition: zeStrings.c:34
#define strlcat
Definition: zeString.h:28
size_t zeStrRmNulls(char *s, size_t sz)
Definition: zeStrings.c:368
int zeStrlEqual(char *sa, char *sb)
Definition: zeStrings.c:81
char * zeStrDup(char *s)
Definition: zeStrings.c:252
char * zeStr2Upper(char *s)
Definition: zeStrings.c:312
char * zeStrJoin(char *sep, int argc, char **argv)
Definition: zeStrings.c:224
char * zeStr2Lower(char *s)
Definition: zeStrings.c:295
int zeStr2Tokens(char *s, int sz, char **argv, char *sep)
Definition: zeStrings.c:610
int nb
Definition: ze-connopen.c:61
#define TRUE
Definition: macros.h:157
char * zeStrCatDup(char *s1, char *s2)
Definition: zeStrings.c:180
#define memcpy(d, s, n)
Definition: ze-sys.h:224
#define ZE_LogSysError(...)
Definition: zeSyslog.h:129
char * zeStrClearTrailingBlanks(char *s)
Definition: zeStrings.c:476
#define isblank(c)
Definition: ze-sys.h:454
time_t last
Definition: ze-connopen.c:60
void * zeMalloc(size_t sz)
Definition: zeStrings.c:276
char * zeStrRmTailBlanks(char *s, size_t size)
Definition: zeStrings.c:450
int zeStrCountChar(char *s, int c)
Definition: zeStrings.c:202
time_t zeStrTime2Secs(char *s)
Definition: zeStrings.c:686
bool zeStrRegex(char *s, char *expr, long *pi, long *pf, bool icase)
Definition: zeStrings.c:544
char * zeStrRmBlanks(char *s, size_t size)
Definition: zeStrings.c:400
void zeStrChkNull(char *s, int len)
Definition: zeStrings.c:347
int zeSafeStrnCpy(char *out, size_t sz, char *in, size_t n)
Definition: zeStrings.c:136