Contents of /trunk/mkinitrd-magellan/busybox/networking/udhcp/dhcprelay.c
Parent Directory | Revision Log
Revision 532 -
(show annotations)
(download)
Sat Sep 1 22:45:15 2007 UTC (16 years, 8 months ago) by niro
File MIME type: text/plain
File size: 7854 byte(s)
Sat Sep 1 22:45:15 2007 UTC (16 years, 8 months ago) by niro
File MIME type: text/plain
File size: 7854 byte(s)
-import if magellan mkinitrd; it is a fork of redhats mkinitrd-5.0.8 with all magellan patches and features; deprecates magellan-src/mkinitrd
1 | /* vi: set sw=4 ts=4: */ |
2 | /* Port to Busybox Copyright (C) 2006 Jesse Dutton <jessedutton@gmail.com> |
3 | * |
4 | * Licensed under GPL v2, see file LICENSE in this tarball for details. |
5 | * |
6 | * DHCP Relay for 'DHCPv4 Configuration of IPSec Tunnel Mode' support |
7 | * Copyright (C) 2002 Mario Strasser <mast@gmx.net>, |
8 | * Zuercher Hochschule Winterthur, |
9 | * Netbeat AG |
10 | * Upstream has GPL v2 or later |
11 | */ |
12 | |
13 | #include "common.h" |
14 | #include "dhcpd.h" |
15 | #include "options.h" |
16 | |
17 | /* constants */ |
18 | #define SELECT_TIMEOUT 5 /* select timeout in sec. */ |
19 | #define MAX_LIFETIME 2*60 /* lifetime of an xid entry in sec. */ |
20 | #define MAX_INTERFACES 9 |
21 | |
22 | |
23 | /* This list holds information about clients. The xid_* functions manipulate this list. */ |
24 | static struct xid_item { |
25 | u_int32_t xid; |
26 | struct sockaddr_in ip; |
27 | int client; |
28 | time_t timestamp; |
29 | struct xid_item *next; |
30 | } dhcprelay_xid_list = {0, {0}, 0, 0, NULL}; |
31 | |
32 | |
33 | static struct xid_item * xid_add(u_int32_t xid, struct sockaddr_in *ip, int client) |
34 | { |
35 | struct xid_item *item; |
36 | |
37 | /* create new xid entry */ |
38 | item = xmalloc(sizeof(struct xid_item)); |
39 | |
40 | /* add xid entry */ |
41 | item->ip = *ip; |
42 | item->xid = xid; |
43 | item->client = client; |
44 | item->timestamp = time(NULL); |
45 | item->next = dhcprelay_xid_list.next; |
46 | dhcprelay_xid_list.next = item; |
47 | |
48 | return item; |
49 | } |
50 | |
51 | |
52 | static void xid_expire(void) |
53 | { |
54 | struct xid_item *item = dhcprelay_xid_list.next; |
55 | struct xid_item *last = &dhcprelay_xid_list; |
56 | time_t current_time = time(NULL); |
57 | |
58 | while (item != NULL) { |
59 | if ((current_time-item->timestamp) > MAX_LIFETIME) { |
60 | last->next = item->next; |
61 | free(item); |
62 | item = last->next; |
63 | } else { |
64 | last = item; |
65 | item = item->next; |
66 | } |
67 | } |
68 | } |
69 | |
70 | static struct xid_item * xid_find(u_int32_t xid) |
71 | { |
72 | struct xid_item *item = dhcprelay_xid_list.next; |
73 | while (item != NULL) { |
74 | if (item->xid == xid) { |
75 | return item; |
76 | } |
77 | item = item->next; |
78 | } |
79 | return NULL; |
80 | } |
81 | |
82 | static void xid_del(u_int32_t xid) |
83 | { |
84 | struct xid_item *item = dhcprelay_xid_list.next; |
85 | struct xid_item *last = &dhcprelay_xid_list; |
86 | while (item != NULL) { |
87 | if (item->xid == xid) { |
88 | last->next = item->next; |
89 | free(item); |
90 | item = last->next; |
91 | } else { |
92 | last = item; |
93 | item = item->next; |
94 | } |
95 | } |
96 | } |
97 | |
98 | |
99 | /** |
100 | * get_dhcp_packet_type - gets the message type of a dhcp packet |
101 | * p - pointer to the dhcp packet |
102 | * returns the message type on success, -1 otherwise |
103 | */ |
104 | static int get_dhcp_packet_type(struct dhcpMessage *p) |
105 | { |
106 | uint8_t *op; |
107 | |
108 | /* it must be either a BOOTREQUEST or a BOOTREPLY */ |
109 | if (p->op != BOOTREQUEST && p->op != BOOTREPLY) |
110 | return -1; |
111 | /* get message type option */ |
112 | op = get_option(p, DHCP_MESSAGE_TYPE); |
113 | if (op != NULL) |
114 | return op[0]; |
115 | return -1; |
116 | } |
117 | |
118 | /** |
119 | * signal_handler - handles signals ;-) |
120 | * sig - sent signal |
121 | */ |
122 | static int dhcprelay_stopflag; |
123 | static void dhcprelay_signal_handler(int sig) |
124 | { |
125 | dhcprelay_stopflag = 1; |
126 | } |
127 | |
128 | /** |
129 | * get_client_devices - parses the devices list |
130 | * dev_list - comma separated list of devices |
131 | * returns array |
132 | */ |
133 | static char ** get_client_devices(char *dev_list, int *client_number) |
134 | { |
135 | char *s, *list, **client_dev; |
136 | int i, cn; |
137 | |
138 | /* copy list */ |
139 | list = xstrdup(dev_list); |
140 | if (list == NULL) return NULL; |
141 | |
142 | /* get number of items */ |
143 | for (s = dev_list, cn = 1; *s; s++) |
144 | if (*s == ',') |
145 | cn++; |
146 | |
147 | client_dev = xzalloc(cn * sizeof(*client_dev)); |
148 | |
149 | /* parse list */ |
150 | s = strtok(list, ","); |
151 | i = 0; |
152 | while (s != NULL) { |
153 | client_dev[i++] = xstrdup(s); |
154 | s = strtok(NULL, ","); |
155 | } |
156 | |
157 | /* free copy and exit */ |
158 | free(list); |
159 | *client_number = cn; |
160 | return client_dev; |
161 | } |
162 | |
163 | |
164 | /* Creates listen sockets (in fds) and returns the number allocated. */ |
165 | static int init_sockets(char **client, int num_clients, |
166 | char *server, int *fds, int *max_socket) |
167 | { |
168 | int i; |
169 | |
170 | /* talk to real server on bootps */ |
171 | fds[0] = listen_socket(htonl(INADDR_ANY), 67, server); |
172 | *max_socket = fds[0]; |
173 | |
174 | /* array starts at 1 since server is 0 */ |
175 | num_clients++; |
176 | |
177 | for (i=1; i < num_clients; i++) { |
178 | /* listen for clients on bootps */ |
179 | fds[i] = listen_socket(htonl(INADDR_ANY), 67, client[i-1]); |
180 | if (fds[i] > *max_socket) *max_socket = fds[i]; |
181 | } |
182 | |
183 | return i; |
184 | } |
185 | |
186 | |
187 | /** |
188 | * pass_on() - forwards dhcp packets from client to server |
189 | * p - packet to send |
190 | * client - number of the client |
191 | */ |
192 | static void pass_on(struct dhcpMessage *p, int packet_len, int client, int *fds, |
193 | struct sockaddr_in *client_addr, struct sockaddr_in *server_addr) |
194 | { |
195 | int res, type; |
196 | struct xid_item *item; |
197 | |
198 | /* check packet_type */ |
199 | type = get_dhcp_packet_type(p); |
200 | if (type != DHCPDISCOVER && type != DHCPREQUEST |
201 | && type != DHCPDECLINE && type != DHCPRELEASE |
202 | && type != DHCPINFORM |
203 | ) { |
204 | return; |
205 | } |
206 | |
207 | /* create new xid entry */ |
208 | item = xid_add(p->xid, client_addr, client); |
209 | |
210 | /* forward request to LAN (server) */ |
211 | res = sendto(fds[0], p, packet_len, 0, (struct sockaddr*)server_addr, |
212 | sizeof(struct sockaddr_in)); |
213 | if (res != packet_len) { |
214 | bb_perror_msg("pass_on"); |
215 | return; |
216 | } |
217 | } |
218 | |
219 | /** |
220 | * pass_back() - forwards dhcp packets from server to client |
221 | * p - packet to send |
222 | */ |
223 | static void pass_back(struct dhcpMessage *p, int packet_len, int *fds) |
224 | { |
225 | int res, type; |
226 | struct xid_item *item; |
227 | |
228 | /* check xid */ |
229 | item = xid_find(p->xid); |
230 | if (!item) { |
231 | return; |
232 | } |
233 | |
234 | /* check packet type */ |
235 | type = get_dhcp_packet_type(p); |
236 | if (type != DHCPOFFER && type != DHCPACK && type != DHCPNAK) { |
237 | return; |
238 | } |
239 | |
240 | if (item->ip.sin_addr.s_addr == htonl(INADDR_ANY)) |
241 | item->ip.sin_addr.s_addr = htonl(INADDR_BROADCAST); |
242 | if (item->client > MAX_INTERFACES) |
243 | return; |
244 | res = sendto(fds[item->client], p, packet_len, 0, (struct sockaddr*)(&item->ip), |
245 | sizeof(item->ip)); |
246 | if (res != packet_len) { |
247 | bb_perror_msg("pass_back"); |
248 | return; |
249 | } |
250 | |
251 | /* remove xid entry */ |
252 | xid_del(p->xid); |
253 | } |
254 | |
255 | static void dhcprelay_loop(int *fds, int num_sockets, int max_socket, char **clients, |
256 | struct sockaddr_in *server_addr, uint32_t gw_ip) |
257 | { |
258 | struct dhcpMessage dhcp_msg; |
259 | fd_set rfds; |
260 | size_t packlen; |
261 | socklen_t addr_size; |
262 | struct sockaddr_in client_addr; |
263 | struct timeval tv; |
264 | int i; |
265 | |
266 | while (!dhcprelay_stopflag) { |
267 | FD_ZERO(&rfds); |
268 | for (i = 0; i < num_sockets; i++) |
269 | FD_SET(fds[i], &rfds); |
270 | tv.tv_sec = SELECT_TIMEOUT; |
271 | tv.tv_usec = 0; |
272 | if (select(max_socket + 1, &rfds, NULL, NULL, &tv) > 0) { |
273 | /* server */ |
274 | if (FD_ISSET(fds[0], &rfds)) { |
275 | packlen = udhcp_get_packet(&dhcp_msg, fds[0]); |
276 | if (packlen > 0) { |
277 | pass_back(&dhcp_msg, packlen, fds); |
278 | } |
279 | } |
280 | for (i = 1; i < num_sockets; i++) { |
281 | /* clients */ |
282 | if (!FD_ISSET(fds[i], &rfds)) |
283 | continue; |
284 | addr_size = sizeof(struct sockaddr_in); |
285 | packlen = recvfrom(fds[i], &dhcp_msg, sizeof(dhcp_msg), 0, |
286 | (struct sockaddr *)(&client_addr), &addr_size); |
287 | if (packlen <= 0) |
288 | continue; |
289 | if (read_interface(clients[i-1], NULL, &dhcp_msg.giaddr, NULL) < 0) |
290 | dhcp_msg.giaddr = gw_ip; |
291 | pass_on(&dhcp_msg, packlen, i, fds, &client_addr, server_addr); |
292 | } |
293 | } |
294 | xid_expire(); |
295 | } |
296 | } |
297 | |
298 | int dhcprelay_main(int argc, char **argv) |
299 | { |
300 | int i, num_sockets, max_socket, fds[MAX_INTERFACES]; |
301 | uint32_t gw_ip; |
302 | char **clients; |
303 | struct sockaddr_in server_addr; |
304 | |
305 | server_addr.sin_family = AF_INET; |
306 | server_addr.sin_port = htons(67); |
307 | if (argc == 4) { |
308 | if (!inet_aton(argv[3], &server_addr.sin_addr)) |
309 | bb_perror_msg_and_die("didn't grok server"); |
310 | } else if (argc == 3) { |
311 | server_addr.sin_addr.s_addr = htonl(INADDR_BROADCAST); |
312 | } else { |
313 | bb_show_usage(); |
314 | } |
315 | clients = get_client_devices(argv[1], &num_sockets); |
316 | if (!clients) return 0; |
317 | |
318 | signal(SIGTERM, dhcprelay_signal_handler); |
319 | signal(SIGQUIT, dhcprelay_signal_handler); |
320 | signal(SIGINT, dhcprelay_signal_handler); |
321 | |
322 | num_sockets = init_sockets(clients, num_sockets, argv[2], fds, &max_socket); |
323 | |
324 | if (read_interface(argv[2], NULL, &gw_ip, NULL) == -1) |
325 | return 1; |
326 | |
327 | dhcprelay_loop(fds, num_sockets, max_socket, clients, &server_addr, gw_ip); |
328 | |
329 | if (ENABLE_FEATURE_CLEAN_UP) { |
330 | for (i = 0; i < num_sockets; i++) { |
331 | close(fds[i]); |
332 | free(clients[i]); |
333 | } |
334 | } |
335 | |
336 | return 0; |
337 | } |