189 lines
5.1 KiB
C
189 lines
5.1 KiB
C
/*
|
|
List of IPv6 ranges.
|
|
|
|
Sames as the "ranges.h" module, but for IPv6 instead of IPv4.
|
|
*/
|
|
#ifndef RANGES6_H
|
|
#define RANGES6_H
|
|
#include "massip-addr.h"
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
struct Range;
|
|
|
|
/**
|
|
* A range of IPv6 ranges.
|
|
* Inclusive, so [n..m] includes both 'n' and 'm'.
|
|
*/
|
|
struct Range6
|
|
{
|
|
ipv6address begin;
|
|
ipv6address end;
|
|
};
|
|
|
|
/**
|
|
* An array of ranges in sorted order
|
|
*/
|
|
struct Range6List
|
|
{
|
|
struct Range6 *list;
|
|
size_t count;
|
|
size_t max;
|
|
size_t *picker;
|
|
unsigned is_sorted:1;
|
|
};
|
|
|
|
/**
|
|
* Adds the given range to the targets list. The given range can be a duplicate
|
|
* or overlap with an existing range, which will get combined with existing
|
|
* ranges.
|
|
* @param targets
|
|
* A list of IPv6 ranges.
|
|
* @param begin
|
|
* The first address of the range that'll be added.
|
|
* @param end
|
|
* The last address (inclusive) of the range that'll be added.
|
|
*/
|
|
void
|
|
range6list_add_range(struct Range6List *targets, ipv6address begin, ipv6address end);
|
|
|
|
|
|
/**
|
|
* Removes the given range from the target list. The input range doesn't
|
|
* have to exist, or can partial overlap with existing ranges.
|
|
* @param targets
|
|
* A list of IPv6 ranges.
|
|
* @param begin
|
|
* The first address of the range that'll be removed.
|
|
* @param end
|
|
* The last address of the range that'll be removed (inclusive).
|
|
*/
|
|
void
|
|
range6list_remove_range(struct Range6List *targets, const ipv6address begin, const ipv6address end);
|
|
|
|
/**
|
|
* Same as 'rangelist_remove_range()', except the input is a range
|
|
* structure instead of a start/stop numbers.
|
|
*/
|
|
void
|
|
range6list_remove_range2(struct Range6List *targets, struct Range6 range);
|
|
|
|
/**
|
|
* Returns 'true' if the indicated IPv6 address is in one of the target
|
|
* ranges.
|
|
* @param targets
|
|
* A list of IPv6 ranges
|
|
* @param ip
|
|
* An IPv6 address that might in be in the list of ranges
|
|
* @return
|
|
* 'true' if the ranges contain the item, or 'false' otherwise
|
|
*/
|
|
int
|
|
range6list_is_contains(const struct Range6List *targets, const ipv6address ip);
|
|
|
|
|
|
/**
|
|
* Tests if the range is bad/invalid.
|
|
* @return 1 is invalid, 0 if good.
|
|
*/
|
|
int range6_is_bad_address(const struct Range6 *range);
|
|
|
|
/**
|
|
* Remove things from the target list. The primary use of this is the
|
|
* "exclude-file" containing a list of IP addresses that we should
|
|
* not scan
|
|
* @param targets
|
|
* Our array of target IP address (or port) ranges that we'll be
|
|
* scanning.
|
|
* @param excludes
|
|
* A list, probably read in from --excludefile, of things that we
|
|
* should not be scanning, that will override anything we otherwise
|
|
* try to scan.
|
|
* @return
|
|
* the total number of IP addresses or ports removed.
|
|
*/
|
|
ipv6address
|
|
range6list_exclude( struct Range6List *targets,
|
|
const struct Range6List *excludes);
|
|
|
|
|
|
/**
|
|
* Counts the total number of IPv6 addresses in the target list. This
|
|
* iterates over all the ranges in the table, summing up the count within
|
|
* each range.
|
|
* @param targets
|
|
* A list of IP address or port ranges.
|
|
* @return
|
|
* The total number of address or ports.
|
|
*/
|
|
massint128_t
|
|
range6list_count(const struct Range6List *targets);
|
|
|
|
/**
|
|
* Given an index in a continuous range of [0...count], pick a corresponding
|
|
* number (IP address or port) from a list of non-continuous ranges (not
|
|
* necessarily starting from 0). In other words, given the two ranges
|
|
* 10-19 50-69
|
|
* we'll have a total of 30 possible numbers. Thus, the index goes from
|
|
* [0..29], with the values 0..9 picking the corresponding values from the
|
|
* first range, and the values 10..29 picking the corresponding values
|
|
* from the second range.
|
|
*
|
|
* NOTE: This is a fundamental part of this program's design, that the user
|
|
* can specify non-contiguous IP and port ranges, but yet we iterate over
|
|
* them using a monotonically increasing index variable.
|
|
*
|
|
* @param targets
|
|
* A list of IP address ranges, or a list of port ranges (one or the
|
|
* other, but not both).
|
|
* @param index
|
|
* An integer starting at 0 up to (but not including) the value returned
|
|
* by 'rangelist_count()' for this target list.
|
|
* @return
|
|
* an IP address or port corresponding to this index.
|
|
*/
|
|
ipv6address
|
|
range6list_pick(const struct Range6List *targets, uint64_t index);
|
|
|
|
|
|
|
|
/**
|
|
* Remove all the ranges in the range list.
|
|
*/
|
|
void
|
|
range6list_remove_all(struct Range6List *list);
|
|
|
|
/**
|
|
* Merge two range lists
|
|
*/
|
|
void
|
|
range6list_merge(struct Range6List *list1, const struct Range6List *list2);
|
|
|
|
|
|
/**
|
|
* Optimizes the target list, so that when we call "rangelist_pick()"
|
|
* from an index, it runs faster. It currently configures this for
|
|
* a binary-search, though in the future some more efficient
|
|
* algorithm may be chosen.
|
|
*/
|
|
void
|
|
range6list_optimize(struct Range6List *targets);
|
|
|
|
/**
|
|
* Sorts the list of target. We maintain the list of targets in sorted
|
|
* order internally even though we scan the targets in random order
|
|
* externally.
|
|
*/
|
|
void
|
|
range6list_sort(struct Range6List *targets);
|
|
|
|
/**
|
|
* Does a regression test of this module
|
|
* @return
|
|
* 0 if the regression test succeeds, or a positive value on failure
|
|
*/
|
|
int
|
|
ranges6_selftest(void);
|
|
|
|
|
|
#endif
|