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. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * @(#)slc.c 8.2 (Berkeley) 5/30/95
30 * $FreeBSD: src/crypto/telnet/telnetd/slc.c,v 1.4.2.3 2002/04/13 10:59:08 markm Exp $
31 * $DragonFly: src/crypto/telnet/telnetd/slc.c,v 1.2 2003/06/17 04:24:37 dillon Exp $
40 static unsigned char *def_slcbuf = NULL;
41 static int def_slclen = 0;
42 static int slcchange; /* change to slc is requested */
43 static unsigned char *slcptr; /* pointer into slc buffer */
44 static unsigned char slcbuf[NSLC*6]; /* buffer for slc negotiation */
49 * Write out the current special characters to the client.
57 * Send out list of triplets of special characters
58 * to client. We only send info on the characters
59 * that are currently supported.
61 for (i = 1; i <= NSLC; i++) {
62 if ((slctab[i].defset.flag & SLC_LEVELBITS) == SLC_NOSUPPORT)
64 add_slc((unsigned char)i, slctab[i].current.flag,
65 slctab[i].current.val);
68 } /* end of send_slc */
73 * Set pty special characters to all the defaults.
80 for (i = 1; i <= NSLC; i++) {
81 slctab[i].current.val = slctab[i].defset.val;
82 if (slctab[i].current.val == (cc_t)(_POSIX_VDISABLE))
83 slctab[i].current.flag = SLC_NOSUPPORT;
85 slctab[i].current.flag = slctab[i].defset.flag;
87 *(slctab[i].sptr) = slctab[i].defset.val;
92 } /* end of default_slc */
98 * Initialize the slc mapping table.
101 get_slc_defaults(void)
107 for (i = 1; i <= NSLC; i++) {
108 slctab[i].defset.flag =
109 spcset(i, &slctab[i].defset.val, &slctab[i].sptr);
110 slctab[i].current.flag = SLC_NOSUPPORT;
111 slctab[i].current.val = 0;
114 } /* end of get_slc_defaults */
120 * Add an slc triplet to the slc buffer.
123 add_slc(char func, char flag, cc_t val)
126 if ((*slcptr++ = (unsigned char)func) == 0xff)
129 if ((*slcptr++ = (unsigned char)flag) == 0xff)
132 if ((*slcptr++ = (unsigned char)val) == 0xff)
135 } /* end of add_slc */
140 * Get ready to process incoming slc's and respond to them.
142 * The parameter getit is non-zero if it is necessary to grab a copy
143 * of the terminal control structures.
152 (void) sprintf((char *)slcbuf, "%c%c%c%c",
153 IAC, SB, TELOPT_LINEMODE, LM_SLC);
156 } /* end of start_slc */
161 * Finish up the slc negotiation. If something to send, then send it.
164 end_slc(unsigned char **bufp)
169 * If a change has occured, store the new terminal control
170 * structures back to the terminal driver.
177 * If the pty state has not yet been fully processed and there is a
178 * deferred slc request from the client, then do not send any
179 * sort of slc negotiation now. We will respond to the client's
182 if (def_slcbuf && (terminit() == 0)) {
186 if (slcptr > (slcbuf + 4)) {
189 return(slcptr - slcbuf - 4);
191 (void) sprintf((char *)slcptr, "%c%c", IAC, SE);
193 len = slcptr - slcbuf;
194 output_datalen(slcbuf, len);
195 netflush(); /* force it out immediately */
196 DIAG(TD_OPTIONS, printsub('>', slcbuf+2, len-2););
201 } /* end of end_slc */
206 * Figure out what to do about the client's slc
209 process_slc(unsigned char func, unsigned char flag, cc_t val)
211 int hislevel, mylevel, ack;
214 * Ensure that we know something about this function
217 add_slc(func, SLC_NOSUPPORT, 0);
222 * Process the special case requests of 0 SLC_DEFAULT 0
223 * and 0 SLC_VARIABLE 0. Be a little forgiving here, don't
224 * worry about whether the value is actually 0 or not.
227 if ((flag = flag & SLC_LEVELBITS) == SLC_DEFAULT) {
230 } else if (flag == SLC_VARIABLE) {
237 * Appears to be a function that we know something about. So
238 * get on with it and see what we know.
241 hislevel = flag & SLC_LEVELBITS;
242 mylevel = slctab[func].current.flag & SLC_LEVELBITS;
243 ack = flag & SLC_ACK;
245 * ignore the command if:
246 * the function value and level are the same as what we already have;
247 * or the level is the same and the ack bit is set
249 if (hislevel == mylevel && (val == slctab[func].current.val || ack)) {
253 * If we get here, we got an ack, but the levels don't match.
254 * This shouldn't happen. If it does, it is probably because
255 * we have sent two requests to set a variable without getting
256 * a response between them, and this is the first response.
257 * So, ignore it, and wait for the next response.
261 change_slc(func, flag, val);
264 } /* end of process_slc */
269 * Process a request to change one of our special characters.
270 * Compare client's request with what we are capable of supporting.
273 change_slc(char func, char flag, cc_t val)
275 int hislevel, mylevel;
277 hislevel = flag & SLC_LEVELBITS;
278 mylevel = slctab[(int)func].defset.flag & SLC_LEVELBITS;
280 * If client is setting a function to NOSUPPORT
281 * or DEFAULT, then we can easily and directly
282 * accomodate the request.
284 if (hislevel == SLC_NOSUPPORT) {
285 slctab[(int)func].current.flag = flag;
286 slctab[(int)func].current.val = (cc_t)_POSIX_VDISABLE;
288 add_slc(func, flag, val);
291 if (hislevel == SLC_DEFAULT) {
293 * Special case here. If client tells us to use
294 * the default on a function we don't support, then
295 * return NOSUPPORT instead of what we may have as a
296 * default level of DEFAULT.
298 if (mylevel == SLC_DEFAULT) {
299 slctab[(int)func].current.flag = SLC_NOSUPPORT;
301 slctab[(int)func].current.flag = slctab[(int)func].defset.flag;
303 slctab[(int)func].current.val = slctab[(int)func].defset.val;
304 add_slc(func, slctab[(int)func].current.flag,
305 slctab[(int)func].current.val);
310 * Client wants us to change to a new value or he
311 * is telling us that he can't change to our value.
312 * Some of the slc's we support and can change,
313 * some we do support but can't change,
314 * and others we don't support at all.
315 * If we can change it then we have a pointer to
316 * the place to put the new value, so change it,
317 * otherwise, continue the negotiation.
319 if (slctab[(int)func].sptr) {
321 * We can change this one.
323 slctab[(int)func].current.val = val;
324 *(slctab[(int)func].sptr) = val;
325 slctab[(int)func].current.flag = flag;
328 add_slc(func, flag, val);
331 * It is not possible for us to support this
332 * request as he asks.
334 * If our level is DEFAULT, then just ack whatever was
337 * If he can't change and we can't change,
338 * then degenerate to NOSUPPORT.
340 * Otherwise we send our level back to him, (CANTCHANGE
341 * or NOSUPPORT) and if CANTCHANGE, send
344 if (mylevel == SLC_DEFAULT) {
345 slctab[(int)func].current.flag = flag;
346 slctab[(int)func].current.val = val;
348 } else if (hislevel == SLC_CANTCHANGE &&
349 mylevel == SLC_CANTCHANGE) {
350 flag &= ~SLC_LEVELBITS;
351 flag |= SLC_NOSUPPORT;
352 slctab[(int)func].current.flag = flag;
354 flag &= ~SLC_LEVELBITS;
356 slctab[(int)func].current.flag = flag;
357 if (mylevel == SLC_CANTCHANGE) {
358 slctab[(int)func].current.val =
359 slctab[(int)func].defset.val;
360 val = slctab[(int)func].current.val;
363 add_slc(func, flag, val);
366 } /* end of change_slc */
368 #if defined(USE_TERMIO) && (VEOF == VMIN)
369 cc_t oldeofc = '\004';
375 * Check the special characters in use and notify the client if any have
376 * changed. Only those characters that are capable of being changed are
377 * likely to have changed. If a local change occurs, kick the support level
378 * and flags up to the defaults.
385 for (i = 1; i <= NSLC; i++) {
386 #if defined(USE_TERMIO) && (VEOF == VMIN)
388 * In a perfect world this would be a neat little
389 * function. But in this world, we should not notify
390 * client of changes to the VEOF char when
391 * ICANON is off, because it is not representing
392 * a special character.
395 if (!tty_isediting())
397 else if (slctab[i].sptr)
398 oldeofc = *(slctab[i].sptr);
400 #endif /* defined(USE_TERMIO) && defined(SYSV_TERMIO) */
401 if (slctab[i].sptr &&
402 (*(slctab[i].sptr) != slctab[i].current.val)) {
403 slctab[i].current.val = *(slctab[i].sptr);
404 if (*(slctab[i].sptr) == (cc_t)_POSIX_VDISABLE)
405 slctab[i].current.flag = SLC_NOSUPPORT;
407 slctab[i].current.flag = slctab[i].defset.flag;
408 add_slc((unsigned char)i, slctab[i].current.flag,
409 slctab[i].current.val);
417 * Process an slc option buffer. Defer processing of incoming slc's
418 * until after the terminal state has been processed. Save the first slc
419 * request that comes along, but discard all others.
421 * ptr points to the beginning of the buffer, len is the length.
424 do_opt_slc(unsigned char *ptr, int len)
426 unsigned char func, flag;
428 unsigned char *end = ptr + len;
430 if (terminit()) { /* go ahead */
433 if (ptr >= end) break;
435 if (ptr >= end) break;
438 process_slc(func, flag, val);
443 * save this slc buffer if it is the first, otherwise dump
446 if (def_slcbuf == NULL) {
448 def_slcbuf = (unsigned char *)malloc((unsigned)len);
449 if (def_slcbuf == NULL)
450 return; /* too bad */
451 memmove(def_slcbuf, ptr, len);
455 } /* end of do_opt_slc */
460 * Do slc stuff that was deferred.
467 do_opt_slc(def_slcbuf, def_slclen);
474 } /* end of deferslc */
476 #endif /* LINEMODE */