1 |
dpavlin |
1 |
/* |
2 |
|
|
* Cisco 7200 (Predator) simulation platform. |
3 |
|
|
* Copyright (c) 2006 Christophe Fillot (cf@utc.fr) |
4 |
|
|
* |
5 |
|
|
* NetIO bridges. |
6 |
|
|
*/ |
7 |
|
|
|
8 |
|
|
#include <stdio.h> |
9 |
|
|
#include <stdlib.h> |
10 |
|
|
#include <string.h> |
11 |
|
|
#include <unistd.h> |
12 |
|
|
#include <pthread.h> |
13 |
|
|
#include <errno.h> |
14 |
|
|
#include <sys/select.h> |
15 |
|
|
#include <sys/time.h> |
16 |
|
|
#include <sys/types.h> |
17 |
|
|
|
18 |
|
|
#include "utils.h" |
19 |
|
|
#include "registry.h" |
20 |
|
|
#include "net_io.h" |
21 |
|
|
#include "net_io_bridge.h" |
22 |
|
|
|
23 |
|
|
#define PKT_MAX_SIZE 2048 |
24 |
|
|
|
25 |
|
|
/* Receive a packet */ |
26 |
|
|
static int netio_bridge_recv_pkt(netio_desc_t *nio,u_char *pkt,ssize_t pkt_len, |
27 |
|
|
netio_bridge_t *t) |
28 |
|
|
{ |
29 |
|
|
int i; |
30 |
|
|
|
31 |
|
|
NETIO_BRIDGE_LOCK(t); |
32 |
|
|
|
33 |
|
|
for(i=0;i<NETIO_BRIDGE_MAX_NIO;i++) |
34 |
|
|
if ((t->nio[i] != NULL) && (t->nio[i] != nio)) |
35 |
|
|
netio_send(t->nio[i],pkt,pkt_len); |
36 |
|
|
|
37 |
|
|
NETIO_BRIDGE_UNLOCK(t); |
38 |
|
|
return(0); |
39 |
|
|
} |
40 |
|
|
|
41 |
|
|
/* Acquire a reference to NetIO bridge from the registry (inc ref count) */ |
42 |
|
|
netio_desc_t *netio_bridge_acquire(char *name) |
43 |
|
|
{ |
44 |
|
|
return(registry_find(name,OBJ_TYPE_NIO_BRIDGE)); |
45 |
|
|
} |
46 |
|
|
|
47 |
|
|
/* Release a NetIO bridge (decrement reference count) */ |
48 |
|
|
int netio_bridge_release(char *name) |
49 |
|
|
{ |
50 |
|
|
return(registry_unref(name,OBJ_TYPE_NIO_BRIDGE)); |
51 |
|
|
} |
52 |
|
|
|
53 |
|
|
/* Create a virtual bridge */ |
54 |
|
|
netio_bridge_t *netio_bridge_create(char *name) |
55 |
|
|
{ |
56 |
|
|
netio_bridge_t *t; |
57 |
|
|
|
58 |
|
|
/* Allocate a new bridge structure */ |
59 |
|
|
if (!(t = malloc(sizeof(*t)))) |
60 |
|
|
return NULL; |
61 |
|
|
|
62 |
|
|
memset(t,0,sizeof(*t)); |
63 |
|
|
pthread_mutex_init(&t->lock,NULL); |
64 |
|
|
|
65 |
|
|
if (!(t->name = strdup(name))) |
66 |
|
|
goto err_name; |
67 |
|
|
|
68 |
|
|
/* Record this object in registry */ |
69 |
|
|
if (registry_add(t->name,OBJ_TYPE_NIO_BRIDGE,t) == -1) { |
70 |
|
|
fprintf(stderr,"netio_bridge_create: unable to register bridge '%s'\n", |
71 |
|
|
name); |
72 |
|
|
goto err_reg; |
73 |
|
|
} |
74 |
|
|
|
75 |
|
|
return t; |
76 |
|
|
|
77 |
|
|
err_reg: |
78 |
|
|
free(t->name); |
79 |
|
|
err_name: |
80 |
|
|
free(t); |
81 |
|
|
return NULL; |
82 |
|
|
} |
83 |
|
|
|
84 |
|
|
/* Add a NetIO descriptor to a virtual bridge */ |
85 |
|
|
int netio_bridge_add_netio(netio_bridge_t *t,char *nio_name) |
86 |
|
|
{ |
87 |
|
|
netio_desc_t *nio; |
88 |
|
|
int i; |
89 |
|
|
|
90 |
|
|
NETIO_BRIDGE_LOCK(t); |
91 |
|
|
|
92 |
|
|
/* Try to find a free slot in the NIO array */ |
93 |
|
|
for(i=0;i<NETIO_BRIDGE_MAX_NIO;i++) |
94 |
|
|
if (t->nio[i] == NULL) |
95 |
|
|
break; |
96 |
|
|
|
97 |
|
|
/* No free slot found ... */ |
98 |
|
|
if (i == NETIO_BRIDGE_MAX_NIO) |
99 |
|
|
goto error; |
100 |
|
|
|
101 |
|
|
/* Acquire the NIO descriptor and increment its reference count */ |
102 |
|
|
if (!(nio = netio_acquire(nio_name))) |
103 |
|
|
goto error; |
104 |
|
|
|
105 |
|
|
t->nio[i] = nio; |
106 |
|
|
netio_rxl_add(nio,(netio_rx_handler_t)netio_bridge_recv_pkt,t,NULL); |
107 |
|
|
NETIO_BRIDGE_UNLOCK(t); |
108 |
|
|
return(0); |
109 |
|
|
|
110 |
|
|
error: |
111 |
|
|
NETIO_BRIDGE_UNLOCK(t); |
112 |
|
|
return(-1); |
113 |
|
|
} |
114 |
|
|
|
115 |
|
|
/* Free resources used by a NIO in a bridge */ |
116 |
|
|
static void netio_bridge_free_nio(netio_desc_t *nio) |
117 |
|
|
{ |
118 |
|
|
netio_rxl_remove(nio); |
119 |
|
|
netio_release(nio->name); |
120 |
|
|
} |
121 |
|
|
|
122 |
|
|
/* Remove a NetIO descriptor from a virtual bridge */ |
123 |
|
|
int netio_bridge_remove_netio(netio_bridge_t *t,char *nio_name) |
124 |
|
|
{ |
125 |
|
|
netio_desc_t *nio; |
126 |
|
|
int i; |
127 |
|
|
|
128 |
|
|
NETIO_BRIDGE_LOCK(t); |
129 |
|
|
|
130 |
|
|
if (!(nio = registry_exists(nio_name,OBJ_TYPE_NIO))) |
131 |
|
|
goto error; |
132 |
|
|
|
133 |
|
|
/* Try to find the NIO in the NIO array */ |
134 |
|
|
for(i=0;i<NETIO_BRIDGE_MAX_NIO;i++) |
135 |
|
|
if (t->nio[i] == nio) |
136 |
|
|
break; |
137 |
|
|
|
138 |
|
|
if (i == NETIO_BRIDGE_MAX_NIO) |
139 |
|
|
goto error; |
140 |
|
|
|
141 |
|
|
/* Remove the NIO from the RX multiplexer */ |
142 |
|
|
netio_bridge_free_nio(t->nio[i]); |
143 |
|
|
t->nio[i] = NULL; |
144 |
|
|
|
145 |
|
|
NETIO_BRIDGE_UNLOCK(t); |
146 |
|
|
return(0); |
147 |
|
|
|
148 |
|
|
error: |
149 |
|
|
NETIO_BRIDGE_UNLOCK(t); |
150 |
|
|
return(-1); |
151 |
|
|
} |
152 |
|
|
|
153 |
|
|
/* Save the configuration of a bridge */ |
154 |
|
|
void netio_bridge_save_config(netio_bridge_t *t,FILE *fd) |
155 |
|
|
{ |
156 |
|
|
int i; |
157 |
|
|
|
158 |
|
|
fprintf(fd,"nio_bridge create %s\n",t->name); |
159 |
|
|
|
160 |
|
|
for(i=0;i<NETIO_BRIDGE_MAX_NIO;i++) |
161 |
|
|
fprintf(fd,"nio_bridge add_nio %s %s\n",t->name,t->nio[i]->name); |
162 |
|
|
|
163 |
|
|
fprintf(fd,"\n"); |
164 |
|
|
} |
165 |
|
|
|
166 |
|
|
/* Save configurations of all NIO bridges */ |
167 |
|
|
static void netio_bridge_reg_save_config(registry_entry_t *entry, |
168 |
|
|
void *opt,int *err) |
169 |
|
|
{ |
170 |
|
|
netio_bridge_save_config((netio_bridge_t *)entry->data,(FILE *)opt); |
171 |
|
|
} |
172 |
|
|
|
173 |
|
|
void netio_bridge_save_config_all(FILE *fd) |
174 |
|
|
{ |
175 |
|
|
registry_foreach_type(OBJ_TYPE_NIO_BRIDGE,netio_bridge_reg_save_config, |
176 |
|
|
fd,NULL); |
177 |
|
|
} |
178 |
|
|
|
179 |
|
|
/* Free resources used by a NIO bridge */ |
180 |
|
|
static int netio_bridge_free(void *data,void *arg) |
181 |
|
|
{ |
182 |
|
|
netio_bridge_t *t = data; |
183 |
|
|
int i; |
184 |
|
|
|
185 |
|
|
NETIO_BRIDGE_LOCK(t); |
186 |
|
|
|
187 |
|
|
for(i=0;i<NETIO_BRIDGE_MAX_NIO;i++) { |
188 |
|
|
if (!t->nio[i]) |
189 |
|
|
continue; |
190 |
|
|
|
191 |
|
|
netio_bridge_free_nio(t->nio[i]); |
192 |
|
|
} |
193 |
|
|
|
194 |
|
|
NETIO_BRIDGE_UNLOCK(t); |
195 |
|
|
free(t->name); |
196 |
|
|
free(t); |
197 |
|
|
return(TRUE); |
198 |
|
|
} |
199 |
|
|
|
200 |
|
|
/* Delete a virtual bridge */ |
201 |
|
|
int netio_bridge_delete(char *name) |
202 |
|
|
{ |
203 |
|
|
return(registry_delete_if_unused(name,OBJ_TYPE_NIO_BRIDGE, |
204 |
|
|
netio_bridge_free,NULL)); |
205 |
|
|
} |
206 |
|
|
|
207 |
|
|
/* Delete all virtual bridges */ |
208 |
|
|
int netio_bridge_delete_all(void) |
209 |
|
|
{ |
210 |
|
|
return(registry_delete_type(OBJ_TYPE_NIO_BRIDGE,netio_bridge_free,NULL)); |
211 |
|
|
} |
212 |
|
|
|
213 |
|
|
/* Create a new interface */ |
214 |
|
|
static int netio_bridge_cfg_create_if(netio_bridge_t *t, |
215 |
|
|
char **tokens,int count) |
216 |
|
|
{ |
217 |
|
|
netio_desc_t *nio = NULL; |
218 |
|
|
int nio_type; |
219 |
|
|
|
220 |
|
|
nio_type = netio_get_type(tokens[1]); |
221 |
|
|
switch(nio_type) { |
222 |
|
|
case NETIO_TYPE_UNIX: |
223 |
|
|
if (count != 4) { |
224 |
|
|
fprintf(stderr,"NETIO_BRIDGE: invalid number of arguments " |
225 |
|
|
"for UNIX NIO\n"); |
226 |
|
|
break; |
227 |
|
|
} |
228 |
|
|
|
229 |
|
|
nio = netio_desc_create_unix(tokens[0],tokens[2],tokens[3]); |
230 |
|
|
break; |
231 |
|
|
|
232 |
|
|
case NETIO_TYPE_TAP: |
233 |
|
|
if (count != 3) { |
234 |
|
|
fprintf(stderr,"NETIO_BRIDGE: invalid number of arguments " |
235 |
|
|
"for TAP NIO\n"); |
236 |
|
|
break; |
237 |
|
|
} |
238 |
|
|
|
239 |
|
|
nio = netio_desc_create_tap(tokens[0],tokens[2]); |
240 |
|
|
break; |
241 |
|
|
|
242 |
|
|
case NETIO_TYPE_UDP: |
243 |
|
|
if (count != 5) { |
244 |
|
|
fprintf(stderr,"NETIO_BRIDGE: invalid number of arguments " |
245 |
|
|
"for UDP NIO\n"); |
246 |
|
|
break; |
247 |
|
|
} |
248 |
|
|
|
249 |
|
|
nio = netio_desc_create_udp(tokens[0],atoi(tokens[2]), |
250 |
|
|
tokens[3],atoi(tokens[4])); |
251 |
|
|
break; |
252 |
|
|
|
253 |
|
|
case NETIO_TYPE_TCP_CLI: |
254 |
|
|
if (count != 4) { |
255 |
|
|
fprintf(stderr,"NETIO_BRIDGE: invalid number of arguments " |
256 |
|
|
"for TCP CLI NIO\n"); |
257 |
|
|
break; |
258 |
|
|
} |
259 |
|
|
|
260 |
|
|
nio = netio_desc_create_tcp_cli(tokens[0],tokens[2],tokens[3]); |
261 |
|
|
break; |
262 |
|
|
|
263 |
|
|
case NETIO_TYPE_TCP_SER: |
264 |
|
|
if (count != 3) { |
265 |
|
|
fprintf(stderr,"NETIO_BRIDGE: invalid number of arguments " |
266 |
|
|
"for TCP SER NIO\n"); |
267 |
|
|
break; |
268 |
|
|
} |
269 |
|
|
|
270 |
|
|
nio = netio_desc_create_tcp_ser(tokens[0],tokens[2]); |
271 |
|
|
break; |
272 |
|
|
|
273 |
|
|
#ifdef GEN_ETH |
274 |
|
|
case NETIO_TYPE_GEN_ETH: |
275 |
|
|
if (count != 3) { |
276 |
|
|
fprintf(stderr,"NETIO_BRIDGE: invalid number of arguments " |
277 |
|
|
"for Generic Ethernet NIO\n"); |
278 |
|
|
break; |
279 |
|
|
} |
280 |
|
|
|
281 |
|
|
nio = netio_desc_create_geneth(tokens[0],tokens[2]); |
282 |
|
|
break; |
283 |
|
|
#endif |
284 |
|
|
|
285 |
|
|
#ifdef LINUX_ETH |
286 |
|
|
case NETIO_TYPE_LINUX_ETH: |
287 |
|
|
if (count != 3) { |
288 |
|
|
fprintf(stderr,"NETIO_BRIDGE: invalid number of arguments " |
289 |
|
|
"for Linux Ethernet NIO\n"); |
290 |
|
|
break; |
291 |
|
|
} |
292 |
|
|
|
293 |
|
|
nio = netio_desc_create_lnxeth(tokens[0],tokens[2]); |
294 |
|
|
break; |
295 |
|
|
#endif |
296 |
|
|
|
297 |
|
|
default: |
298 |
|
|
fprintf(stderr,"NETIO_BRIDGE: unknown/invalid NETIO type '%s'\n", |
299 |
|
|
tokens[1]); |
300 |
|
|
} |
301 |
|
|
|
302 |
|
|
if (!nio) { |
303 |
|
|
fprintf(stderr,"NETIO_BRIDGE: unable to create NETIO descriptor\n"); |
304 |
|
|
return(-1); |
305 |
|
|
} |
306 |
|
|
|
307 |
|
|
if (netio_bridge_add_netio(t,tokens[0]) == -1) { |
308 |
|
|
fprintf(stderr,"NETIO_BRIDGE: unable to add NETIO descriptor.\n"); |
309 |
|
|
netio_release(nio->name); |
310 |
|
|
return(-1); |
311 |
|
|
} |
312 |
|
|
|
313 |
|
|
netio_release(nio->name); |
314 |
|
|
return(0); |
315 |
|
|
} |
316 |
|
|
|
317 |
|
|
#define NETIO_BRIDGE_MAX_TOKENS 16 |
318 |
|
|
|
319 |
|
|
/* Handle a configuration line */ |
320 |
|
|
static int netio_bridge_handle_cfg_line(netio_bridge_t *t,char *str) |
321 |
|
|
{ |
322 |
|
|
char *tokens[NETIO_BRIDGE_MAX_TOKENS]; |
323 |
|
|
int count; |
324 |
|
|
|
325 |
|
|
if ((count = m_strsplit(str,':',tokens,NETIO_BRIDGE_MAX_TOKENS)) <= 2) |
326 |
|
|
return(-1); |
327 |
|
|
|
328 |
|
|
return(netio_bridge_cfg_create_if(t,tokens,count)); |
329 |
|
|
} |
330 |
|
|
|
331 |
|
|
/* Read a configuration file */ |
332 |
|
|
static int netio_bridge_read_cfg_file(netio_bridge_t *t,char *filename) |
333 |
|
|
{ |
334 |
|
|
char buffer[1024],*ptr; |
335 |
|
|
FILE *fd; |
336 |
|
|
|
337 |
|
|
if (!(fd = fopen(filename,"r"))) { |
338 |
|
|
perror("fopen"); |
339 |
|
|
return(-1); |
340 |
|
|
} |
341 |
|
|
|
342 |
|
|
while(!feof(fd)) { |
343 |
|
|
if (!fgets(buffer,sizeof(buffer),fd)) |
344 |
|
|
break; |
345 |
|
|
|
346 |
|
|
/* skip comments and end of line */ |
347 |
|
|
if ((ptr = strpbrk(buffer,"#\r\n")) != NULL) |
348 |
|
|
*ptr = 0; |
349 |
|
|
|
350 |
|
|
/* analyze non-empty lines */ |
351 |
|
|
if (strchr(buffer,':')) |
352 |
|
|
netio_bridge_handle_cfg_line(t,buffer); |
353 |
|
|
} |
354 |
|
|
|
355 |
|
|
fclose(fd); |
356 |
|
|
return(0); |
357 |
|
|
} |
358 |
|
|
|
359 |
|
|
/* Start a virtual bridge */ |
360 |
|
|
int netio_bridge_start(char *filename) |
361 |
|
|
{ |
362 |
|
|
netio_bridge_t *t; |
363 |
|
|
|
364 |
|
|
if (!(t = netio_bridge_create("default"))) { |
365 |
|
|
fprintf(stderr,"NETIO_BRIDGE: unable to create virtual fabric table.\n"); |
366 |
|
|
return(-1); |
367 |
|
|
} |
368 |
|
|
|
369 |
|
|
if (netio_bridge_read_cfg_file(t,filename) == -1) { |
370 |
|
|
fprintf(stderr,"NETIO_BRIDGE: unable to parse configuration file.\n"); |
371 |
|
|
return(-1); |
372 |
|
|
} |
373 |
|
|
|
374 |
|
|
netio_bridge_release("default"); |
375 |
|
|
return(0); |
376 |
|
|
} |