Don't try to handle incoming data if sptps_start() has not been called yet.
[tinc] / src / multicast_device.c
1 /*
2     device.c -- multicast socket
3     Copyright (C) 2002-2005 Ivo Timmermans,
4                   2002-2012 Guus Sliepen <guus@tinc-vpn.org>
5
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License along
17     with this program; if not, write to the Free Software Foundation, Inc.,
18     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 #include "system.h"
22
23 #include "conf.h"
24 #include "device.h"
25 #include "net.h"
26 #include "logger.h"
27 #include "netutl.h"
28 #include "utils.h"
29 #include "route.h"
30 #include "xalloc.h"
31
32 static char *device_info;
33
34 static uint64_t device_total_in = 0;
35 static uint64_t device_total_out = 0;
36
37 static struct addrinfo *ai = NULL;
38 static mac_t ignore_src = {{0}};
39
40 static bool setup_device(void) {
41         char *host = NULL;
42         char *port;
43         char *space;
44         int ttl = 1;
45
46         device_info = "multicast socket";
47
48         get_config_string(lookup_config(config_tree, "Interface"), &iface);
49
50         if(!get_config_string(lookup_config(config_tree, "Device"), &device)) {
51                 logger(DEBUG_ALWAYS, LOG_ERR, "Device variable required for %s", device_info);
52                 goto error;
53         }
54
55         host = xstrdup(device);
56         space = strchr(host, ' ');
57         if(!space) {
58                 logger(DEBUG_ALWAYS, LOG_ERR, "Port number required for %s", device_info);
59                 goto error;
60         }
61
62         *space++ = 0;
63         port = space;
64         space = strchr(port, ' ');
65
66         if(space) {
67                 *space++ = 0;
68                 ttl = atoi(space);
69         }
70
71         ai = str2addrinfo(host, port, SOCK_DGRAM);
72         if(!ai)
73                 goto error;
74
75         device_fd = socket(ai->ai_family, SOCK_DGRAM, IPPROTO_UDP);
76         if(device_fd < 0) {
77                 logger(DEBUG_ALWAYS, LOG_ERR, "Creating socket failed: %s", sockstrerror(sockerrno));
78                 goto error;
79         }
80
81 #ifdef FD_CLOEXEC
82         fcntl(device_fd, F_SETFD, FD_CLOEXEC);
83 #endif
84
85         static const int one = 1;
86         setsockopt(device_fd, SOL_SOCKET, SO_REUSEADDR, (void *)&one, sizeof one);
87
88         if(bind(device_fd, ai->ai_addr, ai->ai_addrlen)) {
89                 logger(DEBUG_ALWAYS, LOG_ERR, "Can't bind to %s %s: %s", host, port, sockstrerror(sockerrno));
90                 goto error;
91         }
92
93         switch(ai->ai_family) {
94 #ifdef IP_ADD_MEMBERSHIP
95                 case AF_INET: {
96                         struct ip_mreq mreq;
97                         struct sockaddr_in in;
98                         memcpy(&in, ai->ai_addr, sizeof in);
99                         mreq.imr_multiaddr.s_addr = in.sin_addr.s_addr;
100                         mreq.imr_interface.s_addr = htonl(INADDR_ANY);
101                         if(setsockopt(device_fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (void *)&mreq, sizeof mreq)) {
102                                 logger(DEBUG_ALWAYS, LOG_ERR, "Cannot join multicast group %s %s: %s", host, port, sockstrerror(sockerrno));
103                                 goto error;
104                         }
105 #ifdef IP_MULTICAST_LOOP
106                         setsockopt(device_fd, IPPROTO_IP, IP_MULTICAST_LOOP, (const void *)&one, sizeof one);
107 #endif
108 #ifdef IP_MULTICAST_TTL
109                         setsockopt(device_fd, IPPROTO_IP, IP_MULTICAST_TTL, (void *)&ttl, sizeof ttl);
110 #endif
111                 } break;
112 #endif
113
114 #ifdef IPV6_JOIN_GROUP
115                 case AF_INET6: {
116                         struct ipv6_mreq mreq;
117                         struct sockaddr_in6 in6;
118                         memcpy(&in6, ai->ai_addr, sizeof in6);
119                         memcpy(&mreq.ipv6mr_multiaddr, &in6.sin6_addr, sizeof mreq.ipv6mr_multiaddr);
120                         mreq.ipv6mr_interface = in6.sin6_scope_id;
121                         if(setsockopt(device_fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, (void *)&mreq, sizeof mreq)) {
122                                 logger(DEBUG_ALWAYS, LOG_ERR, "Cannot join multicast group %s %s: %s", host, port, sockstrerror(sockerrno));
123                                 goto error;
124                         }
125 #ifdef IPV6_MULTICAST_LOOP
126                         setsockopt(device_fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (const void *)&one, sizeof one);
127 #endif
128 #ifdef IPV6_MULTICAST_HOPS
129                         setsockopt(device_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (void *)&ttl, sizeof ttl);
130 #endif
131                 } break;
132 #endif
133
134                 default:
135                         logger(DEBUG_ALWAYS, LOG_ERR, "Multicast for address family %hx unsupported", ai->ai_family);
136                         goto error;
137         }
138
139         freeaddrinfo(ai);
140
141         logger(DEBUG_ALWAYS, LOG_INFO, "%s is a %s", device, device_info);
142
143         return true;
144
145 error:
146         if(device_fd >= 0)
147                 closesocket(device_fd);
148         if(ai)
149                 freeaddrinfo(ai);
150         free(host);
151
152         return false;
153 }
154
155 static void close_device(void) {
156         close(device_fd);
157
158         free(device);
159         free(iface);
160
161         if(ai)
162                 freeaddrinfo(ai);
163 }
164
165 static bool read_packet(vpn_packet_t *packet) {
166         int lenin;
167
168         if((lenin = recv(device_fd, (void *)packet->data, MTU, 0)) <= 0) {
169                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
170                            device, strerror(errno));
171                 return false;
172         }
173
174         if(!memcmp(&ignore_src, packet->data + 6, sizeof ignore_src)) {
175                 logger(DEBUG_SCARY_THINGS, LOG_DEBUG, "Ignoring loopback packet of %d bytes from %s", lenin, device_info);
176                 packet->len = 0;
177                 return true;
178         }
179
180         packet->len = lenin;
181
182         device_total_in += packet->len;
183
184         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Read packet of %d bytes from %s", packet->len,
185                            device_info);
186
187         return true;
188 }
189
190 static bool write_packet(vpn_packet_t *packet) {
191         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s",
192                            packet->len, device_info);
193
194         if(sendto(device_fd, (void *)packet->data, packet->len, 0, ai->ai_addr, ai->ai_addrlen) < 0) {
195                 logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device,
196                            strerror(errno));
197                 return false;
198         }
199
200         device_total_out += packet->len;
201
202         memcpy(&ignore_src, packet->data + 6, sizeof ignore_src);
203
204         return true;
205 }
206
207 static void dump_device_stats(void) {
208         logger(DEBUG_ALWAYS, LOG_DEBUG, "Statistics for %s %s:", device_info, device);
209         logger(DEBUG_ALWAYS, LOG_DEBUG, " total bytes in:  %10"PRIu64, device_total_in);
210         logger(DEBUG_ALWAYS, LOG_DEBUG, " total bytes out: %10"PRIu64, device_total_out);
211 }
212
213 const devops_t multicast_devops = {
214         .setup = setup_device,
215         .close = close_device,
216         .read = read_packet,
217         .write = write_packet,
218         .dump_stats = dump_device_stats,
219 };
220
221 #if 0
222
223 static bool not_supported(void) {
224         logger(DEBUG_ALWAYS, LOG_ERR, "Raw socket device not supported on this platform");
225         return false;
226 }
227
228 const devops_t multicast_devops = {
229         .setup = not_supported,
230         .close = NULL,
231         .read = NULL,
232         .write = NULL,
233         .dump_stats = NULL,
234 };
235 #endif