1/*
2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
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.
20 *
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
31 * SUCH DAMAGE.
32 */
33
34#include <sys/cdefs.h>
35
36__FBSDID("$FreeBSD: head/contrib/telnet/telnetd/slc.c 87139 2001-11-30 21:06:38Z markm $");
37
38#ifndef lint
39static const char sccsid[] = "@(#)slc.c 8.2 (Berkeley) 5/30/95";
40#endif
41
42#include "telnetd.h"
43
44#ifdef LINEMODE
45/*
46 * local variables
47 */
48static unsigned char *def_slcbuf = (unsigned char *)0;
49static int def_slclen = 0;
50static int slcchange; /* change to slc is requested */
51static unsigned char *slcptr; /* pointer into slc buffer */
52static unsigned char slcbuf[NSLC*6]; /* buffer for slc negotiation */
53
54/*
55 * send_slc
56 *
57 * Write out the current special characters to the client.
58 */
59void
60send_slc(void)
61{
62 int i;
63
64 /*
65 * Send out list of triplets of special characters
66 * to client. We only send info on the characters
67 * that are currently supported.
68 */
69 for (i = 1; i <= NSLC; i++) {
70 if ((slctab[i].defset.flag & SLC_LEVELBITS) == SLC_NOSUPPORT)
71 continue;
72 add_slc((unsigned char)i, slctab[i].current.flag,
73 slctab[i].current.val);
74 }
75
76} /* end of send_slc */
77
78/*
79 * default_slc
80 *
81 * Set pty special characters to all the defaults.
82 */
83static void
84default_slc(void)
85{
86 int i;
87
88 for (i = 1; i <= NSLC; i++) {
89 slctab[i].current.val = slctab[i].defset.val;
90 if (slctab[i].current.val == (cc_t)(_POSIX_VDISABLE))
91 slctab[i].current.flag = SLC_NOSUPPORT;
92 else
93 slctab[i].current.flag = slctab[i].defset.flag;
94 if (slctab[i].sptr) {
95 *(slctab[i].sptr) = slctab[i].defset.val;
96 }
97 }
98 slcchange = 1;
99
100} /* end of default_slc */
101#endif /* LINEMODE */
102
103/*
104 * get_slc_defaults
105 *
106 * Initialize the slc mapping table.
107 */
108void
109get_slc_defaults(void)
110{
111 int i;
112
113 init_termbuf();
114
115 for (i = 1; i <= NSLC; i++) {
116 slctab[i].defset.flag =
117 spcset(i, &slctab[i].defset.val, &slctab[i].sptr);
118 slctab[i].current.flag = SLC_NOSUPPORT;
119 slctab[i].current.val = 0;
120 }
121
122} /* end of get_slc_defaults */
123
124#ifdef LINEMODE
125/*
126 * add_slc
127 *
128 * Add an slc triplet to the slc buffer.
129 */
130void
131add_slc(char func, char flag, cc_t val)
132{
133
134 if ((*slcptr++ = (unsigned char)func) == 0xff)
135 *slcptr++ = 0xff;
136
137 if ((*slcptr++ = (unsigned char)flag) == 0xff)
138 *slcptr++ = 0xff;
139
140 if ((*slcptr++ = (unsigned char)val) == 0xff)
141 *slcptr++ = 0xff;
142
143} /* end of add_slc */
144
145/*
146 * start_slc
147 *
148 * Get ready to process incoming slc's and respond to them.
149 *
150 * The parameter getit is non-zero if it is necessary to grab a copy
151 * of the terminal control structures.
152 */
153void
154start_slc(int getit)
155{
156
157 slcchange = 0;
158 if (getit)
159 init_termbuf();
160 (void) sprintf((char *)slcbuf, "%c%c%c%c",
161 IAC, SB, TELOPT_LINEMODE, LM_SLC);
162 slcptr = slcbuf + 4;
163
164} /* end of start_slc */
165
166/*
167 * end_slc
168 *
169 * Finish up the slc negotiation. If something to send, then send it.
170 */
171int
172end_slc(unsigned char **bufp)
173{
174 int len;
175
176 /*
177 * If a change has occured, store the new terminal control
178 * structures back to the terminal driver.
179 */
180 if (slcchange) {
181 set_termbuf();
182 }
183
184 /*
185 * If the pty state has not yet been fully processed and there is a
186 * deferred slc request from the client, then do not send any
187 * sort of slc negotiation now. We will respond to the client's
188 * request very soon.
189 */
190 if (def_slcbuf && (terminit() == 0)) {
191 return(0);
192 }
193
194 if (slcptr > (slcbuf + 4)) {
195 if (bufp) {
196 *bufp = &slcbuf[4];
197 return(slcptr - slcbuf - 4);
198 } else {
199 (void) sprintf((char *)slcptr, "%c%c", IAC, SE);
200 slcptr += 2;
201 len = slcptr - slcbuf;
202 output_datalen(slcbuf, len);
203 netflush(); /* force it out immediately */
204 DIAG(TD_OPTIONS, printsub('>', slcbuf+2, len-2););
205 }
206 }
207 return (0);
208
209} /* end of end_slc */
210
211/*
212 * process_slc
213 *
214 * Figure out what to do about the client's slc
215 */
216void
217process_slc(unsigned char func, unsigned char flag, cc_t val)
218{
219 int hislevel, mylevel, ack;
220
221 /*
222 * Ensure that we know something about this function
223 */
224 if (func > NSLC) {
225 add_slc(func, SLC_NOSUPPORT, 0);
226 return;
227 }
228
229 /*
230 * Process the special case requests of 0 SLC_DEFAULT 0
231 * and 0 SLC_VARIABLE 0. Be a little forgiving here, don't
232 * worry about whether the value is actually 0 or not.
233 */
234 if (func == 0) {
235 if ((flag = flag & SLC_LEVELBITS) == SLC_DEFAULT) {
236 default_slc();
237 send_slc();
238 } else if (flag == SLC_VARIABLE) {
239 send_slc();
240 }
241 return;
242 }
243
244 /*
245 * Appears to be a function that we know something about. So
246 * get on with it and see what we know.
247 */
248
249 hislevel = flag & SLC_LEVELBITS;
250 mylevel = slctab[func].current.flag & SLC_LEVELBITS;
251 ack = flag & SLC_ACK;
252 /*
253 * ignore the command if:
254 * the function value and level are the same as what we already have;
255 * or the level is the same and the ack bit is set
256 */
257 if (hislevel == mylevel && (val == slctab[func].current.val || ack)) {
258 return;
259 } else if (ack) {
260 /*
261 * If we get here, we got an ack, but the levels don't match.
262 * This shouldn't happen. If it does, it is probably because
263 * we have sent two requests to set a variable without getting
264 * a response between them, and this is the first response.
265 * So, ignore it, and wait for the next response.
266 */
267 return;
268 } else {
269 change_slc(func, flag, val);
270 }
271
272} /* end of process_slc */
273
274/*
275 * change_slc
276 *
277 * Process a request to change one of our special characters.
278 * Compare client's request with what we are capable of supporting.
279 */
280void
281change_slc(char func, char flag, cc_t val)
282{
283 int hislevel, mylevel;
284
285 hislevel = flag & SLC_LEVELBITS;
286 mylevel = slctab[(int)func].defset.flag & SLC_LEVELBITS;
287 /*
288 * If client is setting a function to NOSUPPORT
289 * or DEFAULT, then we can easily and directly
290 * accomodate the request.
291 */
292 if (hislevel == SLC_NOSUPPORT) {
293 slctab[(int)func].current.flag = flag;
294 slctab[(int)func].current.val = (cc_t)_POSIX_VDISABLE;
295 flag |= SLC_ACK;
296 add_slc(func, flag, val);
297 return;
298 }
299 if (hislevel == SLC_DEFAULT) {
300 /*
301 * Special case here. If client tells us to use
302 * the default on a function we don't support, then
303 * return NOSUPPORT instead of what we may have as a
304 * default level of DEFAULT.
305 */
306 if (mylevel == SLC_DEFAULT) {
307 slctab[(int)func].current.flag = SLC_NOSUPPORT;
308 } else {
309 slctab[(int)func].current.flag = slctab[(int)func].defset.flag;
310 }
311 slctab[(int)func].current.val = slctab[(int)func].defset.val;
312 add_slc(func, slctab[(int)func].current.flag,
313 slctab[(int)func].current.val);
314 return;
315 }
316
317 /*
318 * Client wants us to change to a new value or he
319 * is telling us that he can't change to our value.
320 * Some of the slc's we support and can change,
321 * some we do support but can't change,
322 * and others we don't support at all.
323 * If we can change it then we have a pointer to
324 * the place to put the new value, so change it,
325 * otherwise, continue the negotiation.
326 */
327 if (slctab[(int)func].sptr) {
328 /*
329 * We can change this one.
330 */
331 slctab[(int)func].current.val = val;
332 *(slctab[(int)func].sptr) = val;
333 slctab[(int)func].current.flag = flag;
334 flag |= SLC_ACK;
335 slcchange = 1;
336 add_slc(func, flag, val);
337 } else {
338 /*
339 * It is not possible for us to support this
340 * request as he asks.
341 *
342 * If our level is DEFAULT, then just ack whatever was
343 * sent.
344 *
345 * If he can't change and we can't change,
346 * then degenerate to NOSUPPORT.
347 *
348 * Otherwise we send our level back to him, (CANTCHANGE
349 * or NOSUPPORT) and if CANTCHANGE, send
350 * our value as well.
351 */
352 if (mylevel == SLC_DEFAULT) {
353 slctab[(int)func].current.flag = flag;
354 slctab[(int)func].current.val = val;
355 flag |= SLC_ACK;
356 } else if (hislevel == SLC_CANTCHANGE &&
357 mylevel == SLC_CANTCHANGE) {
358 flag &= ~SLC_LEVELBITS;
359 flag |= SLC_NOSUPPORT;
360 slctab[(int)func].current.flag = flag;
361 } else {
362 flag &= ~SLC_LEVELBITS;
363 flag |= mylevel;
364 slctab[(int)func].current.flag = flag;
365 if (mylevel == SLC_CANTCHANGE) {
366 slctab[(int)func].current.val =
367 slctab[(int)func].defset.val;
368 val = slctab[(int)func].current.val;
369 }
370 }
371 add_slc(func, flag, val);
372 }
373
374} /* end of change_slc */
375
376#if defined(USE_TERMIO) && (VEOF == VMIN)
377cc_t oldeofc = '\004';
378#endif
379
380/*
381 * check_slc
382 *
383 * Check the special characters in use and notify the client if any have
384 * changed. Only those characters that are capable of being changed are
385 * likely to have changed. If a local change occurs, kick the support level
386 * and flags up to the defaults.
387 */
388void
389check_slc(void)
390{
391 int i;
392
393 for (i = 1; i <= NSLC; i++) {
394#if defined(USE_TERMIO) && (VEOF == VMIN)
395 /*
396 * In a perfect world this would be a neat little
397 * function. But in this world, we should not notify
398 * client of changes to the VEOF char when
399 * ICANON is off, because it is not representing
400 * a special character.
401 */
402 if (i == SLC_EOF) {
403 if (!tty_isediting())
404 continue;
405 else if (slctab[i].sptr)
406 oldeofc = *(slctab[i].sptr);
407 }
408#endif /* defined(USE_TERMIO) && defined(SYSV_TERMIO) */
409 if (slctab[i].sptr &&
410 (*(slctab[i].sptr) != slctab[i].current.val)) {
411 slctab[i].current.val = *(slctab[i].sptr);
412 if (*(slctab[i].sptr) == (cc_t)_POSIX_VDISABLE)
413 slctab[i].current.flag = SLC_NOSUPPORT;
414 else
415 slctab[i].current.flag = slctab[i].defset.flag;
416 add_slc((unsigned char)i, slctab[i].current.flag,
417 slctab[i].current.val);
418 }
419 }
420} /* check_slc */
421
422/*
423 * do_opt_slc
424 *
425 * Process an slc option buffer. Defer processing of incoming slc's
426 * until after the terminal state has been processed. Save the first slc
427 * request that comes along, but discard all others.
428 *
429 * ptr points to the beginning of the buffer, len is the length.
430 */
431void
432do_opt_slc(unsigned char *ptr, int len)
433{
434 unsigned char func, flag;
435 cc_t val;
436 unsigned char *end = ptr + len;
437
438 if (terminit()) { /* go ahead */
439 while (ptr < end) {
440 func = *ptr++;
441 if (ptr >= end) break;
442 flag = *ptr++;
443 if (ptr >= end) break;
444 val = (cc_t)*ptr++;
445
446 process_slc(func, flag, val);
447
448 }
449 } else {
450 /*
451 * save this slc buffer if it is the first, otherwise dump
452 * it.
453 */
454 if (def_slcbuf == (unsigned char *)0) {
455 def_slclen = len;
456 def_slcbuf = (unsigned char *)malloc((unsigned)len);
457 if (def_slcbuf == (unsigned char *)0)
458 return; /* too bad */
459 memmove(def_slcbuf, ptr, len);
460 }
461 }
462
463} /* end of do_opt_slc */
464
465/*
466 * deferslc
467 *
468 * Do slc stuff that was deferred.
469 */
470void
471deferslc(void)
472{
473 if (def_slcbuf) {
474 start_slc(1);
475 do_opt_slc(def_slcbuf, def_slclen);
476 (void) end_slc(0);
477 free(def_slcbuf);
478 def_slcbuf = (unsigned char *)0;
479 def_slclen = 0;
480 }
481
482} /* end of deferslc */
483
484#endif /* LINEMODE */