tincd/uml_socket/device.c

/*
    device.c -- UML network socket
    Copyright (C) 2002-2004 Ivo Timmermans <ivo@tinc-vpn.org>,
                  2002-2004 Guus Sliepen <guus@tinc-vpn.org>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    $Id: device.c 1374 2004-03-21 14:21:22Z guus $
*/

#include <time.h>
#include <sys/time.h>
#include <sys/un.h>

int device_fd = -1;
static int listen_fd = -1;
static int request_fd = -1;
static int data_fd = -1;
static int write_fd = -1;
static int state = 0;
char *device;
char *iface = NULL;
char *device_info;

bool running;

static int device_total_in = 0;
static int device_total_out = 0;

enum request_type { REQ_NEW_CONTROL };

static struct request {
  uint32_t magic;
  uint32_t version;
  enum request_type type;
  struct sockaddr_un sock;
} request;

static struct sockaddr_un data_sun;

bool setup_device(void)
{
        struct sockaddr_un listen_sun;
        static const int one = 1;
        struct {
                char zero;
                int pid;
                int usecs;
        } name;
        struct timeval tv;

        cp();

        if(!get_config_string(lookup_config(config_tree, "Device"), &device))
                return false;

        get_config_string(lookup_config(config_tree, "Interface"), &iface);

        device_info = _("UML network socket");

        if((write_fd = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0) {
                logger(LOG_ERR, _("Could not open write %s: %s"), device_info, strerror(errno));
                running = false;
                return false;
        }

        setsockopt(write_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);

        if(fcntl(write_fd, F_SETFL, O_NONBLOCK) < 0) {
                logger(LOG_ERR, _("System call `%s' failed: %s"), "fcntl", strerror(errno));
                running = false;
                return false;
        }

        if((data_fd = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0) {
                logger(LOG_ERR, _("Could not open data %s: %s"), device_info, strerror(errno));
                running = false;
                return false;
        }

        setsockopt(data_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);

        if(fcntl(data_fd, F_SETFL, O_NONBLOCK) < 0) {
                logger(LOG_ERR, _("System call `%s' failed: %s"), "fcntl", strerror(errno));
                running = false;
                return false;
        }

        name.zero = 0;
        name.pid = getpid();
        gettimeofday(&tv, NULL);
        name.usecs = tv.tv_usec;
        data_sun.sun_family = AF_UNIX;
        memcpy(&data_sun.sun_path, &name, sizeof name);
        
        if(bind(data_fd, (struct sockaddr *)&data_sun, sizeof data_sun) < 0) {
                logger(LOG_ERR, _("Could not bind data %s: %s"), device_info, strerror(errno));
                running = false;
                return false;
        }

        if((listen_fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
                logger(LOG_ERR, _("Could not open %s: %s"), device_info,
                           strerror(errno));
                return false;
        }

        setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);

        if(fcntl(listen_fd, F_SETFL, O_NONBLOCK) < 0) {
                logger(LOG_ERR, _("System call `%s' failed: %s"), "fcntl", strerror(errno));
                return false;
        }

        listen_sun.sun_family = AF_UNIX;
        strncpy(listen_sun.sun_path, device, sizeof listen_sun.sun_path);
        if(bind(listen_fd, (struct sockaddr *)&listen_sun, sizeof listen_sun) < 0) {
                logger(LOG_ERR, _("Could not bind %s to %s: %s"), device_info, device, strerror(errno));
                return false;
        }

        if(listen(listen_fd, 1) < 0) {
                logger(LOG_ERR, _("Could not listen on %s %s: %s"), device_info, device, strerror(errno));
                return false;
        }

        device_fd = listen_fd;
        state = 0;

        logger(LOG_INFO, _("%s is a %s"), device, device_info);

        if(routing_mode == RMODE_ROUTER)
                overwrite_mac = true;

        return true;
}

void close_device(void)
{
        cp();

        if(listen_fd >= 0)
                close(listen_fd);

        if(request_fd >= 0)
                close(request_fd);

        if(data_fd >= 0)
                close(data_fd);

        if(write_fd >= 0)
                close(write_fd);

        unlink(device);
}

bool read_packet(vpn_packet_t *packet)
{
        int lenin;

        cp();

        switch(state) {
                case 0: {
                        struct sockaddr sa;
                        socklen_t salen = sizeof sa;

                        request_fd = accept(listen_fd, &sa, &salen);
                        if(request_fd < 0) {
                                logger(LOG_ERR, _("Could not accept connection to %s %s: %s"), device_info, device, strerror(errno));
                                return false;
                        }

                        if(fcntl(listen_fd, F_SETFL, O_NONBLOCK) < 0) {
                                logger(LOG_ERR, _("System call `%s' failed: %s"), "fcntl", strerror(errno));
                                running = false;
                                return false;
                        }

                        close(listen_fd);
                        listen_fd = -1;
                        device_fd = request_fd;
                        state = 1;

                        return false;
                }

                case 1: {
                        if((lenin = read(request_fd, &request, sizeof request)) != sizeof request) {
                                logger(LOG_ERR, _("Error while reading request from %s %s: %s"), device_info,
                                           device, strerror(errno));
                                running = false;
                                return false;
                        }

                        if(request.magic != 0xfeedface || request.version != 3 || request.type != REQ_NEW_CONTROL) {
                                logger(LOG_ERR, _("Unknown magic %x, version %d, request type %d from %s %s"),
                                                request.magic, request.version, request.type, device_info, device);
                                running = false;
                                return false;
                        }

                        if(connect(write_fd, (sockaddr *)&request.sock, sizeof request.sock) < 0) {
                                logger(LOG_ERR, _("Could not bind write %s: %s"), device_info, strerror(errno));
                                running = false;
                                return false;
                        }

                        write(request_fd, &data_sun, sizeof data_sun);
                        device_fd = data_fd;

                        logger(LOG_INFO, _("Connection with UML established"));

                        state = 2;
                        return false;
                }

                case 2: {
                        if((lenin = read(data_fd, packet->data, MTU)) <= 0) {
                                logger(LOG_ERR, _("Error while reading from %s %s: %s"), device_info,
                                           device, strerror(errno));
                                running = false;
                                return false;
                        }

                        packet->len = lenin;

                        device_total_in += packet->len;

                        ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Read packet of %d bytes from %s"), packet->len,
                                           device_info);

                        return true;
                }
        }
}

bool write_packet(vpn_packet_t *packet)
{
        cp();

        if(state != 2) {
                ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Dropping packet of %d bytes to %s: not connected to UML yet"),
                                packet->len, device_info);
                return false;
        }

        ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Writing packet of %d bytes to %s"),
                           packet->len, device_info);

        if(write(write_fd, packet->data, packet->len) < 0) {
                if(errno != EINTR && errno != EAGAIN) {
                        logger(LOG_ERR, _("Can't write to %s %s: %s"), device_info, device, strerror(errno));
                        running = false;
                }

                return false;
        }

        device_total_out += packet->len;

        return true;
}

void dump_device_stats(void)
{
        cp();

        logger(LOG_DEBUG, _("Statistics for %s %s:"), device_info, device);
        logger(LOG_DEBUG, _(" total bytes in:  %10d"), device_total_in);
        logger(LOG_DEBUG, _(" total bytes out: %10d"), device_total_out);
}
Revision:	1.1
Committed:	Thu Mar 17 23:59:38 2005 UTC (19 years, 3 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-1_9, rel-1_8, rel-2_01, rel-3_0, rel-2_2, rel-2_0, rel-2_21, rel-2_22, rel-2_25, HEAD
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	/*
2			device.c -- UML network socket
3			Copyright (C) 2002-2004 Ivo Timmermans <ivo@tinc-vpn.org>,
4			2002-2004 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
17			along with this program; if not, write to the Free Software
18			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20			$Id: device.c 1374 2004-03-21 14:21:22Z guus $
21			*/
22
23			#include <time.h>
24			#include <sys/time.h>
25			#include <sys/un.h>
26
27			int device_fd = -1;
28			static int listen_fd = -1;
29			static int request_fd = -1;
30			static int data_fd = -1;
31			static int write_fd = -1;
32			static int state = 0;
33			char *device;
34			char *iface = NULL;
35			char *device_info;
36
37			bool running;
38
39			static int device_total_in = 0;
40			static int device_total_out = 0;
41
42			enum request_type { REQ_NEW_CONTROL };
43
44			static struct request {
45			uint32_t magic;
46			uint32_t version;
47			enum request_type type;
48			struct sockaddr_un sock;
49			} request;
50
51			static struct sockaddr_un data_sun;
52
53			bool setup_device(void)
54			{
55			struct sockaddr_un listen_sun;
56			static const int one = 1;
57			struct {
58			char zero;
59			int pid;
60			int usecs;
61			} name;
62			struct timeval tv;
63
64			cp();
65
66			if(!get_config_string(lookup_config(config_tree, "Device"), &device))
67			return false;
68
69			get_config_string(lookup_config(config_tree, "Interface"), &iface);
70
71			device_info = _("UML network socket");
72
73			if((write_fd = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0) {
74			logger(LOG_ERR, _("Could not open write %s: %s"), device_info, strerror(errno));
75			running = false;
76			return false;
77			}
78
79			setsockopt(write_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
80
81			if(fcntl(write_fd, F_SETFL, O_NONBLOCK) < 0) {
82			logger(LOG_ERR, _("System call `%s' failed: %s"), "fcntl", strerror(errno));
83			running = false;
84			return false;
85			}
86
87			if((data_fd = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0) {
88			logger(LOG_ERR, _("Could not open data %s: %s"), device_info, strerror(errno));
89			running = false;
90			return false;
91			}
92
93			setsockopt(data_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
94
95			if(fcntl(data_fd, F_SETFL, O_NONBLOCK) < 0) {
96			logger(LOG_ERR, _("System call `%s' failed: %s"), "fcntl", strerror(errno));
97			running = false;
98			return false;
99			}
100
101			name.zero = 0;
102			name.pid = getpid();
103			gettimeofday(&tv, NULL);
104			name.usecs = tv.tv_usec;
105			data_sun.sun_family = AF_UNIX;
106			memcpy(&data_sun.sun_path, &name, sizeof name);
107
108			if(bind(data_fd, (struct sockaddr *)&data_sun, sizeof data_sun) < 0) {
109			logger(LOG_ERR, _("Could not bind data %s: %s"), device_info, strerror(errno));
110			running = false;
111			return false;
112			}
113
114			if((listen_fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
115			logger(LOG_ERR, _("Could not open %s: %s"), device_info,
116			strerror(errno));
117			return false;
118			}
119
120			setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
121
122			if(fcntl(listen_fd, F_SETFL, O_NONBLOCK) < 0) {
123			logger(LOG_ERR, _("System call `%s' failed: %s"), "fcntl", strerror(errno));
124			return false;
125			}
126
127			listen_sun.sun_family = AF_UNIX;
128			strncpy(listen_sun.sun_path, device, sizeof listen_sun.sun_path);
129			if(bind(listen_fd, (struct sockaddr *)&listen_sun, sizeof listen_sun) < 0) {
130			logger(LOG_ERR, _("Could not bind %s to %s: %s"), device_info, device, strerror(errno));
131			return false;
132			}
133
134			if(listen(listen_fd, 1) < 0) {
135			logger(LOG_ERR, _("Could not listen on %s %s: %s"), device_info, device, strerror(errno));
136			return false;
137			}
138
139			device_fd = listen_fd;
140			state = 0;
141
142			logger(LOG_INFO, _("%s is a %s"), device, device_info);
143
144			if(routing_mode == RMODE_ROUTER)
145			overwrite_mac = true;
146
147			return true;
148			}
149
150			void close_device(void)
151			{
152			cp();
153
154			if(listen_fd >= 0)
155			close(listen_fd);
156
157			if(request_fd >= 0)
158			close(request_fd);
159
160			if(data_fd >= 0)
161			close(data_fd);
162
163			if(write_fd >= 0)
164			close(write_fd);
165
166			unlink(device);
167			}
168
169			bool read_packet(vpn_packet_t *packet)
170			{
171			int lenin;
172
173			cp();
174
175			switch(state) {
176			case 0: {
177			struct sockaddr sa;
178			socklen_t salen = sizeof sa;
179
180			request_fd = accept(listen_fd, &sa, &salen);
181			if(request_fd < 0) {
182			logger(LOG_ERR, _("Could not accept connection to %s %s: %s"), device_info, device, strerror(errno));
183			return false;
184			}
185
186			if(fcntl(listen_fd, F_SETFL, O_NONBLOCK) < 0) {
187			logger(LOG_ERR, _("System call `%s' failed: %s"), "fcntl", strerror(errno));
188			running = false;
189			return false;
190			}
191
192			close(listen_fd);
193			listen_fd = -1;
194			device_fd = request_fd;
195			state = 1;
196
197			return false;
198			}
199
200			case 1: {
201			if((lenin = read(request_fd, &request, sizeof request)) != sizeof request) {
202			logger(LOG_ERR, _("Error while reading request from %s %s: %s"), device_info,
203			device, strerror(errno));
204			running = false;
205			return false;
206			}
207
208			if(request.magic != 0xfeedface \|\| request.version != 3 \|\| request.type != REQ_NEW_CONTROL) {
209			logger(LOG_ERR, _("Unknown magic %x, version %d, request type %d from %s %s"),
210			request.magic, request.version, request.type, device_info, device);
211			running = false;
212			return false;
213			}
214
215			if(connect(write_fd, (sockaddr *)&request.sock, sizeof request.sock) < 0) {
216			logger(LOG_ERR, _("Could not bind write %s: %s"), device_info, strerror(errno));
217			running = false;
218			return false;
219			}
220
221			write(request_fd, &data_sun, sizeof data_sun);
222			device_fd = data_fd;
223
224			logger(LOG_INFO, _("Connection with UML established"));
225
226			state = 2;
227			return false;
228			}
229
230			case 2: {
231			if((lenin = read(data_fd, packet->data, MTU)) <= 0) {
232			logger(LOG_ERR, _("Error while reading from %s %s: %s"), device_info,
233			device, strerror(errno));
234			running = false;
235			return false;
236			}
237
238			packet->len = lenin;
239
240			device_total_in += packet->len;
241
242			ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Read packet of %d bytes from %s"), packet->len,
243			device_info);
244
245			return true;
246			}
247			}
248			}
249
250			bool write_packet(vpn_packet_t *packet)
251			{
252			cp();
253
254			if(state != 2) {
255			ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Dropping packet of %d bytes to %s: not connected to UML yet"),
256			packet->len, device_info);
257			return false;
258			}
259
260			ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Writing packet of %d bytes to %s"),
261			packet->len, device_info);
262
263			if(write(write_fd, packet->data, packet->len) < 0) {
264			if(errno != EINTR && errno != EAGAIN) {
265			logger(LOG_ERR, _("Can't write to %s %s: %s"), device_info, device, strerror(errno));
266			running = false;
267			}
268
269			return false;
270			}
271
272			device_total_out += packet->len;
273
274			return true;
275			}
276
277			void dump_device_stats(void)
278			{
279			cp();
280
281			logger(LOG_DEBUG, _("Statistics for %s %s:"), device_info, device);
282			logger(LOG_DEBUG, _(" total bytes in: %10d"), device_total_in);
283			logger(LOG_DEBUG, _(" total bytes out: %10d"), device_total_out);
284			}