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