tincctl: restrict umask argument for FORTIFY
[tinc] / src / fd_device.c
1 /*
2     fd_device.c -- Interaction with Android tun fd
3     Copyright (C)   2001-2005   Ivo Timmermans,
4                     2001-2016   Guus Sliepen <guus@tinc-vpn.org>
5                     2009        Grzegorz Dymarek <gregd72002@googlemail.com>
6                     2016-2020   Pacien TRAN-GIRARD <pacien@pacien.net>
7
8     This program is free software; you can redistribute it and/or modify
9     it under the terms of the GNU General Public License as published by
10     the Free Software Foundation; either version 2 of the License, or
11     (at your option) any later version.
12
13     This program is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16     GNU General Public License for more details.
17
18     You should have received a copy of the GNU General Public License along
19     with this program; if not, write to the Free Software Foundation, Inc.,
20     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23 #include "system.h"
24
25 #ifdef HAVE_SYS_UN_H
26 #include <sys/un.h>
27
28 #include "conf.h"
29 #include "device.h"
30 #include "ethernet.h"
31 #include "logger.h"
32 #include "net.h"
33 #include "route.h"
34 #include "utils.h"
35
36 struct unix_socket_addr {
37         size_t size;
38         struct sockaddr_un addr;
39 };
40
41 static int read_fd(int socket) {
42         char iobuf;
43         struct iovec iov = {0};
44         char cmsgbuf[CMSG_SPACE(sizeof(device_fd))];
45         struct msghdr msg = {0};
46         int ret;
47         struct cmsghdr *cmsgptr;
48
49         iov.iov_base = &iobuf;
50         iov.iov_len = 1;
51         msg.msg_iov = &iov;
52         msg.msg_iovlen = 1;
53         msg.msg_control = cmsgbuf;
54         msg.msg_controllen = sizeof(cmsgbuf);
55
56         if((ret = recvmsg(socket, &msg, 0)) < 1) {
57                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not read from unix socket (error %d)!", ret);
58                 return -1;
59         }
60
61 #ifdef IP_RECVERR
62
63         if(msg.msg_flags & (MSG_CTRUNC | MSG_OOB | MSG_ERRQUEUE)) {
64 #else
65
66         if(msg.msg_flags & (MSG_CTRUNC | MSG_OOB)) {
67 #endif
68                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while receiving message (flags %d)!", msg.msg_flags);
69                 return -1;
70         }
71
72         cmsgptr = CMSG_FIRSTHDR(&msg);
73
74         if(cmsgptr->cmsg_level != SOL_SOCKET) {
75                 logger(DEBUG_ALWAYS, LOG_ERR, "Wrong CMSG level: %d, expected %d!",
76                        cmsgptr->cmsg_level, SOL_SOCKET);
77                 return -1;
78         }
79
80         if(cmsgptr->cmsg_type != SCM_RIGHTS) {
81                 logger(DEBUG_ALWAYS, LOG_ERR, "Wrong CMSG type: %d, expected %d!",
82                        cmsgptr->cmsg_type, SCM_RIGHTS);
83                 return -1;
84         }
85
86         if(cmsgptr->cmsg_len != CMSG_LEN(sizeof(device_fd))) {
87                 logger(DEBUG_ALWAYS, LOG_ERR, "Wrong CMSG data length: %lu, expected %lu!",
88                        (unsigned long)cmsgptr->cmsg_len, (unsigned long)CMSG_LEN(sizeof(device_fd)));
89                 return -1;
90         }
91
92         return *(int *) CMSG_DATA(cmsgptr);
93 }
94
95 static int receive_fd(struct unix_socket_addr socket_addr) {
96         int socketfd;
97         int ret;
98         int result;
99
100         if((socketfd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
101                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not open stream socket (error %d)!", socketfd);
102                 return -1;
103         }
104
105         if((ret = connect(socketfd, (struct sockaddr *) &socket_addr.addr, socket_addr.size)) < 0) {
106                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not connect to Unix socket (error %d)!", ret);
107                 result = -1;
108                 goto end;
109         }
110
111         result = read_fd(socketfd);
112
113 end:
114         close(socketfd);
115         return result;
116 }
117
118 static struct unix_socket_addr parse_socket_addr(const char *path) {
119         struct sockaddr_un socket_addr;
120         size_t path_length;
121
122         if(strlen(path) >= sizeof(socket_addr.sun_path)) {
123                 logger(DEBUG_ALWAYS, LOG_ERR, "Unix socket path too long!");
124                 return (struct unix_socket_addr) {
125                         0
126                 };
127         }
128
129         socket_addr.sun_family = AF_UNIX;
130         strncpy(socket_addr.sun_path, path, sizeof(socket_addr.sun_path));
131
132         if(path[0] == '@') {
133                 /* abstract namespace socket */
134                 socket_addr.sun_path[0] = '\0';
135                 path_length = strlen(path);
136         } else {
137                 /* filesystem path with NUL terminator */
138                 path_length = strlen(path) + 1;
139         }
140
141         return (struct unix_socket_addr) {
142                 .size = offsetof(struct sockaddr_un, sun_path) + path_length,
143                 .addr = socket_addr
144         };
145 }
146
147 static bool setup_device(void) {
148         if(routing_mode == RMODE_SWITCH) {
149                 logger(DEBUG_ALWAYS, LOG_ERR, "Switch mode not supported (requires unsupported TAP device)!");
150                 return false;
151         }
152
153         if(!get_config_string(lookup_config(config_tree, "Device"), &device)) {
154                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not read device from configuration!");
155                 return false;
156         }
157
158         /* device is either directly a file descriptor or an unix socket to read it from */
159         if(sscanf(device, "%d", &device_fd) != 1) {
160                 logger(DEBUG_ALWAYS, LOG_INFO, "Receiving fd from Unix socket at %s.", device);
161                 device_fd = receive_fd(parse_socket_addr(device));
162         }
163
164         if(device_fd < 0) {
165                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not open %s: %s!", device, strerror(errno));
166                 return false;
167         }
168
169         logger(DEBUG_ALWAYS, LOG_INFO, "fd/%d adapter set up.", device_fd);
170
171         return true;
172 }
173
174 static void close_device(void) {
175         close(device_fd);
176         device_fd = -1;
177 }
178
179 static inline uint16_t get_ip_ethertype(vpn_packet_t *packet) {
180         switch(DATA(packet)[ETH_HLEN] >> 4) {
181         case 4:
182                 return ETH_P_IP;
183
184         case 6:
185                 return ETH_P_IPV6;
186
187         default:
188                 return ETH_P_MAX;
189         }
190 }
191
192 static inline void set_etherheader(vpn_packet_t *packet, uint16_t ethertype) {
193         memset(DATA(packet), 0, ETH_HLEN - ETHER_TYPE_LEN);
194
195         DATA(packet)[ETH_HLEN - ETHER_TYPE_LEN] = (ethertype >> 8) & 0xFF;
196         DATA(packet)[ETH_HLEN - ETHER_TYPE_LEN + 1] = ethertype & 0xFF;
197 }
198
199 static bool read_packet(vpn_packet_t *packet) {
200         int lenin = read(device_fd, DATA(packet) + ETH_HLEN, MTU - ETH_HLEN);
201
202         if(lenin <= 0) {
203                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from fd/%d: %s!", device_fd, strerror(errno));
204                 return false;
205         }
206
207         uint16_t ethertype = get_ip_ethertype(packet);
208
209         if(ethertype == ETH_P_MAX) {
210                 logger(DEBUG_TRAFFIC, LOG_ERR, "Unknown IP version while reading packet from fd/%d!", device_fd);
211                 return false;
212         }
213
214         set_etherheader(packet, ethertype);
215         packet->len = lenin + ETH_HLEN;
216
217         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Read packet of %d bytes from fd/%d.", packet->len, device_fd);
218
219         return true;
220 }
221
222 static bool write_packet(vpn_packet_t *packet) {
223         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to fd/%d.", packet->len, device_fd);
224
225         if(write(device_fd, DATA(packet) + ETH_HLEN, packet->len - ETH_HLEN) < 0) {
226                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to fd/%d: %s!", device_fd, strerror(errno));
227                 return false;
228         }
229
230         return true;
231 }
232
233 const devops_t fd_devops = {
234         .setup = setup_device,
235         .close = close_device,
236         .read = read_packet,
237         .write = write_packet,
238 };
239 #endif