[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/snap_kern_iface.c Go to the documentation of this file. /* * snap_kern_iface.c : interface between snap interpreter and the rest * of the kernel networking code */ #include <asm/types.h> #include <assert.h> #include <errno.h> #include <features.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 <net/if.h> #include <net/if_arp.h> #include <netdb.h> #include <netinet/in.h> #include <netinet/ip.h> #include <stdlib.h> #include <sys/types.h> #include <sys/ioctl.h> #include <sys/socket.h> #include <sys/un.h> #include <unistd.h> #include "d_printf.h" #include "packet.h" #include "memalloc.h" #include "interface.h" #include "sockets.h" #include "pathnames.h" #include "intl.h" #include "net-support.h" #include "router.h" #include "io.h" #include "warn.h" #define NIPQUAD(addr) \ ((unsigned char *)&(addr))[0], \ ((unsigned char *)&(addr))[1], \ ((unsigned char *)&(addr))[2], \ ((unsigned char *)&(addr))[3] #ifdef CONFIG_IP_SNAP static inline unsigned short ip_fast_csum(unsigned char * iph, unsigned int ihl); #ifdef CONFIG_IP_SNAP_DEBUG int sysctl_snap_debug_level = 0; #endif /* CONFIG_IP_SNAP_DEBUG */ /* hardware interface definitions */ struct if_info { struct if_nameindex ifni; __u32 addr; char hwaddr[32]; }; /* hardware interface variables */ struct sockaddr_in *thishosthint = NULL; struct hostent *thishe = NULL; unsigned int numifs = 0; struct if_info *ifs = NULL; unsigned int maxifnum = 0; unsigned int ifs_size = 0; /* the send sockets */ static int rawip_send_ra_socket; void init_kern_iface(struct sockaddr_in *hint) { char hostname[128]; struct if_nameindex *allifs; struct if_nameindex *currif; struct interface ife; unsigned char ra_space[4]; /* get the primary hostname */ if ((hint != NULL) && (hint->sin_addr.s_addr != 0)) { thishosthint = hint; } if (gethostname(hostname,sizeof(hostname)) < 0) { perror("gethostname"); exit(EXIT_FAILURE); } if ((thishe = gethostbyname(hostname)) == NULL) { herror("gethostbyname"); fprintf(stderr,"debug >> error while trying to resolve %s\n",hostname); exit(EXIT_FAILURE); } if ((rawip_send_ra_socket = socket(AF_INET, SOCK_RAW, IPPROTO_SNAP)) < 0) { perror("snap_kern_iface: rawip_send_ra_socket: socket()"); exit(EXIT_FAILURE); } ra_space[IPOPT_OPTVAL] = IPOPT_RA; ra_space[IPOPT_OLEN] = 4; ra_space[2] = ra_space[3] = 0; if (setsockopt(rawip_send_ra_socket, IPPROTO_IP, IP_OPTIONS, ra_space, sizeof(ra_space)) < 0) { perror("rawip_send_ra_socket: router alert setsockopt()"); exit(EXIT_FAILURE); } /* retrieve the active interfaces from the kernel */ if ((skfd = sockets_open()) < 0) { perror("skfd: sockets_open()"); exit(EXIT_FAILURE); } /* collect IFACE info from glibc functions */ if ((allifs = if_nameindex()) == NULL) { perror("if_nameindex"); exit(EXIT_FAILURE); } for (currif = allifs; (currif->if_index != 0) && (currif->if_name != NULL); currif++) { if (currif->if_index > maxifnum) { maxifnum = currif->if_index; } numifs++; } d_printf(40,"found %d interfaces\n",numifs); assert(maxifnum > 0); /* get additional IFACE info from local functions */ memalloc(ifs,struct if_info *,sizeof(struct if_info) * (maxifnum + 1)); ifs_size = maxifnum + 1; for (currif = allifs;(currif->if_index != 0) && (currif->if_name != NULL); currif++) { (void)if_fetch(currif->if_name, &ife); ifs[currif->if_index].ifni.if_index = currif->if_index; ifs[currif->if_index].ifni.if_name = currif->if_name; ifs[currif->if_index].addr = (*(struct sockaddr_in *)(&ife.addr)).sin_addr.s_addr; memcpy(ifs[currif->if_index].hwaddr, ife.hwaddr, 32); d_printf(45,"if_index %d = %s inaddr = %d.%d.%d.%d\n", currif->if_index,currif->if_name, NIPQUAD((*(struct sockaddr_in *)(&ife.addr)).sin_addr.s_addr)); fflush(stderr); } /* read additional IFACE and ROUTE info from /proc NB: IFACE info from /proc/net/dev is used for ifacename<->ifaceindex translation I don't know why Jon implemented this. */ read_ifaces(PROC_NET_DEV_PATH); read_routes(PROC_NET_ROUTE_PATH); } /* returns one of the current host's IP addresses, preferably not 127.0.0.1 */ #ifdef __KERNEL__ int snap_here(u32 *addr, struct sk_buff *skb) { #else int snap_here(__u32 *addr, packet_t *p) { #endif int i; __u32 tmpaddr; if (thishosthint != NULL) { d_printf(50,"%s:%d: HERE: found non-loopback addr\n", __FILE__,__LINE__); *addr = thishosthint->sin_addr.s_addr; return 0; } assert(thishe != NULL); for(i=0; thishe->h_addr_list[i] != NULL; i++) { tmpaddr = *(__u32 *)thishe->h_addr_list[i]; if (tmpaddr != htonl(INADDR_LOOPBACK)) { d_printf(50,"%s:%d: HERE: found non-loopback addr\n", __FILE__,__LINE__); *addr = tmpaddr; return 0; } } if (i > 0) { d_printf(50,"%s:%d: HERE: ran through %d ifs, all loopback!\n", __FILE__,__LINE__,i); *addr = *(__u32 *)thishe->h_addr_list[0]; return 0; } return -1; } #ifdef __KERNEL__ int getdevindex(struct device *dev_in) { return -1; /* not found */ } #endif int next_hop(__u32 *hop, __u32 daddr, /* where we are headed */ int tos ) { /* type of service */ struct rt_lookup rt; if (nexthop(daddr,&rt) < 0) { *hop = 0; return -1; } *hop = rt.hopaddr; return 0; } #ifdef __KERNEL__ int ishere(__u32 addr, struct sk_buff *skb) { #else int ishere(__u32 addr, packet_t *p) { #endif int i; struct if_info *curr; for(i=0; i<=maxifnum; i++) { curr = &ifs[i]; d_printf(100,"%s:%d: curr=%d, here=(%d.%d.%d.%d)\n", __FILE__,__LINE__,i,NIPQUAD(curr->addr)); if ((curr->ifni.if_index != 0) && (curr->ifni.if_name != NULL) && (curr->addr == addr)) { d_printf(100,"%s:%d: ishere(%d.%d.%d.%d) -> YES\n", __FILE__,__LINE__,NIPQUAD(addr)); return 1; } } d_printf(100,"%s:%d: ishere(%d.%d.%d.%d) -> NO\n", __FILE__,__LINE__,NIPQUAD(addr)); return 0; } /* protocol specific demux send handlers */ #include "../src/snap_demux_handler.h" #ifdef __KERNEL__ int snap_demux_send_unix(__u16 destport, struct sk_buff *skb, void *s, unsigned int slen) { #else int snap_demux_send_unix(__u16 destport, packet_t *p, void *s, unsigned int slen) { #endif int usock; struct sockaddr_un laddr; d_printf_timed(7,"snap_demux_send_unix : creating socket\n"); if ((usock = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0) { perror("snap_demux_send_unix: socket()"); return -1; } d_printf_timed(7,"snap_demux_send_unix : creating sockaddr_un struct\n"); laddr.sun_family = AF_UNIX; sprintf(laddr.sun_path, "/tmp/snap%d",destport); d_printf_timed(7,"snap_demux_send_unix : sending \n"); if (sendto(usock, s, slen, 0, (struct sockaddr *)&laddr, sizeof(laddr)) < slen) { perror("snap_demux_send_unix: sendto()"); return -1; } d_printf_timed(7,"snap_demux_send_unix : finished \n"); close(usock); return 0; } #ifdef __KERNEL__ int snap_demux_send_rawip(__u16 destport, struct sk_buff *skb, void *s, unsigned int slen) { #else int snap_demux_send_rawip(__u16 destport, packet_t *p, void *s, unsigned int slen) { #endif struct sockaddr_in bindaddr; int socket_rawip; if ((socket_rawip = socket(AF_INET, SOCK_RAW, IPPROTO_SNAP)) < 0) { perror("snap_demux_send_rawip: socket()"); return 1; } memset(&bindaddr, 0, sizeof(bindaddr)); bindaddr.sin_family = AF_INET; bindaddr.sin_addr.s_addr = htonl( (127 << 24) + 1 ); /* == 127.0.0.1 */ if (sendto(socket_rawip, s, slen, 0, (struct sockaddr *)&bindaddr, sizeof(bindaddr)) < slen) { perror("snap_demux_send_udp: sendto()"); close (socket_rawip); return -1; } close (socket_rawip); return 0; } #ifdef __KERNEL__ int snap_demux_send_udp(__u16 destport, struct sk_buff *skb, void *s, unsigned int slen) { #else int snap_demux_send_udp(__u16 destport, packet_t *p, void *s, unsigned int slen) { #endif struct sockaddr_in bindaddr; int socket_udp; d_printf_timed(7,"snap_demux_send_udp : creating socket\n"); if ((socket_udp = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { perror("snap_demux_send_udp: socket()"); return 1; } d_printf_timed(7,"snap_demux_send_udp : creating sockaddr_in struct\n"); memset(&bindaddr, 0, sizeof(bindaddr)); bindaddr.sin_family = AF_INET; bindaddr.sin_addr.s_addr = htonl( (127 << 24) + 1 ); /* == 127.0.0.1 */ bindaddr.sin_port = htons(destport); d_printf_timed(7,"snap_demux_send_udp : sending \n"); if (sendto(socket_udp, s, slen, 0, (struct sockaddr *)&bindaddr, sizeof(bindaddr)) < slen) { perror("snap_demux_send_udp: sendto()"); close(socket_udp); return -1; } close(socket_udp); d_printf_timed(7,"snap_demux_send_udp : finished \n"); return 0; } /* handle demux instruction. Outgoing interfaces can be selected by setting an environment variable. For backward compatibility purposes handling defaults to a unix pipe */ #ifdef __KERNEL__ int snap_demux_send(__u16 destport, struct sk_buff *skb, void *s, unsigned int slen) { #else int snap_demux_send(__u16 destport, packet_t *p, void *s, unsigned int slen) { #endif int protocols; int returnvals = 0; char* env_val; d_printf_timed(7,"snap_demux_send : preparing for send ..\n"); /* retrieve the protocols */ env_val = getenv("SNAP_DEMUX_HANDLER"); if (env_val != NULL) protocols = atoi(env_val); else protocols = SNAP_UDP; if (protocols & SNAP_UNIX) returnvals += snap_demux_send_unix(destport, p, s, slen); if (protocols & SNAP_RAWIP) returnvals += snap_demux_send_rawip(destport, p, s, slen); if (protocols & SNAP_UDP) returnvals += snap_demux_send_udp(destport, p, s, slen); d_printf_timed(7,"snap_demux_send : .. sent message\n"); return returnvals; } int snap_send_packet(packet_t *p, int stack_amt, __u32 dest, unsigned char rb, int ep, short direct) { struct snaphdr *sh; buffer_t newbuf; __u32 hopaddr; struct rt_lookup rt; struct iphdr *newiph; struct sockaddr_in hopipaddr; d_printf(60,"snap_send_packet : marshalling packet and initializing structure\n"); if (marshal_packet(p, stack_amt, &newbuf)) { warn("%s:%d: marshal_packet failed\n",__FILE__,__LINE__); return -1; } /* modify the snapheader */ newiph = (struct iphdr *)newbuf.s; sh = (struct snaphdr *)(newbuf.s + newiph->ihl * 4); sh->entry_point = htons(ep); sh->daddr = dest; /* create the ip header */ newiph->daddr = dest; newiph->ttl = rb; newiph->check = 0; newiph->check = ip_fast_csum((unsigned char *)newiph, newiph->ihl); /* initialize the sockaddr structure */ memset(&hopipaddr, 0, sizeof(hopipaddr)); hopipaddr.sin_family = AF_INET; /* calculate the next hop only if we do not want a direct connection */ if (!direct){ if (nexthop(dest,&rt) < 0) /* find next IP hop */ return -1; hopaddr = rt.hopaddr; d_printf(100,"%s:%d: indirect send to next hop: %d.%d.%d.%d, ifindex %d\n",__FILE__,__LINE__,NIPQUAD(hopaddr),rt.ifidx); hopipaddr.sin_addr.s_addr = hopaddr; } else { d_printf(100,"%s:%d: direct send to next host: %d.%d.%d.%d, ifindex unknown\n",__FILE__,__LINE__,NIPQUAD(dest)); hopipaddr.sin_addr.s_addr = dest; } if (setsockopt(rawip_send_ra_socket, IPPROTO_IP, IP_TTL, (char *)&rb, sizeof(rb)) < 0) { perror("rawip_send_ra_socket: ttl setsockopt()"); return -1; } d_printf(60,"snap_send_packet : sending packet\n"); if (sendto(rawip_send_ra_socket, sh, newbuf.lenb - (newiph->ihl * 4), 0, (struct sockaddr *)&hopipaddr, sizeof(hopipaddr)) != newbuf.lenb - (newiph->ihl * 4)) { perror("rawip_send_ra_socket: sendto()"); return -1; } d_printf(60,"snap_send_packet : finished\n"); return 0; } packet_t *pkt_dup(packet_t *p) { return NULL; } int next_hop_and_dev(__u32 *hop, int *dev, __u32 daddr) { struct rt_lookup rt; if (nexthop(daddr, &rt) < 0) { *hop = 0; *dev = 0; return -1; } *hop = rt.hopaddr; *dev = rt.ifidx; return 0; } static inline unsigned short ip_fast_csum(unsigned char * iph, unsigned int ihl) { unsigned int sum; __asm__ __volatile__("\n\ movl (%1), %0 \n\ subl $4, %2 \n\ jbe 2f \n\ addl 4(%1), %0 \n\ adcl 8(%1), %0 \n\ adcl 12(%1), %0 \n\ 1: adcl 16(%1), %0 \n\ lea 4(%1), %1 \n\ decl %2 \n\ jne 1b \n\ adcl $0, %0 \n\ movl %0, %2 \n\ shrl $16, %0 \n\ addw %w2, %w0 \n\ adcl $0, %0 \n\ notl %0 \n\ 2: \n\ " /* Since the input registers which are loaded with iph and ipl are modified, we must also specify them as outputs, or gcc will assume they contain their original values. */ : "=r" (sum), "=r" (iph), "=r" (ihl) : "1" (iph), "2" (ihl)); return(sum); } #endif /* CONFIG_IP_SNAP */