![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_imphost.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / sys / netimp|
Return to if_imphost.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / netimp |
1.1 root 1: /* if_imphost.c 6.1 83/07/29 */
2:
3: #include "imp.h"
4: #if NIMP > 0
5: /*
6: * Host table manipulation routines.
7: * Only needed when shipping stuff through an IMP.
8: *
9: * Everything in here is called at splimp from
10: * from the IMP protocol code (if_imp.c), or
11: * interlocks with the code at splimp.
12: */
13: #include "../h/param.h"
14: #include "../h/mbuf.h"
15:
16: #include "../netinet/in.h"
17: #include "../netinet/in_systm.h"
18:
19: #include "../netimp/if_imp.h"
20: #include "../netimp/if_imphost.h"
21:
22: /*
23: * Head of host table hash chains.
24: */
25: struct mbuf *hosts;
26:
27: /*
28: * Given an internet address
29: * return a host structure (if it exists).
30: */
31: struct host *
32: hostlookup(addr)
33: struct in_addr addr;
34: {
35: register struct host *hp;
36: register struct mbuf *m;
37: register int hash = HOSTHASH(addr);
38:
39: for (m = hosts; m; m = m->m_next) {
40: hp = &mtod(m, struct hmbuf *)->hm_hosts[hash];
41: if (hp->h_addr.s_addr == addr.s_addr) {
42: hp->h_flags |= HF_INUSE;
43: return (hp);
44: }
45: }
46: return ((struct host *)0);
47: }
48:
49: /*
50: * Enter a reference to this host's internet
51: * address. If no host structure exists, create
52: * one and hook it into the host database.
53: */
54: struct host *
55: hostenter(addr)
56: struct in_addr addr;
57: {
58: register struct mbuf *m, **mprev;
59: register struct host *hp, *hp0 = 0;
60: register int hash = HOSTHASH(addr);
61:
62: mprev = &hosts;
63: while (m = *mprev) {
64: mprev = &m->m_next;
65: hp = &mtod(m, struct hmbuf *)->hm_hosts[hash];
66: if ((hp->h_flags & HF_INUSE) == 0) {
67: if (hp->h_addr.s_addr == addr.s_addr)
68: goto foundhost;
69: if (hp0 == 0)
70: hp0 = hp;
71: continue;
72: }
73: if (hp->h_addr.s_addr == addr.s_addr)
74: goto foundhost;
75: }
76:
77: /*
78: * No current host structure, make one.
79: * If our search ran off the end of the
80: * chain of mbuf's, allocate another.
81: */
82: if (hp0 == 0) {
83: m = m_getclr(M_DONTWAIT, MT_HTABLE);
84: if (m == NULL)
85: return ((struct host *)0);
86: *mprev = m;
87: hp0 = &mtod(m, struct hmbuf *)->hm_hosts[hash];
88: }
89: mtod(dtom(hp0), struct hmbuf *)->hm_count++;
90: hp = hp0;
91: hp->h_addr = addr;
92: hp->h_timer = 0;
93: hp->h_flags = 0;
94:
95: foundhost:
96: hp->h_flags |= HF_INUSE;
97: return (hp);
98: }
99:
100: /*
101: * Mark a host structure free and set it's
102: * timer going.
103: */
104: hostfree(hp)
105: register struct host *hp;
106: {
107:
108: hp->h_flags &= ~HF_INUSE;
109: hp->h_timer = HOSTTIMER;
110: hp->h_rfnm = 0;
111: }
112:
113: /*
114: * Reset a given network's host entries.
115: */
116: hostreset(net)
117: int net;
118: {
119: register struct mbuf *m;
120: register struct host *hp, *lp;
121: struct hmbuf *hm;
122:
123: for (m = hosts; m; m = m->m_next) {
124: hm = mtod(m, struct hmbuf *);
125: hp = hm->hm_hosts;
126: lp = hp + HPMBUF;
127: while (hm->hm_count > 0 && hp < lp) {
128: if (hp->h_addr.s_net == net) {
129: hp->h_flags &= ~HF_INUSE;
130: hostrelease(hp);
131: }
132: hp++;
133: }
134: }
135: }
136:
137: /*
138: * Remove a host structure and release
139: * any resources it's accumulated.
140: */
141: hostrelease(hp)
142: register struct host *hp;
143: {
144: register struct mbuf *m, **mprev, *mh = dtom(hp);
145:
146: /*
147: * Discard any packets left on the waiting q
148: */
149: if (m = hp->h_q) {
150: register struct mbuf *n;
151:
152: do {
153: n = m->m_act;
154: m_freem(m);
155: m = n;
156: } while (m != hp->h_q);
157: hp->h_q = 0;
158: }
159: hp->h_flags = 0;
160: if (--mtod(mh, struct hmbuf *)->hm_count)
161: return;
162: mprev = &hosts;
163: while ((m = *mprev) != mh)
164: mprev = &m->m_next;
165: *mprev = m_free(mh);
166: }
167:
168: /*
169: * Remove a packet from the holding q.
170: * The RFNM counter is also bumped.
171: */
172: struct mbuf *
173: hostdeque(hp)
174: register struct host *hp;
175: {
176: register struct mbuf *m;
177:
178: hp->h_rfnm--;
179: HOST_DEQUE(hp, m);
180: if (m)
181: return (m);
182: if (hp->h_rfnm == 0)
183: hostfree(hp);
184: return (0);
185: }
186:
187: /*
188: * Host data base timer routine.
189: * Decrement timers on structures which are
190: * waiting to be deallocated. On expiration
191: * release resources, possibly deallocating
192: * mbuf associated with structure.
193: */
194: hostslowtimo()
195: {
196: register struct mbuf *m;
197: register struct host *hp, *lp;
198: struct hmbuf *hm;
199: int s = splimp();
200:
201: for (m = hosts; m; m = m->m_next) {
202: hm = mtod(m, struct hmbuf *);
203: hp = hm->hm_hosts;
204: lp = hp + HPMBUF;
205: for (; hm->hm_count > 0 && hp < lp; hp++) {
206: if (hp->h_flags & HF_INUSE)
207: continue;
208: if (hp->h_timer && --hp->h_timer == 0)
209: hostrelease(hp);
210: }
211: }
212: splx(s);
213: }
214: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.