(file) Return to ModuleController.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/ModuleController.h between version 1.13 and 1.17

version 1.13, 2002/03/29 17:36:41 version 1.17, 2002/04/01 22:58:52
Line 38 
Line 38 
 #include <Pegasus/Common/Cimom.h> #include <Pegasus/Common/Cimom.h>
 #include <Pegasus/Common/CimomMessage.h> #include <Pegasus/Common/CimomMessage.h>
 #include <Pegasus/Common/MessageQueueService.h> #include <Pegasus/Common/MessageQueueService.h>
   #include <Pegasus/Common/peg_authorization.h>
  
 #include <bitset>  
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 class ModuleController; class ModuleController;
  
  
 class PEGASUS_COMMON_LINKAGE pegasus_module  class PEGASUS_COMMON_LINKAGE pegasus_module : pegasus_authorization_handle
 { {
    private:    private:
       class PEGASUS_COMMON_LINKAGE module_rep        class module_rep
       {       {
          public:          public:
             module_rep(ModuleController *controller,             module_rep(ModuleController *controller,
Line 61 
Line 61 
  
             ~module_rep(void) ;             ~module_rep(void) ;
  
   
             Boolean operator == (const module_rep *rep) const             Boolean operator == (const module_rep *rep) const
             { if (rep == this ) return true; return false; }             { if (rep == this ) return true; return false; }
  
Line 87 
Line 86 
          private:          private:
             module_rep(void);             module_rep(void);
             module_rep(const module_rep & );             module_rep(const module_rep & );
             module_rep& operator= (const module_rep & );              module_rep & operator= (const module_rep & rep);
   
  
             Mutex _thread_safety;             Mutex _thread_safety;
             ModuleController *_controller;             ModuleController *_controller;
Line 119 
Line 119 
       };       };
  
    public:    public:
         typedef pegasus_authorization_handle Base;
  
       pegasus_module(ModuleController *controller,       pegasus_module(ModuleController *controller,
                      const String &id,                      const String &id,
Line 127 
Line 128 
                      void (*async_callback)(Uint32, Message *, void *),                      void (*async_callback)(Uint32, Message *, void *),
                      void (*shutdown_notify)(Uint32 code, void *)) ;                      void (*shutdown_notify)(Uint32 code, void *)) ;
  
         pegasus_module(const pegasus_module & mod);
         pegasus_module & operator= (const pegasus_module & mod);
   
       ~pegasus_module(void);       ~pegasus_module(void);
  
       pegasus_module & operator= (const pegasus_module & mod);        virtual Boolean authorized(pegasus_base_identity *id, Uint32 operation);
         virtual Boolean authorized(pegasus_base_identity *id);
   
       Boolean operator == (const pegasus_module *mod) const;       Boolean operator == (const pegasus_module *mod) const;
       Boolean operator == (const pegasus_module & mod) const ;       Boolean operator == (const pegasus_module & mod) const ;
       Boolean operator == (const String &  mod) const;       Boolean operator == (const String &  mod) const;
Line 140 
Line 146 
       // introspection interface       // introspection interface
       Boolean query_interface(const String & class_id, void **object_ptr) const;       Boolean query_interface(const String & class_id, void **object_ptr) const;
  
    private:  
  
      private:
         pegasus_base_identity *_id;
       module_rep *_rep;       module_rep *_rep;
   
       pegasus_module(void);       pegasus_module(void);
       pegasus_module(const pegasus_module & mod);  
       Boolean _rcv_msg(Message *) ;       Boolean _rcv_msg(Message *) ;
       Message * _receive_message(Message *msg);       Message * _receive_message(Message *msg);
       void _send_async_callback(Uint32 msg_handle, Message *msg) ;       void _send_async_callback(Uint32 msg_handle, Message *msg) ;
       void _send_shutdown_notify(void);       void _send_shutdown_notify(void);
       Boolean _shutdown(void);       Boolean _shutdown(void);
         bitset<32> _allowed_operations;
  
       void reference(void) { _rep->reference(); }       void reference(void) { _rep->reference(); }
       void dereference(void)  { _rep->dereference(); }       void dereference(void)  { _rep->dereference(); }
Line 164 
Line 172 
    public:    public:
       typedef MessageQueueService Base;       typedef MessageQueueService Base;
  
       enum        static const Uint32 GET_CLIENT_HANDLE;
       {        static const Uint32 REGISTER_MODULE;
          GET_CLIENT_HANDLE,        static const Uint32 DEREGISTER_MODULE;
          REGISTER_MODULE,        static const Uint32 FIND_SERVICE;
          DEREGISTER_MODULE,        static const Uint32 FIND_MODULE_IN_SERVICE;
          FIND_SERVICE,        static const Uint32 GET_MODULE_REFERENCE;
          FIND_MODULE_IN_SERVICE,        static const Uint32 MODULE_SEND_WAIT;
          GET_MODULE_REFERENCE,        static const Uint32 MODULE_SEND_WAIT_MODULE;
          MODULE_SEND_WAIT,        static const Uint32 MODULE_SEND_ASYNC;
          MODULE_SEND_WAIT_MODULE,        static const Uint32 MODULE_SEND_ASYNC_MODULE;
          MODULE_SEND_ASYNC,        static const Uint32 BLOCKING_THREAD_EXEC;
          MODULE_SEND_ASYNC_MODULE,        static const Uint32 ASYNC_THREAD_EXEC;
          BLOCKING_THREAD_EXEC,        static const Uint32 CLIENT_SEND_WAIT;
          ASYNC_THREAD_EXEC,        static const Uint32 CLIENT_SEND_WAIT_MODULE;
          NUMBER_OPERATIONS        static const Uint32 CLIENT_SEND_ASYNC;
       } ;        static const Uint32 CLIENT_SEND_ASYNC_MODULE;
         static const Uint32 CLIENT_BLOCKING_THREAD_EXEC;
         static const Uint32 CLIENT_ASYNC_THREAD_EXEC;
   
   
    private:    private:
       class PEGASUS_COMMON_LINKAGE client_handle        class client_handle : pegasus_authorization_handle
       {       {
          public:          public:
               typedef pegasus_authorization_handle Base;
   
             client_handle(void)             client_handle(void)
                : _allowed_operations(0),                 :Base(),
                  _allowed_destinations(0),                  _id(new pegasus_internal_identity(peg_credential_types::SERVICE)),
                  _allowed_sources(0),                  allowed_operations( GET_CLIENT_HANDLE |
                  _identity(NULL)                                      FIND_SERVICE |
                                       FIND_MODULE_IN_SERVICE |
                                       GET_MODULE_REFERENCE |
                                       CLIENT_SEND_WAIT |
                                       CLIENT_SEND_WAIT_MODULE |
                                       CLIENT_SEND_ASYNC |
                                       CLIENT_SEND_ASYNC_MODULE |
                                       CLIENT_BLOCKING_THREAD_EXEC |
                                       CLIENT_ASYNC_THREAD_EXEC)
             {             {
             }  
  
             ~client_handle(void);              }
  
          private:              client_handle(pegasus_base_identity *id)
             friend class ModuleController;                 :Base(), _id(id)
             client_handle(Uint32 operations,  
                           Uint32 destinations,  
                           Uint32 sources,  
                           void *identity)  
                : _allowed_operations(operations),  
                  _allowed_destinations(destinations),  
                  _allowed_sources(sources),  
                  _identity(identity)  
             {             {
                  if( id && (id->get_base_id_type() == peg_identity_types::INTERNAL ))
                  {
                     if (id->get_base_cred_type() == peg_credential_types::SERVICE )
                        allowed_operations = ModuleController::CLIENT_SEND_WAIT |
                                             ModuleController::CLIENT_SEND_WAIT_MODULE |
                                             ModuleController::CLIENT_SEND_ASYNC |
                                             ModuleController::CLIENT_SEND_ASYNC_MODULE |
                                             ModuleController::CLIENT_BLOCKING_THREAD_EXEC |
                                             ModuleController::CLIENT_ASYNC_THREAD_EXEC;
                     else
                        allowed_operations = 0;
             }             }
  
             bitset<NUMBER_OPERATIONS>  _allowed_operations;              }
             bitset<128> _allowed_destinations;              ~client_handle(void)
             bitset<128> _allowed_sources;  
             void *_identity;  
   
             Boolean allowed(Uint32 operation,  
                             Uint32 destination,  
                             Uint32 source,  
                             void *identity)  
             {             {
                return true;                 delete _id;
             }             }
   
               virtual Boolean authorized(Uint32 operation);
               virtual Boolean authorized(void);
   
            private:
               pegasus_base_identity *_id;
               bitset<64> allowed_operations;
       };       };
  
    public:    public:
Line 293 
Line 317 
       void async_thread_exec(pegasus_module & handle,       void async_thread_exec(pegasus_module & handle,
                              PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),                              PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                              void *parm) throw(Permission, Deadlock, IPCException);                              void *parm) throw(Permission, Deadlock, IPCException);
   
       Boolean verify_handle(pegasus_module *);       Boolean verify_handle(pegasus_module *);
    protected:    protected:
       // ATTN-RK-P2-20010322:  These methods are pure virtual in superclass       // ATTN-RK-P2-20010322:  These methods are pure virtual in superclass

Legend:
Removed from v.1.13  
changed lines
  Added in v.1.17
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2