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