ses.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008 - 2012, Andy Bierman, All Rights Reserved.
 * Copyright (c) 2012 - 2024, 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>
 
/* Used for UDP-Notif to store */
#include <sys/socket.h>
//#include <netinet/in.h>
//#include <arpa/inet.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                         *
*                                                                   *
*********************************************************************/
 
/* this buffer length used in recvfrom to allow for
 *  maximum IPv6 address length
 */
#define SES_SOCKADDR_BUFFLEN 128
 
/* this buffer length used in udpnot for displayable
 * IP address length
 * maximum IPv6 address length should be 46
 */
#define SES_PRINTADDR_BUFFLEN 50
 
#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_BUFFSIZE(S) (S)->session_buffsize
 
#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_PEERPORT(S) (S)->peerport
 
#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_RDFN(S)   (S)->rdfn
 
#define SES_WRFN(S)   (S)->wrfn
 
 
#define SES_SENDHOOK_FN(S)   (S)->sendhook_fn
 
 
#define SES_LAST_OUTBUFF(S)     (S)->last_outbuff
 
 
#define SES_SKIP_OUTMSG(S)     (S)->skip_outmsg
 
#define SES_CALLHOME_NAME(S)  (S)->callhome_name
 
 
#define SES_FREE_PENDING(S)  (S)->free_pending
 
 
#define SES_RCVR_CB(S)   (S)->rcvr_cb
 
 
#define SES_CUR_DSCP(S)   (S)->cur_dscp
 
 
#define SES_NULL_SID  0
 
#define SES_MSG_BUFFSIZE  9000
 
#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  SES_MSG_BUFFSIZE
 
#define SES_UDPNOTIF_READBUFF_SIZE 65532
 
#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_TYP_UDPNOTIF    
} 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_UDPNOTIF  
} 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            excluded_events;
 
    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;     
    uint32           segment;
 
    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;      
    ncx_msg_encoding_t  msg_encoding;
 
    uint32 publisher_id;
 
    uint32 message_id;
 
} 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 status_t (*ses_sendhook_fn_t) (void *s,
                                       boolean start);
 
 
 
typedef status_t (*ses_setup_fn_t) (void *s,
                                    void *cookie);
 
 
 
typedef struct ses_udpnotif_cb_t_ {
 
    uint32 curmsg_addrlen;
 
    xmlChar curmsg_addr[SES_SOCKADDR_BUFFLEN];
 
    dlq_hdr_t  pubcbQ;    // Q of udpnotif::pubcb_t
 
    ses_setup_fn_t  setup_fn;
 
    void *cookie;
 
    const xmlChar *curmsg_print_addr;
 
} ses_udpnotif_cb_t;
 
 
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;           
    uint16           peerport;          
    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          free_pending; 
    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;           
    ses_sendhook_fn_t sendhook_fn;
 
    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;
 
    xmlChar         *callhome_name;
 
    size_t           session_buffsize;
 
    uint8 cur_dscp;
 
    boolean last_outbuff;
 
    boolean skip_outmsg;
 
    void  *rcvr_cb;
 
    ses_udpnotif_cb_t  *udpnotif_cb;
 
} 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_udpnotif_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);
 
extern boolean
    ses_poll_ready (ses_cb_t *scb);
 
 
extern const xmlChar *
    ses_get_scb_username (ses_cb_t *scb);
 
 
extern const xmlChar *
    ses_get_scb_client_addr (ses_cb_t *scb);
 
 
extern size_t
    ses_get_outbuff_len (const ses_cb_t *scb);
 
extern xmlChar *
    ses_get_outbuff (ses_cb_t *scb);
 
 
extern status_t
    ses_set_setup_cb (ses_cb_t *scb,
                      ses_setup_fn_t fn,
                      void *cookie);
 
 
 
#ifdef __cplusplus
}  /* end extern 'C' */
#endif
 
#endif            /* _H_ses */