diff options
Diffstat (limited to 'lib/vty_io.h')
| -rw-r--r-- | lib/vty_io.h | 613 |
1 files changed, 422 insertions, 191 deletions
diff --git a/lib/vty_io.h b/lib/vty_io.h index 19689853..59ffb808 100644 --- a/lib/vty_io.h +++ b/lib/vty_io.h @@ -25,286 +25,517 @@ #ifndef _ZEBRA_VTY_IO_H #define _ZEBRA_VTY_IO_H -#include <stdbool.h> -#include <errno.h> +//#include "zebra.h" +#include "misc.h" +//#include <errno.h> -#include "uty.h" -#include "vty.h" +#include "vty_local.h" +#include "command_local.h" +#include "vty_io_basic.h" #include "vio_fifo.h" -#include "vio_lines.h" -#include "keystroke.h" #include "thread.h" -#include "command.h" +#include "command_execute.h" #include "qstring.h" +#include "list_util.h" /*============================================================================== - * Here are structures and other definitions which are shared by: + * Structures and other definitions for the top level VTY I/O. * - * vty.c -- the main vty handler - * vty_cli.c -- which handles the command line stuff - * vty_io.c -- .... - * - * The "struct vty" is used extensively across the Quagga daemons, where it - * has two functions relating to command handling as: - * - * 1) a "file handle" for output produced by commands - * - * 2) the holder of some context -- notably the current command "node" -- for - * command execution to use - * - * The bulk of "struct vty" is, therefore, private to vty.c and is factored - * out into the "struct vty_io". - * - * To reduce the size of vty.c, some groups of functions are separated into: - * - * vty_cli.c -- which looks after the keystroke by keystroke handling - * of the command line. + * There is one struct vty_io per VTY, which contains, inter alia, the vin + * and vout stacks. * + * The vin and vout stacks contain one or more struct vty_vf -- one per + * input and/or output associated with the VTY. */ -/*------------------------------------------------------------------------------ - * VTY sock structure - * - * Used for VTY_TERM and VTY_SHELL_SERV VTY types, which are attached to TCP - * and UNIX sockets, respectively. - * - * Also used for the associated listeners. - */ +enum +{ + VTY_WATCH_DOG_INTERVAL = 5, /* interval between barks */ -typedef int thread_action(struct thread *) ; + VTY_HALF_CLOSE_TIMEOUT = 120, /* timeout after half_close */ -union sock_action -{ - qps_action* qnexus ; - thread_action* thread ; - void* anon ; + VTY_TIMEOUT_DEFAULT = 600, /* terminal timeout value */ } ; -union timer_action +/*------------------------------------------------------------------------------ + * VTY VIN and OUT types + */ +enum vio_in_type /* Command input */ { - qtimer_action* qnexus ; - thread_action* thread ; - void* anon ; + VIN_NONE = 0, /* not a valid input type */ + + VIN_TERM, /* telnet terminal */ + VIN_VTYSH, /* vty_shell input */ + + VIN_FILE, /* ordinary file input */ + VIN_PIPE, /* pipe (from child process) */ + + VIN_CONFIG, /* config file */ + + VIN_PIPE_RETURN, /* */ + + /* The VIN types >= VIN_SPECIALS do not have an associated fd. + * + * These can coexist with a VOUT which does have an associated fd. + */ + VIN_SPECIALS, /* all special from now on */ + + VIN_DEV_NULL = VIN_SPECIALS, + /* black hole input */ } ; +typedef enum vio_in_type vio_in_type_t ; -struct vio_sock_actions +enum vio_out_type /* Command output */ { - union sock_action read ; - union sock_action write ; - union timer_action timer ; + VOUT_NONE = 0, /* not a valid output type */ + + VOUT_TERM, /* a telnet terminal */ + VOUT_VTYSH, /* a vty_shell output pipe */ + + VOUT_FILE, /* ordinary file */ + VOUT_PIPE, /* pipe (to child process, and back again) */ + + VOUT_CONFIG, /* config file */ + + /* The VOUT types >= VOUT_SPECIALS do not have an associated fd. + * + * These can coexist with a VIN which does have an associated fd. + */ + VOUT_SPECIALS, /* all special from now on */ + + VOUT_DEV_NULL = VOUT_SPECIALS, + /* black hole output */ + + VOUT_SHELL_ONLY, /* pipe (but only back from child process */ + + VOUT_STDOUT, /* stdout */ + VOUT_STDERR, /* stderr */ }; +typedef enum vio_out_type vio_out_type_t ; -typedef struct vio_sock* vio_sock ; -struct vio_sock +/*------------------------------------------------------------------------------ + * State of a vf -- has separate state for vin/vout. + */ +enum vf_state { - int fd ; + vf_closed = 0, /* the vf has not been opened, or has been + * completely closed -- there will be no vfd. */ - void* info ; /* for action routines */ + vf_open, /* the vf has been opened, and any required vfd + * is open and I/O is possible. */ - struct vio_sock_actions action ; + vf_eof, /* for a vin: end of file has been reached or + * input has been terminated. The vfd may have + * been closed -- but in any case no further + * I/O should be attempted, and any buffered + * input will be discarded. */ - bool read_open ; /* read returns 0 if not open */ - bool write_open ; /* write completes instantly if not open */ - int error_seen ; /* non-zero => failed */ + vf_closing, /* for a vout: open, but in process of closing. + * May still output stuff. */ - qps_file qf ; /* when running qnexus */ + vf_error, /* an I/O error has been reported. + * The vfd may or may not have been closed and + * I/O may or may not be possible TODO */ - struct thread *t_read; /* when running threads */ - struct thread *t_write; + vf_timed_out, /* a timout has been reported. + * The vfd may or may not have been closed and + * I/O may or may not be possible TODO */ +} ; +typedef enum vf_state vf_state_t ; - unsigned long v_timeout; /* time-out in seconds -- 0 => none */ - bool timer_running ; /* true when timer is running */ +/*------------------------------------------------------------------------------ + * vio_child structure. + * + * Lives on the vio_childer_list until collected or "curtains". + * + */ +typedef enum vio_child_await vio_child_await_t ; - qtimer qtr; /* when running qnexus */ - struct thread *t_timer; /* when running threads */ +struct vio_vf ; /* Forward reference */ +typedef struct vio_vf* vio_vf ; +typedef struct vio_child* vio_child ; + +struct vio_child +{ + struct dl_list_pair(vio_child) list ; /* in the list of children */ + + vio_vf parent ; + + pid_t pid ; + bool collected ; /* waitpid() done */ + int report ; /* from waitpid() */ + + bool overdue ; /* patience exhausted */ + + bool awaited ; /* if child is awaited -- !vf->blocking */ + vio_timer timer ; /* limit the waiting time */ } ; -enum +/*------------------------------------------------------------------------------ + * vty_vf -- "vty file" structure + * + * A vio_vf may be a read, write or read/write object. + * + * All I/O is via vio_vfd objects, except for VOUT_STDOUT and VOUT_STDERR. + * The vio_vfd layer hides the differences between the qpthreads an legacy + * thread environments. + * + * The VOUT_STDOUT and VOUT_STDERR are handled as direct output to the standard + * i/o file handles. In the case of a VTY_CONFIG_READ, the vin is VIN_CONFIG + * and the vout is VOUT_STDOUT, and these can share a single vty_vf. + * + * Also used for the associated listeners. + */ +struct vty_io ; /* Forward reference */ +typedef struct vty_io* vty_io ; + +struct vio_vf { - on = true, - off = false + vty_io vio ; /* parent */ + + char* name ; /* MTYPE_VTY_NAME (if any) */ + + /* Input side. */ + + vio_in_type_t vin_type ; + vf_state_t vin_state ; + vio_vf vin_next ; /* list of inputs */ + + cmd_context context ; /* pushed exec->context. */ + + struct vty_cli* cli ; /* NULL if not a VTY_TERMINAL ! */ + + vio_fifo ibuf ; /* input fifo (if required) */ + + qstring cl ; /* command line buffer */ + bool line_complete ; /* false => line in construction */ + uint line_number ; /* number of first line in cl */ + uint line_step ; /* number of real lines in cl */ + + /* Output side. */ + + vio_out_type_t vout_type ; + vf_state_t vout_state ; + vio_vf vout_next ; /* list of outputs */ + + vio_vf pr_master ; /* receiving return stuff from there */ + + vio_fifo obuf ; /* output fifo (if required) */ + + uint depth_mark ; /* depth of this vout */ + + /* I/O */ + + vio_vfd vfd ; /* vty_io_basic "file descriptor" */ + + bool blocking ; /* using blocking I/O (config read) */ + + int error_seen ; /* non-zero => failed */ + + vty_timer_time read_timeout ; + vty_timer_time write_timeout ; + + /* Pipe extras */ + + vio_child child ; /* state of child */ + + vf_state_t pr_state ; /* iff pipe */ + vio_vfd pr_vfd ; /* if pr_state == vf_open */ + + vio_vf pr_slave ; /* sending return stuff to there */ + + bool pr_only ; /* no vfd */ } ; -enum vty_readiness /* bit significant */ +enum vty_readiness /* bit significant */ { - not_ready = 0, - read_ready = 1, - write_ready = 2, /* takes precedence */ - now_ready = 4 + not_ready = 0, + read_ready = BIT(0), + write_ready = BIT(1), /* may take precedence */ } ; +typedef enum vty_readiness vty_readiness_t ; /*------------------------------------------------------------------------------ - * The vty_io structure + * State of a vty command loop. */ +enum vc_state +{ + vc_null = 0, /* the command loop has not yet been entered. */ -struct vty_io { - struct vty* vty ; /* the related vty */ - char *name ; /* for VTY_TERM is IP address) */ + vc_running, /* the command loop is running, and the vty is + * in its hands. */ - /* List of all vty_io objects */ - struct dl_list_pair(vty_io) vio_list ; + vc_io_error_trap, /* the command loop is running, but an I/O + * error has been posted. */ - /* List of all vty_io that are in monitor state */ - struct dl_list_pair(vty_io) mon_list ; + vc_close_trap, /* the command loop is running, but the vty is + * reset and must be closed */ + + vc_waiting, /* the command loop is waiting for I/O. */ - /* VTY type and sock stuff */ - enum vty_type type; + vc_stopped, /* the command loop has stopped, the vty is due + to be closed (loop cannot run again) */ - struct vio_sock sock ; /* for VTY_TERM and VTY_SHELL_SERV */ + vc_closed, /* the command loop has finished and the vty + * has been closed. */ +} ; +typedef enum vc_state vc_state_t ; + +/*------------------------------------------------------------------------------ + * The vty_io structure + * + * The main elements of the vty_io object are the vin and vout stacks. + * + * One of the challenges is managing the closing of VTY objects. First, + * cannot close and free a VTY object which is in the hands of a command + * function, or which is queued to or from a command function. Second, + * do not wish to completely close an output until have given it a chance + * to clear any buffered output. + * + * + * + * "cmd_running" means that the VTY is in hands of (or has been passed to) TODO + * a command loop -- the VTY cannot be fully closed until that is no + * longer the case. + * + * "blocking" is set for configuration reading VTY, so that everything is + * done with blocking I/O. + * + * "closing" means that the vty has been closed (!), but a command + * and or output may still be active: + * + * - if is a socket, will have shut_down the read side (half-closed) + * + * - any further attempts to read will give "eof" + * + * - there may be a command in execution -- see "cmd_running". TODO + * + * - further writing will be honoured. + * + * - the write side may still be active, attempting to empty out any + * pending output. + * + * "closed" means the vty has been fully and finally closed. + * + * - any further attempts to write will be ignored, but return instant + * success. + * + * - the file/socket has been fully closed. + * + * - the VTY and all attached structures can be reaped by the death_watch. + */ +struct vty_cli ; /* forward reference -- vty_cli.h is + *not* included, because that refers + back to the vty_io ! */ - bool half_closed ; /* => on death watch list */ - bool closed ; /* => all I/O terminated - will also be half_closed */ +struct vty_io /* typedef appears above */ +{ + vty vty ; /* the related vty */ - const char* close_reason ; /* message to be sent, once all other - output has completed, giving reason - for closing the VTY. */ + vio_vf vin ; /* vin stack */ + vio_vf vin_base ; + uint vin_depth ; - /* When writing configuration file */ - enum vty_type real_type ; + uint real_depth ; /* less than vin_depth when closing */ - int file_fd ; - int file_error ; + vio_vf vout ; /* vout stack */ + vio_vf vout_base ; + uint vout_depth ; - /*--------------------------------------------------------------------*/ - /* Command line and related state */ + /* Error handling */ + bool err_hard ; /* eg I/O error */ + vio_fifo ebuf ; /* buffer for error message */ - keystroke_stream key_stream ; + /* List of all vty_io objects */ + struct dl_list_pair(vty_io) vio_list ; - /* cli_drawn <=> the current prompt and user input occupy the current - * line on the screen. - * - * cli_dirty <=> the last command output did not end with a newline. + /* State * - * If cli_drawn is true, the following are valid: + * "blocking" is set for configuration reading VTY, so that everything is + * done with blocking I/O. * - * cli_prompt_len -- the length of the prompt part. - * (will be the "--more--" prompt in cli_more_wait) - * - * cli_extra_len -- the length of any ^X at the cursor position - * (for when blocked waiting for queued command) - * - * cli_echo_suppress -- the user part of the command line is suppressed - * - * NB: cli_echo_suppress is only used for password entry. + * "state" as described above. */ - bool cli_drawn ; - bool cli_dirty ; + bool blocking ; /* => all I/O is blocking. */ - int cli_prompt_len ; - int cli_extra_len ; + vc_state_t state ; - bool cli_echo_suppress ; + char* close_reason ; /* MTYPE_TMP (if any) */ - /* "cache" for prompt -- when node or host name changes, prompt does */ - enum node_type cli_prompt_node ; - bool cli_prompt_set ; - qstring_t cli_prompt_for_node ; - - /* State of the CLI + /* For ease of output, pointer to current vout->obuf * - * cli_blocked -- blocked from processing keystrokes - * cmd_in_progress -- command dispatched (may be queued) - * cmd_out_enabled -- contents of the command FIFO may be written away - * cli_more_wait -- is in "--more--" wait state - */ - bool cli_blocked ; - bool cmd_in_progress ; - bool cmd_out_enabled ; - bool cli_more_wait ; - - /* This is used to control command output, so that each write_ready event - * generates at most one tranche of output. + * Even when the vty is almost closed, there will remain a valid obuf, + * though anything sent to it under those conditions will be discarded. */ - bool cmd_out_done ; - - /* This is set only if the "--more--" handling is enabled */ - bool cli_more_enabled ; + vio_fifo obuf ; - /* Command Line(s) - * - * cli_do -- when current command being prepared is completed (by - * CR/LF or otherwise) this says what there now is to be done. - * - * cl -- current command line being prepared. - * - * clx -- current command line being executed. + /* The following is for "vty monitor". * - * NB: during command execution vty->buf is set to point at the '\0' - * terminated current command line being executed. + * With the exception of the "monitor" flag, need the LOG_MUTEX in order + * to change any of this. */ - enum cli_do cli_do ; + bool monitor ; /* is in monitor state */ - qstring_t cl ; - qstring_t clx ; + bool mon_kick ; /* vty needs a kick */ + int maxlvl ; /* message level wish to see */ - /* CLI output buffering */ - vio_fifo_t cli_obuf ; + vio_fifo mbuf ; /* monitor output pending */ - /* Command output buffering */ - vio_fifo_t cmd_obuf ; - - vio_line_control cmd_lc ; - - /* Failure count for login attempts */ - int fail; - - /* History of commands */ - vector_t hist ; - int hp ; /* History lookup current point */ - int hindex; /* History insert end point */ + /* List of all vty_io that are in monitor state */ + struct dl_list_pair(vty_io) mon_list ; +} ; - /* Window width/height as reported by Telnet. 0 => unknown */ - int width; - int height; +/*============================================================================== + * Assertions for suitable state to close things ! + */ +Inline void +VTY_ASSERT_CAN_CLOSE(vty vty) +{ + if (vty_debug) + { + VTY_ASSERT_LOCKED() ; - /* Configure lines. */ - int lines; - bool lines_set ; /* true <=> explicitly set */ + if (!vty->vio->blocking && !vty_is_cli_thread()) + VTY_ASSERT_FAILED() ; + } ; +} ; - /* Terminal monitor. */ - bool monitor ; - bool monitor_busy ; +Inline void +VTY_ASSERT_CAN_CLOSE_VF(vio_vf vf) +{ + if (vty_debug) + { + VTY_ASSERT_LOCKED() ; - /* In configure mode. */ - bool config; + if (!vf->blocking && !vty_is_cli_thread()) + VTY_ASSERT_FAILED() ; + } ; } ; /*============================================================================== * Functions */ -extern struct vty* uty_new (enum vty_type type, int sock_fd) ; +extern int uty_out (vty_io vio, const char* format, ...) PRINTF_ATTRIBUTE(2, 3); +Inline int uty_vprintf(vty_io vio, const char *format, va_list args) ; + +Inline void uty_out_clear(vty_io vio) ; +Inline void uty_out_accept(vty_io vio) ; +Inline void uty_out_reject(vty_io vio) ; + +extern vty uty_new (vty_type_t type, node_type_t node) ; +extern void uty_close(vty_io vio, const char* reason, bool curtains) ; + +extern void uty_set_timeout(vty_io vio, vty_timer_time timeout) ; + +extern void uty_vin_new_context(vty_io vio, cmd_context context, + qpath file_here) ; +extern void uty_vin_push(vty_io vio, vio_vf vf, vio_in_type_t type, + vio_vfd_action* read_action, + vio_timer_action* read_timer_action, + usize ibuf_size) ; +extern void uty_vout_push(vty_io vio, vio_vf vf, vio_out_type_t type, + vio_vfd_action* write_action, + vio_timer_action* write_timer_action, + usize obuf_size) ; +extern void uty_vout_sync_depth(vty_io vio) ; +extern cmd_return_code_t uty_vin_pop(vty_io vio, bool final, + cmd_context context) ; +extern cmd_return_code_t uty_vout_pop(vty_io vio, bool final) ; + + +extern vio_vf uty_vf_new(vty_io vio, const char* name, int fd, vfd_type_t type, + vfd_io_type_t io_type) ; +extern void uty_vf_set_read(vio_vf vf, on_off_b on) ; +extern void uty_vf_set_read_timeout(vio_vf vf, vty_timer_time read_timeout) ; +extern void uty_vf_set_write(vio_vf vf, on_off_b on) ; +extern void uty_vf_set_write_timeout(vio_vf vf, vty_timer_time write_timeout) ; +extern int uty_vf_error(vio_vf vf, const char* what, int err) ; + +extern vio_child uty_child_register(pid_t pid, vio_vf parent) ; +extern void vty_child_close_register(void) ; +extern void uty_child_awaited(vio_child child, vty_timer_time timeout) ; +extern bool uty_child_collect(vio_child child, vty_timer_time timeout, + bool final) ; +extern vio_child uty_child_dismiss(vio_child child, bool final) ; +extern void uty_sigchld(void) ; + +extern void uty_child_signal_nexus_set(vty_io vio) ; +extern void vty_child_signal_nexus_signal(void) ; +extern void uty_child_signal_nexus_clear(vty_io vio) ; + extern void uty_open_listeners(const char *addr, unsigned short port, const char *path) ; +extern void uty_add_listener(int fd, vio_vfd_accept* accept) ; extern void uty_close_listeners(void) ; +extern void uty_watch_dog_init(void) ; extern void uty_watch_dog_start(void) ; extern void uty_watch_dog_stop(void) ; -extern void uty_half_close (vty_io vio, const char* reason) ; -extern void uty_close (vty_io vio) ; +extern const char* uty_get_name(vty_io vio) ; -extern int uty_out (struct vty *vty, const char *format, ...) - PRINTF_ATTRIBUTE(2, 3) ; -extern int uty_vout(struct vty *vty, const char *format, va_list args) ; -extern void uty_out_clear(vty_io vio) ; -extern void uty_out_fflush(vty_io vio, FILE* file) ; +extern void uty_set_monitor(vty_io vio, bool on) ; -extern void uty_set_height(vty_io vio) ; -extern void uty_cmd_output_start(vty_io vio) ; +/*============================================================================== + * Inline Functions + */ -extern void uty_sock_set_readiness(vio_sock sock, enum vty_readiness ready) ; -extern void uty_sock_set_timer(vio_sock sock, unsigned long timeout) ; +Inline bool +uty_is_terminal(struct vty *vty) +{ + return vty->type == VTY_TERMINAL ; +} -extern int uty_read (vty_io vio, keystroke steal) ; -extern int utysh_read (vty_io vio, qstring cl, qstring buf) ; +Inline bool +uty_is_shell_server(struct vty *vty) +{ + return vty->type == VTY_SHELL_SERVER ; +} +Inline bool +uty_is_shell_client(struct vty *vty) +{ + return vty->type == VTY_SHELL_CLIENT ; +} -extern const char* uty_get_name(vty_io vio) ; +/*------------------------------------------------------------------------------ + * Command output -- append to output buffer. + */ +Inline int +uty_vprintf(vty_io vio, const char *format, va_list args) +{ + return vio_fifo_vprintf(vio->obuf, format, args) ; +} ; -extern void uty_set_monitor(vty_io vio, bool on) ; +/*------------------------------------------------------------------------------ + * Clear command output -- discard anything in the buffer, but keep markers. + */ +Inline void +uty_out_clear(vty_io vio) +{ + vio_fifo_clear(vio->obuf, false) ; +} ; + +/*------------------------------------------------------------------------------ + * Accept command output -- advance any end_mark to current put position. + */ +Inline void +uty_out_accept(vty_io vio) +{ + vio_fifo_step_end_mark(vio->obuf) ; +} ; + +/*------------------------------------------------------------------------------ + * Reject command output -- discard anything after the end_mark in the buffer, + * but keep markers. + */ +Inline void +uty_out_reject(vty_io vio) +{ + vio_fifo_back_to_end_mark(vio->obuf, true) ; +} ; #endif /* _ZEBRA_VTY_IO_H */ |