]>
Commit | Line | Data |
---|---|---|
8842468c | 1 | /* |
2 | * Common ioctl functions for Solaris. | |
3 | * Copyright (C) 1997, 98 Kunihiro Ishiguro | |
4 | * | |
5 | * This file is part of GNU Zebra. | |
6 | * | |
7 | * GNU Zebra is free software; you can redistribute it and/or modify it | |
8 | * under the terms of the GNU General Public License as published by the | |
9 | * Free Software Foundation; either version 2, or (at your option) any | |
10 | * later version. | |
11 | * | |
12 | * GNU Zebra is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with GNU Zebra; see the file COPYING. If not, write to the Free | |
19 | * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA | |
20 | * 02111-1307, USA. | |
21 | */ | |
22 | ||
23 | #include <zebra.h> | |
24 | ||
25 | #include "linklist.h" | |
26 | #include "if.h" | |
27 | #include "prefix.h" | |
28 | #include "ioctl.h" | |
29 | #include "log.h" | |
48a46fa0 | 30 | #include "privs.h" |
8842468c | 31 | |
32 | #include "zebra/rib.h" | |
33 | #include "zebra/rt.h" | |
5c78b3d0 | 34 | #include "zebra/interface.h" |
8842468c | 35 | |
48a46fa0 | 36 | extern struct zebra_privs_t zserv_privs; |
8842468c | 37 | |
38 | /* clear and set interface name string */ | |
39 | void | |
5c78b3d0 | 40 | lifreq_set_name (struct lifreq *lifreq, const char *ifname) |
8842468c | 41 | { |
5c78b3d0 | 42 | strncpy (lifreq->lifr_name, ifname, IFNAMSIZ); |
8842468c | 43 | } |
44 | ||
45 | /* call ioctl system call */ | |
46 | int | |
47 | if_ioctl (u_long request, caddr_t buffer) | |
48 | { | |
49 | int sock; | |
4460e7a4 | 50 | int ret; |
51 | int err; | |
8842468c | 52 | |
53 | if (zserv_privs.change(ZPRIVS_RAISE)) | |
54 | zlog (NULL, LOG_ERR, "Can't raise privileges"); | |
55 | ||
56 | sock = socket (AF_INET, SOCK_DGRAM, 0); | |
57 | if (sock < 0) | |
58 | { | |
6a52d0d1 | 59 | int save_errno = errno; |
8842468c | 60 | if (zserv_privs.change(ZPRIVS_LOWER)) |
61 | zlog (NULL, LOG_ERR, "Can't lower privileges"); | |
6a52d0d1 | 62 | zlog_err("Cannot create UDP socket: %s", safe_strerror(save_errno)); |
8842468c | 63 | exit (1); |
64 | } | |
65 | ||
4460e7a4 | 66 | if ((ret = ioctl (sock, request, buffer)) < 0) |
67 | err = errno; | |
8842468c | 68 | |
69 | if (zserv_privs.change(ZPRIVS_LOWER)) | |
70 | zlog (NULL, LOG_ERR, "Can't lower privileges"); | |
71 | ||
8842468c | 72 | close (sock); |
73 | ||
74 | if (ret < 0) | |
75 | { | |
76 | errno = err; | |
77 | return ret; | |
78 | } | |
79 | return 0; | |
80 | } | |
81 | ||
5b73a671 | 82 | |
8842468c | 83 | int |
84 | if_ioctl_ipv6 (u_long request, caddr_t buffer) | |
85 | { | |
5b73a671 | 86 | #ifdef HAVE_IPV6 |
8842468c | 87 | int sock; |
4460e7a4 | 88 | int ret; |
89 | int err; | |
8842468c | 90 | |
91 | if (zserv_privs.change(ZPRIVS_RAISE)) | |
92 | zlog (NULL, LOG_ERR, "Can't raise privileges"); | |
93 | ||
94 | sock = socket (AF_INET6, SOCK_DGRAM, 0); | |
95 | if (sock < 0) | |
96 | { | |
6a52d0d1 | 97 | int save_errno = errno; |
8842468c | 98 | if (zserv_privs.change(ZPRIVS_LOWER)) |
99 | zlog (NULL, LOG_ERR, "Can't lower privileges"); | |
6a52d0d1 | 100 | zlog_err("Cannot create IPv6 datagram socket: %s", |
101 | safe_strerror(save_errno)); | |
8842468c | 102 | exit (1); |
103 | } | |
104 | ||
4460e7a4 | 105 | if ((ret = ioctl (sock, request, buffer)) < 0) |
106 | err = errno; | |
8842468c | 107 | |
108 | if (zserv_privs.change(ZPRIVS_LOWER)) | |
109 | zlog (NULL, LOG_ERR, "Can't lower privileges"); | |
110 | ||
8842468c | 111 | close (sock); |
112 | ||
113 | if (ret < 0) | |
114 | { | |
115 | errno = err; | |
116 | return ret; | |
117 | } | |
5b73a671 | 118 | #endif /* HAVE_IPV6 */ |
119 | ||
8842468c | 120 | return 0; |
121 | } | |
8842468c | 122 | |
123 | /* | |
124 | * get interface metric | |
125 | * -- if value is not avaliable set -1 | |
126 | */ | |
127 | void | |
128 | if_get_metric (struct interface *ifp) | |
129 | { | |
130 | struct lifreq lifreq; | |
131 | int ret; | |
132 | ||
5c78b3d0 | 133 | lifreq_set_name (&lifreq, ifp->name); |
8842468c | 134 | |
8842468c | 135 | if (ifp->flags & IFF_IPV4) |
136 | ret = AF_IOCTL (AF_INET, SIOCGLIFMETRIC, (caddr_t) & lifreq); | |
5b73a671 | 137 | #ifdef SOLARIS_IPV6 |
8842468c | 138 | else if (ifp->flags & IFF_IPV6) |
139 | ret = AF_IOCTL (AF_INET6, SIOCGLIFMETRIC, (caddr_t) & lifreq); | |
5b73a671 | 140 | #endif /* SOLARIS_IPV6 */ |
8842468c | 141 | else |
142 | ret = -1; | |
8842468c | 143 | |
144 | if (ret < 0) | |
145 | return; | |
146 | ||
147 | ifp->metric = lifreq.lifr_metric; | |
148 | ||
149 | if (ifp->metric == 0) | |
150 | ifp->metric = 1; | |
151 | } | |
152 | ||
153 | /* get interface MTU */ | |
154 | void | |
155 | if_get_mtu (struct interface *ifp) | |
156 | { | |
157 | struct lifreq lifreq; | |
158 | int ret; | |
f5e004f7 | 159 | u_char changed = 0; |
8842468c | 160 | |
8842468c | 161 | if (ifp->flags & IFF_IPV4) |
162 | { | |
5c78b3d0 | 163 | lifreq_set_name (&lifreq, ifp->name); |
8842468c | 164 | ret = AF_IOCTL (AF_INET, SIOCGLIFMTU, (caddr_t) & lifreq); |
165 | if (ret < 0) | |
166 | { | |
167 | zlog_info ("Can't lookup mtu on %s by ioctl(SIOCGLIFMTU)", | |
168 | ifp->name); | |
169 | ifp->mtu = -1; | |
170 | } | |
171 | else | |
172 | { | |
173 | ifp->mtu = lifreq.lifr_metric; | |
f5e004f7 | 174 | changed = 1; |
8842468c | 175 | } |
176 | } | |
177 | ||
5b73a671 | 178 | #ifdef HAVE_IPV6 |
8842468c | 179 | if ((ifp->flags & IFF_IPV6) == 0) |
f5e004f7 PJ |
180 | { |
181 | if (changed) | |
182 | zebra_interface_up_update(ifp); | |
183 | return; | |
184 | } | |
5b73a671 | 185 | |
186 | memset(&lifreq, 0, sizeof(lifreq)); | |
5c78b3d0 | 187 | lifreq_set_name (&lifreq, ifp->name); |
5b73a671 | 188 | |
8842468c | 189 | ret = AF_IOCTL (AF_INET6, SIOCGLIFMTU, (caddr_t) & lifreq); |
190 | if (ret < 0) | |
191 | { | |
192 | zlog_info ("Can't lookup mtu6 on %s by ioctl(SIOCGIFMTU)", ifp->name); | |
193 | ifp->mtu6 = -1; | |
194 | } | |
195 | else | |
196 | { | |
197 | ifp->mtu6 = lifreq.lifr_metric; | |
f5e004f7 | 198 | changed = 1 |
8842468c | 199 | } |
f5e004f7 PJ |
200 | |
201 | if (changed) | |
202 | zebra_interface_up_update(ifp); | |
5b73a671 | 203 | #endif /* HAVE_IPV6 */ |
8842468c | 204 | } |
205 | ||
206 | /* Set up interface's address, netmask (and broadcast? ). | |
207 | Solaris uses ifname:number semantics to set IP address aliases. */ | |
208 | int | |
209 | if_set_prefix (struct interface *ifp, struct connected *ifc) | |
210 | { | |
211 | int ret; | |
212 | struct ifreq ifreq; | |
213 | struct sockaddr_in addr; | |
214 | struct sockaddr_in broad; | |
215 | struct sockaddr_in mask; | |
216 | struct prefix_ipv4 ifaddr; | |
217 | struct prefix_ipv4 *p; | |
218 | ||
219 | p = (struct prefix_ipv4 *) ifc->address; | |
220 | ||
221 | ifaddr = *p; | |
222 | ||
223 | strncpy (ifreq.ifr_name, ifp->name, IFNAMSIZ); | |
224 | ||
225 | addr.sin_addr = p->prefix; | |
226 | addr.sin_family = p->family; | |
227 | memcpy (&ifreq.ifr_addr, &addr, sizeof (struct sockaddr_in)); | |
228 | ||
229 | ret = if_ioctl (SIOCSIFADDR, (caddr_t) & ifreq); | |
230 | ||
231 | if (ret < 0) | |
232 | return ret; | |
233 | ||
234 | /* We need mask for make broadcast addr. */ | |
235 | masklen2ip (p->prefixlen, &mask.sin_addr); | |
236 | ||
237 | if (if_is_broadcast (ifp)) | |
238 | { | |
239 | apply_mask_ipv4 (&ifaddr); | |
240 | addr.sin_addr = ifaddr.prefix; | |
241 | ||
242 | broad.sin_addr.s_addr = (addr.sin_addr.s_addr | ~mask.sin_addr.s_addr); | |
243 | broad.sin_family = p->family; | |
244 | ||
245 | memcpy (&ifreq.ifr_broadaddr, &broad, sizeof (struct sockaddr_in)); | |
246 | ret = if_ioctl (SIOCSIFBRDADDR, (caddr_t) & ifreq); | |
247 | if (ret < 0) | |
48a46fa0 | 248 | return ret; |
8842468c | 249 | } |
250 | ||
251 | mask.sin_family = p->family; | |
252 | #ifdef SUNOS_5 | |
253 | memcpy (&mask, &ifreq.ifr_addr, sizeof (mask)); | |
254 | #else | |
255 | memcpy (&ifreq.ifr_netmask, &mask, sizeof (struct sockaddr_in)); | |
48a46fa0 | 256 | #endif /* SUNOS_5 */ |
8842468c | 257 | ret = if_ioctl (SIOCSIFNETMASK, (caddr_t) & ifreq); |
258 | ||
259 | return ((ret < 0) ? ret : 0); | |
260 | } | |
261 | ||
262 | /* Set up interface's address, netmask (and broadcast). | |
263 | Solaris uses ifname:number semantics to set IP address aliases. */ | |
264 | int | |
265 | if_unset_prefix (struct interface *ifp, struct connected *ifc) | |
266 | { | |
267 | int ret; | |
268 | struct ifreq ifreq; | |
269 | struct sockaddr_in addr; | |
270 | struct prefix_ipv4 *p; | |
271 | ||
272 | p = (struct prefix_ipv4 *) ifc->address; | |
273 | ||
274 | strncpy (ifreq.ifr_name, ifp->name, IFNAMSIZ); | |
275 | ||
276 | memset (&addr, 0, sizeof (struct sockaddr_in)); | |
277 | addr.sin_family = p->family; | |
278 | memcpy (&ifreq.ifr_addr, &addr, sizeof (struct sockaddr_in)); | |
279 | ||
280 | ret = if_ioctl (SIOCSIFADDR, (caddr_t) & ifreq); | |
281 | ||
282 | if (ret < 0) | |
283 | return ret; | |
284 | ||
285 | return 0; | |
286 | } | |
287 | ||
5c78b3d0 | 288 | /* Get just the flags for the given name. |
289 | * Used by the normal 'if_get_flags' function, as well | |
290 | * as the bootup interface-list code, which has to peek at per-address | |
291 | * flags in order to figure out which ones should be ignored.. | |
0752ef0b | 292 | */ |
5c78b3d0 | 293 | int |
294 | if_get_flags_direct (const char *ifname, uint64_t *flags, unsigned int af) | |
0752ef0b | 295 | { |
5c78b3d0 | 296 | struct lifreq lifreq; |
297 | int ret; | |
298 | ||
299 | lifreq_set_name (&lifreq, ifname); | |
300 | ||
301 | ret = AF_IOCTL (af, SIOCGLIFFLAGS, (caddr_t) &lifreq); | |
302 | ||
303 | if (ret) | |
304 | zlog_debug ("%s: ifname %s, error %s (%d)", | |
305 | __func__, ifname, safe_strerror (errno), errno); | |
306 | ||
307 | *flags = lifreq.lifr_flags; | |
308 | ||
309 | return ret; | |
0752ef0b | 310 | } |
311 | ||
8842468c | 312 | /* get interface flags */ |
313 | void | |
314 | if_get_flags (struct interface *ifp) | |
315 | { | |
0752ef0b | 316 | int ret4, ret6; |
5c78b3d0 | 317 | uint64_t newflags = 0; |
318 | uint64_t tmpflags; | |
8842468c | 319 | |
320 | if (ifp->flags & IFF_IPV4) | |
321 | { | |
5c78b3d0 | 322 | ret4 = if_get_flags_direct (ifp->name, &tmpflags, AF_INET); |
0752ef0b | 323 | |
324 | if (!ret4) | |
5c78b3d0 | 325 | newflags |= tmpflags; |
326 | else if (errno == ENXIO) | |
327 | { | |
328 | /* it's gone */ | |
329 | UNSET_FLAG (ifp->flags, IFF_UP); | |
330 | if_flags_update (ifp, ifp->flags); | |
331 | } | |
8842468c | 332 | } |
333 | ||
334 | if (ifp->flags & IFF_IPV6) | |
335 | { | |
5c78b3d0 | 336 | ret6 = if_get_flags_direct (ifp->name, &tmpflags, AF_INET6); |
0752ef0b | 337 | |
338 | if (!ret6) | |
5c78b3d0 | 339 | newflags |= tmpflags; |
340 | else if (errno == ENXIO) | |
341 | { | |
342 | /* it's gone */ | |
343 | UNSET_FLAG (ifp->flags, IFF_UP); | |
344 | if_flags_update (ifp, ifp->flags); | |
345 | } | |
8842468c | 346 | } |
0752ef0b | 347 | |
348 | /* only update flags if one of above succeeded */ | |
349 | if ( !(ret4 && ret6) ) | |
5c78b3d0 | 350 | if_flags_update (ifp, newflags); |
8842468c | 351 | } |
352 | ||
353 | /* Set interface flags */ | |
354 | int | |
5c78b3d0 | 355 | if_set_flags (struct interface *ifp, uint64_t flags) |
8842468c | 356 | { |
357 | int ret; | |
358 | struct lifreq lifreq; | |
359 | ||
5c78b3d0 | 360 | lifreq_set_name (&lifreq, ifp->name); |
8842468c | 361 | |
362 | lifreq.lifr_flags = ifp->flags; | |
363 | lifreq.lifr_flags |= flags; | |
364 | ||
8842468c | 365 | if (ifp->flags & IFF_IPV4) |
366 | ret = AF_IOCTL (AF_INET, SIOCSLIFFLAGS, (caddr_t) & lifreq); | |
367 | else if (ifp->flags & IFF_IPV6) | |
368 | ret = AF_IOCTL (AF_INET6, SIOCSLIFFLAGS, (caddr_t) & lifreq); | |
369 | else | |
370 | ret = -1; | |
371 | ||
372 | if (ret < 0) | |
373 | zlog_info ("can't set interface flags on %s: %s", ifp->name, | |
6099b3b5 | 374 | safe_strerror (errno)); |
8842468c | 375 | else |
376 | ret = 0; | |
48a46fa0 | 377 | |
378 | return ret; | |
8842468c | 379 | } |
380 | ||
381 | /* Unset interface's flag. */ | |
382 | int | |
5c78b3d0 | 383 | if_unset_flags (struct interface *ifp, uint64_t flags) |
8842468c | 384 | { |
385 | int ret; | |
386 | struct lifreq lifreq; | |
387 | ||
5c78b3d0 | 388 | lifreq_set_name (&lifreq, ifp->name); |
8842468c | 389 | |
390 | lifreq.lifr_flags = ifp->flags; | |
391 | lifreq.lifr_flags &= ~flags; | |
392 | ||
8842468c | 393 | if (ifp->flags & IFF_IPV4) |
394 | ret = AF_IOCTL (AF_INET, SIOCSLIFFLAGS, (caddr_t) & lifreq); | |
395 | else if (ifp->flags & IFF_IPV6) | |
396 | ret = AF_IOCTL (AF_INET6, SIOCSLIFFLAGS, (caddr_t) & lifreq); | |
397 | else | |
398 | ret = -1; | |
399 | ||
400 | if (ret < 0) | |
401 | zlog_info ("can't unset interface flags"); | |
402 | else | |
403 | ret = 0; | |
404 | ||
48a46fa0 | 405 | return ret; |
8842468c | 406 | } |
407 | ||
408 | #ifdef HAVE_IPV6 | |
409 | ||
410 | /* Interface's address add/delete functions. */ | |
411 | int | |
412 | if_prefix_add_ipv6 (struct interface *ifp, struct connected *ifc) | |
413 | { | |
414 | char addrbuf[INET_ADDRSTRLEN]; | |
415 | ||
416 | inet_ntop (AF_INET6, &(((struct prefix_ipv6 *) (ifc->address))->prefix), | |
417 | addrbuf, sizeof (addrbuf)); | |
418 | zlog_warn ("Can't set %s on interface %s", addrbuf, ifp->name); | |
419 | ||
420 | return 0; | |
421 | ||
422 | } | |
423 | ||
424 | int | |
425 | if_prefix_delete_ipv6 (struct interface *ifp, struct connected *ifc) | |
426 | { | |
427 | char addrbuf[INET_ADDRSTRLEN]; | |
428 | ||
429 | inet_ntop (AF_INET6, &(((struct prefix_ipv6 *) (ifc->address))->prefix), | |
430 | addrbuf, sizeof (addrbuf)); | |
431 | zlog_warn ("Can't delete %s on interface %s", addrbuf, ifp->name); | |
432 | ||
433 | return 0; | |
434 | ||
435 | } | |
436 | ||
437 | #endif /* HAVE_IPV6 */ |