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