ses.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008 - 2012, Andy Bierman, All Rights Reserved.
 * Copyright (c) 2012 - 2021, YumaWorks, Inc., All Rights Reserved.
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
#ifndef _H_ses
#define _H_ses
/*  FILE: ses.h
*********************************************************************
*                                                                   *
*                         P U R P O S E                             *
*                                                                   *
*********************************************************************/

/*********************************************************************
*                                                                   *
*                   C H A N G E         H I S T O R Y               *
*                                                                   *
*********************************************************************

date             init     comment
----------------------------------------------------------------------
30-dec-05    abb      Begun.
*/

/* used by applications to generate FILE output */
#include <stdio.h>

/* used for timestamps and time deltas */
#include <time.h>

/* used by the agent for the xmlTextReader interface */
#include <xmlreader.h>

#ifndef _H_dlq
#include "dlq.h"
#endif

#ifndef _H_ncxtypes
#include "ncxtypes.h"
#endif

#ifndef _H_status
#include "status.h"
#endif

#ifndef _H_tstamp
#include "tstamp.h"
#endif

#if defined(WITH_SNMP) && defined(WITH_RESTCONF)
#include <net-snmp/net-snmp-config.h>

#ifndef UCLINUX
#include <net-snmp/net-snmp-features.h>
#endif

#include <net-snmp/net-snmp-includes.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

/********************************************************************
*                                                                   *
*                         C O N S T A N T S                         *
*                                                                   *
*********************************************************************/

#define SES_MY_SID(S)   ((S)->sid)

#define SES_MY_FD(S)   ((S)->fd)

#define SES_MY_USERNAME(S)   ((S)->username)

#define SES_KILLREQ_SET(S) ((S)->state >= SES_ST_SHUTDOWN_REQ)

#define SES_ACK_KILLREQ(S) ((S)->state = SES_ST_SHUTDOWN)

#define SES_OUT_BYTES(S) (S)->stats.out_bytes

#define SES_LINELEN(S) (S)->stats.out_line

#define SES_LINESIZE(S) (S)->linesize

#define SES_IN_ENCODING(S) (S)->in_encoding

#define SES_OUT_ENCODING(S) (S)->out_encoding

#define SES_IS_DUMMY(S) ((S)->sid == 0)

#define SES_IS_YCONTROL(S) ((S)->ycontrol)

#define SES_CONN_CLOSED(S) (S)->conn_closed

#define SES_SET_CUR_RPC_MSG(S,MSG) (S)->cur_rpc_msg = MSG

#define SES_GET_CUR_RPC_MSG(S) (S)->cur_rpc_msg

#define SES_GET_JSON_1LINE(S) (S)->json_1line

#define SES_USE_JSON_ATTRS(S) (S)->json_attrs

#define SES_SET_JSON_ATTRS(S) (S)->json_attrs = TRUE

#define SES_SET_LEAFLIST_PTR(S,V) (S)->leaflist = V

#define SES_GET_LEAFLIST_PTR(S) (S)->leaflist

#define SES_SET_LEAFLIST_ATTRS(S,A) (S)->any_leaflist_attrs = A

#define SES_GET_LEAFLIST_ATTRS(S) (S)->any_leaflist_attrs

#define SES_KEEP_XMLNS(S) (S)->keep_xmlns

#define SES_RAWXML_MODE(S) (S)->rawxml_mode

#define SES_STATE(S) (S)->state

#define SES_PEERADDR(S) (S)->peeraddr

#define SES_TRANSPORT(S) (S)->transport

#define SES_PROTOCOL(S)  (S)->protocol

#define SES_IS_IPV6(S)  (S)->is_ipv6

#define SES_IS_CALLHOME(S)  (S)->is_callhome

#define SES_TYPE(S) (S)->type

#define SES_GET_COOKIE(S) (S)->get_cookie

#define SES_BREADCRUMBQ(S) &(S)->breadcrumbQ

#define SES_CURMSG(S) (S)->curmsg

#define SES_START_TLS(S)  (S)->start_tls

#define SES_WILDCARD_OK(S)  (S)->wildcard_ok

#define SES_MGRCB(S) (S)->mgrcb

#define SES_NOTIF_ACTIVE(S) (S)->notif_active

#define SES_RFC8639_NOTIF_COUNT(S) (S)->rfc8639_notif_cnt

#define SES_BINARY_NOTIFS(S) (S)->binary_notifs

#define BINLOG (const xmlChar *)"***binary***"


#define SES_NULL_SID  0

#define SES_MSG_BUFFSIZE  1000

#define SES_MAX_BUFFERS  500000

#ifdef WITH_COAP
#define SES_MAX_FREE_BUFFERS  4
#else
#define SES_MAX_FREE_BUFFERS  32
#endif  // WITH_COAP

#define SES_MAX_BUFFSEND   32

#define SES_MAX_BYTESEND   0xffff

#define SES_DEF_LINESIZE   72

#define SES_MAX_STARTCHUNK_SIZE 13

#define SES_MAX_CHUNKNUM_SIZE 10

#define SES_STARTCHUNK_PAD  10

#define SES_ENDCHUNK_PAD  8

#define SES_READBUFF_SIZE  1000

#define SES_GET_YPMODE(S)  (S)->yp_mode

#define SES_SET_YPMODE(S,V)  (S)->yp_mode = V

#define SES_REMOTE_WAIT(S)  (S)->remote_wait

#define SES_NEED_FILE_OVERRIDE(S) ((S)->file_override && (S)->fp)

#define SES_SYSTEM_USERNAME  NCX_EL_SYSTEM


/********************************************************************
*                                                                   *
*                             T Y P E S                             *
*                                                                   *
*********************************************************************/

typedef uint32 ses_id_t;

typedef enum ses_ypmode_t_ {
    SES_YPMODE_NONE,     
    SES_YPMODE_HA,       
    SES_YPMODE_RESTCONF, 
    SES_YPMODE_NETCONF   
} ses_ypmode_t;


typedef enum ses_type_t_ {
    SES_TYP_NONE,       
    SES_TYP_NETCONF,    
    SES_TYP_DUMMY,      
    SES_TYP_YCONTROL,   
    SES_TYP_COAP,       
    SES_TYP_SNMP,       
    SES_TYP_GNMI        
} ses_type_t;


typedef enum ses_transport_t_ {
    SES_TRANSPORT_NONE,   
    SES_TRANSPORT_SSH,    
    SES_TRANSPORT_BEEP,   
    SES_TRANSPORT_SOAP,   
    SES_TRANSPORT_SOAPBEEP, 
    SES_TRANSPORT_TLS, 
    SES_TRANSPORT_TCP_TAILF,   
    SES_TRANSPORT_TCP_NCX,   
    SES_TRANSPORT_HTTP,   
    SES_TRANSPORT_CLI,    
    SES_TRANSPORT_WEBUI,  
    SES_TRANSPORT_AFLOCAL,  
    SES_TRANSPORT_COAP,  
    SES_TRANSPORT_COAP_DTLS, /* CoAP DTLS/UDP socket */
    SES_TRANSPORT_SNMP,   
    SES_TRANSPORT_NETCONF_TLS,  
    SES_TRANSPORT_GNMI   
} ses_transport_t;


typedef enum ses_state_t_ {
    SES_ST_NONE,               
    SES_ST_INIT,               
    SES_ST_HELLO_WAIT,         
    SES_ST_XRD_WAIT,           
    SES_ST_RESTCAPS_WAIT,      
    SES_ST_IDLE,               
    SES_ST_IN_MSG,             
    SES_ST_SHUTDOWN_REQ,       
    SES_ST_SHUTDOWN            
} ses_state_t;


typedef enum ses_instate_t_ {
    SES_INST_NONE,           
    SES_INST_IDLE,           
    SES_INST_INMSG,          
    SES_INST_INSTART,        
    SES_INST_INBETWEEN,      
    SES_INST_INEND           
} ses_instate_t;


typedef enum ses_mode_t_ {
    SES_MODE_NONE,     
    SES_MODE_XML,      
    SES_MODE_XMLDOC,   
    SES_MODE_HTML,     
    SES_MODE_TEXT,     
    SES_MODE_BINARY,   
} ses_mode_t;


typedef enum ses_term_reason_t_ {
    SES_TR_NONE,          
    SES_TR_CLOSED,        
    SES_TR_KILLED,        
    SES_TR_DROPPED,       
    SES_TR_TIMEOUT,       
    SES_TR_OTHER,         
    SES_TR_BAD_START,     
    SES_TR_BAD_HELLO      
} ses_term_reason_t;


typedef enum ses_prolog_state_t_ {
    SES_PRST_NONE,       
    SES_PRST_WAITING,    
    SES_PRST_DONE        
} ses_prolog_state_t;


typedef struct ses_stats_t_ {
    uint32            in_bytes;

    uint32            out_bytes;

    uint32            out_line;

    uint32            inRpcs;

    uint32            inBadRpcs;

    uint32            outRpcErrors;

    uint32            outNotifications;

    uint32            requests;
} ses_stats_t;


typedef struct ses_total_stats_t_ {
    uint32            active_sessions;

    uint32            closed_sessions;

    uint32            failed_sessions;

    uint32            inBadHellos;

    uint32            inSessions;

    uint32            droppedSessions;

    ses_stats_t       stats;

    xmlChar           startTime[TSTAMP_MIN_SIZE];
} ses_total_stats_t;


typedef struct ses_msg_buff_t_ {
    dlq_hdr_t        qhdr;         
    size_t           buffstart;    
    size_t           bufflen;      
    size_t           buffpos;      
    boolean          islast;       
    boolean          isbinary;     
    xmlChar          buff[SES_MSG_BUFFSIZE+1];
} ses_msg_buff_t;


typedef struct ses_ready_t_ {
    dlq_hdr_t hdr;

    ses_id_t  sid;

    boolean   inq;

    boolean   ycontrol;
} ses_ready_t;


typedef struct ses_msg_t_ {
    dlq_hdr_t        qhdr;        
    boolean          ready;               
    boolean          dispatched;              
    ses_msg_buff_t  *curbuff;         
    dlq_hdr_t        buffQ;             
    ses_prolog_state_t prolog_state;      
    size_t           curchunksize;           
    size_t           expchunksize;      
} ses_msg_t;


typedef ssize_t (*ses_read_fn_t) (void *s,
                                  char *buff,
                                  size_t bufflen,
                                  bool *erragain);


typedef status_t (*ses_write_fn_t) (void *s);


typedef struct ses_cb_t_ {
    dlq_hdr_t        qhdr;           
    ses_type_t       type;                      
    uint32           protocols_requested;            
    ncx_protocol_t   protocol;       
    ses_transport_t  transport;               
    ncx_msg_encoding_t encoding;           
    ses_state_t      state;                    
    ses_mode_t       mode;                      
    ses_id_t         sid;                         
    ses_id_t         killedbysid;       
    ses_id_t         rollback_sid;   
    ses_term_reason_t termreason;         
    time_t           hello_time;      
    time_t           last_rpc_time;    
    xmlChar         *start_time;         
    xmlChar         *username;                       
    xmlChar         *peeraddr;           
    xmlChar         *subsys_id;     
    int              tid;                
    void            *tcb;                
    boolean          locks_released;     
    boolean          conn_closed;       
    boolean          active;            
    boolean          notif_active;       
    boolean          stream_output;        
    boolean          noxmlns;          
    boolean          framing11;     
    boolean          keep_xmlns;    
    boolean          warn_xml;      
    boolean          rawxml_mode;    
    boolean          direct_mode;     
    boolean          msg_mode;         
    boolean          ycontrol;        
    boolean          dbapi;             
    boolean          dbapi_system;      
    boolean          sse_mode;  
    boolean          ypgnmi;        
    boolean          restconf_sse_mode;  
    boolean          restconf_notif;  
    boolean          json_1line;   
    boolean          http_chunk_mode; 
    boolean          http_waitrn;     
    boolean          json_attrs;     
    boolean          any_leaflist_attrs; 
    boolean          is_ycontrol_scb;   
    boolean          is_ipv6;  
    boolean          is_callhome; 
    boolean          dropped; 
    boolean          start_tls; 
    boolean          checksum_mode;  
    uint32           last_ch;   
    struct val_value_t_  *leaflist;  
    ncx_display_mode_t in_encoding;

    ncx_display_mode_t out_encoding;

    xmlTextReaderPtr reader;             
    FILE            *fp;             
    int              fd;           
    ses_read_fn_t    rdfn;          
    ses_write_fn_t   wrfn;           
    uint32           inendpos;      
    ses_instate_t    instate;               
    uint32           buffcnt;           
    uint32           freecnt;            
    dlq_hdr_t        msgQ;              
    dlq_hdr_t        freeQ;              
    dlq_hdr_t        outQ;               
    ses_msg_buff_t  *outbuff;          
    ses_ready_t      inready;            
    ses_ready_t      outready;          
    ses_stats_t      stats;           
    void            *mgrcb;    
    struct rpc_msg_t_ *cur_rpc_msg;  
    struct yangapi_cb_t_ *rcb;        
    xmlChar         *entry_point;       
    xmlChar          startchunk[SES_MAX_STARTCHUNK_SIZE+1];

    xmlChar         *readbuff;
    uint32           readbuffsize;   
    /*** user preferences ***/
    int8             indent;          
    int8             msg_indent;      
    uint32           linesize;              
    ncx_withdefaults_t  withdef;       
    uint32           cache_timeout;  
    struct agt_acm_cache_t_ *acm_cache;

    xmlChar         *service_name;   
    boolean reading_header; 
    boolean content_length_based; 
    boolean chunk_based; 
    int32 total_length;  
    boolean         use_traceid;

    ses_ypmode_t    yp_mode;

    boolean         skip_modnames;

    void             *openssl_ctx;   
    void             *openssl_ssl;   
    void             *get_cookie;

    boolean           remote_wait;

    dlq_hdr_t        breadcrumbQ;  
    ses_msg_t       *curmsg;

    boolean         wildcard_ok;

    boolean         file_override;

    struct cfg_template_t_  *fake_candidate;

    uint16       rfc8639_notif_cnt;

    uint32        checksum;
    uint32        checksum_cnt;   
    dlq_hdr_t                snmp_getnext_listQ;

    struct obj_template_t_  *snmp_table_obj;

    boolean          ypgrpc;        
    boolean         binary_notifs;

    uint32          yang_sid_tree;

} ses_cb_t;


/********************************************************************
*                                                                   *
*                        F U N C T I O N S                          *
*                                                                   *
*********************************************************************/

extern ses_cb_t *
    ses_new_scb (void);


extern ses_cb_t *
    ses_new_dummy_scb (void);


#ifdef WITH_COAP

extern ses_cb_t *
    ses_new_coap_scb (void);


extern void
    ses_init_coap_scb (ses_cb_t *scb);

#endif // WITH_COAP


#if defined(WITH_SNMP) && defined(WITH_RESTCONF)

extern ses_cb_t *
    ses_new_snmp_scb (void);

#endif // WITH_SNMP


extern void
    ses_free_scb (ses_cb_t *scb);


extern void
    ses_putchar (ses_cb_t *scb,
                 uint32    ch);


extern void
    ses_put_binchar (ses_cb_t *scb,
                     uint32    ch);


extern void
    ses_putstr (ses_cb_t *scb,
                const xmlChar *str);


extern void
    ses_put_binstr (ses_cb_t *scb,
                    const xmlChar *str,
                    uint32 len);


extern void
    ses_putstr_indent (ses_cb_t *scb,
                       const xmlChar *str,
                       int32 indent);


extern void
    ses_putcstr (ses_cb_t *scb,
                 const xmlChar *str,
                 int32 indent);


extern void
    ses_puthstr (ses_cb_t *scb,
                 const xmlChar *str);


extern void
    ses_putcchar (ses_cb_t *scb,
                  uint32    ch);


extern void
    ses_putastr (ses_cb_t *scb,
                 const xmlChar *str,
                 int32 indent);


extern void
    ses_putjstr (ses_cb_t *scb,
                 const xmlChar *str,
                 int32 indent);


extern void
    ses_indent (ses_cb_t *scb,
                int32 indent);


extern int32
    ses_indent_count (const ses_cb_t *scb);


extern int32
    ses_message_indent_count (const ses_cb_t *scb);


extern void
    ses_set_indent (ses_cb_t *scb,
                    int32 indent);


extern void
    ses_set_message_indent (ses_cb_t *scb, int32 indent);


extern void
    ses_set_mode (ses_cb_t *scb,
                  ses_mode_t mode);


extern ses_mode_t
    ses_get_mode (ses_cb_t *scb);


extern void ses_start_msg_mode (ses_cb_t *scb);


extern void ses_stop_msg_mode (ses_cb_t *scb);


extern status_t
    ses_start_msg (ses_cb_t *scb);


extern void
    ses_finish_msg (ses_cb_t *scb);


extern int
    ses_read_cb (void *context,
                 char *buffer,
                 int len);


extern status_t
    ses_accept_input (ses_cb_t *scb);


extern const xmlChar *
    ses_state_name (ses_state_t state);


extern ncx_withdefaults_t
    ses_withdef (const ses_cb_t *scb);


extern uint32
    ses_line_left (const ses_cb_t *scb);


extern void
    ses_put_extern (ses_cb_t *scb,
                    const xmlChar *fname);


extern status_t
    ses_put_extern2 (ses_cb_t *scb,
                     const xmlChar *fname);


extern status_t
    ses_put_extern_bin (ses_cb_t *scb,
                        const xmlChar *fname);



extern ses_total_stats_t *
    ses_get_total_stats (void);


extern ses_transport_t
    ses_get_transport (ses_cb_t *scb);


extern ses_transport_t
    ses_get_transport_enum (const xmlChar *str);


extern const xmlChar *
    ses_get_transport_name (ses_transport_t transport);


extern const xmlChar *
    ses_get_transport_yang_name (ses_transport_t transport);


extern void
    ses_set_xml_nons (ses_cb_t *scb);


extern boolean
    ses_get_xml_nons (const ses_cb_t *scb);


extern status_t
    ses_set_protocol (ses_cb_t *scb,
                      ncx_protocol_t proto);


extern ncx_protocol_t
    ses_get_protocol (const ses_cb_t *scb);


extern void
    ses_set_protocols_requested (ses_cb_t *scb,
                                 ncx_protocol_t proto);


extern boolean
    ses_protocol_requested (ses_cb_t *scb,
                            ncx_protocol_t proto);


extern void
    ses_set_extern_xml_mode (ses_cb_t *scb,
                             boolean rawxml_mode);


extern void
    ses_set_extern_xml_mode_ex (ses_cb_t *scb,
                                boolean rawxml_mode,
                                boolean keep_xmlns);


extern void
    ses_clear_extern_xml_mode (ses_cb_t *scb,
                               boolean rawxml_mode);


extern void
    ses_clear_extern_xml_mode_ex (ses_cb_t *scb,
                                  boolean rawxml_mode,
                                  boolean keep_xmlns);


extern void
    ses_set_out_encoding (ses_cb_t *scb,
                          ncx_display_mode_t encoding);


extern void
    ses_set_SSE_encoding (ses_cb_t *scb);


extern ncx_display_mode_t
    ses_get_out_encoding (ses_cb_t *scb);


extern int32
    ses_new_indent_count (boolean indent_in,
                          int32 indent,
                          int32 indent_amount);


extern void
    ses_free_xml_reader (ses_cb_t *scb);


extern status_t
    ses_getline_cb (xmlChar *fillbuff,
                    uint32 fillbuffsize,
                    void *cookie);


extern status_t
    ses_set_control_session (ses_cb_t *scb);


extern boolean
    ses_is_control_session (ses_cb_t *scb);


extern void
    ses_set_dbapi_session (ses_cb_t *scb);


extern boolean
    ses_is_dbapi_session (ses_cb_t *scb);


extern void
    ses_set_dbapi_system_session (ses_cb_t *scb);


extern boolean
    ses_is_dbapi_system_session (ses_cb_t *scb);


extern void
    ses_clear_dbapi_system_session (ses_cb_t *scb);


extern boolean
    ses_is_system_session (ses_cb_t *scb);


extern int32
    ses_add_indent (ses_cb_t *scb,
                    int32 indent);


extern int32
    ses_dec_indent (ses_cb_t *scb,
                    int32 indent);


extern ncx_msg_encoding_t
    ses_get_msg_encoding (const ses_cb_t *scb);


extern status_t
    ses_start_http_chunk_mode (ses_cb_t *scb);


extern const xmlChar *
    ses_get_entry_point (ses_cb_t *scb);


extern status_t
    ses_set_entry_point (ses_cb_t *scb,
                         const xmlChar *point);


extern boolean
    ses_notifications_active (const ses_cb_t *scb);


#ifdef WITH_GNMI

extern status_t
    ses_set_gnmi_control_session (ses_cb_t *scb);


extern boolean
    ses_is_gnmi_control_session (ses_cb_t *scb);


extern void
    ses_set_gnmi_session (ses_cb_t *scb);


extern boolean
    ses_is_gnmi_session (ses_cb_t *scb);

#endif //WITH_GNMI


extern status_t
    ses_add_breadcrumb_obj (ses_cb_t *scb,
                            struct obj_template_t_ *obj);


extern void
    ses_clean_breadcrumbQ (ses_cb_t *scb);


extern boolean
    ses_dropped (const ses_cb_t *scb);


extern status_t
    ses_set_file_override (ses_cb_t *scb,
                           const xmlChar *filespec,
                           boolean is_binary);


extern void
    ses_clear_file_override (ses_cb_t *scb);


extern void
    ses_start_checksum (ses_cb_t *scb);


extern uint32
    ses_finish_checksum (ses_cb_t *scb,
                         uint32 *checksum_cnt);


extern boolean
    ses_dropped_ex (ses_cb_t *scb);


#ifdef WITH_GRPC

extern status_t
    ses_set_grpc_control_session (ses_cb_t *scb);


extern boolean
    ses_is_grpc_control_session (ses_cb_t *scb);


extern void
    ses_set_grpc_session (ses_cb_t *scb);


extern boolean
    ses_is_grpc_session (ses_cb_t *scb);

#endif //WITH_GRPC


extern void
    ses_dump_binary_buff (const xmlChar *buff,
                          size_t bufflen);

#ifdef __cplusplus
}  /* end extern 'C' */
#endif

#endif            /* _H_ses */