Use progress callback for output
[platform/upstream/openconnect.git] / tun.c
1 /*
2  * Open AnyConnect (SSL + DTLS) client
3  *
4  * © 2008 David Woodhouse <dwmw2@infradead.org>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public License
8  * as published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * This library 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  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to:
18  *
19  *   Free Software Foundation, Inc.
20  *   51 Franklin Street, Fifth Floor,
21  *   Boston, MA 02110-1301 USA
22  */
23
24 #include <string.h>
25 #include <net/if.h>
26 #include <sys/ioctl.h>
27 #include <linux/if_tun.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <fcntl.h>
31 #include <unistd.h>
32 #include <netinet/in.h>
33 #include <arpa/inet.h>
34 #include <errno.h>
35
36 #include "openconnect.h"
37
38 static int local_config_tun(struct openconnect_info *vpninfo, int mtu_only)
39 {
40         struct ifreq ifr;
41         int net_fd;
42
43         net_fd = socket(PF_INET, SOCK_DGRAM, 0);
44         if (net_fd < 0) {
45                 perror("open net");
46                 return -EINVAL;
47         }
48         memset(&ifr, 0, sizeof(ifr));
49         strncpy(ifr.ifr_name, vpninfo->ifname, sizeof(ifr.ifr_name) - 1);
50
51         if (!mtu_only) {
52                 struct sockaddr_in *addr = (struct sockaddr_in *) &ifr.ifr_addr;
53
54                 if (ioctl(net_fd, SIOCGIFFLAGS, &ifr) < 0)
55                         perror("SIOCGIFFLAGS");
56
57                 ifr.ifr_flags |= IFF_UP;
58                 if (ioctl(net_fd, SIOCSIFFLAGS, &ifr) < 0)
59                         perror("SIOCSIFFLAGS");
60
61                 addr->sin_family = AF_INET;
62                 addr->sin_addr.s_addr = inet_addr(vpninfo->vpn_addr);
63                 if (ioctl(net_fd, SIOCSIFADDR, &ifr) < 0)
64                         perror("SIOCSIFADDR");
65
66                 addr->sin_addr.s_addr = inet_addr(vpninfo->vpn_netmask);
67                 if (ioctl(net_fd, SIOCSIFNETMASK, &ifr) < 0)
68                         perror("SIOCSIFNETMASK");
69         }
70
71         ifr.ifr_mtu = vpninfo->mtu;
72         if (ioctl(net_fd, SIOCSIFMTU, &ifr) < 0)
73                 perror("SIOCSIFMTU");
74
75         close(net_fd);
76
77         return 0;
78 }
79
80 static int setenv_int(const char *opt, int value)
81 {
82         char buf[16];
83         sprintf(buf, "%d", value);
84         return setenv(opt, buf, 1);
85 }
86
87 static int appendenv(const char *opt, const char *new)
88 {
89         char buf[1024];
90         char *old = getenv(opt);
91
92         buf[1023] = 0;
93         if (old)
94                 snprintf(buf, 1023, "%s %s", old, new);
95         else
96                 snprintf(buf, 1023, "%s", new);
97
98         return setenv(opt, buf, 1);
99 }
100
101 static int script_config_tun(struct openconnect_info *vpninfo)
102 {
103         struct sockaddr_in *sin = (void *)vpninfo->peer_addr;
104
105         if (vpninfo->peer_addr->sa_family != AF_INET) {
106                 vpninfo->progress(vpninfo, PRG_ERR, "Script cannot handle anything but Legacy IP\n");
107                 return -EINVAL;
108         }
109
110         setenv("VPNGATEWAY", inet_ntoa(sin->sin_addr), 1);
111         setenv("TUNDEV", vpninfo->ifname, 1);
112         setenv("reason", "connect", 1);
113         unsetenv("CISCO_BANNER");
114         unsetenv("CISCO_SPLIT_INC");
115
116         setenv_int("INTERNAL_IP4_MTU", vpninfo->mtu);
117
118         setenv("INTERNAL_IP4_ADDRESS", vpninfo->vpn_addr, 1);
119         setenv("INTERNAL_IP4_NETMASK", vpninfo->vpn_netmask, 1);
120         
121         if (vpninfo->vpn_dns[0])
122                 setenv("INTERNAL_IP4_DNS", vpninfo->vpn_dns[0], 1);
123         else
124                 unsetenv("INTERNAL_IP4_DNS");
125         if (vpninfo->vpn_dns[1])
126                 appendenv("INTERNAL_IP4_DNS", vpninfo->vpn_dns[1]);
127         if (vpninfo->vpn_dns[2])
128                 appendenv("INTERNAL_IP4_DNS", vpninfo->vpn_dns[2]);
129
130         if (vpninfo->vpn_nbns[0])
131                 setenv("INTERNAL_IP4_NBNS", vpninfo->vpn_nbns[0], 1);
132         else
133                 unsetenv("INTERNAL_IP4_NBNS");
134         if (vpninfo->vpn_nbns[1])
135                 appendenv("INTERNAL_IP4_NBNS", vpninfo->vpn_nbns[1]);
136         if (vpninfo->vpn_nbns[2])
137                 appendenv("INTERNAL_IP4_NBNS", vpninfo->vpn_nbns[2]);
138
139         if (vpninfo->vpn_domain)
140                 setenv("CISCO_DEF_DOMAIN", vpninfo->vpn_domain, 1);
141         else unsetenv ("CISCO_DEF_DOMAIN");
142
143         system(vpninfo->vpnc_script);
144         return 0;
145 }
146
147
148 /* Set up a tuntap device. */
149 int setup_tun(struct openconnect_info *vpninfo)
150 {
151         struct ifreq ifr;
152         int tun_fd;
153         int pfd;
154
155         tun_fd = open("/dev/net/tun", O_RDWR);
156         if (tun_fd < 0) {
157                 perror("open tun");
158                 exit(1);
159         }
160         memset(&ifr, 0, sizeof(ifr));
161         ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
162         if (vpninfo->ifname)
163                 strncpy(ifr.ifr_name, vpninfo->ifname,
164                         sizeof(ifr.ifr_name) - 1);
165         if (ioctl(tun_fd, TUNSETIFF, (void *) &ifr) < 0) {
166                 perror("TUNSETIFF");
167                 exit(1);
168         }
169         if (!vpninfo->ifname)
170                 vpninfo->ifname = strdup(ifr.ifr_name);
171
172         fcntl(tun_fd, F_SETFD, FD_CLOEXEC);
173
174         if (vpninfo->vpnc_script) {
175                 script_config_tun(vpninfo);
176                 /* We have to set the MTU for ourselves, because the script doesn't */
177                 local_config_tun(vpninfo, 1);
178         } else
179                 local_config_tun(vpninfo, 0);
180
181         /* Better still, use lwip and just provide a SOCKS server rather than
182            telling the kernel about it at all */
183         vpninfo->tun_fd = tun_fd;
184         pfd = vpn_add_pollfd(vpninfo, vpninfo->tun_fd, POLLIN);
185
186         fcntl(vpninfo->tun_fd, F_SETFL, fcntl(vpninfo->tun_fd, F_GETFL) | O_NONBLOCK);
187
188         return 0;
189 }
190
191 int tun_mainloop(struct openconnect_info *vpninfo, int *timeout)
192 {
193         char buf[2000];
194         int len;
195         int work_done = 0;
196
197         while ( (len = read(vpninfo->tun_fd, buf, sizeof(buf))) > 0) {
198                 queue_new_packet(&vpninfo->outgoing_queue, AF_INET, buf, len);
199                 work_done = 1;
200         }
201
202         /* The kernel returns -ENOMEM when the queue is full, so theoretically
203            we could handle that and retry... but it doesn't let us poll() for
204            the no-longer-full situation, so let's not bother. */
205         while (vpninfo->incoming_queue) {
206                 struct pkt *this = vpninfo->incoming_queue;
207                 vpninfo->incoming_queue = this->next;
208                 write(vpninfo->tun_fd, this->data, this->len);
209         }
210         /* Work is not done if we just got rid of packets off the queue */
211         return work_done;
212 }