From 64c8fdffab47bea64d9c746f5885d99dd81fe48f Mon Sep 17 00:00:00 2001 From: erickson Date: Sun, 19 Jun 2005 16:23:08 +0000 Subject: [PATCH 1/1] moved into their respective src dirs git-svn-id: svn://svn.open-ils.org/OpenSRF/trunk@353 9efc2488-bf62-4759-914b-345cdb29e865 --- include/opensrf/generic_utils.h | 89 ----------- include/opensrf/osrf_app_session.h | 197 ------------------------ include/opensrf/osrf_message.h | 99 ------------- include/opensrf/osrf_stack.h | 17 --- include/opensrf/osrf_system.h | 12 -- include/opensrf/string_array.h | 28 ---- include/opensrf/transport_client.h | 84 ----------- include/opensrf/transport_message.h | 94 ------------ include/opensrf/transport_session.h | 222 ---------------------------- include/opensrf/transport_socket.h | 64 -------- 10 files changed, 906 deletions(-) delete mode 100644 include/opensrf/generic_utils.h delete mode 100644 include/opensrf/osrf_app_session.h delete mode 100644 include/opensrf/osrf_message.h delete mode 100644 include/opensrf/osrf_stack.h delete mode 100644 include/opensrf/osrf_system.h delete mode 100644 include/opensrf/string_array.h delete mode 100644 include/opensrf/transport_client.h delete mode 100644 include/opensrf/transport_message.h delete mode 100644 include/opensrf/transport_session.h delete mode 100644 include/opensrf/transport_socket.h diff --git a/include/opensrf/generic_utils.h b/include/opensrf/generic_utils.h deleted file mode 100644 index e81f76f..0000000 --- a/include/opensrf/generic_utils.h +++ /dev/null @@ -1,89 +0,0 @@ -#include -#include -#include -#include - -/* libxml stuff for the config reader */ -#include -#include -#include -#include -#include - -#include "utils.h" - -#ifndef GENERIC_UTILS_H -#define GENERIC_UTILS_H - -#define LOG_ERROR 1 -#define LOG_WARNING 2 -#define LOG_INFO 3 -#define LOG_DEBUG 4 - - -#define equals(a,b) !strcmp(a,b) - - -/* -inline void* safe_malloc( int size ); - -#define BUFFER_MAX_SIZE 10485760 - -struct growing_buffer_struct { - char *buf; - int n_used; - int size; -}; -typedef struct growing_buffer_struct growing_buffer; - -growing_buffer* buffer_init( int initial_num_bytes); -int buffer_addchar(growing_buffer* gb, char c); -int buffer_add(growing_buffer* gb, char* c); -int buffer_reset( growing_buffer* gb); -char* buffer_data( growing_buffer* gb); -int buffer_free( growing_buffer* gb ); -int buffer_fadd(growing_buffer* gb, const char* format, ... ); -*/ - - -void log_free(); - -// Utility method -void get_timestamp( char buf_36chars[]); -double get_timestamp_millis(); - -// --------------------------------------------------------------------------------- -// Error handling interface. -// --------------------------------------------------------------------------------- - -void fatal_handler( char* message, ...); -void warning_handler( char* message, ... ); -void info_handler( char* message, ... ); -void debug_handler( char* message, ... ); - -/** If we return 0 either the log level is less than LOG_ERROR - * or we could not open the log file - */ -int log_init( int log_level, char* log_file ); - -// --------------------------------------------------------------------------------- -// Config file module -// --------------------------------------------------------------------------------- -struct config_reader_struct { - xmlDocPtr config_doc; - xmlXPathContextPtr xpathCx; - char* name; - struct config_reader_struct* next; -}; -typedef struct config_reader_struct config_reader; -config_reader* conf_reader; - -//void config_reader_init( char* config_file ); -void config_reader_init( char* name, char* config_file ); - -void config_reader_free(); - -// allocastes a char*. FREE me. -char* config_value( const char* config_name, const char* xp_query, ... ); - -#endif diff --git a/include/opensrf/osrf_app_session.h b/include/opensrf/osrf_app_session.h deleted file mode 100644 index 593db63..0000000 --- a/include/opensrf/osrf_app_session.h +++ /dev/null @@ -1,197 +0,0 @@ -#include "libjson/json.h" -#include "opensrf/transport_client.h" -#include "opensrf/generic_utils.h" -#include "osrf_message.h" -#include "osrf_system.h" -#include "opensrf/string_array.h" - -#ifndef OSRF_APP_SESSION -#define OSRF_APP_SESSION - - -#define DEF_RECV_TIMEOUT 6 /* receive timeout */ -#define DEF_QUEUE_SIZE - -enum OSRF_SESSION_STATE { OSRF_SESSION_CONNECTING, OSRF_SESSION_CONNECTED, OSRF_SESSION_DISCONNECTED }; -enum OSRF_SESSION_TYPE { OSRF_SESSION_SERVER, OSRF_SESSION_CLIENT }; - -struct osrf_app_request_struct { - /** Our controlling session */ - struct osrf_app_session_struct* session; - - /** our "id" */ - int request_id; - /** True if we have received a 'request complete' message from our request */ - int complete; - /** Our original request payload */ - osrf_message* payload; - /** List of responses to our request */ - osrf_message* result; - - /** So we can be listified */ - struct osrf_app_request_struct* next; -}; -typedef struct osrf_app_request_struct osrf_app_request; - -struct osrf_app_session_struct { - - /** Our messag passing object */ - transport_client* transport_handle; - /** Cache of active app_request objects */ - osrf_app_request* request_queue; - - /** The original remote id of the remote service we're talking to */ - char* orig_remote_id; - /** The current remote id of the remote service we're talking to */ - char* remote_id; - - /** Who we're talking to */ - char* remote_service; - - /** The current request thread_trace */ - int thread_trace; - /** Our ID */ - char* session_id; - - /* true if this session does not require connect messages */ - int stateless; - - /** The connect state */ - enum OSRF_SESSION_STATE state; - - /** SERVER or CLIENT */ - enum OSRF_SESSION_TYPE type; - - /** So we can be listified */ - struct osrf_app_session_struct* next; -}; -typedef struct osrf_app_session_struct osrf_app_session; - - - -// -------------------------------------------------------------------------- -// PUBLIC API *** -// -------------------------------------------------------------------------- - -/** Allocates a initializes a new app_session */ -osrf_app_session* osrf_app_client_session_init( char* remote_service ); - -/** Allocates and initializes a new server session. The global session cache - * is checked to see if this session already exists, if so, it's returned - */ -osrf_app_session* osrf_app_server_session_init( - char* session_id, char* our_app, char* remote_service, char* remote_id ); - -/** returns a session from the global session hash */ -osrf_app_session* osrf_app_session_find_session( char* session_id ); - -/** Builds a new app_request object with the given payload andn returns - * the id of the request. This id is then used to perform work on the - * requeset. - */ -int osrf_app_session_make_request( - osrf_app_session* session, json* params, - char* method_name, int protocol, string_array* arr ); - -/** Sets the given request to complete state */ -void osrf_app_session_set_complete( osrf_app_session* session, int request_id ); - -/** Returns true if the given request is complete */ -int osrf_app_session_request_complete( osrf_app_session* session, int request_id ); - -/** Does a recv call on the given request */ -osrf_message* osrf_app_session_request_recv( - osrf_app_session* session, int request_id, int timeout ); - -/** Removes the request from the request set and frees the reqest */ -void osrf_app_session_request_finish( osrf_app_session* session, int request_id ); - -/** Resends the orginal request with the given request id */ -int osrf_app_session_request_resend( osrf_app_session*, int request_id ); - -/** Resets the remote connection target to that of the original*/ -void osrf_app_session_reset_remote( osrf_app_session* ); - -/** Sets the remote target to 'remote_id' */ -void osrf_app_session_set_remote( osrf_app_session* session, char* remote_id ); - -/** pushes the given message into the result list of the app_request - * whose request_id matches the messages thread_trace - */ -int osrf_app_session_push_queue( osrf_app_session*, osrf_message* msg ); - -/** Attempts to connect to the remote service. Returns 1 on successful - * connection, 0 otherwise. - */ -int osrf_app_session_connect( osrf_app_session* ); - -/** Sends a disconnect message to the remote service. No response is expected */ -int osrf_app_session_disconnect( osrf_app_session* ); - -/** Waits up to 'timeout' seconds for some data to arrive. - * Any data that arrives will be processed according to its - * payload and message type. This method will return after - * any data has arrived. - */ -int osrf_app_session_queue_wait( osrf_app_session*, int timeout ); - -/** Disconnects (if client), frees any attached app_reuqests, removes the session from the - * global session cache and frees the session. Needless to say, only call this when the - * session is completey done. - */ -void osrf_app_session_destroy ( osrf_app_session* ); - - - -// -------------------------------------------------------------------------- -// -------------------------------------------------------------------------- -// Request functions -// -------------------------------------------------------------------------- - -/** Allocations and initializes a new app_request object */ -osrf_app_request* _osrf_app_request_init( osrf_app_session* session, osrf_message* msg ); - -/** Frees memory used by an app_request object */ -void _osrf_app_request_free( osrf_app_request * req ); - -/** Pushes the given message onto the list of 'responses' to this request */ -void _osrf_app_request_push_queue( osrf_app_request*, osrf_message* payload ); - -/** Checks the receive queue for messages. If any are found, the first - * is popped off and returned. Otherwise, this method will wait at most timeout - * seconds for a message to appear in the receive queue. Once it arrives it is returned. - * If no messages arrive in the timeout provided, null is returned. - */ -osrf_message* _osrf_app_request_recv( osrf_app_request* req, int timeout ); - -/** Resend this requests original request message */ -int _osrf_app_request_resend( osrf_app_request* req ); - - -// -------------------------------------------------------------------------- -// -------------------------------------------------------------------------- -// Session functions -// -------------------------------------------------------------------------- - -/** Returns the app_request with the given thread_trace (request_id) */ -osrf_app_request* _osrf_app_session_get_request( osrf_app_session*, int thread_trace ); - -/** frees memory held by a session. Note: We delete all requests in the request list */ -void _osrf_app_session_free( osrf_app_session* ); - -/** adds a session to the global session cache */ -void _osrf_app_session_push_session( osrf_app_session* ); - -/** removes from global session cache */ -void _osrf_app_session_remove_session( char* session_id ); - -/** Adds an app_request to the request set */ -void _osrf_app_session_push_request( osrf_app_session*, osrf_app_request* req ); - -/** Removes an app_request from this session request set, freeing the request object */ -void _osrf_app_session_remove_request( osrf_app_session*, osrf_app_request* req ); - -/** Send the given message */ -int _osrf_app_session_send( osrf_app_session*, osrf_message* msg ); - -#endif diff --git a/include/opensrf/osrf_message.h b/include/opensrf/osrf_message.h deleted file mode 100644 index f6c4ca1..0000000 --- a/include/opensrf/osrf_message.h +++ /dev/null @@ -1,99 +0,0 @@ -#include "libjson/json.h" -#include "opensrf/generic_utils.h" -#include "opensrf/string_array.h" - -#ifndef osrf_message_h -#define osrf_message_h - -#define OSRF_XML_NAMESPACE "http://open-ils.org/xml/namespaces/oils_v1" - -#define OSRF_STATUS_CONTINUE 100 - -#define OSRF_STATUS_OK 200 -#define OSRF_STATUS_ACCEPTED 202 -#define OSRF_STATUS_COMPLETE 205 - -#define OSRF_STATUS_REDIRECTED 307 - -#define OSRF_STATUS_BADREQUEST 400 -#define OSRF_STATUS_UNAUTHORIZED 401 -#define OSRF_STATUS_FORBIDDEN 403 -#define OSRF_STATUS_NOTFOUND 404 -#define OSRF_STATUS_NOTALLOWED 405 -#define OSRF_STATUS_TIMEOUT 408 -#define OSRF_STATUS_EXPFAILED 417 - -#define OSRF_STATUS_INTERNALSERVERERROR 500 -#define OSRF_STATUS_NOTIMPLEMENTED 501 -#define OSRF_STATUS_VERSIONNOTSUPPORTED 505 - - -enum M_TYPE { CONNECT, REQUEST, RESULT, STATUS, DISCONNECT }; - -#define OSRF_MAX_PARAMS 128; - -struct osrf_message_struct { - - enum M_TYPE m_type; - int thread_trace; - int protocol; - - int parse_json_result; - int parse_json_params; - - /* if we're a STATUS message */ - char* status_name; - - /* if we're a STATUS or RESULT */ - char* status_text; - int status_code; - - int is_exception; - - /* if we're a RESULT */ - json* result_content; - - /* unparsed json string */ - char* result_string; - - /* if we're a REQUEST */ - char* method_name; - json* params; - - /* in case anyone wants to make a list of us. - we won't touch this variable */ - struct osrf_message_struct* next; - - string_array* parray; - char* full_param_string; - -}; -typedef struct osrf_message_struct osrf_message; - - -osrf_message* osrf_message_init( enum M_TYPE type, int thread_trace, int protocol ); -void osrf_message_set_request_info( osrf_message*, char* param_name, json* params ); -void osrf_message_set_status_info( osrf_message*, char* status_name, char* status_text, int status_code ); -void osrf_message_set_result_content( osrf_message*, char* json_string ); -void osrf_message_free( osrf_message* ); -char* osrf_message_to_xml( osrf_message* ); -/** Pushes any message retreived from the xml into the 'msgs' array. - * it is assumed that 'msgs' has beenn pre-allocated. - * Returns the number of message that are in the buffer. - */ -int osrf_message_from_xml( char* xml, osrf_message* msgs[] ); - -/* decides whether all message automatically parse incoming json data */ -/* to change a single message, set msg->parse_json accordingly */ -//void osrf_message_set_json_parse( int bool ); - -void osrf_message_set_json_parse_result( int ibool ); -void osrf_message_set_json_parse_params( int ibool ); - - -void osrf_message_add_param( osrf_message*, char* param_string ); - - - - -#endif diff --git a/include/opensrf/osrf_stack.h b/include/opensrf/osrf_stack.h deleted file mode 100644 index 23b358e..0000000 --- a/include/opensrf/osrf_stack.h +++ /dev/null @@ -1,17 +0,0 @@ -#include "opensrf/transport_client.h" -#include "osrf_message.h" -#include "osrf_app_session.h" - -#ifndef OSRF_STACK_H -#define OSRF_STACK_H - -/* the max number of oilsMessage blobs present in any one root packet */ -#define OSRF_MAX_MSGS_PER_PACKET 16 -// ----------------------------------------------------------------------------- - -int osrf_stack_transport_handler( transport_message* msg ); -int osrf_stack_message_handler( osrf_app_session* session, osrf_message* msg ); -int osrf_stack_application_handler( osrf_app_session* session, osrf_message*msg ); - - -#endif diff --git a/include/opensrf/osrf_system.h b/include/opensrf/osrf_system.h deleted file mode 100644 index 7247d3a..0000000 --- a/include/opensrf/osrf_system.h +++ /dev/null @@ -1,12 +0,0 @@ -#include "opensrf/transport_client.h" - -#ifndef OSRF_SYSTEM_H -#define OSRF_SYSTEM_H - -/** Connects to jabber. Returns 1 on success, 0 on failure */ -int osrf_system_bootstrap_client(); -transport_client* osrf_system_get_transport_client(); - -int osrf_system_shutdown(); - -#endif diff --git a/include/opensrf/string_array.h b/include/opensrf/string_array.h deleted file mode 100644 index 805e1e2..0000000 --- a/include/opensrf/string_array.h +++ /dev/null @@ -1,28 +0,0 @@ -#include - -#include "opensrf/generic_utils.h" - -#define STRING_ARRAY_MAX_SIZE 1024 - -#ifndef STRING_ARRAY_H -#define STRING_ARRAY_H - -struct string_array_struct { - char** array; - int size; - int arr_size; - int total_string_size; -}; -typedef struct string_array_struct string_array; - -string_array* init_string_array(int size); -void string_array_add(string_array*, char* string); - -char* string_array_get_string(string_array* arr, int index); -void string_array_destroy(string_array*); - -/* total size of all included strings */ -int string_array_get_total_size(string_array* arr); - - -#endif diff --git a/include/opensrf/transport_client.h b/include/opensrf/transport_client.h deleted file mode 100644 index 695bbf0..0000000 --- a/include/opensrf/transport_client.h +++ /dev/null @@ -1,84 +0,0 @@ -#include "opensrf/transport_session.h" -#include - -#ifndef TRANSPORT_CLIENT_H -#define TRANSPORT_CLIENT_H - -#define MESSAGE_LIST_HEAD 1 -#define MESSAGE_LIST_ITEM 2 - - -// --------------------------------------------------------------------------- -// Represents a node in a linked list. The node holds a pointer to the next -// node (which is null unless set), a pointer to a transport_message, and -// and a type variable (which is not really curently necessary). -// --------------------------------------------------------------------------- -struct message_list_struct { - struct message_list_struct* next; - transport_message* message; - int type; -}; - -typedef struct message_list_struct transport_message_list; -typedef struct message_list_struct transport_message_node; - -// --------------------------------------------------------------------------- -// Our client struct. We manage a list of messages and a controlling session -// --------------------------------------------------------------------------- -struct transport_client_struct { - transport_message_list* m_list; - transport_session* session; -}; -typedef struct transport_client_struct transport_client; - -// --------------------------------------------------------------------------- -// Allocates and initializes and transport_client. This does no connecting -// The user must call client_free(client) when finished with the allocated -// object. -// --------------------------------------------------------------------------- -transport_client* client_init( char* server, int port, int component ); - -// --------------------------------------------------------------------------- -// Connects to the Jabber server with the provided information. Returns 1 on -// success, 0 otherwise. -// --------------------------------------------------------------------------- -int client_connect( transport_client* client, - char* username, char* password, char* resource, - int connect_timeout, enum TRANSPORT_AUTH_TYPE auth_type ); - -int client_disconnect( transport_client* client ); - -// --------------------------------------------------------------------------- -// De-allocates memory associated with a transport_client object. Users -// must use this method when finished with a client object. -// --------------------------------------------------------------------------- -int client_free( transport_client* client ); - -// --------------------------------------------------------------------------- -// Sends the given message. The message must at least have the recipient -// field set. -// --------------------------------------------------------------------------- -int client_send_message( transport_client* client, transport_message* msg ); - -// --------------------------------------------------------------------------- -// Returns 1 if this client is currently connected to the server, 0 otherwise -// --------------------------------------------------------------------------- -int client_connected( transport_client* client ); - -// --------------------------------------------------------------------------- -// This is the message handler required by transport_session. This handler -// takes all incoming messages and puts them into the back of a linked list -// of messages. -// --------------------------------------------------------------------------- -void client_message_handler( void* client, transport_message* msg ); - -// --------------------------------------------------------------------------- -// If there are any message in the message list, the 'oldest' message is -// returned. If not, this function will wait at most 'timeout' seconds -// for a message to arrive. Specifying -1 means that this function will not -// return unless a message arrives. -// --------------------------------------------------------------------------- -transport_message* client_recv( transport_client* client, int timeout ); - - -#endif diff --git a/include/opensrf/transport_message.h b/include/opensrf/transport_message.h deleted file mode 100644 index a1f7836..0000000 --- a/include/opensrf/transport_message.h +++ /dev/null @@ -1,94 +0,0 @@ -#include "opensrf/generic_utils.h" - -#include -#include -#include -#include -#include -#include -#include - -#ifndef TRANSPORT_MESSAGE_H -#define TRANSPORT_MESSAGE_H - - - -// --------------------------------------------------------------------------------- -// Jabber message object. -// --------------------------------------------------------------------------------- -struct transport_message_struct { - char* body; - char* subject; - char* thread; - char* recipient; - char* sender; - char* router_from; - char* router_to; - char* router_class; - char* router_command; - int is_error; - char* error_type; - int error_code; - int broadcast; - char* msg_xml; /* the entire message as XML complete with entity encoding */ -}; -typedef struct transport_message_struct transport_message; - -// --------------------------------------------------------------------------------- -// Allocates and returns a transport_message. All chars are safely re-allocated -// within this method. -// Returns NULL on error -// --------------------------------------------------------------------------------- -transport_message* message_init( char* body, char* subject, - char* thread, char* recipient, char* sender ); - -transport_message* new_message_from_xml( const char* msg_xml ); - - -void message_set_router_info( transport_message* msg, char* router_from, - char* router_to, char* router_class, char* router_command, int broadcast_enabled ); - -// --------------------------------------------------------------------------------- -// Formats the Jabber message as XML for encoding. -// Returns NULL on error -// --------------------------------------------------------------------------------- -char* message_to_xml( const transport_message* msg ); - - -// --------------------------------------------------------------------------------- -// Call this to create the encoded XML for sending on the wire. -// This is a seperate function so that encoding will not necessarily have -// to happen on all messages (i.e. typically only occurs outbound messages). -// --------------------------------------------------------------------------------- -int message_prepare_xml( transport_message* msg ); - -// --------------------------------------------------------------------------------- -// Deallocates the memory used by the transport_message -// Returns 0 on error -// --------------------------------------------------------------------------------- -int message_free( transport_message* msg ); - -// --------------------------------------------------------------------------------- -// Prepares the shared XML document -// --------------------------------------------------------------------------------- -//int message_init_xml(); - -// --------------------------------------------------------------------------------- -// Determines the username of a Jabber ID. This expects a pre-allocated char -// array for the return value. -// --------------------------------------------------------------------------------- -void jid_get_username( const char* jid, char buf[] ); - -// --------------------------------------------------------------------------------- -// Determines the resource of a Jabber ID. This expects a pre-allocated char -// array for the return value. -// --------------------------------------------------------------------------------- -void jid_get_resource( const char* jid, char buf[] ); - -/** Puts the domain portion of the given jid into the pre-allocated buffer */ -void jid_get_domain( const char* jid, char buf[] ); - -void set_msg_error( transport_message*, char* error_type, int error_code); - - -#endif diff --git a/include/opensrf/transport_session.h b/include/opensrf/transport_session.h deleted file mode 100644 index f044c01..0000000 --- a/include/opensrf/transport_session.h +++ /dev/null @@ -1,222 +0,0 @@ -// --------------------------------------------------------------------------------- -// Manages the Jabber session. Data is taken from the TCP object and pushed into -// a SAX push parser as it arrives. When key Jabber documetn elements are met, -// logic ensues. -// --------------------------------------------------------------------------------- -#include "opensrf/transport_socket.h" -#include "opensrf/transport_message.h" -#include "opensrf/generic_utils.h" - -#include "sha.h" - -#include -#include -#include -#include -#include /* only for xmlNewInputFromFile() */ -#include -#include -#include - -#ifndef TRANSPORT_SESSION_H -#define TRANSPORT_SESSION_H - -#define CONNECTING_1 1 /* just starting the connection to Jabber */ -#define CONNECTING_2 2 /* First packet sent and packet received from server */ - -/* Note. these are growing buffers, so all that's necessary is a sane starting point */ -#define JABBER_BODY_BUFSIZE 4096 -#define JABBER_SUBJECT_BUFSIZE 64 -#define JABBER_THREAD_BUFSIZE 64 -#define JABBER_JID_BUFSIZE 64 -#define JABBER_STATUS_BUFSIZE 16 - -// --------------------------------------------------------------------------------- -// Takes data from the socket handler and pushes it directly into the push parser -// --------------------------------------------------------------------------------- -void grab_incoming( void * session, char* data ); - -// --------------------------------------------------------------------------------- -// Callback for handling the startElement event. Much of the jabber logic occurs -// in this and the characterHandler callbacks. -// Here we check for the various top level jabber elements: body, iq, etc. -// --------------------------------------------------------------------------------- -void startElementHandler( - void *session, const xmlChar *name, const xmlChar **atts); - -// --------------------------------------------------------------------------------- -// Callback for handling the endElement event. Updates the Jabber state machine -// to let us know the element is over. -// --------------------------------------------------------------------------------- -void endElementHandler( void *session, const xmlChar *name); - -// --------------------------------------------------------------------------------- -// This is where we extract XML text content. In particular, this is useful for -// extracting Jabber message bodies. -// --------------------------------------------------------------------------------- -void characterHandler( - void *session, const xmlChar *ch, int len); - -void parseWarningHandler( void *session, const char* msg, ... ); -void parseErrorHandler( void *session, const char* msg, ... ); - -// --------------------------------------------------------------------------------- -// Tells the SAX parser which functions will be used as event callbacks -// --------------------------------------------------------------------------------- -static xmlSAXHandler SAXHandlerStruct = { - NULL, /* internalSubset */ - NULL, /* isStandalone */ - NULL, /* hasInternalSubset */ - NULL, /* hasExternalSubset */ - NULL, /* resolveEntity */ - NULL, /* getEntity */ - NULL, /* entityDecl */ - NULL, /* notationDecl */ - NULL, /* attributeDecl */ - NULL, /* elementDecl */ - NULL, /* unparsedEntityDecl */ - NULL, /* setDocumentLocator */ - NULL, /* startDocument */ - NULL, /* endDocument */ - startElementHandler, /* startElement */ - endElementHandler, /* endElement */ - NULL, /* reference */ - characterHandler, /* characters */ - NULL, /* ignorableWhitespace */ - NULL, /* processingInstruction */ - NULL, /* comment */ - parseWarningHandler, /* xmlParserWarning */ - parseErrorHandler, /* xmlParserError */ - NULL, /* xmlParserFatalError : unused */ - NULL, /* getParameterEntity */ - NULL, /* cdataBlock; */ - NULL, /* externalSubset; */ - 1, - NULL, - NULL, /* startElementNs */ - NULL, /* endElementNs */ - NULL /* xmlStructuredErrorFunc */ -}; - -// --------------------------------------------------------------------------------- -// Our SAX handler pointer. -// --------------------------------------------------------------------------------- -static const xmlSAXHandlerPtr SAXHandler = &SAXHandlerStruct; - -// --------------------------------------------------------------------------------- -// Jabber state machine. This is how we know where we are in the Jabber -// conversation. -// --------------------------------------------------------------------------------- -struct jabber_state_machine_struct { - int connected; - int connecting; - int in_message; - int in_message_body; - int in_thread; - int in_subject; - int in_error; - int in_message_error; - int in_iq; - int in_presence; - int in_status; -}; -typedef struct jabber_state_machine_struct jabber_machine; - - -enum TRANSPORT_AUTH_TYPE { AUTH_PLAIN, AUTH_DIGEST }; - -// --------------------------------------------------------------------------------- -// Transport session. This maintains all the various parts of a session -// --------------------------------------------------------------------------------- -struct transport_session_struct { - - /* our socket connection */ - transport_socket* sock_obj; - /* our Jabber state machine */ - jabber_machine* state_machine; - /* our SAX push parser context */ - xmlParserCtxtPtr parser_ctxt; - - /* our text buffers for holding text data */ - growing_buffer* body_buffer; - growing_buffer* subject_buffer; - growing_buffer* thread_buffer; - growing_buffer* from_buffer; - growing_buffer* recipient_buffer; - growing_buffer* status_buffer; - growing_buffer* message_error_type; - growing_buffer* session_id; - int message_error_code; - - /* for OILS extenstions */ - growing_buffer* router_to_buffer; - growing_buffer* router_from_buffer; - growing_buffer* router_class_buffer; - growing_buffer* router_command_buffer; - int router_broadcast; - - /* this can be anything. It will show up in the - callbacks for your convenience. We will *not* - deallocate whatever this is when we're done. That's - your job. - */ - void* user_data; - - int component; /* true if we're a component */ - - /* the Jabber message callback */ - void (*message_callback) ( void* user_data, transport_message* msg ); - //void (iq_callback) ( void* user_data, transport_iq_message* iq ); -}; -typedef struct transport_session_struct transport_session; - - -// ------------------------------------------------------------------ -// Allocates and initializes the necessary transport session -// data structures. -// ------------------------------------------------------------------ -transport_session* init_transport( char* server, int port, void* user_data, int component ); - -// ------------------------------------------------------------------ -// Returns the value of the given XML attribute -// The xmlChar** construct is commonly returned from SAX event -// handlers. Pass that in with the name of the attribute you want -// to retrieve. -// ------------------------------------------------------------------ -char* get_xml_attr( const xmlChar** atts, char* attr_name ); - -// ------------------------------------------------------------------ -// Waits at most 'timeout' seconds for data to arrive from the -// TCP handler. A timeout of -1 means to wait indefinitely. -// ------------------------------------------------------------------ -int session_wait( transport_session* session, int timeout ); - -// --------------------------------------------------------------------------------- -// Sends the given Jabber message -// --------------------------------------------------------------------------------- -int session_send_msg( transport_session* session, transport_message* msg ); - -// --------------------------------------------------------------------------------- -// Returns 1 if this session is connected to the jabber server. 0 otherwise -// --------------------------------------------------------------------------------- -int session_connected( transport_session* ); - -// ------------------------------------------------------------------ -// Deallocates session memory -// ------------------------------------------------------------------ -int session_free( transport_session* session ); - -// ------------------------------------------------------------------ -// Connects to the Jabber server. Waits at most connect_timeout -// seconds before failing -// ------------------------------------------------------------------ -int session_connect( transport_session* session, - const char* username, const char* password, - const char* resource, int connect_timeout, - enum TRANSPORT_AUTH_TYPE auth_type ); - -int session_disconnect( transport_session* session ); - -int reset_session_buffers( transport_session* session ); - -#endif diff --git a/include/opensrf/transport_socket.h b/include/opensrf/transport_socket.h deleted file mode 100644 index a3e9d5f..0000000 --- a/include/opensrf/transport_socket.h +++ /dev/null @@ -1,64 +0,0 @@ -#include "opensrf/generic_utils.h" - -#include -#include -#include -#include - -//--------------------------------------------------------------- -// WIN32 -//--------------------------------------------------------------- -#ifdef WIN32 -#include -#include -#else - -//--------------------------------------------------------------- -// Unix headers -//--------------------------------------------------------------- -#include -#include -#include -#include -#include -#include -#include -#include -#endif - -#ifndef TRANSPORT_SOCKET_H -#define TRANSPORT_SOCKET_H - -/* how many characters we read from the socket at a time */ -#ifdef _ROUTER -#define BUFSIZE 412 -#else -#define BUFSIZE 4096 -#endif - -/* we maintain the socket information */ -struct transport_socket_struct { - int sock_fd; - int connected; - char* server; - int port; - void * user_data; - /* user_data may be anything. it's whatever you wish - to see showing up in the callback in addition to - the acutal character data*/ - void (*data_received_callback) (void * user_data, char*); -}; -typedef struct transport_socket_struct transport_socket; - -int tcp_connect( transport_socket* obj ); -int tcp_send( transport_socket* obj, const char* data ); -int tcp_disconnect( transport_socket* obj ); -int tcp_wait( transport_socket* obj, int timeout ); -int tcp_connected( transport_socket* obj ); - -/* utility methods */ -int set_fl( int fd, int flags ); -int clr_fl( int fd, int flags ); - - -#endif -- 2.43.2