suricata
util-misc.c
Go to the documentation of this file.
1 /* Copyright (C) 2007-2022 Open Information Security Foundation
2  *
3  * You can copy, redistribute or modify this Program under the terms of
4  * the GNU General Public License version 2 as published by the Free
5  * Software Foundation.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * version 2 along with this program; if not, write to the Free Software
14  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15  * 02110-1301, USA.
16  */
17 
18 /**
19  * \file
20  *
21  * \author Anoop Saldanha <anoopsaldanha@gmail.com>
22  */
23 
24 #include "suricata-common.h"
25 #include "suricata.h"
26 #include "util-byte.h"
27 #include "util-debug.h"
28 #include "util-misc.h"
29 #include "util-validate.h"
30 
31 #define PARSE_REGEX "^\\s*(\\d+(?:.\\d+)?)\\s*([a-zA-Z]{2,3})?\\s*$"
32 static pcre2_code *parse_regex = NULL;
33 static pcre2_match_data *parse_regex_match = NULL;
34 
35 void ParseSizeInit(void)
36 {
37  int en;
38  PCRE2_SIZE eo;
39  int opts = 0;
40 
41  parse_regex =
42  pcre2_compile((PCRE2_SPTR8)PARSE_REGEX, PCRE2_ZERO_TERMINATED, opts, &en, &eo, NULL);
43  if (parse_regex == NULL) {
44  PCRE2_UCHAR errbuffer[256];
45  pcre2_get_error_message(en, errbuffer, sizeof(errbuffer));
46  SCLogError("pcre2 compile of \"%s\" failed at "
47  "offset %d: %s",
48  PARSE_REGEX, (int)eo, errbuffer);
49  exit(EXIT_FAILURE);
50  }
51  parse_regex_match = pcre2_match_data_create_from_pattern(parse_regex, NULL);
52 }
53 
54 void ParseSizeDeinit(void)
55 {
56  pcre2_code_free(parse_regex);
57  pcre2_match_data_free(parse_regex_match);
58 }
59 
60 /* size string parsing API */
61 
62 static int ParseSizeString(const char *size, double *res)
63 {
64  int pcre2_match_ret;
65  int r;
66  int retval = 0;
67  char str[128];
68  char str2[128];
69 
70  *res = 0;
71 
72  if (size == NULL) {
73  SCLogError("invalid size argument: NULL. Valid input is <number><unit>. Unit can be "
74  "kb/KiB, mb/MiB or gb/GiB");
75  retval = -2;
76  goto end;
77  }
78 
79  pcre2_match_ret = pcre2_match(
80  parse_regex, (PCRE2_SPTR8)size, strlen(size), 0, 0, parse_regex_match, NULL);
81 
82  if (!(pcre2_match_ret == 2 || pcre2_match_ret == 3)) {
83  SCLogError("invalid size argument: '%s'. Valid input is <number><unit>. Unit can be "
84  "kb/KiB, mb/MiB or gb/GiB",
85  size);
86  retval = -2;
87  goto end;
88  }
89 
90  size_t copylen = sizeof(str);
91  r = pcre2_substring_copy_bynumber(parse_regex_match, 1, (PCRE2_UCHAR8 *)str, &copylen);
92  if (r < 0) {
93  SCLogError("pcre2_substring_copy_bynumber failed");
94  retval = -2;
95  goto end;
96  }
97 
98  char *endptr, *str_ptr = str;
99  errno = 0;
100  *res = strtod(str_ptr, &endptr);
101  if (errno == ERANGE) {
102  SCLogError("Numeric value out of range");
103  retval = -1;
104  goto end;
105  } else if (endptr == str_ptr) {
106  SCLogError("Invalid numeric value");
107  retval = -1;
108  goto end;
109  }
110 
111  if (pcre2_match_ret == 3) {
112  copylen = sizeof(str2);
113  r = pcre2_substring_copy_bynumber(parse_regex_match, 2, (PCRE2_UCHAR8 *)str2, &copylen);
114 
115  if (r < 0) {
116  SCLogError("pcre2_substring_copy_bynumber failed");
117  retval = -2;
118  goto end;
119  }
120 
121  if (strcasecmp(str2, "kb") == 0 || strcmp(str2, "KiB") == 0) {
122  *res *= 1024;
123  } else if (strcasecmp(str2, "mb") == 0 || strcmp(str2, "MiB") == 0) {
124  *res *= 1024 * 1024;
125  } else if (strcasecmp(str2, "gb") == 0 || strcmp(str2, "GiB") == 0) {
126  *res *= 1024 * 1024 * 1024;
127  } else {
128  /* Bad unit. */
129  retval = -1;
130  goto end;
131  }
132  }
133 
134  retval = 0;
135 end:
136  return retval;
137 }
138 
139 int ParseSizeStringU8(const char *size, uint8_t *res)
140 {
141  double temp_res = 0;
142 
143  *res = 0;
144  int r = ParseSizeString(size, &temp_res);
145  if (r < 0)
146  return r;
147 
148  if (temp_res > UINT8_MAX)
149  return -1;
150 
151  *res = temp_res;
152 
153  return 0;
154 }
155 
156 int ParseSizeStringU16(const char *size, uint16_t *res)
157 {
158  double temp_res = 0;
159 
160  *res = 0;
161  int r = ParseSizeString(size, &temp_res);
162  if (r < 0)
163  return r;
164 
165  if (temp_res > UINT16_MAX)
166  return -1;
167 
168  *res = temp_res;
169 
170  return 0;
171 }
172 
173 int ParseSizeStringU32(const char *size, uint32_t *res)
174 {
175  double temp_res = 0;
176 
177  *res = 0;
178  int r = ParseSizeString(size, &temp_res);
179  if (r < 0)
180  return r;
181 
182  if (temp_res > UINT32_MAX)
183  return -1;
184 
185  *res = temp_res;
186 
187  return 0;
188 }
189 
190 int ParseSizeStringU64(const char *size, uint64_t *res)
191 {
192  double temp_res = 0;
193 
194  *res = 0;
195  int r = ParseSizeString(size, &temp_res);
196  if (r < 0)
197  return r;
198 
199  if (temp_res > (double) UINT64_MAX)
200  return -1;
201 
202  *res = temp_res;
203 
204  return 0;
205 }
206 
207 void ShortenString(const char *input,
208  char *output, size_t output_size, char c)
209 {
210  if (output_size == 0)
211  return;
212 
213  const size_t str_len = strlen(input);
214  size_t half = (output_size - 1) / 2;
215 
216  /* If the output size is an even number */
217  if (half * 2 == (output_size - 1)) {
218  half = half - 1;
219  }
220  DEBUG_VALIDATE_BUG_ON(half > output_size);
221  if (half == 0 || half > output_size)
222  return;
223 
224  /* Add the first half to the new string */
225  snprintf(output, half+1, "%s", input);
226 
227  const size_t second_half_len = (output_size - 1) - half - 1;
228 
229  /* Add space and the separator character */
230  const char *second_half_start = input + (str_len - second_half_len);
231 
232  size_t remaining_size = output_size - half;
233 
234  snprintf(output + half, remaining_size, "%c%s", c, second_half_start);
235 }
236 
237 /*********************************Unittests********************************/
238 
239 #ifdef UNITTESTS
240 
241 static int UtilMiscParseSizeStringTest01(void)
242 {
243  const char *str;
244  double result;
245 
246  /* no space */
247 
248  str = "10";
249  result = 0;
250  FAIL_IF(ParseSizeString(str, &result) != 0);
251  FAIL_IF(result != 10);
252 
253  str = "10kb";
254  result = 0;
255  FAIL_IF(ParseSizeString(str, &result) != 0);
256  FAIL_IF(result != 10 * 1024);
257 
258  str = "10Kb";
259  result = 0;
260  FAIL_IF(ParseSizeString(str, &result) != 0);
261  FAIL_IF(result != 10 * 1024);
262 
263  str = "10KB";
264  result = 0;
265  FAIL_IF(ParseSizeString(str, &result) != 0);
266  FAIL_IF(result != 10 * 1024);
267 
268  str = "10mb";
269  result = 0;
270  FAIL_IF(ParseSizeString(str, &result) != 0);
271  FAIL_IF(result != 10 * 1024 * 1024);
272 
273  str = "10gb";
274  result = 0;
275  FAIL_IF(ParseSizeString(str, &result) != 0);
276  FAIL_IF(result != 10737418240UL);
277 
278  /* space start */
279 
280  str = " 10";
281  result = 0;
282  FAIL_IF(ParseSizeString(str, &result) != 0);
283  FAIL_IF(result != 10);
284 
285  str = " 10kb";
286  result = 0;
287  FAIL_IF(ParseSizeString(str, &result) != 0);
288  FAIL_IF(result != 10 * 1024);
289 
290  str = " 10Kb";
291  result = 0;
292  FAIL_IF(ParseSizeString(str, &result) != 0);
293  FAIL_IF(result != 10 * 1024);
294 
295  str = " 10KB";
296  result = 0;
297  FAIL_IF(ParseSizeString(str, &result) != 0);
298  FAIL_IF(result != 10 * 1024);
299 
300  str = " 10mb";
301  result = 0;
302  FAIL_IF(ParseSizeString(str, &result) != 0);
303  FAIL_IF(result != 10 * 1024 * 1024);
304 
305  str = " 10gb";
306  result = 0;
307  FAIL_IF(ParseSizeString(str, &result) != 0);
308  FAIL_IF(result != 10737418240);
309 
310  /* space end */
311 
312  str = "10 ";
313  result = 0;
314  FAIL_IF(ParseSizeString(str, &result) != 0);
315  FAIL_IF(result != 10);
316 
317  str = "10kb ";
318  result = 0;
319  FAIL_IF(ParseSizeString(str, &result) != 0);
320  FAIL_IF(result != 10 * 1024);
321 
322  str = "10Kb ";
323  result = 0;
324  FAIL_IF(ParseSizeString(str, &result) != 0);
325  FAIL_IF(result != 10 * 1024);
326 
327  str = "10KB ";
328  result = 0;
329  FAIL_IF(ParseSizeString(str, &result) != 0);
330  FAIL_IF(result != 10 * 1024);
331 
332  str = "10mb ";
333  result = 0;
334  FAIL_IF(ParseSizeString(str, &result) != 0);
335  FAIL_IF(result != 10 * 1024 * 1024);
336 
337  str = "10gb ";
338  result = 0;
339  FAIL_IF(ParseSizeString(str, &result) != 0);
340  FAIL_IF(result != 10737418240);
341 
342  /* space start - space end */
343 
344  str = " 10 ";
345  result = 0;
346  FAIL_IF(ParseSizeString(str, &result) != 0);
347  FAIL_IF(result != 10);
348 
349  str = " 10kb ";
350  result = 0;
351  FAIL_IF(ParseSizeString(str, &result) != 0);
352  FAIL_IF(result != 10 * 1024);
353 
354  str = " 10Kb ";
355  result = 0;
356  FAIL_IF(ParseSizeString(str, &result) != 0);
357  FAIL_IF(result != 10 * 1024);
358 
359  str = " 10KB ";
360  result = 0;
361  FAIL_IF(ParseSizeString(str, &result) != 0);
362  FAIL_IF(result != 10 * 1024);
363 
364  str = " 10mb ";
365  result = 0;
366  FAIL_IF(ParseSizeString(str, &result) != 0);
367  FAIL_IF(result != 10 * 1024 * 1024);
368 
369  str = " 10gb ";
370  result = 0;
371  FAIL_IF(ParseSizeString(str, &result) != 0);
372  FAIL_IF(result != 10737418240);
373 
374  /* space between number and scale */
375 
376  /* no space */
377 
378  str = "10";
379  result = 0;
380  FAIL_IF(ParseSizeString(str, &result) != 0);
381  FAIL_IF(result != 10);
382 
383  str = "10 kb";
384  result = 0;
385  FAIL_IF(ParseSizeString(str, &result) != 0);
386  FAIL_IF(result != 10 * 1024);
387 
388  str = "10 Kb";
389  result = 0;
390  FAIL_IF(ParseSizeString(str, &result) != 0);
391  FAIL_IF(result != 10 * 1024);
392 
393  str = "10 KB";
394  result = 0;
395  FAIL_IF(ParseSizeString(str, &result) != 0);
396  FAIL_IF(result != 10 * 1024);
397 
398  str = "10 mb";
399  result = 0;
400  FAIL_IF(ParseSizeString(str, &result) != 0);
401  FAIL_IF(result != 10 * 1024 * 1024);
402 
403  str = "10 gb";
404  result = 0;
405  FAIL_IF(ParseSizeString(str, &result) != 0);
406  FAIL_IF(result != 10737418240);
407 
408  /* space start */
409 
410  str = " 10";
411  result = 0;
412  FAIL_IF(ParseSizeString(str, &result) != 0);
413  FAIL_IF(result != 10);
414 
415  str = " 10 kb";
416  result = 0;
417  FAIL_IF(ParseSizeString(str, &result) != 0);
418  FAIL_IF(result != 10 * 1024);
419 
420  str = " 10 Kb";
421  result = 0;
422  FAIL_IF(ParseSizeString(str, &result) != 0);
423  FAIL_IF(result != 10 * 1024);
424 
425  str = " 10 KB";
426  result = 0;
427  FAIL_IF(ParseSizeString(str, &result) != 0);
428  FAIL_IF(result != 10 * 1024);
429 
430  str = " 10 mb";
431  result = 0;
432  FAIL_IF(ParseSizeString(str, &result) != 0);
433  FAIL_IF(result != 10 * 1024 * 1024);
434 
435  str = " 10 gb";
436  result = 0;
437  FAIL_IF(ParseSizeString(str, &result) != 0);
438  FAIL_IF(result != 10737418240);
439 
440  /* space end */
441 
442  str = "10 ";
443  result = 0;
444  FAIL_IF(ParseSizeString(str, &result) != 0);
445  FAIL_IF(result != 10);
446 
447  str = "10 kb ";
448  result = 0;
449  FAIL_IF(ParseSizeString(str, &result) != 0);
450  FAIL_IF(result != 10 * 1024);
451 
452  str = "10 Kb ";
453  result = 0;
454  FAIL_IF(ParseSizeString(str, &result) != 0);
455  FAIL_IF(result != 10 * 1024);
456 
457  str = "10 KB ";
458  result = 0;
459  FAIL_IF(ParseSizeString(str, &result) != 0);
460  FAIL_IF(result != 10 * 1024);
461 
462  str = "10 mb ";
463  result = 0;
464  FAIL_IF(ParseSizeString(str, &result) != 0);
465  FAIL_IF(result != 10 * 1024 * 1024);
466 
467  str = "10 gb ";
468  result = 0;
469  FAIL_IF(ParseSizeString(str, &result) != 0);
470  FAIL_IF(result != 10737418240);
471 
472  /* space start - space end */
473 
474  str = " 10 ";
475  result = 0;
476  FAIL_IF(ParseSizeString(str, &result) != 0);
477  FAIL_IF(result != 10);
478 
479  str = " 10 kb ";
480  result = 0;
481  FAIL_IF(ParseSizeString(str, &result) != 0);
482  FAIL_IF(result != 10 * 1024);
483 
484  str = " 10 Kb ";
485  result = 0;
486  FAIL_IF(ParseSizeString(str, &result) != 0);
487  FAIL_IF(result != 10 * 1024);
488 
489  str = " 10 KB ";
490  result = 0;
491  FAIL_IF(ParseSizeString(str, &result) != 0);
492  FAIL_IF(result != 10 * 1024);
493 
494  str = " 10 mb ";
495  result = 0;
496  FAIL_IF(ParseSizeString(str, &result) != 0);
497  FAIL_IF(result != 10 * 1024 * 1024);
498 
499  str = " 10 gb ";
500  result = 0;
501  FAIL_IF(ParseSizeString(str, &result) != 0);
502  FAIL_IF(result != 10737418240);
503 
504  /* no space */
505 
506  str = "10.5";
507  result = 0;
508  FAIL_IF(ParseSizeString(str, &result) != 0);
509  FAIL_IF(result != 10.5);
510 
511  str = "10.5kb";
512  result = 0;
513  FAIL_IF(ParseSizeString(str, &result) != 0);
514  FAIL_IF(result != 10.5 * 1024);
515 
516  str = "10.5Kb";
517  result = 0;
518  FAIL_IF(ParseSizeString(str, &result) != 0);
519  FAIL_IF(result != 10.5 * 1024);
520 
521  str = "10.5KB";
522  result = 0;
523  FAIL_IF(ParseSizeString(str, &result) != 0);
524  FAIL_IF(result != 10.5 * 1024);
525 
526  str = "10.5mb";
527  result = 0;
528  FAIL_IF(ParseSizeString(str, &result) != 0);
529  FAIL_IF(result != 10.5 * 1024 * 1024);
530 
531  str = "10.5gb";
532  result = 0;
533  FAIL_IF(ParseSizeString(str, &result) != 0);
534  FAIL_IF(result != 10.5 * 1024 * 1024 * 1024);
535 
536  /* space start */
537 
538  str = " 10.5";
539  result = 0;
540  FAIL_IF(ParseSizeString(str, &result) != 0);
541  FAIL_IF(result != 10.5);
542 
543  str = " 10.5kb";
544  result = 0;
545  FAIL_IF(ParseSizeString(str, &result) != 0);
546  FAIL_IF(result != 10.5 * 1024);
547 
548  str = " 10.5Kb";
549  result = 0;
550  FAIL_IF(ParseSizeString(str, &result) != 0);
551  FAIL_IF(result != 10.5 * 1024);
552 
553  str = " 10.5KB";
554  result = 0;
555  FAIL_IF(ParseSizeString(str, &result) != 0);
556  FAIL_IF(result != 10.5 * 1024);
557 
558  str = " 10.5mb";
559  result = 0;
560  FAIL_IF(ParseSizeString(str, &result) != 0);
561  FAIL_IF(result != 10.5 * 1024 * 1024);
562 
563  str = " 10.5gb";
564  result = 0;
565  FAIL_IF(ParseSizeString(str, &result) != 0);
566  FAIL_IF(result != 10.5 * 1024 * 1024 * 1024);
567 
568  /* space end */
569 
570  str = "10.5 ";
571  result = 0;
572  FAIL_IF(ParseSizeString(str, &result) != 0);
573  FAIL_IF(result != 10.5);
574 
575  str = "10.5kb ";
576  result = 0;
577  FAIL_IF(ParseSizeString(str, &result) != 0);
578  FAIL_IF(result != 10.5 * 1024);
579 
580  str = "10.5Kb ";
581  result = 0;
582  FAIL_IF(ParseSizeString(str, &result) != 0);
583  FAIL_IF(result != 10.5 * 1024);
584 
585  str = "10.5KB ";
586  result = 0;
587  FAIL_IF(ParseSizeString(str, &result) != 0);
588  FAIL_IF(result != 10.5 * 1024);
589 
590  str = "10.5mb ";
591  result = 0;
592  FAIL_IF(ParseSizeString(str, &result) != 0);
593  FAIL_IF(result != 10.5 * 1024 * 1024);
594 
595  str = "10.5gb ";
596  result = 0;
597  FAIL_IF(ParseSizeString(str, &result) != 0);
598  FAIL_IF(result != 10.5 * 1024 * 1024 * 1024);
599 
600  /* space start - space end */
601 
602  str = " 10.5 ";
603  result = 0;
604  FAIL_IF(ParseSizeString(str, &result) != 0);
605  FAIL_IF(result != 10.5);
606 
607  str = " 10.5kb ";
608  result = 0;
609  FAIL_IF(ParseSizeString(str, &result) != 0);
610  FAIL_IF(result != 10.5 * 1024);
611 
612  str = " 10.5Kb ";
613  result = 0;
614  FAIL_IF(ParseSizeString(str, &result) != 0);
615  FAIL_IF(result != 10.5 * 1024);
616 
617  str = " 10.5KB ";
618  result = 0;
619  FAIL_IF(ParseSizeString(str, &result) != 0);
620  FAIL_IF(result != 10.5 * 1024);
621 
622  str = " 10.5mb ";
623  result = 0;
624  FAIL_IF(ParseSizeString(str, &result) != 0);
625  FAIL_IF(result != 10.5 * 1024 * 1024);
626 
627  str = " 10.5gb ";
628  result = 0;
629  FAIL_IF(ParseSizeString(str, &result) != 0);
630  FAIL_IF(result != 10.5 * 1024 * 1024 * 1024);
631 
632  /* space between number and scale */
633 
634  /* no space */
635 
636  str = "10.5";
637  result = 0;
638  FAIL_IF(ParseSizeString(str, &result) != 0);
639  FAIL_IF(result != 10.5);
640 
641  str = "10.5 kb";
642  result = 0;
643  FAIL_IF(ParseSizeString(str, &result) != 0);
644  FAIL_IF(result != 10.5 * 1024);
645 
646  str = "10.5 Kb";
647  result = 0;
648  FAIL_IF(ParseSizeString(str, &result) != 0);
649  FAIL_IF(result != 10.5 * 1024);
650 
651  str = "10.5 KB";
652  result = 0;
653  FAIL_IF(ParseSizeString(str, &result) != 0);
654  FAIL_IF(result != 10.5 * 1024);
655 
656  str = "10.5 mb";
657  result = 0;
658  FAIL_IF(ParseSizeString(str, &result) != 0);
659  FAIL_IF(result != 10.5 * 1024 * 1024);
660 
661  str = "10.5 gb";
662  result = 0;
663  FAIL_IF(ParseSizeString(str, &result) != 0);
664  FAIL_IF(result != 10.5 * 1024 * 1024 * 1024);
665 
666  /* space start */
667 
668  str = " 10.5";
669  result = 0;
670  FAIL_IF(ParseSizeString(str, &result) != 0);
671  FAIL_IF(result != 10.5);
672 
673  str = " 10.5 kb";
674  result = 0;
675  FAIL_IF(ParseSizeString(str, &result) != 0);
676  FAIL_IF(result != 10.5 * 1024);
677 
678  str = " 10.5 Kb";
679  result = 0;
680  FAIL_IF(ParseSizeString(str, &result) != 0);
681  FAIL_IF(result != 10.5 * 1024);
682 
683  str = " 10.5 KB";
684  result = 0;
685  FAIL_IF(ParseSizeString(str, &result) != 0);
686  FAIL_IF(result != 10.5 * 1024);
687 
688  str = " 10.5 mb";
689  result = 0;
690  FAIL_IF(ParseSizeString(str, &result) != 0);
691  FAIL_IF(result != 10.5 * 1024 * 1024);
692 
693  str = " 10.5 gb";
694  result = 0;
695  FAIL_IF(ParseSizeString(str, &result) != 0);
696  FAIL_IF(result != 10.5 * 1024 * 1024 * 1024);
697 
698  /* space end */
699 
700  str = "10.5 ";
701  result = 0;
702  FAIL_IF(ParseSizeString(str, &result) != 0);
703  FAIL_IF(result != 10.5);
704 
705  str = "10.5 kb ";
706  result = 0;
707  FAIL_IF(ParseSizeString(str, &result) != 0);
708  FAIL_IF(result != 10.5 * 1024);
709 
710  str = "10.5 Kb ";
711  result = 0;
712  FAIL_IF(ParseSizeString(str, &result) != 0);
713  FAIL_IF(result != 10.5 * 1024);
714 
715  str = "10.5 KB ";
716  result = 0;
717  FAIL_IF(ParseSizeString(str, &result) != 0);
718  FAIL_IF(result != 10.5 * 1024);
719 
720  str = "10.5 mb ";
721  result = 0;
722  FAIL_IF(ParseSizeString(str, &result) != 0);
723  FAIL_IF(result != 10.5 * 1024 * 1024);
724 
725  str = "10.5 gb ";
726  result = 0;
727  FAIL_IF(ParseSizeString(str, &result) != 0);
728  FAIL_IF(result != 10.5 * 1024 * 1024 * 1024);
729 
730  /* space start - space end */
731 
732  str = " 10.5 ";
733  result = 0;
734  FAIL_IF(ParseSizeString(str, &result) != 0);
735  FAIL_IF(result != 10.5);
736 
737  str = " 10.5 kb ";
738  result = 0;
739  FAIL_IF(ParseSizeString(str, &result) != 0);
740  FAIL_IF(result != 10.5 * 1024);
741 
742  str = " 10.5 Kb ";
743  result = 0;
744  FAIL_IF(ParseSizeString(str, &result) != 0);
745  FAIL_IF(result != 10.5 * 1024);
746 
747  str = " 10.5 KB ";
748  result = 0;
749  FAIL_IF(ParseSizeString(str, &result) != 0);
750  FAIL_IF(result != 10.5 * 1024);
751 
752  str = " 10.5 mb ";
753  result = 0;
754  FAIL_IF(ParseSizeString(str, &result) != 0);
755  FAIL_IF(result != 10.5 * 1024 * 1024);
756 
757  str = " 10.5 gb ";
758  result = 0;
759  FAIL_IF(ParseSizeString(str, &result) != 0);
760  FAIL_IF(result != 10.5 * 1024 * 1024 * 1024);
761 
762  /* Should fail on unknown units. */
763  FAIL_IF(ParseSizeString("32eb", &result) == 0);
764 
765  PASS;
766 }
767 
768 static int UtilMiscParseSizeStringTest02(void)
769 {
770  const char *str;
771  double result;
772 
773  str = "10kib";
774  result = 0;
775  FAIL_IF_NOT(ParseSizeString(str, &result) == -1);
776 
777  str = "10Kib";
778  result = 0;
779  FAIL_IF_NOT(ParseSizeString(str, &result) == -1);
780 
781  str = "10KiB";
782  result = 0;
783  FAIL_IF_NOT(ParseSizeString(str, &result) == 0);
784  FAIL_IF(result != 10 * 1024);
785 
786  str = "10mib";
787  result = 0;
788  FAIL_IF_NOT(ParseSizeString(str, &result) == -1);
789 
790  str = "10gib";
791  result = 0;
792  FAIL_IF_NOT(ParseSizeString(str, &result) == -1);
793 
794  str = " 10.5 KiB ";
795  result = 0;
796  FAIL_IF_NOT(ParseSizeString(str, &result) == 0);
797  FAIL_IF(result != 10.5 * 1024);
798 
799  str = " 10.5 MiB ";
800  result = 0;
801  FAIL_IF_NOT(ParseSizeString(str, &result) == 0);
802  FAIL_IF(result != 10.5 * 1024 * 1024);
803 
804  str = " 10.5 GiB ";
805  result = 0;
806  FAIL_IF_NOT(ParseSizeString(str, &result) == 0);
807  FAIL_IF(result != 10.5 * 1024 * 1024 * 1024);
808 
809  PASS;
810 }
811 
812 static int UtilMiscShortenStringTest01(void)
813 {
814  char buffer[100];
815  const char *original = "abcdefghijklmnopqrstuvwxyz";
816  const char sep = '~';
817  const char *expected = NULL;
818 
819  memset(buffer, 0, sizeof(buffer));
820  expected = "abc~wxyz";
821  ShortenString(original, buffer, 9, sep);
822  FAIL_IF_NOT(strcmp(buffer, expected) == 0);
823 
824  memset(buffer, 0, sizeof(buffer));
825  expected = "abcd~wxyz";
826  ShortenString(original, buffer, 10, sep);
827  FAIL_IF_NOT(strcmp(buffer, expected) == 0);
828 
829  memset(buffer, 0, sizeof(buffer));
830  expected = "a~z";
831  ShortenString(original, buffer, 4, sep);
832  FAIL_IF_NOT(strcmp(buffer, expected) == 0);
833 
834  memset(buffer, 0, sizeof(buffer));
835  expected = "";
836  ShortenString(original, buffer, 3, sep);
837  FAIL_IF_NOT(strcmp(buffer, expected) == 0);
838 
839  memset(buffer, 0, sizeof(buffer));
840  expected = "";
841  ShortenString(original, buffer, 2, sep);
842  FAIL_IF_NOT(strcmp(buffer, expected) == 0);
843 
844  memset(buffer, 0, sizeof(buffer));
845  expected = "";
846  ShortenString(original, buffer, 1, sep);
847  FAIL_IF_NOT(strcmp(buffer, expected) == 0);
848 
849  memset(buffer, 0, sizeof(buffer));
850  expected = "";
851  ShortenString(original, buffer, 0, sep);
852  FAIL_IF_NOT(strcmp(buffer, expected) == 0);
853 
854  PASS;
855 }
856 
857 void UtilMiscRegisterTests(void)
858 {
859  UtRegisterTest("UtilMiscParseSizeStringTest01",
860  UtilMiscParseSizeStringTest01);
861  UtRegisterTest("UtilMiscParseSizeStringTest02", UtilMiscParseSizeStringTest02);
862  UtRegisterTest("UtilMiscShortenStringTest01", UtilMiscShortenStringTest01);
863 }
864 #endif /* UNITTESTS */
util-byte.h
ParseSizeStringU16
int ParseSizeStringU16(const char *size, uint16_t *res)
Definition: util-misc.c:156
UtRegisterTest
void UtRegisterTest(const char *name, int(*TestFn)(void))
Register unit test.
Definition: util-unittest.c:101
ParseSizeStringU64
int ParseSizeStringU64(const char *size, uint64_t *res)
Definition: util-misc.c:190
MemcmpTest18Tests::result
int result
Definition: util-memcmp.c:312
ShortenString
void ShortenString(const char *input, char *output, size_t output_size, char c)
Definition: util-misc.c:207
FAIL_IF_NOT
#define FAIL_IF_NOT(expr)
Fail a test if expression evaluates to false.
Definition: util-unittest.h:82
ParseSizeInit
void ParseSizeInit(void)
Definition: util-misc.c:35
util-debug.h
ParseSizeStringU8
int ParseSizeStringU8(const char *size, uint8_t *res)
Definition: util-misc.c:139
PASS
#define PASS
Pass the test.
Definition: util-unittest.h:105
FAIL_IF
#define FAIL_IF(expr)
Fail a test if expression evaluates to true.
Definition: util-unittest.h:71
suricata-common.h
ParseSizeDeinit
void ParseSizeDeinit(void)
Definition: util-misc.c:54
ParseSizeStringU32
int ParseSizeStringU32(const char *size, uint32_t *res)
Definition: util-misc.c:173
util-validate.h
str
#define str(s)
Definition: suricata-common.h:313
SCLogError
#define SCLogError(...)
Macro used to log ERROR messages.
Definition: util-debug.h:274
UtilMiscRegisterTests
void UtilMiscRegisterTests(void)
Definition: util-misc.c:857
suricata.h
util-misc.h
DEBUG_VALIDATE_BUG_ON
#define DEBUG_VALIDATE_BUG_ON(exp)
Definition: util-validate.h:109
PARSE_REGEX
#define PARSE_REGEX
Definition: util-misc.c:31