Greenbone Vulnerability Management Libraries 22.24.0
hosts.c
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2013-2023 Greenbone AG
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later
4 */
5
15
16#include "hosts.h"
17
18#include "networking.h" /* for ipv4_as_ipv6, addr6_as_str, gvm_resolve */
19
20#include <arpa/inet.h> /* for inet_pton, inet_ntop */
21#include <assert.h> /* for assert */
22#include <ctype.h> /* for isdigit */
23#include <malloc.h>
24#include <netdb.h> /* for getnameinfo, NI_NAMEREQD */
25#include <stdint.h> /* for uint8_t, uint32_t */
26#include <stdio.h> /* for sscanf, perror */
27#include <stdlib.h> /* for strtol, atoi */
28#include <string.h> /* for strchr, memcpy, memcmp, bzero, strcasecmp */
29#include <sys/socket.h> /* for AF_INET, AF_INET6, sockaddr */
30#include <unistd.h> /* for usleep() */
31
32#undef G_LOG_DOMAIN
36#define G_LOG_DOMAIN "libgvm base"
37
38/* Static variables */
39
41 [HOST_TYPE_NAME] = "Hostname",
42 [HOST_TYPE_IPV4] = "IPv4",
43 [HOST_TYPE_IPV6] = "IPv6",
44 [HOST_TYPE_CIDR_BLOCK] = "IPv4 CIDR block",
45 [HOST_TYPE_RANGE_SHORT] = "IPv4 short range",
46 [HOST_TYPE_RANGE_LONG] = "IPv4 long range"};
47
48/* Function definitions */
49
58static int
59is_ipv4_address (const char *str)
60{
61 struct sockaddr_in sa;
62
63 return inet_pton (AF_INET, str, &(sa.sin_addr)) == 1;
64}
65
74static int
75is_ipv6_address (const char *str)
76{
77 struct sockaddr_in6 sa6;
78
79 return inet_pton (AF_INET6, str, &(sa6.sin6_addr)) == 1;
80}
81
90static int
91is_cidr_block (const char *str)
92{
93 long block;
94 char *addr_str, *block_str, *p;
95
96 addr_str = g_strdup (str);
97 block_str = strchr (addr_str, '/');
98 if (block_str == NULL)
99 {
100 g_free (addr_str);
101 return 0;
102 }
103
104 /* Separate the address from the block value. */
105 *block_str = '\0';
106 block_str++;
107
108 if (!is_ipv4_address (addr_str) || !isdigit (*block_str))
109 {
110 g_free (addr_str);
111 return 0;
112 }
113
114 p = NULL;
115 block = strtol (block_str, &p, 10);
116
117 if (*p || block <= 0 || block > 30)
118 {
119 g_free (addr_str);
120 return 0;
121 }
122
123 g_free (addr_str);
124 return 1;
125}
126
136static int
137cidr_get_block (const char *str, unsigned int *block)
138{
139 if (str == NULL || block == NULL)
140 return -1;
141
142 if (sscanf (str, "%*[0-9.]/%2u", block) != 1)
143 return -1;
144
145 return 0;
146}
147
157static int
158cidr_get_ip (const char *str, struct in_addr *addr)
159{
160 gchar *addr_str, *tmp;
161
162 if (str == NULL || addr == NULL)
163 return -1;
164
165 addr_str = g_strdup (str);
166 tmp = strchr (addr_str, '/');
167 if (tmp == NULL)
168 {
169 g_free (addr_str);
170 return -1;
171 }
172 *tmp = '\0';
173
174 if (inet_pton (AF_INET, addr_str, addr) != 1)
175 return -1;
176
177 g_free (addr_str);
178 return 0;
179}
180
197static int
198cidr_block_ips (const char *str, struct in_addr *first, struct in_addr *last)
199{
200 unsigned int block;
201
202 if (str == NULL || first == NULL || last == NULL)
203 return -1;
204
205 /* Get IP and block values. */
206 if (cidr_get_block (str, &block) == -1)
207 return -1;
208 if (cidr_get_ip (str, first) == -1)
209 return -1;
210
211 /* First IP: And with mask and increment. */
212 first->s_addr &= htonl (0xffffffff ^ ((1 << (32 - block)) - 1));
213 first->s_addr = htonl (ntohl (first->s_addr) + 1);
214
215 /* Last IP: First IP + Number of usable hosts - 1. */
216 last->s_addr = htonl (ntohl (first->s_addr) + (1 << (32 - block)) - 3);
217 return 0;
218}
219
228static int
229is_long_range_network (const char *str)
230{
231 char *first_str, *second_str;
232 int ret;
233
234 first_str = g_strdup (str);
235 second_str = strchr (first_str, '-');
236 if (second_str == NULL)
237 {
238 g_free (first_str);
239 return 0;
240 }
241
242 /* Separate the addresses. */
243 *second_str = '\0';
244 second_str++;
245
246 ret = is_ipv4_address (first_str) && is_ipv4_address (second_str);
247 g_free (first_str);
248
249 return ret;
250}
251
263static int
264long_range_network_ips (const char *str, struct in_addr *first,
265 struct in_addr *last)
266{
267 char *first_str, *last_str;
268
269 if (str == NULL || first == NULL || last == NULL)
270 return -1;
271
272 first_str = g_strdup (str);
273 last_str = strchr (first_str, '-');
274 if (last_str == NULL)
275 {
276 g_free (first_str);
277 return -1;
278 }
279
280 /* Separate the two IPs. */
281 *last_str = '\0';
282 last_str++;
283
284 if (inet_pton (AF_INET, first_str, first) != 1
285 || inet_pton (AF_INET, last_str, last) != 1)
286 {
287 g_free (first_str);
288 return -1;
289 }
290
291 g_free (first_str);
292 return 0;
293}
294
303static int
304is_short_range_network (const char *str)
305{
306 long end;
307 char *ip_str, *end_str, *p;
308
309 ip_str = g_strdup (str);
310 end_str = strchr (ip_str, '-');
311 if (end_str == NULL)
312 {
313 g_free (ip_str);
314 return 0;
315 }
316
317 /* Separate the addresses. */
318 *end_str = '\0';
319 end_str++;
320
321 if (!is_ipv4_address (ip_str) || !isdigit (*end_str))
322 {
323 g_free (ip_str);
324 return 0;
325 }
326
327 p = NULL;
328 end = strtol (end_str, &p, 10);
329
330 if (*p || end < 0 || end > 255)
331 {
332 g_free (ip_str);
333 return 0;
334 }
335
336 g_free (ip_str);
337 return 1;
338}
339
351static int
352short_range_network_ips (const char *str, struct in_addr *first,
353 struct in_addr *last)
354{
355 char *first_str, *last_str;
356 int end;
357
358 if (str == NULL || first == NULL || last == NULL)
359 return -1;
360
361 first_str = g_strdup (str);
362 last_str = strchr (first_str, '-');
363 if (last_str == NULL)
364 {
365 g_free (first_str);
366 return -1;
367 }
368
369 /* Separate the two IPs. */
370 *last_str = '\0';
371 last_str++;
372 end = atoi (last_str);
373
374 /* Get the first IP */
375 if (inet_pton (AF_INET, first_str, first) != 1)
376 {
377 g_free (first_str);
378 return -1;
379 }
380
381 /* Get the last IP */
382 last->s_addr = htonl ((ntohl (first->s_addr) & 0xffffff00) + end);
383
384 g_free (first_str);
385 return 0;
386}
387
395static int
396is_hostname (const char *str)
397{
398 gchar *copy, **point, **split;
399
400 /* From
401 * https://stackoverflow.com/questions/2532053/validate-a-hostname-string. */
402
403 /* Remove one dot from the end. */
404
405 copy = g_strdup (str);
406 if (copy[strlen (copy) - 1] == '.')
407 copy[strlen (copy) - 1] = '\0';
408
409 /* Check length. */
410
411 if (strlen (copy) == 0 || strlen (copy) > 253)
412 {
413 g_free (copy);
414 return 0;
415 }
416
417 /* Split on dots. */
418
419 point = split = g_strsplit (copy, ".", 0);
420 g_free (copy);
421
422 /* Last part (TLD) may not be an integer. */
423
424 if (*point)
425 {
426 gchar *last;
427
428 while (*(point + 1))
429 point++;
430 last = *point;
431 if (strlen (last))
432 {
433 while (*last && isdigit (*last))
434 last++;
435 if (*last == '\0')
436 {
437 g_strfreev (split);
438 return 0;
439 }
440 }
441 }
442
443 /* Check each part. */
444
445 point = split;
446 while (*point)
447 if (g_regex_match_simple ("^(?!-)[a-z0-9_-]{1,63}(?<!-)$", *point,
448 G_REGEX_CASELESS, 0)
449 == 0)
450 {
451 g_strfreev (split);
452 return 0;
453 }
454 else
455 point++;
456
457 g_strfreev (split);
458 return 1;
459}
460
469static int
470is_cidr6_block (const char *str)
471{
472 long block;
473 char *addr6_str, *block_str, *p;
474
475 addr6_str = g_strdup (str);
476 block_str = strchr (addr6_str, '/');
477 if (block_str == NULL)
478 {
479 g_free (addr6_str);
480 return 0;
481 }
482
483 /* Separate the address from the block value. */
484 *block_str = '\0';
485 block_str++;
486
487 if (!is_ipv6_address (addr6_str) || !isdigit (*block_str))
488 {
489 g_free (addr6_str);
490 return 0;
491 }
492
493 p = NULL;
494 block = strtol (block_str, &p, 10);
495
496 if (*p || block <= 0 || block > 128)
497 {
498 g_free (addr6_str);
499 return 0;
500 }
501
502 g_free (addr6_str);
503 return 1;
504}
505
515static int
516cidr6_get_block (const char *str, unsigned int *block)
517{
518 if (str == NULL || block == NULL)
519 return -1;
520
521 if (sscanf (str, "%*[0-9a-fA-F.:]/%3u", block) != 1)
522 return -1;
523
524 return 0;
525}
526
536static int
537cidr6_get_ip (const char *str, struct in6_addr *addr6)
538{
539 gchar *addr6_str, *tmp;
540
541 if (str == NULL || addr6 == NULL)
542 return -1;
543
544 addr6_str = g_strdup (str);
545 tmp = strchr (addr6_str, '/');
546 if (tmp == NULL)
547 {
548 g_free (addr6_str);
549 return -1;
550 }
551 *tmp = '\0';
552
553 if (inet_pton (AF_INET6, addr6_str, addr6) != 1)
554 return -1;
555
556 g_free (addr6_str);
557 return 0;
558}
559
571static int
572cidr6_block_ips (const char *str, struct in6_addr *first, struct in6_addr *last)
573{
574 unsigned int block;
575 int i, j;
576
577 if (str == NULL || first == NULL || last == NULL)
578 return -1;
579
580 /* Get IP and block values. */
581 if (cidr6_get_block (str, &block) == -1)
582 return -1;
583 if (cidr6_get_ip (str, first) == -1)
584 return -1;
585 memcpy (&last->s6_addr, &first->s6_addr, 16);
586
587 /* /128 => Specified address is the first and last one. */
588 if (block == 128)
589 return 0;
590
591 /* First IP: And with mask and increment to skip network address. */
592 j = 15;
593 for (i = (128 - block) / 8; i > 0; i--)
594 {
595 first->s6_addr[j] = 0;
596 j--;
597 }
598 first->s6_addr[j] &= 0xff ^ ((1 << ((128 - block) % 8)) - 1);
599
600 /* Last IP: Broadcast address - 1. */
601 j = 15;
602 for (i = (128 - block) / 8; i > 0; i--)
603 {
604 last->s6_addr[j] = 0xff;
605 j--;
606 }
607 last->s6_addr[j] |= (1 << ((128 - block) % 8)) - 1;
608
609 /* /127 => Only two addresses. Don't skip network / broadcast addresses.*/
610 if (block == 127)
611 return 0;
612
613 /* Increment first IP. */
614 for (i = 15; i >= 0; --i)
615 if (first->s6_addr[i] < 255)
616 {
617 first->s6_addr[i]++;
618 break;
619 }
620 else
621 first->s6_addr[i] = 0;
622 /* Decrement last IP. */
623 for (i = 15; i >= 0; --i)
624 if (last->s6_addr[i] > 0)
625 {
626 last->s6_addr[i]--;
627 break;
628 }
629 else
630 last->s6_addr[i] = 0xff;
631
632 return 0;
633}
634
643static int
644is_long_range6_network (const char *str)
645{
646 char *first_str, *second_str;
647 int ret;
648
649 first_str = g_strdup (str);
650 second_str = strchr (first_str, '-');
651 if (second_str == NULL)
652 {
653 g_free (first_str);
654 return 0;
655 }
656
657 /* Separate the addresses. */
658 *second_str = '\0';
659 second_str++;
660
661 ret = is_ipv6_address (first_str) && is_ipv6_address (second_str);
662 g_free (first_str);
663
664 return ret;
665}
666
678static int
679long_range6_network_ips (const char *str, struct in6_addr *first,
680 struct in6_addr *last)
681{
682 char *first_str, *last_str;
683
684 if (str == NULL || first == NULL || last == NULL)
685 return -1;
686
687 first_str = g_strdup (str);
688 last_str = strchr (first_str, '-');
689 if (last_str == NULL)
690 {
691 g_free (first_str);
692 return -1;
693 }
694
695 /* Separate the two IPs. */
696 *last_str = '\0';
697 last_str++;
698
699 if (inet_pton (AF_INET6, first_str, first) != 1
700 || inet_pton (AF_INET6, last_str, last) != 1)
701 {
702 g_free (first_str);
703 return -1;
704 }
705
706 g_free (first_str);
707 return 0;
708}
709
718static int
719is_short_range6_network (const char *str)
720{
721 char *ip_str, *end_str, *p;
722
723 ip_str = g_strdup (str);
724 end_str = strchr (ip_str, '-');
725 if (end_str == NULL)
726 {
727 g_free (ip_str);
728 return 0;
729 }
730
731 /* Separate the addresses. */
732 *end_str = '\0';
733 end_str++;
734
735 if (!is_ipv6_address (ip_str) || *end_str == '\0')
736 {
737 g_free (ip_str);
738 return 0;
739 }
740
741 p = end_str;
742 /* Check that the 2nd part is at most 4 hexadecimal characters. */
743 while (isxdigit (*p) && p++)
744 ;
745 if (*p || p - end_str > 4)
746 {
747 g_free (ip_str);
748 return 0;
749 }
750
751 g_free (ip_str);
752 return 1;
753}
754
766static int
767short_range6_network_ips (const char *str, struct in6_addr *first,
768 struct in6_addr *last)
769{
770 char *first_str, *last_str;
771 long int end;
772
773 if (str == NULL || first == NULL || last == NULL)
774 return -1;
775
776 first_str = g_strdup (str);
777 last_str = strchr (first_str, '-');
778 if (last_str == NULL)
779 {
780 g_free (first_str);
781 return -1;
782 }
783
784 /* Separate the first IP. */
785 *last_str = '\0';
786 last_str++;
787
788 if (inet_pton (AF_INET6, first_str, first) != 1)
789 {
790 g_free (first_str);
791 return -1;
792 }
793
794 /* Calculate the last IP. */
795 memcpy (last, first, sizeof (*last));
796 end = strtol (last_str, NULL, 16);
797 memcpy (&last->s6_addr[15], &end, 1);
798 memcpy (&last->s6_addr[14], ((char *) &end) + 1, 1);
799
800 g_free (first_str);
801 return 0;
802}
803
812int
813gvm_get_host_type (const gchar *str_stripped)
814{
815 /*
816 * We have a single element with no leading or trailing
817 * white spaces. This element could represent different host
818 * definitions: single IPs, host names, CIDR-expressed blocks,
819 * range-expressed networks, IPv6 addresses.
820 */
821
822 /* Null or empty string. */
823 if (str_stripped == NULL || *str_stripped == '\0')
824 return -1;
825
826 /* Check for regular single IPv4 address. */
827 if (is_ipv4_address (str_stripped))
828 return HOST_TYPE_IPV4;
829
830 /* Check for regular single IPv6 address. */
831 if (is_ipv6_address (str_stripped))
832 return HOST_TYPE_IPV6;
833
834 /* Check for regular IPv4 CIDR-expressed block like "192.168.12.0/24" */
835 if (is_cidr_block (str_stripped))
837
838 /* Check for short range-expressed networks "192.168.12.5-40" */
839 if (is_short_range_network (str_stripped))
841
842 /* Check for long range-expressed networks "192.168.1.0-192.168.3.44" */
843 if (is_long_range_network (str_stripped))
845
846 /* Check for regular IPv6 CIDR-expressed block like "2620:0:2d0:200::7/120" */
847 if (is_cidr6_block (str_stripped))
849
850 /* Check for short range-expressed networks "::1-ef12" */
851 if (is_short_range6_network (str_stripped))
853
854 /* Check for long IPv6 range-expressed networks like "::1:20:7-::1:25:3" */
855 if (is_long_range6_network (str_stripped))
857
858 /* Check for hostname. */
859 if (is_hostname (str_stripped))
860 return HOST_TYPE_NAME;
861
862 return -1;
863}
864
874gvm_vhost_new (char *value, char *source)
875{
876 gvm_vhost_t *vhost;
877
878 vhost = g_malloc0 (sizeof (gvm_vhost_t));
879 vhost->value = value;
880 vhost->source = source;
881
882 return vhost;
883}
884
890static void
891gvm_vhost_free (gpointer vhost)
892{
893 if (vhost)
894 {
895 g_free (((gvm_vhost_t *) vhost)->value);
896 g_free (((gvm_vhost_t *) vhost)->source);
897 }
898 g_free (vhost);
899}
900
908gpointer
909gvm_duplicate_vhost (gconstpointer vhost, gpointer data)
910{
911 (void) (data);
912 gvm_vhost_t *ret = NULL;
913
914 if (!vhost)
915 return NULL;
916
917 ret = gvm_vhost_new (g_strdup (((gvm_vhost_t *) vhost)->value),
918 g_strdup (((gvm_vhost_t *) vhost)->source));
919
920 return ret;
921}
922
928static gvm_host_t *
930{
931 gvm_host_t *host;
932
933 host = g_malloc0 (sizeof (gvm_host_t));
934
935 return host;
936}
937
943void
944gvm_host_free (gpointer host)
945{
946 gvm_host_t *h = host;
947 if (h == NULL)
948 return;
949
950 /* If host of type hostname, free the name buffer, first. */
951 if (h->type == HOST_TYPE_NAME)
952 g_free (h->name);
953
954 g_slist_free_full (h->vhosts, gvm_vhost_free);
955 g_free (h);
956}
957
964void
966{
967 if (hosts->count == hosts->max_size)
968 {
969 hosts->max_size *= 4;
970 hosts->hosts =
971 g_realloc_n (hosts->hosts, hosts->max_size, sizeof (*hosts->hosts));
972 memset (hosts->hosts + hosts->count, '\0',
973 (hosts->max_size - hosts->count) * sizeof (gvm_host_t *));
974 }
975 hosts->hosts[hosts->count] = host;
976 hosts->count++;
977}
978
986static gvm_hosts_t *
987gvm_hosts_init (const char *hosts_str)
988{
989 gvm_hosts_t *hosts;
990
991 hosts = g_malloc0 (sizeof (gvm_hosts_t));
992 hosts->max_size = 1024;
993 hosts->hosts = g_malloc0_n (hosts->max_size, sizeof (gvm_host_t *));
994 hosts->orig_str = g_strdup (hosts_str);
995 return hosts;
996}
997
1004static void
1006{
1007 size_t i;
1008 if (!hosts)
1009 return;
1010
1011 for (i = 0; i < hosts->max_size; i++)
1012 {
1013 if (!hosts->hosts[i])
1014 {
1015 size_t j;
1016
1017 /* Fill the gap with the closest host entry, in order to keep the
1018 * sequential ordering. */
1019 for (j = i + 1; j < hosts->max_size; j++)
1020 {
1021 if (hosts->hosts[j])
1022 {
1023 hosts->hosts[i] = hosts->hosts[j];
1024 hosts->hosts[j] = NULL;
1025 break;
1026 }
1027 }
1028 /* No more entries left, ie. the empty space between count and
1029 * max_size. */
1030 if (!hosts->hosts[i])
1031 return;
1032 }
1033 }
1034}
1035
1042static void
1044{
1048 GHashTable *name_table;
1049 size_t i, duplicates = 0;
1050
1051 if (hosts == NULL)
1052 return;
1053 name_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
1054
1055 for (i = 0; i < hosts->count; i++)
1056 {
1057 gchar *name;
1058
1059 name = gvm_host_value_str (hosts->hosts[i]);
1060 if (name)
1061 {
1062 gvm_host_t *host, *removed = hosts->hosts[i];
1063
1064 host = g_hash_table_lookup (name_table, name);
1065 if (host)
1066 {
1067 /* Remove duplicate host. Add its vhosts to the original host. */
1068 host->vhosts = g_slist_concat (host->vhosts, removed->vhosts);
1069 removed->vhosts = NULL;
1070 gvm_host_free (removed);
1071 hosts->hosts[i] = NULL;
1072 duplicates++;
1073 g_free (name);
1074 }
1075 else
1076 g_hash_table_insert (name_table, name, hosts->hosts[i]);
1077 }
1078 }
1079
1080 if (duplicates)
1081 gvm_hosts_fill_gaps (hosts);
1082 g_hash_table_destroy (name_table);
1083 hosts->count -= duplicates;
1084 hosts->duplicated += duplicates;
1085 hosts->current = 0;
1086#ifdef __GLIBC__
1087 malloc_trim (0);
1088#endif
1089}
1090
1103gvm_hosts_new_with_max (const gchar *hosts_str, unsigned int max_hosts)
1104{
1105 gvm_hosts_t *hosts;
1106 gchar **host_element, **split;
1107 gchar *str;
1108
1109 if (hosts_str == NULL)
1110 return NULL;
1111
1112 /* Normalize separator: Transform newlines into commas. */
1113 hosts = gvm_hosts_init (hosts_str);
1114 str = hosts->orig_str;
1115 while (*str)
1116 {
1117 if (*str == '\n')
1118 *str = ',';
1119 str++;
1120 }
1121
1122 /* Split comma-separated list into single host-specifications */
1123 split = g_strsplit (hosts->orig_str, ",", 0);
1124
1125 /* first element of the split list */
1126 host_element = split;
1127 while (*host_element)
1128 {
1129 int host_type;
1130 gchar *stripped = g_strstrip (*host_element);
1131
1132 if (stripped == NULL || *stripped == '\0')
1133 {
1134 host_element++;
1135 continue;
1136 }
1137
1138 /* IPv4, hostname, IPv6, collection (short/long range, cidr block) etc,. ?
1139 */
1140 /* -1 if error. */
1141 host_type = gvm_get_host_type (stripped);
1142
1143 switch (host_type)
1144 {
1145 case HOST_TYPE_NAME:
1146 case HOST_TYPE_IPV4:
1147 case HOST_TYPE_IPV6:
1148 {
1149 /* New host. */
1150 gvm_host_t *host = gvm_host_new ();
1151 host->type = host_type;
1153 host->name = g_ascii_strdown (stripped, -1);
1154 else if (host_type == HOST_TYPE_IPV4)
1155 {
1156 if (inet_pton (AF_INET, stripped, &host->addr) != 1)
1157 break;
1158 }
1159 else if (host_type == HOST_TYPE_IPV6)
1160 {
1161 if (inet_pton (AF_INET6, stripped, &host->addr6) != 1)
1162 break;
1163 }
1164 gvm_hosts_add (hosts, host);
1165 break;
1166 }
1170 {
1171 struct in_addr first, last;
1172 uint32_t current;
1173 int (*ips_func) (const char *, struct in_addr *, struct in_addr *);
1174
1176 ips_func = cidr_block_ips;
1177 else if (host_type == HOST_TYPE_RANGE_SHORT)
1178 ips_func = short_range_network_ips;
1179 else
1180 ips_func = long_range_network_ips;
1181
1182 if (ips_func (stripped, &first, &last) == -1)
1183 break;
1184
1185 /* Make sure that first actually comes before last */
1186 if (ntohl (first.s_addr) > ntohl (last.s_addr))
1187 break;
1188
1189 /* Add addresses from first to last as single hosts. */
1190 current = first.s_addr;
1191 while (ntohl (current) <= ntohl (last.s_addr))
1192 {
1193 gvm_host_t *host;
1194 if (max_hosts > 0 && hosts->count > max_hosts)
1195 {
1196 g_strfreev (split);
1197 gvm_hosts_free (hosts);
1198 return NULL;
1199 }
1200 host = gvm_host_new ();
1201 host->type = HOST_TYPE_IPV4;
1202 host->addr.s_addr = current;
1203 gvm_hosts_add (hosts, host);
1204 /* Next IP address. */
1205 current = htonl (ntohl (current) + 1);
1206 }
1207 break;
1208 }
1212 {
1213 struct in6_addr first, last;
1214 unsigned char current[16];
1215 int (*ips_func) (const char *, struct in6_addr *,
1216 struct in6_addr *);
1217
1219 ips_func = cidr6_block_ips;
1221 ips_func = short_range6_network_ips;
1222 else
1223 ips_func = long_range6_network_ips;
1224
1225 if (ips_func (stripped, &first, &last) == -1)
1226 break;
1227
1228 /* Make sure the first comes before the last. */
1229 if (memcmp (&first.s6_addr, &last.s6_addr, 16) > 0)
1230 break;
1231
1232 /* Add addresses from first to last as single hosts. */
1233 memcpy (current, &first.s6_addr, 16);
1234 while (memcmp (current, &last.s6_addr, 16) <= 0)
1235 {
1236 int i;
1237 gvm_host_t *host;
1238
1239 if (max_hosts > 0 && hosts->count > max_hosts)
1240 {
1241 g_strfreev (split);
1242 gvm_hosts_free (hosts);
1243 return NULL;
1244 }
1245 host = gvm_host_new ();
1246 host->type = HOST_TYPE_IPV6;
1247 memcpy (host->addr6.s6_addr, current, 16);
1248 gvm_hosts_add (hosts, host);
1249 /* Next IPv6 address. */
1250 for (i = 15; i >= 0; --i)
1251 if (current[i] < 255)
1252 {
1253 current[i]++;
1254 break;
1255 }
1256 else
1257 current[i] = 0;
1258 }
1259 break;
1260 }
1261 case -1:
1262 default:
1263 /* Invalid host string. */
1264 g_strfreev (split);
1265 gvm_hosts_free (hosts);
1266 return NULL;
1267 }
1268 host_element++; /* move on to next element of split list */
1269 if (max_hosts > 0 && hosts->count > max_hosts)
1270 {
1271 g_strfreev (split);
1272 gvm_hosts_free (hosts);
1273 return NULL;
1274 }
1275 }
1276
1277 /* No need to check for duplicates when a hosts string contains a
1278 * single (IP/Hostname/Range/Subnetwork) entry. */
1279 if (g_strv_length (split) > 1)
1280 gvm_hosts_deduplicate (hosts);
1281
1282 g_strfreev (split);
1283#ifdef __GLIBC__
1284 malloc_trim (0);
1285#endif
1286 return hosts;
1287}
1288
1300gvm_hosts_new (const gchar *hosts_str)
1301{
1302 return gvm_hosts_new_with_max (hosts_str, 0);
1303}
1304
1313gvm_host_t *
1315{
1316 if (!hosts || hosts->current == hosts->count)
1317 return NULL;
1318
1319 return hosts->hosts[hosts->current++];
1320}
1321
1331void
1333{
1334 void *host_tmp;
1335 size_t i;
1336
1337 if (!hosts)
1338 return;
1339
1340 // Keep in mind that gvm_hosts_next will return the current host and then
1341 // increment hosts->current.
1342
1343 if (hosts->current == hosts->count)
1344 {
1345 // We're on the last host, just make the previous host current.
1346 // TODO what happens when current is 0?
1347 hosts->current -= 1;
1348 return;
1349 }
1350
1351 // Make the previous host current. This makes sure that gvm_hosts_next will
1352 // return the host that has replaced the current host.
1353 // TODO what happens when current is 0?
1354 hosts->current -= 1;
1355 // Get the host to be moved.
1356 host_tmp = hosts->hosts[hosts->current];
1357
1358 // Shift all the others down. Start from current + 1 because we're assigning
1359 // into the previous slot (i - 1). It's safe to do this because we already
1360 // checked if current == count above.
1361 for (i = hosts->current + 1; i < hosts->count; i++)
1362 hosts->hosts[i - 1] = hosts->hosts[i];
1363
1364 // Put the moved host on the end.
1365 hosts->hosts[hosts->count - 1] = host_tmp;
1366}
1367
1374void
1376{
1377 size_t i;
1378
1379 if (hosts == NULL)
1380 return;
1381
1382 if (hosts->orig_str)
1383 g_free (hosts->orig_str);
1384 for (i = 0; i < hosts->count; i++)
1385 gvm_host_free (hosts->hosts[i]);
1386 g_free (hosts->hosts);
1387 g_free (hosts);
1388 hosts = NULL;
1389}
1390
1398void
1400{
1401 size_t i = 0;
1402 GRand *rand;
1403
1404 if (hosts == NULL)
1405 return;
1406
1407 /* Shuffle the array. */
1408 rand = g_rand_new ();
1409 for (i = 0; i < hosts->count; i++)
1410 {
1411 void *tmp;
1412 int j = g_rand_int_range (rand, 0, hosts->count);
1413
1414 tmp = hosts->hosts[i];
1415 hosts->hosts[i] = hosts->hosts[j];
1416 hosts->hosts[j] = tmp;
1417 }
1418
1419 hosts->current = 0;
1420 g_rand_free (rand);
1421}
1422
1430void
1432{
1433 size_t i, j;
1434 if (hosts == NULL)
1435 return;
1436
1437 for (i = 0, j = hosts->count - 1; i < j; i++, j--)
1438 {
1439 gvm_host_t *tmp = hosts->hosts[i];
1440 hosts->hosts[i] = hosts->hosts[j];
1441 hosts->hosts[j] = tmp;
1442 }
1443 hosts->current = 0;
1444}
1445
1456GSList *
1458{
1459 size_t i, new_entries = 0, resolved = 0;
1460 GSList *unresolved = NULL;
1461
1462 for (i = 0; i < hosts->count; i++)
1463 {
1464 GSList *list, *tmp;
1465 gvm_host_t *host = hosts->hosts[i];
1466
1467 if (host->type != HOST_TYPE_NAME)
1468 continue;
1469
1470 list = tmp = gvm_resolve_list (host->name);
1471 while (tmp)
1472 {
1473 /* Create a new host for each IP address. */
1474 gvm_host_t *new;
1475 struct in6_addr *ip6 = tmp->data;
1476 gvm_vhost_t *vhost;
1477
1478 new = gvm_host_new ();
1479 if (ip6->s6_addr32[0] != 0 || ip6->s6_addr32[1] != 0
1480 || ip6->s6_addr32[2] != htonl (0xffff))
1481 {
1482 new->type = HOST_TYPE_IPV6;
1483 memcpy (&new->addr6, ip6, sizeof (new->addr6));
1484 }
1485 else
1486 {
1487 new->type = HOST_TYPE_IPV4;
1488 memcpy (&new->addr6, &ip6->s6_addr32[3], sizeof (new->addr));
1489 }
1490 vhost =
1491 gvm_vhost_new (g_strdup (host->name), g_strdup ("Forward-DNS"));
1492 new->vhosts = g_slist_prepend (new->vhosts, vhost);
1493 gvm_hosts_add (hosts, new);
1494 tmp = tmp->next;
1495 new_entries = 1;
1496 }
1497 /* Remove hostname from list, as it was either replaced by IPs, or
1498 * is unresolvable. */
1499 hosts->hosts[i] = NULL;
1500 resolved++;
1501 if (!list)
1502 unresolved = g_slist_prepend (unresolved, g_strdup (host->name));
1503 gvm_host_free (host);
1504 g_slist_free_full (list, g_free);
1505 }
1506 if (resolved)
1507 gvm_hosts_fill_gaps (hosts);
1508 hosts->count -= resolved;
1509 hosts->removed += resolved;
1510 if (new_entries)
1511 gvm_hosts_deduplicate (hosts);
1512 hosts->current = 0;
1513 return unresolved;
1514}
1515
1524int
1525gvm_vhosts_exclude (gvm_host_t *host, const char *excluded_str)
1526{
1527 GSList *vhost;
1528 char **excluded;
1529 int ret = 0;
1530
1531 if (!host || !excluded_str)
1532 return ret;
1533
1534 vhost = host->vhosts;
1535 excluded = g_strsplit (excluded_str, ",", 0);
1536 if (!excluded || !*excluded)
1537 {
1538 g_strfreev (excluded);
1539 return ret;
1540 }
1541 while (vhost)
1542 {
1543 char **tmp = excluded;
1544 char *value = ((gvm_vhost_t *) vhost->data)->value;
1545
1546 while (*tmp)
1547 {
1548 if (!strcasecmp (value, g_strstrip (*tmp)))
1549 {
1550 gvm_vhost_free (vhost->data);
1551 host->vhosts = vhost = g_slist_delete_link (host->vhosts, vhost);
1552 ret++;
1553 break;
1554 }
1555 tmp++;
1556 if (!*tmp)
1557 {
1558 vhost = vhost->next;
1559 break;
1560 }
1561 }
1562 }
1563 g_strfreev (excluded);
1564
1565 return ret;
1566}
1567
1579int
1580gvm_hosts_exclude_with_max (gvm_hosts_t *hosts, const char *excluded_str,
1581 unsigned int max_hosts)
1582{
1586 gvm_hosts_t *excluded_hosts;
1587 GHashTable *name_table;
1588 size_t excluded = 0, i;
1589
1590 if (hosts == NULL || excluded_str == NULL)
1591 return -1;
1592
1593 excluded_hosts = gvm_hosts_new_with_max (excluded_str, max_hosts);
1594 if (excluded_hosts == NULL)
1595 return -1;
1596
1597 if (gvm_hosts_count (excluded_hosts) == 0)
1598 {
1599 gvm_hosts_free (excluded_hosts);
1600 return 0;
1601 }
1602
1603 /* Hash host values from excluded hosts list. */
1604 name_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
1605 for (i = 0; i < excluded_hosts->count; i++)
1606 {
1607 gchar *name;
1608
1609 name = gvm_host_value_str (excluded_hosts->hosts[i]);
1610 if (name)
1611 g_hash_table_insert (name_table, name, hosts);
1612 }
1613
1614 /* Check for hosts values in hash table. */
1615 for (i = 0; i < hosts->count; i++)
1616 {
1617 gchar *name;
1618
1619 name = gvm_host_value_str (hosts->hosts[i]);
1620 if (name)
1621 {
1622 if (g_hash_table_lookup (name_table, name))
1623 {
1624 gvm_host_free (hosts->hosts[i]);
1625 hosts->hosts[i] = NULL;
1626 excluded++;
1627 g_free (name);
1628 continue;
1629 }
1630 g_free (name);
1631 }
1632 }
1633
1634 /* Cleanup. */
1635 if (excluded)
1636 gvm_hosts_fill_gaps (hosts);
1637 hosts->count -= excluded;
1638 hosts->removed += excluded;
1639 hosts->current = 0;
1640 g_hash_table_destroy (name_table);
1641 gvm_hosts_free (excluded_hosts);
1642 return excluded;
1643}
1644
1657GSList *
1658gvm_hosts_allowed_only (gvm_hosts_t *hosts, const char *deny_hosts_str,
1659 const char *allow_hosts_str)
1660{
1664 gvm_hosts_t *allowed_hosts, *denied_hosts;
1665 GHashTable *name_allow_table = NULL, *name_deny_table = NULL;
1666 GSList *removed = NULL;
1667 size_t excluded = 0, i;
1668
1669 if (hosts == NULL || (deny_hosts_str == NULL && allow_hosts_str == NULL))
1670 return NULL;
1671
1672 // Prepare list of denied and allowed hosts
1673 denied_hosts = gvm_hosts_new_with_max (deny_hosts_str, 0);
1674 allowed_hosts = gvm_hosts_new_with_max (allow_hosts_str, 0);
1675 if (denied_hosts == NULL && allowed_hosts == NULL)
1676 return NULL;
1677
1678 if (gvm_hosts_count (denied_hosts) == 0)
1679 gvm_hosts_free (denied_hosts);
1680 else
1681 {
1682 /* Hash host values from denied hosts list. */
1683 name_deny_table =
1684 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
1685 for (i = 0; i < denied_hosts->count; i++)
1686 {
1687 gchar *name;
1688
1689 name = gvm_host_value_str (denied_hosts->hosts[i]);
1690 if (name)
1691 g_hash_table_insert (name_deny_table, name, hosts);
1692 }
1693 }
1694 if (gvm_hosts_count (allowed_hosts) == 0)
1695 gvm_hosts_free (allowed_hosts);
1696 else
1697 {
1698 /* Hash host values from allowed hosts list. */
1699 name_allow_table =
1700 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
1701 for (i = 0; i < allowed_hosts->count; i++)
1702 {
1703 gchar *name;
1704
1705 name = gvm_host_value_str (allowed_hosts->hosts[i]);
1706 if (name)
1707 g_hash_table_insert (name_allow_table, name, hosts);
1708 }
1709 }
1710
1711 /* Check for authorized hosts in hash table and create a list of removed
1712 * hosts. */
1713 for (i = 0; i < hosts->count; i++)
1714 {
1715 gchar *name;
1716
1717 name = gvm_host_value_str (hosts->hosts[i]);
1718 if (name)
1719 {
1720 if (denied_hosts != NULL
1721 && g_hash_table_lookup (name_deny_table, name))
1722 {
1723 gvm_host_free (hosts->hosts[i]);
1724 hosts->hosts[i] = NULL;
1725 excluded++;
1726 removed = g_slist_prepend (removed, name);
1727 continue;
1728 }
1729 else if (allowed_hosts != NULL
1730 && !g_hash_table_lookup (name_allow_table, name))
1731 {
1732 gvm_host_free (hosts->hosts[i]);
1733 hosts->hosts[i] = NULL;
1734 excluded++;
1735 removed = g_slist_prepend (removed, name);
1736 continue;
1737 }
1738 g_free (name);
1739 }
1740 }
1741
1742 /* Cleanup. */
1743 if (excluded)
1744 gvm_hosts_fill_gaps (hosts);
1745
1746 hosts->count -= excluded;
1747 hosts->removed += excluded;
1748 hosts->current = 0;
1749 if (name_allow_table != NULL)
1750 g_hash_table_destroy (name_allow_table);
1751 if (name_deny_table != NULL)
1752 g_hash_table_destroy (name_deny_table);
1753 if (allowed_hosts != NULL)
1754 gvm_hosts_free (allowed_hosts);
1755 if (denied_hosts != NULL)
1756 gvm_hosts_free (denied_hosts);
1757 return removed;
1758}
1759
1770int
1771gvm_hosts_exclude (gvm_hosts_t *hosts, const char *excluded_str)
1772{
1773 return gvm_hosts_exclude_with_max (hosts, excluded_str, 0);
1774}
1775
1786gvm_host_t *
1787gvm_host_from_str (const gchar *host_str)
1788{
1789 int host_type;
1790
1791 if (host_str == NULL)
1792 return NULL;
1793
1794 /* IPv4, hostname, IPv6 */
1795 /* -1 if error. */
1796 host_type = gvm_get_host_type (host_str);
1797
1798 switch (host_type)
1799 {
1800 case HOST_TYPE_NAME:
1801 case HOST_TYPE_IPV4:
1802 case HOST_TYPE_IPV6:
1803 {
1804 /* New host. */
1805 gvm_host_t *host = gvm_host_new ();
1806 host->type = host_type;
1808 host->name = g_ascii_strdown (host_str, -1);
1809 else if (host_type == HOST_TYPE_IPV4)
1810 {
1811 if (inet_pton (AF_INET, host_str, &host->addr) != 1)
1812 break;
1813 }
1814 else if (host_type == HOST_TYPE_IPV6)
1815 {
1816 if (inet_pton (AF_INET6, host_str, &host->addr6) != 1)
1817 break;
1818 }
1819 return host;
1820 }
1821 case -1:
1822 default:
1823 return NULL;
1824 }
1825 return NULL;
1826}
1827
1835char *
1837{
1838 int retry = 10;
1839 gchar hostname[NI_MAXHOST];
1840 void *addr;
1841 size_t addrlen;
1842 struct sockaddr_in sa;
1843 struct sockaddr_in6 sa6;
1844
1845 if (!host)
1846 return NULL;
1847
1848 if (host->type == HOST_TYPE_IPV4)
1849 {
1850 addr = &sa;
1851 addrlen = sizeof (sa);
1852 memset (addr, '\0', addrlen);
1853 sa.sin_addr = host->addr;
1854 sa.sin_family = AF_INET;
1855 }
1856 else if (host->type == HOST_TYPE_IPV6)
1857 {
1858 addr = &sa6;
1859 addrlen = sizeof (sa6);
1860 memset (&sa6, '\0', addrlen);
1861 memcpy (&sa6.sin6_addr, &host->addr6, 16);
1862 sa6.sin6_family = AF_INET6;
1863 }
1864 else
1865 return NULL;
1866
1867 while (retry--)
1868 {
1869 int ret = getnameinfo (addr, addrlen, hostname, sizeof (hostname), NULL,
1870 0, NI_NAMEREQD);
1871 if (!ret)
1872 return g_ascii_strdown (hostname, -1);
1873 if (ret != EAI_AGAIN)
1874 break;
1875 usleep (10000); // 10ms
1876 }
1877 return NULL;
1878}
1879
1888static int
1889host_name_verify (gvm_host_t *host, const char *value)
1890{
1891 GSList *list, *tmp;
1892 char *host_str;
1893 int ret = -1;
1894
1895 assert (host);
1896 assert (value);
1897 host_str = gvm_host_value_str (host);
1898 list = tmp = gvm_resolve_list (value);
1899 while (tmp)
1900 {
1901 char buffer[INET6_ADDRSTRLEN];
1902 addr6_to_str (tmp->data, buffer);
1903 if (!strcasecmp (host_str, buffer))
1904 {
1905 ret = 0;
1906 break;
1907 }
1908 tmp = tmp->next;
1909 }
1910 g_free (host_str);
1911 g_slist_free_full (list, g_free);
1912 return ret;
1913}
1914
1920void
1922{
1923 GSList *vhosts;
1924 gvm_vhost_t *vhost;
1925 char *value;
1926
1927 if (!host || host->type == HOST_TYPE_NAME)
1928 return;
1929
1930 value = gvm_host_reverse_lookup (host);
1931 if (!value)
1932 return;
1933 if (host_name_verify (host, value))
1934 {
1935 g_free (value);
1936 return;
1937 }
1938 /* Don't add vhost, if already in the list. */
1939 vhosts = host->vhosts;
1940 while (vhosts)
1941 {
1942 if (!strcasecmp (((gvm_vhost_t *) vhosts->data)->value, value))
1943 {
1944 g_free (value);
1945 return;
1946 }
1947 vhosts = vhosts->next;
1948 }
1949 vhost = gvm_vhost_new (value, g_strdup ("Reverse-DNS"));
1950 host->vhosts = g_slist_prepend (host->vhosts, vhost);
1951}
1952
1964{
1965 size_t i, count = 0;
1966 gvm_hosts_t *excluded = gvm_hosts_new ("");
1967
1968 if (hosts == NULL)
1969 return NULL;
1970
1971 for (i = 0; i < hosts->count; i++)
1972 {
1973 gchar *name = gvm_host_reverse_lookup (hosts->hosts[i]);
1974
1975 if (name == NULL)
1976 {
1977 gvm_hosts_add (excluded, gvm_duplicate_host (hosts->hosts[i]));
1978 gvm_host_free (hosts->hosts[i]);
1979 hosts->hosts[i] = NULL;
1980 count++;
1981 }
1982 else
1983 g_free (name);
1984 }
1985
1986 if (count)
1987 gvm_hosts_fill_gaps (hosts);
1988 hosts->count -= count;
1989 hosts->removed += count;
1990 hosts->current = 0;
1991 return excluded;
1992}
1993
2003int
2005{
2006 gvm_hosts_t *excluded;
2007 int count = 0;
2008
2009 if (hosts == NULL)
2010 return -1;
2011
2012 excluded = gvm_hosts_reverse_lookup_only_excluded (hosts);
2013 count = excluded->count;
2014 gvm_hosts_free (excluded);
2015
2016 return count;
2017}
2018
2030{
2034 size_t i, count = 0;
2035 GHashTable *name_table;
2036 gvm_hosts_t *excluded = NULL;
2037
2038 if (hosts == NULL)
2039 return NULL;
2040
2041 excluded = gvm_hosts_new ("");
2042 name_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
2043 for (i = 0; i < hosts->count; i++)
2044 {
2045 gchar *name;
2046
2047 name = gvm_host_reverse_lookup (hosts->hosts[i]);
2048 if (name)
2049 {
2050 if (g_hash_table_lookup (name_table, name))
2051 {
2052 gvm_hosts_add (excluded, gvm_duplicate_host (hosts->hosts[i]));
2053 gvm_host_free (hosts->hosts[i]);
2054 hosts->hosts[i] = NULL;
2055 count++;
2056 g_free (name);
2057 }
2058 else
2059 {
2060 /* Insert in the hash table. Value not important. */
2061 g_hash_table_insert (name_table, name, hosts);
2062 }
2063 }
2064 }
2065
2066 if (count)
2067 gvm_hosts_fill_gaps (hosts);
2068 g_hash_table_destroy (name_table);
2069 hosts->removed += count;
2070 hosts->count -= count;
2071 hosts->current = 0;
2072 return excluded;
2073}
2074
2084int
2086{
2087 gvm_hosts_t *excluded = NULL;
2088 int count = 0;
2089 if (hosts == NULL)
2090 return -1;
2091
2092 excluded = gvm_hosts_reverse_lookup_unify_excluded (hosts);
2093 count = excluded->count;
2094 gvm_hosts_free (excluded);
2095
2096 return count;
2097}
2098
2105unsigned int
2107{
2108 return hosts ? hosts->count : 0;
2109}
2110
2119unsigned int
2121{
2122 return hosts ? hosts->removed : 0;
2123}
2124
2133unsigned int
2135{
2136 return hosts ? hosts->duplicated : 0;
2137}
2138
2149gvm_host_t *
2150gvm_host_find_in_hosts (const gvm_host_t *host, const struct in6_addr *addr,
2151 const gvm_hosts_t *hosts)
2152{
2153 char *host_str;
2154 size_t i;
2155
2156 if (host == NULL || hosts == NULL)
2157 return NULL;
2158
2159 host_str = gvm_host_value_str (host);
2160
2161 for (i = 0; i < hosts->count; i++)
2162 {
2163 gvm_host_t *current_host = hosts->hosts[i];
2164 char *tmp = gvm_host_value_str (current_host);
2165
2166 if (strcasecmp (host_str, tmp) == 0)
2167 {
2168 g_free (host_str);
2169 g_free (tmp);
2170 return current_host;
2171 }
2172 g_free (tmp);
2173
2174 /* Hostnames in hosts list shouldn't be resolved. */
2175 if (addr && gvm_host_type (current_host) != HOST_TYPE_NAME)
2176 {
2177 struct in6_addr tmpaddr;
2178 gvm_host_get_addr6 (current_host, &tmpaddr);
2179
2180 if (memcmp (addr->s6_addr, &tmpaddr.s6_addr, 16) == 0)
2181 {
2182 g_free (host_str);
2183 return current_host;
2184 }
2185 }
2186 }
2187
2188 g_free (host_str);
2189 return NULL;
2190}
2191
2198gvm_host_t *
2200{
2201 gvm_host_t *ret = NULL;
2202
2203 if (host == NULL)
2204 return NULL;
2205
2206 ret = gvm_host_new ();
2207
2208 ret->type = host->type;
2209 switch (host->type)
2210 {
2211 case HOST_TYPE_NAME:
2212 ret->name = g_strdup (host->name);
2213 break;
2214 case HOST_TYPE_IPV4:
2215 ret->addr.s_addr = host->addr.s_addr;
2216 break;
2217 case HOST_TYPE_IPV6:
2218 ret->addr6.__in6_u = host->addr6.__in6_u;
2219 break;
2220 default:
2221 g_free (ret);
2222 return NULL;
2223 }
2224 ret->vhosts = g_slist_copy_deep (host->vhosts, gvm_duplicate_vhost, NULL);
2225
2226 return ret;
2227}
2228
2241int
2242gvm_host_in_hosts (const gvm_host_t *host, const struct in6_addr *addr,
2243 const gvm_hosts_t *hosts)
2244{
2245 if (gvm_host_find_in_hosts (host, addr, hosts))
2246 return 1;
2247
2248 return 0;
2249}
2250
2258enum host_type
2260{
2261 assert (host);
2262 return host->type;
2263}
2264
2273gchar *
2275{
2276 if (host == NULL)
2277 return NULL;
2278
2279 return host_type_str[host->type];
2280}
2281
2289gchar *
2291{
2292 if (host == NULL)
2293 return NULL;
2294
2295 switch (host->type)
2296 {
2297 case HOST_TYPE_NAME:
2298 return g_strdup (host->name);
2299 break;
2300 case HOST_TYPE_IPV4:
2301 case HOST_TYPE_IPV6:
2302 /* Handle both cases using inet_ntop(). */
2303 {
2304 int family, size;
2305 gchar *str;
2306 const void *srcaddr;
2307
2308 if (host->type == HOST_TYPE_IPV4)
2309 {
2310 family = AF_INET;
2311 size = INET_ADDRSTRLEN;
2312 srcaddr = &host->addr;
2313 }
2314 else
2315 {
2316 family = AF_INET6;
2317 size = INET6_ADDRSTRLEN;
2318 srcaddr = &host->addr6;
2319 }
2320
2321 str = g_malloc0 (size);
2322 if (inet_ntop (family, srcaddr, str, size) == NULL)
2323 {
2324 perror ("inet_ntop");
2325 g_free (str);
2326 return NULL;
2327 }
2328 return str;
2329 }
2330 default:
2331 return g_strdup ("Erroneous host type: Should be Hostname/IPv4/IPv6.");
2332 }
2333}
2334
2346int
2347gvm_host_resolve (const gvm_host_t *host, void *dst, int family)
2348{
2349 if (host == NULL || dst == NULL || host->type != HOST_TYPE_NAME)
2350 return -1;
2351
2352 return gvm_resolve (host->name, dst, family);
2353}
2354
2367int
2368gvm_host_get_addr6 (const gvm_host_t *host, struct in6_addr *ip6)
2369{
2370 if (host == NULL || ip6 == NULL)
2371 return -1;
2372
2373 switch (gvm_host_type (host))
2374 {
2375 case HOST_TYPE_IPV6:
2376 memcpy (ip6, &host->addr6, sizeof (struct in6_addr));
2377 return 0;
2378
2379 case HOST_TYPE_IPV4:
2380 ipv4_as_ipv6 (&host->addr, ip6);
2381 return 0;
2382
2383 case HOST_TYPE_NAME:
2384 {
2385 struct in_addr ip4;
2386
2387 /* Fail if IPv4 and IPv6 both don't resolve. */
2388 if (gvm_host_resolve (host, &ip4, AF_INET) == 0)
2389 ipv4_as_ipv6 (&ip4, ip6);
2390 else if (gvm_host_resolve (host, ip6, AF_INET6) == -1)
2391 return -1;
2392 return 0;
2393 }
2394
2395 default:
2396 return -1;
2397 }
2398}
void gvm_hosts_add(gvm_hosts_t *hosts, gvm_host_t *host)
Inserts a host object at the end of a hosts collection.
Definition hosts.c:965
int gvm_host_in_hosts(const gvm_host_t *host, const struct in6_addr *addr, const gvm_hosts_t *hosts)
Returns whether a host has an equal host in a hosts collection. eg. 192.168.10.1 has an equal in list...
Definition hosts.c:2242
static int is_long_range_network(const char *str)
Checks if a buffer points to a valid long range-expressed network. "192.168.12.1-192....
Definition hosts.c:229
gvm_hosts_t * gvm_hosts_reverse_lookup_unify_excluded(gvm_hosts_t *hosts)
Removes hosts duplicates that reverse-lookup to the same value. Not to be used while iterating over t...
Definition hosts.c:2029
static int cidr_get_ip(const char *str, struct in_addr *addr)
Gets the IPv4 value from a CIDR-expressed block. eg. For "192.168.1.10/24" it is "192....
Definition hosts.c:158
int gvm_hosts_reverse_lookup_only(gvm_hosts_t *hosts)
Removes hosts that don't reverse-lookup from the hosts collection. Not to be used while iterating ove...
Definition hosts.c:2004
gchar * gvm_host_value_str(const gvm_host_t *host)
Gets a host's value in printable format.
Definition hosts.c:2290
static int short_range_network_ips(const char *str, struct in_addr *first, struct in_addr *last)
Gets the first and last IPv4 addresses from a short range-expressed network. "192....
Definition hosts.c:352
int gvm_host_resolve(const gvm_host_t *host, void *dst, int family)
Resolves a host object's name to an IPv4 or IPv6 address. Host object should be of type HOST_TYPE_NAM...
Definition hosts.c:2347
gvm_hosts_t * gvm_hosts_reverse_lookup_only_excluded(gvm_hosts_t *hosts)
Removes hosts that don't reverse-lookup from the hosts collection. Not to be used while iterating ove...
Definition hosts.c:1963
gchar * host_type_str[HOST_TYPE_MAX]
Definition hosts.c:40
static int is_long_range6_network(const char *str)
Checks if a buffer points to a valid long IPv6 range-expressed network. "::fee5-::1:530" is valid.
Definition hosts.c:644
static int long_range_network_ips(const char *str, struct in_addr *first, struct in_addr *last)
Gets the first and last IPv4 addresses from a long range-expressed network. eg. "192....
Definition hosts.c:264
char * gvm_host_reverse_lookup(gvm_host_t *host)
Checks for a host object reverse dns lookup existence.
Definition hosts.c:1836
static int is_cidr_block(const char *str)
Checks if a buffer points to an IPv4 CIDR-expressed block. "192.168.12.3/24" is valid,...
Definition hosts.c:91
static int cidr6_get_block(const char *str, unsigned int *block)
Gets the network block value from a CIDR-expressed block string. For "192.168.1.1/24" it is 24.
Definition hosts.c:516
gvm_host_t * gvm_duplicate_host(gvm_host_t *host)
Creates a deep copy of a host. gvm_host_free has to be called on it.
Definition hosts.c:2199
static int is_short_range_network(const char *str)
Checks if a buffer points to a valid short range-expressed network. "192.168.11.1-50" is valid,...
Definition hosts.c:304
gvm_vhost_t * gvm_vhost_new(char *value, char *source)
Creates a new gvm_vhost_t object.
Definition hosts.c:874
gvm_hosts_t * gvm_hosts_new(const gchar *hosts_str)
Creates a new gvm_hosts_t structure and the associated hosts objects from the provided hosts_str.
Definition hosts.c:1300
gvm_host_t * gvm_hosts_next(gvm_hosts_t *hosts)
Gets the next gvm_host_t from a gvm_hosts_t structure. The state of iteration is kept internally with...
Definition hosts.c:1314
GSList * gvm_hosts_allowed_only(gvm_hosts_t *hosts, const char *deny_hosts_str, const char *allow_hosts_str)
Returns a list of hosts after a host authorization check.
Definition hosts.c:1658
void gvm_host_free(gpointer host)
Frees the memory occupied by an gvm_host_t object.
Definition hosts.c:944
unsigned int gvm_hosts_removed(const gvm_hosts_t *hosts)
Gets the count of single values in hosts string that were removed (duplicates / excluded....
Definition hosts.c:2120
gchar * gvm_host_type_str(const gvm_host_t *host)
Gets a host's type in printable format.
Definition hosts.c:2274
void gvm_host_add_reverse_lookup(gvm_host_t *host)
Add a host's reverse-lookup name to the vhosts list.
Definition hosts.c:1921
gvm_hosts_t * gvm_hosts_new_with_max(const gchar *hosts_str, unsigned int max_hosts)
Creates a new gvm_hosts_t structure and the associated hosts objects from the provided hosts_str.
Definition hosts.c:1103
static int is_hostname(const char *str)
Checks if a buffer points to a valid hostname.
Definition hosts.c:396
static int is_cidr6_block(const char *str)
Checks if a buffer points to an IPv6 CIDR-expressed block. "2620:0:2d0:200::7/120" is valid,...
Definition hosts.c:470
static gvm_host_t * gvm_host_new()
Creates a new gvm_host_t object.
Definition hosts.c:929
void gvm_hosts_reverse(gvm_hosts_t *hosts)
Reverses the order of the hosts objects in the collection. Not to be used while iterating over the si...
Definition hosts.c:1431
void gvm_hosts_shuffle(gvm_hosts_t *hosts)
Randomizes the order of the hosts objects in the collection. Not to be used while iterating over the ...
Definition hosts.c:1399
unsigned int gvm_hosts_duplicated(const gvm_hosts_t *hosts)
Gets the count of single values in hosts string that were duplicated and therefore removed from the l...
Definition hosts.c:2134
static int is_short_range6_network(const char *str)
Checks if a buffer points to a valid short IPv6 range-expressed network. "::200:ff:1-fee5" is valid.
Definition hosts.c:719
gvm_host_t * gvm_host_from_str(const gchar *host_str)
Creates a new gvm_host_t from a host string.
Definition hosts.c:1787
static void gvm_hosts_deduplicate(gvm_hosts_t *hosts)
Removes duplicate hosts values from an gvm_hosts_t structure. Also resets the iterator current positi...
Definition hosts.c:1043
static int short_range6_network_ips(const char *str, struct in6_addr *first, struct in6_addr *last)
Gets the first and last IPv6 addresses from a short range-expressed network. eg. "\::ffee:1:1001-1005...
Definition hosts.c:767
static int cidr6_block_ips(const char *str, struct in6_addr *first, struct in6_addr *last)
Gets the first and last usable IPv4 addresses from a CIDR-expressed block. eg. "192....
Definition hosts.c:572
static int is_ipv6_address(const char *str)
Checks if a buffer points to a valid IPv6 address. "0:0:0:0:0:0:0:1", "::1" and "::FFFF:192....
Definition hosts.c:75
static gvm_hosts_t * gvm_hosts_init(const char *hosts_str)
Creates a hosts collection from a hosts string.
Definition hosts.c:987
static int long_range6_network_ips(const char *str, struct in6_addr *first, struct in6_addr *last)
Gets the first and last IPv6 addresses from a long range-expressed network. eg. "::1:200:7-::1:205:50...
Definition hosts.c:679
int gvm_host_get_addr6(const gvm_host_t *host, struct in6_addr *ip6)
Gives a host object's value as an IPv6 address. If the host type is hostname, it resolves the IPv4 ad...
Definition hosts.c:2368
static int is_ipv4_address(const char *str)
Checks if a buffer points to a valid IPv4 address. "192.168.11.1" is valid, "192.168....
Definition hosts.c:59
void gvm_hosts_move_current_host_to_end(gvm_hosts_t *hosts)
Move the current gvm_host_t from a gvm_hosts_t structure to the end of the hosts list.
Definition hosts.c:1332
int gvm_vhosts_exclude(gvm_host_t *host, const char *excluded_str)
Exclude a list of vhosts from a host's vhosts list.
Definition hosts.c:1525
int gvm_hosts_exclude_with_max(gvm_hosts_t *hosts, const char *excluded_str, unsigned int max_hosts)
Excludes a set of hosts provided as a string from a hosts collection. Not to be used while iterating ...
Definition hosts.c:1580
GSList * gvm_hosts_resolve(gvm_hosts_t *hosts)
Resolves host objects of type name in a hosts collection, replacing hostnames with IPv4 values....
Definition hosts.c:1457
enum host_type gvm_host_type(const gvm_host_t *host)
Gets a host object's type.
Definition hosts.c:2259
gpointer gvm_duplicate_vhost(gconstpointer vhost, gpointer data)
Creates a deep copy of a gvm_vhost_t object.
Definition hosts.c:909
static void gvm_hosts_fill_gaps(gvm_hosts_t *hosts)
Fill the gaps in the array of a hosts collection, which are caused by the removal of host entries.
Definition hosts.c:1005
static int host_name_verify(gvm_host_t *host, const char *value)
Verifies that hostname value resolves to a host's IP.
Definition hosts.c:1889
gvm_host_t * gvm_host_find_in_hosts(const gvm_host_t *host, const struct in6_addr *addr, const gvm_hosts_t *hosts)
Find the gvm_host_t from a gvm_hosts_t structure.
Definition hosts.c:2150
int gvm_get_host_type(const gchar *str_stripped)
Determines the host type in a buffer.
Definition hosts.c:813
static int cidr_get_block(const char *str, unsigned int *block)
Gets the network block value from a CIDR-expressed block string. For "192.168.1.1/24" it is 24.
Definition hosts.c:137
unsigned int gvm_hosts_count(const gvm_hosts_t *hosts)
Gets the count of single hosts objects in a hosts collection.
Definition hosts.c:2106
static int cidr_block_ips(const char *str, struct in_addr *first, struct in_addr *last)
Gets the first and last usable IPv4 addresses from a CIDR-expressed block. eg. "192....
Definition hosts.c:198
static void gvm_vhost_free(gpointer vhost)
Frees the memory occupied by an gvm_vhost_t object.
Definition hosts.c:891
void gvm_hosts_free(gvm_hosts_t *hosts)
Frees memory occupied by an gvm_hosts_t structure.
Definition hosts.c:1375
int gvm_hosts_exclude(gvm_hosts_t *hosts, const char *excluded_str)
Excludes a set of hosts provided as a string from a hosts collection. Not to be used while iterating ...
Definition hosts.c:1771
int gvm_hosts_reverse_lookup_unify(gvm_hosts_t *hosts)
Removes hosts duplicates that reverse-lookup to the same value. Not to be used while iterating over t...
Definition hosts.c:2085
static int cidr6_get_ip(const char *str, struct in6_addr *addr6)
Gets the IPv4 value from a CIDR-expressed block. eg. For "192.168.1.10/24" it is "192....
Definition hosts.c:537
Protos and data structures for Hosts collections and single hosts objects.
host_type
Definition hosts.h:34
@ HOST_TYPE_RANGE_SHORT
Definition hosts.h:38
@ HOST_TYPE_RANGE6_SHORT
Definition hosts.h:43
@ HOST_TYPE_RANGE_LONG
Definition hosts.h:39
@ HOST_TYPE_RANGE6_LONG
Definition hosts.h:42
@ HOST_TYPE_NAME
Definition hosts.h:35
@ HOST_TYPE_IPV6
Definition hosts.h:40
@ HOST_TYPE_CIDR6_BLOCK
Definition hosts.h:41
@ HOST_TYPE_MAX
Definition hosts.h:44
@ HOST_TYPE_IPV4
Definition hosts.h:36
@ HOST_TYPE_CIDR_BLOCK
Definition hosts.h:37
struct gvm_host gvm_host_t
Definition hosts.h:48
struct gvm_vhost gvm_vhost_t
Definition hosts.h:49
struct gvm_hosts gvm_hosts_t
Definition hosts.h:50
void addr6_to_str(const struct in6_addr *addr6, char *str)
Stringifies an IP address.
Definition networking.c:261
void ipv4_as_ipv6(const struct in_addr *ip4, struct in6_addr *ip6)
Maps an IPv4 address as an IPv6 address. eg. 192.168.10.20 would map to ::ffff:192....
Definition networking.c:243
int gvm_resolve(const char *name, void *dst, int family)
Resolves a hostname to an IPv4 or IPv6 address.
Definition networking.c:389
GSList * gvm_resolve_list(const char *name)
Returns a list of addresses that a hostname resolves to.
Definition networking.c:339
GVM Networking related API.
struct in6_addr addr6
Definition hosts.h:66
gchar * name
Definition hosts.h:64
GSList * vhosts
Definition hosts.h:69
struct in_addr addr
Definition hosts.h:65
enum host_type type
Definition hosts.h:68
size_t max_size
Definition hosts.h:91
size_t removed
Definition hosts.h:94
gchar * orig_str
Definition hosts.h:89
size_t duplicated
Definition hosts.h:95
size_t current
Definition hosts.h:92
size_t count
Definition hosts.h:93
gvm_host_t ** hosts
Definition hosts.h:90
char * value
Definition hosts.h:77
char * source
Definition hosts.h:78