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

Diff for /pegasus/src/Pegasus/Common/Executor.cpp between version 1.1.2.4 and 1.1.2.12

version 1.1.2.4, 2007/01/02 19:14:09 version 1.1.2.12, 2007/01/09 20:25:40
Line 54 
Line 54 
 #include "Mutex.h" #include "Mutex.h"
 #include "FileSystem.h" #include "FileSystem.h"
 #include "String.h" #include "String.h"
 #include <Pegasus/Security/Cimservera/Strlcpy.h>  #include <Executor/Strlcpy.h>
 #include <Pegasus/Security/Cimservera/Strlcat.h>  #include <Executor/Strlcat.h>
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
 # include <Executor/Executor.h>  # include <Executor/Messages.h>
 #endif #endif
  
 #if defined(PEGASUS_PAM_AUTHENTICATION) #if defined(PEGASUS_PAM_AUTHENTICATION)
 # include <Pegasus/Security/Cimservera/cimservera.h>  # include <Executor/PAMAuth.h>
 #endif #endif
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 82 
Line 82 
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //// ////
 //// InProcess stubs:  //// Loopback stubs:
 //// ////
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 static int InProcess_ping()  static int Loopback_ping()
 { {
     // Nothing to do.     // Nothing to do.
     return 0;     return 0;
 } }
  
 FILE* InProcess_openFile(  FILE* Loopback_openFile(
     const char* path,     const char* path,
     int mode)     int mode)
 { {
Line 105 
Line 105 
         case 'w':         case 'w':
             return fopen(path, "wb");             return fopen(path, "wb");
  
           case 'a':
               return fopen(path, "a+");
   
         default:         default:
             return NULL;             return NULL;
     }     }
 } }
  
 static int InProcess_renameFile(  static int Loopback_renameFile(
     const char* oldPath,     const char* oldPath,
     const char* newPath)     const char* newPath)
 { {
     return FileSystem::renameFile(oldPath, newPath) ? 0 : -1;     return FileSystem::renameFile(oldPath, newPath) ? 0 : -1;
 } }
  
 static int InProcess_removeFile(  static int Loopback_removeFile(
     const char* path)     const char* path)
 { {
     return FileSystem::removeFile(path) ? 0 : -1;     return FileSystem::removeFile(path) ? 0 : -1;
Line 145 
Line 148 
  
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
  
 static int InProcess_startProviderAgent(  static int Loopback_startProviderAgent(
     const char* module,     const char* module,
     int uid,     int uid,
     int gid,     int gid,
Line 238 
Line 241 
  
 #elif defined(PEGASUS_OS_OS400) #elif defined(PEGASUS_OS_OS400)
  
 static int InProcess_startProviderAgent(  static int Loopback_startProviderAgent(
     const char* module,     const char* module,
     int uid,     int uid,
     int gid,     int gid,
Line 252 
Line 255 
  
 #else /* POSIX CASE FOLLOWS */ #else /* POSIX CASE FOLLOWS */
  
 static int InProcess_startProviderAgent(  static int Loopback_startProviderAgent(
       const SessionKey& sessionKey,
     const char* module,     const char* module,
     int uid,     int uid,
     int gid,     int gid,
     int& pid,     int& pid,
       SessionKey& providerAgentSessionKey,
     AnonymousPipe*& readPipe,     AnonymousPipe*& readPipe,
     AnonymousPipe*& writePipe)     AnonymousPipe*& writePipe)
 { {
Line 264 
Line 269 
  
     // Initialize output parameters in case of error.     // Initialize output parameters in case of error.
  
       providerAgentSessionKey.clear();
     pid = -1;     pid = -1;
     readPipe = 0;     readPipe = 0;
     writePipe = 0;     writePipe = 0;
Line 395 
Line 401 
  
 #endif /* !defined(START_PROVIDER_AGENT) */ #endif /* !defined(START_PROVIDER_AGENT) */
  
 static int InProcess_daemonizeExecutor()  static int Loopback_daemonizeExecutor()
 { {
     // Nothing to do.     // Nothing to do.
     return 0;     return 0;
 } }
  
 static int InProcess_changeOwner(  static int Loopback_changeOwner(
     const char* path,     const char* path,
     const char* owner)     const char* owner)
 { {
     return FileSystem::changeFileOwner(path, owner) ? 0 : -1;     return FileSystem::changeFileOwner(path, owner) ? 0 : -1;
 } }
  
 static int InProcess_waitPid(  static int Loopback_reapProviderAgent(
       const SessionKey& sessionKey,
     int pid)     int pid)
 { {
     int status;     int status;
Line 419 
Line 426 
     return status;     return status;
 } }
  
 static int InProcess_pamAuthenticate(  static int Loopback_authenticatePassword(
     const char* username,     const char* username,
     const char* password)      const char* password,
       SessionKey& sessionKey)
 { {
       sessionKey.clear();
   
 #if defined(PEGASUS_PAM_AUTHENTICATION) #if defined(PEGASUS_PAM_AUTHENTICATION)
     return PAMAuthenticate(username, password);     return PAMAuthenticate(username, password);
 #else #else
Line 430 
Line 440 
 #endif #endif
 } }
  
 static int InProcess_pamValidateUser(  static int Loopback_validateUser(
     const char* username)     const char* username)
 { {
 #if defined(PEGASUS_PAM_AUTHENTICATION) #if defined(PEGASUS_PAM_AUTHENTICATION)
Line 575 
Line 585 
     return 0;     return 0;
 } }
  
 static int OutOfProcess_ping()  static int Socket_ping()
 { {
     AutoMutex autoMutex(_mutex);     AutoMutex autoMutex(_mutex);
  
     // _send request header:     // _send request header:
  
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_PING_REQUEST;      header.code = EXECUTOR_PING_MESSAGE;
  
     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
Line 598 
Line 608 
     return -1;     return -1;
 } }
  
 FILE* OutOfProcess_openFile(  FILE* Socket_openFile(
     const char* path,     const char* path,
     int mode)     int mode)
 { {
     AutoMutex autoMutex(_mutex);     AutoMutex autoMutex(_mutex);
  
     if (mode != 'r' && mode != 'w')      if (mode != 'r' && mode != 'w' && mode != 'a')
         return NULL;         return NULL;
  
     // _send request header:     // _send request header:
  
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_OPEN_FILE_REQUEST;      header.code = EXECUTOR_OPEN_FILE_MESSAGE;
  
     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return NULL;         return NULL;
Line 655 
Line 665 
     return NULL;     return NULL;
 } }
  
 static int OutOfProcess_renameFile(  static int Socket_renameFile(
     const char* oldPath,     const char* oldPath,
     const char* newPath)     const char* newPath)
 { {
Line 664 
Line 674 
     // _send request header:     // _send request header:
  
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_RENAME_FILE_REQUEST;      header.code = EXECUTOR_RENAME_FILE_MESSAGE;
  
     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
Line 689 
Line 699 
     return response.status;     return response.status;
 } }
  
 static int OutOfProcess_removeFile(  static int Socket_removeFile(
     const char* path)     const char* path)
 { {
     AutoMutex autoMutex(_mutex);     AutoMutex autoMutex(_mutex);
Line 697 
Line 707 
     // _send request header:     // _send request header:
  
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_REMOVE_FILE_REQUEST;      header.code = EXECUTOR_REMOVE_FILE_MESSAGE;
  
     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
Line 721 
Line 731 
     return response.status;     return response.status;
 } }
  
 static int OutOfProcess_startProviderAgent(  static int Socket_startProviderAgent(
       const SessionKey& sessionKey,
     const char* module,     const char* module,
     int uid,     int uid,
     int gid,     int gid,
     int& pid,     int& pid,
       SessionKey& providerAgentSessionKey,
     AnonymousPipe*& readPipe,     AnonymousPipe*& readPipe,
     AnonymousPipe*& writePipe)     AnonymousPipe*& writePipe)
 { {
     AutoMutex autoMutex(_mutex);     AutoMutex autoMutex(_mutex);
  
       providerAgentSessionKey.clear();
     readPipe = 0;     readPipe = 0;
     writePipe = 0;     writePipe = 0;
  
Line 744 
Line 757 
     // _send request header:     // _send request header:
  
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_START_PROVIDER_AGENT_REQUEST;      header.code = EXECUTOR_START_PROVIDER_AGENT_MESSAGE;
  
     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
Line 753 
Line 766 
  
     ExecutorStartProviderAgentRequest request;     ExecutorStartProviderAgentRequest request;
     memset(&request, 0, sizeof(request));     memset(&request, 0, sizeof(request));
       Strlcpy(request.key, sessionKey.data(), sizeof(request.key));
     memcpy(request.module, module, n);     memcpy(request.module, module, n);
     request.uid = uid;     request.uid = uid;
     request.gid = gid;     request.gid = gid;
Line 767 
Line 781 
     if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))     if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
       // Get the session key.
   
       Strlcpy((char*)providerAgentSessionKey.data(),
           response.key, providerAgentSessionKey.size());
   
     // Check response status and pid.     // Check response status and pid.
  
     if (response.status != 0)     if (response.status != 0)
Line 801 
Line 820 
     return result;     return result;
 } }
  
 static int OutOfProcess_daemonizeExecutor()  static int Socket_daemonizeExecutor()
 { {
     AutoMutex autoMutex(_mutex);     AutoMutex autoMutex(_mutex);
  
     // _send request header:     // _send request header:
  
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_DAEMONIZE_EXECUTOR_REQUEST;      header.code = EXECUTOR_DAEMONIZE_EXECUTOR_MESSAGE;
  
     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
Line 823 
Line 842 
     return response.status;     return response.status;
 } }
  
 static int OutOfProcess_changeOwner(  static int Socket_reapProviderAgent(
     const char* path,      const SessionKey& sessionKey,
     const char* owner)      int pid)
 { {
     AutoMutex autoMutex(_mutex);     AutoMutex autoMutex(_mutex);
  
     // _send request header:     // _send request header:
  
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_CHANGE_OWNER_REQUEST;      header.code = EXECUTOR_REAP_PROVIDER_AGENT;
  
     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // _send request body:     // _send request body:
  
     ExecutorChangeOwnerRequest request;      ExecutorReapProviderAgentRequest request;
     Strlcpy(request.path, path, sizeof(request.path));      memset(&request, 0, sizeof(request));
     Strlcpy(request.owner, owner, sizeof(request.owner));      Strlcpy(request.key, sessionKey.data(), sizeof(request.key));
       request.pid = pid;
  
     if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))     if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))
         return -1;         return -1;
  
     // Receive the response     // Receive the response
  
     ExecutorChangeOwnerResponse response;      ExecutorReapProviderAgentResponse response;
  
     if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))     if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
Line 856 
Line 876 
     return response.status;     return response.status;
 } }
  
 static int OutOfProcess_waitPid(  static int Socket_authenticatePassword(
     int pid)      const char* username,
       const char* password,
       SessionKey& sessionKey)
 { {
     AutoMutex autoMutex(_mutex);     AutoMutex autoMutex(_mutex);
  
       sessionKey.clear();
   
     // _send request header:     // _send request header:
  
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_WAIT_PID_REQUEST;      header.code = EXECUTOR_AUTHENTICATE_PASSWORD_MESSAGE;
  
     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // _send request body:      // _send request body.
  
     ExecutorWaitPidRequest request;      ExecutorAuthenticatePasswordRequest request;
     request.pid = pid;      memset(&request, 0, sizeof(request));
       Strlcpy(request.username, username, EXECUTOR_BUFFER_SIZE);
       Strlcpy(request.password, password, EXECUTOR_BUFFER_SIZE);
  
     if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))     if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))
         return -1;         return -1;
  
     // Receive the response     // Receive the response
  
     ExecutorWaitPidResponse response;      ExecutorAuthenticatePasswordResponse response;
  
     if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))     if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
       Strlcpy((char*)sessionKey.data(), response.key, sessionKey.size());
   
     return response.status;     return response.status;
 } }
  
 static int OutOfProcess_pamAuthenticate(  static int Socket_validateUser(
     const char* username,      const char* username)
     const char* password)  
 { {
     AutoMutex autoMutex(_mutex);     AutoMutex autoMutex(_mutex);
  
     // _send request header:     // _send request header:
  
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_PAM_AUTHENTICATE_REQUEST;      header.code = EXECUTOR_VALIDATE_USER_MESSAGE;
  
     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // _send request body.     // _send request body.
  
     ExecutorPAMAuthenticateRequest request;      ExecutorValidateUserRequest request;
     memset(&request, 0, sizeof(request));     memset(&request, 0, sizeof(request));
     Strlcpy(request.username, username, EXECUTOR_BUFFER_SIZE);     Strlcpy(request.username, username, EXECUTOR_BUFFER_SIZE);
     Strlcpy(request.password, password, EXECUTOR_BUFFER_SIZE);  
  
     if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))     if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))
         return -1;         return -1;
  
     // Receive the response     // Receive the response
  
     ExecutorPAMAuthenticateResponse response;      ExecutorValidateUserResponse response;
  
     if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))     if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
Line 921 
Line 947 
     return response.status;     return response.status;
 } }
  
 static int OutOfProcess_pamValidateUser(  int Socket_challengeLocal(
     const char* username)      const char* user,
       char challenge[EXECUTOR_BUFFER_SIZE],
       SessionKey& sessionKey)
 { {
     AutoMutex autoMutex(_mutex);     AutoMutex autoMutex(_mutex);
  
       sessionKey.clear();
   
     // _send request header:     // _send request header:
  
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_PAM_VALIDATE_USER_REQUEST;      header.code = EXECUTOR_CHALLENGE_LOCAL_MESSAGE;
  
     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))     if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // _send request body.     // _send request body.
  
     ExecutorPAMValidateUserRequest request;      ExecutorChallengeLocalRequest request;
     memset(&request, 0, sizeof(request));     memset(&request, 0, sizeof(request));
     Strlcpy(request.username, username, EXECUTOR_BUFFER_SIZE);      Strlcpy(request.user, user, EXECUTOR_BUFFER_SIZE);
   
       if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))
           return -1;
   
       // Receive the response
   
       ExecutorChallengeLocalResponse response;
   
       if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))
           return -1;
   
       Strlcpy((char*)sessionKey.data(), response.key, sessionKey.size());
       Strlcpy(challenge, response.challenge, EXECUTOR_BUFFER_SIZE);
   
       return response.status;
   }
   
   int Socket_authenticateLocal(
       const SessionKey& sessionKey,
       const char* token)
   {
       AutoMutex autoMutex(_mutex);
   
       // _send request header:
   
       ExecutorRequestHeader header;
       header.code = EXECUTOR_AUTHENTICATE_LOCAL_MESSAGE;
   
       if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
           return -1;
   
       // _send request body.
   
       ExecutorAuthenticateLocalRequest request;
       memset(&request, 0, sizeof(request));
       Strlcpy(request.key, (char*)sessionKey.data(), EXECUTOR_BUFFER_SIZE);
       Strlcpy(request.token, token, EXECUTOR_BUFFER_SIZE);
   
       if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))
           return -1;
   
       // Receive the response
   
       ExecutorAuthenticateLocalResponse response;
   
       if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))
           return -1;
   
       return response.status;
   }
   
   int Socket_newSessionKey(
       const char username[EXECUTOR_BUFFER_SIZE],
       SessionKey& sessionKey)
   {
       AutoMutex autoMutex(_mutex);
   
       sessionKey.clear();
   
       // _send request header:
   
       ExecutorRequestHeader header;
       header.code = EXECUTOR_NEW_SESSION_KEY_MESSAGE;
   
       if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
           return -1;
   
       // _send request body.
   
       ExecutorNewSessionKeyRequest request;
       memset(&request, 0, sizeof(request));
       Strlcpy(request.username, username, sizeof(request.username));
  
     if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))     if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))
         return -1;         return -1;
  
     // Receive the response     // Receive the response
  
     ExecutorPAMValidateUserResponse response;      ExecutorNewSessionKeyResponse response;
   
       if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))
           return -1;
   
       Strlcpy((char*)sessionKey.data(), response.key, sessionKey.size());
   
       return response.status;
   }
   
   int Socket_deleteSessionKey(
       const SessionKey& sessionKey)
   {
       AutoMutex autoMutex(_mutex);
   
       // Send request header:
   
       ExecutorRequestHeader header;
       header.code = EXECUTOR_DELETE_SESSION_KEY_MESSAGE;
   
       if (_send(_getSock(), &header, sizeof(header)) != sizeof(header))
           return -1;
   
       // Send request body.
   
       ExecutorDeleteSessionKeyRequest request;
       memset(&request, 0, sizeof(request));
       Strlcpy(request.key, sessionKey.data(), sizeof(request.key));
   
       if (_send(_getSock(), &request, sizeof(request)) != sizeof(request))
           return -1;
   
       // Receive the response
   
       ExecutorDeleteSessionKeyResponse response;
  
     if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))     if (_recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
Line 970 
Line 1106 
     _mutex.unlock();     _mutex.unlock();
 } }
  
   int Executor::detectExecutor()
   {
       if (_getSock() == -1)
           return -1;
       else
           return 0;
   }
   
 int Executor::ping() int Executor::ping()
 { {
     if (_getSock() == -1)     if (_getSock() == -1)
         return InProcess_ping();          return Loopback_ping();
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
     return OutOfProcess_ping();      return Socket_ping();
 #else #else
     return -1;     return -1;
 #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
Line 987 
Line 1131 
     int mode)     int mode)
 { {
     if (_getSock() == -1)     if (_getSock() == -1)
         return InProcess_openFile(path, mode);          return Loopback_openFile(path, mode);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
     return OutOfProcess_openFile(path, mode);      return Socket_openFile(path, mode);
 #else #else
     return -1;      return NULL;
 #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
 } }
  
Line 1001 
Line 1145 
     const char* newPath)     const char* newPath)
 { {
     if (_getSock() == -1)     if (_getSock() == -1)
         return InProcess_renameFile(oldPath, newPath);          return Loopback_renameFile(oldPath, newPath);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
     return OutOfProcess_renameFile(oldPath, newPath);      return Socket_renameFile(oldPath, newPath);
 #else #else
     return -1;     return -1;
 #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
Line 1014 
Line 1158 
     const char* path)     const char* path)
 { {
     if (_getSock() == -1)     if (_getSock() == -1)
         return InProcess_removeFile(path);          return Loopback_removeFile(path);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
     return OutOfProcess_removeFile(path);      return Socket_removeFile(path);
 #else #else
     return -1;     return -1;
 #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
 } }
  
 int Executor::startProviderAgent( int Executor::startProviderAgent(
       const SessionKey& sessionKey,
     const char* module,     const char* module,
     int uid,     int uid,
     int gid,     int gid,
     int& pid,     int& pid,
       SessionKey& providerAgentSessionKey,
     AnonymousPipe*& readPipe,     AnonymousPipe*& readPipe,
     AnonymousPipe*& writePipe)     AnonymousPipe*& writePipe)
 { {
     if (_getSock() == -1)     if (_getSock() == -1)
         return InProcess_startProviderAgent(          return Loopback_startProviderAgent(sessionKey, module,
             module, uid, gid, pid, readPipe, writePipe);              uid, gid, pid, providerAgentSessionKey, readPipe, writePipe);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
     return OutOfProcess_startProviderAgent(      return Socket_startProviderAgent(sessionKey, module,
         module, uid, gid, pid, readPipe, writePipe);          uid, gid, pid, providerAgentSessionKey, readPipe, writePipe);
 #else #else
       providerAgentSessionKey.clear();
     return -1;     return -1;
 #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
 } }
Line 1046 
Line 1193 
 int Executor::daemonizeExecutor() int Executor::daemonizeExecutor()
 { {
     if (_getSock() == -1)     if (_getSock() == -1)
         return InProcess_daemonizeExecutor();          return Loopback_daemonizeExecutor();
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
     return OutOfProcess_daemonizeExecutor();      return Socket_daemonizeExecutor();
 #else #else
     return -1;     return -1;
 #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
 } }
  
 int Executor::changeOwner(  int Executor::reapProviderAgent(
     const char* path,      const SessionKey& sessionKey,
     const char* owner)      int pid)
 { {
     if (_getSock() == -1)     if (_getSock() == -1)
         return InProcess_changeOwner(path, owner);          return Loopback_reapProviderAgent(sessionKey, pid);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
     return OutOfProcess_changeOwner(path, owner);      return Socket_reapProviderAgent(sessionKey, pid);
 #else #else
     return -1;     return -1;
 #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
 } }
  
 int Executor::waitPid(  int Executor::authenticatePassword(
     int pid)      const char* username,
       const char* password,
       SessionKey& sessionKey)
 { {
     if (_getSock() == -1)     if (_getSock() == -1)
         return InProcess_waitPid(pid);          return Loopback_authenticatePassword(username, password, sessionKey);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
     return OutOfProcess_waitPid(pid);      return Socket_authenticatePassword(username, password, sessionKey);
 #else #else
       sessionKey.clear();
     return -1;     return -1;
 #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
 } }
  
 int Executor::pamAuthenticate(  int Executor::validateUser(
     const char* username,      const char* username)
     const char* password)  
 { {
     if (_getSock() == -1)     if (_getSock() == -1)
         return InProcess_pamAuthenticate(username, password);          return Loopback_validateUser(username);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
     return OutOfProcess_pamAuthenticate(username, password);      return Socket_validateUser(username);
 #else #else
     return -1;     return -1;
 #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
 } }
  
 int Executor::pamValidateUser(  int Executor::challengeLocal(
     const char* username)      const char* user,
       char path[EXECUTOR_BUFFER_SIZE],
       SessionKey& sessionKey)
   {
       if (_getSock() == -1)
           return -1;
   
   #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
       return Socket_challengeLocal(user, path, sessionKey);
   #else
       sessionKey.clear();
       return -1;
   #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
   }
   
   int Executor::authenticateLocal(
       const SessionKey& sessionKey,
       const char* challengeResponse)
   {
       if (_getSock() == -1)
           return -1;
   
   #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
       return Socket_authenticateLocal(sessionKey, challengeResponse);
   #else
       return -1;
   #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
   }
   
   int Executor::newSessionKey(
       const char username[EXECUTOR_BUFFER_SIZE],
       SessionKey& sessionKey)
 { {
     if (_getSock() == -1)     if (_getSock() == -1)
         return InProcess_pamValidateUser(username);      {
           sessionKey.clear();
           return 0;
       }
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
     return OutOfProcess_pamValidateUser(username);      return Socket_newSessionKey(username, sessionKey);
 #else #else
     return -1;     return -1;
 #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */ #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
 } }
  
   int Executor::deleteSessionKey(
       const SessionKey& sessionKey)
   {
       if (_getSock() == -1)
           return 0;
   
   #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
       return Socket_deleteSessionKey(sessionKey);
   #else
       return 0;
   #endif /* defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) */
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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