falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/include/SPC/spcP.h

565 lines
21 KiB
C
Raw Permalink Blame History

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these libraries and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/*
* $XConsortium: spcP.h /main/4 1996/05/15 12:01:55 drk $
* Language: C
*
* (c) Copyright 1996 Digital Equipment Corporation.
* (c) Copyright 1988,1993,1994,1996 Hewlett-Packard Company.
* (c) Copyright 1993,1994,1996 International Business Machines Corp.
* (c) Copyright 1993,1994,1996 Sun Microsystems, Inc.
* (c) Copyright 1993,1994,1996 Novell, Inc.
* (c) Copyright 1996 FUJITSU LIMITED.
* (c) Copyright 1996 Hitachi.
*/
#ifndef _spcP_h
#define _spcP_h
#include <netdb.h> /* hostent */
#include <termios.h>
#include <bms/bms.h>
#include <bms/Symbolic.h>
#include <bms/XeUserMsg.h>
#include <bms/SbEvent.h>
#include <bms/spc.h>
#include <bms/scoop.h>
#include <bms/connect.h>
#include <bms/MemoryMgr.h>
#include "chars.h"
#include "spcE.h"
#include "spc-obj.h"
/* ---------------------------------------------------------------------- */
#ifndef CDE_CONFIGURATION_TOP
#define CDE_CONFIGURATION_TOP "/etc/opt/dt"
#endif
#ifndef CDE_INSTALLATION_TOP
#define CDE_INSTALLATION_TOP "/usr/dt"
#endif
#define Stdin(chn) chn->file_descs[STDIN]
#define Stdout(chn) chn->file_descs[STDOUT]
#define Stderr(chn) chn->file_descs[STDERR]
/* Some necessary identifiers */
#define OK 0
#define ERROR -1
#define Undefined -1
/* Some character constants */
#define Channel_ByteID (XeChar)'\077'
/* And finally, the common channel identifier */
#ifndef BITSPERBYTE
#define BITSPERBYTE 8
#endif
#define CID_High_Bits (Channel_ByteID << (BITSPERBYTE * (sizeof(int) - 1)))
#define CID_Middle_Bits (0x1010 << BITSPERBYTE)
#define CID_Low_Bits (Channel_ByteID & 0xff)
#define Channel_Identifier (CID_High_Bits | CID_Middle_Bits | CID_Low_Bits)
/*** Note: If device names ever increase from: /dev/ptym/ptyp0, look here ***/
#define PTY_NAMLEN 20
#define EXCEPT_FLAG -1 /* Used for TIOC handling in PTY's */
/* Define lengths of buffers for protocol requests and other sizes of things */
#define REQUEST_HEADER_LENGTH 20
#define MAXREQLEN (SPC_BUFSIZ+REQUEST_HEADER_LENGTH)
#define DEFAULT_ENVP_SIZE 50
/*
**
** Definitions for select.
**
*/
extern int max_fds;
/*
* Macros to access SPC_IOMode bit fields
*/
/* These are derived from above spc bit specifications */
#define IS_SPCIO_STDIN(a) (a & SPCIO_WRITEONLY)
#define IS_SPCIO_STDOUT(a) (a & SPCIO_READONLY)
#define IS_SPCIO_STDERR(a) (a & SPCIO_ERRORONLY)
#define IS_SPCIO_SEPARATE(a) (a & SPCIO_SEPARATEREADERROR)
#define IS_SPCIO_NOIO(a) ((a & SPCIO_SOURCE_MASK) == SPCIO_NOIO)
#define IS_SPCIO_WRITEONLY(a) ((a & SPCIO_SOURCE_MASK) == SPCIO_WRITEONLY)
#define IS_SPCIO_READONLY(a) ((a & SPCIO_SOURCE_MASK) == SPCIO_READONLY)
#define IS_SPCIO_READWRITE(a) ((a & SPCIO_SOURCE_MASK) == SPCIO_READWRITE)
#define IS_SPCIO_ERRORONLY(a) ((a & SPCIO_SOURCE_MASK) == SPCIO_ERRORONLY)
#define IS_SPCIO_WRITEERROR(a) ((a & SPCIO_SOURCE_MASK) == SPCIO_WRITEERROR)
#define IS_SPCIO_READERROR(a) ((a & SPCIO_SOURCE_MASK) == SPCIO_READERROR)
#define IS_SPCIO_READWRITEERROR(a)((a&SPCIO_SOURCE_MASK) == SPCIO_READWRITEERROR)
/* Style flags (mutually exclusive) */
#define IS_SPCIO_PIPE(a) ((a & SPCIO_STYLE_MASK) == SPCIO_PIPE)
#define IS_SPCIO_PTY(a) ((a & SPCIO_STYLE_MASK) == SPCIO_PTY)
#define IS_SPCIO_NOIOMODE(a) ((a & SPCIO_STYLE_MASK) == SPCIO_NOIOMODE)
#define IS_SPCIO_LINEEDIT(a) (a & SPCIO_LINEEDIT)
/* Other non-mutually exclusive flags */
#define IS_SPCIO_SYSTEM(a) (a & SPCIO_SYSTEM)
#define IS_SPCIO_LINEORIENTED(a)(a & SPCIO_LINEORIENTED)
#define IS_SPCIO_WAIT(a) (a & SPCIO_WAIT)
#define IS_SPCIO_TOOLKIT(a) (a & SPCIO_USE_XTOOLKIT)
#define IS_SPCIO_SYNC_TERM(a) (a & SPCIO_SYNC_TERMINATOR)
#define IS_SPCIO_USE_LOGFILE(a) (a & SPCIO_USE_LOGFILE)
#define IS_SPCIO_SIGNAL_PGRP(a) (a & SPCIO_SIGNAL_PGRP)
#define IS_SPCIO_FORCE_CONTEXT(a) (a & SPCIO_FORCE_CONTEXT)
#define SPCIO_HAS_DATA 0x2000 /* Used for line-oriented IO */
#define HAS_DATA(chn) (((chn->IOMode) & SPCIO_HAS_DATA) == SPCIO_HAS_DATA)
#define SPCIO_UNUSED3 0x80000
/* Flags for internal use only */
#define SPCIO_DEALLOC_ARGV 0x4000
#define IS_SPCIO_DEALLOC_ARGV(a) (a & SPCIO_DEALLOC_ARGV)
#define SPCIO_DELAY_CLOSE 0x8000
#define IS_SPCIO_DELAY_CLOSE(a) (a & SPCIO_DELAY_CLOSE)
#define SPCIO_DO_CLOSE 0x10000
#define IS_SPCIO_DO_CLOSE(a) (a & SPCIO_DO_CLOSE)
/* Make sure that STATE_OFFSET is always such that you will clear the
IOMode flags */
#define STATE_OFFSET 24
#define SPCIO_ACTIVE (1<<STATE_OFFSET) /* channel has subprocess */
#define SPCIO_DATA (2<<STATE_OFFSET) /* channel has data */
#define IS_SPCIO_ACTIVE(a) (a & SPCIO_ACTIVE)
#define IS_SPCIO_DATA(a) (a & SPCIO_DATA)
#define IS_ACTIVE(chn) (IS_SPCIO_ACTIVE(chn->IOMode))
#define IS_DATA(chn) (IS_SPCIO_DATA(chn->IOMode))
#define IS_REMOTE(chn) (chn->connection)
/* SPC state machine */
#define CHANNEL_STATE(io_mode) ((io_mode)>>STATE_OFFSET & 0x3)
#define MAKE_CHANNEL_STATE(io_mode, _state) \
(((_state)<<STATE_OFFSET) | (io_mode & ~(0x3<<STATE_OFFSET)))
#define MAKE_STATE(_data,_proc) ((_data)<<1 | (_proc))
#define MAKE_STATE_INDEX(_old,_new) ((_old)<<2 | (_new))
#define DATA_LINE(_state) ((_state) >> 1)
#define PROC_LINE(_state) ((_state) & 1)
/* Defaults */
#define DEFAULT_CHANNEL_CLASS pty_channel_class
#define IS_SPCIO_DEFAULT(a) !((a) & SPCIO_STYLE_MASK)
#define SPCIO_DEFAULT SPCIO_PTY
/*
* Type definitions for SPC file descriptors
*/
/* Definitions for wires */
#define READ_SIDE 0
#define WRITE_SIDE 1
/*
* Constants and external declarations for managing the SPC daemon's
* logfile list, exit timer and process id list.
*/
#define SPCD_DEFAULT_TIMEOUT 10
#define SPCD_DEAD_PROCESS -1
#define SPCD_NO_TIMER -1
#define SPCD_REQUEST_PENDING 1
#define SPCD_NO_REQUEST_PENDING 0
/*
* Constants for the 'SPC_who_am_i' variable.
*/
#define SPC_I_AM_A_CLIENT 1
#define SPC_I_AM_A_DAEMON 2
/*
* External variables defined in noio.c
*/
extern char **SPC_logfile_list;
/*
* External variables defined in spc-exec.c
*/
extern pid_t *SPC_pid_list;
extern char *SPC_mount_point_env_var;
/*
* External variables defined in spc-obj.c
*/
extern int SPC_who_am_i;
/*
* The client version number.
*/
extern int SPC_client_version_number;
/*
* The name of the directory used for authentication and
* for temporary logfiles.
*/
extern XeString SPCD_Authentication_Dir;
/*
* Definitions for file locations
*/
#define SPCD_ENV_INSTALL_DIRECTORY CDE_INSTALLATION_TOP "/config"
#define SPCD_ENV_CONFIG_DIRECTORY CDE_CONFIGURATION_TOP "/config"
#define SPCD_ENV_HOME_DIRECTORY ".dt"
#define SPCD_ENV_FILE "dtspcdenv"
#define SPCD_PROG_NAME "dtspcd"
/*
* The name of the remove environment 'keyword'.
*/
#define SPC_REMOVE_VAR "unset"
/*
***
*** Start typedefs
***
*/
typedef int Files[3]; /* Standard set of file descriptors */
typedef int SPC_IOMode; /* Sub-Process Control IO Mode Bits */
/* This is a "wire", a data structure used in creating communication paths
to / from a subprocess. It encapsulates all the information needed by
all types of paths */
typedef struct _wire {
SPC_IOMode flags; /* Basically, acts like an IOMode, but
we are only interested in its data bits */
int fd[2];
XeString master_name, slave_name;
int read_toolkit_id, except_toolkit_id;
struct termios master_termio, slave_termio;
struct _wire *next;
} Wire;
typedef struct _buffered_data {
XeChar data[MAXREQLEN];
int len, offset;
} buffered_data, *buffered_data_ptr;
typedef enum {
SPC_Input,
SPC_Exception,
SPC_Terminator,
SPC_Client
} SPC_Callback_Condition;
/*
* Type definition for an SPC Connection (a socket to SPCD server)
*/
typedef struct _SPC_Connection {
/* The host on which other end resides */
XeChar hostname[MAXHOSTNAMELEN];
int sid; /* The Socket ID */
XeChar connected; /* Whether server connection is made */
struct hostent *local; /* socket address information for */
struct hostent *remote; /* ... local, remote machine */
int termination_id;
struct _SPC_Connection
*next; /* The next server in the list */
XeQueue queued_remote_data; /* queue for remote data */
int protocol_version; /* Version of protocol of remote */
XeString hostinfo; /* Info about remote, (type, os, etc) */
} SPC_Connection, *SPC_Connection_Ptr;
/*
* This next macro returns a newly allocated string.
* The caller should free it.
*/
#define CONNECTION_HOSTNAME(conn) \
((conn->remote) ? XeFindShortHost((conn)->remote->h_name) : \
Xestrdup(XeString_Empty))
/*
* Type definition for an SPC Channel
*/
typedef int (*SPC_F_read_filter)(SPC_Channel_Ptr, int, XeString, int);
typedef struct _SPC_Channel { /* Sub-Process Control Channel */
/* stuff for SCOOP */
channel_clasp class_ptr;
root_object_part
/* First, we place a channel identifier, so we can check cid (see below) */
int identifier; /* The common identifier for every channel */
/* The setup request information */
SPC_Connection *connection; /* The connection structure (Local = NULL) */
XeString context_dir; /* Directory to "cd" to during spawn */
XeString path; /* The command path pointer */
XeString *argv; /* The command argument list pointers */
XeString *envp; /* The command environment list pointers */
SPC_IOMode IOMode; /* The IO Control Mode settings */
/* User defined data handling procedures */
SbInputHandlerProc Input_Handler;
/* The user input handler routine */
void * client_data; /* The user associated input handler data */
/* Useful (ie.) as input Widget */
SPC_TerminateHandlerType Terminate_Handler; /* The SIGCLD user handler routine */
void * Terminate_Data; /* The client_data for user handler routine */
/* Now the recorded information */
int pid; /* The child Process IDentification number */
/* Also the RPID for a Remote channel */
int cid; /* The remote Channel IDentification number */
int status; /* The Process status */
Wire *wires[3]; /* The read side/write side file descriptors */
Files file_descs; /* Which file descriptors to use */
Wire *wire_list; /* Pointer to list of wires we have
(used for reset & pre_fork processing) */
buffered_data_ptr linebufs[3]; /* Buffers for lined oriented IO */
SPC_F_read_filter read_filter;
/* Function to use to read. It may
be the actual read method, or it
may be a filter for newlines
(which would eventually call the read
method) */
XeQueue queued_remote_data; /* queue for remote data */
XeString logfile; /* logfile name for SPCIO_USE_LOGFILE */
int close_timeout; /* Amount of time to wait for a pty close */
struct _SPC_Channel *next; /* The next active channel */
int sync_pipe[2]; /* Only used in pty.c for __hpux_pty */
} SPC_Channel;
/* The default shell when none can be derived */
#ifdef hpV4
#define DEFAULT_SHELL (XeString ) "/usr/bin/sh"
#else
#define DEFAULT_SHELL (XeString ) "/bin/sh"
#endif /* hpV4 */
/* Some macros which define the bit field portions of a wait() status */
/* NOTE: These should be independent of integer word size */
#define WAIT_STATUS_MASK 0xff
#define IS_WAIT_STATUS_STOPPED 0177
#define IS_WAIT_STATUS_EXITED 0000
#define IS_WAIT_STATUS_DUMPED 0200
typedef unsigned long SPCInputId;
/* SPC/local.c */
int close_local_channel_object (SPC_Channel_Ptr channel);
int write_local_channel_object (SPC_Channel_Ptr channel, XeString buffer, int nbytes);
int signal_local_channel_object (SPC_Channel_Ptr channel, int sig);
int local_channel_object_wait_for_termination (SPC_Channel_Ptr channel);
int remove_logfile_local_channel_object (SPC_Channel_Ptr channel);
void local_channel_object_input_handler (void * client_data, int *source, SPCInputId *id);
int local_channel_object_send_eof(SPC_Channel_Ptr channel);
/* noio.c */
void noio_channel_class_init (object_clasp c);
SPC_Channel_Ptr open_noio_channel_object (SPC_Channel_Ptr channel, int iomode, XeString hostname);
int read_noio_channel_object (SPC_Channel_Ptr channel, int connector, XeString buffer, int nbytes);
int write_noio_channel_object (SPC_Channel_Ptr channel, XeString buffer, int nbytes);
int pre_fork_noio_channel_object (SPC_Channel_Ptr channel);
int post_fork_noio_channel_object (SPC_Channel_Ptr channel, int parentp);
int reset_noio_channel_object (SPC_Channel_Ptr channel);
int attach_noio_channel_object (SPC_Channel_Ptr channel, int);
void noio_channel_object_input_handler (void * client_data, int *source, SPCInputId *id);
int send_eof_noio_channel_object(SPC_Channel_Ptr channel);
int set_termio_noio_channel_object(SPC_Channel_Ptr, int, int, struct termios *);
/* pipe.c */
void pipe_channel_class_init (object_clasp c);
Wire *getpipe (Wire *prevwire);
SPC_Channel_Ptr open_pipe_channel_object (SPC_Channel_Ptr channel, int iomode, XeString hostname);
int read_pipe_channel_object (SPC_Channel_Ptr channel, int connector, XeString buffer, int nbytes);
int pre_fork_pipe_channel_object (SPC_Channel_Ptr channel);
int post_fork_pipe_channel_object (SPC_Channel_Ptr channel, int parentp);
int reset_pipe_channel_object (SPC_Channel_Ptr channel);
int attach_pipe_channel_object (SPC_Channel_Ptr channel, int);
int add_input_pipe_channel_object (SPC_Channel_Ptr channel, SbInputHandlerProc handler, void *data);
/* pty.c */
void pty_channel_class_init (object_clasp c);
SPC_Channel_Ptr open_pty_channel_object (SPC_Channel_Ptr channel, int iomode, XeString hostname);
int read_pty_channel_object (SPC_Channel_Ptr channel, int connector, XeString buffer, int nbytes);
int pre_fork_pty_channel_object (SPC_Channel_Ptr channel);
int post_fork_pty_channel_object (SPC_Channel_Ptr channel, int parentp);
int reset_pty_channel_object (SPC_Channel_Ptr channel);
int attach_pty_channel_object (SPC_Channel_Ptr channel, int pid);
int add_input_pty_channel_object (SPC_Channel_Ptr channel, SbInputHandlerProc handler, void *data);
int set_termio_pty_channel_object(SPC_Channel_Ptr channel, int, int,
struct termios *);
struct termios *SPC_Get_Current_Termio(void);
int SPC_Setpgrp(int);
/* remote.c */
void remote_channel_class_init (object_clasp c);
Wire *get_new_remote_wire (Wire *prevwire);
SPC_Channel_Ptr open_remote_channel_object (SPC_Channel_Ptr channel, int iomode, XeString hostname);
int close_remote_channel_object (SPC_Channel_Ptr channel);
int reset_remote_channel_object (SPC_Channel_Ptr channel);
int exec_proc_remote_channel_object (SPC_Channel_Ptr channel);
int write_remote_channel_object (SPC_Channel_Ptr channel, XeString buffer, int len);
int read_remote_channel_object (SPC_Channel_Ptr channel, int connection, XeString buffer, int len);
int signal_remote_channel_object (SPC_Channel_Ptr channel, int sig);
int attach_remote_channel_object (SPC_Channel_Ptr channel, int pid);
int remove_logfile_remote_channel_object (SPC_Channel_Ptr channel);
int add_input_remote_channel_object (SPC_Channel_Ptr channel, SbInputHandlerProc handler, void *data);
int SPC_Debug_Mode (SPC_Channel_Ptr channel, XeString file);
int send_eof_remote_channel_object(SPC_Channel_Ptr channel);
int set_termio_remote_channel_object(SPC_Channel_Ptr channel,
int, int, struct termios *);
/* spc-env.c */
XeString SPC_Getenv (XeString var, XeString *envp);
XeString *SPC_Putenv (XeString val, XeString *envp);
XeString *SPC_Add_Env_File (XeString filename, XeString *envp);
XeString *SPC_Create_Default_Envp (XeString *old_envp);
XeString *SPC_Fixup_Environment (XeString *envp, SPC_Channel_Ptr channel);
XeString *SPC_Merge_Envp (XeString *dest_envp, XeString *source_envp);
void SPC_Free_Envp (XeString *envp);
/* spc-exec.c */
int SPC_Setup_Synchronous_Terminator (void);
SPC_Connection_Ptr SPC_Channel_Terminator_Connection (SPC_Channel_Ptr channel);
void SPC_Close_Unused (void);
int SPC_MakeSystemCommand (SPC_Channel_Ptr channel);
void SPC_Child_Terminated(int);
int exec_proc_local_channel_object (SPC_Channel_Ptr channel);
/* spc-net.c */
Boolean SPC_Init_Local_Host_Info (void);
int SPC_Local_Hostname (XeString hostname);
SPC_Connection_Ptr SPC_Open_Connection (XeString hostname);
int SPC_Open_Socket (SPC_Connection_Ptr conn, int type);
int SPC_Contact_Server (SPC_Connection_Ptr connection);
SPC_Connection_Ptr SPC_Init_Child (SPC_Connection_Ptr conn, int from);
SPC_Connection_Ptr SPC_Standalone_Daemon (SPC_Connection_Ptr conn);
int SPC_Inetd_Daemon (SPC_Connection_Ptr conn);
SPC_Connection_Ptr SPC_Start_Daemon (int standalone);
/* spc-obj.c */
void spc_init_fds(void);
object *alloc_channel_object (object_clasp c);
void channel_class_init (object_clasp c);
int SPC_ResetTerminator(void);
int SPC_Initialize (void);
SPC_Channel_Ptr SPC_Initialize_Channel (XeString hostname, int iomode);
void SPC_Channel_Terminated (SPC_Channel_Ptr channel);
int SPC_Check_Style (int iomode);
int SPC_Transform_Iomode (int iomode);
int SPC_Newline_Filter (SPC_Channel_Ptr channel, int connector, XeString buffer, int ntoread);
int SPC_Input_Handler (SPC_Channel_Ptr channel, int connector);
SPC_Channel_Ptr open_channel_object (SPC_Channel_Ptr channel, int iomode, XeString hostname);
int close_channel_object (SPC_Channel_Ptr channel);
int read_channel_object (SPC_Channel_Ptr channel, int connector, XeString buffer, int nbytes);
int write_channel_object (SPC_Channel_Ptr channel, XeString buffer, int nbytes);
int reset_channel_object (SPC_Channel_Ptr channel);
int pre_fork_channel_object (SPC_Channel_Ptr channel);
int post_fork_channel_object (SPC_Channel_Ptr channel, int parentp);
int exec_proc_channel_object (SPC_Channel_Ptr channel);
int signal_channel_object (SPC_Channel_Ptr channel, int sig);
int channel_object_wait_for_termination (SPC_Channel_Ptr channel);
int attach_channel_object (SPC_Channel_Ptr channel, int pid);
int add_input_channel_object (SPC_Channel_Ptr channel, SbInputHandlerProc handler, void *data);
int remove_logfile_channel_object (SPC_Channel_Ptr channel);
/* spc-sm.c */
int SPC_Change_State (SPC_Channel_Ptr channel, int connector, int data_line, int process_line);
int error_fun (SPC_Channel_Ptr channel, int connector);
int connector_eof (SPC_Channel_Ptr channel, int connector);
int connector_eof_with_reset (SPC_Channel_Ptr channel, int connector);
int sigcld_with_reset (SPC_Channel_Ptr channel, int connector);
/* spc-xt.c */
typedef void (*spc_handler_func_type) (void *, int *, SPCInputId *);
int SPC_Wait_For_Termination (SPC_Channel_Ptr channel);
void SPC_XtBreak (void);
void SPC_XtAddInput (SPC_Channel_Ptr channel, int *id_addr, int fd, spc_handler_func_type handler, SPC_Callback_Condition condition);
void SPC_XtRemoveInput (int *id_addr, SPC_Callback_Condition condition);
/* spc-util.c */
Wire *get_new_wire (void);
void free_wire (Wire *wire);
SPC_Channel_Ptr SPC_Find_PID (int pid);
int spc_close (int fd);
int spc_dup2 (int from, int to);
int SPC_fd_to_connector (SPC_Channel_Ptr channel, int fd);
XeString *Alloc_Argv (int n);
void SPC_Conditional_Packet_Handler (void * client_data, int *source, SPCInputId *id);
int sprintf_len (XeString s, XeString format, ...);
typedef Boolean (path_search_predicate)(XeString, XeString, XeString);
Boolean path_search (XeString path, XeString filename, path_search_predicate p);
/* spc-error.c */
XeString SPC_copy_string (XeString str);
void SPC_Error (int error, ...);
int SPC_Make_Log_Filename (XeString name, int unique);
int SPC_Open_Log (XeString filename, int unique);
int SPC_Close_Log (void);
int SPC_Write_Log (XeString str);
int SPC_Format_Log (XeString format, ...);
SPCError *SPC_Lookup_Error (int errornum);
SPCError *SPC_Lookup_Error (int errornum);
/* spc-termio.c */
XeString SPC_Decode_Termios( struct termios * );
void SPC_Encode_Termios(XeString buff, struct termios *tio);
#endif /* _spcP_h */
Reference in New Issue View Git Blame Copy Permalink