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 * @(#)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 $ 36 */ 37 38 #include "telnetd.h" 39 40 #ifdef LINEMODE 41 /* 42 * local variables 43 */ 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 */ 49 50 /* 51 * send_slc 52 * 53 * Write out the current special characters to the client. 54 */ 55 void 56 send_slc(void) 57 { 58 int i; 59 60 /* 61 * Send out list of triplets of special characters 62 * to client. We only send info on the characters 63 * that are currently supported. 64 */ 65 for (i = 1; i <= NSLC; i++) { 66 if ((slctab[i].defset.flag & SLC_LEVELBITS) == SLC_NOSUPPORT) 67 continue; 68 add_slc((unsigned char)i, slctab[i].current.flag, 69 slctab[i].current.val); 70 } 71 72 } /* end of send_slc */ 73 74 /* 75 * default_slc 76 * 77 * Set pty special characters to all the defaults. 78 */ 79 static void 80 default_slc(void) 81 { 82 int i; 83 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; 88 else 89 slctab[i].current.flag = slctab[i].defset.flag; 90 if (slctab[i].sptr) { 91 *(slctab[i].sptr) = slctab[i].defset.val; 92 } 93 } 94 slcchange = 1; 95 96 } /* end of default_slc */ 97 #endif /* LINEMODE */ 98 99 /* 100 * get_slc_defaults 101 * 102 * Initialize the slc mapping table. 103 */ 104 void 105 get_slc_defaults(void) 106 { 107 int i; 108 109 init_termbuf(); 110 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; 116 } 117 118 } /* end of get_slc_defaults */ 119 120 #ifdef LINEMODE 121 /* 122 * add_slc 123 * 124 * Add an slc triplet to the slc buffer. 125 */ 126 void 127 add_slc(char func, char flag, cc_t val) 128 { 129 130 if ((*slcptr++ = (unsigned char)func) == 0xff) 131 *slcptr++ = 0xff; 132 133 if ((*slcptr++ = (unsigned char)flag) == 0xff) 134 *slcptr++ = 0xff; 135 136 if ((*slcptr++ = (unsigned char)val) == 0xff) 137 *slcptr++ = 0xff; 138 139 } /* end of add_slc */ 140 141 /* 142 * start_slc 143 * 144 * Get ready to process incoming slc's and respond to them. 145 * 146 * The parameter getit is non-zero if it is necessary to grab a copy 147 * of the terminal control structures. 148 */ 149 void 150 start_slc(int getit) 151 { 152 153 slcchange = 0; 154 if (getit) 155 init_termbuf(); 156 (void) sprintf((char *)slcbuf, "%c%c%c%c", 157 IAC, SB, TELOPT_LINEMODE, LM_SLC); 158 slcptr = slcbuf + 4; 159 160 } /* end of start_slc */ 161 162 /* 163 * end_slc 164 * 165 * Finish up the slc negotiation. If something to send, then send it. 166 */ 167 int 168 end_slc(unsigned char **bufp) 169 { 170 int len; 171 172 /* 173 * If a change has occured, store the new terminal control 174 * structures back to the terminal driver. 175 */ 176 if (slcchange) { 177 set_termbuf(); 178 } 179 180 /* 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 184 * request very soon. 185 */ 186 if (def_slcbuf && (terminit() == 0)) { 187 return(0); 188 } 189 190 if (slcptr > (slcbuf + 4)) { 191 if (bufp) { 192 *bufp = &slcbuf[4]; 193 return(slcptr - slcbuf - 4); 194 } else { 195 (void) sprintf((char *)slcptr, "%c%c", IAC, SE); 196 slcptr += 2; 197 len = slcptr - slcbuf; 198 output_datalen(slcbuf, len); 199 netflush(); /* force it out immediately */ 200 DIAG(TD_OPTIONS, printsub('>', slcbuf+2, len-2);); 201 } 202 } 203 return (0); 204 205 } /* end of end_slc */ 206 207 /* 208 * process_slc 209 * 210 * Figure out what to do about the client's slc 211 */ 212 void 213 process_slc(unsigned char func, unsigned char flag, cc_t val) 214 { 215 int hislevel, mylevel, ack; 216 217 /* 218 * Ensure that we know something about this function 219 */ 220 if (func > NSLC) { 221 add_slc(func, SLC_NOSUPPORT, 0); 222 return; 223 } 224 225 /* 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. 229 */ 230 if (func == 0) { 231 if ((flag = flag & SLC_LEVELBITS) == SLC_DEFAULT) { 232 default_slc(); 233 send_slc(); 234 } else if (flag == SLC_VARIABLE) { 235 send_slc(); 236 } 237 return; 238 } 239 240 /* 241 * Appears to be a function that we know something about. So 242 * get on with it and see what we know. 243 */ 244 245 hislevel = flag & SLC_LEVELBITS; 246 mylevel = slctab[func].current.flag & SLC_LEVELBITS; 247 ack = flag & SLC_ACK; 248 /* 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 252 */ 253 if (hislevel == mylevel && (val == slctab[func].current.val || ack)) { 254 return; 255 } else if (ack) { 256 /* 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. 262 */ 263 return; 264 } else { 265 change_slc(func, flag, val); 266 } 267 268 } /* end of process_slc */ 269 270 /* 271 * change_slc 272 * 273 * Process a request to change one of our special characters. 274 * Compare client's request with what we are capable of supporting. 275 */ 276 void 277 change_slc(char func, char flag, cc_t val) 278 { 279 int hislevel, mylevel; 280 281 hislevel = flag & SLC_LEVELBITS; 282 mylevel = slctab[(int)func].defset.flag & SLC_LEVELBITS; 283 /* 284 * If client is setting a function to NOSUPPORT 285 * or DEFAULT, then we can easily and directly 286 * accomodate the request. 287 */ 288 if (hislevel == SLC_NOSUPPORT) { 289 slctab[(int)func].current.flag = flag; 290 slctab[(int)func].current.val = (cc_t)_POSIX_VDISABLE; 291 flag |= SLC_ACK; 292 add_slc(func, flag, val); 293 return; 294 } 295 if (hislevel == SLC_DEFAULT) { 296 /* 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. 301 */ 302 if (mylevel == SLC_DEFAULT) { 303 slctab[(int)func].current.flag = SLC_NOSUPPORT; 304 } else { 305 slctab[(int)func].current.flag = slctab[(int)func].defset.flag; 306 } 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); 310 return; 311 } 312 313 /* 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. 322 */ 323 if (slctab[(int)func].sptr) { 324 /* 325 * We can change this one. 326 */ 327 slctab[(int)func].current.val = val; 328 *(slctab[(int)func].sptr) = val; 329 slctab[(int)func].current.flag = flag; 330 flag |= SLC_ACK; 331 slcchange = 1; 332 add_slc(func, flag, val); 333 } else { 334 /* 335 * It is not possible for us to support this 336 * request as he asks. 337 * 338 * If our level is DEFAULT, then just ack whatever was 339 * sent. 340 * 341 * If he can't change and we can't change, 342 * then degenerate to NOSUPPORT. 343 * 344 * Otherwise we send our level back to him, (CANTCHANGE 345 * or NOSUPPORT) and if CANTCHANGE, send 346 * our value as well. 347 */ 348 if (mylevel == SLC_DEFAULT) { 349 slctab[(int)func].current.flag = flag; 350 slctab[(int)func].current.val = val; 351 flag |= SLC_ACK; 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; 357 } else { 358 flag &= ~SLC_LEVELBITS; 359 flag |= mylevel; 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; 365 } 366 } 367 add_slc(func, flag, val); 368 } 369 370 } /* end of change_slc */ 371 372 #if defined(USE_TERMIO) && (VEOF == VMIN) 373 cc_t oldeofc = '\004'; 374 #endif 375 376 /* 377 * check_slc 378 * 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. 383 */ 384 void 385 check_slc(void) 386 { 387 int i; 388 389 for (i = 1; i <= NSLC; i++) { 390 #if defined(USE_TERMIO) && (VEOF == VMIN) 391 /* 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. 397 */ 398 if (i == SLC_EOF) { 399 if (!tty_isediting()) 400 continue; 401 else if (slctab[i].sptr) 402 oldeofc = *(slctab[i].sptr); 403 } 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; 410 else 411 slctab[i].current.flag = slctab[i].defset.flag; 412 add_slc((unsigned char)i, slctab[i].current.flag, 413 slctab[i].current.val); 414 } 415 } 416 } /* check_slc */ 417 418 /* 419 * do_opt_slc 420 * 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. 424 * 425 * ptr points to the beginning of the buffer, len is the length. 426 */ 427 void 428 do_opt_slc(unsigned char *ptr, int len) 429 { 430 unsigned char func, flag; 431 cc_t val; 432 unsigned char *end = ptr + len; 433 434 if (terminit()) { /* go ahead */ 435 while (ptr < end) { 436 func = *ptr++; 437 if (ptr >= end) break; 438 flag = *ptr++; 439 if (ptr >= end) break; 440 val = (cc_t)*ptr++; 441 442 process_slc(func, flag, val); 443 444 } 445 } else { 446 /* 447 * save this slc buffer if it is the first, otherwise dump 448 * it. 449 */ 450 if (def_slcbuf == (unsigned char *)0) { 451 def_slclen = len; 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); 456 } 457 } 458 459 } /* end of do_opt_slc */ 460 461 /* 462 * deferslc 463 * 464 * Do slc stuff that was deferred. 465 */ 466 void 467 deferslc(void) 468 { 469 if (def_slcbuf) { 470 start_slc(1); 471 do_opt_slc(def_slcbuf, def_slclen); 472 (void) end_slc(0); 473 free(def_slcbuf); 474 def_slcbuf = (unsigned char *)0; 475 def_slclen = 0; 476 } 477 478 } /* end of deferslc */ 479 480 #endif /* LINEMODE */ 481