2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * @(#)slc.c 8.2 (Berkeley) 5/30/95
34 * $FreeBSD: src/libexec/telnetd/slc.c,v 1.8.2.4 2002/04/13 11:07:12 markm Exp $
35 * $DragonFly: src/libexec/telnetd/slc.c,v 1.2 2003/06/17 04:27:08 dillon Exp $
44 static unsigned char *def_slcbuf = (unsigned char *)0;
45 static int def_slclen = 0;
46 static int slcchange; /* change to slc is requested */
47 static unsigned char *slcptr; /* pointer into slc buffer */
48 static unsigned char slcbuf[NSLC*6]; /* buffer for slc negotiation */
53 * Write out the current special characters to the client.
61 * Send out list of triplets of special characters
62 * to client. We only send info on the characters
63 * that are currently supported.
65 for (i = 1; i <= NSLC; i++) {
66 if ((slctab[i].defset.flag & SLC_LEVELBITS) == SLC_NOSUPPORT)
68 add_slc((unsigned char)i, slctab[i].current.flag,
69 slctab[i].current.val);
72 } /* end of send_slc */
77 * Set pty special characters to all the defaults.
84 for (i = 1; i <= NSLC; i++) {
85 slctab[i].current.val = slctab[i].defset.val;
86 if (slctab[i].current.val == (cc_t)(_POSIX_VDISABLE))
87 slctab[i].current.flag = SLC_NOSUPPORT;
89 slctab[i].current.flag = slctab[i].defset.flag;
91 *(slctab[i].sptr) = slctab[i].defset.val;
96 } /* end of default_slc */
102 * Initialize the slc mapping table.
105 get_slc_defaults(void)
111 for (i = 1; i <= NSLC; i++) {
112 slctab[i].defset.flag =
113 spcset(i, &slctab[i].defset.val, &slctab[i].sptr);
114 slctab[i].current.flag = SLC_NOSUPPORT;
115 slctab[i].current.val = 0;
118 } /* end of get_slc_defaults */
124 * Add an slc triplet to the slc buffer.
127 add_slc(char func, char flag, cc_t val)
130 if ((*slcptr++ = (unsigned char)func) == 0xff)
133 if ((*slcptr++ = (unsigned char)flag) == 0xff)
136 if ((*slcptr++ = (unsigned char)val) == 0xff)
139 } /* end of add_slc */
144 * Get ready to process incoming slc's and respond to them.
146 * The parameter getit is non-zero if it is necessary to grab a copy
147 * of the terminal control structures.
156 (void) sprintf((char *)slcbuf, "%c%c%c%c",
157 IAC, SB, TELOPT_LINEMODE, LM_SLC);
160 } /* end of start_slc */
165 * Finish up the slc negotiation. If something to send, then send it.
168 end_slc(unsigned char **bufp)
173 * If a change has occured, store the new terminal control
174 * structures back to the terminal driver.
181 * If the pty state has not yet been fully processed and there is a
182 * deferred slc request from the client, then do not send any
183 * sort of slc negotiation now. We will respond to the client's
186 if (def_slcbuf && (terminit() == 0)) {
190 if (slcptr > (slcbuf + 4)) {
193 return(slcptr - slcbuf - 4);
195 (void) sprintf((char *)slcptr, "%c%c", IAC, SE);
197 len = slcptr - slcbuf;
198 output_datalen(slcbuf, len);
199 netflush(); /* force it out immediately */
200 DIAG(TD_OPTIONS, printsub('>', slcbuf+2, len-2););
205 } /* end of end_slc */
210 * Figure out what to do about the client's slc
213 process_slc(unsigned char func, unsigned char flag, cc_t val)
215 int hislevel, mylevel, ack;
218 * Ensure that we know something about this function
221 add_slc(func, SLC_NOSUPPORT, 0);
226 * Process the special case requests of 0 SLC_DEFAULT 0
227 * and 0 SLC_VARIABLE 0. Be a little forgiving here, don't
228 * worry about whether the value is actually 0 or not.
231 if ((flag = flag & SLC_LEVELBITS) == SLC_DEFAULT) {
234 } else if (flag == SLC_VARIABLE) {
241 * Appears to be a function that we know something about. So
242 * get on with it and see what we know.
245 hislevel = flag & SLC_LEVELBITS;
246 mylevel = slctab[func].current.flag & SLC_LEVELBITS;
247 ack = flag & SLC_ACK;
249 * ignore the command if:
250 * the function value and level are the same as what we already have;
251 * or the level is the same and the ack bit is set
253 if (hislevel == mylevel && (val == slctab[func].current.val || ack)) {
257 * If we get here, we got an ack, but the levels don't match.
258 * This shouldn't happen. If it does, it is probably because
259 * we have sent two requests to set a variable without getting
260 * a response between them, and this is the first response.
261 * So, ignore it, and wait for the next response.
265 change_slc(func, flag, val);
268 } /* end of process_slc */
273 * Process a request to change one of our special characters.
274 * Compare client's request with what we are capable of supporting.
277 change_slc(char func, char flag, cc_t val)
279 int hislevel, mylevel;
281 hislevel = flag & SLC_LEVELBITS;
282 mylevel = slctab[(int)func].defset.flag & SLC_LEVELBITS;
284 * If client is setting a function to NOSUPPORT
285 * or DEFAULT, then we can easily and directly
286 * accomodate the request.
288 if (hislevel == SLC_NOSUPPORT) {
289 slctab[(int)func].current.flag = flag;
290 slctab[(int)func].current.val = (cc_t)_POSIX_VDISABLE;
292 add_slc(func, flag, val);
295 if (hislevel == SLC_DEFAULT) {
297 * Special case here. If client tells us to use
298 * the default on a function we don't support, then
299 * return NOSUPPORT instead of what we may have as a
300 * default level of DEFAULT.
302 if (mylevel == SLC_DEFAULT) {
303 slctab[(int)func].current.flag = SLC_NOSUPPORT;
305 slctab[(int)func].current.flag = slctab[(int)func].defset.flag;
307 slctab[(int)func].current.val = slctab[(int)func].defset.val;
308 add_slc(func, slctab[(int)func].current.flag,
309 slctab[(int)func].current.val);
314 * Client wants us to change to a new value or he
315 * is telling us that he can't change to our value.
316 * Some of the slc's we support and can change,
317 * some we do support but can't change,
318 * and others we don't support at all.
319 * If we can change it then we have a pointer to
320 * the place to put the new value, so change it,
321 * otherwise, continue the negotiation.
323 if (slctab[(int)func].sptr) {
325 * We can change this one.
327 slctab[(int)func].current.val = val;
328 *(slctab[(int)func].sptr) = val;
329 slctab[(int)func].current.flag = flag;
332 add_slc(func, flag, val);
335 * It is not possible for us to support this
336 * request as he asks.
338 * If our level is DEFAULT, then just ack whatever was
341 * If he can't change and we can't change,
342 * then degenerate to NOSUPPORT.
344 * Otherwise we send our level back to him, (CANTCHANGE
345 * or NOSUPPORT) and if CANTCHANGE, send
348 if (mylevel == SLC_DEFAULT) {
349 slctab[(int)func].current.flag = flag;
350 slctab[(int)func].current.val = val;
352 } else if (hislevel == SLC_CANTCHANGE &&
353 mylevel == SLC_CANTCHANGE) {
354 flag &= ~SLC_LEVELBITS;
355 flag |= SLC_NOSUPPORT;
356 slctab[(int)func].current.flag = flag;
358 flag &= ~SLC_LEVELBITS;
360 slctab[(int)func].current.flag = flag;
361 if (mylevel == SLC_CANTCHANGE) {
362 slctab[(int)func].current.val =
363 slctab[(int)func].defset.val;
364 val = slctab[(int)func].current.val;
367 add_slc(func, flag, val);
370 } /* end of change_slc */
372 #if defined(USE_TERMIO) && (VEOF == VMIN)
373 cc_t oldeofc = '\004';
379 * Check the special characters in use and notify the client if any have
380 * changed. Only those characters that are capable of being changed are
381 * likely to have changed. If a local change occurs, kick the support level
382 * and flags up to the defaults.
389 for (i = 1; i <= NSLC; i++) {
390 #if defined(USE_TERMIO) && (VEOF == VMIN)
392 * In a perfect world this would be a neat little
393 * function. But in this world, we should not notify
394 * client of changes to the VEOF char when
395 * ICANON is off, because it is not representing
396 * a special character.
399 if (!tty_isediting())
401 else if (slctab[i].sptr)
402 oldeofc = *(slctab[i].sptr);
404 #endif /* defined(USE_TERMIO) && defined(SYSV_TERMIO) */
405 if (slctab[i].sptr &&
406 (*(slctab[i].sptr) != slctab[i].current.val)) {
407 slctab[i].current.val = *(slctab[i].sptr);
408 if (*(slctab[i].sptr) == (cc_t)_POSIX_VDISABLE)
409 slctab[i].current.flag = SLC_NOSUPPORT;
411 slctab[i].current.flag = slctab[i].defset.flag;
412 add_slc((unsigned char)i, slctab[i].current.flag,
413 slctab[i].current.val);
421 * Process an slc option buffer. Defer processing of incoming slc's
422 * until after the terminal state has been processed. Save the first slc
423 * request that comes along, but discard all others.
425 * ptr points to the beginning of the buffer, len is the length.
428 do_opt_slc(unsigned char *ptr, int len)
430 unsigned char func, flag;
432 unsigned char *end = ptr + len;
434 if (terminit()) { /* go ahead */
437 if (ptr >= end) break;
439 if (ptr >= end) break;
442 process_slc(func, flag, val);
447 * save this slc buffer if it is the first, otherwise dump
450 if (def_slcbuf == (unsigned char *)0) {
452 def_slcbuf = (unsigned char *)malloc((unsigned)len);
453 if (def_slcbuf == (unsigned char *)0)
454 return; /* too bad */
455 memmove(def_slcbuf, ptr, len);
459 } /* end of do_opt_slc */
464 * Do slc stuff that was deferred.
471 do_opt_slc(def_slcbuf, def_slclen);
474 def_slcbuf = (unsigned char *)0;
478 } /* end of deferslc */
480 #endif /* LINEMODE */