]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - ospf6d/ospf6_network.c
New upstream version 1.2.4
[quagga-debian.git] / ospf6d / ospf6_network.c
1 /*
2  * Copyright (C) 2003 Yasuhiro Ohara
3  *
4  * This file is part of GNU Zebra.
5  *
6  * GNU Zebra is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the
8  * Free Software Foundation; either version 2, or (at your option) any
9  * later version.
10  *
11  * GNU Zebra is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with GNU Zebra; see the file COPYING.  If not, write to the 
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
19  * Boston, MA 02111-1307, USA.  
20  */
21
22 #include <zebra.h>
23
24 #include "log.h"
25 #include "memory.h"
26 #include "sockunion.h"
27 #include "sockopt.h"
28 #include "privs.h"
29
30 #include "libospf.h"
31 #include "ospf6_proto.h"
32 #include "ospf6_network.h"
33
34 extern struct zebra_privs_t ospf6d_privs;
35
36 int  ospf6_sock;
37 struct in6_addr allspfrouters6;
38 struct in6_addr alldrouters6;
39
40 /* setsockopt MulticastLoop to off */
41 static void
42 ospf6_reset_mcastloop (void)
43 {
44   u_int off = 0;
45   if (setsockopt (ospf6_sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
46                   &off, sizeof (u_int)) < 0)
47     zlog_warn ("Network: reset IPV6_MULTICAST_LOOP failed: %s",
48                safe_strerror (errno));
49 }
50
51 static void
52 ospf6_set_pktinfo (void)
53 {
54   setsockopt_ipv6_pktinfo (ospf6_sock, 1);
55 }
56
57 static void
58 ospf6_set_transport_class (void)
59 {
60 #ifdef IPTOS_PREC_INTERNETCONTROL
61   setsockopt_ipv6_tclass (ospf6_sock, IPTOS_PREC_INTERNETCONTROL);
62 #endif
63 }
64
65 static void
66 ospf6_set_checksum (void)
67 {
68   int offset = 12;
69 #ifndef DISABLE_IPV6_CHECKSUM
70   if (setsockopt (ospf6_sock, IPPROTO_IPV6, IPV6_CHECKSUM,
71                   &offset, sizeof (offset)) < 0)
72     zlog_warn ("Network: set IPV6_CHECKSUM failed: %s", safe_strerror (errno));
73 #else
74   zlog_warn ("Network: Don't set IPV6_CHECKSUM");
75 #endif /* DISABLE_IPV6_CHECKSUM */
76 }
77
78 /* Make ospf6d's server socket. */
79 int
80 ospf6_serv_sock (void)
81 {
82   if (ospf6d_privs.change (ZPRIVS_RAISE))
83     zlog_err ("ospf6_serv_sock: could not raise privs");
84
85   ospf6_sock = socket (AF_INET6, SOCK_RAW, IPPROTO_OSPFIGP);
86   if (ospf6_sock < 0)
87     {
88       zlog_warn ("Network: can't create OSPF6 socket.");
89       if (ospf6d_privs.change (ZPRIVS_LOWER))
90         zlog_err ("ospf_sock_init: could not lower privs");
91       return -1;
92     }
93   if (ospf6d_privs.change (ZPRIVS_LOWER))
94       zlog_err ("ospf_sock_init: could not lower privs");
95
96   /* set socket options */
97 #if 1
98   sockopt_reuseaddr (ospf6_sock);
99 #else
100   ospf6_set_reuseaddr ();
101 #endif /*1*/
102   ospf6_reset_mcastloop ();
103   ospf6_set_pktinfo ();
104   ospf6_set_transport_class ();
105   ospf6_set_checksum ();
106
107   /* setup global in6_addr, allspf6 and alldr6 for later use */
108   inet_pton (AF_INET6, ALLSPFROUTERS6, &allspfrouters6);
109   inet_pton (AF_INET6, ALLDROUTERS6, &alldrouters6);
110
111   return 0;
112 }
113
114 /* ospf6 set socket option */
115 int
116 ospf6_sso (ifindex_t ifindex, struct in6_addr *group, int option)
117 {
118   struct ipv6_mreq mreq6;
119   int ret;
120
121   assert (ifindex);
122   mreq6.ipv6mr_interface = ifindex;
123   memcpy (&mreq6.ipv6mr_multiaddr, group, sizeof (struct in6_addr));
124
125   ret = setsockopt (ospf6_sock, IPPROTO_IPV6, option,
126                     &mreq6, sizeof (mreq6));
127   if (ret < 0)
128     {
129       zlog_err ("Network: setsockopt (%d) on ifindex %d failed: %s",
130                 option, ifindex, safe_strerror (errno));
131     }
132
133   return ret;
134 }
135
136 static int
137 iov_count (struct iovec *iov)
138 {
139   int i;
140   for (i = 0; iov[i].iov_base; i++)
141     ;
142   return i;
143 }
144
145 static int
146 iov_totallen (struct iovec *iov)
147 {
148   int i;
149   int totallen = 0;
150   for (i = 0; iov[i].iov_base; i++)
151     totallen += iov[i].iov_len;
152   return totallen;
153 }
154
155 int
156 ospf6_sendmsg (struct in6_addr *src, struct in6_addr *dst,
157                ifindex_t *ifindex, struct iovec *message)
158 {
159   int retval;
160   struct msghdr smsghdr;
161   struct cmsghdr *scmsgp;
162   u_char cmsgbuf[CMSG_SPACE(sizeof (struct in6_pktinfo))];
163   struct in6_pktinfo *pktinfo;
164   struct sockaddr_in6 dst_sin6;
165
166   assert (dst);
167   assert (*ifindex);
168
169   scmsgp = (struct cmsghdr *)cmsgbuf;
170   pktinfo = (struct in6_pktinfo *)(CMSG_DATA(scmsgp));
171   memset (&dst_sin6, 0, sizeof (struct sockaddr_in6));
172
173   /* source address */
174   pktinfo->ipi6_ifindex = *ifindex;
175   if (src)
176     memcpy (&pktinfo->ipi6_addr, src, sizeof (struct in6_addr));
177   else
178     memset (&pktinfo->ipi6_addr, 0, sizeof (struct in6_addr));
179
180   /* destination address */
181   dst_sin6.sin6_family = AF_INET6;
182 #ifdef SIN6_LEN
183   dst_sin6.sin6_len = sizeof (struct sockaddr_in6);
184 #endif /*SIN6_LEN*/
185   memcpy (&dst_sin6.sin6_addr, dst, sizeof (struct in6_addr));
186 #ifdef HAVE_SIN6_SCOPE_ID
187   dst_sin6.sin6_scope_id = *ifindex;
188 #endif
189
190   /* send control msg */
191   scmsgp->cmsg_level = IPPROTO_IPV6;
192   scmsgp->cmsg_type = IPV6_PKTINFO;
193   scmsgp->cmsg_len = CMSG_LEN (sizeof (struct in6_pktinfo));
194   /* scmsgp = CMSG_NXTHDR (&smsghdr, scmsgp); */
195
196   /* send msg hdr */
197   memset (&smsghdr, 0, sizeof (smsghdr));
198   smsghdr.msg_iov = message;
199   smsghdr.msg_iovlen = iov_count (message);
200   smsghdr.msg_name = (caddr_t) &dst_sin6;
201   smsghdr.msg_namelen = sizeof (struct sockaddr_in6);
202   smsghdr.msg_control = (caddr_t) cmsgbuf;
203   smsghdr.msg_controllen = scmsgp->cmsg_len;
204
205   retval = sendmsg (ospf6_sock, &smsghdr, 0);
206   if (retval != iov_totallen (message))
207     zlog_warn ("sendmsg failed: ifindex: %d: %s (%d)",
208                *ifindex, safe_strerror (errno), errno);
209
210   return retval;
211 }
212
213 int
214 ospf6_recvmsg (struct in6_addr *src, struct in6_addr *dst,
215                ifindex_t *ifindex, struct iovec *message)
216 {
217   int retval;
218   struct msghdr rmsghdr;
219   struct cmsghdr *rcmsgp;
220   u_char cmsgbuf[CMSG_SPACE(sizeof (struct in6_pktinfo))];
221   struct in6_pktinfo *pktinfo;
222   struct sockaddr_in6 src_sin6;
223
224   rcmsgp = (struct cmsghdr *)cmsgbuf;
225   pktinfo = (struct in6_pktinfo *)(CMSG_DATA(rcmsgp));
226   memset (&src_sin6, 0, sizeof (struct sockaddr_in6));
227
228   /* receive control msg */
229   rcmsgp->cmsg_level = IPPROTO_IPV6;
230   rcmsgp->cmsg_type = IPV6_PKTINFO;
231   rcmsgp->cmsg_len = CMSG_LEN (sizeof (struct in6_pktinfo));
232   /* rcmsgp = CMSG_NXTHDR (&rmsghdr, rcmsgp); */
233
234   /* receive msg hdr */
235   memset (&rmsghdr, 0, sizeof (rmsghdr));
236   rmsghdr.msg_iov = message;
237   rmsghdr.msg_iovlen = iov_count (message);
238   rmsghdr.msg_name = (caddr_t) &src_sin6;
239   rmsghdr.msg_namelen = sizeof (struct sockaddr_in6);
240   rmsghdr.msg_control = (caddr_t) cmsgbuf;
241   rmsghdr.msg_controllen = sizeof (cmsgbuf);
242
243   retval = recvmsg (ospf6_sock, &rmsghdr, 0);
244   if (retval < 0)
245     zlog_warn ("recvmsg failed: %s", safe_strerror (errno));
246   else if (retval == iov_totallen (message))
247     zlog_warn ("recvmsg read full buffer size: %d", retval);
248
249   /* source address */
250   assert (src);
251   memcpy (src, &src_sin6.sin6_addr, sizeof (struct in6_addr));
252
253   /* destination address */
254   if (ifindex)
255     *ifindex = pktinfo->ipi6_ifindex;
256   if (dst)
257     memcpy (dst, &pktinfo->ipi6_addr, sizeof (struct in6_addr));
258
259   return retval;
260 }
261
262