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