]>
Commit | Line | Data |
---|---|---|
f521be31 | 1 | /* Copyright (C) 2003, 2006, 2009 Free Software Foundation, Inc. |
a4596570 UD |
2 | This file is part of the GNU C Library. |
3 | Contributed by Ulrich Drepper <drepper@redhat.com>, 2003. | |
4 | ||
5 | The GNU C Library is free software; you can redistribute it and/or | |
6 | modify it under the terms of the GNU Lesser General Public | |
7 | License as published by the Free Software Foundation; either | |
8 | version 2.1 of the License, or (at your option) any later version. | |
9 | ||
10 | The GNU C Library is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 | Lesser General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU Lesser General Public | |
59ba27a6 PE |
16 | License along with the GNU C Library; if not, see |
17 | <http://www.gnu.org/licenses/>. */ | |
a4596570 UD |
18 | |
19 | #include <assert.h> | |
20 | #include <string.h> | |
21 | #include <netinet/in.h> | |
22 | #include <netinet/ip6.h> | |
23 | #include <sys/param.h> | |
24 | ||
25 | ||
26 | static void | |
27 | internal_function | |
28 | add_pad (struct cmsghdr *cmsg, int len) | |
29 | { | |
30 | unsigned char *p = CMSG_DATA (cmsg) + cmsg->cmsg_len - CMSG_LEN (0); | |
31 | ||
32 | if (len == 1) | |
33 | /* Special handling for 1, a one-byte solution. */ | |
34 | *p++ = IP6OPT_PAD1; | |
35 | else if (len != 0) | |
36 | { | |
37 | /* Multibyte padding. */ | |
38 | *p++ = IP6OPT_PADN; | |
39 | *p++ = len - 2; /* Discount the two header bytes. */ | |
40 | /* The rest is filled with zero. */ | |
41 | memset (p, '\0', len - 2); | |
42 | p += len - 2; | |
43 | } | |
44 | ||
45 | /* Account for the bytes. */ | |
46 | cmsg->cmsg_len += len; | |
47 | } | |
48 | ||
49 | ||
50 | static int | |
51 | get_opt_end (const uint8_t **result, const uint8_t *startp, | |
52 | const uint8_t *endp) | |
53 | { | |
54 | if (startp >= endp) | |
55 | /* Out of bounds. */ | |
56 | return -1; | |
57 | ||
58 | if (*startp == IP6OPT_PAD1) | |
59 | { | |
60 | /* Just this one byte. */ | |
61 | *result = startp + 1; | |
62 | return 0; | |
63 | } | |
64 | ||
65 | /* Now we know there must be at least two bytes. */ | |
66 | if (startp + 2 > endp | |
67 | /* Now we can get the length byte. */ | |
68 | || startp + startp[1] + 2 > endp) | |
69 | return -1; | |
70 | ||
71 | *result = startp + startp[1] + 2; | |
72 | ||
73 | return 0; | |
74 | } | |
75 | ||
76 | ||
1663b44f UD |
77 | static uint8_t *option_alloc (struct cmsghdr *cmsg, int datalen, int multx, |
78 | int plusy); | |
79 | ||
80 | ||
a4596570 UD |
81 | /* RFC 2292, 6.3.1 |
82 | ||
83 | This function returns the number of bytes required to hold an option | |
84 | when it is stored as ancillary data, including the cmsghdr structure | |
85 | at the beginning, and any padding at the end (to make its size a | |
86 | multiple of 8 bytes). The argument is the size of the structure | |
87 | defining the option, which must include any pad bytes at the | |
88 | beginning (the value y in the alignment term "xn + y"), the type | |
89 | byte, the length byte, and the option data. */ | |
90 | int | |
91 | inet6_option_space (nbytes) | |
92 | int nbytes; | |
93 | { | |
94 | /* Add room for the extension header. */ | |
95 | nbytes += sizeof (struct ip6_ext); | |
96 | ||
97 | return CMSG_SPACE (roundup (nbytes, 8)); | |
98 | } | |
94dc1a24 UD |
99 | link_warning (inet6_option_space, |
100 | "inet6_option_space is obsolete, use the RFC 3542 interfaces") | |
a4596570 UD |
101 | |
102 | ||
103 | /* RFC 2292, 6.3.2 | |
104 | ||
105 | This function is called once per ancillary data object that will | |
106 | contain either Hop-by-Hop or Destination options. It returns 0 on | |
107 | success or -1 on an error. */ | |
108 | int | |
109 | inet6_option_init (bp, cmsgp, type) | |
110 | void *bp; | |
111 | struct cmsghdr **cmsgp; | |
112 | int type; | |
113 | { | |
114 | /* Only Hop-by-Hop or Destination options allowed. */ | |
115 | if (type != IPV6_HOPOPTS && type != IPV6_DSTOPTS) | |
116 | return -1; | |
117 | ||
118 | /* BP is a pointer to the previously allocated space. */ | |
119 | struct cmsghdr *newp = (struct cmsghdr *) bp; | |
120 | ||
121 | /* Initialize the message header. | |
122 | ||
123 | Length: No data yet, only the cmsghdr struct. */ | |
124 | newp->cmsg_len = CMSG_LEN (0); | |
125 | /* Originating protocol: obviously IPv6. */ | |
126 | newp->cmsg_level = IPPROTO_IPV6; | |
127 | /* Message type. */ | |
128 | newp->cmsg_type = type; | |
129 | ||
130 | /* Pass up the result. */ | |
131 | *cmsgp = newp; | |
132 | ||
133 | return 0; | |
134 | } | |
94dc1a24 UD |
135 | link_warning (inet6_option_init, |
136 | "inet6_option_init is obsolete, use the RFC 3542 interfaces") | |
a4596570 UD |
137 | |
138 | ||
139 | /* RFC 2292, 6.3.3 | |
140 | ||
141 | This function appends a Hop-by-Hop option or a Destination option | |
142 | into an ancillary data object that has been initialized by | |
143 | inet6_option_init(). This function returns 0 if it succeeds or -1 on | |
144 | an error. */ | |
145 | int | |
146 | inet6_option_append (cmsg, typep, multx, plusy) | |
147 | struct cmsghdr *cmsg; | |
148 | const uint8_t *typep; | |
149 | int multx; | |
150 | int plusy; | |
151 | { | |
152 | /* typep is a pointer to the 8-bit option type. It is assumed that this | |
153 | field is immediately followed by the 8-bit option data length field, | |
154 | which is then followed immediately by the option data. | |
155 | ||
156 | The option types IP6OPT_PAD1 and IP6OPT_PADN also must be handled. */ | |
157 | int len = typep[0] == IP6OPT_PAD1 ? 1 : typep[1] + 2; | |
158 | ||
159 | /* Get the pointer to the space in the message. */ | |
1663b44f | 160 | uint8_t *ptr = option_alloc (cmsg, len, multx, plusy); |
a4596570 UD |
161 | if (ptr == NULL) |
162 | /* Some problem with the parameters. */ | |
163 | return -1; | |
164 | ||
165 | /* Copy the content. */ | |
166 | memcpy (ptr, typep, len); | |
167 | ||
168 | return 0; | |
169 | } | |
94dc1a24 UD |
170 | link_warning (inet6_option_append, |
171 | "inet6_option_append is obsolete, use the RFC 3542 interfaces") | |
a4596570 UD |
172 | |
173 | ||
174 | /* RFC 2292, 6.3.4 | |
175 | ||
176 | This function appends a Hop-by-Hop option or a Destination option | |
177 | into an ancillary data object that has been initialized by | |
178 | inet6_option_init(). This function returns a pointer to the 8-bit | |
179 | option type field that starts the option on success, or NULL on an | |
180 | error. */ | |
1663b44f UD |
181 | static uint8_t * |
182 | option_alloc (struct cmsghdr *cmsg, int datalen, int multx, int plusy) | |
a4596570 UD |
183 | { |
184 | /* The RFC limits the value of the alignment values. */ | |
185 | if ((multx != 1 && multx != 2 && multx != 4 && multx != 8) | |
186 | || ! (plusy >= 0 && plusy <= 7)) | |
187 | return NULL; | |
188 | ||
189 | /* Current data size. */ | |
190 | int dsize = cmsg->cmsg_len - CMSG_LEN (0); | |
191 | ||
192 | /* The first two bytes of the option are for the extended header. */ | |
193 | if (__builtin_expect (dsize == 0, 0)) | |
194 | { | |
195 | cmsg->cmsg_len += sizeof (struct ip6_ext); | |
196 | dsize = sizeof (struct ip6_ext); | |
197 | } | |
198 | ||
199 | /* First add padding. */ | |
200 | add_pad (cmsg, ((multx - (dsize & (multx - 1))) & (multx - 1)) + plusy); | |
201 | ||
202 | /* Return the pointer to the start of the option space. */ | |
203 | uint8_t *result = CMSG_DATA (cmsg) + cmsg->cmsg_len - CMSG_LEN (0); | |
204 | cmsg->cmsg_len += datalen; | |
205 | ||
206 | /* The extended option header length is measured in 8-byte groups. | |
207 | To represent the current length we might have to add padding. */ | |
208 | dsize = cmsg->cmsg_len - CMSG_LEN (0); | |
209 | add_pad (cmsg, (8 - (dsize & (8 - 1))) & (8 - 1)); | |
210 | ||
211 | /* Record the new length of the option. */ | |
212 | assert (((cmsg->cmsg_len - CMSG_LEN (0)) % 8) == 0); | |
213 | int len8b = (cmsg->cmsg_len - CMSG_LEN (0)) / 8 - 1; | |
214 | if (len8b >= 256) | |
215 | /* Too long. */ | |
216 | return NULL; | |
217 | ||
f521be31 UD |
218 | struct ip6_ext *ie = (void *) CMSG_DATA (cmsg); |
219 | ie->ip6e_len = len8b; | |
a4596570 UD |
220 | |
221 | return result; | |
222 | } | |
1663b44f UD |
223 | |
224 | ||
225 | uint8_t * | |
226 | inet6_option_alloc (cmsg, datalen, multx, plusy) | |
227 | struct cmsghdr *cmsg; | |
228 | int datalen; | |
229 | int multx; | |
230 | int plusy; | |
231 | { | |
232 | return option_alloc (cmsg, datalen, multx, plusy); | |
233 | } | |
94dc1a24 UD |
234 | link_warning (inet6_option_alloc, |
235 | "inet6_option_alloc is obsolete, use the RFC 3542 interfaces") | |
a4596570 UD |
236 | |
237 | ||
238 | /* RFC 2292, 6.3.5 | |
239 | ||
240 | This function processes the next Hop-by-Hop option or Destination | |
241 | option in an ancillary data object. If another option remains to be | |
242 | processed, the return value of the function is 0 and *tptrp points to | |
243 | the 8-bit option type field (which is followed by the 8-bit option | |
244 | data length, followed by the option data). If no more options remain | |
245 | to be processed, the return value is -1 and *tptrp is NULL. If an | |
246 | error occurs, the return value is -1 and *tptrp is not NULL. */ | |
247 | int | |
248 | inet6_option_next (cmsg, tptrp) | |
249 | const struct cmsghdr *cmsg; | |
250 | uint8_t **tptrp; | |
251 | { | |
252 | /* Make sure it is an option of the right type. */ | |
253 | if (cmsg->cmsg_level != IPPROTO_IPV6 | |
254 | || (cmsg->cmsg_type != IPV6_HOPOPTS && cmsg->cmsg_type != IPV6_DSTOPTS)) | |
255 | return -1; | |
256 | ||
257 | /* Pointer to the extension header. We only compute the address, we | |
258 | don't access anything yet. */ | |
259 | const struct ip6_ext *ip6e = (const struct ip6_ext *) CMSG_DATA (cmsg); | |
260 | ||
261 | /* Make sure the message is long enough. */ | |
262 | if (cmsg->cmsg_len < CMSG_LEN (sizeof (struct ip6_ext)) | |
263 | /* Now we can access the extension header. */ | |
264 | || cmsg->cmsg_len < CMSG_LEN ((ip6e->ip6e_len + 1) * 8)) | |
265 | /* Too small. */ | |
266 | return -1; | |
267 | ||
268 | /* Determine the address of the byte past the message. */ | |
269 | const uint8_t *endp = CMSG_DATA (cmsg) + (ip6e->ip6e_len + 1) * 8; | |
270 | ||
271 | const uint8_t *result; | |
cec40916 | 272 | if (*tptrp == NULL) |
a4596570 UD |
273 | /* This is the first call, return the first option if there is one. */ |
274 | result = (const uint8_t *) (ip6e + 1); | |
275 | else | |
276 | { | |
277 | /* Make sure *TPTRP points to a beginning of a new option in | |
278 | the message. The upper limit is checked in get_opt_end. */ | |
279 | if (*tptrp < (const uint8_t *) (ip6e + 1)) | |
280 | return -1; | |
281 | ||
282 | /* Get the beginning of the next option. */ | |
283 | if (get_opt_end (&result, *tptrp, endp) != 0) | |
284 | return -1; | |
285 | } | |
286 | ||
287 | /* We know where the next option starts. */ | |
288 | *tptrp = (uint8_t *) result; | |
289 | ||
290 | /* Check the option is fully represented in the message. */ | |
291 | return get_opt_end (&result, result, endp); | |
292 | } | |
94dc1a24 UD |
293 | link_warning (inet6_option_next, |
294 | "inet6_option_next is obsolete, use the RFC 3542 interfaces") | |
a4596570 UD |
295 | |
296 | ||
297 | /* RFC 2292, 6.3.6 | |
298 | ||
299 | This function is similar to the previously described | |
300 | inet6_option_next() function, except this function lets the caller | |
301 | specify the option type to be searched for, instead of always | |
302 | returning the next option in the ancillary data object. cmsg is a | |
303 | pointer to cmsghdr structure of which cmsg_level equals IPPROTO_IPV6 | |
304 | and cmsg_type equals either IPV6_HOPOPTS or IPV6_DSTOPTS. */ | |
305 | int | |
306 | inet6_option_find (cmsg, tptrp, type) | |
307 | const struct cmsghdr *cmsg; | |
308 | uint8_t **tptrp; | |
309 | int type; | |
310 | { | |
311 | /* Make sure it is an option of the right type. */ | |
312 | if (cmsg->cmsg_level != IPPROTO_IPV6 | |
313 | || (cmsg->cmsg_type != IPV6_HOPOPTS && cmsg->cmsg_type != IPV6_DSTOPTS)) | |
314 | return -1; | |
315 | ||
316 | /* Pointer to the extension header. We only compute the address, we | |
317 | don't access anything yet. */ | |
318 | const struct ip6_ext *ip6e = (const struct ip6_ext *) CMSG_DATA (cmsg); | |
319 | ||
320 | /* Make sure the message is long enough. */ | |
321 | if (cmsg->cmsg_len < CMSG_LEN (sizeof (struct ip6_ext)) | |
322 | /* Now we can access the extension header. */ | |
323 | || cmsg->cmsg_len < CMSG_LEN ((ip6e->ip6e_len + 1) * 8)) | |
324 | /* Too small. */ | |
325 | return -1; | |
326 | ||
327 | /* Determine the address of the byte past the message. */ | |
328 | const uint8_t *endp = CMSG_DATA (cmsg) + (ip6e->ip6e_len + 1) * 8; | |
329 | ||
330 | const uint8_t *next; | |
cec40916 | 331 | if (*tptrp == NULL) |
a4596570 UD |
332 | /* This is the first call, return the first option if there is one. */ |
333 | next = (const uint8_t *) (ip6e + 1); | |
334 | else | |
335 | { | |
336 | /* Make sure *TPTRP points to a beginning of a new option in | |
337 | the message. The upper limit is checked in get_opt_end. */ | |
338 | if (*tptrp < (const uint8_t *) (ip6e + 1)) | |
339 | return -1; | |
340 | ||
341 | /* Get the beginning of the next option. */ | |
342 | if (get_opt_end (&next, *tptrp, endp) != 0) | |
343 | return -1; | |
344 | } | |
345 | ||
346 | /* Now search for the appropriate typed entry. */ | |
347 | const uint8_t *result; | |
348 | do | |
349 | { | |
350 | result = next; | |
351 | ||
352 | /* Get the end of this entry. */ | |
353 | if (get_opt_end (&next, result, endp) != 0) | |
354 | return -1; | |
355 | } | |
356 | while (*result != type); | |
357 | ||
358 | /* We know where the next option starts. */ | |
359 | *tptrp = (uint8_t *) result; | |
360 | ||
361 | /* Success. */ | |
362 | return 0; | |
363 | } | |
94dc1a24 UD |
364 | link_warning (inet6_option_find, |
365 | "inet6_option_find is obsolete, use the RFC 3542 interfaces") |