/[dynamips]/upstream/dynamips-0.2.5/net_io.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Annotation of /upstream/dynamips-0.2.5/net_io.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1 - (hide annotations)
Sat Oct 6 16:01:44 2007 UTC (12 years, 3 months ago) by dpavlin
File MIME type: text/plain
File size: 39509 byte(s)
import 0.2.5 from upstream

1 dpavlin 1 /*
2     * Cisco 7200 (Predator) simulation platform.
3     * Copyright (c) 2005,2006 Christophe Fillot (cf@utc.fr)
4     *
5     * Network Input/Output Abstraction Layer.
6     */
7    
8     /* By default, Cygwin supports only 64 FDs with select()! */
9     #ifdef __CYGWIN__
10     #define FD_SETSIZE 1024
11     #endif
12    
13     #include <stdio.h>
14     #include <stdlib.h>
15     #include <string.h>
16     #include <stdarg.h>
17     #include <unistd.h>
18     #include <errno.h>
19     #include <signal.h>
20     #include <fcntl.h>
21     #include <ctype.h>
22     #include <time.h>
23     #include <sys/time.h>
24     #include <sys/stat.h>
25     #include <sys/types.h>
26     #include <sys/ioctl.h>
27     #include <sys/socket.h>
28     #include <sys/un.h>
29     #include <sys/wait.h>
30     #include <netinet/in.h>
31     #include <arpa/inet.h>
32     #include <netdb.h>
33     #include <pthread.h>
34    
35     #ifdef __linux__
36     #include <net/if.h>
37     #include <linux/if_tun.h>
38     #endif
39    
40     #include "registry.h"
41     #include "net.h"
42     #include "net_io.h"
43     #include "net_io_filter.h"
44    
45     /* Free a NetIO descriptor */
46     static int netio_free(void *data,void *arg);
47    
48     /* NIO RX listener */
49     static pthread_mutex_t netio_rxl_mutex = PTHREAD_MUTEX_INITIALIZER;
50     static pthread_mutex_t netio_rxq_mutex = PTHREAD_MUTEX_INITIALIZER;
51     static struct netio_rx_listener *netio_rxl_list = NULL;
52     static struct netio_rx_listener *netio_rxl_add_list = NULL;
53     static netio_desc_t *netio_rxl_remove_list = NULL;
54     static pthread_t netio_rxl_thread;
55     static pthread_cond_t netio_rxl_cond;
56    
57     #define NETIO_RXL_LOCK() pthread_mutex_lock(&netio_rxl_mutex);
58     #define NETIO_RXL_UNLOCK() pthread_mutex_unlock(&netio_rxl_mutex);
59    
60     #define NETIO_RXQ_LOCK() pthread_mutex_lock(&netio_rxq_mutex);
61     #define NETIO_RXQ_UNLOCK() pthread_mutex_unlock(&netio_rxq_mutex);
62    
63     /* NetIO type */
64     typedef struct {
65     char *name;
66     char *desc;
67     }netio_type_t;
68    
69     /* NETIO types (must follow the enum definition) */
70     static netio_type_t netio_types[NETIO_TYPE_MAX] = {
71     { "unix" , "UNIX local sockets" },
72     { "vde" , "Virtual Distributed Ethernet / UML switch" },
73     { "tap" , "Linux/FreeBSD TAP device" },
74     { "udp" , "UDP sockets" },
75     { "tcp_cli" , "TCP client" },
76     { "tcp_ser" , "TCP server" },
77     #ifdef LINUX_ETH
78     { "linux_eth" , "Linux Ethernet device" },
79     #endif
80     #ifdef GEN_ETH
81     { "gen_eth" , "Generic Ethernet device (PCAP)" },
82     #endif
83     { "fifo" , "FIFO (intra-hypervisor)" },
84     { "null" , "Null device" },
85     };
86    
87     /* Get NETIO type given a description */
88     int netio_get_type(char *type)
89     {
90     int i;
91    
92     for(i=0;i<NETIO_TYPE_MAX;i++)
93     if (!strcmp(type,netio_types[i].name))
94     return(i);
95    
96     return(-1);
97     }
98    
99     /* Show the NETIO types */
100     void netio_show_types(void)
101     {
102     int i;
103    
104     printf("Available NETIO types:\n");
105    
106     for(i=0;i<NETIO_TYPE_MAX;i++)
107     printf(" * %-10s : %s\n",netio_types[i].name,netio_types[i].desc);
108    
109     printf("\n");
110     }
111    
112     /*
113     * =========================================================================
114     * Generic functions (abstraction layer)
115     * =========================================================================
116     */
117    
118     /* Acquire a reference to NIO from registry (increment reference count) */
119     netio_desc_t *netio_acquire(char *name)
120     {
121     return(registry_find(name,OBJ_TYPE_NIO));
122     }
123    
124     /* Release an NIO (decrement reference count) */
125     int netio_release(char *name)
126     {
127     return(registry_unref(name,OBJ_TYPE_NIO));
128     }
129    
130     /* Record an NIO in registry */
131     static int netio_record(netio_desc_t *nio)
132     {
133     return(registry_add(nio->name,OBJ_TYPE_NIO,nio));
134     }
135    
136     /* Create a new NetIO descriptor */
137     static netio_desc_t *netio_create(char *name)
138     {
139     netio_desc_t *nio;
140    
141     if (!(nio = malloc(sizeof(*nio))))
142     return NULL;
143    
144     /* setup as a NULL descriptor */
145     memset(nio,0,sizeof(*nio));
146     nio->type = NETIO_TYPE_NULL;
147    
148     /* save name for registry */
149     if (!(nio->name = strdup(name))) {
150     free(nio);
151     return NULL;
152     }
153    
154     return nio;
155     }
156    
157     /* Delete a NetIO descriptor */
158     int netio_delete(char *name)
159     {
160     return(registry_delete_if_unused(name,OBJ_TYPE_NIO,netio_free,NULL));
161     }
162    
163     /* Delete all NetIO descriptors */
164     int netio_delete_all(void)
165     {
166     return(registry_delete_type(OBJ_TYPE_NIO,netio_free,NULL));
167     }
168    
169     /* Save the configuration of a NetIO descriptor */
170     void netio_save_config(netio_desc_t *nio,FILE *fd)
171     {
172     if (nio->save_cfg)
173     nio->save_cfg(nio,fd);
174     }
175    
176     /* Save configurations of all NetIO descriptors */
177     static void netio_reg_save_config(registry_entry_t *entry,void *opt,int *err)
178     {
179     netio_save_config((netio_desc_t *)entry->data,(FILE *)opt);
180     }
181    
182     void netio_save_config_all(FILE *fd)
183     {
184     registry_foreach_type(OBJ_TYPE_NIO,netio_reg_save_config,fd,NULL);
185     fprintf(fd,"\n");
186     }
187    
188     /* Send a packet through a NetIO descriptor */
189     ssize_t netio_send(netio_desc_t *nio,void *pkt,size_t len)
190     {
191     int res;
192    
193     if (!nio)
194     return(-1);
195    
196     if (nio->debug) {
197     printf("NIO %s: sending a packet of %lu bytes:\n",nio->name,(u_long)len);
198     mem_dump(stdout,pkt,len);
199     }
200    
201     /* Apply the TX filter */
202     if (nio->tx_filter != NULL) {
203     res = nio->tx_filter->pkt_handler(nio,pkt,len,nio->tx_filter_data);
204    
205     if (res <= 0)
206     return(-1);
207     }
208    
209     return(nio->send(nio->dptr,pkt,len));
210     }
211    
212     /* Receive a packet through a NetIO descriptor */
213     ssize_t netio_recv(netio_desc_t *nio,void *pkt,size_t max_len)
214     {
215     ssize_t len;
216     int res;
217    
218     if (!nio)
219     return(-1);
220    
221     /* Receive the packet */
222     if ((len = nio->recv(nio->dptr,pkt,max_len)) <= 0)
223     return(-1);
224    
225     if (nio->debug) {
226     printf("NIO %s: receiving a packet of %ld bytes:\n",nio->name,(long)len);
227     mem_dump(stdout,pkt,len);
228     }
229    
230     /* Apply the RX filter */
231     if (nio->rx_filter != NULL) {
232     res = nio->rx_filter->pkt_handler(nio,pkt,len,nio->rx_filter_data);
233    
234     if (res == NETIO_FILTER_ACTION_DROP)
235     return(-1);
236     }
237    
238     return(len);
239     }
240    
241     /* Get a NetIO FD */
242     int netio_get_fd(netio_desc_t *nio)
243     {
244     int fd = -1;
245    
246     switch(nio->type) {
247     case NETIO_TYPE_UNIX:
248     fd = nio->u.nud.fd;
249     break;
250     case NETIO_TYPE_VDE:
251     fd = nio->u.nvd.data_fd;
252     break;
253     case NETIO_TYPE_TAP:
254     fd = nio->u.ntd.fd;
255     break;
256     case NETIO_TYPE_TCP_CLI:
257     case NETIO_TYPE_TCP_SER:
258     case NETIO_TYPE_UDP:
259     fd = nio->u.nid.fd;
260     break;
261     #ifdef LINUX_ETH
262     case NETIO_TYPE_LINUX_ETH:
263     fd = nio->u.nled.fd;
264     break;
265     #endif
266     }
267    
268     return(fd);
269     }
270    
271     /*
272     * =========================================================================
273     * UNIX sockets
274     * =========================================================================
275     */
276    
277     /* Create an UNIX socket */
278     static int netio_unix_create_socket(netio_unix_desc_t *nud)
279     {
280     struct sockaddr_un local_sock;
281    
282     if ((nud->fd = socket(AF_UNIX,SOCK_DGRAM,0)) == -1) {
283     perror("netio_unix: socket");
284     return(-1);
285     }
286    
287     memset(&local_sock,0,sizeof(local_sock));
288     local_sock.sun_family = AF_UNIX;
289     strcpy(local_sock.sun_path,nud->local_filename);
290    
291     if (bind(nud->fd,(struct sockaddr *)&local_sock,sizeof(local_sock)) == -1) {
292     perror("netio_unix: bind");
293     return(-1);
294     }
295    
296     return(nud->fd);
297     }
298    
299     /* Free a NetIO unix descriptor */
300     static void netio_unix_free(netio_unix_desc_t *nud)
301     {
302     if (nud->fd != -1)
303     close(nud->fd);
304    
305     if (nud->local_filename) {
306     unlink(nud->local_filename);
307     free(nud->local_filename);
308     }
309     }
310    
311     /* Allocate a new NetIO UNIX descriptor */
312     static int netio_unix_create(netio_unix_desc_t *nud,char *local,char *remote)
313     {
314     memset(nud,0,sizeof(*nud));
315     nud->fd = -1;
316    
317     /* check lengths */
318     if ((strlen(local) >= sizeof(nud->remote_sock.sun_path)) ||
319     (strlen(remote) >= sizeof(nud->remote_sock.sun_path)))
320     goto nomem_error;
321    
322     if (!(nud->local_filename = strdup(local)))
323     goto nomem_error;
324    
325     if (netio_unix_create_socket(nud) == -1)
326     return(-1);
327    
328     /* prepare the remote info */
329     nud->remote_sock.sun_family = AF_UNIX;
330     strcpy(nud->remote_sock.sun_path,remote);
331     return(0);
332    
333     nomem_error:
334     fprintf(stderr,"netio_unix_create: "
335     "invalid file size or insufficient memory\n");
336     return(-1);
337     }
338    
339     /* Write a packet to an UNIX socket */
340     static ssize_t netio_unix_send(netio_unix_desc_t *nud,void *pkt,size_t pkt_len)
341     {
342     return(sendto(nud->fd,pkt,pkt_len,0,
343     (struct sockaddr *)&nud->remote_sock,
344     sizeof(&nud->remote_sock)));
345     }
346    
347     /* Receive a packet from an UNIX socket */
348     static ssize_t netio_unix_recv(netio_unix_desc_t *nud,void *pkt,size_t max_len)
349     {
350     return(recvfrom(nud->fd,pkt,max_len,0,NULL,NULL));
351     }
352    
353     /* Save the NIO configuration */
354     static void netio_unix_save_cfg(netio_desc_t *nio,FILE *fd)
355     {
356     netio_unix_desc_t *nud = nio->dptr;
357     fprintf(fd,"nio create_unix %s %s %s\n",
358     nio->name,nud->local_filename,nud->remote_sock.sun_path);
359     }
360    
361     /* Create a new NetIO descriptor with UNIX method */
362     netio_desc_t *netio_desc_create_unix(char *nio_name,char *local,char *remote)
363     {
364     netio_desc_t *nio;
365    
366     if (!(nio = netio_create(nio_name)))
367     return NULL;
368    
369     if (netio_unix_create(&nio->u.nud,local,remote) == -1) {
370     netio_free(nio,NULL);
371     return NULL;
372     }
373    
374     nio->type = NETIO_TYPE_UNIX;
375     nio->send = (void *)netio_unix_send;
376     nio->recv = (void *)netio_unix_recv;
377     nio->save_cfg = netio_unix_save_cfg;
378     nio->dptr = &nio->u.nud;
379    
380     if (netio_record(nio) == -1) {
381     netio_free(nio,NULL);
382     return NULL;
383     }
384    
385     return nio;
386     }
387    
388     /*
389     * =========================================================================
390     * VDE (Virtual Distributed Ethernet) interface
391     * =========================================================================
392     */
393    
394     /* Free a NetIO VDE descriptor */
395     static void netio_vde_free(netio_vde_desc_t *nvd)
396     {
397     if (nvd->data_fd != -1)
398     close(nvd->data_fd);
399    
400     if (nvd->ctrl_fd != -1)
401     close(nvd->ctrl_fd);
402    
403     if (nvd->local_filename) {
404     unlink(nvd->local_filename);
405     free(nvd->local_filename);
406     }
407     }
408    
409     /* Create a new NetIO VDE descriptor */
410     static int netio_vde_create(netio_vde_desc_t *nvd,char *control,char *local)
411     {
412     struct sockaddr_un ctrl_sock,tst;
413     struct vde_request_v3 req;
414     ssize_t len;
415     int res;
416    
417     memset(nvd,0,sizeof(*nvd));
418     nvd->ctrl_fd = nvd->data_fd = -1;
419    
420     if ((strlen(control) >= sizeof(ctrl_sock.sun_path)) ||
421     (strlen(local) >= sizeof(nvd->remote_sock.sun_path))) {
422     fprintf(stderr,"netio_vde_create: bad filenames specified\n");
423     return(-1);
424     }
425    
426     /* Copy the local filename */
427     if (!(nvd->local_filename = strdup(local))) {
428     fprintf(stderr,"netio_vde_create: insufficient memory\n");
429     return(-1);
430     }
431    
432     /* Connect to the VDE switch controller */
433     nvd->ctrl_fd = socket(AF_UNIX,SOCK_STREAM,0);
434     if (nvd->ctrl_fd < 0) {
435     perror("netio_vde_create: socket(control)");
436     return(-1);
437     }
438    
439     memset(&ctrl_sock,0,sizeof(ctrl_sock));
440     ctrl_sock.sun_family = AF_UNIX;
441     strcpy(ctrl_sock.sun_path,control);
442    
443     res = connect(nvd->ctrl_fd,(struct sockaddr *)&ctrl_sock,
444     sizeof(ctrl_sock));
445    
446     if (res < 0) {
447     perror("netio_vde_create: connect(control)");
448     return(-1);
449     }
450    
451     tst.sun_family = AF_UNIX;
452     strcpy(tst.sun_path,local);
453    
454     /* Create the data connection */
455     nvd->data_fd = socket(AF_UNIX,SOCK_DGRAM,0);
456     if (nvd->data_fd < 0) {
457     perror("netio_vde_create: socket(data)");
458     return(-1);
459     }
460    
461     if (bind(nvd->data_fd,(struct sockaddr *)&tst,sizeof(tst))<0) {
462     perror("netio_vde_create: bind(data)");
463     return(-1);
464     }
465    
466     /* Now, process to registration */
467     memset(&req,0,sizeof(req));
468     req.sock.sun_family = AF_UNIX;
469     strcpy(req.sock.sun_path,local);
470     req.magic = VDE_SWITCH_MAGIC;
471     req.version = VDE_SWITCH_VERSION;
472     req.type = VDE_REQ_NEW_CONTROL;
473    
474     len = write(nvd->ctrl_fd,&req,sizeof(req));
475     if (len != sizeof(req)) {
476     perror("netio_vde_create: write(req)");
477     return(-1);
478     }
479    
480     /* Read the remote socket descriptor */
481     len = read(nvd->ctrl_fd,&nvd->remote_sock,sizeof(nvd->remote_sock));
482     if (len != sizeof(nvd->remote_sock)) {
483     perror("netio_vde_create: read(req)");
484     return(-1);
485     }
486    
487     return(0);
488     }
489    
490     /* Write a packet to a VDE data socket */
491     static ssize_t netio_vde_send(netio_vde_desc_t *nvd,void *pkt,size_t pkt_len)
492     {
493     return(sendto(nvd->data_fd,pkt,pkt_len,0,
494     (struct sockaddr *)&nvd->remote_sock,
495     sizeof(nvd->remote_sock)));
496     }
497    
498     /* Receive a packet from a VDE socket */
499     static ssize_t netio_vde_recv(netio_vde_desc_t *nvd,void *pkt,size_t max_len)
500     {
501     return(recvfrom(nvd->data_fd,pkt,max_len,0,NULL,NULL));
502     }
503    
504     /* Save the NIO configuration */
505     static void netio_vde_save_cfg(netio_desc_t *nio,FILE *fd)
506     {
507     netio_vde_desc_t *nvd = nio->dptr;
508     fprintf(fd,"nio create_vde %s %s %s\n",
509     nio->name,nvd->remote_sock.sun_path,nvd->local_filename);
510     }
511    
512     /* Create a new NetIO descriptor with VDE method */
513     netio_desc_t *netio_desc_create_vde(char *nio_name,char *control,char *local)
514     {
515     netio_vde_desc_t *nvd;
516     netio_desc_t *nio;
517    
518     if (!(nio = netio_create(nio_name)))
519     return NULL;
520    
521     nvd = &nio->u.nvd;
522    
523     if (netio_vde_create(nvd,control,local) == -1) {
524     netio_free(nio,NULL);
525     return NULL;
526     }
527    
528     nio->type = NETIO_TYPE_VDE;
529     nio->send = (void *)netio_vde_send;
530     nio->recv = (void *)netio_vde_recv;
531     nio->save_cfg = netio_vde_save_cfg;
532     nio->dptr = &nio->u.nvd;
533    
534     if (netio_record(nio) == -1) {
535     netio_free(nio,NULL);
536     return NULL;
537     }
538    
539     return nio;
540     }
541    
542     /*
543     * =========================================================================
544     * TAP devices
545     * =========================================================================
546     */
547    
548     /* Free a NetIO TAP descriptor */
549     static void netio_tap_free(netio_tap_desc_t *ntd)
550     {
551     if (ntd->fd != -1)
552     close(ntd->fd);
553     }
554    
555     /* Open a TAP device */
556     static int netio_tap_open(char *tap_devname)
557     {
558     #ifdef __linux__
559     struct ifreq ifr;
560     int fd,err;
561    
562     if ((fd = open("/dev/net/tun",O_RDWR)) < 0)
563     return(-1);
564    
565     memset(&ifr,0,sizeof(ifr));
566    
567     /* Flags: IFF_TUN - TUN device (no Ethernet headers)
568     * IFF_TAP - TAP device
569     *
570     * IFF_NO_PI - Do not provide packet information
571     */
572     ifr.ifr_flags = IFF_TAP|IFF_NO_PI;
573     if (*tap_devname)
574     strncpy(ifr.ifr_name,tap_devname,IFNAMSIZ);
575    
576     if ((err = ioctl(fd,TUNSETIFF,(void *)&ifr)) < 0) {
577     close(fd);
578     return err;
579     }
580    
581     strcpy(tap_devname,ifr.ifr_name);
582     return(fd);
583     #else
584     int i,fd = -1;
585    
586     if (*tap_devname) {
587     fd = open(tap_devname,O_RDWR);
588     } else {
589     for(i=0;i<16;i++) {
590     snprintf(tap_devname,NETIO_DEV_MAXLEN,"/dev/tap%d",i);
591    
592     if ((fd = open(tap_devname,O_RDWR)) >= 0)
593     break;
594     }
595     }
596    
597     return(fd);
598     #endif
599     }
600    
601     /* Allocate a new NetIO TAP descriptor */
602     static int netio_tap_create(netio_tap_desc_t *ntd,char *tap_name)
603     {
604     if (strlen(tap_name) >= NETIO_DEV_MAXLEN) {
605     fprintf(stderr,"netio_tap_create: bad TAP device string specified.\n");
606     return(-1);
607     }
608    
609     memset(ntd,0,sizeof(*ntd));
610     strcpy(ntd->filename,tap_name);
611     ntd->fd = netio_tap_open(ntd->filename);
612    
613     if (ntd->fd == -1) {
614     fprintf(stderr,"netio_tap_create: unable to open TAP device %s (%s)\n",
615     tap_name,strerror(errno));
616     return(-1);
617     }
618    
619     return(0);
620     }
621    
622     /* Write a packet to a TAP device */
623     static ssize_t netio_tap_send(netio_tap_desc_t *ntd,void *pkt,size_t pkt_len)
624     {
625     return(write(ntd->fd,pkt,pkt_len));
626     }
627    
628     /* Receive a packet through a TAP device */
629     static ssize_t netio_tap_recv(netio_tap_desc_t *ntd,void *pkt,size_t max_len)
630     {
631     return(read(ntd->fd,pkt,max_len));
632     }
633    
634     /* Save the NIO configuration */
635     static void netio_tap_save_cfg(netio_desc_t *nio,FILE *fd)
636     {
637     netio_tap_desc_t *ntd = nio->dptr;
638     fprintf(fd,"nio create_tap %s %s\n",nio->name,ntd->filename);
639     }
640    
641     /* Create a new NetIO descriptor with TAP method */
642     netio_desc_t *netio_desc_create_tap(char *nio_name,char *tap_name)
643     {
644     netio_tap_desc_t *ntd;
645     netio_desc_t *nio;
646    
647     if (!(nio = netio_create(nio_name)))
648     return NULL;
649    
650     ntd = &nio->u.ntd;
651    
652     if (netio_tap_create(ntd,tap_name) == -1) {
653     netio_free(nio,NULL);
654     return NULL;
655     }
656    
657     nio->type = NETIO_TYPE_TAP;
658     nio->send = (void *)netio_tap_send;
659     nio->recv = (void *)netio_tap_recv;
660     nio->save_cfg = netio_tap_save_cfg;
661     nio->dptr = &nio->u.ntd;
662    
663     if (netio_record(nio) == -1) {
664     netio_free(nio,NULL);
665     return NULL;
666     }
667    
668     return nio;
669     }
670    
671     /*
672     * =========================================================================
673     * TCP sockets
674     * =========================================================================
675     */
676    
677     /* Free a NetIO TCP descriptor */
678     static void netio_tcp_free(netio_inet_desc_t *nid)
679     {
680     if (nid->fd != -1)
681     close(nid->fd);
682     }
683    
684     /*
685     * very simple protocol to send packets over tcp
686     * 32 bits in network format - size of packet, then packet itself and so on.
687     */
688     static ssize_t netio_tcp_send(netio_inet_desc_t *nid,void *pkt,size_t pkt_len)
689     {
690     u_long l = htonl(pkt_len);
691    
692     if (write(nid->fd,&l,sizeof(l)) == -1)
693     return(-1);
694    
695     return(write(nid->fd,pkt,pkt_len));
696     }
697    
698     static ssize_t netio_tcp_recv(netio_inet_desc_t *nid,void *pkt,size_t max_len)
699     {
700     u_long l;
701    
702     if (read(nid->fd,&l,sizeof(l)) != sizeof(l))
703     return(-1);
704    
705     if (ntohl(l) > max_len)
706     return(-1);
707    
708     return(read(nid->fd,pkt,ntohl(l)));
709     }
710    
711     static int netio_tcp_cli_create(netio_inet_desc_t *nid,char *host,char *port)
712     {
713     struct sockaddr_in serv;
714     struct servent *sp;
715     struct hostent *hp;
716    
717     if ((nid->fd = socket(PF_INET,SOCK_STREAM,0)) < 0) {
718     perror("netio_tcp_cli_create: socket");
719     return(-1);
720     }
721    
722     memset(&serv,0,sizeof(serv));
723     serv.sin_family = AF_INET;
724    
725     if (atoi(port) == 0) {
726     if (!(sp = getservbyname(port,"tcp"))) {
727     fprintf(stderr,"netio_tcp_cli_create: port %s is neither "
728     "number not service %s\n",port,strerror(errno));
729     close(nid->fd);
730     return(-1);
731     }
732     serv.sin_port = sp->s_port;
733     } else
734     serv.sin_port = htons(atoi(port));
735    
736     if (inet_addr(host) == INADDR_NONE) {
737     if (!(hp = gethostbyname(host))) {
738     fprintf(stderr,"netio_tcp_cli_create: no host %s\n",host);
739     close(nid->fd);
740     return(-1);
741     }
742     serv.sin_addr.s_addr = *hp->h_addr;
743     } else
744     serv.sin_addr.s_addr = inet_addr(host);
745    
746     if (connect(nid->fd,(struct sockaddr *)&serv,sizeof(serv)) < 0) {
747     fprintf(stderr,"netio_tcp_cli_create: connect to %s:%s failed %s\n",
748     host,port,strerror(errno));
749     close(nid->fd);
750     return(-1);
751     }
752     return(0);
753     }
754    
755     /* Create a new NetIO descriptor with TCP_CLI method */
756     netio_desc_t *netio_desc_create_tcp_cli(char *nio_name,char *host,char *port)
757     {
758     netio_desc_t *nio;
759    
760     if (!(nio = netio_create(nio_name)))
761     return NULL;
762    
763     if (netio_tcp_cli_create(&nio->u.nid,host,port) < 0) {
764     netio_free(nio,NULL);
765     return NULL;
766     }
767    
768     nio->type = NETIO_TYPE_TCP_CLI;
769     nio->send = (void *)netio_tcp_send;
770     nio->recv = (void *)netio_tcp_recv;
771     nio->dptr = &nio->u.nid;
772    
773     if (netio_record(nio) == -1) {
774     netio_free(nio,NULL);
775     return NULL;
776     }
777    
778     return nio;
779     }
780    
781     static int netio_tcp_ser_create(netio_inet_desc_t *nid,char *port)
782     {
783     struct sockaddr_in serv;
784     struct servent *sp;
785     int sock_fd;
786    
787     if ((sock_fd = socket(PF_INET,SOCK_STREAM,0)) < 0) {
788     perror("netio_tcp_cli_create: socket\n");
789     return(-1);
790     }
791    
792     memset(&serv,0,sizeof(serv));
793     serv.sin_family = AF_INET;
794     serv.sin_addr.s_addr = htonl(INADDR_ANY);
795    
796     if (atoi(port) == 0) {
797     if (!(sp = getservbyname(port,"tcp"))) {
798     fprintf(stderr,"netio_tcp_ser_create: port %s is neither "
799     "number not service %s\n",port,strerror(errno));
800     close(sock_fd);
801     return(-1);
802     }
803     serv.sin_port = sp->s_port;
804     } else
805     serv.sin_port = htons(atoi(port));
806    
807     if (bind(sock_fd,(struct sockaddr *)&serv,sizeof(serv)) < 0) {
808     fprintf(stderr,"netio_tcp_ser_create: bind %s failed %s\n",
809     port,strerror(errno));
810     close(sock_fd);
811     return(-1);
812     }
813    
814     if (listen(sock_fd,1) < 0) {
815     fprintf(stderr,"netio_tcp_ser_create: listen %s failed %s\n",
816     port,strerror(errno));
817     close(sock_fd);
818     return(-1);
819     }
820    
821     fprintf(stderr,"Waiting connection on port %s...\n",port);
822    
823     if ((nid->fd = accept(sock_fd,NULL,NULL)) < 0) {
824     fprintf(stderr,"netio_tcp_ser_create: accept %s failed %s\n",
825     port,strerror(errno));
826     close(sock_fd);
827     return(-1);
828     }
829    
830     fprintf(stderr,"Connected\n");
831    
832     close(sock_fd);
833     return(0);
834     }
835    
836     /* Create a new NetIO descriptor with TCP_SER method */
837     netio_desc_t *netio_desc_create_tcp_ser(char *nio_name,char *port)
838     {
839     netio_desc_t *nio;
840    
841     if (!(nio = netio_create(nio_name)))
842     return NULL;
843    
844     if (netio_tcp_ser_create(&nio->u.nid,port) == -1) {
845     netio_free(nio,NULL);
846     return NULL;
847     }
848    
849     nio->type = NETIO_TYPE_TCP_SER;
850     nio->send = (void *)netio_tcp_send;
851     nio->recv = (void *)netio_tcp_recv;
852     nio->dptr = &nio->u.nid;
853    
854     if (netio_record(nio) == -1) {
855     netio_free(nio,NULL);
856     return NULL;
857     }
858    
859     return nio;
860     }
861    
862     /*
863     * =========================================================================
864     * UDP sockets
865     * =========================================================================
866     */
867    
868     /* Free a NetIO UDP descriptor */
869     static void netio_udp_free(netio_inet_desc_t *nid)
870     {
871     if (nid->remote_host) {
872     free(nid->remote_host);
873     nid->remote_host = NULL;
874     }
875    
876     if (nid->fd != -1)
877     close(nid->fd);
878     }
879    
880     /* Write a packet to an UDP socket */
881     static ssize_t netio_udp_send(netio_inet_desc_t *nid,void *pkt,size_t pkt_len)
882     {
883     return(send(nid->fd,pkt,pkt_len,0));
884     }
885    
886     /* Receive a packet from an UDP socket */
887     static ssize_t netio_udp_recv(netio_inet_desc_t *nid,void *pkt,size_t max_len)
888     {
889     return(recvfrom(nid->fd,pkt,max_len,0,NULL,NULL));
890     }
891    
892     /* Save the NIO configuration */
893     static void netio_udp_save_cfg(netio_desc_t *nio,FILE *fd)
894     {
895     netio_inet_desc_t *nid = nio->dptr;
896     fprintf(fd,"nio create_udp %s %d %s %d\n",
897     nio->name,nid->local_port,nid->remote_host,nid->remote_port);
898     }
899    
900     /* Create a new NetIO descriptor with UDP method */
901     netio_desc_t *netio_desc_create_udp(char *nio_name,int local_port,
902     char *remote_host,int remote_port)
903     {
904     netio_inet_desc_t *nid;
905     netio_desc_t *nio;
906    
907     if (!(nio = netio_create(nio_name)))
908     return NULL;
909    
910     nid = &nio->u.nid;
911     nid->local_port = local_port;
912     nid->remote_port = remote_port;
913    
914     if (!(nid->remote_host = strdup(remote_host))) {
915     fprintf(stderr,"netio_desc_create_udp: insufficient memory\n");
916     goto error;
917     }
918    
919     if ((nid->fd = udp_connect(local_port,remote_host,remote_port)) < 0) {
920     fprintf(stderr,"netio_desc_create_udp: unable to connect to %s:%d\n",
921     remote_host,remote_port);
922     goto error;
923     }
924    
925     nio->type = NETIO_TYPE_UDP;
926     nio->send = (void *)netio_udp_send;
927     nio->recv = (void *)netio_udp_recv;
928     nio->save_cfg = netio_udp_save_cfg;
929     nio->dptr = &nio->u.nid;
930    
931     if (netio_record(nio) == -1)
932     goto error;
933    
934     return nio;
935    
936     error:
937     netio_free(nio,NULL);
938     return NULL;
939     }
940    
941     /*
942     * =========================================================================
943     * Linux RAW Ethernet driver
944     * =========================================================================
945     */
946     #ifdef LINUX_ETH
947     /* Free a NetIO raw ethernet descriptor */
948     static void netio_lnxeth_free(netio_lnxeth_desc_t *nled)
949     {
950     if (nled->fd != -1)
951     close(nled->fd);
952     }
953    
954     /* Write a packet to a raw Ethernet socket */
955     static ssize_t netio_lnxeth_send(netio_lnxeth_desc_t *nled,
956     void *pkt,size_t pkt_len)
957     {
958     return(lnx_eth_send(nled->fd,nled->dev_id,pkt,pkt_len));
959     }
960    
961     /* Receive a packet from an raw Ethernet socket */
962     static ssize_t netio_lnxeth_recv(netio_lnxeth_desc_t *nled,
963     void *pkt,size_t max_len)
964     {
965     return(lnx_eth_recv(nled->fd,pkt,max_len));
966     }
967    
968     /* Save the NIO configuration */
969     static void netio_lnxeth_save_cfg(netio_desc_t *nio,FILE *fd)
970     {
971     netio_lnxeth_desc_t *nled = nio->dptr;
972     fprintf(fd,"nio create_linux_eth %s %s\n",nio->name,nled->dev_name);
973     }
974    
975     /* Create a new NetIO descriptor with raw Ethernet method */
976     netio_desc_t *netio_desc_create_lnxeth(char *nio_name,char *dev_name)
977     {
978     netio_lnxeth_desc_t *nled;
979     netio_desc_t *nio;
980    
981     if (!(nio = netio_create(nio_name)))
982     return NULL;
983    
984     nled = &nio->u.nled;
985    
986     if (strlen(dev_name) >= NETIO_DEV_MAXLEN) {
987     fprintf(stderr,"netio_desc_create_lnxeth: bad Ethernet device string "
988     "specified.\n");
989     netio_free(nio,NULL);
990     return NULL;
991     }
992    
993     strcpy(nled->dev_name,dev_name);
994    
995     nled->fd = lnx_eth_init_socket(dev_name);
996     nled->dev_id = lnx_eth_get_dev_index(dev_name);
997    
998     if (nled->fd < 0) {
999     netio_free(nio,NULL);
1000     return NULL;
1001     }
1002    
1003     nio->type = NETIO_TYPE_LINUX_ETH;
1004     nio->send = (void *)netio_lnxeth_send;
1005     nio->recv = (void *)netio_lnxeth_recv;
1006     nio->save_cfg = netio_lnxeth_save_cfg;
1007     nio->dptr = &nio->u.nled;
1008    
1009     if (netio_record(nio) == -1) {
1010     netio_free(nio,NULL);
1011     return NULL;
1012     }
1013    
1014     return nio;
1015     }
1016     #endif /* LINUX_ETH */
1017    
1018     /*
1019     * =========================================================================
1020     * Generic RAW Ethernet driver
1021     * =========================================================================
1022     */
1023     #ifdef GEN_ETH
1024     /* Free a NetIO raw ethernet descriptor */
1025     static void netio_geneth_free(netio_geneth_desc_t *nged)
1026     {
1027     gen_eth_close(nged->pcap_dev);
1028     }
1029    
1030     /* Write a packet to an Ethernet device */
1031     static ssize_t netio_geneth_send(netio_geneth_desc_t *nged,
1032     void *pkt,size_t pkt_len)
1033     {
1034     return(gen_eth_send(nged->pcap_dev,pkt,pkt_len));
1035     }
1036    
1037     /* Receive a packet from an Ethernet device */
1038     static ssize_t netio_geneth_recv(netio_geneth_desc_t *nged,
1039     void *pkt,size_t max_len)
1040     {
1041     return(gen_eth_recv(nged->pcap_dev,pkt,max_len));
1042     }
1043    
1044     /* Save the NIO configuration */
1045     static void netio_geneth_save_cfg(netio_desc_t *nio,FILE *fd)
1046     {
1047     netio_geneth_desc_t *nged = nio->dptr;
1048     fprintf(fd,"nio create_gen_eth %s %s\n",nio->name,nged->dev_name);
1049     }
1050    
1051     /* Create a new NetIO descriptor with generic raw Ethernet method */
1052     netio_desc_t *netio_desc_create_geneth(char *nio_name,char *dev_name)
1053     {
1054     netio_geneth_desc_t *nged;
1055     netio_desc_t *nio;
1056    
1057     if (!(nio = netio_create(nio_name)))
1058     return NULL;
1059    
1060     nged = &nio->u.nged;
1061    
1062     if (strlen(dev_name) >= NETIO_DEV_MAXLEN) {
1063     fprintf(stderr,"netio_desc_create_geneth: bad Ethernet device string "
1064     "specified.\n");
1065     netio_free(nio,NULL);
1066     return NULL;
1067     }
1068    
1069     strcpy(nged->dev_name,dev_name);
1070    
1071     if (!(nged->pcap_dev = gen_eth_init(dev_name))) {
1072     netio_free(nio,NULL);
1073     return NULL;
1074     }
1075    
1076     nio->type = NETIO_TYPE_GEN_ETH;
1077     nio->send = (void *)netio_geneth_send;
1078     nio->recv = (void *)netio_geneth_recv;
1079     nio->save_cfg = netio_geneth_save_cfg;
1080     nio->dptr = &nio->u.nged;
1081    
1082     if (netio_record(nio) == -1) {
1083     netio_free(nio,NULL);
1084     return NULL;
1085     }
1086    
1087     return nio;
1088     }
1089     #endif /* GEN_ETH */
1090    
1091     /*
1092     * =========================================================================
1093     * FIFO Driver (intra-hypervisor communications)
1094     * =========================================================================
1095     */
1096    
1097     /* Extract the first packet of the FIFO */
1098     static netio_fifo_pkt_t *netio_fifo_extract_pkt(netio_fifo_desc_t *nfd)
1099     {
1100     netio_fifo_pkt_t *p;
1101    
1102     if (!(p = nfd->head))
1103     return NULL;
1104    
1105     nfd->pkt_count--;
1106     nfd->head = p->next;
1107    
1108     if (!nfd->head)
1109     nfd->last = NULL;
1110    
1111     return p;
1112     }
1113    
1114     /* Insert a packet into the FIFO (in tail) */
1115     static void netio_fifo_insert_pkt(netio_fifo_desc_t *nfd,netio_fifo_pkt_t *p)
1116     {
1117     pthread_mutex_lock(&nfd->lock);
1118    
1119     nfd->pkt_count++;
1120     p->next = NULL;
1121    
1122     if (nfd->last) {
1123     nfd->last->next = p;
1124     } else {
1125     nfd->head = p;
1126     }
1127    
1128     nfd->last = p;
1129     pthread_mutex_unlock(&nfd->lock);
1130     }
1131    
1132     /* Free the packet list */
1133     static void netio_fifo_free_pkt_list(netio_fifo_desc_t *nfd)
1134     {
1135     netio_fifo_pkt_t *p,*next;
1136    
1137     for(p=nfd->head;p;p=next) {
1138     next = p->next;
1139     free(p);
1140     }
1141    
1142     nfd->head = nfd->last = NULL;
1143     nfd->pkt_count = 0;
1144     }
1145    
1146     /* Establish a cross-connect between two FIFO NetIO */
1147     int netio_fifo_crossconnect(netio_desc_t *a,netio_desc_t *b)
1148     {
1149     netio_fifo_desc_t *pa,*pb;
1150    
1151     if ((a->type != NETIO_TYPE_FIFO) || (b->type != NETIO_TYPE_FIFO))
1152     return(-1);
1153    
1154     pa = &a->u.nfd;
1155     pb = &b->u.nfd;
1156    
1157     /* A => B */
1158     pthread_mutex_lock(&pa->endpoint_lock);
1159     pthread_mutex_lock(&pa->lock);
1160     pa->endpoint = pb;
1161     netio_fifo_free_pkt_list(pa);
1162     pthread_mutex_unlock(&pa->lock);
1163     pthread_mutex_unlock(&pa->endpoint_lock);
1164    
1165     /* B => A */
1166     pthread_mutex_lock(&pb->endpoint_lock);
1167     pthread_mutex_lock(&pb->lock);
1168     pb->endpoint = pa;
1169     netio_fifo_free_pkt_list(pb);
1170     pthread_mutex_unlock(&pb->lock);
1171     pthread_mutex_unlock(&pb->endpoint_lock);
1172     return(0);
1173     }
1174    
1175     /* Unbind an endpoint */
1176     static void netio_fifo_unbind_endpoint(netio_fifo_desc_t *nfd)
1177     {
1178     pthread_mutex_lock(&nfd->endpoint_lock);
1179     nfd->endpoint = NULL;
1180     pthread_mutex_unlock(&nfd->endpoint_lock);
1181     }
1182    
1183     /* Free a NetIO FIFO descriptor */
1184     static void netio_fifo_free(netio_fifo_desc_t *nfd)
1185     {
1186     if (nfd->endpoint)
1187     netio_fifo_unbind_endpoint(nfd->endpoint);
1188    
1189     netio_fifo_free_pkt_list(nfd);
1190     pthread_mutex_destroy(&nfd->lock);
1191     pthread_cond_destroy(&nfd->cond);
1192     }
1193    
1194     /* Send a packet (to the endpoint FIFO) */
1195     static ssize_t netio_fifo_send(netio_fifo_desc_t *nfd,void *pkt,size_t pkt_len)
1196     {
1197     netio_fifo_pkt_t *p;
1198     size_t len;
1199    
1200     pthread_mutex_lock(&nfd->endpoint_lock);
1201    
1202     /* The cross-connect must have been established before */
1203     if (!nfd->endpoint)
1204     goto error;
1205    
1206     /* Allocate a a new packet and insert it into the endpoint FIFO */
1207     len = sizeof(netio_fifo_pkt_t) + pkt_len;
1208     if (!(p = malloc(len)))
1209     goto error;
1210    
1211     memcpy(p->pkt,pkt,pkt_len);
1212     p->pkt_len = pkt_len;
1213     netio_fifo_insert_pkt(nfd->endpoint,p);
1214     pthread_cond_signal(&nfd->endpoint->cond);
1215     pthread_mutex_unlock(&nfd->endpoint_lock);
1216     return(pkt_len);
1217    
1218     error:
1219     pthread_mutex_unlock(&nfd->endpoint_lock);
1220     return(-1);
1221     }
1222    
1223     /* Read a packet from the local FIFO queue */
1224     static ssize_t netio_fifo_recv(netio_fifo_desc_t *nfd,void *pkt,size_t max_len)
1225     {
1226     struct timespec ts;
1227     m_tmcnt_t expire;
1228     netio_fifo_pkt_t *p;
1229     size_t len = -1;
1230    
1231     /* Wait for the endpoint to signal a new arriving packet */
1232     expire = m_gettime_usec() + 50000;
1233     ts.tv_sec = expire / 1000000;
1234     ts.tv_nsec = (expire % 1000000) * 1000;
1235    
1236     pthread_mutex_lock(&nfd->lock);
1237     pthread_cond_timedwait(&nfd->cond,&nfd->lock,&ts);
1238    
1239     /* Extract a packet from the list */
1240     p = netio_fifo_extract_pkt(nfd);
1241     pthread_mutex_unlock(&nfd->lock);
1242    
1243     if (p) {
1244     len = m_min(p->pkt_len,max_len);
1245     memcpy(pkt,p->pkt,len);
1246     free(p);
1247     }
1248    
1249     return(len);
1250     }
1251    
1252     /* Create a new NetIO descriptor with FIFO method */
1253     netio_desc_t *netio_desc_create_fifo(char *nio_name)
1254     {
1255     netio_fifo_desc_t *nfd;
1256     netio_desc_t *nio;
1257    
1258     if (!(nio = netio_create(nio_name)))
1259     return NULL;
1260    
1261     nfd = &nio->u.nfd;
1262     pthread_mutex_init(&nfd->lock,NULL);
1263     pthread_mutex_init(&nfd->endpoint_lock,NULL);
1264     pthread_cond_init(&nfd->cond,NULL);
1265    
1266     nio->type = NETIO_TYPE_FIFO;
1267     nio->send = (void *)netio_fifo_send;
1268     nio->recv = (void *)netio_fifo_recv;
1269     nio->dptr = nfd;
1270    
1271     if (netio_record(nio) == -1) {
1272     netio_free(nio,NULL);
1273     return NULL;
1274     }
1275    
1276     return nio;
1277     }
1278    
1279     /*
1280     * =========================================================================
1281     * NULL Driver (does nothing, used for debugging)
1282     * =========================================================================
1283     */
1284     static ssize_t netio_null_send(void *null_ptr,void *pkt,size_t pkt_len)
1285     {
1286     return(pkt_len);
1287     }
1288    
1289     static ssize_t netio_null_recv(void *null_ptr,void *pkt,size_t max_len)
1290     {
1291     usleep(200000);
1292     return(-1);
1293     }
1294    
1295     static void netio_null_save_cfg(netio_desc_t *nio,FILE *fd)
1296     {
1297     fprintf(fd,"nio create_null %s\n",nio->name);
1298     }
1299    
1300     /* Create a new NetIO descriptor with NULL method */
1301     netio_desc_t *netio_desc_create_null(char *nio_name)
1302     {
1303     netio_desc_t *nio;
1304    
1305     if (!(nio = netio_create(nio_name)))
1306     return NULL;
1307    
1308     nio->type = NETIO_TYPE_NULL;
1309     nio->send = (void *)netio_null_send;
1310     nio->recv = (void *)netio_null_recv;
1311     nio->save_cfg = netio_null_save_cfg;
1312     nio->dptr = NULL;
1313    
1314     if (netio_record(nio) == -1) {
1315     netio_free(nio,NULL);
1316     return NULL;
1317     }
1318    
1319     return nio;
1320     }
1321    
1322     /* Free a NetIO descriptor */
1323     static int netio_free(void *data,void *arg)
1324     {
1325     netio_desc_t *nio = data;
1326    
1327     if (nio) {
1328     netio_filter_unbind(nio,NETIO_FILTER_DIR_RX);
1329     netio_filter_unbind(nio,NETIO_FILTER_DIR_TX);
1330    
1331     switch(nio->type) {
1332     case NETIO_TYPE_UNIX:
1333     netio_unix_free(&nio->u.nud);
1334     break;
1335     case NETIO_TYPE_VDE:
1336     netio_vde_free(&nio->u.nvd);
1337     break;
1338     case NETIO_TYPE_TAP:
1339     netio_tap_free(&nio->u.ntd);
1340     break;
1341     case NETIO_TYPE_TCP_CLI:
1342     case NETIO_TYPE_TCP_SER:
1343     netio_tcp_free(&nio->u.nid);
1344     break;
1345     case NETIO_TYPE_UDP:
1346     netio_udp_free(&nio->u.nid);
1347     break;
1348     #ifdef LINUX_ETH
1349     case NETIO_TYPE_LINUX_ETH:
1350     netio_lnxeth_free(&nio->u.nled);
1351     break;
1352     #endif
1353     #ifdef GEN_ETH
1354     case NETIO_TYPE_GEN_ETH:
1355     netio_geneth_free(&nio->u.nged);
1356     break;
1357     #endif
1358     case NETIO_TYPE_FIFO:
1359     netio_fifo_free(&nio->u.nfd);
1360     break;
1361     case NETIO_TYPE_NULL:
1362     break;
1363     default:
1364     fprintf(stderr,"NETIO: unknown descriptor type %u\n",nio->type);
1365     }
1366    
1367     free(nio->name);
1368     free(nio);
1369     }
1370    
1371     return(TRUE);
1372     }
1373    
1374     /*
1375     * =========================================================================
1376     * RX Listeners
1377     * =========================================================================
1378     */
1379    
1380     /* Find a RX listener */
1381     static inline struct netio_rx_listener *netio_rxl_find(netio_desc_t *nio)
1382     {
1383     struct netio_rx_listener *rxl;
1384    
1385     for(rxl=netio_rxl_list;rxl;rxl=rxl->next)
1386     if (rxl->nio == nio)
1387     return rxl;
1388    
1389     return NULL;
1390     }
1391    
1392     /* Remove a NIO from the listener list */
1393     static int netio_rxl_remove_internal(netio_desc_t *nio)
1394     {
1395     struct netio_rx_listener *rxl;
1396     int res = -1;
1397    
1398     if ((rxl = netio_rxl_find(nio))) {
1399     /* we suppress this NIO only when the ref count hits 0 */
1400     rxl->ref_count--;
1401    
1402     if (!rxl->ref_count) {
1403     /* remove this listener from the double linked list */
1404     if (rxl->next)
1405     rxl->next->prev = rxl->prev;
1406    
1407     if (rxl->prev)
1408     rxl->prev->next = rxl->next;
1409     else
1410     netio_rxl_list = rxl->next;
1411    
1412     /* if this is non-FD NIO, wait for thread to terminate */
1413     if (netio_get_fd(rxl->nio) == -1) {
1414     rxl->running = FALSE;
1415     pthread_join(rxl->spec_thread,NULL);
1416     }
1417    
1418     free(rxl);
1419     }
1420    
1421     res = 0;
1422     }
1423    
1424     return(res);
1425     }
1426    
1427     /* Add a RXL listener to the listener list */
1428     static void netio_rxl_add_internal(struct netio_rx_listener *rxl)
1429     {
1430     struct netio_rx_listener *tmp;
1431    
1432     if ((tmp = netio_rxl_find(rxl->nio))) {
1433     tmp->ref_count++;
1434     free(rxl);
1435     } else {
1436     rxl->prev = NULL;
1437     rxl->next = netio_rxl_list;
1438     if (rxl->next) rxl->next->prev = rxl;
1439     netio_rxl_list = rxl;
1440     }
1441     }
1442    
1443     /* RX Listener dedicated thread (for non-FD NIO) */
1444     static void *netio_rxl_spec_thread(void *arg)
1445     {
1446     struct netio_rx_listener *rxl = arg;
1447     u_char pkt[NETIO_MAX_PKT_SIZE];
1448     ssize_t pkt_len;
1449    
1450     while(rxl->running) {
1451     pkt_len = netio_recv(rxl->nio,pkt,sizeof(pkt));
1452    
1453     if (pkt_len > 0)
1454     rxl->rx_handler(rxl->nio,pkt,pkt_len,rxl->arg1,rxl->arg2);
1455     }
1456    
1457     return NULL;
1458     }
1459    
1460     /* RX Listener General Thread */
1461     void *netio_rxl_gen_thread(void *arg)
1462     {
1463     struct netio_rx_listener *rxl;
1464     u_char pkt[NETIO_MAX_PKT_SIZE];
1465     ssize_t pkt_len;
1466     netio_desc_t *nio;
1467     struct timeval tv;
1468     int fd,fd_max,res;
1469     fd_set rfds;
1470    
1471     for(;;) {
1472     NETIO_RXL_LOCK();
1473    
1474     NETIO_RXQ_LOCK();
1475     /* Add the new waiting NIO to the active list */
1476     while(netio_rxl_add_list != NULL) {
1477     rxl = netio_rxl_add_list;
1478     netio_rxl_add_list = netio_rxl_add_list->next;
1479     netio_rxl_add_internal(rxl);
1480     }
1481    
1482     /* Delete the NIO present in the remove list */
1483     while(netio_rxl_remove_list != NULL) {
1484     nio = netio_rxl_remove_list;
1485     netio_rxl_remove_list = netio_rxl_remove_list->rxl_next;
1486     netio_rxl_remove_internal(nio);
1487     }
1488    
1489     pthread_cond_broadcast(&netio_rxl_cond);
1490     NETIO_RXQ_UNLOCK();
1491    
1492     /* Build the FD set */
1493     FD_ZERO(&rfds);
1494     fd_max = -1;
1495     for(rxl=netio_rxl_list;rxl;rxl=rxl->next) {
1496     if ((fd = netio_get_fd(rxl->nio)) == -1)
1497     continue;
1498    
1499     if (fd > fd_max) fd_max = fd;
1500     FD_SET(fd,&rfds);
1501     }
1502     NETIO_RXL_UNLOCK();
1503    
1504     /* Wait for incoming packets */
1505     tv.tv_sec = 0;
1506     tv.tv_usec = 200 * 1000; /* 200 ms */
1507     res = select(fd_max+1,&rfds,NULL,NULL,&tv);
1508    
1509     if (res == -1) {
1510     if (errno != EINTR)
1511     perror("netio_rxl_thread: select");
1512     continue;
1513     }
1514    
1515     /* Examine active FDs and call user handlers */
1516     NETIO_RXL_LOCK();
1517    
1518     for(rxl=netio_rxl_list;rxl;rxl=rxl->next) {
1519     if ((fd = netio_get_fd(rxl->nio)) == -1)
1520     continue;
1521    
1522     if (FD_ISSET(fd,&rfds)) {
1523     pkt_len = netio_recv(rxl->nio,pkt,sizeof(pkt));
1524    
1525     if (pkt_len > 0)
1526     rxl->rx_handler(rxl->nio,pkt,pkt_len,rxl->arg1,rxl->arg2);
1527     }
1528     }
1529    
1530     NETIO_RXL_UNLOCK();
1531     }
1532    
1533     return NULL;
1534     }
1535    
1536     /* Add a RX listener in the listener list */
1537     int netio_rxl_add(netio_desc_t *nio,netio_rx_handler_t rx_handler,
1538     void *arg1,void *arg2)
1539     {
1540     struct netio_rx_listener *rxl;
1541    
1542     NETIO_RXQ_LOCK();
1543    
1544     if (!(rxl = malloc(sizeof(*rxl)))) {
1545     NETIO_RXQ_UNLOCK();
1546     fprintf(stderr,"netio_rxl_add: unable to create structure.\n");
1547     return(-1);
1548     }
1549    
1550     memset(rxl,0,sizeof(*rxl));
1551     rxl->nio = nio;
1552     rxl->ref_count = 1;
1553     rxl->rx_handler = rx_handler;
1554     rxl->arg1 = arg1;
1555     rxl->arg2 = arg2;
1556     rxl->running = TRUE;
1557    
1558     if ((netio_get_fd(rxl->nio) == -1) &&
1559     pthread_create(&rxl->spec_thread,NULL,netio_rxl_spec_thread,rxl))
1560     {
1561     NETIO_RXQ_UNLOCK();
1562     fprintf(stderr,"netio_rxl_add: unable to create specific thread.\n");
1563     free(rxl);
1564     return(-1);
1565     }
1566    
1567     rxl->next = netio_rxl_add_list;
1568     netio_rxl_add_list = rxl;
1569    
1570     pthread_cond_wait(&netio_rxl_cond,&netio_rxq_mutex);
1571     NETIO_RXQ_UNLOCK();
1572     return(0);
1573     }
1574    
1575     /* Remove a NIO from the listener list */
1576     int netio_rxl_remove(netio_desc_t *nio)
1577     {
1578     NETIO_RXQ_LOCK();
1579     nio->rxl_next = netio_rxl_remove_list;
1580     netio_rxl_remove_list = nio;
1581     pthread_cond_wait(&netio_rxl_cond,&netio_rxq_mutex);
1582     NETIO_RXQ_UNLOCK();
1583     return(0);
1584     }
1585    
1586     /* Initialize the RXL thread */
1587     int netio_rxl_init(void)
1588     {
1589     pthread_cond_init(&netio_rxl_cond,NULL);
1590    
1591     if (pthread_create(&netio_rxl_thread,NULL,netio_rxl_gen_thread,NULL)) {
1592     perror("netio_rxl_init: pthread_create");
1593     return(-1);
1594     }
1595    
1596     return(0);
1597     }

  ViewVC Help
Powered by ViewVC 1.1.26