Refactor svr4_create_solib_event_breakpoints
[external/binutils.git] / gdb / serial.c
1 /* Generic serial interface routines
2
3    Copyright (C) 1992-2019 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include <ctype.h>
22 #include "serial.h"
23 #include "gdbcmd.h"
24 #include "cli/cli-utils.h"
25
26 /* Is serial being debugged?  */
27
28 static unsigned int global_serial_debug_p;
29
30 /* Serial I/O handlers.  */
31
32 static std::vector<const struct serial_ops *> serial_ops_list;
33
34 /* Pointer to list of scb's.  */
35
36 static struct serial *scb_base;
37
38 /* Non-NULL gives filename which contains a recording of the remote session,
39    suitable for playback by gdbserver.  */
40
41 static char *serial_logfile = NULL;
42 static struct ui_file *serial_logfp = NULL;
43
44 static const struct serial_ops *serial_interface_lookup (const char *);
45 static void serial_logchar (struct ui_file *stream,
46                             int ch_type, int ch, int timeout);
47 static const char logbase_hex[] = "hex";
48 static const char logbase_octal[] = "octal";
49 static const char logbase_ascii[] = "ascii";
50 static const char *const logbase_enums[] =
51 {logbase_hex, logbase_octal, logbase_ascii, NULL};
52 static const char *serial_logbase = logbase_ascii;
53 \f
54
55 static int serial_current_type = 0;
56
57 /* Log char CH of type CHTYPE, with TIMEOUT.  */
58
59 /* Define bogus char to represent a BREAK.  Should be careful to choose a value
60    that can't be confused with a normal char, or an error code.  */
61 #define SERIAL_BREAK 1235
62
63 static void
64 serial_logchar (struct ui_file *stream, int ch_type, int ch, int timeout)
65 {
66   if (ch_type != serial_current_type)
67     {
68       fprintf_unfiltered (stream, "\n%c ", ch_type);
69       serial_current_type = ch_type;
70     }
71
72   if (serial_logbase != logbase_ascii)
73     fputc_unfiltered (' ', stream);
74
75   switch (ch)
76     {
77     case SERIAL_TIMEOUT:
78       fprintf_unfiltered (stream, "<Timeout: %d seconds>", timeout);
79       return;
80     case SERIAL_ERROR:
81       fprintf_unfiltered (stream, "<Error: %s>", safe_strerror (errno));
82       return;
83     case SERIAL_EOF:
84       fputs_unfiltered ("<Eof>", stream);
85       return;
86     case SERIAL_BREAK:
87       fputs_unfiltered ("<Break>", stream);
88       return;
89     default:
90       if (serial_logbase == logbase_hex)
91         fprintf_unfiltered (stream, "%02x", ch & 0xff);
92       else if (serial_logbase == logbase_octal)
93         fprintf_unfiltered (stream, "%03o", ch & 0xff);
94       else
95         switch (ch)
96           {
97           case '\\':
98             fputs_unfiltered ("\\\\", stream);
99             break;
100           case '\b':
101             fputs_unfiltered ("\\b", stream);
102             break;
103           case '\f':
104             fputs_unfiltered ("\\f", stream);
105             break;
106           case '\n':
107             fputs_unfiltered ("\\n", stream);
108             break;
109           case '\r':
110             fputs_unfiltered ("\\r", stream);
111             break;
112           case '\t':
113             fputs_unfiltered ("\\t", stream);
114             break;
115           case '\v':
116             fputs_unfiltered ("\\v", stream);
117             break;
118           default:
119             fprintf_unfiltered (stream,
120                                 isprint (ch) ? "%c" : "\\x%02x", ch & 0xFF);
121             break;
122           }
123     }
124 }
125
126 void
127 serial_log_command (struct target_ops *self, const char *cmd)
128 {
129   if (!serial_logfp)
130     return;
131
132   serial_current_type = 'c';
133
134   fputs_unfiltered ("\nc ", serial_logfp);
135   fputs_unfiltered (cmd, serial_logfp);
136
137   /* Make sure that the log file is as up-to-date as possible,
138      in case we are getting ready to dump core or something.  */
139   gdb_flush (serial_logfp);
140 }
141
142 \f
143 static const struct serial_ops *
144 serial_interface_lookup (const char *name)
145 {
146   for (const serial_ops *ops : serial_ops_list)
147     if (strcmp (name, ops->name) == 0)
148       return ops;
149
150   return NULL;
151 }
152
153 void
154 serial_add_interface (const struct serial_ops *optable)
155 {
156   serial_ops_list.push_back (optable);
157 }
158
159 /* Return the open serial device for FD, if found, or NULL if FD is
160    not already opened.  */
161
162 struct serial *
163 serial_for_fd (int fd)
164 {
165   struct serial *scb;
166
167   for (scb = scb_base; scb; scb = scb->next)
168     if (scb->fd == fd)
169       return scb;
170
171   return NULL;
172 }
173
174 /* Create a new serial for OPS.  */
175
176 static struct serial *
177 new_serial (const struct serial_ops *ops)
178 {
179   struct serial *scb;
180
181   scb = XCNEW (struct serial);
182
183   scb->ops = ops;
184
185   scb->bufp = scb->buf;
186   scb->error_fd = -1;
187   scb->refcnt = 1;
188
189   return scb;
190 }
191
192 static struct serial *serial_open_ops_1 (const struct serial_ops *ops,
193                                          const char *open_name);
194
195 /* Open up a device or a network socket, depending upon the syntax of NAME.  */
196
197 struct serial *
198 serial_open (const char *name)
199 {
200   const struct serial_ops *ops;
201   const char *open_name = name;
202
203   if (startswith (name, "|"))
204     {
205       ops = serial_interface_lookup ("pipe");
206       /* Discard ``|'' and any space before the command itself.  */
207       ++open_name;
208       open_name = skip_spaces (open_name);
209     }
210   /* Check for a colon, suggesting an IP address/port pair.
211      Do this *after* checking for all the interesting prefixes.  We
212      don't want to constrain the syntax of what can follow them.  */
213   else if (strchr (name, ':'))
214     ops = serial_interface_lookup ("tcp");
215   else
216     {
217 #ifndef USE_WIN32API
218       /* Check to see if name is a socket.  If it is, then treat it
219          as such.  Otherwise assume that it's a character device.  */
220       struct stat sb;
221       if (stat (name, &sb) == 0 && (sb.st_mode & S_IFMT) == S_IFSOCK)
222         ops = serial_interface_lookup ("local");
223       else
224 #endif
225         ops = serial_interface_lookup ("hardwire");
226     }
227
228   if (!ops)
229     return NULL;
230
231   return serial_open_ops_1 (ops, open_name);
232 }
233
234 /* Open up a serial for OPS, passing OPEN_NAME to the open method.  */
235
236 static struct serial *
237 serial_open_ops_1 (const struct serial_ops *ops, const char *open_name)
238 {
239   struct serial *scb;
240
241   scb = new_serial (ops);
242
243   /* `...->open (...)' would get expanded by the open(2) syscall macro.  */
244   if ((*scb->ops->open) (scb, open_name))
245     {
246       xfree (scb);
247       return NULL;
248     }
249
250   scb->next = scb_base;
251   scb_base = scb;
252
253   if (serial_logfile != NULL)
254     {
255       stdio_file_up file (new stdio_file ());
256
257       if (!file->open (serial_logfile, "w"))
258         perror_with_name (serial_logfile);
259
260       serial_logfp = file.release ();
261     }
262
263   return scb;
264 }
265
266 /* See serial.h.  */
267
268 struct serial *
269 serial_open_ops (const struct serial_ops *ops)
270 {
271   return serial_open_ops_1 (ops, NULL);
272 }
273
274 /* Open a new serial stream using a file handle, using serial
275    interface ops OPS.  */
276
277 static struct serial *
278 serial_fdopen_ops (const int fd, const struct serial_ops *ops)
279 {
280   struct serial *scb;
281
282   if (!ops)
283     {
284       ops = serial_interface_lookup ("terminal");
285       if (!ops)
286         ops = serial_interface_lookup ("hardwire");
287     }
288
289   if (!ops)
290     return NULL;
291
292   scb = new_serial (ops);
293
294   scb->next = scb_base;
295   scb_base = scb;
296
297   if ((ops->fdopen) != NULL)
298     (*ops->fdopen) (scb, fd);
299   else
300     scb->fd = fd;
301
302   return scb;
303 }
304
305 struct serial *
306 serial_fdopen (const int fd)
307 {
308   return serial_fdopen_ops (fd, NULL);
309 }
310
311 static void
312 do_serial_close (struct serial *scb, int really_close)
313 {
314   struct serial *tmp_scb;
315
316   if (serial_logfp)
317     {
318       fputs_unfiltered ("\nEnd of log\n", serial_logfp);
319       serial_current_type = 0;
320
321       /* XXX - What if serial_logfp == gdb_stdout or gdb_stderr?  */
322       delete serial_logfp;
323       serial_logfp = NULL;
324     }
325
326   /* ensure that the FD has been taken out of async mode.  */
327   if (scb->async_handler != NULL)
328     serial_async (scb, NULL, NULL);
329
330   if (really_close)
331     scb->ops->close (scb);
332
333   /* For serial_is_open.  */
334   scb->bufp = NULL;
335
336   if (scb_base == scb)
337     scb_base = scb_base->next;
338   else
339     for (tmp_scb = scb_base; tmp_scb; tmp_scb = tmp_scb->next)
340       {
341         if (tmp_scb->next != scb)
342           continue;
343
344         tmp_scb->next = tmp_scb->next->next;
345         break;
346       }
347
348   serial_unref (scb);
349 }
350
351 void
352 serial_close (struct serial *scb)
353 {
354   do_serial_close (scb, 1);
355 }
356
357 void
358 serial_un_fdopen (struct serial *scb)
359 {
360   do_serial_close (scb, 0);
361 }
362
363 int
364 serial_is_open (struct serial *scb)
365 {
366   return scb->bufp != NULL;
367 }
368
369 void
370 serial_ref (struct serial *scb)
371 {
372   scb->refcnt++;
373 }
374
375 void
376 serial_unref (struct serial *scb)
377 {
378   --scb->refcnt;
379   if (scb->refcnt == 0)
380     xfree (scb);
381 }
382
383 int
384 serial_readchar (struct serial *scb, int timeout)
385 {
386   int ch;
387
388   /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
389      code is finished.  */
390   if (0 && serial_is_async_p (scb) && timeout < 0)
391     internal_error (__FILE__, __LINE__,
392                     _("serial_readchar: blocking read in async mode"));
393
394   ch = scb->ops->readchar (scb, timeout);
395   if (serial_logfp != NULL)
396     {
397       serial_logchar (serial_logfp, 'r', ch, timeout);
398
399       /* Make sure that the log file is as up-to-date as possible,
400          in case we are getting ready to dump core or something.  */
401       gdb_flush (serial_logfp);
402     }
403   if (serial_debug_p (scb))
404     {
405       fprintf_unfiltered (gdb_stdlog, "[");
406       serial_logchar (gdb_stdlog, 'r', ch, timeout);
407       fprintf_unfiltered (gdb_stdlog, "]");
408       gdb_flush (gdb_stdlog);
409     }
410
411   return (ch);
412 }
413
414 int
415 serial_write (struct serial *scb, const void *buf, size_t count)
416 {
417   if (serial_logfp != NULL)
418     {
419       const char *str = (const char *) buf;
420       size_t c;
421
422       for (c = 0; c < count; c++)
423         serial_logchar (serial_logfp, 'w', str[c] & 0xff, 0);
424
425       /* Make sure that the log file is as up-to-date as possible,
426          in case we are getting ready to dump core or something.  */
427       gdb_flush (serial_logfp);
428     }
429   if (serial_debug_p (scb))
430     {
431       const char *str = (const char *) buf;
432       size_t c;
433
434       for (c = 0; c < count; c++)
435         {
436           fprintf_unfiltered (gdb_stdlog, "[");
437           serial_logchar (gdb_stdlog, 'w', str[c] & 0xff, 0);
438           fprintf_unfiltered (gdb_stdlog, "]");
439         }
440       gdb_flush (gdb_stdlog);
441     }
442
443   return (scb->ops->write (scb, buf, count));
444 }
445
446 void
447 serial_printf (struct serial *desc, const char *format, ...)
448 {
449   va_list args;
450   va_start (args, format);
451
452   std::string buf = string_vprintf (format, args);
453   serial_write (desc, buf.c_str (), buf.length ());
454
455   va_end (args);
456 }
457
458 int
459 serial_drain_output (struct serial *scb)
460 {
461   return scb->ops->drain_output (scb);
462 }
463
464 int
465 serial_flush_output (struct serial *scb)
466 {
467   return scb->ops->flush_output (scb);
468 }
469
470 int
471 serial_flush_input (struct serial *scb)
472 {
473   return scb->ops->flush_input (scb);
474 }
475
476 int
477 serial_send_break (struct serial *scb)
478 {
479   if (serial_logfp != NULL)
480     serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
481
482   return (scb->ops->send_break (scb));
483 }
484
485 void
486 serial_raw (struct serial *scb)
487 {
488   scb->ops->go_raw (scb);
489 }
490
491 serial_ttystate
492 serial_get_tty_state (struct serial *scb)
493 {
494   return scb->ops->get_tty_state (scb);
495 }
496
497 serial_ttystate
498 serial_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
499 {
500   return scb->ops->copy_tty_state (scb, ttystate);
501 }
502
503 int
504 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
505 {
506   return scb->ops->set_tty_state (scb, ttystate);
507 }
508
509 void
510 serial_print_tty_state (struct serial *scb,
511                         serial_ttystate ttystate,
512                         struct ui_file *stream)
513 {
514   scb->ops->print_tty_state (scb, ttystate, stream);
515 }
516
517 int
518 serial_setbaudrate (struct serial *scb, int rate)
519 {
520   return scb->ops->setbaudrate (scb, rate);
521 }
522
523 int
524 serial_setstopbits (struct serial *scb, int num)
525 {
526   return scb->ops->setstopbits (scb, num);
527 }
528
529 /* See serial.h.  */
530
531 int
532 serial_setparity (struct serial *scb, int parity)
533 {
534   return scb->ops->setparity (scb, parity);
535 }
536
537 int
538 serial_can_async_p (struct serial *scb)
539 {
540   return (scb->ops->async != NULL);
541 }
542
543 int
544 serial_is_async_p (struct serial *scb)
545 {
546   return (scb->ops->async != NULL) && (scb->async_handler != NULL);
547 }
548
549 void
550 serial_async (struct serial *scb,
551               serial_event_ftype *handler,
552               void *context)
553 {
554   int changed = ((scb->async_handler == NULL) != (handler == NULL));
555
556   scb->async_handler = handler;
557   scb->async_context = context;
558   /* Only change mode if there is a need.  */
559   if (changed)
560     scb->ops->async (scb, handler != NULL);
561 }
562
563 void
564 serial_debug (struct serial *scb, int debug_p)
565 {
566   scb->debug_p = debug_p;
567 }
568
569 int
570 serial_debug_p (struct serial *scb)
571 {
572   return scb->debug_p || global_serial_debug_p;
573 }
574
575 #ifdef USE_WIN32API
576 void
577 serial_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
578 {
579   if (scb->ops->wait_handle)
580     scb->ops->wait_handle (scb, read, except);
581   else
582     {
583       *read = (HANDLE) _get_osfhandle (scb->fd);
584       *except = NULL;
585     }
586 }
587
588 void
589 serial_done_wait_handle (struct serial *scb)
590 {
591   if (scb->ops->done_wait_handle)
592     scb->ops->done_wait_handle (scb);
593 }
594 #endif
595
596 int
597 serial_pipe (struct serial *scbs[2])
598 {
599   const struct serial_ops *ops;
600   int fildes[2];
601
602   ops = serial_interface_lookup ("pipe");
603   if (!ops)
604     {
605       errno = ENOSYS;
606       return -1;
607     }
608
609   if (gdb_pipe (fildes) == -1)
610     return -1;
611
612   scbs[0] = serial_fdopen_ops (fildes[0], ops);
613   scbs[1] = serial_fdopen_ops (fildes[1], ops);
614   return 0;
615 }
616
617 /* Serial set/show framework.  */
618
619 static struct cmd_list_element *serial_set_cmdlist;
620 static struct cmd_list_element *serial_show_cmdlist;
621
622 static void
623 serial_set_cmd (const char *args, int from_tty)
624 {
625   printf_unfiltered ("\"set serial\" must be followed "
626                      "by the name of a command.\n");
627   help_list (serial_set_cmdlist, "set serial ", all_commands, gdb_stdout);
628 }
629
630 static void
631 serial_show_cmd (const char *args, int from_tty)
632 {
633   cmd_show_list (serial_show_cmdlist, from_tty, "");
634 }
635
636 /* Baud rate specified for talking to serial target systems.  Default
637    is left as -1, so targets can choose their own defaults.  */
638 /* FIXME: This means that "show serial baud" and gr_files_info can
639    print -1 or (unsigned int)-1.  This is a Bad User Interface.  */
640
641 int baud_rate = -1;
642
643 static void
644 serial_baud_show_cmd (struct ui_file *file, int from_tty,
645                       struct cmd_list_element *c, const char *value)
646 {
647   fprintf_filtered (file, _("Baud rate for remote serial I/O is %s.\n"),
648                     value);
649 }
650
651 /* Parity for serial port.  */
652
653 int serial_parity = GDBPARITY_NONE;
654
655 static const char parity_none[] = "none";
656 static const char parity_odd[] = "odd";
657 static const char parity_even[] = "even";
658 static const char *const parity_enums[] =
659   {parity_none, parity_odd, parity_even,  NULL};
660 static const char *parity = parity_none;
661
662 /* Set serial_parity value.  */
663
664 static void
665 set_parity (const char *ignore_args, int from_tty, struct cmd_list_element *c)
666 {
667   if (parity == parity_odd)
668     serial_parity = GDBPARITY_ODD;
669   else if (parity == parity_even)
670     serial_parity = GDBPARITY_EVEN;
671   else
672     serial_parity = GDBPARITY_NONE;
673 }
674
675 void
676 _initialize_serial (void)
677 {
678 #if 0
679   add_com ("connect", class_obscure, connect_command, _("\
680 Connect the terminal directly up to the command monitor.\n\
681 Use <CR>~. or <CR>~^D to break out."));
682 #endif /* 0 */
683
684   add_prefix_cmd ("serial", class_maintenance, serial_set_cmd, _("\
685 Set default serial/parallel port configuration."),
686                   &serial_set_cmdlist, "set serial ",
687                   0/*allow-unknown*/,
688                   &setlist);
689
690   add_prefix_cmd ("serial", class_maintenance, serial_show_cmd, _("\
691 Show default serial/parallel port configuration."),
692                   &serial_show_cmdlist, "show serial ",
693                   0/*allow-unknown*/,
694                   &showlist);
695
696   /* If target is open when baud changes, it doesn't take effect until
697      the next open (I think, not sure).  */
698   add_setshow_zinteger_cmd ("baud", no_class, &baud_rate, _("\
699 Set baud rate for remote serial I/O."), _("\
700 Show baud rate for remote serial I/O."), _("\
701 This value is used to set the speed of the serial port when debugging\n\
702 using remote targets."),
703                             NULL,
704                             serial_baud_show_cmd,
705                             &serial_set_cmdlist, &serial_show_cmdlist);
706
707   add_setshow_enum_cmd ("parity", no_class, parity_enums,
708                         &parity, _("\
709 Set parity for remote serial I/O."), _("\
710 Show parity for remote serial I/O."), NULL,
711                         set_parity,
712                         NULL, /* FIXME: i18n: */
713                         &serial_set_cmdlist, &serial_show_cmdlist);
714
715   add_setshow_filename_cmd ("remotelogfile", no_class, &serial_logfile, _("\
716 Set filename for remote session recording."), _("\
717 Show filename for remote session recording."), _("\
718 This file is used to record the remote session for future playback\n\
719 by gdbserver."),
720                             NULL,
721                             NULL, /* FIXME: i18n: */
722                             &setlist, &showlist);
723
724   add_setshow_enum_cmd ("remotelogbase", no_class, logbase_enums,
725                         &serial_logbase, _("\
726 Set numerical base for remote session logging."), _("\
727 Show numerical base for remote session logging."), NULL,
728                         NULL,
729                         NULL, /* FIXME: i18n: */
730                         &setlist, &showlist);
731
732   add_setshow_zuinteger_cmd ("serial", class_maintenance,
733                              &global_serial_debug_p, _("\
734 Set serial debugging."), _("\
735 Show serial debugging."), _("\
736 When non-zero, serial port debugging is enabled."),
737                              NULL,
738                              NULL, /* FIXME: i18n: */
739                              &setdebuglist, &showdebuglist);
740 }