I've just discovered that using the saved sessions menu from Unix
[u/mdw/putty] / unix / uxser.c
1 /*
2 * Serial back end (Unix-specific).
3 */
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <assert.h>
8 #include <limits.h>
9
10 #include <errno.h>
11 #include <unistd.h>
12 #include <fcntl.h>
13 #include <termios.h>
14
15 #include "putty.h"
16 #include "tree234.h"
17
18 #define SERIAL_MAX_BACKLOG 4096
19
20 typedef struct serial_backend_data {
21 void *frontend;
22 int fd;
23 int finished;
24 int inbufsize;
25 bufchain output_data;
26 } *Serial;
27
28 /*
29 * We store our serial backends in a tree sorted by fd, so that
30 * when we get an uxsel notification we know which backend instance
31 * is the owner of the serial port that caused it.
32 */
33 static int serial_compare_by_fd(void *av, void *bv)
34 {
35 Serial a = (Serial)av;
36 Serial b = (Serial)bv;
37
38 if (a->fd < b->fd)
39 return -1;
40 else if (a->fd > b->fd)
41 return +1;
42 return 0;
43 }
44
45 static int serial_find_by_fd(void *av, void *bv)
46 {
47 int a = *(int *)av;
48 Serial b = (Serial)bv;
49
50 if (a < b->fd)
51 return -1;
52 else if (a > b->fd)
53 return +1;
54 return 0;
55 }
56
57 static tree234 *serial_by_fd = NULL;
58
59 static int serial_select_result(int fd, int event);
60 static void serial_uxsel_setup(Serial serial);
61 static void serial_try_write(Serial serial);
62
63 static const char *serial_configure(Serial serial, Config *cfg)
64 {
65 struct termios options;
66 int bflag, bval;
67 const char *str;
68 char *msg;
69
70 if (serial->fd < 0)
71 return "Unable to reconfigure already-closed serial connection";
72
73 tcgetattr(serial->fd, &options);
74
75 /*
76 * Find the appropriate baud rate flag.
77 */
78 #define SETBAUD(x) (bflag = B ## x, bval = x)
79 #define CHECKBAUD(x) do { if (cfg->serspeed >= x) SETBAUD(x); } while (0)
80 SETBAUD(50);
81 #ifdef B75
82 CHECKBAUD(75);
83 #endif
84 #ifdef B110
85 CHECKBAUD(110);
86 #endif
87 #ifdef B134
88 CHECKBAUD(134);
89 #endif
90 #ifdef B150
91 CHECKBAUD(150);
92 #endif
93 #ifdef B200
94 CHECKBAUD(200);
95 #endif
96 #ifdef B300
97 CHECKBAUD(300);
98 #endif
99 #ifdef B600
100 CHECKBAUD(600);
101 #endif
102 #ifdef B1200
103 CHECKBAUD(1200);
104 #endif
105 #ifdef B1800
106 CHECKBAUD(1800);
107 #endif
108 #ifdef B2400
109 CHECKBAUD(2400);
110 #endif
111 #ifdef B4800
112 CHECKBAUD(4800);
113 #endif
114 #ifdef B9600
115 CHECKBAUD(9600);
116 #endif
117 #ifdef B19200
118 CHECKBAUD(19200);
119 #endif
120 #ifdef B38400
121 CHECKBAUD(38400);
122 #endif
123 #ifdef B57600
124 CHECKBAUD(57600);
125 #endif
126 #ifdef B76800
127 CHECKBAUD(76800);
128 #endif
129 #ifdef B115200
130 CHECKBAUD(115200);
131 #endif
132 #ifdef B230400
133 CHECKBAUD(230400);
134 #endif
135 #undef CHECKBAUD
136 #undef SETBAUD
137 cfsetispeed(&options, bflag);
138 cfsetospeed(&options, bflag);
139 msg = dupprintf("Configuring baud rate %d", bval);
140 logevent(serial->frontend, msg);
141 sfree(msg);
142
143 options.c_cflag &= ~CSIZE;
144 switch (cfg->serdatabits) {
145 case 5: options.c_cflag |= CS5; break;
146 case 6: options.c_cflag |= CS6; break;
147 case 7: options.c_cflag |= CS7; break;
148 case 8: options.c_cflag |= CS8; break;
149 default: return "Invalid number of data bits (need 5, 6, 7 or 8)";
150 }
151 msg = dupprintf("Configuring %d data bits", cfg->serdatabits);
152 logevent(serial->frontend, msg);
153 sfree(msg);
154
155 if (cfg->serstopbits >= 4) {
156 options.c_cflag |= CSTOPB;
157 } else {
158 options.c_cflag &= ~CSTOPB;
159 }
160 msg = dupprintf("Configuring %d stop bits",
161 (options.c_cflag & CSTOPB ? 2 : 1));
162 logevent(serial->frontend, msg);
163 sfree(msg);
164
165 options.c_iflag &= ~(IXON|IXOFF);
166 #ifdef CRTSCTS
167 options.c_cflag &= ~CRTSCTS;
168 #endif
169 #ifdef CNEW_RTSCTS
170 options.c_cflag &= ~CNEW_RTSCTS;
171 #endif
172 if (cfg->serflow == SER_FLOW_XONXOFF) {
173 options.c_iflag |= IXON | IXOFF;
174 str = "XON/XOFF";
175 } else if (cfg->serflow == SER_FLOW_RTSCTS) {
176 #ifdef CRTSCTS
177 options.c_cflag |= CRTSCTS;
178 #endif
179 #ifdef CNEW_RTSCTS
180 options.c_cflag |= CNEW_RTSCTS;
181 #endif
182 str = "RTS/CTS";
183 } else
184 str = "no";
185 msg = dupprintf("Configuring %s flow control", str);
186 logevent(serial->frontend, msg);
187 sfree(msg);
188
189 /* Parity */
190 if (cfg->serparity == SER_PAR_ODD) {
191 options.c_cflag |= PARENB;
192 options.c_cflag |= PARODD;
193 str = "odd";
194 } else if (cfg->serparity == SER_PAR_EVEN) {
195 options.c_cflag |= PARENB;
196 options.c_cflag &= ~PARODD;
197 str = "even";
198 } else {
199 options.c_cflag &= ~PARENB;
200 str = "no";
201 }
202 msg = dupprintf("Configuring %s parity", str);
203 logevent(serial->frontend, msg);
204 sfree(msg);
205
206 options.c_cflag |= CLOCAL | CREAD;
207 options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
208 options.c_iflag &= ~(ISTRIP | IGNCR | INLCR | ICRNL
209 #ifdef IUCLC
210 | IUCLC
211 #endif
212 );
213 options.c_oflag &= ~(OPOST
214 #ifdef ONLCR
215 | ONLCR
216 #endif
217 | OCRNL | ONOCR | ONLRET);
218 options.c_cc[VMIN] = 1;
219 options.c_cc[VTIME] = 0;
220
221 if (tcsetattr(serial->fd, TCSANOW, &options) < 0)
222 return "Unable to configure serial port";
223
224 return NULL;
225 }
226
227 /*
228 * Called to set up the serial connection.
229 *
230 * Returns an error message, or NULL on success.
231 *
232 * Also places the canonical host name into `realhost'. It must be
233 * freed by the caller.
234 */
235 static const char *serial_init(void *frontend_handle, void **backend_handle,
236 Config *cfg,
237 char *host, int port, char **realhost, int nodelay,
238 int keepalive)
239 {
240 Serial serial;
241 const char *err;
242
243 serial = snew(struct serial_backend_data);
244 *backend_handle = serial;
245
246 serial->frontend = frontend_handle;
247 serial->finished = FALSE;
248 serial->inbufsize = 0;
249 bufchain_init(&serial->output_data);
250
251 {
252 char *msg = dupprintf("Opening serial device %s", cfg->serline);
253 logevent(serial->frontend, msg);
254 }
255
256 serial->fd = open(cfg->serline, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK);
257 if (serial->fd < 0)
258 return "Unable to open serial port";
259
260 fcntl(serial->fd, F_SETFD, FD_CLOEXEC);
261
262 err = serial_configure(serial, cfg);
263 if (err)
264 return err;
265
266 *realhost = dupstr(cfg->serline);
267
268 if (!serial_by_fd)
269 serial_by_fd = newtree234(serial_compare_by_fd);
270 add234(serial_by_fd, serial);
271
272 serial_uxsel_setup(serial);
273
274 /*
275 * Specials are always available.
276 */
277 update_specials_menu(serial->frontend);
278
279 return NULL;
280 }
281
282 static void serial_close(Serial serial)
283 {
284 if (serial->fd >= 0) {
285 close(serial->fd);
286 serial->fd = -1;
287 }
288 }
289
290 static void serial_free(void *handle)
291 {
292 Serial serial = (Serial) handle;
293
294 serial_close(serial);
295
296 bufchain_clear(&serial->output_data);
297
298 sfree(serial);
299 }
300
301 static void serial_reconfig(void *handle, Config *cfg)
302 {
303 Serial serial = (Serial) handle;
304 const char *err;
305
306 err = serial_configure(serial, cfg);
307
308 /*
309 * FIXME: what should we do if err returns something?
310 */
311 }
312
313 static int serial_select_result(int fd, int event)
314 {
315 Serial serial;
316 char buf[4096];
317 int ret;
318 int finished = FALSE;
319
320 serial = find234(serial_by_fd, &fd, serial_find_by_fd);
321
322 if (!serial)
323 return 1; /* spurious event; keep going */
324
325 if (event == 1) {
326 ret = read(serial->fd, buf, sizeof(buf));
327
328 if (ret == 0) {
329 /*
330 * Shouldn't happen on a real serial port, but I'm open
331 * to the idea that there might be two-way devices we
332 * can treat _like_ serial ports which can return EOF.
333 */
334 finished = TRUE;
335 } else if (ret < 0) {
336 perror("read serial port");
337 exit(1);
338 } else if (ret > 0) {
339 serial->inbufsize = from_backend(serial->frontend, 0, buf, ret);
340 serial_uxsel_setup(serial); /* might acquire backlog and freeze */
341 }
342 } else if (event == 2) {
343 /*
344 * Attempt to send data down the pty.
345 */
346 serial_try_write(serial);
347 }
348
349 if (finished) {
350 serial_close(serial);
351
352 serial->finished = TRUE;
353
354 notify_remote_exit(serial->frontend);
355 }
356
357 return !finished;
358 }
359
360 static void serial_uxsel_setup(Serial serial)
361 {
362 int rwx = 0;
363
364 if (serial->inbufsize <= SERIAL_MAX_BACKLOG)
365 rwx |= 1;
366 if (bufchain_size(&serial->output_data))
367 rwx |= 2; /* might also want to write to it */
368 uxsel_set(serial->fd, rwx, serial_select_result);
369 }
370
371 static void serial_try_write(Serial serial)
372 {
373 void *data;
374 int len, ret;
375
376 assert(serial->fd >= 0);
377
378 while (bufchain_size(&serial->output_data) > 0) {
379 bufchain_prefix(&serial->output_data, &data, &len);
380 ret = write(serial->fd, data, len);
381
382 if (ret < 0 && (errno == EWOULDBLOCK)) {
383 /*
384 * We've sent all we can for the moment.
385 */
386 break;
387 }
388 if (ret < 0) {
389 perror("write serial port");
390 exit(1);
391 }
392 bufchain_consume(&serial->output_data, ret);
393 }
394
395 serial_uxsel_setup(serial);
396 }
397
398 /*
399 * Called to send data down the serial connection.
400 */
401 static int serial_send(void *handle, char *buf, int len)
402 {
403 Serial serial = (Serial) handle;
404
405 if (serial->fd < 0)
406 return 0;
407
408 bufchain_add(&serial->output_data, buf, len);
409 serial_try_write(serial);
410
411 return bufchain_size(&serial->output_data);
412 }
413
414 /*
415 * Called to query the current sendability status.
416 */
417 static int serial_sendbuffer(void *handle)
418 {
419 Serial serial = (Serial) handle;
420 return bufchain_size(&serial->output_data);
421 }
422
423 /*
424 * Called to set the size of the window
425 */
426 static void serial_size(void *handle, int width, int height)
427 {
428 /* Do nothing! */
429 return;
430 }
431
432 /*
433 * Send serial special codes.
434 */
435 static void serial_special(void *handle, Telnet_Special code)
436 {
437 Serial serial = (Serial) handle;
438
439 if (serial->fd >= 0 && code == TS_BRK) {
440 tcsendbreak(serial->fd, 0);
441 logevent(serial->frontend, "Sending serial break at user request");
442 }
443
444 return;
445 }
446
447 /*
448 * Return a list of the special codes that make sense in this
449 * protocol.
450 */
451 static const struct telnet_special *serial_get_specials(void *handle)
452 {
453 static const struct telnet_special specials[] = {
454 {"Break", TS_BRK},
455 {NULL, TS_EXITMENU}
456 };
457 return specials;
458 }
459
460 static int serial_connected(void *handle)
461 {
462 return 1; /* always connected */
463 }
464
465 static int serial_sendok(void *handle)
466 {
467 return 1;
468 }
469
470 static void serial_unthrottle(void *handle, int backlog)
471 {
472 Serial serial = (Serial) handle;
473 serial->inbufsize = backlog;
474 serial_uxsel_setup(serial);
475 }
476
477 static int serial_ldisc(void *handle, int option)
478 {
479 /*
480 * Local editing and local echo are off by default.
481 */
482 return 0;
483 }
484
485 static void serial_provide_ldisc(void *handle, void *ldisc)
486 {
487 /* This is a stub. */
488 }
489
490 static void serial_provide_logctx(void *handle, void *logctx)
491 {
492 /* This is a stub. */
493 }
494
495 static int serial_exitcode(void *handle)
496 {
497 Serial serial = (Serial) handle;
498 if (serial->fd >= 0)
499 return -1; /* still connected */
500 else
501 /* Exit codes are a meaningless concept with serial ports */
502 return INT_MAX;
503 }
504
505 /*
506 * cfg_info for Serial does nothing at all.
507 */
508 static int serial_cfg_info(void *handle)
509 {
510 return 0;
511 }
512
513 Backend serial_backend = {
514 serial_init,
515 serial_free,
516 serial_reconfig,
517 serial_send,
518 serial_sendbuffer,
519 serial_size,
520 serial_special,
521 serial_get_specials,
522 serial_connected,
523 serial_exitcode,
524 serial_sendok,
525 serial_ldisc,
526 serial_provide_ldisc,
527 serial_provide_logctx,
528 serial_unthrottle,
529 serial_cfg_info,
530 1
531 };