suricata
util-misc.c
Go to the documentation of this file.
1 /* Copyright (C) 2007-2010 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 
31 #define PARSE_REGEX "^\\s*(\\d+(?:.\\d+)?)\\s*([a-zA-Z]{2})?\\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));
47  "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(SC_ERR_INVALID_ARGUMENTS,"invalid size argument - NULL. Valid size "
75  "argument should be in the format - \n"
76  "xxx <- indicates it is just bytes\n"
77  "xxxkb or xxxKb or xxxKB or xxxkB <- indicates kilobytes\n"
78  "xxxmb or xxxMb or xxxMB or xxxmB <- indicates megabytes\n"
79  "xxxgb or xxxGb or xxxGB or xxxgB <- indicates gigabytes.\n"
80  );
81  retval = -2;
82  goto end;
83  }
84 
85  pcre2_match_ret = pcre2_match(
86  parse_regex, (PCRE2_SPTR8)size, strlen(size), 0, 0, parse_regex_match, NULL);
87 
88  if (!(pcre2_match_ret == 2 || pcre2_match_ret == 3)) {
89  SCLogError(SC_ERR_PCRE_MATCH, "invalid size argument - %s. Valid size "
90  "argument should be in the format - \n"
91  "xxx <- indicates it is just bytes\n"
92  "xxxkb or xxxKb or xxxKB or xxxkB <- indicates kilobytes\n"
93  "xxxmb or xxxMb or xxxMB or xxxmB <- indicates megabytes\n"
94  "xxxgb or xxxGb or xxxGB or xxxgB <- indicates gigabytes.\n",
95  size);
96  retval = -2;
97  goto end;
98  }
99 
100  size_t copylen = sizeof(str);
101  r = pcre2_substring_copy_bynumber(parse_regex_match, 1, (PCRE2_UCHAR8 *)str, &copylen);
102  if (r < 0) {
103  SCLogError(SC_ERR_PCRE_GET_SUBSTRING, "pcre2_substring_copy_bynumber failed");
104  retval = -2;
105  goto end;
106  }
107 
108  char *endptr, *str_ptr = str;
109  errno = 0;
110  *res = strtod(str_ptr, &endptr);
111  if (errno == ERANGE) {
112  SCLogError(SC_ERR_NUMERIC_VALUE_ERANGE, "Numeric value out of range");
113  retval = -1;
114  goto end;
115  } else if (endptr == str_ptr) {
116  SCLogError(SC_ERR_INVALID_NUMERIC_VALUE, "Invalid numeric value");
117  retval = -1;
118  goto end;
119  }
120 
121  if (pcre2_match_ret == 3) {
122  copylen = sizeof(str2);
123  r = pcre2_substring_copy_bynumber(parse_regex_match, 2, (PCRE2_UCHAR8 *)str2, &copylen);
124 
125  if (r < 0) {
126  SCLogError(SC_ERR_PCRE_GET_SUBSTRING, "pcre2_substring_copy_bynumber failed");
127  retval = -2;
128  goto end;
129  }
130 
131  if (strcasecmp(str2, "kb") == 0) {
132  *res *= 1024;
133  } else if (strcasecmp(str2, "mb") == 0) {
134  *res *= 1024 * 1024;
135  } else if (strcasecmp(str2, "gb") == 0) {
136  *res *= 1024 * 1024 * 1024;
137  } else {
138  /* Bad unit. */
139  retval = -1;
140  goto end;
141  }
142  }
143 
144  retval = 0;
145 end:
146  return retval;
147 }
148 
149 int ParseSizeStringU8(const char *size, uint8_t *res)
150 {
151  double temp_res = 0;
152 
153  *res = 0;
154  int r = ParseSizeString(size, &temp_res);
155  if (r < 0)
156  return r;
157 
158  if (temp_res > UINT8_MAX)
159  return -1;
160 
161  *res = temp_res;
162 
163  return 0;
164 }
165 
166 int ParseSizeStringU16(const char *size, uint16_t *res)
167 {
168  double temp_res = 0;
169 
170  *res = 0;
171  int r = ParseSizeString(size, &temp_res);
172  if (r < 0)
173  return r;
174 
175  if (temp_res > UINT16_MAX)
176  return -1;
177 
178  *res = temp_res;
179 
180  return 0;
181 }
182 
183 int ParseSizeStringU32(const char *size, uint32_t *res)
184 {
185  double temp_res = 0;
186 
187  *res = 0;
188  int r = ParseSizeString(size, &temp_res);
189  if (r < 0)
190  return r;
191 
192  if (temp_res > UINT32_MAX)
193  return -1;
194 
195  *res = temp_res;
196 
197  return 0;
198 }
199 
200 int ParseSizeStringU64(const char *size, uint64_t *res)
201 {
202  double temp_res = 0;
203 
204  *res = 0;
205  int r = ParseSizeString(size, &temp_res);
206  if (r < 0)
207  return r;
208 
209  if (temp_res > (double) UINT64_MAX)
210  return -1;
211 
212  *res = temp_res;
213 
214  return 0;
215 }
216 
217 void ShortenString(const char *input,
218  char *output, size_t output_size, char c)
219 {
220  const size_t str_len = strlen(input);
221  size_t half = (output_size - 1) / 2;
222 
223  /* If the output size is an even number */
224  if (half * 2 == (output_size - 1)) {
225  half = half - 1;
226  }
227 
228  size_t spaces = (output_size - 1) - (half * 2);
229 
230  /* Add the first half to the new string */
231  snprintf(output, half+1, "%s", input);
232 
233  /* Add the amount of spaces wanted */
234  size_t length = half;
235  for (size_t i = half; i < half + spaces; i++) {
236  char s[2] = "";
237  snprintf(s, sizeof(s), "%c", c);
238  length = strlcat(output, s, output_size);
239  }
240 
241  snprintf(output + length, half + 1, "%s", input + (str_len - half));
242 }
243 
244 /*********************************Unittests********************************/
245 
246 #ifdef UNITTESTS
247 
248 static int UtilMiscParseSizeStringTest01(void)
249 {
250  const char *str;
251  double result;
252 
253  /* no space */
254 
255  str = "10";
256  result = 0;
257  if (ParseSizeString(str, &result) > 0) {
258  goto error;
259  }
260  if (result != 10) {
261  goto error;
262  }
263 
264  str = "10kb";
265  result = 0;
266  if (ParseSizeString(str, &result) > 0) {
267  goto error;
268  }
269  if (result != 10 * 1024) {
270  goto error;
271  }
272 
273  str = "10Kb";
274  result = 0;
275  if (ParseSizeString(str, &result) > 0) {
276  goto error;
277  }
278  if (result != 10 * 1024) {
279  goto error;
280  }
281 
282  str = "10KB";
283  result = 0;
284  if (ParseSizeString(str, &result) > 0) {
285  goto error;
286  }
287  if (result != 10 * 1024) {
288  goto error;
289  }
290 
291  str = "10mb";
292  result = 0;
293  if (ParseSizeString(str, &result) > 0) {
294  goto error;
295  }
296  if (result != 10 * 1024 * 1024) {
297  goto error;
298  }
299 
300  str = "10gb";
301  result = 0;
302  if (ParseSizeString(str, &result) > 0) {
303  goto error;
304  }
305  if (result != 10737418240UL) {
306  goto error;
307  }
308 
309 
310  /* space start */
311 
312  str = " 10";
313  result = 0;
314  if (ParseSizeString(str, &result) > 0) {
315  goto error;
316  }
317  if (result != 10) {
318  goto error;
319  }
320 
321  str = " 10kb";
322  result = 0;
323  if (ParseSizeString(str, &result) > 0) {
324  goto error;
325  }
326  if (result != 10 * 1024) {
327  goto error;
328  }
329 
330  str = " 10Kb";
331  result = 0;
332  if (ParseSizeString(str, &result) > 0) {
333  goto error;
334  }
335  if (result != 10 * 1024) {
336  goto error;
337  }
338 
339  str = " 10KB";
340  result = 0;
341  if (ParseSizeString(str, &result) > 0) {
342  goto error;
343  }
344  if (result != 10 * 1024) {
345  goto error;
346  }
347 
348  str = " 10mb";
349  result = 0;
350  if (ParseSizeString(str, &result) > 0) {
351  goto error;
352  }
353  if (result != 10 * 1024 * 1024) {
354  goto error;
355  }
356 
357  str = " 10gb";
358  result = 0;
359  if (ParseSizeString(str, &result) > 0) {
360  goto error;
361  }
362  if (result != 10737418240) {
363  goto error;
364  }
365 
366  /* space end */
367 
368  str = "10 ";
369  result = 0;
370  if (ParseSizeString(str, &result) > 0) {
371  goto error;
372  }
373  if (result != 10) {
374  goto error;
375  }
376 
377  str = "10kb ";
378  result = 0;
379  if (ParseSizeString(str, &result) > 0) {
380  goto error;
381  }
382  if (result != 10 * 1024) {
383  goto error;
384  }
385 
386  str = "10Kb ";
387  result = 0;
388  if (ParseSizeString(str, &result) > 0) {
389  goto error;
390  }
391  if (result != 10 * 1024) {
392  goto error;
393  }
394 
395  str = "10KB ";
396  result = 0;
397  if (ParseSizeString(str, &result) > 0) {
398  goto error;
399  }
400  if (result != 10 * 1024) {
401  goto error;
402  }
403 
404  str = "10mb ";
405  result = 0;
406  if (ParseSizeString(str, &result) > 0) {
407  goto error;
408  }
409  if (result != 10 * 1024 * 1024) {
410  goto error;
411  }
412 
413  str = "10gb ";
414  result = 0;
415  if (ParseSizeString(str, &result) > 0) {
416  goto error;
417  }
418  if (result != 10737418240) {
419  goto error;
420  }
421 
422  /* space start - space end */
423 
424  str = " 10 ";
425  result = 0;
426  if (ParseSizeString(str, &result) > 0) {
427  goto error;
428  }
429  if (result != 10) {
430  goto error;
431  }
432 
433  str = " 10kb ";
434  result = 0;
435  if (ParseSizeString(str, &result) > 0) {
436  goto error;
437  }
438  if (result != 10 * 1024) {
439  goto error;
440  }
441 
442  str = " 10Kb ";
443  result = 0;
444  if (ParseSizeString(str, &result) > 0) {
445  goto error;
446  }
447  if (result != 10 * 1024) {
448  goto error;
449  }
450 
451  str = " 10KB ";
452  result = 0;
453  if (ParseSizeString(str, &result) > 0) {
454  goto error;
455  }
456  if (result != 10 * 1024) {
457  goto error;
458  }
459 
460  str = " 10mb ";
461  result = 0;
462  if (ParseSizeString(str, &result) > 0) {
463  goto error;
464  }
465  if (result != 10 * 1024 * 1024) {
466  goto error;
467  }
468 
469  str = " 10gb ";
470  result = 0;
471  if (ParseSizeString(str, &result) > 0) {
472  goto error;
473  }
474  if (result != 10737418240) {
475  goto error;
476  }
477 
478 
479  /* space between number and scale */
480 
481  /* no space */
482 
483  str = "10";
484  result = 0;
485  if (ParseSizeString(str, &result) > 0) {
486  goto error;
487  }
488  if (result != 10) {
489  goto error;
490  }
491 
492  str = "10 kb";
493  result = 0;
494  if (ParseSizeString(str, &result) > 0) {
495  goto error;
496  }
497  if (result != 10 * 1024) {
498  goto error;
499  }
500 
501  str = "10 Kb";
502  result = 0;
503  if (ParseSizeString(str, &result) > 0) {
504  goto error;
505  }
506  if (result != 10 * 1024) {
507  goto error;
508  }
509 
510  str = "10 KB";
511  result = 0;
512  if (ParseSizeString(str, &result) > 0) {
513  goto error;
514  }
515  if (result != 10 * 1024) {
516  goto error;
517  }
518 
519  str = "10 mb";
520  result = 0;
521  if (ParseSizeString(str, &result) > 0) {
522  goto error;
523  }
524  if (result != 10 * 1024 * 1024) {
525  goto error;
526  }
527 
528  str = "10 gb";
529  result = 0;
530  if (ParseSizeString(str, &result) > 0) {
531  goto error;
532  }
533  if (result != 10737418240) {
534  goto error;
535  }
536 
537 
538  /* space start */
539 
540  str = " 10";
541  result = 0;
542  if (ParseSizeString(str, &result) > 0) {
543  goto error;
544  }
545  if (result != 10) {
546  goto error;
547  }
548 
549  str = " 10 kb";
550  result = 0;
551  if (ParseSizeString(str, &result) > 0) {
552  goto error;
553  }
554  if (result != 10 * 1024) {
555  goto error;
556  }
557 
558  str = " 10 Kb";
559  result = 0;
560  if (ParseSizeString(str, &result) > 0) {
561  goto error;
562  }
563  if (result != 10 * 1024) {
564  goto error;
565  }
566 
567  str = " 10 KB";
568  result = 0;
569  if (ParseSizeString(str, &result) > 0) {
570  goto error;
571  }
572  if (result != 10 * 1024) {
573  goto error;
574  }
575 
576  str = " 10 mb";
577  result = 0;
578  if (ParseSizeString(str, &result) > 0) {
579  goto error;
580  }
581  if (result != 10 * 1024 * 1024) {
582  goto error;
583  }
584 
585  str = " 10 gb";
586  result = 0;
587  if (ParseSizeString(str, &result) > 0) {
588  goto error;
589  }
590  if (result != 10737418240) {
591  goto error;
592  }
593 
594  /* space end */
595 
596  str = "10 ";
597  result = 0;
598  if (ParseSizeString(str, &result) > 0) {
599  goto error;
600  }
601  if (result != 10) {
602  goto error;
603  }
604 
605  str = "10 kb ";
606  result = 0;
607  if (ParseSizeString(str, &result) > 0) {
608  goto error;
609  }
610  if (result != 10 * 1024) {
611  goto error;
612  }
613 
614  str = "10 Kb ";
615  result = 0;
616  if (ParseSizeString(str, &result) > 0) {
617  goto error;
618  }
619  if (result != 10 * 1024) {
620  goto error;
621  }
622 
623  str = "10 KB ";
624  result = 0;
625  if (ParseSizeString(str, &result) > 0) {
626  goto error;
627  }
628  if (result != 10 * 1024) {
629  goto error;
630  }
631 
632  str = "10 mb ";
633  result = 0;
634  if (ParseSizeString(str, &result) > 0) {
635  goto error;
636  }
637  if (result != 10 * 1024 * 1024) {
638  goto error;
639  }
640 
641  str = "10 gb ";
642  result = 0;
643  if (ParseSizeString(str, &result) > 0) {
644  goto error;
645  }
646  if (result != 10737418240) {
647  goto error;
648  }
649 
650  /* space start - space end */
651 
652  str = " 10 ";
653  result = 0;
654  if (ParseSizeString(str, &result) > 0) {
655  goto error;
656  }
657  if (result != 10) {
658  goto error;
659  }
660 
661  str = " 10 kb ";
662  result = 0;
663  if (ParseSizeString(str, &result) > 0) {
664  goto error;
665  }
666  if (result != 10 * 1024) {
667  goto error;
668  }
669 
670  str = " 10 Kb ";
671  result = 0;
672  if (ParseSizeString(str, &result) > 0) {
673  goto error;
674  }
675  if (result != 10 * 1024) {
676  goto error;
677  }
678 
679  str = " 10 KB ";
680  result = 0;
681  if (ParseSizeString(str, &result) > 0) {
682  goto error;
683  }
684  if (result != 10 * 1024) {
685  goto error;
686  }
687 
688  str = " 10 mb ";
689  result = 0;
690  if (ParseSizeString(str, &result) > 0) {
691  goto error;
692  }
693  if (result != 10 * 1024 * 1024) {
694  goto error;
695  }
696 
697  str = " 10 gb ";
698  result = 0;
699  if (ParseSizeString(str, &result) > 0) {
700  goto error;
701  }
702  if (result != 10737418240) {
703  goto error;
704  }
705 
706  /* no space */
707 
708  str = "10.5";
709  result = 0;
710  if (ParseSizeString(str, &result) > 0) {
711  goto error;
712  }
713  if (result != 10.5) {
714  goto error;
715  }
716 
717  str = "10.5kb";
718  result = 0;
719  if (ParseSizeString(str, &result) > 0) {
720  goto error;
721  }
722  if (result != 10.5 * 1024) {
723  goto error;
724  }
725 
726  str = "10.5Kb";
727  result = 0;
728  if (ParseSizeString(str, &result) > 0) {
729  goto error;
730  }
731  if (result != 10.5 * 1024) {
732  goto error;
733  }
734 
735  str = "10.5KB";
736  result = 0;
737  if (ParseSizeString(str, &result) > 0) {
738  goto error;
739  }
740  if (result != 10.5 * 1024) {
741  goto error;
742  }
743 
744  str = "10.5mb";
745  result = 0;
746  if (ParseSizeString(str, &result) > 0) {
747  goto error;
748  }
749  if (result != 10.5 * 1024 * 1024) {
750  goto error;
751  }
752 
753  str = "10.5gb";
754  result = 0;
755  if (ParseSizeString(str, &result) > 0) {
756  goto error;
757  }
758  if (result != 10.5 * 1024 * 1024 * 1024) {
759  goto error;
760  }
761 
762 
763  /* space start */
764 
765  str = " 10.5";
766  result = 0;
767  if (ParseSizeString(str, &result) > 0) {
768  goto error;
769  }
770  if (result != 10.5) {
771  goto error;
772  }
773 
774  str = " 10.5kb";
775  result = 0;
776  if (ParseSizeString(str, &result) > 0) {
777  goto error;
778  }
779  if (result != 10.5 * 1024) {
780  goto error;
781  }
782 
783  str = " 10.5Kb";
784  result = 0;
785  if (ParseSizeString(str, &result) > 0) {
786  goto error;
787  }
788  if (result != 10.5 * 1024) {
789  goto error;
790  }
791 
792  str = " 10.5KB";
793  result = 0;
794  if (ParseSizeString(str, &result) > 0) {
795  goto error;
796  }
797  if (result != 10.5 * 1024) {
798  goto error;
799  }
800 
801  str = " 10.5mb";
802  result = 0;
803  if (ParseSizeString(str, &result) > 0) {
804  goto error;
805  }
806  if (result != 10.5 * 1024 * 1024) {
807  goto error;
808  }
809 
810  str = " 10.5gb";
811  result = 0;
812  if (ParseSizeString(str, &result) > 0) {
813  goto error;
814  }
815  if (result != 10.5 * 1024 * 1024 * 1024) {
816  goto error;
817  }
818 
819  /* space end */
820 
821  str = "10.5 ";
822  result = 0;
823  if (ParseSizeString(str, &result) > 0) {
824  goto error;
825  }
826  if (result != 10.5) {
827  goto error;
828  }
829 
830  str = "10.5kb ";
831  result = 0;
832  if (ParseSizeString(str, &result) > 0) {
833  goto error;
834  }
835  if (result != 10.5 * 1024) {
836  goto error;
837  }
838 
839  str = "10.5Kb ";
840  result = 0;
841  if (ParseSizeString(str, &result) > 0) {
842  goto error;
843  }
844  if (result != 10.5 * 1024) {
845  goto error;
846  }
847 
848  str = "10.5KB ";
849  result = 0;
850  if (ParseSizeString(str, &result) > 0) {
851  goto error;
852  }
853  if (result != 10.5 * 1024) {
854  goto error;
855  }
856 
857  str = "10.5mb ";
858  result = 0;
859  if (ParseSizeString(str, &result) > 0) {
860  goto error;
861  }
862  if (result != 10.5 * 1024 * 1024) {
863  goto error;
864  }
865 
866  str = "10.5gb ";
867  result = 0;
868  if (ParseSizeString(str, &result) > 0) {
869  goto error;
870  }
871  if (result != 10.5 * 1024 * 1024 * 1024) {
872  goto error;
873  }
874 
875  /* space start - space end */
876 
877  str = " 10.5 ";
878  result = 0;
879  if (ParseSizeString(str, &result) > 0) {
880  goto error;
881  }
882  if (result != 10.5) {
883  goto error;
884  }
885 
886  str = " 10.5kb ";
887  result = 0;
888  if (ParseSizeString(str, &result) > 0) {
889  goto error;
890  }
891  if (result != 10.5 * 1024) {
892  goto error;
893  }
894 
895  str = " 10.5Kb ";
896  result = 0;
897  if (ParseSizeString(str, &result) > 0) {
898  goto error;
899  }
900  if (result != 10.5 * 1024) {
901  goto error;
902  }
903 
904  str = " 10.5KB ";
905  result = 0;
906  if (ParseSizeString(str, &result) > 0) {
907  goto error;
908  }
909  if (result != 10.5 * 1024) {
910  goto error;
911  }
912 
913  str = " 10.5mb ";
914  result = 0;
915  if (ParseSizeString(str, &result) > 0) {
916  goto error;
917  }
918  if (result != 10.5 * 1024 * 1024) {
919  goto error;
920  }
921 
922  str = " 10.5gb ";
923  result = 0;
924  if (ParseSizeString(str, &result) > 0) {
925  goto error;
926  }
927  if (result != 10.5 * 1024 * 1024 * 1024) {
928  goto error;
929  }
930 
931 
932  /* space between number and scale */
933 
934  /* no space */
935 
936  str = "10.5";
937  result = 0;
938  if (ParseSizeString(str, &result) > 0) {
939  goto error;
940  }
941  if (result != 10.5) {
942  goto error;
943  }
944 
945  str = "10.5 kb";
946  result = 0;
947  if (ParseSizeString(str, &result) > 0) {
948  goto error;
949  }
950  if (result != 10.5 * 1024) {
951  goto error;
952  }
953 
954  str = "10.5 Kb";
955  result = 0;
956  if (ParseSizeString(str, &result) > 0) {
957  goto error;
958  }
959  if (result != 10.5 * 1024) {
960  goto error;
961  }
962 
963  str = "10.5 KB";
964  result = 0;
965  if (ParseSizeString(str, &result) > 0) {
966  goto error;
967  }
968  if (result != 10.5 * 1024) {
969  goto error;
970  }
971 
972  str = "10.5 mb";
973  result = 0;
974  if (ParseSizeString(str, &result) > 0) {
975  goto error;
976  }
977  if (result != 10.5 * 1024 * 1024) {
978  goto error;
979  }
980 
981  str = "10.5 gb";
982  result = 0;
983  if (ParseSizeString(str, &result) > 0) {
984  goto error;
985  }
986  if (result != 10.5 * 1024 * 1024 * 1024) {
987  goto error;
988  }
989 
990 
991  /* space start */
992 
993  str = " 10.5";
994  result = 0;
995  if (ParseSizeString(str, &result) > 0) {
996  goto error;
997  }
998  if (result != 10.5) {
999  goto error;
1000  }
1001 
1002  str = " 10.5 kb";
1003  result = 0;
1004  if (ParseSizeString(str, &result) > 0) {
1005  goto error;
1006  }
1007  if (result != 10.5 * 1024) {
1008  goto error;
1009  }
1010 
1011  str = " 10.5 Kb";
1012  result = 0;
1013  if (ParseSizeString(str, &result) > 0) {
1014  goto error;
1015  }
1016  if (result != 10.5 * 1024) {
1017  goto error;
1018  }
1019 
1020  str = " 10.5 KB";
1021  result = 0;
1022  if (ParseSizeString(str, &result) > 0) {
1023  goto error;
1024  }
1025  if (result != 10.5 * 1024) {
1026  goto error;
1027  }
1028 
1029  str = " 10.5 mb";
1030  result = 0;
1031  if (ParseSizeString(str, &result) > 0) {
1032  goto error;
1033  }
1034  if (result != 10.5 * 1024 * 1024) {
1035  goto error;
1036  }
1037 
1038  str = " 10.5 gb";
1039  result = 0;
1040  if (ParseSizeString(str, &result) > 0) {
1041  goto error;
1042  }
1043  if (result != 10.5 * 1024 * 1024 * 1024) {
1044  goto error;
1045  }
1046 
1047  /* space end */
1048 
1049  str = "10.5 ";
1050  result = 0;
1051  if (ParseSizeString(str, &result) > 0) {
1052  goto error;
1053  }
1054  if (result != 10.5) {
1055  goto error;
1056  }
1057 
1058  str = "10.5 kb ";
1059  result = 0;
1060  if (ParseSizeString(str, &result) > 0) {
1061  goto error;
1062  }
1063  if (result != 10.5 * 1024) {
1064  goto error;
1065  }
1066 
1067  str = "10.5 Kb ";
1068  result = 0;
1069  if (ParseSizeString(str, &result) > 0) {
1070  goto error;
1071  }
1072  if (result != 10.5 * 1024) {
1073  goto error;
1074  }
1075 
1076  str = "10.5 KB ";
1077  result = 0;
1078  if (ParseSizeString(str, &result) > 0) {
1079  goto error;
1080  }
1081  if (result != 10.5 * 1024) {
1082  goto error;
1083  }
1084 
1085  str = "10.5 mb ";
1086  result = 0;
1087  if (ParseSizeString(str, &result) > 0) {
1088  goto error;
1089  }
1090  if (result != 10.5 * 1024 * 1024) {
1091  goto error;
1092  }
1093 
1094  str = "10.5 gb ";
1095  result = 0;
1096  if (ParseSizeString(str, &result) > 0) {
1097  goto error;
1098  }
1099  if (result != 10.5 * 1024 * 1024 * 1024) {
1100  goto error;
1101  }
1102 
1103  /* space start - space end */
1104 
1105  str = " 10.5 ";
1106  result = 0;
1107  if (ParseSizeString(str, &result) > 0) {
1108  goto error;
1109  }
1110  if (result != 10.5) {
1111  goto error;
1112  }
1113 
1114  str = " 10.5 kb ";
1115  result = 0;
1116  if (ParseSizeString(str, &result) > 0) {
1117  goto error;
1118  }
1119  if (result != 10.5 * 1024) {
1120  goto error;
1121  }
1122 
1123  str = " 10.5 Kb ";
1124  result = 0;
1125  if (ParseSizeString(str, &result) > 0) {
1126  goto error;
1127  }
1128  if (result != 10.5 * 1024) {
1129  goto error;
1130  }
1131 
1132  str = " 10.5 KB ";
1133  result = 0;
1134  if (ParseSizeString(str, &result) > 0) {
1135  goto error;
1136  }
1137  if (result != 10.5 * 1024) {
1138  goto error;
1139  }
1140 
1141  str = " 10.5 mb ";
1142  result = 0;
1143  if (ParseSizeString(str, &result) > 0) {
1144  goto error;
1145  }
1146  if (result != 10.5 * 1024 * 1024) {
1147  goto error;
1148  }
1149 
1150  str = " 10.5 gb ";
1151  result = 0;
1152  if (ParseSizeString(str, &result) > 0) {
1153  goto error;
1154  }
1155  if (result != 10.5 * 1024 * 1024 * 1024) {
1156  goto error;
1157  }
1158 
1159  /* Should fail on unknown units. */
1160  if (ParseSizeString("32eb", &result) > 0) {
1161  goto error;
1162  }
1163 
1164  return 1;
1165  error:
1166  return 0;
1167 }
1168 
1169 #endif /* UNITTESTS */
1170 
1172 {
1173 #ifdef UNITTESTS
1174  UtRegisterTest("UtilMiscParseSizeStringTest01",
1175  UtilMiscParseSizeStringTest01);
1176 #endif /* UNITTESTS */
1177 
1178  return;
1179 }
util-byte.h
SC_ERR_PCRE_COMPILE
@ SC_ERR_PCRE_COMPILE
Definition: util-error.h:35
ParseSizeStringU16
int ParseSizeStringU16(const char *size, uint16_t *res)
Definition: util-misc.c:166
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:200
MemcmpTest18Tests::result
int result
Definition: util-memcmp.c:345
SC_ERR_PCRE_GET_SUBSTRING
@ SC_ERR_PCRE_GET_SUBSTRING
Definition: util-error.h:34
ShortenString
void ShortenString(const char *input, char *output, size_t output_size, char c)
Definition: util-misc.c:217
SC_ERR_INVALID_ARGUMENTS
@ SC_ERR_INVALID_ARGUMENTS
Definition: util-error.h:82
util-unittest.h
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:149
SC_ERR_PCRE_MATCH
@ SC_ERR_PCRE_MATCH
Definition: util-error.h:32
strlcat
size_t strlcat(char *, const char *src, size_t siz)
Definition: util-strlcatu.c:45
res
PoolThreadReserved res
Definition: stream-tcp-private.h:0
suricata-common.h
SCLogError
#define SCLogError(err_code,...)
Macro used to log ERROR messages.
Definition: util-debug.h:257
ParseSizeDeinit
void ParseSizeDeinit(void)
Definition: util-misc.c:55
ParseSizeStringU32
int ParseSizeStringU32(const char *size, uint32_t *res)
Definition: util-misc.c:183
str
#define str(s)
Definition: suricata-common.h:268
SC_ERR_NUMERIC_VALUE_ERANGE
@ SC_ERR_NUMERIC_VALUE_ERANGE
Definition: util-error.h:91
UtilMiscRegisterTests
void UtilMiscRegisterTests(void)
Definition: util-misc.c:1171
suricata.h
util-misc.h
SC_ERR_INVALID_NUMERIC_VALUE
@ SC_ERR_INVALID_NUMERIC_VALUE
Definition: util-error.h:90
PARSE_REGEX
#define PARSE_REGEX
Definition: util-misc.c:31