]>
Commit | Line | Data |
---|---|---|
f0cbd3ec FB |
1 | /* |
2 | * Copyright (c) 1995 Danny Gasparovski. | |
3 | * | |
4 | * Please read the file COPYRIGHT for the | |
5 | * terms and conditions of the copyright. | |
6 | */ | |
7 | ||
8 | #include <slirp.h> | |
9 | ||
f0cbd3ec | 10 | int if_queued = 0; /* Number of packets queued so far */ |
f0cbd3ec FB |
11 | |
12 | struct mbuf if_fastq; /* fast queue (for interactive data) */ | |
13 | struct mbuf if_batchq; /* queue for non-interactive data */ | |
14 | struct mbuf *next_m; /* Pointer to next mbuf to output */ | |
15 | ||
16 | #define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm)) | |
17 | ||
18 | void | |
19 | ifs_insque(ifm, ifmhead) | |
20 | struct mbuf *ifm, *ifmhead; | |
21 | { | |
22 | ifm->ifs_next = ifmhead->ifs_next; | |
23 | ifmhead->ifs_next = ifm; | |
24 | ifm->ifs_prev = ifmhead; | |
25 | ifm->ifs_next->ifs_prev = ifm; | |
26 | } | |
27 | ||
28 | void | |
29 | ifs_remque(ifm) | |
30 | struct mbuf *ifm; | |
31 | { | |
32 | ifm->ifs_prev->ifs_next = ifm->ifs_next; | |
33 | ifm->ifs_next->ifs_prev = ifm->ifs_prev; | |
34 | } | |
35 | ||
36 | void | |
37 | if_init() | |
38 | { | |
f0cbd3ec FB |
39 | if_fastq.ifq_next = if_fastq.ifq_prev = &if_fastq; |
40 | if_batchq.ifq_next = if_batchq.ifq_prev = &if_batchq; | |
41 | // sl_compress_init(&comp_s); | |
42 | next_m = &if_batchq; | |
43 | } | |
44 | ||
45 | #if 0 | |
46 | /* | |
47 | * This shouldn't be needed since the modem is blocking and | |
48 | * we don't expect any signals, but what the hell.. | |
49 | */ | |
50 | inline int | |
51 | writen(fd, bptr, n) | |
52 | int fd; | |
53 | char *bptr; | |
54 | int n; | |
55 | { | |
56 | int ret; | |
57 | int total; | |
5fafdf24 | 58 | |
f0cbd3ec | 59 | /* This should succeed most of the time */ |
02d2c54c | 60 | ret = send(fd, bptr, n,0); |
f0cbd3ec FB |
61 | if (ret == n || ret <= 0) |
62 | return ret; | |
5fafdf24 | 63 | |
f0cbd3ec FB |
64 | /* Didn't write everything, go into the loop */ |
65 | total = ret; | |
66 | while (n > total) { | |
02d2c54c | 67 | ret = send(fd, bptr+total, n-total,0); |
f0cbd3ec FB |
68 | if (ret <= 0) |
69 | return ret; | |
70 | total += ret; | |
71 | } | |
72 | return total; | |
73 | } | |
74 | ||
75 | /* | |
76 | * if_input - read() the tty, do "top level" processing (ie: check for any escapes), | |
77 | * and pass onto (*ttyp->if_input) | |
5fafdf24 | 78 | * |
f0cbd3ec FB |
79 | * XXXXX Any zeros arriving by themselves are NOT placed into the arriving packet. |
80 | */ | |
81 | #define INBUFF_SIZE 2048 /* XXX */ | |
82 | void | |
83 | if_input(ttyp) | |
84 | struct ttys *ttyp; | |
85 | { | |
86 | u_char if_inbuff[INBUFF_SIZE]; | |
87 | int if_n; | |
5fafdf24 | 88 | |
f0cbd3ec FB |
89 | DEBUG_CALL("if_input"); |
90 | DEBUG_ARG("ttyp = %lx", (long)ttyp); | |
5fafdf24 | 91 | |
02d2c54c | 92 | if_n = recv(ttyp->fd, (char *)if_inbuff, INBUFF_SIZE,0); |
5fafdf24 | 93 | |
f0cbd3ec | 94 | DEBUG_MISC((dfd, " read %d bytes\n", if_n)); |
5fafdf24 | 95 | |
f0cbd3ec FB |
96 | if (if_n <= 0) { |
97 | if (if_n == 0 || (errno != EINTR && errno != EAGAIN)) { | |
98 | if (ttyp->up) | |
99 | link_up--; | |
100 | tty_detached(ttyp, 0); | |
101 | } | |
102 | return; | |
103 | } | |
104 | if (if_n == 1) { | |
105 | if (*if_inbuff == '0') { | |
106 | ttyp->ones = 0; | |
107 | if (++ttyp->zeros >= 5) | |
108 | slirp_exit(0); | |
109 | return; | |
110 | } | |
111 | if (*if_inbuff == '1') { | |
112 | ttyp->zeros = 0; | |
113 | if (++ttyp->ones >= 5) | |
114 | tty_detached(ttyp, 0); | |
115 | return; | |
116 | } | |
117 | } | |
118 | ttyp->ones = ttyp->zeros = 0; | |
5fafdf24 | 119 | |
f0cbd3ec FB |
120 | (*ttyp->if_input)(ttyp, if_inbuff, if_n); |
121 | } | |
5fafdf24 TS |
122 | #endif |
123 | ||
f0cbd3ec FB |
124 | /* |
125 | * if_output: Queue packet into an output queue. | |
5fafdf24 | 126 | * There are 2 output queue's, if_fastq and if_batchq. |
f0cbd3ec FB |
127 | * Each output queue is a doubly linked list of double linked lists |
128 | * of mbufs, each list belonging to one "session" (socket). This | |
129 | * way, we can output packets fairly by sending one packet from each | |
130 | * session, instead of all the packets from one session, then all packets | |
5fafdf24 | 131 | * from the next session, etc. Packets on the if_fastq get absolute |
f0cbd3ec FB |
132 | * priority, but if one session hogs the link, it gets "downgraded" |
133 | * to the batchq until it runs out of packets, then it'll return | |
134 | * to the fastq (eg. if the user does an ls -alR in a telnet session, | |
135 | * it'll temporarily get downgraded to the batchq) | |
136 | */ | |
137 | void | |
138 | if_output(so, ifm) | |
139 | struct socket *so; | |
140 | struct mbuf *ifm; | |
141 | { | |
142 | struct mbuf *ifq; | |
143 | int on_fastq = 1; | |
5fafdf24 | 144 | |
f0cbd3ec FB |
145 | DEBUG_CALL("if_output"); |
146 | DEBUG_ARG("so = %lx", (long)so); | |
147 | DEBUG_ARG("ifm = %lx", (long)ifm); | |
5fafdf24 | 148 | |
f0cbd3ec FB |
149 | /* |
150 | * First remove the mbuf from m_usedlist, | |
151 | * since we're gonna use m_next and m_prev ourselves | |
152 | * XXX Shouldn't need this, gotta change dtom() etc. | |
153 | */ | |
154 | if (ifm->m_flags & M_USEDLIST) { | |
155 | remque(ifm); | |
156 | ifm->m_flags &= ~M_USEDLIST; | |
157 | } | |
5fafdf24 | 158 | |
f0cbd3ec | 159 | /* |
3b46e624 | 160 | * See if there's already a batchq list for this session. |
f0cbd3ec FB |
161 | * This can include an interactive session, which should go on fastq, |
162 | * but gets too greedy... hence it'll be downgraded from fastq to batchq. | |
163 | * We mustn't put this packet back on the fastq (or we'll send it out of order) | |
164 | * XXX add cache here? | |
165 | */ | |
166 | for (ifq = if_batchq.ifq_prev; ifq != &if_batchq; ifq = ifq->ifq_prev) { | |
167 | if (so == ifq->ifq_so) { | |
168 | /* A match! */ | |
169 | ifm->ifq_so = so; | |
170 | ifs_insque(ifm, ifq->ifs_prev); | |
171 | goto diddit; | |
172 | } | |
173 | } | |
5fafdf24 | 174 | |
f0cbd3ec FB |
175 | /* No match, check which queue to put it on */ |
176 | if (so && (so->so_iptos & IPTOS_LOWDELAY)) { | |
177 | ifq = if_fastq.ifq_prev; | |
178 | on_fastq = 1; | |
179 | /* | |
180 | * Check if this packet is a part of the last | |
181 | * packet's session | |
182 | */ | |
183 | if (ifq->ifq_so == so) { | |
184 | ifm->ifq_so = so; | |
185 | ifs_insque(ifm, ifq->ifs_prev); | |
186 | goto diddit; | |
187 | } | |
188 | } else | |
189 | ifq = if_batchq.ifq_prev; | |
5fafdf24 | 190 | |
f0cbd3ec FB |
191 | /* Create a new doubly linked list for this session */ |
192 | ifm->ifq_so = so; | |
193 | ifs_init(ifm); | |
194 | insque(ifm, ifq); | |
5fafdf24 | 195 | |
f0cbd3ec FB |
196 | diddit: |
197 | ++if_queued; | |
5fafdf24 | 198 | |
f0cbd3ec FB |
199 | if (so) { |
200 | /* Update *_queued */ | |
201 | so->so_queued++; | |
202 | so->so_nqueued++; | |
203 | /* | |
204 | * Check if the interactive session should be downgraded to | |
205 | * the batchq. A session is downgraded if it has queued 6 | |
206 | * packets without pausing, and at least 3 of those packets | |
207 | * have been sent over the link | |
208 | * (XXX These are arbitrary numbers, probably not optimal..) | |
209 | */ | |
5fafdf24 | 210 | if (on_fastq && ((so->so_nqueued >= 6) && |
f0cbd3ec | 211 | (so->so_nqueued - so->so_queued) >= 3)) { |
3b46e624 | 212 | |
f0cbd3ec FB |
213 | /* Remove from current queue... */ |
214 | remque(ifm->ifs_next); | |
3b46e624 | 215 | |
f0cbd3ec FB |
216 | /* ...And insert in the new. That'll teach ya! */ |
217 | insque(ifm->ifs_next, &if_batchq); | |
218 | } | |
219 | } | |
220 | ||
221 | #ifndef FULL_BOLT | |
222 | /* | |
223 | * This prevents us from malloc()ing too many mbufs | |
224 | */ | |
225 | if (link_up) { | |
226 | /* if_start will check towrite */ | |
227 | if_start(); | |
228 | } | |
229 | #endif | |
230 | } | |
231 | ||
232 | /* | |
233 | * Send a packet | |
234 | * We choose a packet based on it's position in the output queues; | |
235 | * If there are packets on the fastq, they are sent FIFO, before | |
236 | * everything else. Otherwise we choose the first packet from the | |
237 | * batchq and send it. the next packet chosen will be from the session | |
238 | * after this one, then the session after that one, and so on.. So, | |
239 | * for example, if there are 3 ftp session's fighting for bandwidth, | |
240 | * one packet will be sent from the first session, then one packet | |
241 | * from the second session, then one packet from the third, then back | |
242 | * to the first, etc. etc. | |
243 | */ | |
244 | void | |
245 | if_start(void) | |
246 | { | |
247 | struct mbuf *ifm, *ifqt; | |
5fafdf24 | 248 | |
f0cbd3ec | 249 | DEBUG_CALL("if_start"); |
5fafdf24 | 250 | |
f0cbd3ec FB |
251 | if (if_queued == 0) |
252 | return; /* Nothing to do */ | |
5fafdf24 | 253 | |
f0cbd3ec FB |
254 | again: |
255 | /* check if we can really output */ | |
256 | if (!slirp_can_output()) | |
257 | return; | |
258 | ||
259 | /* | |
260 | * See which queue to get next packet from | |
261 | * If there's something in the fastq, select it immediately | |
262 | */ | |
263 | if (if_fastq.ifq_next != &if_fastq) { | |
264 | ifm = if_fastq.ifq_next; | |
265 | } else { | |
266 | /* Nothing on fastq, see if next_m is valid */ | |
267 | if (next_m != &if_batchq) | |
268 | ifm = next_m; | |
269 | else | |
270 | ifm = if_batchq.ifq_next; | |
3b46e624 | 271 | |
f0cbd3ec FB |
272 | /* Set which packet to send on next iteration */ |
273 | next_m = ifm->ifq_next; | |
274 | } | |
275 | /* Remove it from the queue */ | |
276 | ifqt = ifm->ifq_prev; | |
277 | remque(ifm); | |
278 | --if_queued; | |
5fafdf24 | 279 | |
f0cbd3ec FB |
280 | /* If there are more packets for this session, re-queue them */ |
281 | if (ifm->ifs_next != /* ifm->ifs_prev != */ ifm) { | |
282 | insque(ifm->ifs_next, ifqt); | |
283 | ifs_remque(ifm); | |
284 | } | |
5fafdf24 | 285 | |
f0cbd3ec FB |
286 | /* Update so_queued */ |
287 | if (ifm->ifq_so) { | |
288 | if (--ifm->ifq_so->so_queued == 0) | |
289 | /* If there's no more queued, reset nqueued */ | |
290 | ifm->ifq_so->so_nqueued = 0; | |
291 | } | |
5fafdf24 | 292 | |
f0cbd3ec | 293 | /* Encapsulate the packet for sending */ |
242acf3a | 294 | if_encap((uint8_t *)ifm->m_data, ifm->m_len); |
f0cbd3ec | 295 | |
c9a62117 FB |
296 | m_free(ifm); |
297 | ||
f0cbd3ec FB |
298 | if (if_queued) |
299 | goto again; | |
300 | } |