]> git.meshlink.io Git - meshlink/blob - src/multicast_device.c
Fix sending empty SPTPS records.
[meshlink] / src / multicast_device.c
1 /*
2     device.c -- multicast socket
3     Copyright (C) 2002-2005 Ivo Timmermans,
4                   2002-2013 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         logger(DEBUG_ALWAYS, LOG_INFO, "%s is a %s", device, device_info);
140
141         return true;
142
143 error:
144         if(device_fd >= 0)
145                 closesocket(device_fd);
146         if(ai)
147                 freeaddrinfo(ai);
148         free(host);
149
150         return false;
151 }
152
153 static void close_device(void) {
154         close(device_fd);
155
156         free(device);
157         free(iface);
158
159         if(ai)
160                 freeaddrinfo(ai);
161 }
162
163 static bool read_packet(vpn_packet_t *packet) {
164         int lenin;
165
166         if((lenin = recv(device_fd, (void *)packet->data, MTU, 0)) <= 0) {
167                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
168                            device, strerror(errno));
169                 return false;
170         }
171
172         if(!memcmp(&ignore_src, packet->data + 6, sizeof ignore_src)) {
173                 logger(DEBUG_SCARY_THINGS, LOG_DEBUG, "Ignoring loopback packet of %d bytes from %s", lenin, device_info);
174                 return false;
175         }
176
177         packet->len = lenin;
178
179         device_total_in += packet->len;
180
181         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Read packet of %d bytes from %s", packet->len,
182                            device_info);
183
184         return true;
185 }
186
187 static bool write_packet(vpn_packet_t *packet) {
188         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s",
189                            packet->len, device_info);
190
191         if(sendto(device_fd, (void *)packet->data, packet->len, 0, ai->ai_addr, ai->ai_addrlen) < 0) {
192                 logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device,
193                            strerror(errno));
194                 return false;
195         }
196
197         device_total_out += packet->len;
198
199         memcpy(&ignore_src, packet->data + 6, sizeof ignore_src);
200
201         return true;
202 }
203
204 static void dump_device_stats(void) {
205         logger(DEBUG_ALWAYS, LOG_DEBUG, "Statistics for %s %s:", device_info, device);
206         logger(DEBUG_ALWAYS, LOG_DEBUG, " total bytes in:  %10"PRIu64, device_total_in);
207         logger(DEBUG_ALWAYS, LOG_DEBUG, " total bytes out: %10"PRIu64, device_total_out);
208 }
209
210 const devops_t multicast_devops = {
211         .setup = setup_device,
212         .close = close_device,
213         .read = read_packet,
214         .write = write_packet,
215         .dump_stats = dump_device_stats,
216 };
217
218 #if 0
219
220 static bool not_supported(void) {
221         logger(DEBUG_ALWAYS, LOG_ERR, "Raw socket device not supported on this platform");
222         return false;
223 }
224
225 const devops_t multicast_devops = {
226         .setup = not_supported,
227         .close = NULL,
228         .read = NULL,
229         .write = NULL,
230         .dump_stats = NULL,
231 };
232 #endif