![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ip_output.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / sys / netinet|
Return to ip_output.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / netinet |
1.1 root 1: /* ip_output.c 6.2 83/10/22 */
2:
3: #include "../h/param.h"
4: #include "../h/mbuf.h"
5: #include "../h/errno.h"
6: #include "../h/socket.h"
7: #include "../h/socketvar.h"
8:
9: #include "../net/if.h"
10: #include "../net/route.h"
11:
12: #include "../netinet/in.h"
13: #include "../netinet/in_systm.h"
14: #include "../netinet/ip.h"
15: #include "../netinet/ip_var.h"
16:
17: #ifdef vax
18: #include "../vax/mtpr.h"
19: #endif
20:
21: ip_output(m, opt, ro, flags)
22: struct mbuf *m;
23: struct mbuf *opt;
24: struct route *ro;
25: int flags;
26: {
27: register struct ip *ip = mtod(m, struct ip *);
28: register struct ifnet *ifp;
29: int len, hlen = sizeof (struct ip), off, error = 0;
30: struct route iproute;
31: struct sockaddr *dst;
32:
33: if (opt) /* XXX */
34: (void) m_free(opt); /* XXX */
35: /*
36: * Fill in IP header.
37: */
38: ip->ip_hl = hlen >> 2;
39: if ((flags & IP_FORWARDING) == 0) {
40: ip->ip_v = IPVERSION;
41: ip->ip_off &= IP_DF;
42: ip->ip_id = htons(ip_id++);
43: }
44:
45: /*
46: * Route packet.
47: */
48: if (ro == 0) {
49: ro = &iproute;
50: bzero((caddr_t)ro, sizeof (*ro));
51: }
52: dst = &ro->ro_dst;
53: if (ro->ro_rt == 0) {
54: ro->ro_dst.sa_family = AF_INET;
55: ((struct sockaddr_in *)&ro->ro_dst)->sin_addr = ip->ip_dst;
56: /*
57: * If routing to interface only,
58: * short circuit routing lookup.
59: */
60: if (flags & IP_ROUTETOIF) {
61: ifp = if_ifonnetof(in_netof(ip->ip_dst));
62: if (ifp == 0) {
63: error = ENETUNREACH;
64: goto bad;
65: }
66: goto gotif;
67: }
68: rtalloc(ro);
69: }
70: if (ro->ro_rt == 0 || (ifp = ro->ro_rt->rt_ifp) == 0) {
71: error = ENETUNREACH;
72: goto bad;
73: }
74: ro->ro_rt->rt_use++;
75: if (ro->ro_rt->rt_flags & (RTF_GATEWAY|RTF_HOST))
76: dst = &ro->ro_rt->rt_gateway;
77: gotif:
78: #ifndef notdef
79: /*
80: * If source address not specified yet, use address
81: * of outgoing interface.
82: */
83: if (in_lnaof(ip->ip_src) == INADDR_ANY)
84: ip->ip_src.s_addr =
85: ((struct sockaddr_in *)&ifp->if_addr)->sin_addr.s_addr;
86: #endif
87:
88: /*
89: * Look for broadcast address and
90: * and verify user is allowed to send
91: * such a packet.
92: */
93: if (in_lnaof(((struct sockaddr_in *)dst)->sin_addr) == INADDR_ANY) {
94: if ((ifp->if_flags & IFF_BROADCAST) == 0) {
95: error = EADDRNOTAVAIL;
96: goto bad;
97: }
98: if ((flags & IP_ALLOWBROADCAST) == 0) {
99: error = EACCES;
100: goto bad;
101: }
102: /* don't allow broadcast messages to be fragmented */
103: if (ip->ip_len > ifp->if_mtu) {
104: error = EMSGSIZE;
105: goto bad;
106: }
107: }
108:
109: /*
110: * If small enough for interface, can just send directly.
111: */
112: if (ip->ip_len <= ifp->if_mtu) {
113: ip->ip_len = htons((u_short)ip->ip_len);
114: ip->ip_off = htons((u_short)ip->ip_off);
115: ip->ip_sum = 0;
116: ip->ip_sum = in_cksum(m, hlen);
117: error = (*ifp->if_output)(ifp, m, dst);
118: goto done;
119: }
120:
121: /*
122: * Too large for interface; fragment if possible.
123: * Must be able to put at least 8 bytes per fragment.
124: */
125: if (ip->ip_off & IP_DF) {
126: error = EMSGSIZE;
127: goto bad;
128: }
129: len = (ifp->if_mtu - hlen) &~ 7;
130: if (len < 8) {
131: error = EMSGSIZE;
132: goto bad;
133: }
134:
135: /*
136: * Discard IP header from logical mbuf for m_copy's sake.
137: * Loop through length of segment, make a copy of each
138: * part and output.
139: */
140: m->m_len -= sizeof (struct ip);
141: m->m_off += sizeof (struct ip);
142: for (off = 0; off < ip->ip_len-hlen; off += len) {
143: struct mbuf *mh = m_get(M_DONTWAIT, MT_HEADER);
144: struct ip *mhip;
145:
146: if (mh == 0) {
147: error = ENOBUFS;
148: goto bad;
149: }
150: mh->m_off = MMAXOFF - hlen;
151: mhip = mtod(mh, struct ip *);
152: *mhip = *ip;
153: if (hlen > sizeof (struct ip)) {
154: int olen = ip_optcopy(ip, mhip, off);
155: mh->m_len = sizeof (struct ip) + olen;
156: } else
157: mh->m_len = sizeof (struct ip);
158: mhip->ip_off = off >> 3;
159: if (off + len >= ip->ip_len-hlen)
160: len = mhip->ip_len = ip->ip_len - hlen - off;
161: else {
162: mhip->ip_len = len;
163: mhip->ip_off |= IP_MF;
164: }
165: mhip->ip_len += sizeof (struct ip);
166: mhip->ip_len = htons((u_short)mhip->ip_len);
167: mh->m_next = m_copy(m, off, len);
168: if (mh->m_next == 0) {
169: (void) m_free(mh);
170: error = ENOBUFS; /* ??? */
171: goto bad;
172: }
173: mhip->ip_off = htons((u_short)mhip->ip_off);
174: mhip->ip_sum = 0;
175: mhip->ip_sum = in_cksum(mh, hlen);
176: if (error = (*ifp->if_output)(ifp, mh, dst))
177: break;
178: }
179: m_freem(m);
180: goto done;
181:
182: bad:
183: m_freem(m);
184: done:
185: if (ro == &iproute && (flags & IP_ROUTETOIF) == 0 && ro->ro_rt)
186: RTFREE(ro->ro_rt);
187: return (error);
188: }
189:
190: /*
191: * Copy options from ip to jp.
192: * If off is 0 all options are copied
193: * otherwise copy selectively.
194: */
195: ip_optcopy(ip, jp, off)
196: struct ip *ip, *jp;
197: int off;
198: {
199: register u_char *cp, *dp;
200: int opt, optlen, cnt;
201:
202: cp = (u_char *)(ip + 1);
203: dp = (u_char *)(jp + 1);
204: cnt = (ip->ip_hl << 2) - sizeof (struct ip);
205: for (; cnt > 0; cnt -= optlen, cp += optlen) {
206: opt = cp[0];
207: if (opt == IPOPT_EOL)
208: break;
209: if (opt == IPOPT_NOP)
210: optlen = 1;
211: else
212: optlen = cp[1];
213: if (optlen > cnt) /* XXX */
214: optlen = cnt; /* XXX */
215: if (off == 0 || IPOPT_COPIED(opt)) {
216: bcopy((caddr_t)cp, (caddr_t)dp, (unsigned)optlen);
217: dp += optlen;
218: }
219: }
220: for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
221: *dp++ = IPOPT_EOL;
222: return (optlen);
223: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.