1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
/* ip address type, for libreswan
*
* Copyright (C) 1998, 1999, 2000 Henry Spencer.
* Copyright (C) 1999, 2000, 2001 Richard Guy Briggs
* Copyright (C) 2019 Andrew Cagney <cagney@gnu.org>
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Library General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at your
* option) any later version. See <https://www.gnu.org/licenses/lgpl-2.1.txt>.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
* License for more details.
*
*/
#ifndef IP_ADDRESS_H
#define IP_ADDRESS_H
#include "lswcdefs.h" /* for MUST_USE_RESULT */
#include "shunk.h"
#include "chunk.h"
#include "err.h"
#include "where.h"
struct jambuf;
struct ip_info;
extern bool log_ip; /* false -> redact (aka sanitize) ip addresses */
/*
* Basic data types for the address-handling functions.
*
* ip_address et.al. are supposed to be opaque types; do not use their
* definitions directly, they are subject to change!
*
* Because whack sends raw ip_addresses to pluto using a byte
* stream, this structure needs to be stream friendly - it
* must not contain pointers (such as a pointer to struct
* ip_info). so instead it contains an index.
*/
typedef struct {
bool is_address;
/*
* Index into the struct ip_info array; must be stream
* friendly.
*/
unsigned version; /* 0, 4, 6 */
/*
* We need something that makes static IPv4 initializers possible
* (struct in_addr requires htonl() which is run-time only).
*/
struct ip_bytes { uint8_t byte[16]; } bytes;
} ip_address;
#define PRI_ADDRESS "%s (version=%d is_address=%s)"
#define pri_address(A, B) \
str_address(A, B), \
(A)->version, \
bool_str((A)->is_address)
void pexpect_address(const ip_address *a, const char *t, where_t where);
#define paddress(A) pexpect_address(A, #A, HERE)
/*
* Constructors.
*/
ip_address address_from_in_addr(const struct in_addr *in);
ip_address address_from_in6_addr(const struct in6_addr *sin6);
err_t data_to_address(const void *data, size_t sizeof_data,
const struct ip_info *af, ip_address *dst) MUST_USE_RESULT;
/* either SHUNK or CHUNK */
#define hunk_to_address(HUNK, AF, DST) data_to_address(HUNK.ptr, HUNK.len, AF, DST)
/* assumes dotted / colon notation */
err_t numeric_to_address(shunk_t src, const struct ip_info *type, ip_address *dst);
/* if numeric lookup fails, try a DNS lookup */
err_t domain_to_address(shunk_t src, const struct ip_info *type, ip_address *dst);
/*
* Convert an address to a string:
*
* This implements https://tools.ietf.org/html/rfc5952 where zeros in
* the middle of an IPv6 address are suppressed. If the IP address is
* "sensitive" use *_address_sensitive().
*/
typedef struct {
char buf[(4+1)*8/*0000:...*/ + 1/*\0*/ + 1/*CANARY*/];
} address_buf;
size_t jam_address(struct jambuf *buf, const ip_address *src);
const char *str_address(const ip_address *src, address_buf *dst);
/*
* sensitive: don't print address when !log_ip
*
* reversed: in-addr format.
* raw: This is not the format function you are looking for. For IPv6
* include all zeros, vis :0:..:0:; when SEPC != '\0' use it as the
* separator instead of '.' (IPv4) or ':' (IPv6).
*/
typedef struct {
/* string includes NUL, add 1 for canary */
char buf[sizeof("4.0.0.0.3.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.2.0.0.0.1.0.0.0.IP6.ARPA.") + 1];
} address_reversed_buf;
size_t jam_address_sensitive(struct jambuf *buf, const ip_address *src);
size_t jam_address_reversed(struct jambuf *buf, const ip_address *src);
const char *str_address_sensitive(const ip_address *src, address_buf *dst);
const char *str_address_reversed(const ip_address *src, address_reversed_buf *buf);
typedef address_buf ipstr_buf;
const char *ipstr(const ip_address *src, ipstr_buf *b);
const char *sensitive_ipstr(const ip_address *src, ipstr_buf *b);
/*
* Magic values.
*
* XXX: While the headers call the all-zero address "ANY" (INADDR_ANY,
* IN6ADDR_ANY_INIT), the headers also refer to the IPv6 value as
* unspecified (for instance IN6_IS_ADDR_UNSPECIFIED()) leaving the
* term "unspecified" underspecified.
*
* Consequently an AF_UNSPEC address (i.e., uninitialized or unset),
* is identified by *_unset().
*/
extern const ip_address unset_address;
bool address_is_unset(const ip_address *address);
const struct ip_info *address_type(const ip_address *address);
/* !unset && !any */
bool address_is_specified(const ip_address *address);
bool address_is_loopback(const ip_address *address);
bool address_is_any(const ip_address *address);
/* are two is_set() addresses identical? */
bool address_eq(const ip_address *address, const ip_address *another);
/* AF={INET,INET6}, ADDR = 0; aka %any? */
ip_address address_any(const struct ip_info *info);
/*
* Raw address bytes, both read-only and read-write.
*/
shunk_t address_as_shunk(const ip_address *address);
chunk_t address_as_chunk(ip_address *address);
/*
* XXX: prop up IPv4 centric code that just isn't worth the effort.
*/
uint32_t ntohl_address(const ip_address *address);
/*
* Modify an address routing-prefix:host-id.
*/
extern const struct ip_blit set_bits;
extern const struct ip_blit clear_bits;
extern const struct ip_blit keep_bits;
ip_address address_from_blit(const struct ip_info *afi,
struct ip_bytes bytes,
const struct ip_blit *routing_prefix,
const struct ip_blit *host_id,
unsigned nr_prefix_bits);
/* address_from_blit(AFI, BYTES, clear_bits, keep_bits, 0); */
ip_address address_from_raw(const struct ip_info *afi,
const struct ip_bytes *bytes);
/*
* Old style.
*/
/* looks up names in DNS */
extern err_t ttoaddr(const char *src, size_t srclen, int af, ip_address *dst);
/* does not look up names in DNS */
extern err_t ttoaddr_num(const char *src, size_t srclen, int af, ip_address *dst);
/* RFC 1886 old IPv6 reverse-lookup format is the bulkiest */
#define ADDRTOT_BUF sizeof(address_reversed_buf)
extern err_t tnatoaddr(const char *src, size_t srclen, int af, ip_address *dst);
/* misc. conversions and related */
extern int addrtypeof(const ip_address *src);
extern int masktocount(const ip_address *src);
/* tests */
extern bool sameaddr(const ip_address *a, const ip_address *b);
extern int addrcmp(const ip_address *a, const ip_address *b);
#endif
|
