suricata
util-host-os-info.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  * Host info utility functions
24  */
25 
26 #include "suricata-common.h"
27 #include "util-host-os-info.h"
28 #include "util-error.h"
29 #include "util-debug.h"
30 #include "util-ip.h"
31 #include "util-radix4-tree.h"
32 #include "util-radix6-tree.h"
33 #include "util-byte.h"
34 #include "stream-tcp-private.h"
35 #include "stream-tcp-reassemble.h"
36 
37 #include "conf.h"
38 #include "conf-yaml-loader.h"
39 
40 #include "util-enum.h"
41 
42 /** Enum map for the various OS flavours */
44  { "none", OS_POLICY_NONE },
45  { "bsd", OS_POLICY_BSD },
46  { "bsd-right", OS_POLICY_BSD_RIGHT },
47  { "old-linux", OS_POLICY_OLD_LINUX },
48  { "linux", OS_POLICY_LINUX },
49  { "old-solaris", OS_POLICY_OLD_SOLARIS },
50  { "solaris", OS_POLICY_SOLARIS },
51  { "hpux10", OS_POLICY_HPUX10 },
52  { "hpux11", OS_POLICY_HPUX11 },
53  { "irix", OS_POLICY_IRIX },
54  { "macos", OS_POLICY_MACOS },
55  { "windows", OS_POLICY_WINDOWS },
56  { "vista", OS_POLICY_VISTA },
57  { "windows2k3", OS_POLICY_WINDOWS2K3 },
58  { NULL, -1 },
59 };
60 
61 /** Radix trees that hold the host OS information */
62 static SCRadix4Tree sc_hinfo_tree4 = SC_RADIX4_TREE_INITIALIZER;
63 static SCRadix6Tree sc_hinfo_tree6 = SC_RADIX6_TREE_INITIALIZER;
64 
65 /**
66  * \brief Allocates the host_os flavour wrapped in user_data variable to be sent
67  * along with the key to the radix tree
68  *
69  * \param host_os Pointer to a character string containing the host_os flavour
70  *
71  * \retval user_data On success, pointer to the user_data that has to be sent
72  * along with the key, to be added to the Radix tree; NULL on
73  * failure
74  * \initonly
75  */
76 static void *SCHInfoAllocUserDataOSPolicy(const char *host_os)
77 {
78  /* the host os flavour that has to be sent as user data */
80  if (v == -1) {
81  SCLogError("Invalid enum map inside SCHInfoAddHostOSInfo()");
82  return NULL;
83  }
84 
85  int *user_data = SCMalloc(sizeof(int));
86  if (user_data == NULL) {
87  FatalError("Error allocating memory. Exiting");
88  }
89  *user_data = v;
90  return (void *)user_data;
91 }
92 
93 /**
94  * \brief Used to free the user data that is allocated by host_os_info API
95  *
96  * \param Pointer to the data that has to be freed
97  */
98 static void SCHInfoFreeUserDataOSPolicy(void *data)
99 {
100  if (data != NULL)
101  SCFree(data);
102 }
103 
104 static const SCRadix4Config ospolicy_radix4_config = { SCHInfoFreeUserDataOSPolicy, NULL };
105 static const SCRadix6Config ospolicy_radix6_config = { SCHInfoFreeUserDataOSPolicy, NULL };
106 
107 /**
108  * \brief Used to add the host-os-info data obtained from the conf
109  *
110  * \param host_os The host_os name/flavour from the conf file
111  * \param host_os_ip_range Pointer to a char string holding the ip/ip_netblock
112  * for the host_os specified in the first argument
113  * \param is_ipv4 Indicates if the ip address to be considered for the
114  * default configuration is IPV4; if not it is IPV6.
115  * Specified using SC_HINFO_IS_IPV6 or SC_HINFO_IS_IPV4
116  *
117  * \retval 0 On successfully adding the host os info to the Radix tree
118  * \retval -1 On failure
119  * \initonly (only specified from config, at the startup)
120  */
121 int SCHInfoAddHostOSInfo(const char *host_os, const char *host_os_ip_range, int is_ipv4)
122 {
123  char *ip_str = NULL;
124  char *ip_str_rem = NULL;
125  int *user_data = NULL;
126  bool recursive = false;
127 
128  if (host_os == NULL || host_os_ip_range == NULL ||
129  strlen(host_os_ip_range) == 0) {
130  SCLogError("Invalid arguments");
131  return -1;
132  }
133 
134  /* the host os flavour that has to be sent as user data */
135  if ( (user_data = SCHInfoAllocUserDataOSPolicy(host_os)) == NULL) {
136  SCLogError("Invalid enum map inside");
137  return -1;
138  }
139 
140  /* if we have a default configuration set the appropriate values for the
141  * netblocks */
142  if ( (strcasecmp(host_os_ip_range, "default")) == 0) {
143  if (is_ipv4)
144  host_os_ip_range = "0.0.0.0/0";
145  else
146  host_os_ip_range = "::/0";
147  }
148 
149  if ( (ip_str = SCStrdup(host_os_ip_range)) == NULL) {
150  FatalError("Error allocating memory");
151  }
152 
153  /* check if we have more addresses in the host_os_ip_range */
154  if ((ip_str_rem = strchr(ip_str, ',')) != NULL) {
155  ip_str_rem[0] = '\0';
156  ip_str_rem++;
157  recursive = true;
158  }
159 
160  if (strchr(ip_str, ':') == NULL) {
162  &sc_hinfo_tree4, &ospolicy_radix4_config, ip_str, user_data)) {
163  if (sc_errno == SC_EEXIST) {
164  SCLogError("duplicate ipv4 address '%s'", ip_str);
165  } else {
166  SCLogError("invalid ipv4 address '%s'", ip_str);
167  }
168  SCHInfoFreeUserDataOSPolicy(user_data);
169  SCFree(ip_str);
170  return -1;
171  }
172  } else {
174  &sc_hinfo_tree6, &ospolicy_radix6_config, ip_str, user_data)) {
175  if (sc_errno == SC_EEXIST) {
176  SCLogError("duplicate ipv6 address '%s'", ip_str);
177  } else {
178  SCLogError("invalid ipv6 address '%s'", ip_str);
179  }
180  SCHInfoFreeUserDataOSPolicy(user_data);
181  SCFree(ip_str);
182  return -1;
183  }
184  }
185 
186  if (recursive) {
187  SCHInfoAddHostOSInfo(host_os, ip_str_rem, is_ipv4);
188  }
189 
190  SCFree(ip_str);
191  return *user_data;
192 }
193 
194 #ifdef UNITTESTS
195 /**
196  * \brief Retrieves the host os flavour, given an ipv4/ipv6 address as a string.
197  *
198  * \param Pointer to a string containing an IP address
199  *
200  * \retval The OS flavour on success; -1 on failure, or on not finding the key
201  */
202 static int SCHInfoGetHostOSFlavour(const char *str)
203 {
204  void *user_data = NULL;
205 
206  if (str == NULL || strchr(str, '/') != NULL)
207  return -1;
208 
209  if (strchr(str, ':') != NULL) {
210  struct in6_addr addr;
211  if (inet_pton(AF_INET6, str, &addr) <= 0) {
212  SCLogError("Invalid IPV6 address");
213  return -1;
214  }
215  (void)SCRadix6TreeFindBestMatch(&sc_hinfo_tree6, (uint8_t *)&addr.s6_addr, &user_data);
216  if (user_data == NULL)
217  return -1;
218  else
219  return *((int *)user_data);
220  } else {
221  struct in_addr addr;
222  if (inet_pton(AF_INET, str, &addr) <= 0) {
223  SCLogError("Invalid IPV4 address");
224  return -1;
225  }
226  (void)SCRadix4TreeFindBestMatch(&sc_hinfo_tree4, (uint8_t *)&addr.s_addr, &user_data);
227  if (user_data == NULL)
228  return -1;
229  else
230  return *((int *)user_data);
231  }
232 }
233 #endif
234 
235 /**
236  * \brief Retrieves the host os flavour, given an ipv4 address in the raw
237  * address format.
238  *
239  * \param Pointer to a raw ipv4 address.
240  *
241  * \retval The OS flavour on success; -1 on failure, or on not finding the key
242  */
243 int SCHInfoGetIPv4HostOSFlavour(uint8_t *addr)
244 {
245  void *user_data = NULL;
246  (void)SCRadix4TreeFindBestMatch(&sc_hinfo_tree4, addr, &user_data);
247  if (user_data == NULL)
248  return -1;
249  return *((int *)user_data);
250 }
251 
252 /**
253  * \brief Retrieves the host os flavour, given an ipv6 address in the raw
254  * address format.
255  *
256  * \param Pointer to a raw ipv6 address.
257  *
258  * \retval The OS flavour on success; -1 on failure, or on not finding the key
259  */
260 int SCHInfoGetIPv6HostOSFlavour(uint8_t *addr)
261 {
262  void *user_data = NULL;
263  (void)SCRadix6TreeFindBestMatch(&sc_hinfo_tree6, addr, &user_data);
264  if (user_data == NULL)
265  return -1;
266  return *((int *)user_data);
267 }
268 
270 {
271  SCRadix4TreeRelease(&sc_hinfo_tree4, &ospolicy_radix4_config);
272  SCRadix6TreeRelease(&sc_hinfo_tree6, &ospolicy_radix6_config);
273 }
274 
275 /**
276  * \brief Load the host os policy information from the configuration.
277  *
278  * \initonly (A mem alloc error should cause an exit failure)
279  */
281 {
282  SCConfNode *root = SCConfGetNode("host-os-policy");
283  if (root == NULL)
284  return;
285 
286  SCConfNode *policy;
287  TAILQ_FOREACH(policy, &root->head, next) {
288  SCConfNode *host;
289  TAILQ_FOREACH(host, &policy->head, next) {
290  int is_ipv4 = 1;
291  if (host->val != NULL && strchr(host->val, ':') != NULL)
292  is_ipv4 = 0;
293  if (SCHInfoAddHostOSInfo(policy->name, host->val, is_ipv4) == -1) {
294  FatalError("Failed to add host \"%s\" with policy \"%s\" to host "
295  "info database",
296  host->val, policy->name);
297  }
298  }
299  }
300 }
301 
302 /*------------------------------------Unit_Tests------------------------------*/
303 
304 #ifdef UNITTESTS
305 static SCRadix4Tree sc_hinfo_tree_backup4 = SC_RADIX4_TREE_INITIALIZER;
306 static SCRadix6Tree sc_hinfo_tree_backup6 = SC_RADIX6_TREE_INITIALIZER;
307 
308 static void SCHInfoCreateContextBackup(void)
309 {
310  sc_hinfo_tree_backup4 = sc_hinfo_tree4;
311  sc_hinfo_tree4 = SCRadix4TreeInitialize();
312  sc_hinfo_tree_backup6 = sc_hinfo_tree6;
313  sc_hinfo_tree6 = SCRadix6TreeInitialize();
314 }
315 
316 static void SCHInfoRestoreContextBackup(void)
317 {
318  sc_hinfo_tree4 = sc_hinfo_tree_backup4;
319  sc_hinfo_tree_backup4 = SCRadix4TreeInitialize();
320  sc_hinfo_tree6 = sc_hinfo_tree_backup6;
321  sc_hinfo_tree_backup6 = SCRadix6TreeInitialize();
322 }
323 
324 /**
325  * \test Check if we the IPs with the right OS flavours are added to the host OS
326  * radix tree, and the IPS with invalid flavours returns an error(-1)
327  */
328 static int SCHInfoTestInvalidOSFlavour01(void)
329 {
330  SCHInfoCreateContextBackup();
331 
332  FAIL_IF(SCHInfoAddHostOSInfo("bamboo", "192.168.1.1", SC_HINFO_IS_IPV4) != -1);
333  FAIL_IF(SCHInfoAddHostOSInfo("linux", "192.168.1.2", SC_HINFO_IS_IPV4) !=
335  FAIL_IF(SCHInfoAddHostOSInfo("windows", "192.168.1.3", SC_HINFO_IS_IPV4) !=
337  FAIL_IF(SCHInfoAddHostOSInfo("solaris", "192.168.1.4", SC_HINFO_IS_IPV4) !=
339  FAIL_IF(SCHInfoAddHostOSInfo("hpux10", "192.168.1.5", SC_HINFO_IS_IPV4) !=
341  FAIL_IF(SCHInfoAddHostOSInfo("hpux11", "192.168.1.6", SC_HINFO_IS_IPV4) !=
343  FAIL_IF(SCHInfoAddHostOSInfo("irix", "192.168.1.7", SC_HINFO_IS_IPV4) !=
345  FAIL_IF(SCHInfoAddHostOSInfo("bsd", "192.168.1.8", SC_HINFO_IS_IPV4) !=
347  FAIL_IF(SCHInfoAddHostOSInfo("old_linux", "192.168.1.9", SC_HINFO_IS_IPV4) !=
349  FAIL_IF(SCHInfoAddHostOSInfo("macos", "192.168.1.10", SC_HINFO_IS_IPV4) !=
351  FAIL_IF(SCHInfoAddHostOSInfo("vista", "192.168.1.11", SC_HINFO_IS_IPV4) !=
353  FAIL_IF(SCHInfoAddHostOSInfo("windows2k3", "192.168.1.12", SC_HINFO_IS_IPV4) !=
355 
357  SCHInfoRestoreContextBackup();
358 
359  PASS;
360 }
361 
362 /**
363  * \test Check that invalid ipv4 addresses and ipv4 netblocks are rejected by
364  * the host os info API
365  */
366 static int SCHInfoTestInvalidIPV4Address02(void)
367 {
368  SCHInfoCreateContextBackup();
369 
370  int result = 0;
371 
372  if (SCHInfoAddHostOSInfo("linux", "192.168.1.566", SC_HINFO_IS_IPV4) != -1) {
373  goto end;
374  }
375  if (SCHInfoAddHostOSInfo("linux", "192.168.1", SC_HINFO_IS_IPV4) != -1) {
376  goto end;
377  }
378  if (SCHInfoAddHostOSInfo("linux", "192.", SC_HINFO_IS_IPV4) != -1) {
379  goto end;
380  }
381  if (SCHInfoAddHostOSInfo("linux", "192.168", SC_HINFO_IS_IPV4) != -1) {
382  goto end;
383  }
384  if (SCHInfoAddHostOSInfo("linux", "", SC_HINFO_IS_IPV4) != -1) {
385  goto end;
386  }
387  if (SCHInfoAddHostOSInfo("linux", "192.168.1.1/33", SC_HINFO_IS_IPV4) != -1) {
388  goto end;
389  }
390 
391  result = 1;
392 
393  end:
395  SCHInfoRestoreContextBackup();
396 
397  return result;
398 }
399 
400 /**
401  * \test Check that invalid ipv4 addresses and ipv4 netblocks are rejected by
402  * the host os info API
403  */
404 static int SCHInfoTestInvalidIPV6Address03(void)
405 {
406  SCHInfoCreateContextBackup();
407 
408  int result = 0;
409 
410  if (SCHInfoAddHostOSInfo("linux", "2362:7322", SC_HINFO_IS_IPV6) != -1) {
411  goto end;
412  }
413  if (SCHInfoAddHostOSInfo("linux", "19YW:", SC_HINFO_IS_IPV6) != -1) {
414  goto end;
415  }
416  if (SCHInfoAddHostOSInfo("linux", "1235", SC_HINFO_IS_IPV6) != -1) {
417  goto end;
418  }
419  if (SCHInfoAddHostOSInfo("linux", "1922:236115:", SC_HINFO_IS_IPV6) != -1) {
420  goto end;
421  }
422  if (SCHInfoAddHostOSInfo("linux", "", SC_HINFO_IS_IPV6) != -1) {
423  goto end;
424  }
425  if (SCHInfoAddHostOSInfo("linux",
426  "1921.6311:6241:6422:7352:ABBB:DDDD:EEEE/129",
427  SC_HINFO_IS_IPV6) != -1) {
428  goto end;
429  }
430 
431  result = 1;
432 
433  end:
435  SCHInfoRestoreContextBackup();
436 
437  return result;
438 }
439 
440 /**
441  * \test Check that valid ipv4 addresses are inserted into the host os radix
442  * tree, and the host os api retrieves the right value for the host os
443  * flavour, on supplying as arg an ipv4 addresses that has been added to
444  * the host os radix tree.
445  */
446 static int SCHInfoTestValidIPV4Address04(void)
447 {
448  SCHInfoCreateContextBackup();
449 
450  int result = 0;
451 
452  if (SCHInfoAddHostOSInfo("linux", "192.168.1.1", SC_HINFO_IS_IPV4) == -1) {
453  goto end;
454  }
455  if (SCHInfoAddHostOSInfo("windows", "192.192.1.2", SC_HINFO_IS_IPV4) == -1) {
456  goto end;
457  }
458  if (SCHInfoAddHostOSInfo("solaris", "192.168.1.100", SC_HINFO_IS_IPV4) == -1) {
459  goto end;
460  }
461  if (SCHInfoAddHostOSInfo("hpux10", "192.168.2.4", SC_HINFO_IS_IPV4) == -1) {
462  goto end;
463  }
464  if (SCHInfoAddHostOSInfo("linux", "192.192.1.5", SC_HINFO_IS_IPV4) == -1) {
465  goto end;
466  }
467  if (SCHInfoAddHostOSInfo("vista", "192.168.10.20", SC_HINFO_IS_IPV4) == -1) {
468  goto end;
469  }
470  if (SCHInfoAddHostOSInfo("solaris", "111.163.151.62", SC_HINFO_IS_IPV4) == -1) {
471  goto end;
472  }
473  if (SCHInfoAddHostOSInfo("solaris", "11.1.120.210", SC_HINFO_IS_IPV4) == -1) {
474  goto end;
475  }
476  if (SCHInfoAddHostOSInfo("linux", "19.18.110.210", SC_HINFO_IS_IPV4) == -1) {
477  goto end;
478  }
479  if (SCHInfoAddHostOSInfo("windows", "19.18.120.110", SC_HINFO_IS_IPV4) == -1) {
480  goto end;
481  }
482  if (SCHInfoAddHostOSInfo("hpux11", "191.168.11.128", SC_HINFO_IS_IPV4) == -1) {
483  goto end;
484  }
485  if (SCHInfoAddHostOSInfo("vista", "191.168.11.192", SC_HINFO_IS_IPV4) == -1) {
486  goto end;
487  }
488 
489  if (SCHInfoGetHostOSFlavour("192.168.1.1") !=
491  goto end;
492  }
493  if (SCHInfoGetHostOSFlavour("192.168.1.2") != -1) {
494  goto end;
495  }
496  if (SCHInfoGetHostOSFlavour("192.168.1.100") !=
498  goto end;
499  }
500  if (SCHInfoGetHostOSFlavour("192.192.2.4") != -1) {
501  goto end;
502  }
503  if (SCHInfoGetHostOSFlavour("192.168.2.4") !=
505  goto end;
506  }
507  if (SCHInfoGetHostOSFlavour("192.192.1.5") !=
509  goto end;
510  }
511  if (SCHInfoGetHostOSFlavour("192.168.10.20") !=
513  goto end;
514  }
515  if (SCHInfoGetHostOSFlavour("111.163.151.62") !=
517  goto end;
518  }
519  if (SCHInfoGetHostOSFlavour("11.1.120.210") !=
521  goto end;
522  }
523  if (SCHInfoGetHostOSFlavour("19.18.110.210") !=
525  goto end;
526  }
527  if (SCHInfoGetHostOSFlavour("19.18.120.110") !=
529  goto end;
530  }
531  if (SCHInfoGetHostOSFlavour("191.168.11.128") !=
533  goto end;
534  }
535  if (SCHInfoGetHostOSFlavour("191.168.11.192") !=
537  goto end;
538  }
539  if (SCHInfoGetHostOSFlavour("191.168.11.224") != -1) {
540  goto end;
541  }
542 
543  result = 1;
544 
545  end:
547  SCHInfoRestoreContextBackup();
548 
549  return result;
550 }
551 
552 /**
553  * \test Check that valid ipv4 addresses/netblocks are inserted into the host os
554  * radix tree, and the host os api retrieves the right value for the host
555  * os flavour, on supplying as arg an ipv4 addresses that has been added
556  * to the host os radix tree.
557  */
558 static int SCHInfoTestValidIPV4Address05(void)
559 {
560  SCHInfoCreateContextBackup();
561 
562  struct in_addr in;
563  int result = 0;
564 
565  if (SCHInfoAddHostOSInfo("linux", "192.168.1.1", SC_HINFO_IS_IPV4) == -1) {
566  goto end;
567  }
568  if (SCHInfoAddHostOSInfo("windows", "192.192.1.2", SC_HINFO_IS_IPV4) == -1) {
569  goto end;
570  }
571  if (SCHInfoAddHostOSInfo("solaris", "192.168.1.100", SC_HINFO_IS_IPV4) == -1) {
572  goto end;
573  }
574  if (SCHInfoAddHostOSInfo("hpux10", "192.168.2.4", SC_HINFO_IS_IPV4) == -1) {
575  goto end;
576  }
577  if (SCHInfoAddHostOSInfo("linux", "192.192.1.5", SC_HINFO_IS_IPV4) == -1) {
578  goto end;
579  }
580  if (SCHInfoAddHostOSInfo("vista", "192.168.10.20", SC_HINFO_IS_IPV4) == -1) {
581  goto end;
582  }
583  if (SCHInfoAddHostOSInfo("solaris", "111.163.151.62", SC_HINFO_IS_IPV4) == -1) {
584  goto end;
585  }
586  if (SCHInfoAddHostOSInfo("hpux11", "111.162.208.124/20", SC_HINFO_IS_IPV4) == -1) {
587  goto end;
588  }
589  if (SCHInfoAddHostOSInfo("windows", "111.162.240.1", SC_HINFO_IS_IPV4) == -1) {
590  goto end;
591  }
592  if (SCHInfoAddHostOSInfo("solaris", "111.162.214.100", SC_HINFO_IS_IPV4) == -1) {
593  goto end;
594  }
595  if (SCHInfoAddHostOSInfo("vista", "111.162.208.100", SC_HINFO_IS_IPV4) == -1) {
596  goto end;
597  }
598  if (SCHInfoAddHostOSInfo("linux", "111.162.194.112", SC_HINFO_IS_IPV4) == -1) {
599  goto end;
600  }
601 
602  if (SCHInfoGetHostOSFlavour("192.168.1.1") !=
604  goto end;
605  }
606  if (SCHInfoGetHostOSFlavour("192.168.1.2") != -1) {
607  goto end;
608  }
609  if (SCHInfoGetHostOSFlavour("192.168.1.100") !=
611  goto end;
612  }
613  if (SCHInfoGetHostOSFlavour("192.192.2.4") != -1) {
614  goto end;
615  }
616  if (SCHInfoGetHostOSFlavour("192.168.2.4") !=
618  goto end;
619  }
620  if (SCHInfoGetHostOSFlavour("192.192.1.5") !=
622  goto end;
623  }
624  if (SCHInfoGetHostOSFlavour("192.168.10.20") !=
626  goto end;
627  }
628  if (SCHInfoGetHostOSFlavour("111.163.151.62") !=
630  goto end;
631  }
632  if (SCHInfoGetHostOSFlavour("111.162.208.0") !=
634  goto end;
635  }
636  if (SCHInfoGetHostOSFlavour("111.162.210.1") !=
638  goto end;
639  }
640  if (SCHInfoGetHostOSFlavour("111.162.214.1") !=
642  goto end;
643  }
644  if (SCHInfoGetHostOSFlavour("111.162.0.0") != -1) {
645  goto end;
646  }
647  if (SCHInfoGetHostOSFlavour("111.162.240.112") != -1) {
648  goto end;
649  }
650  if (SCHInfoGetHostOSFlavour("111.162.240.1") !=
652  goto end;
653  }
654  if (SCHInfoGetHostOSFlavour("111.162.214.100") !=
656  goto end;
657  }
658  if (inet_pton(AF_INET, "111.162.208.100", &in) < 0) {
659  goto end;
660  }
661  if (SCHInfoGetIPv4HostOSFlavour((uint8_t *)&in) !=
663  goto end;
664  }
665  if (SCHInfoGetHostOSFlavour("111.162.194.112") !=
667  goto end;
668  }
669  if (SCHInfoGetHostOSFlavour("111.162.208.200") !=
671  goto end;
672  }
673  if (inet_pton(AF_INET, "111.162.208.200", &in) < 0) {
674  goto end;
675  }
676  if (SCHInfoGetIPv4HostOSFlavour((uint8_t *)&in) !=
678  goto end;
679  }
680  if (SCHInfoGetHostOSFlavour("111.162.200.201") != -1) {
681  goto end;
682  }
683 
684  result = 1;
685 
686  end:
688  SCHInfoRestoreContextBackup();
689 
690  return result;
691 }
692 
693 /**
694  * \test Check that valid ipv6 addresses are inserted into the host os radix
695  * tree, and the host os api retrieves the right value for the host os
696  * flavour, on supplying as arg an ipv6 address that has been added to
697  * the host os radix tree.
698  */
699 static int SCHInfoTestValidIPV6Address06(void)
700 {
701  SCHInfoCreateContextBackup();
702 
703  int result = 0;
704 
705  if (SCHInfoAddHostOSInfo("linux",
706  "2351:2512:6211:6246:235A:6242:2352:62AD",
707  SC_HINFO_IS_IPV6) == -1) {
708  goto end;
709  }
710  if (SCHInfoAddHostOSInfo("windows",
711  "6961:6121:2132:6241:423A:2135:2461:621D",
712  SC_HINFO_IS_IPV6) == -1) {
713  goto end;
714  }
715  if (SCHInfoAddHostOSInfo("solaris",
716  "DD13:613D:F312:62DD:6213:421A:6212:2652",
717  SC_HINFO_IS_IPV6) == -1) {
718  goto end;
719  }
720  if (SCHInfoAddHostOSInfo("hpux10",
721  "9891:2131:2151:6426:1342:674D:622F:2342",
722  SC_HINFO_IS_IPV6) == -1) {
723  goto end;
724  }
725  if (SCHInfoAddHostOSInfo("linux",
726  "3525:2351:4223:6211:2311:2667:6242:2154",
727  SC_HINFO_IS_IPV6) == -1) {
728  goto end;
729  }
730  if (SCHInfoAddHostOSInfo("vista",
731  "1511:6211:6726:7777:1212:2333:6222:7722",
732  SC_HINFO_IS_IPV6) == -1) {
733  goto end;
734  }
735  if (SCHInfoAddHostOSInfo("solaris",
736  "2666:6222:7222:2335:6223:7722:3425:2362",
737  SC_HINFO_IS_IPV6) == -1) {
738  goto end;
739  }
740  if (SCHInfoAddHostOSInfo("solaris",
741  "8762:2352:6241:7245:EE23:21AD:2312:622C",
742  SC_HINFO_IS_IPV6) == -1) {
743  goto end;
744  }
745  if (SCHInfoAddHostOSInfo("linux",
746  "6422:EE1A:2621:34AD:2462:432D:642E:E13A",
747  SC_HINFO_IS_IPV6) == -1) {
748  goto end;
749  }
750  if (SCHInfoAddHostOSInfo("windows",
751  "3521:7622:6241:6242:7277:1234:2352:6234",
752  SC_HINFO_IS_IPV6) == -1) {
753  goto end;
754  }
755  if (SCHInfoAddHostOSInfo("hpux11",
756  "2141:6232:6252:2223:7734:2345:6245:6222",
757  SC_HINFO_IS_IPV6) == -1) {
758  goto end;
759  }
760  if (SCHInfoAddHostOSInfo("vista",
761  "5222:6432:6432:2322:6662:3423:4322:3245",
762  SC_HINFO_IS_IPV6) == -1) {
763  goto end;
764  }
765 
766  if (SCHInfoGetHostOSFlavour("2351:2512:6211:6246:235A:6242:2352:62AD") !=
768  goto end;
769  }
770  if (SCHInfoGetHostOSFlavour("2351:2512:6211:6246:235A:6242:2352:6FFFE") != -1) {
771  goto end;
772  }
773  if (SCHInfoGetHostOSFlavour("DD13:613D:F312:62DD:6213:421A:6212:2652") !=
775  goto end;
776  }
777  if (SCHInfoGetHostOSFlavour("DD13:613D:F312:62DD:6213:421A:6212:2222") != -1) {
778  goto end;
779  }
780  if (SCHInfoGetHostOSFlavour("9891:2131:2151:6426:1342:674D:622F:2342") !=
782  goto end;
783  }
784  if (SCHInfoGetHostOSFlavour("3525:2351:4223:6211:2311:2667:6242:2154") !=
786  goto end;
787  }
788  if (SCHInfoGetHostOSFlavour("1511:6211:6726:7777:1212:2333:6222:7722") !=
790  goto end;
791  }
792  if (SCHInfoGetHostOSFlavour("2666:6222:7222:2335:6223:7722:3425:2362") !=
794  goto end;
795  }
796  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2312:622C") !=
798  goto end;
799  }
800  if (SCHInfoGetHostOSFlavour("6422:EE1A:2621:34AD:2462:432D:642E:E13A") !=
802  goto end;
803  }
804  if (SCHInfoGetHostOSFlavour("3521:7622:6241:6242:7277:1234:2352:6234") !=
806  goto end;
807  }
808  if (SCHInfoGetHostOSFlavour("2141:6232:6252:2223:7734:2345:6245:6222") !=
810  goto end;
811  }
812  if (SCHInfoGetHostOSFlavour("5222:6432:6432:2322:6662:3423:4322:3245") !=
814  goto end;
815  }
816  if (SCHInfoGetHostOSFlavour("5222:6432:6432:2322:6662:3423:4322:DDDD") != -1) {
817  goto end;
818  }
819 
820  result = 1;
821 
822  end:
824  SCHInfoRestoreContextBackup();
825 
826  return result;
827 }
828 
829 /**
830  * \test Check that valid ipv6 addresses/netblocks are inserted into the host os
831  * radix tree, and the host os api retrieves the right value for the host
832  * os flavour, on supplying as arg an ipv6 address that has been added to
833  * the host os radix tree.
834  */
835 static int SCHInfoTestValidIPV6Address07(void)
836 {
837  SCHInfoCreateContextBackup();
838 
839  int result = 0;
840 
841  if (SCHInfoAddHostOSInfo("linux",
842  "2351:2512:6211:6246:235A:6242:2352:62AD",
843  SC_HINFO_IS_IPV6) == -1) {
844  goto end;
845  }
846  if (SCHInfoAddHostOSInfo("windows",
847  "6961:6121:2132:6241:423A:2135:2461:621D",
848  SC_HINFO_IS_IPV6) == -1) {
849  goto end;
850  }
851  if (SCHInfoAddHostOSInfo("solaris",
852  "DD13:613D:F312:62DD:6213:421A:6212:2652",
853  SC_HINFO_IS_IPV6) == -1) {
854  goto end;
855  }
856  if (SCHInfoAddHostOSInfo("hpux10",
857  "9891:2131:2151:6426:1342:674D:622F:2342",
858  SC_HINFO_IS_IPV6) == -1) {
859  goto end;
860  }
861  if (SCHInfoAddHostOSInfo("linux",
862  "3525:2351:4223:6211:2311:2667:6242:2154",
863  SC_HINFO_IS_IPV6) == -1) {
864  goto end;
865  }
866  if (SCHInfoAddHostOSInfo("vista",
867  "1511:6211:6726:7777:1212:2333:6222:7722",
868  SC_HINFO_IS_IPV6) == -1) {
869  goto end;
870  }
871  if (SCHInfoAddHostOSInfo("solaris",
872  "2666:6222:7222:2335:6223:7722:3425:2362",
873  SC_HINFO_IS_IPV6) == -1) {
874  goto end;
875  }
876  if (SCHInfoAddHostOSInfo("solaris",
877  "8762:2352:6241:7245:EE23:21AD:2312:622C/68",
878  SC_HINFO_IS_IPV6) == -1) {
879  goto end;
880  }
881  if (SCHInfoAddHostOSInfo("linux",
882  "8762:2352:6241:7245:EE23:21AD:2412:622C",
883  SC_HINFO_IS_IPV6) == -1) {
884  goto end;
885  }
886  if (SCHInfoAddHostOSInfo("windows",
887  "8762:2352:6241:7245:EE23:21AD:FFFF:622C",
888  SC_HINFO_IS_IPV6) == -1) {
889  goto end;
890  }
891  if (SCHInfoAddHostOSInfo("hpux11",
892  "8762:2352:6241:7245:EE23:21AD:2312:62FF",
893  SC_HINFO_IS_IPV6) == -1) {
894  goto end;
895  }
896  if (SCHInfoAddHostOSInfo("vista",
897  "8762:2352:6241:7245:EE23:21AD:2121:1212",
898  SC_HINFO_IS_IPV6) == -1) {
899  goto end;
900  }
901 
902  if (SCHInfoGetHostOSFlavour("2351:2512:6211:6246:235A:6242:2352:62AD") !=
904  goto end;
905  }
906  if (SCHInfoGetHostOSFlavour("2351:2512:6211:6246:235A:6242:2352:6FFFE") != -1) {
907  goto end;
908  }
909  if (SCHInfoGetHostOSFlavour("DD13:613D:F312:62DD:6213:421A:6212:2652") !=
911  goto end;
912  }
913  if (SCHInfoGetHostOSFlavour("DD13:613D:F312:62DD:6213:421A:6212:2222") != -1) {
914  goto end;
915  }
916  if (SCHInfoGetHostOSFlavour("9891:2131:2151:6426:1342:674D:622F:2342") !=
918  goto end;
919  }
920  if (SCHInfoGetHostOSFlavour("3525:2351:4223:6211:2311:2667:6242:2154") !=
922  goto end;
923  }
924  if (SCHInfoGetHostOSFlavour("1511:6211:6726:7777:1212:2333:6222:7722") !=
926  goto end;
927  }
928  if (SCHInfoGetHostOSFlavour("2666:6222:7222:2335:6223:7722:3425:2362") !=
930  goto end;
931  }
932  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2312:622C") !=
934  goto end;
935  }
936  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2412:622C") !=
938  goto end;
939  }
940  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:FFFF:622C") !=
942  goto end;
943  }
944  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2312:62FF") !=
946  goto end;
947  }
948  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2121:1212") !=
950  goto end;
951  }
952  if (SCHInfoGetHostOSFlavour("5222:6432:6432:2322:6662:3423:4322:DDDD") != -1) {
953  goto end;
954  }
955  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2121:1DDD") !=
957  goto end;
958  }
959  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:FFFF:2121:1DDD") !=
961  goto end;
962  }
963  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2312:622C") !=
965  goto end;
966  }
967  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE00:0000:0000:0000") !=
969  goto end;
970  }
971  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:E000:0000:0000:0000") !=
973  goto end;
974  }
975 
976  result = 1;
977 
978  end:
980  SCHInfoRestoreContextBackup();
981 
982  return result;
983 }
984 
985 /**
986  * \test Check that valid ipv6 addresses/netblocks are inserted into the host os
987  * radix tree, and the host os api retrieves the right value for the host
988  * os flavour, on supplying as arg an ipv6 address that has been added to
989  * the host os radix tree.
990  */
991 static int SCHInfoTestValidIPV6Address08(void)
992 {
993  SCHInfoCreateContextBackup();
994 
995  struct in6_addr in6;
996  int result = 0;
997 
998  if (SCHInfoAddHostOSInfo("linux",
999  "2351:2512:6211:6246:235A:6242:2352:62AD",
1000  SC_HINFO_IS_IPV6) == -1) {
1001  goto end;
1002  }
1003  if (SCHInfoAddHostOSInfo("windows",
1004  "6961:6121:2132:6241:423A:2135:2461:621D",
1005  SC_HINFO_IS_IPV6) == -1) {
1006  goto end;
1007  }
1008  if (SCHInfoAddHostOSInfo("solaris",
1009  "DD13:613D:F312:62DD:6213:421A:6212:2652",
1010  SC_HINFO_IS_IPV6) == -1) {
1011  goto end;
1012  }
1013  if (SCHInfoAddHostOSInfo("hpux10",
1014  "9891:2131:2151:6426:1342:674D:622F:2342",
1015  SC_HINFO_IS_IPV6) == -1) {
1016  goto end;
1017  }
1018  if (SCHInfoAddHostOSInfo("linux",
1019  "3525:2351:4223:6211:2311:2667:6242:2154",
1020  SC_HINFO_IS_IPV6) == -1) {
1021  goto end;
1022  }
1023  if (SCHInfoAddHostOSInfo("vista",
1024  "1511:6211:6726:7777:1212:2333:6222:7722",
1025  SC_HINFO_IS_IPV6) == -1) {
1026  goto end;
1027  }
1028  if (SCHInfoAddHostOSInfo("solaris",
1029  "2666:6222:7222:2335:6223:7722:3425:2362",
1030  SC_HINFO_IS_IPV6) == -1) {
1031  goto end;
1032  }
1033  if (SCHInfoAddHostOSInfo("solaris",
1034  "8762:2352:6241:7245:EE23:21AD:2312:622C/68",
1035  SC_HINFO_IS_IPV6) == -1) {
1036  goto end;
1037  }
1038  if (SCHInfoAddHostOSInfo("linux",
1039  "8762:2352:6241:7245:EE23:21AD:2412:622C",
1040  SC_HINFO_IS_IPV6) == -1) {
1041  goto end;
1042  }
1043  if (SCHInfoAddHostOSInfo("windows",
1044  "8762:2352:6241:7245:EE23:21AD:FFFF:622C",
1045  SC_HINFO_IS_IPV6) == -1) {
1046  goto end;
1047  }
1048  if (SCHInfoAddHostOSInfo("hpux11",
1049  "8762:2352:6241:7245:EE23:21AD:2312:62FF",
1050  SC_HINFO_IS_IPV6) == -1) {
1051  goto end;
1052  }
1053  if (SCHInfoAddHostOSInfo("vista",
1054  "8762:2352:6241:7245:EE23:21AD:2121:1212",
1055  SC_HINFO_IS_IPV6) == -1) {
1056  goto end;
1057  }
1058  if (SCHInfoAddHostOSInfo("vista", "8.8.8.0/24", SC_HINFO_IS_IPV4) == -1) {
1059  goto end;
1060  }
1061  if (SCHInfoAddHostOSInfo("irix", "default", SC_HINFO_IS_IPV6) == -1) {
1062  goto end;
1063  }
1064 
1065  if (SCHInfoGetHostOSFlavour("2351:2512:6211:6246:235A:6242:2352:62AD") !=
1067  goto end;
1068  }
1069  if (SCHInfoGetHostOSFlavour("2351:2512:6211:6246:235A:6242:2352:6FFF") !=
1071  goto end;
1072  }
1073  if (SCHInfoGetHostOSFlavour("DD13:613D:F312:62DD:6213:421A:6212:2652") !=
1075  goto end;
1076  }
1077  if (SCHInfoGetHostOSFlavour("DD13:613D:F312:62DD:6213:421A:6212:2222") !=
1079  goto end;
1080  }
1081  if (SCHInfoGetHostOSFlavour("9891:2131:2151:6426:1342:674D:622F:2342") !=
1083  goto end;
1084  }
1085  if (SCHInfoGetHostOSFlavour("3525:2351:4223:6211:2311:2667:6242:2154") !=
1087  goto end;
1088  }
1089  if (SCHInfoGetHostOSFlavour("1511:6211:6726:7777:1212:2333:6222:7722") !=
1091  goto end;
1092  }
1093  if (SCHInfoGetHostOSFlavour("2666:6222:7222:2335:6223:7722:3425:2362") !=
1095  goto end;
1096  }
1097  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2312:622C") !=
1099  goto end;
1100  }
1101  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2412:622C") !=
1103  goto end;
1104  }
1105  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:FFFF:622C") !=
1107  goto end;
1108  }
1109  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2312:62FF") !=
1111  goto end;
1112  }
1113  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2121:1212") !=
1115  goto end;
1116  }
1117  if (SCHInfoGetHostOSFlavour("5222:6432:6432:2322:6662:3423:4322:DDDD") !=
1119  goto end;
1120  }
1121  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2121:1DDD") !=
1123  goto end;
1124  }
1125  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:FFFF:2121:1DDD") !=
1127  goto end;
1128  }
1129  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE23:21AD:2312:622C") !=
1131  goto end;
1132  }
1133  if (SCHInfoGetHostOSFlavour("8762:2352:6241:7245:EE00:0000:0000:0000") !=
1135  goto end;
1136  }
1137  if (inet_pton(AF_INET6, "8762:2352:6241:7245:E000:0000:0000:0000", &in6) < 0) {
1138  goto end;
1139  }
1140  if (SCHInfoGetIPv6HostOSFlavour((uint8_t *)&in6) !=
1142  goto end;
1143  }
1144  if (inet_pton(AF_INET6, "AD23:2DDA:6D1D:A223:E235:0232:1241:1666", &in6) < 0) {
1145  goto end;
1146  }
1147  if (SCHInfoGetIPv6HostOSFlavour((uint8_t *)&in6) !=
1149  goto end;
1150  }
1151  if (SCHInfoGetHostOSFlavour("8.8.8.8") !=
1153  goto end;
1154  }
1155  result = 1;
1156 
1157  end:
1159  SCHInfoRestoreContextBackup();
1160 
1161  return result;
1162 }
1163 
1164 /**
1165  * \test Check that valid ipv4 addresses are inserted into the host os radix
1166  * tree, and the host os api retrieves the right value for the host os
1167  * flavour, on supplying as arg an ipv4 addresses that has been added to
1168  * the host os radix tree.
1169  */
1170 static int SCHInfoTestValidIPV4Address09(void)
1171 {
1172  SCHInfoCreateContextBackup();
1173 
1174  FAIL_IF(SCHInfoAddHostOSInfo("linux", "192.168.1.0", SC_HINFO_IS_IPV4) == -1);
1175  FAIL_IF(SCHInfoAddHostOSInfo("windows", "192.192.1.2", SC_HINFO_IS_IPV4) == -1);
1176  FAIL_IF(SCHInfoGetHostOSFlavour("192.168.1.0") !=
1178  FAIL_IF(SCHInfoAddHostOSInfo("solaris", "192.168.1.0/16", SC_HINFO_IS_IPV4) == -1);
1179  FAIL_IF(SCHInfoAddHostOSInfo("macos", "192.168.1.0/20", SC_HINFO_IS_IPV4) == -1);
1180  FAIL_IF(SCHInfoGetHostOSFlavour("192.168.1.0") !=
1182  FAIL_IF(SCHInfoAddHostOSInfo("vista", "192.168.50.128/25", SC_HINFO_IS_IPV4) == -1);
1183  FAIL_IF(SCHInfoGetHostOSFlavour("192.168.50.128") !=
1185  FAIL_IF(SCHInfoAddHostOSInfo("irix", "192.168.50.128", SC_HINFO_IS_IPV4) == -1);
1186  FAIL_IF(SCHInfoGetHostOSFlavour("192.168.50.128") !=
1188  FAIL_IF(SCHInfoGetHostOSFlavour("192.168.1.100") !=
1190 
1192  SCHInfoRestoreContextBackup();
1193  PASS;
1194 }
1195 
1196 /**
1197  * \test Check the loading of host info from a configuration file.
1198  */
1199 static int SCHInfoTestLoadFromConfig01(void)
1200 {
1201  char config[] = "\
1202 %YAML 1.1\n\
1203 ---\n\
1204 host-os-policy:\n\
1205  bsd: [0.0.0.0/0]\n\
1206  windows: [10.0.0.0/8, 192.168.1.0/24]\n\
1207  linux: [10.0.0.5/32]\n\
1208 \n";
1209 
1210  int result = 0;
1211 
1212  SCHInfoCreateContextBackup();
1213 
1215  SCConfInit();
1216  SCConfYamlLoadString(config, strlen(config));
1217 
1219  if (SCHInfoGetHostOSFlavour("10.0.0.4") != OS_POLICY_WINDOWS)
1220  goto end;
1221  if (SCHInfoGetHostOSFlavour("10.0.0.5") != OS_POLICY_LINUX)
1222  goto end;
1223  if (SCHInfoGetHostOSFlavour("192.168.1.1") != OS_POLICY_WINDOWS)
1224  goto end;
1225  if (SCHInfoGetHostOSFlavour("172.168.1.1") != OS_POLICY_BSD)
1226  goto end;
1227 
1228  result = 1;
1229 
1230  end:
1232  SCConfDeInit();
1234 
1235  SCHInfoRestoreContextBackup();
1236 
1237  return result;
1238 }
1239 
1240 /**
1241  * \test Check the loading of host info from a configuration file.
1242  */
1243 static int SCHInfoTestLoadFromConfig02(void)
1244 {
1245  char config[] = "\
1246 %YAML 1.1\n\
1247 ---\n\
1248 host-os-policy:\n\
1249  one-two: [0.0.0.0/0]\n\
1250  one-two-three:\n\
1251  four_five:\n\
1252  six-seven_eight: [10.0.0.0/8, 192.168.1.0/24]\n\
1253  nine_ten_eleven: [10.0.0.5/32]\n\
1254 \n";
1255 
1256  int result = 0;
1257 
1258  SCHInfoCreateContextBackup();
1259 
1261  SCConfInit();
1262  SCConfYamlLoadString(config, strlen(config));
1263 
1264  SCConfNode *root = SCConfGetNode("host-os-policy");
1265  if (root == NULL)
1266  goto end;
1267 
1268  int count = 0;
1269 
1270  SCConfNode *policy;
1271  TAILQ_FOREACH(policy, &root->head, next) {
1272  switch (count) {
1273  case 0:
1274  if (strcmp("one-two", policy->name) != 0)
1275  goto end;
1276  break;
1277  case 1:
1278  if (strcmp("one-two-three", policy->name) != 0)
1279  goto end;
1280  break;
1281  case 2:
1282  if (strcmp("four-five", policy->name) != 0)
1283  goto end;
1284  break;
1285  case 3:
1286  if (strcmp("six-seven-eight", policy->name) != 0)
1287  goto end;
1288  break;
1289  case 4:
1290  if (strcmp("nine-ten-eleven", policy->name) != 0)
1291  goto end;
1292  break;
1293  }
1294  count++;
1295  }
1296 
1297  result = 1;
1298 
1299  end:
1301  SCConfDeInit();
1303 
1304  SCHInfoRestoreContextBackup();
1305 
1306  return result;
1307 }
1308 
1309 /**
1310  * \test Check the loading of host info from a configuration file.
1311  */
1312 static int SCHInfoTestLoadFromConfig03(void)
1313 {
1314  char config[] = "\
1315 %YAML 1.1\n\
1316 ---\n\
1317 host-os-policy:\n\
1318  bsd-right: [0.0.0.1]\n\
1319  old-linux: [0.0.0.2]\n\
1320  old-solaris: [0.0.0.3]\n\
1321  windows: [0.0.0.4]\n\
1322  vista: [0.0.0.5]\n\
1323 \n";
1324 
1325  int result = 0;
1326 
1327  SCHInfoCreateContextBackup();
1328 
1330  SCConfInit();
1331  SCConfYamlLoadString(config, strlen(config));
1332 
1333  SCConfNode *root = SCConfGetNode("host-os-policy");
1334  if (root == NULL)
1335  goto end;
1336 
1337  SCConfNode *policy;
1338  TAILQ_FOREACH(policy, &root->head, next) {
1339  if (SCMapEnumNameToValue(policy->name, sc_hinfo_os_policy_map) == -1) {
1340  printf("Invalid enum map inside\n");
1341  goto end;
1342  }
1343  }
1344 
1345  result = 1;
1346 
1347  end:
1349  SCConfDeInit();
1351 
1352  SCHInfoRestoreContextBackup();
1353  return result;
1354 }
1355 
1356 /**
1357  * \test Check the loading of host info from a configuration file.
1358  */
1359 static int SCHInfoTestLoadFromConfig04(void)
1360 {
1361  char config[] = "\
1362 %YAML 1.1\n\
1363 ---\n\
1364 host-os-policy:\n\
1365  bsd_right: [0.0.0.1]\n\
1366  old_linux: [0.0.0.2]\n\
1367  old_solaris: [0.0.0.3]\n\
1368  windows: [0.0.0.4]\n\
1369  vista: [0.0.0.5]\n\
1370 \n";
1371 
1372  int result = 0;
1373 
1374  SCHInfoCreateContextBackup();
1375 
1377  SCConfInit();
1378  SCConfYamlLoadString(config, strlen(config));
1379 
1380  SCConfNode *root = SCConfGetNode("host-os-policy");
1381  if (root == NULL)
1382  goto end;
1383 
1384  SCConfNode *policy;
1385  TAILQ_FOREACH(policy, &root->head, next) {
1386  if (SCMapEnumNameToValue(policy->name, sc_hinfo_os_policy_map) == -1) {
1387  printf("Invalid enum map inside\n");
1388  goto end;
1389  }
1390  }
1391 
1392  result = 1;
1393 
1394  end:
1396  SCConfDeInit();
1398 
1399  SCHInfoRestoreContextBackup();
1400  return result;
1401 }
1402 
1403 /**
1404  * \test Check the loading of host info from a configuration file.
1405  */
1406 static int SCHInfoTestLoadFromConfig05(void)
1407 {
1408  char config[] = "\
1409 %YAML 1.1\n\
1410 ---\n\
1411 host-os-policy:\n\
1412  bsd_right: [0.0.0.1]\n\
1413  old_linux: [0.0.0.2]\n\
1414  old-solaris: [0.0.0.3]\n\
1415  windows: [0.0.0.4]\n\
1416  linux: [0.0.0.5]\n\
1417 \n";
1418 
1419  SCHInfoCreateContextBackup();
1420 
1422  SCConfInit();
1423  SCConfYamlLoadString(config, strlen(config));
1425 
1426  FAIL_IF (SCHInfoGetHostOSFlavour("0.0.0.1") != OS_POLICY_BSD_RIGHT);
1427  FAIL_IF (SCHInfoGetHostOSFlavour("0.0.0.2") != OS_POLICY_OLD_LINUX);
1428  FAIL_IF (SCHInfoGetHostOSFlavour("0.0.0.3") != OS_POLICY_OLD_SOLARIS);
1429  FAIL_IF (SCHInfoGetHostOSFlavour("0.0.0.4") != OS_POLICY_WINDOWS);
1430  FAIL_IF (SCHInfoGetHostOSFlavour("0.0.0.5") != OS_POLICY_LINUX);
1431  FAIL_IF (SCHInfoGetHostOSFlavour("0.0.0.0") != -1);
1432  FAIL_IF (SCHInfoGetHostOSFlavour("0.0.0.6") != -1);
1433 
1435  SCConfDeInit();
1437  SCHInfoRestoreContextBackup();
1438  PASS;
1439 }
1440 
1441 #endif /* UNITTESTS */
1442 
1444 {
1445 
1446 #ifdef UNITTESTS
1447 
1448  UtRegisterTest("SCHInfoTestInvalidOSFlavour01", SCHInfoTestInvalidOSFlavour01);
1449  UtRegisterTest("SCHInfoTestInvalidIPV4Address02",
1450  SCHInfoTestInvalidIPV4Address02);
1451  UtRegisterTest("SCHInfoTestInvalidIPV6Address03",
1452  SCHInfoTestInvalidIPV6Address03);
1453  UtRegisterTest("SCHInfoTestValidIPV4Address04",
1454  SCHInfoTestValidIPV4Address04);
1455  UtRegisterTest("SCHInfoTestValidIPV4Address05",
1456  SCHInfoTestValidIPV4Address05);
1457  UtRegisterTest("SCHInfoTestValidIPV6Address06",
1458  SCHInfoTestValidIPV6Address06);
1459  UtRegisterTest("SCHInfoTestValidIPV6Address07",
1460  SCHInfoTestValidIPV6Address07);
1461  UtRegisterTest("SCHInfoTestValidIPV6Address08",
1462  SCHInfoTestValidIPV6Address08);
1463  UtRegisterTest("SCHInfoTestValidIPV4Address09",
1464  SCHInfoTestValidIPV4Address09);
1465 
1466  UtRegisterTest("SCHInfoTestLoadFromConfig01", SCHInfoTestLoadFromConfig01);
1467  UtRegisterTest("SCHInfoTestLoadFromConfig02", SCHInfoTestLoadFromConfig02);
1468  UtRegisterTest("SCHInfoTestLoadFromConfig03", SCHInfoTestLoadFromConfig03);
1469  UtRegisterTest("SCHInfoTestLoadFromConfig04", SCHInfoTestLoadFromConfig04);
1470  UtRegisterTest("SCHInfoTestLoadFromConfig05", SCHInfoTestLoadFromConfig05);
1471 #endif /* UNITTESTS */
1472 }
util-byte.h
SCConfYamlLoadString
int SCConfYamlLoadString(const char *string, size_t len)
Load configuration from a YAML string.
Definition: conf-yaml-loader.c:535
OS_POLICY_WINDOWS
@ OS_POLICY_WINDOWS
Definition: stream-tcp-reassemble.h:47
OS_POLICY_OLD_SOLARIS
@ OS_POLICY_OLD_SOLARIS
Definition: stream-tcp-reassemble.h:41
SCRadix6TreeFindBestMatch
SCRadix6Node * SCRadix6TreeFindBestMatch(const SCRadix6Tree *tree, const uint8_t *key, void **user_data)
Definition: util-radix6-tree.c:172
SCRadix4AddKeyIPV4String
bool SCRadix4AddKeyIPV4String(SCRadix4Tree *tree, const SCRadix4Config *config, const char *str, void *user)
Adds a new IPV4/netblock to the Radix4 tree from a string.
Definition: util-radix4-tree.c:226
UtRegisterTest
void UtRegisterTest(const char *name, int(*TestFn)(void))
Register unit test.
Definition: util-unittest.c:101
OS_POLICY_VISTA
@ OS_POLICY_VISTA
Definition: stream-tcp-reassemble.h:48
next
struct HtpBodyChunk_ * next
Definition: app-layer-htp.h:0
OS_POLICY_HPUX11
@ OS_POLICY_HPUX11
Definition: stream-tcp-reassemble.h:44
SCRadix4TreeInitialize
SCRadix4Tree SCRadix4TreeInitialize(void)
Definition: util-radix4-tree.c:165
OS_POLICY_BSD
@ OS_POLICY_BSD
Definition: stream-tcp-reassemble.h:37
TAILQ_FOREACH
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:252
stream-tcp-reassemble.h
OS_POLICY_IRIX
@ OS_POLICY_IRIX
Definition: stream-tcp-reassemble.h:45
sc_hinfo_os_policy_map
SCEnumCharMap sc_hinfo_os_policy_map[]
Definition: util-host-os-info.c:43
OS_POLICY_WINDOWS2K3
@ OS_POLICY_WINDOWS2K3
Definition: stream-tcp-reassemble.h:49
OS_POLICY_BSD_RIGHT
@ OS_POLICY_BSD_RIGHT
Definition: stream-tcp-reassemble.h:38
SCRadix4TreeRelease
void SCRadix4TreeRelease(SCRadix4Tree *tree, const SCRadix4Config *config)
Definition: util-radix4-tree.c:171
SCRadix4Tree_
Structure for the radix tree.
Definition: util-radix4-tree.h:66
SCConfInit
void SCConfInit(void)
Initialize the configuration system.
Definition: conf.c:120
util-debug.h
SCHInfoGetIPv6HostOSFlavour
int SCHInfoGetIPv6HostOSFlavour(uint8_t *addr)
Retrieves the host os flavour, given an ipv6 address in the raw address format.
Definition: util-host-os-info.c:260
PASS
#define PASS
Pass the test.
Definition: util-unittest.h:105
util-error.h
OS_POLICY_LINUX
@ OS_POLICY_LINUX
Definition: stream-tcp-reassemble.h:40
OS_POLICY_SOLARIS
@ OS_POLICY_SOLARIS
Definition: stream-tcp-reassemble.h:42
util-ip.h
SCHInfoRegisterTests
void SCHInfoRegisterTests(void)
Definition: util-host-os-info.c:1443
OS_POLICY_HPUX10
@ OS_POLICY_HPUX10
Definition: stream-tcp-reassemble.h:43
SC_HINFO_IS_IPV6
#define SC_HINFO_IS_IPV6
Definition: util-host-os-info.h:27
conf-yaml-loader.h
stream-tcp-private.h
conf.h
SC_RADIX4_TREE_INITIALIZER
#define SC_RADIX4_TREE_INITIALIZER
Definition: util-radix4-tree.h:78
SCConfCreateContextBackup
void SCConfCreateContextBackup(void)
Creates a backup of the conf_hash hash_table used by the conf API.
Definition: conf.c:740
SCHInfoAddHostOSInfo
int SCHInfoAddHostOSInfo(const char *host_os, const char *host_os_ip_range, int is_ipv4)
Used to add the host-os-info data obtained from the conf.
Definition: util-host-os-info.c:121
SCHInfoCleanResources
void SCHInfoCleanResources(void)
Definition: util-host-os-info.c:269
util-host-os-info.h
SCRadix6Config_
Definition: util-radix6-tree.h:69
FAIL_IF
#define FAIL_IF(expr)
Fail a test if expression evaluates to true.
Definition: util-unittest.h:71
SC_HINFO_IS_IPV4
#define SC_HINFO_IS_IPV4
Definition: util-host-os-info.h:28
SCMapEnumNameToValue
int SCMapEnumNameToValue(const char *enum_name, SCEnumCharMap *table)
Maps a string name to an enum value from the supplied table. Please specify the last element of any m...
Definition: util-enum.c:40
SCRadix4Config_
Definition: util-radix4-tree.h:71
suricata-common.h
SCEnumCharMap_
Definition: util-enum.h:27
SCHInfoLoadFromConfig
void SCHInfoLoadFromConfig(void)
Load the host os policy information from the configuration.
Definition: util-host-os-info.c:280
util-radix4-tree.h
util-radix6-tree.h
SCConfDeInit
void SCConfDeInit(void)
De-initializes the configuration system.
Definition: conf.c:759
SCStrdup
#define SCStrdup(s)
Definition: util-mem.h:56
FatalError
#define FatalError(...)
Definition: util-debug.h:517
OS_POLICY_MACOS
@ OS_POLICY_MACOS
Definition: stream-tcp-reassemble.h:46
SCRadix4TreeFindBestMatch
SCRadix4Node * SCRadix4TreeFindBestMatch(const SCRadix4Tree *tree, const uint8_t *key, void **user_data)
Definition: util-radix4-tree.c:153
SCMalloc
#define SCMalloc(sz)
Definition: util-mem.h:47
SC_EEXIST
@ SC_EEXIST
Definition: util-error.h:32
str
#define str(s)
Definition: suricata-common.h:313
SCConfGetNode
SCConfNode * SCConfGetNode(const char *name)
Get a SCConfNode by name.
Definition: conf.c:183
SCLogError
#define SCLogError(...)
Macro used to log ERROR messages.
Definition: util-debug.h:274
SCRadix6Tree_
Structure for the radix tree.
Definition: util-radix6-tree.h:64
SCFree
#define SCFree(p)
Definition: util-mem.h:61
SCConfRestoreContextBackup
void SCConfRestoreContextBackup(void)
Restores the backup of the hash_table present in backup_conf_hash back to conf_hash.
Definition: conf.c:750
sc_errno
thread_local SCError sc_errno
Definition: util-error.c:31
SCRadix6AddKeyIPV6String
bool SCRadix6AddKeyIPV6String(SCRadix6Tree *tree, const SCRadix6Config *config, const char *str, void *user)
Adds a new IPV6/netblock to the Radix6 tree from a string.
Definition: util-radix6-tree.c:261
SCHInfoGetIPv4HostOSFlavour
int SCHInfoGetIPv4HostOSFlavour(uint8_t *addr)
Retrieves the host os flavour, given an ipv4 address in the raw address format.
Definition: util-host-os-info.c:243
OS_POLICY_NONE
@ OS_POLICY_NONE
Definition: stream-tcp-reassemble.h:36
SCRadix6TreeInitialize
SCRadix6Tree SCRadix6TreeInitialize(void)
Definition: util-radix6-tree.c:359
SCConfNode_::name
char * name
Definition: conf.h:38
OS_POLICY_OLD_LINUX
@ OS_POLICY_OLD_LINUX
Definition: stream-tcp-reassemble.h:39
SCRadix6TreeRelease
void SCRadix6TreeRelease(SCRadix6Tree *tree, const SCRadix6Config *config)
Definition: util-radix6-tree.c:365
SC_RADIX6_TREE_INITIALIZER
#define SC_RADIX6_TREE_INITIALIZER
Definition: util-radix6-tree.h:76
util-enum.h
SCConfNode_
Definition: conf.h:37
SCConfNode_::val
char * val
Definition: conf.h:39