1 | /* |
2 | * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | /* Copyright (c) 1997 Apple Computer, Inc. All Rights Reserved */ |
29 | /* |
30 | * Copyright (c) 1993, 1994 Theo de Raadt |
31 | * All rights reserved. |
32 | * |
33 | * Redistribution and use in source and binary forms, with or without |
34 | * modification, are permitted provided that the following conditions |
35 | * are met: |
36 | * 1. Redistributions of source code must retain the above copyright |
37 | * notice unmodified, this list of conditions, and the following |
38 | * disclaimer. |
39 | * 2. Redistributions in binary form must reproduce the above copyright |
40 | * notice, this list of conditions and the following disclaimer in the |
41 | * documentation and/or other materials provided with the distribution. |
42 | * |
43 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
44 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
45 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
46 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
47 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
48 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
49 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
50 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
51 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
52 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
53 | * SUCH DAMAGE. |
54 | * |
55 | */ |
56 | |
57 | /* |
58 | * We use the NetBSD based clist system, it is much more efficient than the |
59 | * old style clist stuff used by free bsd. |
60 | */ |
61 | |
62 | #include <sys/param.h> |
63 | #include <sys/systm.h> |
64 | #include <sys/ioctl.h> |
65 | #include <sys/tty.h> |
66 | #include <sys/malloc.h> |
67 | |
68 | |
69 | /* |
70 | * At compile time, choose: |
71 | * There are two ways the TTY_QUOTE bit can be stored. If QBITS is |
72 | * defined we allocate an array of bits -- 1/8th as much memory but |
73 | * setbit(), clrbit(), and isset() take more cpu. If QBITS is |
74 | * undefined, we just use an array of bytes. |
75 | * |
76 | * If TTY_QUOTE functionality isn't required by a line discipline, |
77 | * it can free c_cq and set it to NULL. This speeds things up, |
78 | * and also does not use any extra memory. This is useful for (say) |
79 | * a SLIP line discipline that wants a 32K ring buffer for data |
80 | * but doesn't need quoting. |
81 | */ |
82 | #define QBITS |
83 | |
84 | #ifdef QBITS |
85 | #define QMEM(n) ((((n)-1)/NBBY)+1) |
86 | #else |
87 | #define QMEM(n) (n) |
88 | #endif |
89 | |
90 | |
91 | /* |
92 | * Initialize clists. |
93 | */ |
94 | void |
95 | cinit(void) |
96 | { |
97 | } |
98 | |
99 | /* |
100 | * Initialize a particular clist. Ok, they are really ring buffers, |
101 | * of the specified length, with/without quoting support. |
102 | */ |
103 | int |
104 | clalloc(struct clist *clp, int size, int quot) |
105 | { |
106 | MALLOC_ZONE(clp->c_cs, u_char *, size, M_TTYS, M_WAITOK); |
107 | if (!clp->c_cs) |
108 | return (-1); |
109 | bzero(clp->c_cs, size); |
110 | |
111 | if(quot) { |
112 | MALLOC_ZONE(clp->c_cq, u_char *, QMEM(size), M_TTYS, M_WAITOK); |
113 | if (!clp->c_cq) { |
114 | FREE_ZONE(clp->c_cs, size, M_TTYS); |
115 | return (-1); |
116 | } |
117 | bzero(clp->c_cs, QMEM(size)); |
118 | } else |
119 | clp->c_cq = (u_char *)0; |
120 | |
121 | clp->c_cf = clp->c_cl = (u_char *)0; |
122 | clp->c_ce = clp->c_cs + size; |
123 | clp->c_cn = size; |
124 | clp->c_cc = 0; |
125 | return (0); |
126 | } |
127 | |
128 | void |
129 | clfree(struct clist *clp) |
130 | { |
131 | if(clp->c_cs) |
132 | FREE_ZONE(clp->c_cs, clp->c_cn, M_TTYS); |
133 | if(clp->c_cq) |
134 | FREE_ZONE(clp->c_cq, QMEM(clp->c_cn), M_TTYS); |
135 | clp->c_cs = clp->c_cq = (u_char *)0; |
136 | } |
137 | |
138 | |
139 | /* |
140 | * Get a character from a clist. |
141 | */ |
142 | int |
143 | getc(struct clist *clp) |
144 | { |
145 | int c = -1; |
146 | |
147 | if (clp->c_cc == 0) |
148 | goto out; |
149 | |
150 | c = *clp->c_cf & 0xff; |
151 | if (clp->c_cq) { |
152 | #ifdef QBITS |
153 | if (isset(clp->c_cq, clp->c_cf - clp->c_cs) ) |
154 | c |= TTY_QUOTE; |
155 | #else |
156 | if (*(clp->c_cf - clp->c_cs + clp->c_cq)) |
157 | c |= TTY_QUOTE; |
158 | #endif |
159 | } |
160 | if (++clp->c_cf == clp->c_ce) |
161 | clp->c_cf = clp->c_cs; |
162 | if (--clp->c_cc == 0) |
163 | clp->c_cf = clp->c_cl = (u_char *)0; |
164 | out: |
165 | return c; |
166 | } |
167 | |
168 | /* |
169 | * Copy clist to buffer. |
170 | * Return number of bytes moved. |
171 | */ |
172 | int |
173 | q_to_b(struct clist *clp, u_char *cp, int count) |
174 | { |
175 | int cc; |
176 | u_char *p = cp; |
177 | |
178 | /* optimize this while loop */ |
179 | while (count > 0 && clp->c_cc > 0) { |
180 | cc = clp->c_cl - clp->c_cf; |
181 | if (clp->c_cf >= clp->c_cl) |
182 | cc = clp->c_ce - clp->c_cf; |
183 | if (cc > count) |
184 | cc = count; |
185 | bcopy(clp->c_cf, p, cc); |
186 | count -= cc; |
187 | p += cc; |
188 | clp->c_cc -= cc; |
189 | clp->c_cf += cc; |
190 | if (clp->c_cf == clp->c_ce) |
191 | clp->c_cf = clp->c_cs; |
192 | } |
193 | if (clp->c_cc == 0) |
194 | clp->c_cf = clp->c_cl = (u_char *)0; |
195 | return p - cp; |
196 | } |
197 | |
198 | /* |
199 | * Return count of contiguous characters in clist. |
200 | * Stop counting if flag&character is non-null. |
201 | */ |
202 | int |
203 | ndqb(struct clist *clp, int flag) |
204 | { |
205 | int count = 0; |
206 | int i; |
207 | int cc; |
208 | |
209 | if ((cc = clp->c_cc) == 0) |
210 | goto out; |
211 | |
212 | if (flag == 0) { |
213 | count = clp->c_cl - clp->c_cf; |
214 | if (count <= 0) |
215 | count = clp->c_ce - clp->c_cf; |
216 | goto out; |
217 | } |
218 | |
219 | i = clp->c_cf - clp->c_cs; |
220 | if (flag & TTY_QUOTE) { |
221 | while (cc-- > 0 && !(clp->c_cs[i++] & (flag & ~TTY_QUOTE) || |
222 | isset(clp->c_cq, i))) { |
223 | count++; |
224 | if (i == clp->c_cn) |
225 | break; |
226 | } |
227 | } else { |
228 | while (cc-- > 0 && !(clp->c_cs[i++] & flag)) { |
229 | count++; |
230 | if (i == clp->c_cn) |
231 | break; |
232 | } |
233 | } |
234 | out: |
235 | return count; |
236 | } |
237 | |
238 | /* |
239 | * Flush count bytes from clist. |
240 | */ |
241 | void |
242 | ndflush(struct clist *clp, int count) |
243 | { |
244 | int cc; |
245 | |
246 | if (count == clp->c_cc) { |
247 | clp->c_cc = 0; |
248 | clp->c_cf = clp->c_cl = (u_char *)0; |
249 | return; |
250 | } |
251 | /* optimize this while loop */ |
252 | while (count > 0 && clp->c_cc > 0) { |
253 | cc = clp->c_cl - clp->c_cf; |
254 | if (clp->c_cf >= clp->c_cl) |
255 | cc = clp->c_ce - clp->c_cf; |
256 | if (cc > count) |
257 | cc = count; |
258 | count -= cc; |
259 | clp->c_cc -= cc; |
260 | clp->c_cf += cc; |
261 | if (clp->c_cf == clp->c_ce) |
262 | clp->c_cf = clp->c_cs; |
263 | } |
264 | if (clp->c_cc == 0) |
265 | clp->c_cf = clp->c_cl = (u_char *)0; |
266 | } |
267 | |
268 | /* |
269 | * Put a character into the output queue. |
270 | */ |
271 | int |
272 | putc(int c, struct clist *clp) |
273 | { |
274 | int i; |
275 | |
276 | if (clp->c_cc == 0) { |
277 | if (!clp->c_cs) { |
278 | #if DIAGNOSTIC |
279 | //printf("putc: required clalloc\n"); |
280 | #endif |
281 | if(clalloc(clp, 1024, 1)) { |
282 | out: |
283 | return -1; |
284 | } |
285 | } |
286 | clp->c_cf = clp->c_cl = clp->c_cs; |
287 | } |
288 | |
289 | if (clp->c_cc == clp->c_cn) |
290 | goto out; |
291 | |
292 | *clp->c_cl = c & 0xff; |
293 | i = clp->c_cl - clp->c_cs; |
294 | if (clp->c_cq) { |
295 | #ifdef QBITS |
296 | if (c & TTY_QUOTE) |
297 | setbit(clp->c_cq, i); |
298 | else |
299 | clrbit(clp->c_cq, i); |
300 | #else |
301 | q = clp->c_cq + i; |
302 | *q = (c & TTY_QUOTE) ? 1 : 0; |
303 | #endif |
304 | } |
305 | clp->c_cc++; |
306 | clp->c_cl++; |
307 | if (clp->c_cl == clp->c_ce) |
308 | clp->c_cl = clp->c_cs; |
309 | return 0; |
310 | } |
311 | |
312 | #ifdef QBITS |
313 | /* |
314 | * optimized version of |
315 | * |
316 | * for (i = 0; i < len; i++) |
317 | * clrbit(cp, off + len); |
318 | */ |
319 | void |
320 | clrbits(u_char *cp, int off, int len) |
321 | { |
322 | int sby, sbi, eby, ebi; |
323 | int i; |
324 | u_char mask; |
325 | |
326 | if(len==1) { |
327 | clrbit(cp, off); |
328 | return; |
329 | } |
330 | |
331 | sby = off / NBBY; |
332 | sbi = off % NBBY; |
333 | eby = (off+len) / NBBY; |
334 | ebi = (off+len) % NBBY; |
335 | if (sby == eby) { |
336 | mask = ((1 << (ebi - sbi)) - 1) << sbi; |
337 | cp[sby] &= ~mask; |
338 | } else { |
339 | mask = (1<<sbi) - 1; |
340 | cp[sby++] &= mask; |
341 | |
342 | mask = (1<<ebi) - 1; |
343 | /* handle remainder bits, if any, for a non-0 ebi value */ |
344 | if (mask) |
345 | cp[eby] &= ~mask; |
346 | |
347 | for (i = sby; i < eby; i++) |
348 | cp[i] = 0x00; |
349 | } |
350 | } |
351 | #endif |
352 | |
353 | /* |
354 | * Copy buffer to clist. |
355 | * Return number of bytes not transfered. |
356 | */ |
357 | int |
358 | b_to_q(const u_char *cp, int count, struct clist *clp) |
359 | { |
360 | int cc; |
361 | const u_char *p = cp; |
362 | |
363 | if (count <= 0) |
364 | return 0; |
365 | |
366 | |
367 | if (clp->c_cc == 0) { |
368 | if (!clp->c_cs) { |
369 | #if DIAGNOSTIC |
370 | printf("b_to_q: required clalloc\n" ); |
371 | #endif |
372 | if(clalloc(clp, 1024, 1)) |
373 | goto out; |
374 | } |
375 | clp->c_cf = clp->c_cl = clp->c_cs; |
376 | } |
377 | |
378 | if (clp->c_cc == clp->c_cn) |
379 | goto out; |
380 | |
381 | /* optimize this while loop */ |
382 | while (count > 0 && clp->c_cc < clp->c_cn) { |
383 | cc = clp->c_ce - clp->c_cl; |
384 | if (clp->c_cf > clp->c_cl) |
385 | cc = clp->c_cf - clp->c_cl; |
386 | if (cc > count) |
387 | cc = count; |
388 | bcopy(p, clp->c_cl, cc); |
389 | if (clp->c_cq) { |
390 | #ifdef QBITS |
391 | clrbits(clp->c_cq, clp->c_cl - clp->c_cs, cc); |
392 | #else |
393 | bzero(clp->c_cl - clp->c_cs + clp->c_cq, cc); |
394 | #endif |
395 | } |
396 | p += cc; |
397 | count -= cc; |
398 | clp->c_cc += cc; |
399 | clp->c_cl += cc; |
400 | if (clp->c_cl == clp->c_ce) |
401 | clp->c_cl = clp->c_cs; |
402 | } |
403 | out: |
404 | return count; |
405 | } |
406 | |
407 | static int cc; |
408 | |
409 | /* |
410 | * Given a non-NULL pointer into the clist return the pointer |
411 | * to the next character in the list or return NULL if no more chars. |
412 | * |
413 | * Callers must not allow getc's to happen between firstc's and getc's |
414 | * so that the pointer becomes invalid. Note that interrupts are NOT |
415 | * masked. |
416 | */ |
417 | u_char * |
418 | nextc(struct clist *clp, u_char *cp, int *c) |
419 | { |
420 | if (clp->c_cf == cp) { |
421 | /* |
422 | * First time initialization. |
423 | */ |
424 | cc = clp->c_cc; |
425 | } |
426 | if (cc == 0 || cp == NULL) |
427 | return NULL; |
428 | if (--cc == 0) |
429 | return NULL; |
430 | if (++cp == clp->c_ce) |
431 | cp = clp->c_cs; |
432 | *c = *cp & 0xff; |
433 | if (clp->c_cq) { |
434 | #ifdef QBITS |
435 | if (isset(clp->c_cq, cp - clp->c_cs)) |
436 | *c |= TTY_QUOTE; |
437 | #else |
438 | if (*(clp->c_cf - clp->c_cs + clp->c_cq)) |
439 | *c |= TTY_QUOTE; |
440 | #endif |
441 | } |
442 | return cp; |
443 | } |
444 | |
445 | /* |
446 | * Given a non-NULL pointer into the clist return the pointer |
447 | * to the first character in the list or return NULL if no more chars. |
448 | * |
449 | * Callers must not allow getc's to happen between firstc's and getc's |
450 | * so that the pointer becomes invalid. Note that interrupts are NOT |
451 | * masked. |
452 | * |
453 | * *c is set to the NEXT character |
454 | */ |
455 | u_char * |
456 | firstc(struct clist *clp, int *c) |
457 | { |
458 | u_char *cp; |
459 | |
460 | cc = clp->c_cc; |
461 | if (cc == 0) |
462 | return NULL; |
463 | cp = clp->c_cf; |
464 | *c = *cp & 0xff; |
465 | if(clp->c_cq) { |
466 | #ifdef QBITS |
467 | if (isset(clp->c_cq, cp - clp->c_cs)) |
468 | *c |= TTY_QUOTE; |
469 | #else |
470 | if (*(cp - clp->c_cs + clp->c_cq)) |
471 | *c |= TTY_QUOTE; |
472 | #endif |
473 | } |
474 | return clp->c_cf; |
475 | } |
476 | |
477 | /* |
478 | * Remove the last character in the clist and return it. |
479 | */ |
480 | int |
481 | unputc(struct clist *clp) |
482 | { |
483 | unsigned int c = -1; |
484 | |
485 | if (clp->c_cc == 0) |
486 | goto out; |
487 | |
488 | if (clp->c_cl == clp->c_cs) |
489 | clp->c_cl = clp->c_ce - 1; |
490 | else |
491 | --clp->c_cl; |
492 | clp->c_cc--; |
493 | |
494 | c = *clp->c_cl & 0xff; |
495 | if (clp->c_cq) { |
496 | #ifdef QBITS |
497 | if (isset(clp->c_cq, clp->c_cl - clp->c_cs)) |
498 | c |= TTY_QUOTE; |
499 | #else |
500 | if (*(clp->c_cf - clp->c_cs + clp->c_cq)) |
501 | c |= TTY_QUOTE; |
502 | #endif |
503 | } |
504 | if (clp->c_cc == 0) |
505 | clp->c_cf = clp->c_cl = (u_char *)0; |
506 | out: |
507 | return c; |
508 | } |
509 | |
510 | /* |
511 | * Put the chars in the from queue on the end of the to queue. |
512 | */ |
513 | void |
514 | catq(struct clist *from, struct clist *to) |
515 | { |
516 | int c; |
517 | |
518 | while ((c = getc(from)) != -1) |
519 | putc(c, to); |
520 | } |
521 | |