(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.1 and 1.1.2.2

version 1.1.2.1, 2007/01/02 06:17:19 version 1.1.2.2, 2007/01/02 07:47:24
Line 70 
Line 70 
 static int _sock = -1; static int _sock = -1;
 static Mutex _mutex; static Mutex _mutex;
  
   static int _getSock()
   {
       int sock;
       _mutex.lock();
       sock = _sock;
       _mutex.unlock();
       return sock;
   }
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //// ////
Line 511 
Line 520 
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_PING_REQUEST;     header.code = EXECUTOR_PING_REQUEST;
  
     if (Send(_sock, &header, sizeof(header)) != sizeof(header))      if (Send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     ExecutorPingResponse response;     ExecutorPingResponse response;
  
     if (Recv(_sock, &response, sizeof(response)) != sizeof(response))      if (Recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
     if (response.magic == EXECUTOR_PING_MAGIC)     if (response.magic == EXECUTOR_PING_MAGIC)
Line 539 
Line 548 
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_OPEN_FILE_REQUEST;     header.code = EXECUTOR_OPEN_FILE_REQUEST;
  
     if (Send(_sock, &header, sizeof(header)) != sizeof(header))      if (Send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return NULL;         return NULL;
  
     // Send request body.     // Send request body.
Line 549 
Line 558 
     Strlcpy(request.path, path, EXECUTOR_BUFFER_SIZE);     Strlcpy(request.path, path, EXECUTOR_BUFFER_SIZE);
     request.mode = mode;     request.mode = mode;
  
     if (Send(_sock, &request, sizeof(request)) != sizeof(request))      if (Send(_getSock(), &request, sizeof(request)) != sizeof(request))
         return NULL;         return NULL;
  
     // Receive the response     // Receive the response
  
     ExecutorOpenFileResponse response;     ExecutorOpenFileResponse response;
  
     if (Recv(_sock, &response, sizeof(response)) != sizeof(response))      if (Recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return NULL;         return NULL;
  
     // Receive descriptor (if response successful).     // Receive descriptor (if response successful).
Line 565 
Line 574 
     {     {
         int fds[1];         int fds[1];
  
         if (_receiveDescriptorArray(_sock, fds, 1) != 0)          if (_receiveDescriptorArray(_getSock(), fds, 1) != 0)
             return NULL;             return NULL;
  
         if (fds[0] == -1)         if (fds[0] == -1)
Line 593 
Line 602 
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_RENAME_FILE_REQUEST;     header.code = EXECUTOR_RENAME_FILE_REQUEST;
  
     if (Send(_sock, &header, sizeof(header)) != sizeof(header))      if (Send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // Send request body.     // Send request body.
Line 603 
Line 612 
     Strlcpy(request.oldPath, oldPath, EXECUTOR_BUFFER_SIZE);     Strlcpy(request.oldPath, oldPath, EXECUTOR_BUFFER_SIZE);
     Strlcpy(request.newPath, newPath, EXECUTOR_BUFFER_SIZE);     Strlcpy(request.newPath, newPath, EXECUTOR_BUFFER_SIZE);
  
     if (Send(_sock, &request, sizeof(request)) != sizeof(request))      if (Send(_getSock(), &request, sizeof(request)) != sizeof(request))
         return -1;         return -1;
  
     // Receive the response     // Receive the response
  
     ExecutorRenameFileResponse response;     ExecutorRenameFileResponse response;
  
     if (Recv(_sock, &response, sizeof(response)) != sizeof(response))      if (Recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
     return response.status;     return response.status;
Line 626 
Line 635 
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_REMOVE_FILE_REQUEST;     header.code = EXECUTOR_REMOVE_FILE_REQUEST;
  
     if (Send(_sock, &header, sizeof(header)) != sizeof(header))      if (Send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // Send request body.     // Send request body.
Line 635 
Line 644 
     memset(&request, 0, sizeof(request));     memset(&request, 0, sizeof(request));
     Strlcpy(request.path, path, EXECUTOR_BUFFER_SIZE);     Strlcpy(request.path, path, EXECUTOR_BUFFER_SIZE);
  
     if (Send(_sock, &request, sizeof(request)) != sizeof(request))      if (Send(_getSock(), &request, sizeof(request)) != sizeof(request))
         return -1;         return -1;
  
     // Receive the response     // Receive the response
  
     ExecutorRemoveFileResponse response;     ExecutorRemoveFileResponse response;
  
     if (Recv(_sock, &response, sizeof(response)) != sizeof(response))      if (Recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
     return response.status;     return response.status;
Line 673 
Line 682 
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_START_PROVIDER_AGENT_REQUEST;     header.code = EXECUTOR_START_PROVIDER_AGENT_REQUEST;
  
     if (Send(_sock, &header, sizeof(header)) != sizeof(header))      if (Send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // Send request body.     // Send request body.
Line 684 
Line 693 
     request.uid = uid;     request.uid = uid;
     request.gid = gid;     request.gid = gid;
  
     if (Send(_sock, &request, sizeof(request)) != sizeof(request))      if (Send(_getSock(), &request, sizeof(request)) != sizeof(request))
         return -1;         return -1;
  
     // Receive the response     // Receive the response
  
     ExecutorStartProviderAgentResponse response;     ExecutorStartProviderAgentResponse response;
  
     if (Recv(_sock, &response, sizeof(response)) != sizeof(response))      if (Recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
     // Check response status and pid.     // Check response status and pid.
Line 706 
Line 715 
     // Receive descriptors.     // Receive descriptors.
  
     int descriptors[2];     int descriptors[2];
     int result = _receiveDescriptorArray(_sock, descriptors, 2);      int result = _receiveDescriptorArray(_getSock(), descriptors, 2);
  
     if (result == 0)     if (result == 0)
     {     {
Line 737 
Line 746 
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_DAEMONIZE_EXECUTOR_REQUEST;     header.code = EXECUTOR_DAEMONIZE_EXECUTOR_REQUEST;
  
     if (Send(_sock, &header, sizeof(header)) != sizeof(header))      if (Send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // Receive the response     // Receive the response
  
     ExecutorDaemonizeExecutorResponse response;     ExecutorDaemonizeExecutorResponse response;
  
     if (Recv(_sock, &response, sizeof(response)) != sizeof(response))      if (Recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
     return response.status;     return response.status;
Line 761 
Line 770 
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_CHANGE_OWNER_REQUEST;     header.code = EXECUTOR_CHANGE_OWNER_REQUEST;
  
     if (Send(_sock, &header, sizeof(header)) != sizeof(header))      if (Send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // Send request body:     // Send request body:
Line 770 
Line 779 
     Strlcpy(request.path, path, sizeof(request.path));     Strlcpy(request.path, path, sizeof(request.path));
     Strlcpy(request.owner, owner, sizeof(request.owner));     Strlcpy(request.owner, owner, sizeof(request.owner));
  
     if (Send(_sock, &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;     ExecutorChangeOwnerResponse response;
  
     if (Recv(_sock, &response, sizeof(response)) != sizeof(response))      if (Recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
     return response.status;     return response.status;
Line 793 
Line 802 
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_WAIT_PID_REQUEST;     header.code = EXECUTOR_WAIT_PID_REQUEST;
  
     if (Send(_sock, &header, sizeof(header)) != sizeof(header))      if (Send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // Send request body:     // Send request body:
Line 801 
Line 810 
     ExecutorWaitPidRequest request;     ExecutorWaitPidRequest request;
     request.pid = pid;     request.pid = pid;
  
     if (Send(_sock, &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;     ExecutorWaitPidResponse response;
  
     if (Recv(_sock, &response, sizeof(response)) != sizeof(response))      if (Recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
     return response.status;     return response.status;
Line 825 
Line 834 
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_PAM_AUTHENTICATE_REQUEST;     header.code = EXECUTOR_PAM_AUTHENTICATE_REQUEST;
  
     if (Send(_sock, &header, sizeof(header)) != sizeof(header))      if (Send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // Send request body.     // Send request body.
Line 835 
Line 844 
     Strlcpy(request.username, username, EXECUTOR_BUFFER_SIZE);     Strlcpy(request.username, username, EXECUTOR_BUFFER_SIZE);
     Strlcpy(request.password, password, EXECUTOR_BUFFER_SIZE);     Strlcpy(request.password, password, EXECUTOR_BUFFER_SIZE);
  
     if (Send(_sock, &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;     ExecutorPAMAuthenticateResponse response;
  
     if (Recv(_sock, &response, sizeof(response)) != sizeof(response))      if (Recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
     return response.status;     return response.status;
Line 858 
Line 867 
     ExecutorRequestHeader header;     ExecutorRequestHeader header;
     header.code = EXECUTOR_PAM_VALIDATE_USER_REQUEST;     header.code = EXECUTOR_PAM_VALIDATE_USER_REQUEST;
  
     if (Send(_sock, &header, sizeof(header)) != sizeof(header))      if (Send(_getSock(), &header, sizeof(header)) != sizeof(header))
         return -1;         return -1;
  
     // Send request body.     // Send request body.
Line 867 
Line 876 
     memset(&request, 0, sizeof(request));     memset(&request, 0, sizeof(request));
     Strlcpy(request.username, username, EXECUTOR_BUFFER_SIZE);     Strlcpy(request.username, username, EXECUTOR_BUFFER_SIZE);
  
     if (Send(_sock, &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;     ExecutorPAMValidateUserResponse response;
  
     if (Recv(_sock, &response, sizeof(response)) != sizeof(response))      if (Recv(_getSock(), &response, sizeof(response)) != sizeof(response))
         return -1;         return -1;
  
     return response.status;     return response.status;
Line 890 
Line 899 
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 void Executor::setExecutorSocket(int sock)  void Executor::setSock(int sock)
 { {
       _mutex.lock();
     _sock = sock;     _sock = sock;
       _mutex.unlock();
 } }
  
 int Executor::ping() int Executor::ping()
 { {
     if (_sock == -1)      if (_getSock() == -1)
         return InProcess_ping();         return InProcess_ping();
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
Line 911 
Line 922 
     const char* path,     const char* path,
     int mode)     int mode)
 { {
     if (_sock == -1)      if (_getSock() == -1)
         return InProcess_openFile(path, mode);         return InProcess_openFile(path, mode);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
Line 925 
Line 936 
     const char* oldPath,     const char* oldPath,
     const char* newPath)     const char* newPath)
 { {
     if (_sock == -1)      if (_getSock() == -1)
         return InProcess_renameFile(oldPath, newPath);         return InProcess_renameFile(oldPath, newPath);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
Line 938 
Line 949 
 int Executor::removeFile( int Executor::removeFile(
     const char* path)     const char* path)
 { {
     if (_sock == -1)      if (_getSock() == -1)
         return InProcess_removeFile(path);         return InProcess_removeFile(path);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
Line 956 
Line 967 
     AnonymousPipe*& readPipe,     AnonymousPipe*& readPipe,
     AnonymousPipe*& writePipe)     AnonymousPipe*& writePipe)
 { {
     if (_sock == -1)      if (_getSock() == -1)
         return InProcess_startProviderAgent(         return InProcess_startProviderAgent(
             module, uid, gid, pid, readPipe, writePipe);             module, uid, gid, pid, readPipe, writePipe);
  
Line 970 
Line 981 
  
 int Executor::daemonizeExecutor() int Executor::daemonizeExecutor()
 { {
     if (_sock == -1)      if (_getSock() == -1)
         return InProcess_daemonizeExecutor();         return InProcess_daemonizeExecutor();
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
Line 984 
Line 995 
     const char* path,     const char* path,
     const char* owner)     const char* owner)
 { {
     if (_sock == -1)      if (_getSock() == -1)
         return InProcess_changeOwner(path, owner);         return InProcess_changeOwner(path, owner);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
Line 997 
Line 1008 
 int Executor::waitPid( int Executor::waitPid(
     int pid)     int pid)
 { {
     if (_sock == -1)      if (_getSock() == -1)
         return InProcess_waitPid(pid);         return InProcess_waitPid(pid);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
Line 1011 
Line 1022 
     const char* username,     const char* username,
     const char* password)     const char* password)
 { {
     if (_sock == -1)      if (_getSock() == -1)
         return InProcess_pamAuthenticate(username, password);         return InProcess_pamAuthenticate(username, password);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
Line 1024 
Line 1035 
 int Executor::pamValidateUser( int Executor::pamValidateUser(
     const char* username)     const char* username)
 { {
     if (_sock == -1)      if (_getSock() == -1)
         return InProcess_pamValidateUser(username);         return InProcess_pamValidateUser(username);
  
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)

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