[insert project logo here (125x200px max)] Navigator Home Downloads Documentation Research News Forums Project Summary CVS repository Mailinglists Help Announcement Developer Please report any errors or ommissions you find to our `Help' mailinglist, or post a message in the Forums. Copyright and Licensing Information Snap is (c) Jonathan T. Moore, 1999-2002 and licensed under the GNU General Public License (GPL). All other parts of Splash are (c) Willem de Bruijn, 2002-2003 and licensed under the BSD Open Source License. All sourcecode is made publicly available. Acknowledgement Splash and the Splash website are hosted by SourceForge.net

Splash - Documentation SNMP Plus a Lightweight API for SNAP Handling             snap-1.1-wjdb/lib/libsnap.c Go to the documentation of this file. /* snap2snmp connection library */ /* (c) Willem de Bruijn, 2002 */ /* snaplibrary sourcefile */ #include <stdarg.h> #include <pthread.h> #define _GNU_SOURCE #include <assert.h> #include <features.h> #include <getopt.h> #include <net/if_arp.h> #include <netinet/in.h> #include <netinet/ip.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/socket.h> #include <sys/time.h> #include <sys/types.h> #include <unistd.h> #include <libgen.h> #if __GLIBC__ >= 2 && __GLIBC_MINOR >= 1 #include <netpacket/packet.h> #include <net/ethernet.h> /* the L2 protocols */ #else #include <asm/types.h> #include <linux/if_packet.h> #include <linux/if_ether.h> /* The L2 protocols */ #endif #include "d_printf.h" #include "snapnet.h" #include "packet.h" #include "snap.h" #include "version.h" #include "interp.h" #include "snap_kern_iface.h" #include "snap_svc_handler.h" #define NIPQUAD(addr) \ ((unsigned char *)&(addr))[0], \ ((unsigned char *)&(addr))[1], \ ((unsigned char *)&(addr))[2], \ ((unsigned char *)&(addr))[3] #ifndef UDPPORT #define UDPPORT 7777 #endif /* declaration of function. Definition can be found below.*/ int snap_receive(); struct glob_conf { struct sockaddr_in herehint; } gc; struct cmdline_args { int argc; char** argv; }; void usage(char *myname); void parse_cmdline_snap(int argc, char *argv[]); int ethsock = -1; int losock = -1; /* int udpsock = -1; */ int rawiprecvsock = -1; int maxfd; packet_t *p; /* struct sockaddr_ll bindhwaddr; */ fd_set rfds; unsigned char ra_space[4]; struct sockaddr_in bindaddr; struct sockaddr_in udpaddr; int snap(struct cmdline_args *cargs) { #ifndef NDEBUG set_debug_level(); #endif memset(&gc, 0, sizeof(gc)); if (cargs->argc > 0) /* we can call this function without arguments */ parse_cmdline_snap((*cargs).argc,(*cargs).argv); init_kern_iface(&gc.herehint); #ifdef CONFIG_IP_SNAP_SVCS snap_svc_handler_init(); #endif /* set up raw IP socket to avoid "protocol 130" ICMP msgs */ if ((rawiprecvsock = socket(AF_INET, SOCK_RAW, IPPROTO_SNAP)) < 0) { perror("rawiprecvsock: socket()"); exit(EXIT_FAILURE); } ra_space[IPOPT_OPTVAL] = IPOPT_RA; ra_space[IPOPT_OLEN] = 4; ra_space[2] = ra_space[3] = 0; if (setsockopt(rawiprecvsock, IPPROTO_IP, IP_OPTIONS, ra_space, sizeof(ra_space)) < 0) { perror("rawiprecvsock: setsockopt()"); exit(EXIT_FAILURE); } memset(&bindaddr, 0, sizeof(bindaddr)); bindaddr.sin_family = AF_INET; bindaddr.sin_addr.s_addr = htonl(INADDR_ANY); if (bind(rawiprecvsock, (struct sockaddr *)&bindaddr, sizeof(bindaddr)) < 0) { perror("rawiprecvsock: bind()"); exit(EXIT_FAILURE); } /* set up ethernet socket */ if ((ethsock = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0) { perror("ethsock socket()"); exit(EXIT_FAILURE); } #if 0 memset(&bindhwaddr, 0, sizeof(bindhwaddr)); bindhwaddr.sll_family = PF_PACKET; bindhwaddr.sll_protocol = ETH_P_IP; bindhwaddr.sll_ifindex = 2; /* all ifs */ bindhwaddr.sll_hatype = ARPHRD_ETHER; bindhwaddr.sll_halen = 6; if (bind(ethsock, (struct sockaddr *)&bindhwaddr, sizeof(bindhwaddr)) < 0) { perror("bind"); exit(EXIT_FAILURE); } /* set up loopback socket */ if ((losock = socket(PF_PACKET, SOCK_RAW, ETH_P_ALL)) < 0) { perror("losock socket()"); exit(EXIT_FAILURE); } memset(&bindhwaddr, 0, sizeof(bindhwaddr)); bindhwaddr.sll_family = PF_PACKET; bindhwaddr.sll_protocol = ETH_P_IP; bindhwaddr.sll_ifindex = 1; /* all ifs */ bindhwaddr.sll_hatype = ARPHRD_LOOPBACK; bindhwaddr.sll_halen = 6; if (bind(losock, (struct sockaddr *)&bindhwaddr, sizeof(bindhwaddr)) < 0) { perror("bind"); exit(EXIT_FAILURE); } #endif if (losock > ethsock) maxfd = losock + 1; else maxfd = ethsock + 1; /* set up the datagram socket */ /* if ((udpsock = socket(PF_INET, SOCK_DGRAM, 0)) < 0) { perror("udpsock socket()"); exit(EXIT_FAILURE); } bzero((char *) &udpaddr, sizeof(udpaddr)); udpaddr.sin_family = AF_INET; udpaddr.sin_addr.s_addr = htonl(INADDR_ANY); udpaddr.sin_port = htons(UDPPORT); if (bind(udpsock, (struct sockaddr *) &udpaddr, sizeof(udpaddr)) < 0){ perror("udpsock bind()"); exit(EXIT_FAILURE); } if (udpsock >= maxfd) maxfd = udpsock + 1; */ d_printf(5, "SNAP (wjdb tree) version %s : ready\n",VERSION); return 0; } int add_snap_handler(fd_set* activeset){ FD_SET(ethsock,activeset); FD_SET(rawiprecvsock,activeset); return ethsock > rawiprecvsock ? ethsock : rawiprecvsock; } int isset_snap_handler(fd_set* activeset){ return /*FD_ISSET(ethsock, activeset) && */FD_ISSET(rawiprecvsock, activeset); } void clear_snap_handler(fd_set* activeset){ /* if (FD_ISSET(ethsock, activeset)) FD_CLR (ethsock, activeset); */ if (FD_ISSET(rawiprecvsock, activeset)) FD_CLR (rawiprecvsock, activeset); } int handle_snap_request(){ /* if (!snap_recv_pkt (ethsock, &p)){ d_printf(50,"handle_snap_request : received SNAP message over ETHERNET ... parsing\n"); snap_interp_packet(p); d_printf(50,"handle_snap_request : ... finished parsing\n"); return 0; } */ if (!snap_recv_pkt (rawiprecvsock, &p)){ d_printf_timed(10,"handle_snap_request : received SNAP message over RAWIP ... parsing\n"); snap_interp_packet(p); d_printf_timed(10,"handle_snap_request : ... finished parsing\n"); return 0; } /* d_printf(50,"handle_snap_request : received non SNAP message... discarding\n"); */ return 1; } int snap_receive(){ /* initialize the select() vars */ d_printf(50,"snap_receive : waiting for message\n"); FD_ZERO(&rfds); /* FD_SET(ethsock, &rfds);*/ /* FD_SET(udpsock, &rfds);*/ FD_SET(rawiprecvsock, &rfds); /* wait for messages */ if (select(maxfd, &rfds, NULL, NULL, NULL) < 0) { perror("select"); exit(EXIT_FAILURE); } /* handle messages received through ethernet */ /* if (FD_ISSET(ethsock,&rfds)) { if (snap_recv_pkt(ethsock,&p) == 0) { d_printf(50,"snap_receive : received SNAP message over ethernet ... parsing\n"); (void)snap_interp_packet(p); d_printf(50,"snap_receive : ... finished parsing\n"); } d_printf(50,"snap_receive : received non SNAP message over ethernet ... discarding\n"); } */ /* handle messages received through UDP */ /* if (FD_ISSET(udpsock,&rfds)) { if (snap_recv_pkt(udpsock,&p, 0) == 0) { d_printf(50,"snap_receive : received SNAP message over UDP ... parsing\n"); (void)snap_interp_packet(p); d_printf(50,"snap_receive : ... finished parsing\n"); } fprintf(stderr,"snap_receive : received non SNAP message over UDP ... discarding\n"); } */ /* handle messages received through RAWIPSOCK (where this is the destination */ if (FD_ISSET(rawiprecvsock,&rfds)) { if (snap_recv_pkt(rawiprecvsock,&p) == 0) { d_printf_timed(5,"snap_receive : received SNAP message over RAW IP ... parsing\n"); (void)snap_interp_packet(p); d_printf_timed(5,"snap_receive : ... finished parsing\n"); } else fprintf(stderr,"snap_receive : received non SNAP message over RAW IP ... discarding\n"); } return 0; } void usage(char *myname) { fprintf(stderr,"usage: %s [-?v] [-l localaddr]\n",myname); fprintf(stderr," -? : this help\n"); fprintf(stderr," -v : print version and exit\n"); fprintf(stderr," -l : set return val for HERE\n"); fprintf(stderr," -d : set debug level (-1 .. 100)\n"); fflush(stderr); } void parse_cmdline_snap(int argc, char **argv) { /* char *optstring = "?vsl:"; struct option longopts[] = { { "help", 0, NULL, '?' }, { "version", 0, NULL, 'v' }, { "localaddr", 1, NULL, 'l' }, { "shared" , 0, NULL, 's' }, { NULL, 0, NULL, 0 } }; */ int args_in = 0; int args_expected = 0; int ret; char c = 0; /* establish defaults */ /* No defaults yet. */ for (ret=0; ret < argc; ret++){ d_printf(90," argument %d: %s\n",ret, argv[ret]); if (strlen(argv[ret]) > 1) c = argv[ret][1]; if (strlen(argv[ret]) > 1 && argv[ret][0] == '-') switch(c) { case '?': usage(basename(argv[0])); exit(EXIT_SUCCESS); break; case 'v': printf("%s version %s\n",PACKAGE,VERSION); printf("%s: SNAP virtual machine daemon\n", basename(argv[0])); printf("Copyright (C) 2002,2001 by Jonathan T. Moore and Michael Hicks\n"); printf(" wjdb hack (c) Willem J. de Bruijn, 2002\n"); exit(EXIT_SUCCESS); break; case 'l': { unsigned int c1,c2,c3,c4; unsigned int haddr; if (sscanf(optarg,"%d.%d.%d.%d",&c1,&c2,&c3,&c4) != 4) { fprintf(stderr,"%s: bad local address %s\n", basename(argv[0]),optarg); fflush(stderr); usage(basename(argv[0])); exit(EXIT_FAILURE); } haddr = (c1 << 24) | (c2 << 16) | (c3 << 8) | c4; gc.herehint.sin_addr.s_addr = htonl(haddr); d_printf(5,"%s:%d: local address set to %d.%d.%d.%d\n", __FILE__,__LINE__, NIPQUAD(gc.herehint.sin_addr.s_addr)); } break; case 'd': { int newdebuglvl = atoi(argv[ret+1]); if (newdebuglvl >= -1 && newdebuglvl <= 100) set_debug_level_int(newdebuglvl); d_printf(50,"%s:%d: debug level set to %d\n",__FILE__,__LINE__,sysctl_snap_debug_level); } break; default: printf("%s: unknown option '-%c'\n",basename(argv[0]),c); usage(basename(argv[0])); exit(EXIT_FAILURE); } } /* while(optind < argc) { switch(args_in) { default: printf("%s: extra argument(s)\n",basename(argv[0])); usage(basename(argv[0])); exit(EXIT_FAILURE); } args_in++; optind++; }*/ if (args_in < args_expected) { printf("%s: missing argument(s)\n",basename(argv[0])); usage(basename(argv[0])); exit(EXIT_FAILURE); } assert(args_in == args_expected); } /* call the interpreter directly */ int init_snap(int argc, char** argv){ struct cmdline_args cargs; cargs.argc = argc; cargs.argv = argv; return snap(&cargs); }