/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2007 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. * * ipv4.c, Code implementing the IPv4 internet protocol. */ #pragma ident "%Z%%M% %I% %E% SMI" #include <sys/types.h> #include <socket_impl.h> #include <socket_inet.h> #include <sys/sysmacros.h> #include <sys/socket.h> #include <netinet/in_systm.h> #include <netinet/in.h> #include <netinet/ip.h> #include <netinet/udp.h> #include <net/if_arp.h> #include <sys/promif.h> #include <sys/bootconf.h> #include <sys/fcntl.h> #include <sys/salib.h> #include "icmp4.h" #include "ipv4.h" #include "ipv4_impl.h" #include "mac.h" #include "mac_impl.h" #include "v4_sum_impl.h" #include <sys/bootdebug.h> static struct ip_frag fragment[FRAG_MAX]; /* ip fragment buffers */ static int fragments; /* Number of fragments */ static uint8_t ttl = MAXTTL; /* IP ttl */ static struct in_addr myip; /* our network-order IP addr */ static struct in_addr mynet; /* net-order netaddr */ static struct in_addr netmask = { 0xff, 0xff, 0xff, 0xff }; /* our network-order netmask */ static boolean_t netmask_set = B_FALSE; /* has anyone set netmask? */ static struct in_addr defaultrouter; /* net-order defaultrouter */ static int promiscuous; /* promiscuous mode */ static struct routing table[IPV4_ROUTE_TABLE_SIZE]; static uint16_t g_ip_id; #ifdef DEBUG #define FRAG_DEBUG #endif /* DEBUG */ #ifdef FRAG_DEBUG /* * display the fragment list. For debugging purposes. */ static void frag_disp(uint16_t size) { int i; uint_t total = 0; printf("Dumping fragment info: (%d)\n\n", fragments); printf("More:\tOffset:\tDatap:\t\tIPid:\t\tIPlen:\tIPhlen:\n"); for (i = 0; i < FRAG_MAX; i++) { if (fragment[i].mp == NULL) continue; printf("%d\t%d\t0x%x\t%d\t\t%d\t%d\n", fragment[i].more, fragment[i].offset, fragment[i].mp->b_rptr, fragment[i].ipid, fragment[i].iplen, fragment[i].iphlen); total += (fragment[i].iplen - fragment[i].iphlen); } printf("Total length is: %d. It should be: %d\n\n", total, size); } #endif /* FRAG_DEBUG */ /* * This function returns index of fragment 0 of the current fragmented DGRAM * (which would contain the transport header). Return the fragment number * for success, -1 if we don't yet have the first fragment. */ static int frag_first(void) { int i; if (fragments == 0) return (-1); for (i = 0; i < FRAG_MAX; i++) { if (fragment[i].mp != NULL && fragment[i].offset == 0) return (i); } return (-1); } /* * This function returns index of the last fragment of the current DGRAM. * Returns the fragment number for success, -1 if we don't yet have the * last fragment. */ static int frag_last(void) { int i; if (fragments == 0) return (-1); for (i = 0; i < FRAG_MAX; i++) { if (fragment[i].mp != NULL && !fragment[i].more) return (i); } return (-1); } /* * This function adds a fragment to the current pkt fragment list. Returns * FRAG_NOSLOTS if there are no more slots, FRAG_DUP if the fragment is * a duplicate, or FRAG_SUCCESS if it is successful. */ static int frag_add(int16_t offset, mblk_t *mp, uint16_t ipid, int16_t iplen, int16_t iphlen, uint8_t ipp) { int i; int16_t true_offset = IPV4_OFFSET(offset); /* first pass - look for duplicates */ for (i = 0; i < FRAG_MAX; i++) { if (fragment[i].mp != NULL && fragment[i].offset == true_offset) return (FRAG_DUP); } /* second pass - fill in empty slot */ for (i = 0; i < FRAG_MAX; i++) { if (fragment[i].mp == NULL) { fragment[i].more = (offset & IP_MF); fragment[i].offset = true_offset; fragment[i].mp = mp; fragment[i].ipid = ipid; fragment[i].iplen = iplen; fragment[i].iphlen = iphlen; fragment[i].ipp = ipp; fragments++; return (FRAG_SUCCESS); } } return (FRAG_NOSLOTS); } /* * Nuke a fragment. */ static void frag_free(int index) { if (fragment[index].mp != NULL) { freeb(fragment[index].mp); fragments--; } bzero((caddr_t)&fragment[index], sizeof (struct ip_frag)); } /* * zero the frag list. */ static void frag_flush(void) { int i; for (i = 0; i < FRAG_MAX; i++) frag_free(i); fragments = 0; } /* * Analyze the fragment list - see if we captured all our fragments. * * Returns TRUE if we've got all the fragments, and FALSE if we don't. */ static int frag_chk(void) { int i, first_frag, last_frag; int16_t actual, total; uint16_t ip_id; uint8_t ipp; if (fragments == 0 || (first_frag = frag_first()) < 0 || (last_frag = frag_last()) < 0) return (FALSE); /* * Validate the ipid's of our fragments - nuke those that don't * match the id of the first fragment or don't match the IP * protocol of the first fragment. */ ip_id = fragment[first_frag].ipid; ipp = fragment[first_frag].ipp; for (i = 0; i < FRAG_MAX; i++) { if (fragment[i].mp != NULL && ip_id != fragment[i].ipid && fragment[i].ipp != ipp) { #ifdef FRAG_DEBUG printf("ipv4: Frag id mismatch: %x != %x\n", fragment[i].ipid, ip_id); #endif /* FRAG_DEBUG */ frag_free(i); } } if (frag_last() < 0) return (FALSE); total = fragment[last_frag].offset + fragment[last_frag].iplen - fragment[last_frag].iphlen; for (i = 0, actual = 0; i < FRAG_MAX; i++) actual += (fragment[i].iplen - fragment[i].iphlen); #ifdef FRAG_DEBUG frag_disp(total); #endif /* FRAG_DEBUG */ return (total == actual); } /* * Load the assembled fragments into igp. Returns 0 for success, nonzero * otherwise. */ static int frag_load(struct inetgram *igp) { int i; int16_t len; uint_t total_len; boolean_t first_frag = B_FALSE; mblk_t *mp; struct ip *iph; int first_iph_len; if (fragments == 0) return (ENOENT); mp = igp->igm_mp; /* Get the IP header length of the first fragment. */ i = frag_first(); assert(i >= 0); first_iph_len = fragment[i].iphlen; for (i = 0, len = 0, total_len = 0; i < FRAG_MAX; i++) { if (fragment[i].mp != NULL) { /* * Copy just the data (omit the ip header of all * fragments except the first one which contains * all the info...) */ if (fragment[i].offset == 0) { len = fragment[i].iplen; first_frag = B_TRUE; } else { len = fragment[i].iplen - fragment[i].iphlen; } total_len += len; if (total_len > mp->b_size) return (E2BIG); if (first_frag) { bcopy((caddr_t)(fragment[i].mp->b_rptr), (caddr_t)mp->b_rptr, len); first_frag = B_FALSE; } else { bcopy((caddr_t)(fragment[i].mp->b_rptr + fragment[i].iphlen), (caddr_t)(mp->b_rptr + first_iph_len + fragment[i].offset), len); } mp->b_wptr += len; } } /* Fix the total length in the IP header. */ iph = (struct ip *)mp->b_rptr; iph->ip_len = htons(total_len); return (0); } /* * Locate a routing table entry based upon arguments. IP addresses expected * in network order. Returns index for success, -1 if entry not found. */ static int find_route(uint8_t *flagp, struct in_addr *destp, struct in_addr *gatewayp) { int i, table_entry = -1; for (i = 0; table_entry == -1 && i < IPV4_ROUTE_TABLE_SIZE; i++) { if (flagp != NULL) { if (*flagp & table[i].flag) table_entry = i; } if (destp != NULL) { if (destp->s_addr == table[i].dest.s_addr) table_entry = i; else table_entry = -1; } if (gatewayp != NULL) { if (gatewayp->s_addr == table[i].gateway.s_addr) table_entry = i; else table_entry = -1; } } return (table_entry); } /* * ADD or DEL a routing table entry. Returns 0 for success, -1 and errno * otherwise. IP addresses are expected in network order. */ int ipv4_route(int cmd, uint8_t flag, struct in_addr *destp, struct in_addr *gatewayp) { static int routing_table_initialized; int index; uint8_t tmp_flag; if (gatewayp == NULL) { errno = EINVAL; return (-1); } /* initialize routing table */ if (routing_table_initialized == 0) { for (index = 0; index < IPV4_ROUTE_TABLE_SIZE; index++) table[index].flag = RT_UNUSED; routing_table_initialized = 1; } switch (cmd) { case IPV4_ADD_ROUTE: tmp_flag = (uint8_t)RT_UNUSED; if ((index = find_route(&tmp_flag, NULL, NULL)) == -1) { dprintf("ipv4_route: routing table full.\n"); errno = ENOSPC; return (-1); } table[index].flag = flag; if (destp != NULL) table[index].dest.s_addr = destp->s_addr; else table[index].dest.s_addr = htonl(INADDR_ANY); table[index].gateway.s_addr = gatewayp->s_addr; break; case IPV4_BAD_ROUTE: /* FALLTHRU */ case IPV4_DEL_ROUTE: if ((index = find_route(&flag, destp, gatewayp)) == -1) { dprintf("ipv4_route: No such routing entry.\n"); errno = ENOENT; return (-1); } if (cmd == IPV4_DEL_ROUTE) { table[index].flag = RT_UNUSED; table[index].dest.s_addr = htonl(INADDR_ANY); table[index].gateway.s_addr = htonl(INADDR_ANY); } else table[index].flag = RT_NG; default: errno = EINVAL; return (-1); } return (0); } /* * Return gateway to destination. Returns gateway IP address in network order * for success, NULL if no route to destination exists. */ struct in_addr * ipv4_get_route(uint8_t flag, struct in_addr *destp, struct in_addr *gatewayp) { int index; if ((index = find_route(&flag, destp, gatewayp)) == -1) return (NULL); return (&table[index].gateway); } /* * Initialize the IPv4 generic parts of the socket, as well as the routing * table. */ void ipv4_socket_init(struct inetboot_socket *isp) { isp->input[NETWORK_LVL] = ipv4_input; isp->output[NETWORK_LVL] = ipv4_output; isp->close[NETWORK_LVL] = NULL; isp->headerlen[NETWORK_LVL] = ipv4_header_len; } /* * Initialize a raw ipv4 socket. */ void ipv4_raw_socket(struct inetboot_socket *isp, uint8_t proto) { isp->type = INETBOOT_RAW; if (proto == 0) isp->proto = IPPROTO_IP; else isp->proto = proto; isp->input[TRANSPORT_LVL] = NULL; isp->output[TRANSPORT_LVL] = NULL; isp->headerlen[TRANSPORT_LVL] = NULL; isp->ports = NULL; } /* * Return the size of an IPv4 header (no options) */ /* ARGSUSED */ int ipv4_header_len(struct inetgram *igm) { return (sizeof (struct ip)); } /* * Set our source address. * Argument is assumed to be host order. */ void ipv4_setipaddr(struct in_addr *ip) { myip.s_addr = htonl(ip->s_addr); } /* * Returns our current source address in host order. */ void ipv4_getipaddr(struct in_addr *ip) { ip->s_addr = ntohl(myip.s_addr); } /* * Set our netmask. * Argument is assumed to be host order. */ void ipv4_setnetmask(struct in_addr *ip) { netmask_set = B_TRUE; netmask.s_addr = htonl(ip->s_addr); mynet.s_addr = netmask.s_addr & myip.s_addr; /* implicit */ } void ipv4_getnetid(struct in_addr *my_netid) { struct in_addr my_netmask; if (mynet.s_addr != 0) my_netid->s_addr = ntohl(mynet.s_addr); else { ipv4_getnetmask(&my_netmask); my_netid->s_addr = my_netmask.s_addr & ntohl(myip.s_addr); } } /* * Returns our current netmask in host order. * Neither OBP nor the standalone DHCP client mandate * that the netmask be specified, so in the absence of * a netmask, we attempt to derive it using class-based * heuristics. */ void ipv4_getnetmask(struct in_addr *ip) { if (netmask_set || (myip.s_addr == 0)) ip->s_addr = ntohl(netmask.s_addr); else { /* base the netmask on our IP address */ if (IN_CLASSA(ntohl(myip.s_addr))) ip->s_addr = ntohl(IN_CLASSA_NET); else if (IN_CLASSB(ntohl(myip.s_addr))) ip->s_addr = ntohl(IN_CLASSB_NET); else if (IN_CLASSC(ntohl(myip.s_addr))) ip->s_addr = ntohl(IN_CLASSC_NET); else ip->s_addr = ntohl(IN_CLASSE_NET); } } /* * Set our default router. * Argument is assumed to be host order, and *MUST* be on the same network * as our source IP address. */ void ipv4_setdefaultrouter(struct in_addr *ip) { defaultrouter.s_addr = htonl(ip->s_addr); } /* * Returns our current default router in host order. */ void ipv4_getdefaultrouter(struct in_addr *ip) { ip->s_addr = ntohl(defaultrouter.s_addr); } /* * Toggle promiscuous flag. If set, client disregards destination IP * address. Otherwise, only limited broadcast, network broadcast, and * unicast traffic get through. Returns previous setting. */ int ipv4_setpromiscuous(int toggle) { int old = promiscuous; promiscuous = toggle; return (old); } /* * Set IP TTL. */ void ipv4_setmaxttl(uint8_t cttl) { ttl = cttl; } /* * Convert an ipv4 address to dotted notation. * Returns ptr to statically allocated buffer containing dotted string. */ char * inet_ntoa(struct in_addr ip) { uint8_t *p; static char ipaddr[16]; p = (uint8_t *)&ip.s_addr; (void) sprintf(ipaddr, "%u.%u.%u.%u", p[0], p[1], p[2], p[3]); return (ipaddr); } /* * Construct a transport datagram from a series of IP fragments (igp == NULL) * or from a single IP datagram (igp != NULL). Return the address of the * contructed transport datagram. */ struct inetgram * make_trans_datagram(int index, struct inetgram *igp, struct in_addr ipsrc, struct in_addr ipdst, uint16_t iphlen) { uint16_t trans_len, *transp, new_len; int first_frag, last_frag; boolean_t fragmented; struct inetgram *ngp; struct ip *iph; fragmented = (igp == NULL); ngp = (struct inetgram *)bkmem_zalloc(sizeof (struct inetgram)); if (ngp == NULL) { errno = ENOMEM; if (fragmented) frag_flush(); return (NULL); } if (fragmented) { last_frag = frag_last(); trans_len = fragment[last_frag].offset + fragment[last_frag].iplen - fragment[last_frag].iphlen; first_frag = frag_first(); /* * The returned buffer contains the IP header of the * first fragment. */ trans_len += fragment[first_frag].iphlen; transp = (uint16_t *)(fragment[first_frag].mp->b_rptr + fragment[first_frag].iphlen); } else { /* * Note that igm_len may not be the real length of an * IP packet because some network interface, such as * Ethernet, as a minimum frame size. So we should not * use the interface frame size to determine the * length of an IP packet. We should use the IP * length field in the IP header. */ iph = (struct ip *)igp->igm_mp->b_rptr; trans_len = ntohs(iph->ip_len); transp = (uint16_t *)(igp->igm_mp->b_rptr + iphlen); } ngp->igm_saddr.sin_addr.s_addr = ipsrc.s_addr; ngp->igm_saddr.sin_port = sockets[index].ports(transp, SOURCE); ngp->igm_target.s_addr = ipdst.s_addr; ngp->igm_level = TRANSPORT_LVL; /* * Align to 16bit value. Checksum code may require an extra byte * for padding. */ new_len = ((trans_len + sizeof (int16_t) - 1) & ~(sizeof (int16_t) - 1)); if ((ngp->igm_mp = allocb(new_len, 0)) == NULL) { errno = ENOMEM; bkmem_free((caddr_t)ngp, sizeof (struct inetgram)); if (fragmented) frag_flush(); return (NULL); } if (fragmented) { if (frag_load(ngp) != 0) { freeb(ngp->igm_mp); bkmem_free((caddr_t)ngp, sizeof (struct inetgram)); frag_flush(); return (NULL); } frag_flush(); } else { bcopy((caddr_t)(igp->igm_mp->b_rptr), (caddr_t)ngp->igm_mp->b_rptr, trans_len); ngp->igm_mp->b_wptr += trans_len; } return (ngp); } /* * ipv4_input: Pull in IPv4 datagrams addressed to us. Handle IP fragmentation * (fragments received in any order) and ICMP at this level. * * Note that because our network is serviced by polling when we expect * something (upon a referenced socket), we don't go through the work of * locating the appropriate socket a datagram is destined for. We'll only * accept data for the referenced socket. This means we don't have * asynchronous networking, but since we can't service the net using an * interrupt handler, it doesn't do us any good to try to service datagrams * destined for sockets other than the referenced one. Data is handled in * a fifo manner. * * The mac layer will grab all frames for us. If we find we don't have all * the necessary fragments to reassemble the datagram, we'll call the mac * layer again for FRAG_ATTEMPTS to see if it has any more frames. * * Supported protocols: IPPROTO_IP, IPPROTO_ICMP, IPPROTO_UDP. * * Returns: number of NETWORK_LVL datagrams placed on socket , -1 if error * occurred. * * Note: errno is set to ETIMEDOUT if fragment reassembly fails. */ int ipv4_input(int index) { int datagrams = 0; int frag_stat, input_attempts = 0; uint16_t iphlen, iplen, ip_id; int16_t curr_off; struct ip *iphp; struct inetgram *igp, *newgp = NULL, *ipv4_listp = NULL; struct in_addr ipdst, ipsrc; mblk_t *mp; enum SockType type; #ifdef DEBUG printf("ipv4_input(%d): start ######################################\n", index); #endif /* DEBUG */ frag_flush(); ipv4_try_again: while ((igp = sockets[index].inq) != NULL) { if (igp->igm_level != NETWORK_LVL) { #ifdef DEBUG printf("ipv4_input(%d): unexpected frame type: %d\n", index, igp->igm_level); #endif /* DEBUG */ del_gram(&sockets[index].inq, igp, TRUE); continue; } iphp = (struct ip *)igp->igm_mp->b_rptr; if (iphp->ip_v != IPVERSION) { dprintf("ipv4_input(%d): IPv%d datagram discarded\n", index, iphp->ip_v); del_gram(&sockets[index].inq, igp, TRUE); continue; } iphlen = iphp->ip_hl << 2; if (iphlen < sizeof (struct ip)) { dprintf("ipv4_input(%d): IP msg too short (%d < %u)\n", index, iphlen, (uint_t)sizeof (struct ip)); del_gram(&sockets[index].inq, igp, TRUE); continue; } iplen = ntohs(iphp->ip_len); if (iplen > msgdsize(igp->igm_mp)) { dprintf("ipv4_input(%d): IP len/buffer mismatch " "(%d > %lu)\n", index, iplen, igp->igm_mp->b_size); del_gram(&sockets[index].inq, igp, TRUE); continue; } bcopy((caddr_t)&(iphp->ip_dst), (caddr_t)&ipdst, sizeof (ipdst)); bcopy((caddr_t)&(iphp->ip_src), (caddr_t)&ipsrc, sizeof (ipsrc)); /* igp->igm_mp->b_datap is guaranteed to be 64 bit aligned] */ if (ipv4cksum((uint16_t *)iphp, iphlen) != 0) { dprintf("ipv4_input(%d): Bad IP header checksum " "(to %s)\n", index, inet_ntoa(ipdst)); del_gram(&sockets[index].inq, igp, TRUE); continue; } if (!promiscuous) { /* validate destination address */ if (ipdst.s_addr != htonl(INADDR_BROADCAST) && ipdst.s_addr != (mynet.s_addr | ~netmask.s_addr) && ipdst.s_addr != myip.s_addr) { #ifdef DEBUG printf("ipv4_input(%d): msg to %s discarded.\n", index, inet_ntoa(ipdst)); #endif /* DEBUG */ /* not ours */ del_gram(&sockets[index].inq, igp, TRUE); continue; } } /* Intercept ICMP first */ if (!promiscuous && (iphp->ip_p == IPPROTO_ICMP)) { icmp4(igp, iphp, iphlen, ipsrc); del_gram(&sockets[index].inq, igp, TRUE); continue; } #ifdef DEBUG printf("ipv4_input(%d): processing ID: 0x%x protocol %d " "(0x%x) (0x%x,%d)\n", index, ntohs(iphp->ip_id), iphp->ip_p, igp, igp->igm_mp, igp->igm_mp->b_size); #endif /* DEBUG */ type = sockets[index].type; if (type == INETBOOT_RAW) { /* No fragmentation - Just the raw packet. */ #ifdef DEBUG printf("ipv4_input(%d): Raw packet.\n", index); #endif /* DEBUG */ del_gram(&sockets[index].inq, igp, FALSE); add_grams(&ipv4_listp, igp); igp->igm_mp->b_rptr += iphlen; igp->igm_mp->b_wptr = igp->igm_mp->b_rptr + iplen; datagrams++; continue; } if ((type == INETBOOT_DGRAM && iphp->ip_p != IPPROTO_UDP) || (type == INETBOOT_STREAM && iphp->ip_p != IPPROTO_TCP)) { /* Wrong protocol. */ dprintf("ipv4_input(%d): unexpected protocol: " "%d for socket type %d\n", index, iphp->ip_p, type); del_gram(&sockets[index].inq, igp, TRUE); continue; } /* * The following code is common to both STREAM and DATAGRAM * sockets. */ /* * Once we process the first fragment, we won't have * the transport header, so we'll have to match on * IP id. */ curr_off = ntohs(iphp->ip_off); if ((curr_off & ~(IP_DF | IP_MF)) == 0) { uint16_t *transp; /* Validate transport header. */ mp = igp->igm_mp; if ((mp->b_wptr - mp->b_rptr - iphlen) < sockets[index].headerlen[TRANSPORT_LVL](igp)) { dprintf("ipv4_input(%d): datagram 0 " "too small to hold transport header " "(from %s)\n", index, inet_ntoa(ipsrc)); del_gram(&sockets[index].inq, igp, TRUE); continue; } /* * check alignment - transport elements are 16 * bit aligned.. */ transp = (uint16_t *)(mp->b_rptr + iphlen); if ((uintptr_t)transp % sizeof (uint16_t)) { dprintf("ipv4_input(%d): Transport " "header is not 16-bit aligned " "(0x%lx, from %s)\n", index, (long)transp, inet_ntoa(ipsrc)); del_gram(&sockets[index].inq, igp, TRUE); continue; } if (curr_off & IP_MF) { /* fragment 0 of fragmented datagram */ ip_id = ntohs(iphp->ip_id); frag_stat = frag_add(curr_off, igp->igm_mp, ip_id, iplen, iphlen, iphp->ip_p); if (frag_stat != FRAG_SUCCESS) { #ifdef FRAG_DEBUG if (frag_stat == FRAG_DUP) { printf("ipv4_input" "(%d): Frag dup.\n", index); } else { printf("ipv4_input" "(%d): too many " "frags\n", index); } #endif /* FRAG_DEBUG */ del_gram(&sockets[index].inq, igp, TRUE); continue; } del_gram(&sockets[index].inq, igp, FALSE); /* keep the data, lose the inetgram */ bkmem_free((caddr_t)igp, sizeof (struct inetgram)); #ifdef FRAG_DEBUG printf("ipv4_input(%d): Frag/Off/Id " "(%d/%d/%x)\n", index, fragments, IPV4_OFFSET(curr_off), ip_id); #endif /* FRAG_DEBUG */ } else { /* Single, unfragmented datagram */ newgp = make_trans_datagram(index, igp, ipsrc, ipdst, iphlen); if (newgp != NULL) { add_grams(&ipv4_listp, newgp); datagrams++; } del_gram(&sockets[index].inq, igp, TRUE); continue; } } else { /* fragments other than 0 */ frag_stat = frag_add(curr_off, igp->igm_mp, ntohs(iphp->ip_id), iplen, iphlen, iphp->ip_p); if (frag_stat == FRAG_SUCCESS) { #ifdef FRAG_DEBUG printf("ipv4_input(%d): Frag(%d) " "off(%d) id(%x)\n", index, fragments, IPV4_OFFSET(curr_off), ntohs(iphp->ip_id)); #endif /* FRAG_DEBUG */ del_gram(&sockets[index].inq, igp, FALSE); /* keep the data, lose the inetgram */ bkmem_free((caddr_t)igp, sizeof (struct inetgram)); } else { #ifdef FRAG_DEBUG if (frag_stat == FRAG_DUP) printf("ipv4_input(%d): Frag " "dup.\n", index); else { printf("ipv4_input(%d): too " "many frags\n", index); } #endif /* FRAG_DEBUG */ del_gram(&sockets[index].inq, igp, TRUE); continue; } } /* * Determine if we have all of the fragments. * * NOTE: at this point, we've placed the data in the * fragment table, and the inetgram (igp) has been * deleted. */ if (!frag_chk()) continue; newgp = make_trans_datagram(index, NULL, ipsrc, ipdst, iphlen); if (newgp == NULL) continue; add_grams(&ipv4_listp, newgp); datagrams++; } if (ipv4_listp == NULL && fragments != 0) { if (++input_attempts > FRAG_ATTEMPTS) { dprintf("ipv4_input(%d): reassembly(%d) timed out in " "%d msecs.\n", index, fragments, sockets[index].in_timeout * input_attempts); frag_flush(); errno = ETIMEDOUT; return (-1); } else { /* * Call the media layer again... there may be more * packets waiting. */ if (sockets[index].input[MEDIA_LVL](index) < 0) { /* errno will be set appropriately */ frag_flush(); return (-1); } goto ipv4_try_again; } } add_grams(&sockets[index].inq, ipv4_listp); return (datagrams); } /* * ipv4_output: Generate IPv4 datagram(s) for the payload and deliver them. * Routing is handled here as well, by reusing the saddr field to hold the * router's IP address. * * We don't deal with fragmentation on the outgoing side. * * Arguments: index to socket, inetgram to send. * * Returns: 0 for success, -1 if error occurred. */ int ipv4_output(int index, struct inetgram *ogp) { struct ip *iphp; uint64_t iphbuffer[sizeof (struct ip)]; #ifdef DEBUG printf("ipv4_output(%d): size %d\n", index, ogp->igm_mp->b_wptr - ogp->igm_mp->b_rptr); #endif /* DEBUG */ /* we don't deal (yet) with fragmentation. Maybe never will */ if ((ogp->igm_mp->b_wptr - ogp->igm_mp->b_rptr) > mac_get_mtu()) { dprintf("ipv4: datagram too big for MAC layer.\n"); errno = E2BIG; return (-1); } if (ogp->igm_level != NETWORK_LVL) { #ifdef DEBUG printf("ipv4_output(%d): unexpected frame type: %d\n", index, ogp->igm_level); #endif /* DEBUG */ errno = EINVAL; return (-1); } if (sockets[index].out_flags & SO_DONTROUTE) ogp->igm_oflags |= MSG_DONTROUTE; iphp = (struct ip *)&iphbuffer; iphp->ip_v = IPVERSION; iphp->ip_hl = sizeof (struct ip) / 4; iphp->ip_tos = 0; iphp->ip_len = htons(ogp->igm_mp->b_wptr - ogp->igm_mp->b_rptr + sizeof (struct ip)); iphp->ip_id = htons(++g_ip_id); iphp->ip_off = htons(IP_DF); iphp->ip_p = sockets[index].proto; iphp->ip_sum = htons(0); iphp->ip_ttl = ttl; /* struct copies */ iphp->ip_src = myip; iphp->ip_dst = ogp->igm_saddr.sin_addr; /* * On local / limited broadcasts, don't route. From a purist's * perspective, we should be setting the TTL to 1. But * operational experience has shown that some BOOTP relay agents * (ciscos) discard our packets. Furthermore, these devices also * *don't* reset the TTL to MAXTTL on the unicast side of the * BOOTP relay agent! Sigh. Thus to work correctly in these * environments, we leave the TTL as it has been been set by * the application layer, and simply don't check for a route. */ if (iphp->ip_dst.s_addr == htonl(INADDR_BROADCAST) || (netmask.s_addr != htonl(INADDR_BROADCAST) && iphp->ip_dst.s_addr == (mynet.s_addr | ~netmask.s_addr))) { ogp->igm_oflags |= MSG_DONTROUTE; } /* Routing necessary? */ if ((ogp->igm_oflags & MSG_DONTROUTE) == 0 && ((iphp->ip_dst.s_addr & netmask.s_addr) != mynet.s_addr)) { struct in_addr *rip; if ((rip = ipv4_get_route(RT_HOST, &iphp->ip_dst, NULL)) == NULL) { rip = ipv4_get_route(RT_DEFAULT, NULL, NULL); } if (rip == NULL) { dprintf("ipv4(%d): No route to %s.\n", index, inet_ntoa(iphp->ip_dst)); errno = EHOSTUNREACH; return (-1); } ogp->igm_router.s_addr = rip->s_addr; } else ogp->igm_router.s_addr = htonl(INADDR_ANY); iphp->ip_sum = ipv4cksum((uint16_t *)iphp, sizeof (struct ip)); ogp->igm_mp->b_rptr -= sizeof (struct ip); bcopy((caddr_t)iphp, (caddr_t)(ogp->igm_mp->b_rptr), sizeof (struct ip)); ogp->igm_level = MEDIA_LVL; return (0); } /* * Function to be called by TCP to send out a packet. This is used * when TCP wants to send out packets which it has already filled in * most of the header fields. */ int ipv4_tcp_output(int sock_id, mblk_t *pkt) { struct ip *iph; struct in_addr *rip = NULL; struct inetgram datagram; iph = (struct ip *)pkt->b_rptr; bzero(&datagram, sizeof (struct inetgram)); /* * Bootparams doesn't know about subnet masks, so we need to * explicitly check for this flag. */ if (sockets[sock_id].out_flags & SO_DONTROUTE) datagram.igm_oflags |= MSG_DONTROUTE; /* Routing necessary? */ if (((datagram.igm_oflags & MSG_DONTROUTE) == 0) && ((iph->ip_dst.s_addr & netmask.s_addr) != mynet.s_addr)) { if ((rip = ipv4_get_route(RT_HOST, &iph->ip_dst, NULL)) == NULL) { rip = ipv4_get_route(RT_DEFAULT, NULL, NULL); } if (rip == NULL) { dprintf("ipv4(%d): No route to %s.\n", sock_id, inet_ntoa(iph->ip_dst)); errno = EHOSTUNREACH; return (-1); } } iph->ip_id = htons(++g_ip_id); iph->ip_sum = ipv4cksum((uint16_t *)iph, sizeof (struct ip)); #if DEBUG > 1 printf("ipv4_tcp_output: dump IP packet(%d)\n", iph->ip_len); hexdump((char *)pkt->b_rptr, iph->ip_len); #endif /* Call the MAC layer output routine to send it out. */ datagram.igm_mp = pkt; datagram.igm_level = MEDIA_LVL; if (rip != NULL) datagram.igm_router.s_addr = rip->s_addr; else datagram.igm_router.s_addr = 0; return (mac_state.mac_output(sock_id, &datagram)); } /* * Internet address interpretation routine. * All the network library routines call this * routine to interpret entries in the data bases * which are expected to be an address. * The value returned is in network order. */ in_addr_t inet_addr(const char *cp) { uint32_t val, base, n; char c; uint32_t parts[4], *pp = parts; if (*cp == '\0') return ((uint32_t)-1); /* disallow null string in cp */ again: /* * Collect number up to ``.''. * Values are specified as for C: * 0x=hex, 0=octal, other=decimal. */ val = 0; base = 10; if (*cp == '0') { if (*++cp == 'x' || *cp == 'X') base = 16, cp++; else base = 8; } while ((c = *cp) != NULL) { if (isdigit(c)) { if ((c - '0') >= base) break; val = (val * base) + (c - '0'); cp++; continue; } if (base == 16 && isxdigit(c)) { val = (val << 4) + (c + 10 - (islower(c) ? 'a' : 'A')); cp++; continue; } break; } if (*cp == '.') { /* * Internet format: * a.b.c.d * a.b.c (with c treated as 16-bits) * a.b (with b treated as 24 bits) */ if ((pp >= parts + 3) || (val > 0xff)) { return ((uint32_t)-1); } *pp++ = val, cp++; goto again; } /* * Check for trailing characters. */ if (*cp && !isspace(*cp)) { return ((uint32_t)-1); } *pp++ = val; /* * Concoct the address according to * the number of parts specified. */ n = pp - parts; switch (n) { case 1: /* a -- 32 bits */ val = parts[0]; break; case 2: /* a.b -- 8.24 bits */ if (parts[1] > 0xffffff) return ((uint32_t)-1); val = (parts[0] << 24) | (parts[1] & 0xffffff); break; case 3: /* a.b.c -- 8.8.16 bits */ if (parts[2] > 0xffff) return ((uint32_t)-1); val = (parts[0] << 24) | ((parts[1] & 0xff) << 16) | (parts[2] & 0xffff); break; case 4: /* a.b.c.d -- 8.8.8.8 bits */ if (parts[3] > 0xff) return ((uint32_t)-1); val = (parts[0] << 24) | ((parts[1] & 0xff) << 16) | ((parts[2] & 0xff) << 8) | (parts[3] & 0xff); break; default: return ((uint32_t)-1); } val = htonl(val); return (val); } void hexdump(char *data, int datalen) { char *p; ushort_t *p16 = (ushort_t *)data; char *p8 = data; int i, left, len; int chunk = 16; /* 16 bytes per line */ printf("\n"); for (p = data; p < data + datalen; p += chunk) { printf("\t%4d: ", (int)(p - data)); left = (data + datalen) - p; len = MIN(chunk, left); for (i = 0; i < (len / 2); i++) printf("%04x ", ntohs(*p16++) & 0xffff); if (len % 2) { printf("%02x ", *((unsigned char *)p16)); } for (i = 0; i < (chunk - left) / 2; i++) printf(" "); printf(" "); for (i = 0; i < len; i++, p8++) printf("%c", isprint(*p8) ? *p8 : '.'); printf("\n"); } printf("\n"); }