/********************************************************************** * Copyright (c) Digital Equipment Corporation 1984, 1985, 1986. * * All Rights Reserved. * * Reference "/usr/src/COPYRIGHT" for applicable restrictions. * **********************************************************************/ /* * Copyright (c) 1982 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. * * SCCSID: @(#)ip_output.c 3.0 4/21/86 * @(#)ip_output.c 3.0 (Berkeley) 4/21/86 */ #include <sys/param.h> #include <sys/mbuf.h> #include <errno.h> #include <sys/socket.h> #include <sys/socketvar.h> #include <net/if.h> #include <net/route.h> #include <netinet/in.h> #include <netinet/in_systm.h> #include <netinet/in_var.h> #include <netinet/ip.h> #include <netinet/ip_var.h> #ifdef vax #include "../vax/mtpr.h" #endif ip_output(m, opt, ro, flags) struct mbuf *m; struct mbuf *opt; struct route *ro; int flags; { #ifndef pdp11 register struct ip *ip = mtod(m, struct ip *); #else pdp11 register struct ip *ip; #endif pdp11 register struct ifnet *ifp; int len, hlen = sizeof (struct ip), off, error = 0; struct route iproute; struct sockaddr_in *dst; if (opt) /* XXX */ (void) m_free(opt); /* XXX */ #ifdef pdp11 MAPSAVE(); ip = mtod(m, struct ip *); #endif pdp11 /* * Fill in IP header. */ if ((flags & IP_FORWARDING) == 0) { ip->ip_v = IPVERSION; ip->ip_off &= IP_DF; ip->ip_id = htons(ip_id++); ip->ip_hl = hlen >> 2; } #ifndef BSD else ip->ip_id = htons(ip->ip_id); #endif BSD /* * Route packet. */ if (ro == 0) { ro = &iproute; bzero((caddr_t)ro, sizeof (*ro)); } dst = (struct sockaddr_in *)&ro->ro_dst; if (ro->ro_rt == 0) { dst->sin_family = AF_INET; dst->sin_addr = ip->ip_dst; /* * If routing to interface only, * short circuit routing lookup. */ if (flags & IP_ROUTETOIF) { struct in_ifaddr *ia; ia = in_iaonnetof(in_netof(ip->ip_dst)); if (ia == 0) { error = ENETUNREACH; goto bad; } ifp = ia->ia_ifp; goto gotif; } rtalloc(ro); } else if ((ro->ro_rt->rt_flags & RTF_UP) == 0) { /* * The old route has gone away; try for a new one. */ rtfree(ro->ro_rt); ro->ro_rt = NULL; rtalloc(ro); } if (ro->ro_rt == 0 || (ifp = ro->ro_rt->rt_ifp) == 0) { error = ENETUNREACH; goto bad; } ro->ro_rt->rt_use++; if (ro->ro_rt->rt_flags & (RTF_GATEWAY|RTF_HOST)) dst = (struct sockaddr_in *)&ro->ro_rt->rt_gateway; gotif: #ifndef notdef /* * If source address not specified yet, use address * of outgoing interface. */ if (ip->ip_src.s_addr == INADDR_ANY) { register struct in_ifaddr *ia; for (ia = in_ifaddr; ia; ia = ia->ia_next) if (ia->ia_ifp == ifp) { ip->ip_src = IA_SIN(ia)->sin_addr; break; } } #endif /* * Look for broadcast address and * and verify user is allowed to send * such a packet. */ if (in_broadcast(dst->sin_addr)) { if ((ifp->if_flags & IFF_BROADCAST) == 0) { error = EADDRNOTAVAIL; goto bad; } if ((flags & IP_ALLOWBROADCAST) == 0) { error = EACCES; goto bad; } /* don't allow broadcast messages to be fragmented */ if (ip->ip_len > ifp->if_mtu) { error = EMSGSIZE; goto bad; } } /* * If small enough for interface, can just send directly. */ if (ip->ip_len <= ifp->if_mtu) { ip->ip_len = htons((u_short)ip->ip_len); ip->ip_off = htons((u_short)ip->ip_off); ip->ip_sum = 0; ip->ip_sum = in_cksum(m, hlen); error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst); goto done; } /* * Too large for interface; fragment if possible. * Must be able to put at least 8 bytes per fragment. */ if (ip->ip_off & IP_DF) { error = EMSGSIZE; goto bad; } len = (ifp->if_mtu - hlen) &~ 7; if (len < 8) { error = EMSGSIZE; goto bad; } /* * Discard IP header from logical mbuf for m_copy's sake. * Loop through length of segment, make a copy of each * part and output. */ #ifdef pdp11 # define IP ((struct ip *)&ipcopy[0]) { u_char ipcopy[64]; bcopy((caddr_t)ip, (caddr_t)ipcopy, hlen&0x3f); #else # define IP ip #endif pdp11 m->m_len -= sizeof (struct ip); m->m_off += sizeof (struct ip); for (off = 0; off < IP->ip_len-hlen; off += len) { struct mbuf *mh = m_get(M_DONTWAIT, MT_HEADER); struct ip *mhip; if (mh == 0) { error = ENOBUFS; goto bad; } mh->m_off = MMAXOFF - hlen; mhip = mtod(mh, struct ip *); *mhip = *IP; if (hlen > sizeof (struct ip)) { int olen = ip_optcopy(IP, mhip, off); mh->m_len = sizeof (struct ip) + olen; } else mh->m_len = sizeof (struct ip); mhip->ip_off = off >> 3; if (IP->ip_off & IP_MF) mhip->ip_off |= IP_MF; if (off + len >= IP->ip_len-hlen) len = mhip->ip_len = IP->ip_len - hlen - off; else { mhip->ip_len = len; mhip->ip_off |= IP_MF; } mhip->ip_len += sizeof (struct ip); mhip->ip_len = htons((u_short)mhip->ip_len); mh->m_next = m_copy(m, off, len); if (mh->m_next == 0) { (void) m_free(mh); error = ENOBUFS; /* ??? */ goto bad; } mhip->ip_off = htons((u_short)mhip->ip_off); mhip->ip_sum = 0; mhip->ip_sum = in_cksum(mh, hlen); if (error = (*ifp->if_output)(ifp, mh, (struct sockaddr *)dst)) break; } #ifdef pdp11 } #endif pdp11 bad: m_freem(m); done: if (ro == &iproute && (flags & IP_ROUTETOIF) == 0 && ro->ro_rt) RTFREE(ro->ro_rt); #ifdef pdp11 MAPREST(); #endif pdp11 return (error); } /* * Copy options from ip to jp. * If off is 0 all options are copied * otherwise copy selectively. */ static ip_optcopy(ip, jp, off) struct ip *ip, *jp; int off; { register u_char *cp, *dp; int opt, optlen, cnt; cp = (u_char *)(ip + 1); dp = (u_char *)(jp + 1); cnt = (ip->ip_hl << 2) - sizeof (struct ip); for (; cnt > 0; cnt -= optlen, cp += optlen) { opt = cp[0]; if (opt == IPOPT_EOL) break; if (opt == IPOPT_NOP) optlen = 1; else optlen = cp[1]; if (optlen > cnt) /* XXX */ optlen = cnt; /* XXX */ if (off == 0 || IPOPT_COPIED(opt)) { bcopy((caddr_t)cp, (caddr_t)dp, (unsigned)optlen); dp += optlen; } } for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++) *dp++ = IPOPT_EOL; return (optlen); }