/******************************************************************************* * Copyright (C) 2004-2006 Intel Corp. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * - Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * - Neither the name of Intel Corp. nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. *******************************************************************************/ /** * @author Anas Nashif * @author Eugene Yarmosh * @author Sumeet Kukreja, Dell Inc. * @author Liang Hou */ #ifndef WSMAN_SOAP_H_ #define WSMAN_SOAP_H_ #include "u/hash.h" #include "u/list.h" #include "wsman-faults.h" #include "wsman-soap-message.h" #include "wsman-xml-api.h" #include "wsman-filter.h" #include "wsman-event-pool.h" #include "wsman-subscription-repository.h" #include "wsman-xml-serializer.h" #define SOAP_MAX_RESENT_COUNT 10 #define PEDNING_EVENT_MAX_COUNT 10 #define WS_DISP_TYPE_MASK 0xffff #define WS_DISP_TYPE_RAW_DOC 0 #define WS_DISP_TYPE_GET 1 #define WS_DISP_TYPE_PUT 2 #define WS_DISP_TYPE_CREATE 3 #define WS_DISP_TYPE_DELETE 4 #define WS_DISP_TYPE_ENUMERATE 5 #define WS_DISP_TYPE_PULL 6 #define WS_DISP_TYPE_RELEASE 7 #define WS_DISP_TYPE_UPDATE 8 #define WS_DISP_TYPE_GETSTATUS 9 #define WS_DISP_TYPE_COUNT 11 #define WS_DISP_TYPE_DIRECT_PULL 12 #define WS_DISP_TYPE_DIRECT_GET 13 #define WS_DISP_TYPE_GET_NAMESPACE 14 #define WS_DISP_TYPE_CUSTOM_METHOD 15 #define WS_DISP_TYPE_DIRECT_PUT 16 #define WS_DISP_TYPE_IDENTIFY 17 #define WS_DISP_TYPE_DIRECT_CREATE 18 #define WS_DISP_TYPE_DIRECT_DELETE 19 #define WS_DISP_TYPE_ENUM_REFINSTS 21 #define WS_DISP_TYPE_SUBSCRIBE 22 #define WS_DISP_TYPE_UNSUBSCRIBE 23 #define WS_DISP_TYPE_RENEW 24 #define WS_DISP_TYPE_EVT_PULL 25 #define WS_DISP_TYPE_ACK 26 #define WS_DISP_TYPE_PRIVATE 0xfffe struct __dispatch_t; typedef struct __dispatch_t *SoapDispatchH; typedef SoapDispatchH (*DispatcherCallback) (WsContextH, void *, WsXmlDocH); struct __SoapOp { unsigned __undefined; }; typedef struct __SoapOp *SoapOpH; struct __Soap { /* do not move this field */ pthread_mutex_t lockData; unsigned long uniqueIdCounter; list_t *inboundFilterList; list_t *outboundFilterList; list_t *dispatchList; list_t *processedMsgIdList; pthread_mutex_t lockSubs; //lock for Subscription Repository char *uri_subsRepository; //URI of repository SubsRepositoryOpSetH subscriptionOpSet; //Function talbe of Subscription Repository EventPoolOpSetH eventpoolOpSet; //Function table of event source WsContextH cntx; void *dispatcherData; DispatcherCallback dispatcherProc; void *listener; }; typedef struct __Soap *SoapH; struct _WsXmlDoc { void *parserDoc; unsigned long prefixIndex; // to enumerate not well known namespaces }; struct _WS_CONTEXT_ENTRY { lnode_t *node; unsigned long size; unsigned long options; char *name; }; typedef struct _WS_CONTEXT_ENTRY WS_CONTEXT_ENTRY; struct _WS_CONTEXT { SoapH soap; unsigned long enumIdleTimeout; WsXmlDocH indoc; hash_t *enuminfos; hash_t *entries; WsSerializerContextH serializercntx; list_t *subscriptionMemList; //memory Repository of Subscriptions /* to prevent user from destroying cntx he hasn't created */ int owner; }; typedef struct __WsSubscribeInfo WsSubscribeInfo; // EventThreadContext struct __WsEventThreadContext { SoapH soap; WsSubscribeInfo *subsInfo; WsXmlDocH outdoc; }; typedef struct __WsEventThreadContext * WsEventThreadContextH; typedef void (*WsProcType) (void); struct __XmlSerializerInfo; struct __WsDispatchEndPointInfo { /* put/get/create/delete rpc enumerate/release/pull/update/getstatus */ unsigned long flags; char *rqstName; char *respName; char *inAction; char *outAction; struct __XmlSerializerInfo *serializationInfo; WsProcType serviceEndPoint; void *data; struct __WsSelector *selectors; }; typedef struct __WsDispatchEndPointInfo WsDispatchEndPointInfo; struct __WsSupportedNamespaces { char *ns; char *class_prefix; }; typedef struct __WsSupportedNamespaces WsSupportedNamespaces; struct __WsDispatchInterfaceInfo { unsigned long flags; char *config_id; char *version; char *notes; char *vendor; char *displayName; char *compliance; char *actionUriBase; char *wsmanResourceUri; void *extraData; list_t *namespaces; WsDispatchEndPointInfo *endPoints; }; typedef struct __WsDispatchInterfaceInfo WsDispatchInterfaceInfo; struct __DispatchToEpMap { SoapDispatchH disp; WsDispatchEndPointInfo *ep; }; typedef struct __DispatchToEpMap DispatchToEpMap; struct __WsManDispatcherInfo { int interfaceCount; int mapCount; void *interfaces; DispatchToEpMap map[1]; }; typedef struct __WsManDispatcherInfo WsManDispatcherInfo; typedef struct __WsEnumerateInfo WsEnumerateInfo; typedef int (*WsEndPointSubscribe) (WsContextH,WsSubscribeInfo *, WsmanStatus *, void *); typedef int (*WsEndPointUnSubscribe) (WsContextH,WsSubscribeInfo *, WsmanStatus *, void *); typedef int (*WsEndPointRenew) (WsContextH,WsSubscribeInfo *, WsmanStatus *, void *); typedef int (*WsEndPointEnumerate) (WsContextH, WsEnumerateInfo *, WsmanStatus *, void *); typedef int (*WsEndPointPull) (WsContextH, WsEnumerateInfo *, WsmanStatus *, void *); typedef int (*WsEndPointRelease) (WsContextH, WsEnumerateInfo *, WsmanStatus *, void *); typedef int (*WsEndPointPut) (WsContextH, void *, void **, WsmanStatus *, void *); typedef void *(*WsEndPointGet) (WsContextH, WsmanStatus *, void *); /* return values from wse_send_notification() */ #define WSE_NOTIFICATION_DROPEVENTS 1 #define WSE_NOTIFICATION_DRAOPEVENTS WSE_NOTIFICATION_DROPEVENTS /* sic! */ #define WSE_NOTIFICATION_HEARTBEAT 2 #define WSE_NOTIFICATION_NOACK 3 #define WSE_NOTIFICATION_EVENTS_PENDING 4 typedef int (*WsEndPointEventPoll) (WsEventThreadContextH); typedef int (*WsEndPointSubscriptionCancel) (WsEventThreadContextH); #define EUIDLEN 64 #define WSMAN_ENUMINFO_INWORK_FLAG 0x000010 #define WSMAN_ENUMINFO_POLY_NONE 0x000020 #define WSMAN_ENUMINFO_POLY_INCLUDE 0x000040 #define WSMAN_ENUMINFO_POLY_EXCLUDE 0x000080 #define WSMAN_ENUMINFO_EST_COUNT 0x000100 #define WSMAN_ENUMINFO_OPT 0x000200 #define WSMAN_ENUMINFO_EPR 0x000400 #define WSMAN_ENUMINFO_OBJEPR 0x000800 #define WSMAN_ENUMINFO_EXT 0x001000 #define WSMAN_ENUMINFO_ASSOC 0x020000 #define WSMAN_ENUMINFO_REF 0x040000 #define WSMAN_ENUMINFO_CQL 0x080000 #define WSMAN_ENUMINFO_WQL 0x100000 #define WSMAN_ENUMINFO_SELECTOR 0x200000 #define WSMAN_ENUMINFO_CIM_CONTEXT_CLEANUP 0x400000 #define WSMAN_ENUMINFO_XPATH 0x800000 struct __WsEnumerateInfo { unsigned long flags; char enumId[EUIDLEN]; unsigned long timeStamp; // in msecs unsigned long expires; // expiration time in msecs since the epoch unsigned int totalItems; unsigned int maxItems; unsigned int maxsize; //max envelope size unsigned int index; void *enumResults; void *pullResultPtr; void *appEnumContext; WsmanAuth auth_data; WsEndPointRelease releaseproc; char * epr_to; char * epr_uri; char * encoding; void * aux; void *epr; filter_t *filter; }; #define WSMAN_SUBSCRIBEINFO_UNSUBSCRIBE 0x01 #define WSMAN_SUBSCRIBEINFO_RENEW 0x02 #define WSMAN_SUBSCRIBEINFO_BOOKMARK_DEFAULT 0x04 #define WSMAN_SUBSCRIBEINFO_MANAGER_STARTED 0x08 #define WSMAN_SUBSCRIPTION_CQL 0x10 #define WSMAN_SUBSCRIPTION_WQL 0x20 #define WSMAN_SUBSCRIPTION_SELECTORSET 0x40 #define WSMAN_SUBSCRIPTION_NOTIFICAITON_PENDING 0x80 #define WSMAN_SUBSCRIPTION_CANCELLED 0x100 #define WS_EVENT_DELIVERY_MODE_PUSH 1 /* http://schemas.xmlsoap.org/ws/2004/08/eventing/DeliveryModes/Push */ #define WS_EVENT_DELIVERY_MODE_PUSHWITHACK 2 /* http://schemas.dmtf.org/wbem/wsman/1/wsman/PushWithAck */ #define WS_EVENT_DELIVERY_MODE_EVENTS 3 /* " http://schemas.dmtf.org/wbem/wsman/1/wsman/Events */ #define WS_EVENT_DELIVERY_MODE_PULL 4 /* http://schemas.dmtf.org/wbem/wsman/1/wsman/Pull */ #define WSMAN_SECURITY_PROFILE_HTTP_BASIC_TYPE 1 #define WSMAN_SECURITY_PROFILE_HTTP_DIGEST_TYPE 2 #define WSMAN_SECURITY_PROFILE_HTTPS_BASIC_TYPE 3 #define WSMAN_SECURITY_PROFILE_HTTPS_DIGEST_TYPE 4 #define WSMAN_SECURITY_PROFILE_HTTPS_MUTUAL_TYPE 5 #define WSMAN_SECURITY_PROFILE_HTTPS_MUTUAL_BASIC_TYPE 6 #define WSMAN_SECURITY_PROFILE_HTTPS_MUTUAL_DIGEST_TYPE 7 #define WSMAN_SECURITY_PROFILE_HTTPS_SPNEGO_KERBEROS_TYPE 8 #define WSMAN_SECURITY_PROFILE_HTTPS_MUTUAL_SPNEGO_KERBEROS_TYPE 9 #define WSMAN_SECURITY_PROFILE_HTTP_SPNEGO_KERBEROS_TYPE 10 struct __WsSubscribeInfo { pthread_mutex_t notificationlock; unsigned long flags; long heartbeatCountdown; //countdown of heartbeat, when it is 0, a heartbeat generated char subsId[EUIDLEN]; char * soapNs; char * uri; char * cim_namespace; //CIM namespace void * existingfilterOP; //Object path of existing filter class hash_t * vendor_namespaces; //CIM vendor namespaces; char * epr_notifyto; //A delivery destination for notification messages, using some delivery mode char * username; // username for event sink char * password; // password for event sink char * certificate_thumbprint; //certificate thumbprint of event sink char * locale; // language code char * contentEncoding; //"UTF-8" or "UTF-16" or something else unsigned long expires; int deliveryMode; /*The delivery mode to be used for notification messages sent in relation to this subscription. Implied value is WS_EVENT_DELIVERY_MODE_PUSH, which indicates that Push Mode delivery should be used. */ int deliveryAuthType; // security profile to use when making the connection to delivery events unsigned int connectionRetryCount; // count of connection retry unsigned long connectionRetryinterval; //how long to wait between retries while trying to connect unsigned long heartbeatInterval; //Interval to send a heartbeart unsigned char eventSentLastTime; //To indicate whether an event is sent since last heartbeat WsXmlDocH bookmarkDoc; unsigned char bookmarksFlag; // whether bookmark is needed filter_t *filter; WsmanAuth auth_data; WsEndPointEventPoll eventpoll; // plugin related poll process WsEndPointSubscriptionCancel cancel; //plugin related subscription cancel routine WsXmlDocH templateDoc; //template notificaiton document WsXmlDocH heartbeatDoc; //Fixed heartbeat document }; #if 0 enum __WsmanFilterDialect { WSMAN_FILTER_XPATH, WSMAN_FILTER_SELECTOR }; typedef enum __WsmanFilterDialect WsmanFilterDialect; enum __WsmanPolymorphismMode { INCLUDE_SUBCLASS_PROP = 1, EXCLUDE_SUBCLASS_PROP, POLYMORPHISM_NONE }; typedef enum __WsmanPolymorphismMode WsmanPolymorphismMode; #endif typedef int (*SoapServiceCallback) (SoapOpH, void *, void *); struct __callback_t { lnode_t node; //dataBuf is passed to callback as data SoapServiceCallback proc; }; typedef struct __callback_t callback_t; callback_t * make_callback_entry(SoapServiceCallback proc, void *data, list_t * list_to_add); SoapH ws_soap_initialize(void); void ws_set_context_enumIdleTimeout(WsContextH cntx, unsigned long timeout); void soap_destroy(SoapH soap); SoapH ws_context_get_runtime(WsContextH hCntx); int wsman_register_interface(WsContextH cntx, WsDispatchInterfaceInfo * wsInterface, WsManDispatcherInfo * dispInfo); int wsman_register_endpoint(WsContextH cntx, WsDispatchInterfaceInfo * wsInterface, WsDispatchEndPointInfo * ep, WsManDispatcherInfo * dispInfo); int ws_transfer_put_stub(SoapOpH op, void *appData, void *opaqueData); int ws_transfer_delete_stub(SoapOpH op, void *appData, void *opaqueData); int wsman_identify_stub(SoapOpH op, void *appData, void *opaqueData); int wsenum_enumerate_stub(SoapOpH op, void *appData, void *opaqueData); int ws_transfer_get_stub(SoapOpH op, void *appData, void *opaqueData); int wsenum_pull_stub(SoapOpH op, void *appData, void *opaqueData); int wsenum_pull_direct_stub(SoapOpH op, void *appData, void *opaqueData); int wsenum_release_stub(SoapOpH op, void *appData, void *opaqueData); int wse_subscribe_stub(SoapOpH op, void *appData, void *opaqueData); int wse_unsubscribe_stub(SoapOpH op, void *appData, void *opaqueData); int wse_renew_stub(SoapOpH op, void *appData, void *opaqueData); int wse_pull_stub(SoapOpH op, void *appData, void * opaqueData); SoapOpH soap_create_op(SoapH soap, char *inboundAction, char *outboundAction, char *role, SoapServiceCallback callbackProc, void *callbackData, unsigned long flags); void soap_destroy_op(SoapOpH op); WsXmlDocH soap_get_op_doc(SoapOpH op, int inbound); WsXmlDocH soap_detach_op_doc(SoapOpH op, int inbound); int soap_set_op_doc(SoapOpH op, WsXmlDocH doc, int inbound); SoapH soap_get_op_soap(SoapOpH op); WsContextH ws_create_context(SoapH soap); void ws_initialize_context(WsContextH hCntx, SoapH soap); WsContextH ws_create_runtime(list_t * interfaces); WsContextH ws_create_ep_context(SoapH soap, WsXmlDocH doc); WsContextH ws_get_soap_context(SoapH soap); int ws_destroy_context(WsContextH hCntx); const void *get_context_val(WsContextH hCntx, const char *name); const void *ws_get_context_val(WsContextH cntx, const char *name, int *size); unsigned long ws_get_context_ulong_val(WsContextH cntx, char *name); int ws_set_context_ulong_val(WsContextH cntx, char *name, unsigned long val); int ws_set_context_xml_doc_val(WsContextH cntx, char *name, WsXmlDocH val); int ws_remove_context_val(WsContextH hCntx, char *name); hnode_t * create_context_entry(hash_t * h, char *name, void *val); void destroy_context_entry(WS_CONTEXT_ENTRY * entry); int wsman_fault_occured(WsmanMessage * msg); WsmanKnownStatusCode wsman_find_httpcode_for_value(WsXmlDocH doc); WsmanKnownStatusCode wsman_find_httpcode_for_fault_code(WsmanFaultCodeType faultCode); WsXmlDocH wsman_generate_fault(WsXmlDocH inDoc, WsmanFaultCodeType faultCode, WsmanFaultDetailType faultDetail, char *fault_msg); void wsman_get_fault_status_from_doc(WsXmlDocH doc,WsmanStatus* status) ; void wsman_generate_fault_buffer( WsXmlDocH inDoc, const char *encoding, WsmanFaultCodeType faultCode, WsmanFaultDetailType faultDetail, char *fault_msg, char **buf, int *len); void wsman_status_init(WsmanStatus * s); int wsman_check_status(WsmanStatus * s); void wsman_timeouts_manager(WsContextH cntx, void *opaqueData); void wsman_heartbeat_generator(WsContextH cntx, void *opaqueData); WsEventThreadContextH ws_create_event_context(SoapH soap, WsSubscribeInfo *subsInfo, WsXmlDocH doc); void * wse_notification_sender(void * thrdcntx); void *wse_heartbeat_sender(void * thrdcntx); void wse_notification_manager(void * cntx); int outbound_addressing_filter(SoapOpH opHandle, void *data, void *opaqueData); int outbound_control_header_filter(SoapOpH opHandle, void *data, void *opaqueData); int soap_add_filter(SoapH soap, SoapServiceCallback callbackProc, void *callbackData, int inbound); WsmanMessage *wsman_get_msg_from_op(SoapOpH op) ; unsigned long wsman_get_maxsize_from_op(SoapOpH op); #endif /* SOAP_API_H_ */