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