1 /*
2 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 */
5
6 #pragma ident "%Z%%M% %I% %E% SMI"
7
8 /*
9 * usr/src/cmd/cmd-inet/usr.bin/telnet/ring.c
10 */
11
12 /*
13 * Copyright (c) 1988, 1993
14 * The Regents of the University of California. All rights reserved.
15 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
24 * 3. All advertising materials mentioning features or use of this software
25 * must display the following acknowledgement:
26 * This product includes software developed by the University of
27 * California, Berkeley and its contributors.
28 * 4. Neither the name of the University nor the names of its contributors
29 * may be used to endorse or promote products derived from this software
30 * without specific prior written permission.
31 *
32 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
33 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
34 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
35 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
36 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
40 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
41 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
42 * SUCH DAMAGE.
43 */
44
45 #ifndef lint
46 static char sccsid[] = "@(#)ring.c 8.1 (Berkeley) 6/6/93";
47 #endif /* not lint */
48
49 /*
50 * This defines a structure for a ring buffer.
51 *
52 * The circular buffer has two parts:
53 * (((
54 * full: [consume, supply)
55 * empty: [supply, consume)
56 * ]]]
57 *
58 */
59
60 #include <stdio.h>
61 #include <errno.h>
62 #include <string.h>
63
64 #include <sys/types.h>
65 #include <sys/socket.h>
66 #include <sys/sysmacros.h>
67
68 #include "ring.h"
69 #include "general.h"
70
71
72 #define ring_subtract(d, a, b) (((a)-(b) >= 0)? \
73 (a)-(b): (((a)-(b))+(d)->size))
74
75 #define ring_increment(d, a, c) (((a)+(c) < (d)->top)? \
76 (a)+(c) : (((a)+(c))-(d)->size))
77
78 #define ring_decrement(d, a, c) (((a)-(c) >= (d)->bottom)? \
79 (a)-(c) : (((a)-(c))-(d)->size))
80
81
82 /*
83 * The following is a clock, used to determine full, empty, etc.
84 *
85 * There is some trickiness here. Since the ring buffers are initialized
86 * to ZERO on allocation, we need to make sure, when interpreting the
87 * clock, that when the times are EQUAL, then the buffer is FULL.
88 */
89 ulong_t ring_clock = 0;
90
91
92 #define ring_empty(d) (((d)->consume == (d)->supply) && \
93 ((d)->consumetime >= (d)->supplytime))
94 #define ring_full(d) (((d)->supply == (d)->consume) && \
95 ((d)->supplytime > (d)->consumetime))
96
97
98
99
100
101 /* Buffer state transition routines */
102
103 int
ring_init(ring,buffer,count)104 ring_init(ring, buffer, count)
105 Ring *ring;
106 unsigned char *buffer;
107 int count;
108 {
109 (void) memset(ring, 0, sizeof (*ring));
110
111 ring->size = count;
112
113 ring->supply = ring->consume = ring->bottom = buffer;
114
115 ring->top = ring->bottom+ring->size;
116
117 ring->clearto = 0;
118
119 return (1);
120 }
121
122 /* Mark routines */
123
124 /*
125 * Mark the most recently supplied byte.
126 */
127
128 void
ring_mark(ring)129 ring_mark(ring)
130 Ring *ring;
131 {
132 ring->mark = ring_decrement(ring, ring->supply, 1);
133 }
134
135 /*
136 * Is the ring pointing to the mark?
137 */
138
139 int
ring_at_mark(ring)140 ring_at_mark(ring)
141 Ring *ring;
142 {
143 if (ring->mark == ring->consume) {
144 return (1);
145 } else {
146 return (0);
147 }
148 }
149
150 /*
151 * Clear any mark set on the ring.
152 */
153
154 void
ring_clear_mark(ring)155 ring_clear_mark(ring)
156 Ring *ring;
157 {
158 ring->mark = 0;
159 }
160
161 /*
162 * Add characters from current segment to ring buffer.
163 */
164 void
ring_supplied(ring,count)165 ring_supplied(ring, count)
166 Ring *ring;
167 int count;
168 {
169 ring->supply = ring_increment(ring, ring->supply, count);
170 ring->supplytime = ++ring_clock;
171 }
172
173 /*
174 * We have just consumed "c" bytes.
175 */
176 void
ring_consumed(ring,count)177 ring_consumed(ring, count)
178 Ring *ring;
179 int count;
180 {
181 if (count == 0) /* don't update anything */
182 return;
183
184 if (ring->mark &&
185 (ring_subtract(ring, ring->mark, ring->consume) < count)) {
186 ring->mark = 0;
187 }
188
189 if (ring->consume < ring->clearto &&
190 ring->clearto <= ring->consume + count)
191 ring->clearto = 0;
192 else if (ring->consume + count > ring->top &&
193 ring->bottom <= ring->clearto &&
194 ring->bottom + ((ring->consume + count) - ring->top))
195 ring->clearto = 0;
196
197 ring->consume = ring_increment(ring, ring->consume, count);
198 ring->consumetime = ++ring_clock;
199 /*
200 * Try to encourage "ring_empty_consecutive()" to be large.
201 */
202 if (ring_empty(ring)) {
203 ring->consume = ring->supply = ring->bottom;
204 }
205 }
206
207
208
209 /* Buffer state query routines */
210
211
212 /* Number of bytes that may be supplied */
213 int
ring_empty_count(ring)214 ring_empty_count(ring)
215 Ring *ring;
216 {
217 if (ring_empty(ring)) { /* if empty */
218 return (ring->size);
219 } else {
220 return (ring_subtract(ring, ring->consume, ring->supply));
221 }
222 }
223
224 /* number of CONSECUTIVE bytes that may be supplied */
225 int
ring_empty_consecutive(ring)226 ring_empty_consecutive(ring)
227 Ring *ring;
228 {
229 if ((ring->consume < ring->supply) || ring_empty(ring)) {
230 /*
231 * if consume is "below" supply, or empty, then
232 * return distance to the top
233 */
234 return (ring_subtract(ring, ring->top, ring->supply));
235 } else {
236 /*
237 * else, return what we may.
238 */
239 return (ring_subtract(ring, ring->consume, ring->supply));
240 }
241 }
242
243 /*
244 * Return the number of bytes that are available for consuming
245 * (but don't give more than enough to get to cross over set mark)
246 */
247
248 int
ring_full_count(ring)249 ring_full_count(ring)
250 Ring *ring;
251 {
252 if ((ring->mark == 0) || (ring->mark == ring->consume)) {
253 if (ring_full(ring)) {
254 return (ring->size); /* nothing consumed, but full */
255 } else {
256 return (ring_subtract(ring, ring->supply,
257 ring->consume));
258 }
259 } else {
260 return (ring_subtract(ring, ring->mark, ring->consume));
261 }
262 }
263
264 /*
265 * Return the number of CONSECUTIVE bytes available for consuming.
266 * However, don't return more than enough to cross over set mark.
267 */
268 int
ring_full_consecutive(ring)269 ring_full_consecutive(ring)
270 Ring *ring;
271 {
272 if ((ring->mark == 0) || (ring->mark == ring->consume)) {
273 if ((ring->supply < ring->consume) || ring_full(ring)) {
274 return (ring_subtract(ring, ring->top, ring->consume));
275 } else {
276 return (ring_subtract(ring, ring->supply,
277 ring->consume));
278 }
279 } else {
280 if (ring->mark < ring->consume) {
281 return (ring_subtract(ring, ring->top, ring->consume));
282 } else { /* Else, distance to mark */
283 return (ring_subtract(ring, ring->mark, ring->consume));
284 }
285 }
286 }
287
288 /*
289 * Move data into the "supply" portion of of the ring buffer.
290 */
291 void
ring_supply_data(ring,buffer,count)292 ring_supply_data(ring, buffer, count)
293 Ring *ring;
294 unsigned char *buffer;
295 int count;
296 {
297 int i;
298
299 while (count) {
300 i = MIN(count, ring_empty_consecutive(ring));
301 (void) memcpy(ring->supply, buffer, i);
302 ring_supplied(ring, i);
303 count -= i;
304 buffer += i;
305 }
306 }
307
308 #ifdef notdef
309
310 /*
311 * Move data from the "consume" portion of the ring buffer
312 */
313 void
ring_consume_data(ring,buffer,count)314 ring_consume_data(ring, buffer, count)
315 Ring *ring;
316 unsigned char *buffer;
317 int count;
318 {
319 int i;
320
321 while (count) {
322 i = MIN(count, ring_full_consecutive(ring));
323 memcpy(buffer, ring->consume, i);
324 ring_consumed(ring, i);
325 count -= i;
326 buffer += i;
327 }
328 }
329 #endif
330
331 void
ring_encrypt(ring,encryptor)332 ring_encrypt(ring, encryptor)
333 Ring *ring;
334 void (*encryptor)();
335 {
336 unsigned char *s, *c;
337
338 if (ring_empty(ring) || ring->clearto == ring->supply)
339 return;
340
341 if ((c = ring->clearto) == NULL)
342 c = ring->consume;
343
344 s = ring->supply;
345
346 if (s <= c) {
347 (*encryptor)(c, ring->top - c);
348 (*encryptor)(ring->bottom, s - ring->bottom);
349 } else
350 (*encryptor)(c, s - c);
351
352 ring->clearto = ring->supply;
353 }
354
355 void
ring_clearto(ring)356 ring_clearto(ring)
357 Ring *ring;
358 {
359 if (!ring_empty(ring))
360 ring->clearto = ring->supply;
361 else
362 ring->clearto = 0;
363 }
364