tinc-vpn.org Git - tinc/blob - src/fd_device.c

   1 /*
   2     fd_device.c -- Interaction with Android tun fd
   3     Copyright (C)   2001-2005   Ivo Timmermans,
   4                     2001-2021   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                 .sun_family = AF_UNIX,
 121         };
 122         size_t path_length;
 123
 124         if(strlen(path) >= sizeof(socket_addr.sun_path)) {
 125                 logger(DEBUG_ALWAYS, LOG_ERR, "Unix socket path too long!");
 126                 return (struct unix_socket_addr) {
 127                         0
 128                 };
 129         }
 130
 131         strncpy(socket_addr.sun_path, path, sizeof(socket_addr.sun_path));
 132
 133         if(path[0] == '@') {
 134                 /* abstract namespace socket */
 135                 socket_addr.sun_path[0] = '\0';
 136                 path_length = strlen(path);
 137         } else {
 138                 /* filesystem path with NUL terminator */
 139                 path_length = strlen(path) + 1;
 140         }
 141
 142         return (struct unix_socket_addr) {
 143                 .size = offsetof(struct sockaddr_un, sun_path) + path_length,
 144                 .addr = socket_addr
 145         };
 146 }
 147
 148 static bool setup_device(void) {
 149         if(routing_mode == RMODE_SWITCH) {
 150                 logger(DEBUG_ALWAYS, LOG_ERR, "Switch mode not supported (requires unsupported TAP device)!");
 151                 return false;
 152         }
 153
 154         if(!get_config_string(lookup_config(config_tree, "Device"), &device)) {
 155                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not read device from configuration!");
 156                 return false;
 157         }
 158
 159         /* device is either directly a file descriptor or an unix socket to read it from */
 160         if(sscanf(device, "%d", &device_fd) != 1) {
 161                 logger(DEBUG_ALWAYS, LOG_INFO, "Receiving fd from Unix socket at %s.", device);
 162                 device_fd = receive_fd(parse_socket_addr(device));
 163         }
 164
 165         if(device_fd < 0) {
 166                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not open %s: %s!", device, strerror(errno));
 167                 return false;
 168         }
 169
 170         logger(DEBUG_ALWAYS, LOG_INFO, "fd/%d adapter set up.", device_fd);
 171
 172         return true;
 173 }
 174
 175 static void close_device(void) {
 176         close(device_fd);
 177         device_fd = -1;
 178 }
 179
 180 static inline uint16_t get_ip_ethertype(vpn_packet_t *packet) {
 181         switch(DATA(packet)[ETH_HLEN] >> 4) {
 182         case 4:
 183                 return ETH_P_IP;
 184
 185         case 6:
 186                 return ETH_P_IPV6;
 187
 188         default:
 189                 return ETH_P_MAX;
 190         }
 191 }
 192
 193 static inline void set_etherheader(vpn_packet_t *packet, uint16_t ethertype) {
 194         memset(DATA(packet), 0, ETH_HLEN - ETHER_TYPE_LEN);
 195
 196         DATA(packet)[ETH_HLEN - ETHER_TYPE_LEN] = (ethertype >> 8) & 0xFF;
 197         DATA(packet)[ETH_HLEN - ETHER_TYPE_LEN + 1] = ethertype & 0xFF;
 198 }
 199
 200 static bool read_packet(vpn_packet_t *packet) {
 201         int lenin = read(device_fd, DATA(packet) + ETH_HLEN, MTU - ETH_HLEN);
 202
 203         if(lenin <= 0) {
 204                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from fd/%d: %s!", device_fd, strerror(errno));
 205                 return false;
 206         }
 207
 208         uint16_t ethertype = get_ip_ethertype(packet);
 209
 210         if(ethertype == ETH_P_MAX) {
 211                 logger(DEBUG_TRAFFIC, LOG_ERR, "Unknown IP version while reading packet from fd/%d!", device_fd);
 212                 return false;
 213         }
 214
 215         set_etherheader(packet, ethertype);
 216         packet->len = lenin + ETH_HLEN;
 217
 218         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Read packet of %d bytes from fd/%d.", packet->len, device_fd);
 219
 220         return true;
 221 }
 222
 223 static bool write_packet(vpn_packet_t *packet) {
 224         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to fd/%d.", packet->len, device_fd);
 225
 226         if(write(device_fd, DATA(packet) + ETH_HLEN, packet->len - ETH_HLEN) < 0) {
 227                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to fd/%d: %s!", device_fd, strerror(errno));
 228                 return false;
 229         }
 230
 231         return true;
 232 }
 233
 234 const devops_t fd_devops = {
 235         .setup = setup_device,
 236         .close = close_device,
 237         .read = read_packet,
 238         .write = write_packet,
 239 };
 240 #endif