(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.4.2 and 1.1.4.10

version 1.1.4.2, 2007/03/23 21:53:51 version 1.1.4.10, 2007/05/10 18:16:55
Line 33 
Line 33 
  
 #include <cstdio> #include <cstdio>
 #include <cstdlib> #include <cstdlib>
 #include <cstdlib>  
 #include <cstring> #include <cstring>
  
   #include <Pegasus/Common/Config.h>
   
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
 # include <windows.h> # include <windows.h>
 #else #else
 # include <Executor/Socket.h>  
 # include <sys/types.h>  
 # include <sys/socket.h>  
 # include <unistd.h>  
 # include <fcntl.h>  
 # include <sys/wait.h>  
 # include <unistd.h> # include <unistd.h>
   # include <sys/types.h>
 # include <sys/time.h> # include <sys/time.h>
 # include <sys/resource.h> # include <sys/resource.h>
 #endif #endif
  
 #include "Constants.h"  #if defined(PEGASUS_HAS_SIGNALS)
 #include "Executor.h"  # include <sys/wait.h>
 #include "Mutex.h"  #endif
 #include "FileSystem.h"  
 #include "String.h"  #include <Pegasus/Common/Constants.h>
   #include <Pegasus/Common/Mutex.h>
   #include <Pegasus/Common/FileSystem.h>
   #include <Pegasus/Common/String.h>
   #include <Pegasus/Common/Tracer.h>
   #include <Pegasus/Common/Executor.h>
   
 #include <Executor/Strlcpy.h> #include <Executor/Strlcpy.h>
 #include <Executor/Strlcat.h>  
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
   # include <Executor/Socket.h>
 # include <Executor/Messages.h> # include <Executor/Messages.h>
 #endif #endif
  
Line 100 
Line 102 
         const char* path) = 0;         const char* path) = 0;
  
     virtual int startProviderAgent(     virtual int startProviderAgent(
         const SessionKey& sessionKey,  
         const char* module,         const char* module,
           const String& userName,
         int uid,         int uid,
         int gid,         int gid,
         int& pid,         int& pid,
         SessionKey& providerAgentSessionKey,  
         AnonymousPipe*& readPipe,         AnonymousPipe*& readPipe,
         AnonymousPipe*& writePipe) = 0;         AnonymousPipe*& writePipe) = 0;
  
     virtual int daemonizeExecutor() = 0;     virtual int daemonizeExecutor() = 0;
  
     virtual int reapProviderAgent(     virtual int reapProviderAgent(
         const SessionKey& sessionKey,  
         int pid) = 0;         int pid) = 0;
  
     virtual int authenticatePassword(     virtual int authenticatePassword(
         const char* username,         const char* username,
         const char* password,          const char* password) = 0;
         SessionKey& sessionKey) = 0;  
  
     virtual int validateUser(     virtual int validateUser(
         const char* username) = 0;         const char* username) = 0;
  
     virtual int challengeLocal(     virtual int challengeLocal(
         const char* username,         const char* username,
         char challenge[EXECUTOR_BUFFER_SIZE],          char challengeFilePath[EXECUTOR_BUFFER_SIZE]) = 0;
         SessionKey& sessionKey) = 0;  
  
     virtual int authenticateLocal(     virtual int authenticateLocal(
         const SessionKey& sessionKey,          const char* challengeFilePath,
         const char* challengeResponse) = 0;          const char* response) = 0;
   
     virtual int newSessionKey(  
         const char username[EXECUTOR_BUFFER_SIZE],  
         SessionKey& sessionKey) = 0;  
   
     virtual int deleteSessionKey(  
         const SessionKey& sessionKey) = 0;  
 }; };
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Line 202 
Line 193 
  
  
     virtual int startProviderAgent(     virtual int startProviderAgent(
         const SessionKey& sessionKey,  
         const char* module,         const char* module,
           const String& userName,
         int uid,         int uid,
         int gid,         int gid,
         int& pid,         int& pid,
         SessionKey& providerAgentSessionKey,  
         AnonymousPipe*& readPipe,         AnonymousPipe*& readPipe,
         AnonymousPipe*& writePipe)         AnonymousPipe*& writePipe)
     {     {
           // Add logging here.
   
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
  
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
Line 306 
Line 298 
  
         // 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 337 
Line 328 
  
             // Fork process:             // Fork process:
  
 #if !defined(PEGASUS_OS_VMS)  #if defined(PEGASUS_OS_VMS)
             pid = (int)vfork();             pid = (int)vfork();
 #else #else
             pid = (int)fork();             pid = (int)fork();
Line 350 
Line 341 
  
             if (pid == 0)             if (pid == 0)
             {             {
   #if !defined(PEGASUS_OS_VMS)
                 // Close unused pipe descriptors:                 // Close unused pipe descriptors:
  
                 close(to[1]);                 close(to[1]);
                 close(from[0]);                 close(from[0]);
  
 #if !defined(PEGASUS_OS_VMS)  
  
                 // Close unused descriptors. Leave stdin, stdout, stderr,                 // Close unused descriptors. Leave stdin, stdout, stderr,
                 // and the child's pipe descriptors open.                 // and the child's pipe descriptors open.
Line 379 
Line 370 
  
                 if (uid != -1 && gid != -1)                 if (uid != -1 && gid != -1)
                 {                 {
                     if ((int)getgid() != gid)                      PEG_TRACE((TRC_OS_ABSTRACTION, Tracer::LEVEL4,
                           "Changing user context to: userName=%s uid=%d, gid=%d",
                           (const char*)userName.getCString(), uid, gid));
   
                       if (setgid(gid) != 0)
                     {                     {
                         // ATTN: log failure!                          PEG_TRACE_STRING(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
                         setgid(gid);                            String("setgid failed: ") + String(strerror(errno)));
                           return false;
                     }                     }
  
                     if ((int)getuid() != uid)                      if (setuid(uid) != 0)
                     {                     {
                         // ATTN: log failure!                          PEG_TRACE_STRING(TRC_OS_ABSTRACTION, Tracer::LEVEL2,
                         setuid(uid);                            String("setuid failed: ") + String(strerror(errno)));
                           return false;
                     }                     }
                 }                 }
  
Line 403 
Line 400 
  
                 {                 {
                     CString cstr = path.getCString();                     CString cstr = path.getCString();
                     execl(cstr, cstr, arg1, arg2, module, (char*)0);                      if (execl(cstr, cstr, arg1, arg2, module, (char*)0) == -1)
                       {
                           PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL2,
                               "execl() failed.  errno = %d.", errno));
                     _exit(1);                     _exit(1);
                 }                 }
                   }
                 // ATTN: log failure!  
             }             }
         }         }
         while (0);         while (0);
Line 444 
Line 443 
     }     }
  
     virtual int reapProviderAgent(     virtual int reapProviderAgent(
         const SessionKey& sessionKey,  
         int pid)         int pid)
     {     {
         int status;          int status = 0;
  
   #if defined(PEGASUS_HAS_SIGNALS)
         while ((status = waitpid(pid, 0, 0)) == -1 && errno == EINTR)         while ((status = waitpid(pid, 0, 0)) == -1 && errno == EINTR)
             ;             ;
   #endif
  
         return status;         return status;
     }     }
  
     virtual int authenticatePassword(     virtual int 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
         // ATTN: not handled so don't call in this case.         // ATTN: not handled so don't call in this case.
         sessionKey.clear();  
         return -1;         return -1;
 #endif #endif
     }     }
Line 484 
Line 480 
  
     virtual int challengeLocal(     virtual int challengeLocal(
         const char* username,         const char* username,
         char challenge[EXECUTOR_BUFFER_SIZE],          char challengeFilePath[EXECUTOR_BUFFER_SIZE])
         SessionKey& sessionKey)  
     {     {
         // ATTN: not handled so don't call in this case.         // ATTN: not handled so don't call in this case.
         sessionKey.clear();  
         return -1;         return -1;
     }     }
  
     virtual int authenticateLocal(     virtual int authenticateLocal(
         const SessionKey& sessionKey,          const char* challengeFilePath,
         const char* challengeResponse)          const char* response)
     {     {
         // ATTN: not handled so don't call in this case.         // ATTN: not handled so don't call in this case.
         return -1;         return -1;
     }     }
  
     virtual int newSessionKey(  
         const char username[EXECUTOR_BUFFER_SIZE],  
         SessionKey& sessionKey)  
     {  
         sessionKey.clear();  
         return -1;  
     }  
   
     virtual int deleteSessionKey(  
         const SessionKey& sessionKey)  
     {  
         return -1;  
     }  
   
 private: private:
  
     static int _getProviderAgentPath(String& path)     static int _getProviderAgentPath(String& path)
Line 710 
Line 690 
     }     }
  
     virtual int startProviderAgent(     virtual int startProviderAgent(
         const SessionKey& sessionKey,  
         const char* module,         const char* module,
           const String& userName,
         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 722 
  
         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 759 
Line 736 
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))         if (_recv(_sock, &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 821 
Line 793 
     }     }
  
     virtual int reapProviderAgent(     virtual int reapProviderAgent(
         const SessionKey& sessionKey,  
         int pid)         int pid)
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
Line 838 
Line 809 
  
         ExecutorReapProviderAgentRequest request;         ExecutorReapProviderAgentRequest request;
         memset(&request, 0, sizeof(request));         memset(&request, 0, sizeof(request));
         Strlcpy(request.key, sessionKey.data(), sizeof(request.key));  
         request.pid = pid;         request.pid = pid;
  
         if (_send(_sock, &request, sizeof(request)) != sizeof(request))         if (_send(_sock, &request, sizeof(request)) != sizeof(request))
Line 856 
Line 826 
  
     virtual int authenticatePassword(     virtual int authenticatePassword(
         const char* username,         const char* username,
         const char* password,          const char* password)
         SessionKey& sessionKey)  
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
         sessionKey.clear();  
   
         // _send request header:         // _send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
Line 888 
Line 855 
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))
             return -1;             return -1;
  
         Strlcpy((char*)sessionKey.data(), response.key, sessionKey.size());  
   
         return response.status;         return response.status;
     }     }
  
Line 927 
Line 892 
  
     virtual int challengeLocal(     virtual int challengeLocal(
         const char* username,         const char* username,
         char challenge[EXECUTOR_BUFFER_SIZE],          char challengeFilePath[EXECUTOR_BUFFER_SIZE])
         SessionKey& sessionKey)  
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
         sessionKey.clear();  
   
         // _send request header:         // _send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
Line 958 
Line 920 
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))
             return -1;             return -1;
  
         Strlcpy((char*)sessionKey.data(), response.key, sessionKey.size());          Strlcpy(challengeFilePath, response.challenge, EXECUTOR_BUFFER_SIZE);
         Strlcpy(challenge, response.challenge, EXECUTOR_BUFFER_SIZE);  
  
         return response.status;         return response.status;
     }     }
  
     virtual int authenticateLocal(     virtual int authenticateLocal(
         const SessionKey& sessionKey,          const char* challengeFilePath,
         const char* challengeResponse)          const char* response)
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
Line 982 
Line 943 
  
         ExecutorAuthenticateLocalRequest request;         ExecutorAuthenticateLocalRequest request;
         memset(&request, 0, sizeof(request));         memset(&request, 0, sizeof(request));
         Strlcpy(request.key, (char*)sessionKey.data(), EXECUTOR_BUFFER_SIZE);          Strlcpy(request.challenge, challengeFilePath, EXECUTOR_BUFFER_SIZE);
         Strlcpy(request.token, challengeResponse, EXECUTOR_BUFFER_SIZE);          Strlcpy(request.response, response, EXECUTOR_BUFFER_SIZE);
  
         if (_send(_sock, &request, sizeof(request)) != sizeof(request))         if (_send(_sock, &request, sizeof(request)) != sizeof(request))
             return -1;             return -1;
  
         // Receive the response         // Receive the response
  
         ExecutorAuthenticateLocalResponse response;          ExecutorAuthenticateLocalResponse response_;
  
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))          if (_recv(_sock, &response_, sizeof(response_)) != sizeof(response_))
             return -1;             return -1;
  
         return response.status;          return response_.status;
     }  
   
     virtual int 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(_sock, &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(_sock, &request, sizeof(request)) != sizeof(request))  
             return -1;  
   
         // Receive the response  
   
         ExecutorNewSessionKeyResponse response;  
   
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))  
             return -1;  
   
         Strlcpy((char*)sessionKey.data(), response.key, sessionKey.size());  
   
         return response.status;  
     }  
   
     virtual int deleteSessionKey(  
         const SessionKey& sessionKey)  
     {  
         AutoMutex autoMutex(_mutex);  
   
         // Send request header:  
   
         ExecutorRequestHeader header;  
         header.code = EXECUTOR_DELETE_SESSION_KEY_MESSAGE;  
   
         if (_send(_sock, &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(_sock, &request, sizeof(request)) != sizeof(request))  
             return -1;  
   
         // Receive the response  
   
         ExecutorDeleteSessionKeyResponse response;  
   
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))  
             return -1;  
   
         return response.status;  
     }     }
  
 private: private:
Line 1200 
Line 1092 
 } }
  
 int Executor::startProviderAgent( int Executor::startProviderAgent(
     const SessionKey& sessionKey,  
     const char* module,     const char* module,
       const String& userName,
     int uid,     int uid,
     int gid,     int gid,
     int& pid,     int& pid,
     SessionKey& providerAgentSessionKey,  
     AnonymousPipe*& readPipe,     AnonymousPipe*& readPipe,
     AnonymousPipe*& writePipe)     AnonymousPipe*& writePipe)
 { {
     return _getImpl()->startProviderAgent(sessionKey, module,      return _getImpl()->startProviderAgent(module,
         uid, gid, pid, providerAgentSessionKey, readPipe, writePipe);          userName, uid, gid, pid, readPipe, writePipe);
 } }
  
 int Executor::daemonizeExecutor() int Executor::daemonizeExecutor()
Line 1219 
Line 1110 
 } }
  
 int Executor::reapProviderAgent( int Executor::reapProviderAgent(
     const SessionKey& sessionKey,  
     int pid)     int pid)
 { {
     return _getImpl()->reapProviderAgent(sessionKey, pid);      return _getImpl()->reapProviderAgent(pid);
 } }
  
 int Executor::authenticatePassword( int Executor::authenticatePassword(
     const char* username,     const char* username,
     const char* password,      const char* password)
     SessionKey& sessionKey)  
 { {
     return _getImpl()->authenticatePassword(username, password, sessionKey);      return _getImpl()->authenticatePassword(username, password);
 } }
  
 int Executor::validateUser( int Executor::validateUser(
Line 1241 
Line 1130 
  
 int Executor::challengeLocal( int Executor::challengeLocal(
     const char* user,     const char* user,
     char path[EXECUTOR_BUFFER_SIZE],      char challengeFilePath[EXECUTOR_BUFFER_SIZE])
     SessionKey& sessionKey)  
 { {
     return _getImpl()->challengeLocal(user, path, sessionKey);      return _getImpl()->challengeLocal(user, challengeFilePath);
 } }
  
 int Executor::authenticateLocal( int Executor::authenticateLocal(
     const SessionKey& sessionKey,      const char* challengeFilePath,
     const char* challengeResponse)      const char* response)
 {  
     return _getImpl()->authenticateLocal(sessionKey, challengeResponse);  
 }  
   
 int Executor::newSessionKey(  
     const char username[EXECUTOR_BUFFER_SIZE],  
     SessionKey& sessionKey)  
 {  
     return _getImpl()->newSessionKey(username, sessionKey);  
 }  
   
 int Executor::deleteSessionKey(  
     const SessionKey& sessionKey)  
 { {
     return _getImpl()->deleteSessionKey(sessionKey);      return _getImpl()->authenticateLocal(challengeFilePath, response);
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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