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