cmpift.h

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

	 @return Service return status.
     */
      CMPIStatus (*detachThread)
      (const CMPIBroker * mb, const CMPIContext * ctx);

    // class 0 services

      /** This function requests delivery of an Indication. The CIMOM will
         locate pertinent subscribers and notify them about the event.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param ns Namespace
	 @param ind Indication Instance
	 @return Service return status.
     */
      CMPIStatus (*deliverIndication)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const char *ns, const CMPIInstance * ind);
    // class 1 services

      /** Enumerate Instance Names of the class (and subclasses) defined by <op>.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op ObjectPath containing namespace and classname components.
	 @param rc Output: Service return status (suppressed when NULL).
	 @return Enumeration of ObjectPathes.
     */
    CMPIEnumeration *(*enumInstanceNames)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, CMPIStatus * rc);

      /** Get Instance using <op> as reference. Instance structure can be
         controled using the CMPIInvocationFlags entry in <ctx>.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op ObjectPath containing namespace, classname and key components.
	 @param properties If not NULL, the members of the array define one or more Property
	     names. Each returned Object MUST NOT include elements for any Properties
	     missing from this list
	 @param rc Output: Service return status (suppressed when NULL).
	 @return The Instance.
     */
    CMPIInstance *(*getInstance)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const char **properties, CMPIStatus * rc);

    // class 2 services

      /** Create Instance from <inst> using <op> as reference.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op ObjectPath containing namespace, classname and key components.
	 @param inst Complete instance.
	 @param rc Output: Service return status (suppressed when NULL).
	 @return The assigned instance reference.
     */
    CMPIObjectPath *(*createInstance)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const CMPIInstance * inst, CMPIStatus * rc);

      /** Replace an existing Instance from <inst> using <op> as reference.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op ObjectPath containing namespace, classname and key components.
	 @param inst Complete instance.
	 @return Service return status.
     */
      CMPIStatus (*modifyInstance)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const CMPIInstance * inst,
       const char **properties);

      /** Delete an existing Instance using <op> as reference.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op ObjectPath containing namespace, classname and key components.
	 @return Service return status.
     */
      CMPIStatus (*deleteInstance)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op);

      /** Query the enumeration of instances of the class (and subclasses) defined
         by <op> using <query> expression.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op ObjectPath containing namespace and classname components.
	 @param query Query expression
	 @param lang Query Language
	 @param rc Output: Service return status (suppressed when NULL).
	 @return Resulting eumeration of Instances.
     */
    CMPIEnumeration *(*execQuery)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const char *query, const char *lang,
       CMPIStatus * rc);

      /** Enumerate Instances of the class (and subclasses) defined by <op>.
         Instance structure and inheritance scope can be controled using the
	 CMPIInvocationFlags entry in <ctx>.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op ObjectPath containing namespace and classname components.
	 @param properties If not NULL, the members of the array define one or more Property
	     names. Each returned Object MUST NOT include elements for any Properties
	     missing from this list
	 @param rc Output: Service return status (suppressed when NULL).
	 @return Enumeration of Instances.
     */
    CMPIEnumeration *(*enumInstances)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const char **properties, CMPIStatus * rc);

      /** Enumerate instances associated with the Instance defined by the <op>.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op Source ObjectPath containing namespace, classname and key components.
	 @param assocClass If not NULL, MUST be a valid Association Class name.
	    It acts as a filter on the returned set of Objects by mandating that
	    each returned Object MUST be associated to the source Object via an
	    Instance of this Class or one of its subclasses.
	 @param resultClass If not NULL, MUST be a valid Class name.
	    It acts as a filter on the returned set of Objects by mandating that
	    each returned Object MUST be either an Instance of this Class (or one
	    of its subclasses).
	 @param role If not NULL, MUST be a valid Property name.
	    It acts as a filter on the returned set of Objects by mandating
	    that each returned Object MUST be associated to the source Object
	    via an Association in which the source Object plays the specified role
	    (i.e. the name of the Property in the Association Class that refers
	    to the source Object MUST match the value of this parameter).
	 @param resultRole If not NULL, MUST be a valid Property name.
	    It acts as a filter on the returned set of Objects by mandating
	    that each returned Object MUST be associated to the source Object
	    via an Association in which the returned Object plays the specified role
	    (i.e. the name of the Property in the Association Class that refers to
	    the returned Object MUST match the value of this parameter).
	 @param properties If not NULL, the members of the array define one or more Property
	     names. Each returned Object MUST NOT include elements for any Properties
	     missing from this list
	 @param rc Output: Service return status (suppressed when NULL).
	 @return Enumeration of Instances.
     */
    CMPIEnumeration *(*associators)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const char *assocClass,
       const char *resultClass, const char *role, const char *resultRole,
       const char **properties, CMPIStatus * rc);

      /** Enumerate ObjectPaths associated with the Instance defined by <op>.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op Source ObjectPath containing namespace, classname and key components.
	 @param assocClass If not NULL, MUST be a valid Association Class name.
	    It acts as a filter on the returned set of Objects by mandating that
	    each returned Object MUST be associated to the source Object via an
	    Instance of this Class or one of its subclasses.
	 @param resultClass If not NULL, MUST be a valid Class name.
	    It acts as a filter on the returned set of Objects by mandating that
	    each returned Object MUST be either an Instance of this Class (or one
	    of its subclasses).
	 @param role If not NULL, MUST be a valid Property name.
	    It acts as a filter on the returned set of Objects by mandating
	    that each returned Object MUST be associated to the source Object
	    via an Association in which the source Object plays the specified role
	    (i.e. the name of the Property in the Association Class that refers
	    to the source Object MUST match the value of this parameter).
	 @param resultRole If not NULL, MUST be a valid Property name.
	    It acts as a filter on the returned set of Objects by mandating
	    that each returned Object MUST be associated to the source Object
	    via an Association in which the returned Object plays the specified role
	    (i.e. the name of the Property in the Association Class that refers to
	    the returned Object MUST match the value of this parameter).
	 @param rc Output: Service return status (suppressed when NULL).
	 @return Enumeration of ObjectPaths.
     */
    CMPIEnumeration *(*associatorNames)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const char *assocClass,
       const char *resultClass, const char *role, const char *resultRole,
       CMPIStatus * rc);

       /** Enumerates the association instances that refer to the instance defined by
           <op>.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op Source ObjectPath containing namespace, classname and key components.
	 @param resultClass If not NULL, MUST be a valid Class name.
	    It acts as a filter on the returned set of Objects by mandating that
	    each returned Object MUST be either an Instance of this Class (or one
	    of its subclasses).
	 @param role If not NULL, MUST be a valid Property name.
	    It acts as a filter on the returned set of Objects by mandating
	    that each returned Object MUST be associated to the source Object
	    via an Association in which the source Object plays the specified role
	    (i.e. the name of the Property in the Association Class that refers
	    to the source Object MUST match the value of this parameter).
	 @param properties If not NULL, the members of the array define one or more Property
	     names. Each returned Object MUST NOT include elements for any Properties
	     missing from this list
	 @param rc Output: Service return status (suppressed when NULL).
	 @return Enumeration of ObjectPaths.
     */
    CMPIEnumeration *(*references)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const char *resultClass, const char *role,
       const char **properties, CMPIStatus * rc);

       /** Enumerates the association ObjectPaths that refer to the instance defined by
           <op>.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op Source ObjectPath containing namespace, classname and key components.
	 @param resultClass If not NULL, MUST be a valid Class name.
	    It acts as a filter on the returned set of Objects by mandating that
	    each returned Object MUST be either an Instance of this Class (or one
	    of its subclasses).
	 @param role If not NULL, MUST be a valid Property name.
	    It acts as a filter on the returned set of Objects by mandating
	    that each returned Object MUST be associated to the source Object
	    via an Association in which the source Object plays the specified role
	    (i.e. the name of the Property in the Association Class that refers
	    to the source Object MUST match the value of this parameter).
	 @param rc Output: Service return status (suppressed when NULL).
	 @return Enumeration of ObjectPaths.
       */
    CMPIEnumeration *(*referenceNames)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const char *resultClass, const char *role,
       CMPIStatus * rc);

       /** Invoke a named, extrinsic method of an Instance
         defined by the <op> parameter.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op ObjectPath containing namespace, classname and key components.
	 @param method Method name
	 @param in Input parameters.
	 @param out Output parameters.
	 @param rc Output: Service return status (suppressed when NULL).
	 @return Method return value.
      */
      CMPIData (*invokeMethod)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const char *method,
       const CMPIArgs * in, CMPIArgs * out, CMPIStatus * rc);

       /** Set the named property value of an Instance defined by the <op> parameter.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op ObjectPath containing namespace, classname and key components.
	 @param name Property name
	 @param value Value.
	 @param type Value type.
	 @return Service return status.
      */
      CMPIStatus (*setProperty)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const char *name, const CMPIValue * value,
       CMPIType type);

       /** Get the named property value of an Instance defined by the <op> parameter.
	 @param mb Pointer to the broker.
	 @param ctx Context object
	 @param op ObjectPath containing namespace, classname and key components.
	 @param name Property name
	 @param rc Output: Service return status (suppressed when NULL).
	 @return Property value.
      */
      CMPIData (*getProperty)
      (const CMPIBroker * mb, const CMPIContext * ctx,
       const CMPIObjectPath * op, const char *name, CMPIStatus * rc);
  };


  //---------------------------------------------------
  //--
  //   _CMPIBrokerExtFT Function Table
  //--
  //---------------------------------------------------

#   ifdef CMPI_VER_90

  struct timespec;

   /** This structure is a table of pointers to extended broker CIMOM
       services This table is made available by the Management Broker,
       whenever a provider is loaded and initialized.
       This is an extension used by Pegasus to support platform dependencies.
   */
  struct _CMPIBrokerExtFT
  {
     /** Function table version
     */
    int ftVersion;
	/**
	This function complements a generic dynamic library nameto its OS-dependent native format.
	@param filename Pointer to the generic library name,
	@return The returned char* pointer points to the complemented library name in native OS format.
		Space for this string has been obtained using malloc() and must be released using free() by the caller.
		 In case no storage could be obtained for the complemented library name, NULL will be
		 returned.
	*/
    char *(*resolveFileName) (const char *filename);


       /** Start a new thread using the POSIX threading semantics. 
	 @param start Pointer to the function to be started as a thread.
	 @param param Pointer to the function to be started as a thread.
	 @param detached If not zero, defines that the thread should run in detached mode.
	 @return The return value is the thread ID.
	 */
      CMPI_THREAD_TYPE (*newThread)
      (CMPI_THREAD_RETURN (CMPI_THREAD_CDECL * start) (void *), void *parm,
       int detached);

        /** Waits until the specified thread ends using the POSIX threading semantics.
 	@param thread The thread ID of the thread waiting for completion.
 	@param retval Pointer to the return value of the thread.
	@return Completion code as defined by POSIX threading semantics (pthread_join)
	*/
    int (*joinThread) (CMPI_THREAD_TYPE thread, CMPI_THREAD_RETURN * retval);

        /** Causes the current thread to exit with the passed in return code using POSIX threading semantics.
    @param return_code Is the return code that should be used for the thread.  
	@return The function never exits.
	*/
    int (*exitThread) (CMPI_THREAD_RETURN return_code);

        /** Cancel the thread using the POSIX threading semantics.
 	 @param thread  The thread to be canceled.
	 @return Completion code as defined by POSIX threading semantics (pthread_cancel)
	*/
    int (*cancelThread) (CMPI_THREAD_TYPE thread);

        /** Suspends the execution of the current thread for the specified duration.
     @param msec The suspend duration in milliseconds.
	@return Completion code as defined by POSIX threading semantics (pthread_sleep)
	*/
    int (*threadSleep) (CMPIUint32 msec);