]> asedeno.scripts.mit.edu Git - PuTTY.git/blob - telnet.c
More preparatory work: remove the <windows.h> include from lots of
[PuTTY.git] / telnet.c
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 #include "putty.h"
5
6 #ifndef FALSE
7 #define FALSE 0
8 #endif
9 #ifndef TRUE
10 #define TRUE 1
11 #endif
12
13 #define IAC     255                    /* interpret as command: */
14 #define DONT    254                    /* you are not to use option */
15 #define DO      253                    /* please, you use option */
16 #define WONT    252                    /* I won't use option */
17 #define WILL    251                    /* I will use option */
18 #define SB      250                    /* interpret as subnegotiation */
19 #define SE      240                    /* end sub negotiation */
20
21 #define GA      249                    /* you may reverse the line */
22 #define EL      248                    /* erase the current line */
23 #define EC      247                    /* erase the current character */
24 #define AYT     246                    /* are you there */
25 #define AO      245                    /* abort output--but let prog finish */
26 #define IP      244                    /* interrupt process--permanently */
27 #define BREAK   243                    /* break */
28 #define DM      242                    /* data mark--for connect. cleaning */
29 #define NOP     241                    /* nop */
30 #define EOR     239                    /* end of record (transparent mode) */
31 #define ABORT   238                    /* Abort process */
32 #define SUSP    237                    /* Suspend process */
33 #define xEOF    236                    /* End of file: EOF is already used... */
34
35 #define TELOPT_BINARY   0              /* 8-bit data path */
36 #define TELOPT_ECHO     1              /* echo */
37 #define TELOPT_RCP      2              /* prepare to reconnect */
38 #define TELOPT_SGA      3              /* suppress go ahead */
39 #define TELOPT_NAMS     4              /* approximate message size */
40 #define TELOPT_STATUS   5              /* give status */
41 #define TELOPT_TM       6              /* timing mark */
42 #define TELOPT_RCTE     7              /* remote controlled transmission and echo */
43 #define TELOPT_NAOL     8              /* negotiate about output line width */
44 #define TELOPT_NAOP     9              /* negotiate about output page size */
45 #define TELOPT_NAOCRD   10             /* negotiate about CR disposition */
46 #define TELOPT_NAOHTS   11             /* negotiate about horizontal tabstops */
47 #define TELOPT_NAOHTD   12             /* negotiate about horizontal tab disposition */
48 #define TELOPT_NAOFFD   13             /* negotiate about formfeed disposition */
49 #define TELOPT_NAOVTS   14             /* negotiate about vertical tab stops */
50 #define TELOPT_NAOVTD   15             /* negotiate about vertical tab disposition */
51 #define TELOPT_NAOLFD   16             /* negotiate about output LF disposition */
52 #define TELOPT_XASCII   17             /* extended ascic character set */
53 #define TELOPT_LOGOUT   18             /* force logout */
54 #define TELOPT_BM       19             /* byte macro */
55 #define TELOPT_DET      20             /* data entry terminal */
56 #define TELOPT_SUPDUP   21             /* supdup protocol */
57 #define TELOPT_SUPDUPOUTPUT 22         /* supdup output */
58 #define TELOPT_SNDLOC   23             /* send location */
59 #define TELOPT_TTYPE    24             /* terminal type */
60 #define TELOPT_EOR      25             /* end or record */
61 #define TELOPT_TUID     26             /* TACACS user identification */
62 #define TELOPT_OUTMRK   27             /* output marking */
63 #define TELOPT_TTYLOC   28             /* terminal location number */
64 #define TELOPT_3270REGIME 29           /* 3270 regime */
65 #define TELOPT_X3PAD    30             /* X.3 PAD */
66 #define TELOPT_NAWS     31             /* window size */
67 #define TELOPT_TSPEED   32             /* terminal speed */
68 #define TELOPT_LFLOW    33             /* remote flow control */
69 #define TELOPT_LINEMODE 34             /* Linemode option */
70 #define TELOPT_XDISPLOC 35             /* X Display Location */
71 #define TELOPT_OLD_ENVIRON 36          /* Old - Environment variables */
72 #define TELOPT_AUTHENTICATION 37       /* Authenticate */
73 #define TELOPT_ENCRYPT  38             /* Encryption option */
74 #define TELOPT_NEW_ENVIRON 39          /* New - Environment variables */
75 #define TELOPT_EXOPL    255            /* extended-options-list */
76
77 #define TELQUAL_IS      0              /* option is... */
78 #define TELQUAL_SEND    1              /* send option */
79 #define TELQUAL_INFO    2              /* ENVIRON: informational version of IS */
80 #define BSD_VAR 1
81 #define BSD_VALUE 0
82 #define RFC_VAR 0
83 #define RFC_VALUE 1
84
85 #define CR 13
86 #define LF 10
87 #define NUL 0
88
89 #define iswritable(x) ( (x) != IAC && (x) != CR )
90
91 static char *telopt(int opt)
92 {
93 #define i(x) if (opt == TELOPT_ ## x) return #x;
94     i(BINARY);
95     i(ECHO);
96     i(RCP);
97     i(SGA);
98     i(NAMS);
99     i(STATUS);
100     i(TM);
101     i(RCTE);
102     i(NAOL);
103     i(NAOP);
104     i(NAOCRD);
105     i(NAOHTS);
106     i(NAOHTD);
107     i(NAOFFD);
108     i(NAOVTS);
109     i(NAOVTD);
110     i(NAOLFD);
111     i(XASCII);
112     i(LOGOUT);
113     i(BM);
114     i(DET);
115     i(SUPDUP);
116     i(SUPDUPOUTPUT);
117     i(SNDLOC);
118     i(TTYPE);
119     i(EOR);
120     i(TUID);
121     i(OUTMRK);
122     i(TTYLOC);
123     i(X3PAD);
124     i(NAWS);
125     i(TSPEED);
126     i(LFLOW);
127     i(LINEMODE);
128     i(XDISPLOC);
129     i(OLD_ENVIRON);
130     i(AUTHENTICATION);
131     i(ENCRYPT);
132     i(NEW_ENVIRON);
133     i(EXOPL);
134 #undef i
135     return "<unknown>";
136 }
137
138 static void telnet_size(void *handle, int width, int height);
139
140 struct Opt {
141     int send;                          /* what we initially send */
142     int nsend;                         /* -ve send if requested to stop it */
143     int ack, nak;                      /* +ve and -ve acknowledgements */
144     int option;                        /* the option code */
145     int index;                         /* index into telnet->opt_states[] */
146     enum {
147         REQUESTED, ACTIVE, INACTIVE, REALLY_INACTIVE
148     } initial_state;
149 };
150
151 enum {
152     OPTINDEX_NAWS,
153     OPTINDEX_TSPEED,
154     OPTINDEX_TTYPE,
155     OPTINDEX_OENV,
156     OPTINDEX_NENV,
157     OPTINDEX_ECHO,
158     OPTINDEX_WE_SGA,
159     OPTINDEX_THEY_SGA,
160     NUM_OPTS
161 };
162
163 static const struct Opt o_naws =
164     { WILL, WONT, DO, DONT, TELOPT_NAWS, OPTINDEX_NAWS, REQUESTED };
165 static const struct Opt o_tspeed =
166     { WILL, WONT, DO, DONT, TELOPT_TSPEED, OPTINDEX_TSPEED, REQUESTED };
167 static const struct Opt o_ttype =
168     { WILL, WONT, DO, DONT, TELOPT_TTYPE, OPTINDEX_TTYPE, REQUESTED };
169 static const struct Opt o_oenv = { WILL, WONT, DO, DONT, TELOPT_OLD_ENVIRON,
170     OPTINDEX_OENV, INACTIVE
171 };
172 static const struct Opt o_nenv = { WILL, WONT, DO, DONT, TELOPT_NEW_ENVIRON,
173     OPTINDEX_NENV, REQUESTED
174 };
175 static const struct Opt o_echo =
176     { DO, DONT, WILL, WONT, TELOPT_ECHO, OPTINDEX_ECHO, REQUESTED };
177 static const struct Opt o_we_sga =
178     { WILL, WONT, DO, DONT, TELOPT_SGA, OPTINDEX_WE_SGA, REQUESTED };
179 static const struct Opt o_they_sga =
180     { DO, DONT, WILL, WONT, TELOPT_SGA, OPTINDEX_THEY_SGA, REQUESTED };
181
182 static const struct Opt *const opts[] = {
183     &o_naws, &o_tspeed, &o_ttype, &o_oenv, &o_nenv, &o_echo,
184     &o_we_sga, &o_they_sga, NULL
185 };
186
187 typedef struct telnet_tag {
188     const struct plug_function_table *fn;
189     /* the above field _must_ be first in the structure */
190
191     Socket s;
192
193     void *frontend;
194     void *ldisc;
195     int term_width, term_height;
196
197     int opt_states[NUM_OPTS];
198
199     int echoing, editing;
200     int activated;
201     int bufsize;
202     int in_synch;
203     int sb_opt, sb_len;
204     char *sb_buf;
205     int sb_size;
206
207     enum {
208         TOP_LEVEL, SEENIAC, SEENWILL, SEENWONT, SEENDO, SEENDONT,
209             SEENSB, SUBNEGOT, SUBNEG_IAC, SEENCR
210     } state;
211
212 } *Telnet;
213
214 #define TELNET_MAX_BACKLOG 4096
215
216 #define SB_DELTA 1024
217
218 static void c_write1(Telnet telnet, int c)
219 {
220     int backlog;
221     char cc = (char) c;
222     backlog = from_backend(telnet->frontend, 0, &cc, 1);
223     sk_set_frozen(telnet->s, backlog > TELNET_MAX_BACKLOG);
224 }
225
226 static void log_option(Telnet telnet, char *sender, int cmd, int option)
227 {
228     char buf[50];
229     sprintf(buf, "%s:\t%s %s", sender,
230             (cmd == WILL ? "WILL" : cmd == WONT ? "WONT" :
231              cmd == DO ? "DO" : cmd == DONT ? "DONT" : "<??>"),
232             telopt(option));
233     logevent(telnet->frontend, buf);
234 }
235
236 static void send_opt(Telnet telnet, int cmd, int option)
237 {
238     unsigned char b[3];
239
240     b[0] = IAC;
241     b[1] = cmd;
242     b[2] = option;
243     telnet->bufsize = sk_write(telnet->s, b, 3);
244     log_option(telnet, "client", cmd, option);
245 }
246
247 static void deactivate_option(Telnet telnet, const struct Opt *o)
248 {
249     if (telnet->opt_states[o->index] == REQUESTED ||
250         telnet->opt_states[o->index] == ACTIVE)
251         send_opt(telnet, o->nsend, o->option);
252     telnet->opt_states[o->index] = REALLY_INACTIVE;
253 }
254
255 /*
256  * Generate side effects of enabling or disabling an option.
257  */
258 static void option_side_effects(Telnet telnet, const struct Opt *o, int enabled)
259 {
260     if (o->option == TELOPT_ECHO && o->send == DO)
261         telnet->echoing = !enabled;
262     else if (o->option == TELOPT_SGA && o->send == DO)
263         telnet->editing = !enabled;
264     if (telnet->ldisc)                 /* cause ldisc to notice the change */
265         ldisc_send(telnet->ldisc, NULL, 0, 0);
266
267     /* Ensure we get the minimum options */
268     if (!telnet->activated) {
269         if (telnet->opt_states[o_echo.index] == INACTIVE) {
270             telnet->opt_states[o_echo.index] = REQUESTED;
271             send_opt(telnet, o_echo.send, o_echo.option);
272         }
273         if (telnet->opt_states[o_we_sga.index] == INACTIVE) {
274             telnet->opt_states[o_we_sga.index] = REQUESTED;
275             send_opt(telnet, o_we_sga.send, o_we_sga.option);
276         }
277         if (telnet->opt_states[o_they_sga.index] == INACTIVE) {
278             telnet->opt_states[o_they_sga.index] = REQUESTED;
279             send_opt(telnet, o_they_sga.send, o_they_sga.option);
280         }
281         telnet->activated = TRUE;
282     }
283 }
284
285 static void activate_option(Telnet telnet, const struct Opt *o)
286 {
287     if (o->send == WILL && o->option == TELOPT_NAWS)
288         telnet_size(telnet, telnet->term_width, telnet->term_height);
289     if (o->send == WILL &&
290         (o->option == TELOPT_NEW_ENVIRON ||
291          o->option == TELOPT_OLD_ENVIRON)) {
292         /*
293          * We may only have one kind of ENVIRON going at a time.
294          * This is a hack, but who cares.
295          */
296         deactivate_option(telnet, o->option ==
297                           TELOPT_NEW_ENVIRON ? &o_oenv : &o_nenv);
298     }
299     option_side_effects(telnet, o, 1);
300 }
301
302 static void refused_option(Telnet telnet, const struct Opt *o)
303 {
304     if (o->send == WILL && o->option == TELOPT_NEW_ENVIRON &&
305         telnet->opt_states[o_oenv.index] == INACTIVE) {
306         send_opt(telnet, WILL, TELOPT_OLD_ENVIRON);
307         telnet->opt_states[o_oenv.index] = REQUESTED;
308     }
309     option_side_effects(telnet, o, 0);
310 }
311
312 static void proc_rec_opt(Telnet telnet, int cmd, int option)
313 {
314     const struct Opt *const *o;
315
316     log_option(telnet, "server", cmd, option);
317     for (o = opts; *o; o++) {
318         if ((*o)->option == option && (*o)->ack == cmd) {
319             switch (telnet->opt_states[(*o)->index]) {
320               case REQUESTED:
321                 telnet->opt_states[(*o)->index] = ACTIVE;
322                 activate_option(telnet, *o);
323                 break;
324               case ACTIVE:
325                 break;
326               case INACTIVE:
327                 telnet->opt_states[(*o)->index] = ACTIVE;
328                 send_opt(telnet, (*o)->send, option);
329                 activate_option(telnet, *o);
330                 break;
331               case REALLY_INACTIVE:
332                 send_opt(telnet, (*o)->nsend, option);
333                 break;
334             }
335             return;
336         } else if ((*o)->option == option && (*o)->nak == cmd) {
337             switch (telnet->opt_states[(*o)->index]) {
338               case REQUESTED:
339                 telnet->opt_states[(*o)->index] = INACTIVE;
340                 refused_option(telnet, *o);
341                 break;
342               case ACTIVE:
343                 telnet->opt_states[(*o)->index] = INACTIVE;
344                 send_opt(telnet, (*o)->nsend, option);
345                 option_side_effects(telnet, *o, 0);
346                 break;
347               case INACTIVE:
348               case REALLY_INACTIVE:
349                 break;
350             }
351             return;
352         }
353     }
354     /*
355      * If we reach here, the option was one we weren't prepared to
356      * cope with. So send a negative ack.
357      */
358     send_opt(telnet, (cmd == WILL ? DONT : WONT), option);
359 }
360
361 static void process_subneg(Telnet telnet)
362 {
363     unsigned char b[2048], *p, *q;
364     int var, value, n;
365     char *e;
366
367     switch (telnet->sb_opt) {
368       case TELOPT_TSPEED:
369         if (telnet->sb_len == 1 && telnet->sb_buf[0] == TELQUAL_SEND) {
370             char logbuf[sizeof(cfg.termspeed) + 80];
371             b[0] = IAC;
372             b[1] = SB;
373             b[2] = TELOPT_TSPEED;
374             b[3] = TELQUAL_IS;
375             strcpy(b + 4, cfg.termspeed);
376             n = 4 + strlen(cfg.termspeed);
377             b[n] = IAC;
378             b[n + 1] = SE;
379             telnet->bufsize = sk_write(telnet->s, b, n + 2);
380             logevent(telnet->frontend, "server:\tSB TSPEED SEND");
381             sprintf(logbuf, "client:\tSB TSPEED IS %s", cfg.termspeed);
382             logevent(telnet->frontend, logbuf);
383         } else
384             logevent(telnet->frontend, "server:\tSB TSPEED <something weird>");
385         break;
386       case TELOPT_TTYPE:
387         if (telnet->sb_len == 1 && telnet->sb_buf[0] == TELQUAL_SEND) {
388             char logbuf[sizeof(cfg.termtype) + 80];
389             b[0] = IAC;
390             b[1] = SB;
391             b[2] = TELOPT_TTYPE;
392             b[3] = TELQUAL_IS;
393             for (n = 0; cfg.termtype[n]; n++)
394                 b[n + 4] = (cfg.termtype[n] >= 'a'
395                             && cfg.termtype[n] <=
396                             'z' ? cfg.termtype[n] + 'A' -
397                             'a' : cfg.termtype[n]);
398             b[n + 4] = IAC;
399             b[n + 5] = SE;
400             telnet->bufsize = sk_write(telnet->s, b, n + 6);
401             b[n + 4] = 0;
402             logevent(telnet->frontend, "server:\tSB TTYPE SEND");
403             sprintf(logbuf, "client:\tSB TTYPE IS %s", b + 4);
404             logevent(telnet->frontend, logbuf);
405         } else
406             logevent(telnet->frontend, "server:\tSB TTYPE <something weird>\r\n");
407         break;
408       case TELOPT_OLD_ENVIRON:
409       case TELOPT_NEW_ENVIRON:
410         p = telnet->sb_buf;
411         q = p + telnet->sb_len;
412         if (p < q && *p == TELQUAL_SEND) {
413             char logbuf[50];
414             p++;
415             sprintf(logbuf, "server:\tSB %s SEND", telopt(telnet->sb_opt));
416             logevent(telnet->frontend, logbuf);
417             if (telnet->sb_opt == TELOPT_OLD_ENVIRON) {
418                 if (cfg.rfc_environ) {
419                     value = RFC_VALUE;
420                     var = RFC_VAR;
421                 } else {
422                     value = BSD_VALUE;
423                     var = BSD_VAR;
424                 }
425                 /*
426                  * Try to guess the sense of VAR and VALUE.
427                  */
428                 while (p < q) {
429                     if (*p == RFC_VAR) {
430                         value = RFC_VALUE;
431                         var = RFC_VAR;
432                     } else if (*p == BSD_VAR) {
433                         value = BSD_VALUE;
434                         var = BSD_VAR;
435                     }
436                     p++;
437                 }
438             } else {
439                 /*
440                  * With NEW_ENVIRON, the sense of VAR and VALUE
441                  * isn't in doubt.
442                  */
443                 value = RFC_VALUE;
444                 var = RFC_VAR;
445             }
446             b[0] = IAC;
447             b[1] = SB;
448             b[2] = telnet->sb_opt;
449             b[3] = TELQUAL_IS;
450             n = 4;
451             e = cfg.environmt;
452             while (*e) {
453                 b[n++] = var;
454                 while (*e && *e != '\t')
455                     b[n++] = *e++;
456                 if (*e == '\t')
457                     e++;
458                 b[n++] = value;
459                 while (*e)
460                     b[n++] = *e++;
461                 e++;
462             }
463             if (*cfg.username) {
464                 b[n++] = var;
465                 b[n++] = 'U';
466                 b[n++] = 'S';
467                 b[n++] = 'E';
468                 b[n++] = 'R';
469                 b[n++] = value;
470                 e = cfg.username;
471                 while (*e)
472                     b[n++] = *e++;
473             }
474             b[n++] = IAC;
475             b[n++] = SE;
476             telnet->bufsize = sk_write(telnet->s, b, n);
477             sprintf(logbuf, "client:\tSB %s IS %s", telopt(telnet->sb_opt),
478                     n == 6 ? "<nothing>" : "<stuff>");
479             logevent(telnet->frontend, logbuf);
480         }
481         break;
482     }
483 }
484
485 static void do_telnet_read(Telnet telnet, char *buf, int len)
486 {
487
488     while (len--) {
489         int c = (unsigned char) *buf++;
490
491         switch (telnet->state) {
492           case TOP_LEVEL:
493           case SEENCR:
494             if (c == NUL && telnet->state == SEENCR)
495                 telnet->state = TOP_LEVEL;
496             else if (c == IAC)
497                 telnet->state = SEENIAC;
498             else {
499                 if (!telnet->in_synch)
500                     c_write1(telnet, c);
501
502 #if 1
503                 /* I can't get the F***ing winsock to insert the urgent IAC
504                  * into the right position! Even with SO_OOBINLINE it gives
505                  * it to recv too soon. And of course the DM byte (that
506                  * arrives in the same packet!) appears several K later!!
507                  *
508                  * Oh well, we do get the DM in the right place so I'll
509                  * just stop hiding on the next 0xf2 and hope for the best.
510                  */
511                 else if (c == DM)
512                     telnet->in_synch = 0;
513 #endif
514                 if (c == CR)
515                     telnet->state = SEENCR;
516                 else
517                     telnet->state = TOP_LEVEL;
518             }
519             break;
520           case SEENIAC:
521             if (c == DO)
522                 telnet->state = SEENDO;
523             else if (c == DONT)
524                 telnet->state = SEENDONT;
525             else if (c == WILL)
526                 telnet->state = SEENWILL;
527             else if (c == WONT)
528                 telnet->state = SEENWONT;
529             else if (c == SB)
530                 telnet->state = SEENSB;
531             else if (c == DM) {
532                 telnet->in_synch = 0;
533                 telnet->state = TOP_LEVEL;
534             } else {
535                 /* ignore everything else; print it if it's IAC */
536                 if (c == IAC) {
537                     c_write1(telnet, c);
538                 }
539                 telnet->state = TOP_LEVEL;
540             }
541             break;
542           case SEENWILL:
543             proc_rec_opt(telnet, WILL, c);
544             telnet->state = TOP_LEVEL;
545             break;
546           case SEENWONT:
547             proc_rec_opt(telnet, WONT, c);
548             telnet->state = TOP_LEVEL;
549             break;
550           case SEENDO:
551             proc_rec_opt(telnet, DO, c);
552             telnet->state = TOP_LEVEL;
553             break;
554           case SEENDONT:
555             proc_rec_opt(telnet, DONT, c);
556             telnet->state = TOP_LEVEL;
557             break;
558           case SEENSB:
559             telnet->sb_opt = c;
560             telnet->sb_len = 0;
561             telnet->state = SUBNEGOT;
562             break;
563           case SUBNEGOT:
564             if (c == IAC)
565                 telnet->state = SUBNEG_IAC;
566             else {
567               subneg_addchar:
568                 if (telnet->sb_len >= telnet->sb_size) {
569                     char *newbuf;
570                     telnet->sb_size += SB_DELTA;
571                     newbuf = (telnet->sb_buf ?
572                               srealloc(telnet->sb_buf, telnet->sb_size) :
573                               smalloc(telnet->sb_size));
574                     if (newbuf)
575                         telnet->sb_buf = newbuf;
576                     else
577                         telnet->sb_size -= SB_DELTA;
578                 }
579                 if (telnet->sb_len < telnet->sb_size)
580                     telnet->sb_buf[telnet->sb_len++] = c;
581                 telnet->state = SUBNEGOT;       /* in case we came here by goto */
582             }
583             break;
584           case SUBNEG_IAC:
585             if (c != SE)
586                 goto subneg_addchar;   /* yes, it's a hack, I know, but... */
587             else {
588                 process_subneg(telnet);
589                 telnet->state = TOP_LEVEL;
590             }
591             break;
592         }
593     }
594 }
595
596 static int telnet_closing(Plug plug, char *error_msg, int error_code,
597                           int calling_back)
598 {
599     Telnet telnet = (Telnet) plug;
600
601     if (telnet->s) {
602         sk_close(telnet->s);
603         telnet->s = NULL;
604     }
605     if (error_msg) {
606         /* A socket error has occurred. */
607         logevent(telnet->frontend, error_msg);
608         connection_fatal("%s", error_msg);
609     }                                  /* Otherwise, the remote side closed the connection normally. */
610     return 0;
611 }
612
613 static int telnet_receive(Plug plug, int urgent, char *data, int len)
614 {
615     Telnet telnet = (Telnet) plug;
616     if (urgent)
617         telnet->in_synch = TRUE;
618     do_telnet_read(telnet, data, len);
619     return 1;
620 }
621
622 static void telnet_sent(Plug plug, int bufsize)
623 {
624     Telnet telnet = (Telnet) plug;
625     telnet->bufsize = bufsize;
626 }
627
628 /*
629  * Called to set up the Telnet connection.
630  *
631  * Returns an error message, or NULL on success.
632  *
633  * Also places the canonical host name into `realhost'. It must be
634  * freed by the caller.
635  */
636 static char *telnet_init(void *frontend_handle, void **backend_handle,
637                          char *host, int port, char **realhost, int nodelay)
638 {
639     static const struct plug_function_table fn_table = {
640         telnet_closing,
641         telnet_receive,
642         telnet_sent
643     };
644     SockAddr addr;
645     char *err;
646     Telnet telnet;
647
648     telnet = smalloc(sizeof(*telnet));
649     telnet->fn = &fn_table;
650     telnet->s = NULL;
651     telnet->echoing = TRUE;
652     telnet->editing = TRUE;
653     telnet->activated = FALSE;
654     telnet->sb_buf = NULL;
655     telnet->sb_size = 0;
656     telnet->frontend = frontend_handle;
657     telnet->term_width = cfg.width;
658     telnet->term_height = cfg.height;
659     telnet->state = TOP_LEVEL;
660     *backend_handle = telnet;
661
662     /*
663      * Try to find host.
664      */
665     {
666         char buf[200];
667         sprintf(buf, "Looking up host \"%.170s\"", host);
668         logevent(telnet->frontend, buf);
669     }
670     addr = sk_namelookup(host, realhost);
671     if ((err = sk_addr_error(addr)))
672         return err;
673
674     if (port < 0)
675         port = 23;                     /* default telnet port */
676
677     /*
678      * Open socket.
679      */
680     {
681         char buf[200], addrbuf[100];
682         sk_getaddr(addr, addrbuf, 100);
683         sprintf(buf, "Connecting to %.100s port %d", addrbuf, port);
684         logevent(telnet->frontend, buf);
685     }
686     telnet->s = new_connection(addr, *realhost, port, 0, 1,
687                                nodelay, (Plug) telnet);
688     if ((err = sk_socket_error(telnet->s)))
689         return err;
690
691     sk_addr_free(addr);
692
693     /*
694      * Initialise option states.
695      */
696     if (cfg.passive_telnet) {
697         const struct Opt *const *o;
698
699         for (o = opts; *o; o++)
700             telnet->opt_states[(*o)->index] = INACTIVE;
701     } else {
702         const struct Opt *const *o;
703
704         for (o = opts; *o; o++) {
705             telnet->opt_states[(*o)->index] = (*o)->initial_state;
706             if (telnet->opt_states[(*o)->index] == REQUESTED)
707                 send_opt(telnet, (*o)->send, (*o)->option);
708         }
709         telnet->activated = TRUE;
710     }
711
712     /*
713      * Set up SYNCH state.
714      */
715     telnet->in_synch = FALSE;
716
717     return NULL;
718 }
719
720 /*
721  * Called to send data down the Telnet connection.
722  */
723 static int telnet_send(void *handle, char *buf, int len)
724 {
725     Telnet telnet = (Telnet) handle;
726     char *p;
727     static unsigned char iac[2] = { IAC, IAC };
728     static unsigned char cr[2] = { CR, NUL };
729 #if 0
730     static unsigned char nl[2] = { CR, LF };
731 #endif
732
733     if (telnet->s == NULL)
734         return 0;
735
736     p = buf;
737     while (p < buf + len) {
738         char *q = p;
739
740         while (iswritable((unsigned char) *p) && p < buf + len)
741             p++;
742         telnet->bufsize = sk_write(telnet->s, q, p - q);
743
744         while (p < buf + len && !iswritable((unsigned char) *p)) {
745             telnet->bufsize = 
746                 sk_write(telnet->s, (unsigned char) *p == IAC ? iac : cr, 2);
747             p++;
748         }
749     }
750
751     return telnet->bufsize;
752 }
753
754 /*
755  * Called to query the current socket sendability status.
756  */
757 static int telnet_sendbuffer(void *handle)
758 {
759     Telnet telnet = (Telnet) handle;
760     return telnet->bufsize;
761 }
762
763 /*
764  * Called to set the size of the window from Telnet's POV.
765  */
766 static void telnet_size(void *handle, int width, int height)
767 {
768     Telnet telnet = (Telnet) handle;
769     unsigned char b[16];
770     char logbuf[50];
771
772     telnet->term_width = width;
773     telnet->term_height = height;
774
775     if (telnet->s == NULL || telnet->opt_states[o_naws.index] != ACTIVE)
776         return;
777     b[0] = IAC;
778     b[1] = SB;
779     b[2] = TELOPT_NAWS;
780     b[3] = telnet->term_width >> 8;
781     b[4] = telnet->term_width & 0xFF;
782     b[5] = telnet->term_height >> 8;
783     b[6] = telnet->term_height & 0xFF;
784     b[7] = IAC;
785     b[8] = SE;
786     telnet->bufsize = sk_write(telnet->s, b, 9);
787     sprintf(logbuf, "client:\tSB NAWS %d,%d",
788             ((unsigned char) b[3] << 8) + (unsigned char) b[4],
789             ((unsigned char) b[5] << 8) + (unsigned char) b[6]);
790     logevent(telnet->frontend, logbuf);
791 }
792
793 /*
794  * Send Telnet special codes.
795  */
796 static void telnet_special(void *handle, Telnet_Special code)
797 {
798     Telnet telnet = (Telnet) handle;
799     unsigned char b[2];
800
801     if (telnet->s == NULL)
802         return;
803
804     b[0] = IAC;
805     switch (code) {
806       case TS_AYT:
807         b[1] = AYT;
808         telnet->bufsize = sk_write(telnet->s, b, 2);
809         break;
810       case TS_BRK:
811         b[1] = BREAK;
812         telnet->bufsize = sk_write(telnet->s, b, 2);
813         break;
814       case TS_EC:
815         b[1] = EC;
816         telnet->bufsize = sk_write(telnet->s, b, 2);
817         break;
818       case TS_EL:
819         b[1] = EL;
820         telnet->bufsize = sk_write(telnet->s, b, 2);
821         break;
822       case TS_GA:
823         b[1] = GA;
824         telnet->bufsize = sk_write(telnet->s, b, 2);
825         break;
826       case TS_NOP:
827         b[1] = NOP;
828         telnet->bufsize = sk_write(telnet->s, b, 2);
829         break;
830       case TS_ABORT:
831         b[1] = ABORT;
832         telnet->bufsize = sk_write(telnet->s, b, 2);
833         break;
834       case TS_AO:
835         b[1] = AO;
836         telnet->bufsize = sk_write(telnet->s, b, 2);
837         break;
838       case TS_IP:
839         b[1] = IP;
840         telnet->bufsize = sk_write(telnet->s, b, 2);
841         break;
842       case TS_SUSP:
843         b[1] = SUSP;
844         telnet->bufsize = sk_write(telnet->s, b, 2);
845         break;
846       case TS_EOR:
847         b[1] = EOR;
848         telnet->bufsize = sk_write(telnet->s, b, 2);
849         break;
850       case TS_EOF:
851         b[1] = xEOF;
852         telnet->bufsize = sk_write(telnet->s, b, 2);
853         break;
854       case TS_EOL:
855         telnet->bufsize = sk_write(telnet->s, "\r\n", 2);
856         break;
857       case TS_SYNCH:
858         b[1] = DM;
859         telnet->bufsize = sk_write(telnet->s, b, 1);
860         telnet->bufsize = sk_write_oob(telnet->s, b + 1, 1);
861         break;
862       case TS_RECHO:
863         if (telnet->opt_states[o_echo.index] == INACTIVE ||
864             telnet->opt_states[o_echo.index] == REALLY_INACTIVE) {
865             telnet->opt_states[o_echo.index] = REQUESTED;
866             send_opt(telnet, o_echo.send, o_echo.option);
867         }
868         break;
869       case TS_LECHO:
870         if (telnet->opt_states[o_echo.index] == ACTIVE) {
871             telnet->opt_states[o_echo.index] = REQUESTED;
872             send_opt(telnet, o_echo.nsend, o_echo.option);
873         }
874         break;
875       case TS_PING:
876         if (telnet->opt_states[o_they_sga.index] == ACTIVE) {
877             b[1] = NOP;
878             telnet->bufsize = sk_write(telnet->s, b, 2);
879         }
880         break;
881     }
882 }
883
884 static Socket telnet_socket(void *handle)
885 {
886     Telnet telnet = (Telnet) handle;
887     return telnet->s;
888 }
889
890 static int telnet_sendok(void *handle)
891 {
892     /* Telnet telnet = (Telnet) handle; */
893     return 1;
894 }
895
896 static void telnet_unthrottle(void *handle, int backlog)
897 {
898     Telnet telnet = (Telnet) handle;
899     sk_set_frozen(telnet->s, backlog > TELNET_MAX_BACKLOG);
900 }
901
902 static int telnet_ldisc(void *handle, int option)
903 {
904     Telnet telnet = (Telnet) handle;
905     if (option == LD_ECHO)
906         return telnet->echoing;
907     if (option == LD_EDIT)
908         return telnet->editing;
909     return FALSE;
910 }
911
912 static void telnet_provide_ldisc(void *handle, void *ldisc)
913 {
914     Telnet telnet = (Telnet) handle;
915     telnet->ldisc = ldisc;
916 }
917
918 static void telnet_provide_logctx(void *handle, void *logctx)
919 {
920     /* This is a stub. */
921 }
922
923 static int telnet_exitcode(void *handle)
924 {
925     /* Telnet telnet = (Telnet) handle; */
926     /* Telnet doesn't transmit exit codes back to the client */
927     return 0;
928 }
929
930 Backend telnet_backend = {
931     telnet_init,
932     telnet_send,
933     telnet_sendbuffer,
934     telnet_size,
935     telnet_special,
936     telnet_socket,
937     telnet_exitcode,
938     telnet_sendok,
939     telnet_ldisc,
940     telnet_provide_ldisc,
941     telnet_provide_logctx,
942     telnet_unthrottle,
943     23
944 };