(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.4 and 1.27

version 1.1.4.4, 2007/03/30 00:35:02 version 1.27, 2013/02/22 00:17:18
Line 1 
Line 1 
 //%2006////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;  //
 // EMC Corporation; VERITAS Software Corporation; The Open Group.  // Permission is hereby granted, free of charge, to any person obtaining a
 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;  // copy of this software and associated documentation files (the "Software"),
 // EMC Corporation; Symantec Corporation; The Open Group.  // to deal in the Software without restriction, including without limitation
 //  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // and/or sell copies of the Software, and to permit persons to whom the
 // of this software and associated documentation files (the "Software"), to  // Software is furnished to do so, subject to the following conditions:
 // deal in the Software without restriction, including without limitation the  //
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // The above copyright notice and this permission notice shall be included
 // sell copies of the Software, and to permit persons to whom the Software is  // in all copies or substantial portions of the Software.
 // furnished to do so, subject to the following conditions:  //
 //  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  //////////////////////////////////////////////////////////////////////////
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #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 <errno.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/Once.h>
   #include <Pegasus/Common/FileSystem.h>
   #include <Pegasus/Common/String.h>
   #include <Pegasus/Common/Tracer.h>
   #include <Pegasus/Common/System.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 66 
Line 69 
 # include <Executor/PAMAuth.h> # include <Executor/PAMAuth.h>
 #endif #endif
  
   #ifdef PEGASUS_OS_PASE
   # include <as400_protos.h> // For fork400()
   #endif
   
   #ifdef PEGASUS_OS_ZOS
   # include <spawn.h>
   #endif
   
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Line 100 
Line 111 
         const char* path) = 0;         const char* path) = 0;
  
     virtual int startProviderAgent(     virtual int startProviderAgent(
           unsigned short bitness,
         const char* module,         const char* module,
         int uid,          const String& pegasusHome,
         int gid,          const String& userName,
         int& pid,         int& pid,
         AnonymousPipe*& readPipe,         AnonymousPipe*& readPipe,
         AnonymousPipe*& writePipe) = 0;         AnonymousPipe*& writePipe) = 0;
Line 121 
Line 133 
  
     virtual int challengeLocal(     virtual int challengeLocal(
         const char* username,         const char* username,
         char challenge[EXECUTOR_BUFFER_SIZE]) = 0;          char challengeFilePath[EXECUTOR_BUFFER_SIZE]) = 0;
  
     virtual int authenticateLocal(     virtual int authenticateLocal(
         const char* challenge,          const char* challengeFilePath,
         const char* response) = 0;         const char* response) = 0;
   
       virtual int updateLogLevel(
           const char* logLevel) = 0;
 }; };
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Line 158 
Line 173 
         const char* path,         const char* path,
         int mode)         int mode)
     {     {
           FILE* fhandle = NULL;
         switch (mode)         switch (mode)
         {         {
             case 'r':             case 'r':
                 return fopen(path, "rb");                  fhandle = fopen(path, "r");
                   break;
  
             case 'w':             case 'w':
                 return fopen(path, "wb");                  fhandle = fopen(path, "w");
                   break;
  
             case 'a':             case 'a':
                 return fopen(path, "a+");                  fhandle = fopen(path, "a+");
                   break;
  
             default:             default:
                 return NULL;                  PEGASUS_ASSERT(fhandle);
                   break;
           }
   
           if(!fhandle)
           {
               PEG_TRACE((TRC_SERVER, Tracer::LEVEL1,
                   "Open of file %s in mode %c failed: %s",path,mode,
                   (const char*) PEGASUS_SYSTEM_ERRORMSG.getCString()));
         }         }
           return fhandle;
     }     }
  
     virtual int renameFile(     virtual int renameFile(
Line 190 
Line 218 
  
  
     virtual int startProviderAgent(     virtual int startProviderAgent(
           unsigned short bitness,
         const char* module,         const char* module,
         int uid,          const String& pegasusHome,
         int gid,          const String& userName,
         int& pid,         int& pid,
         AnonymousPipe*& readPipe,         AnonymousPipe*& readPipe,
         AnonymousPipe*& writePipe)         AnonymousPipe*& writePipe)
     {     {
           PEG_METHOD_ENTER(TRC_SERVER,"ExecutorLoopbackImpl::startProviderAgent");
   
   #if !defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
   
           // Resolve full path of "cimprovagt" program.
   
           String path = FileSystem::getAbsolutePath(
               pegasusHome.getCString(),
               bitness == PG_PROVMODULE_BITNESS_32 ?
                   PEGASUS_PROVIDER_AGENT32_PROC_NAME :
                       PEGASUS_PROVIDER_AGENT_PROC_NAME);
   
           // Create CString handles for cimprovagt arguments
   
           CString agentProgramPath = path.getCString();
           CString userNameCString = userName.getCString();
   
   # if defined(PEGASUS_DISABLE_PROV_USERCTXT) || defined(PEGASUS_OS_ZOS)
           const char* setUserContextFlag = "0";    // False
   # else
           const char* setUserContextFlag = "1";    // True
   # endif
   
 #if defined(PEGASUS_OS_TYPE_WINDOWS) #if defined(PEGASUS_OS_TYPE_WINDOWS)
  
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
Line 209 
Line 261 
  
         // Create pipes. Export handles to string.         // Create pipes. Export handles to string.
  
         AnonymousPipe* pipeFromAgent = new AnonymousPipe();          AutoPtr<AnonymousPipe> pipeFromAgent(new AnonymousPipe());
         AnonymousPipe* pipeToAgent = new AnonymousPipe();          AutoPtr<AnonymousPipe> pipeToAgent(new AnonymousPipe());
  
         char readHandle[32];         char readHandle[32];
         char writeHandle[32];         char writeHandle[32];
Line 228 
Line 280 
         ZeroMemory(&siStartInfo, sizeof (STARTUPINFO));         ZeroMemory(&siStartInfo, sizeof (STARTUPINFO));
         siStartInfo.cb = sizeof (STARTUPINFO);         siStartInfo.cb = sizeof (STARTUPINFO);
  
         // Build full path of "cimprovagt" program.  
   
         String path;  
   
         if (_getProviderAgentPath(path) != 0)  
         {  
             delete pipeToAgent;  
             delete pipeFromAgent;  
             return -1;  
         }  
   
         // Format command line.         // Format command line.
  
         char cmdLine[2048];         char cmdLine[2048];
  
         sprintf(cmdLine, "\"%s\" %s %s \"%s\"",          sprintf(cmdLine, "\"%s\" %s %s %s \"%s\" \"%s\"",
             (const char*)path.getCString(),              (const char*)agentProgramPath,
               setUserContextFlag,
             readHandle,             readHandle,
             writeHandle,             writeHandle,
               (const char*)userNameCString,
             module);             module);
  
         //  Create provider agent proess.         //  Create provider agent proess.
Line 263 
Line 306 
             &siStartInfo,  //  STARTUPINFO             &siStartInfo,  //  STARTUPINFO
             &piProcInfo))  //  PROCESS_INFORMATION             &piProcInfo))  //  PROCESS_INFORMATION
         {         {
             delete pipeToAgent;              PEG_METHOD_EXIT();
             delete pipeFromAgent;  
             return -1;             return -1;
         }         }
  
Line 276 
Line 318 
         pipeToAgent->closeReadHandle();         pipeToAgent->closeReadHandle();
         pipeFromAgent->closeWriteHandle();         pipeFromAgent->closeWriteHandle();
  
         readPipe = pipeFromAgent;          readPipe = pipeFromAgent.release();
         writePipe = pipeToAgent;          writePipe = pipeToAgent.release();
  
           PEG_METHOD_EXIT();
         return 0;         return 0;
  
 #elif defined(PEGASUS_OS_OS400)  
   
         // ATTN: no implementation for OS400.  
         return -1;  
   
 #else /* POSIX CASE FOLLOWS */ #else /* POSIX CASE FOLLOWS */
  
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
Line 300 
Line 338 
  
         int to[2];         int to[2];
         int from[2];         int from[2];
           char toPipeArg[32];
           char fromPipeArg[32];
  
         do         do
         {         {
             // Resolve full path of "cimprovagt".  
   
             String path;  
   
             if (_getProviderAgentPath(path) != 0)  
                 return -1;  
   
             // Create "to-agent" pipe:             // Create "to-agent" pipe:
  
             if (pipe(to) != 0)             if (pipe(to) != 0)
               {
                   PEG_METHOD_EXIT();
                 return -1;                 return -1;
               }
  
             // Create "from-agent" pipe:             // Create "from-agent" pipe:
  
             if (pipe(from) != 0)             if (pipe(from) != 0)
               {
                   PEG_METHOD_EXIT();
                 return -1;                 return -1;
               }
   
               // Initialize the cimprovagt pipe arguments:
   
               sprintf(toPipeArg, "%d", to[0]);
               sprintf(fromPipeArg, "%d", from[1]);
  
             // Fork process:              // Start provider agent:
   
   #  if defined(PEGASUS_OS_ZOS)
               // zOS uses __spawn2() instead of fork() to start provider agent
   
               struct __inheritance inherit;
               const char *c_argv[7];
   
               c_argv[0] = agentProgramPath;
               c_argv[1] = setUserContextFlag;
               c_argv[2] = toPipeArg;
               c_argv[3] = fromPipeArg;
               c_argv[4] = userNameCString;
               c_argv[5] = module;
               c_argv[6] = NULL;
   
               // reset the inherit structure
               memset(&inherit,0,sizeof(inherit));
   
               // The provider agent should get a defined JobName.
               inherit.flags=SPAWN_SETJOBNAME;
               memcpy( inherit.jobname,"CFZOOPA ",
                       sizeof(inherit.jobname));
   
               PEG_TRACE((TRC_SERVER, Tracer::LEVEL4,
                   "Starting provider agent: %s %s %s %s %s %s %s",
                   (const char*)agentProgramPath,
                   c_argv[0],
                   c_argv[1],
                   c_argv[2],
                   c_argv[3],
                   c_argv[4],
                   c_argv[5]));
   
               pid = __spawn2(agentProgramPath,0,NULL,&inherit,
                              c_argv,(const char **)environ);
   
               if (pid < 0)
               {
                   PEG_TRACE((TRC_SERVER, Tracer::LEVEL1,
                       "Spawn of provider agent fails:%s "
                           "( errno %d , reason code %08X )",
                       strerror(errno) ,errno,__errno2()));
                   PEG_METHOD_EXIT();
                   return -1;
               }
   
   #  else    // !defined(PEGASUS_OS_ZOS)
  
 #if defined(PEGASUS_OS_VMS) #if defined(PEGASUS_OS_VMS)
             pid = (int)vfork();             pid = (int)vfork();
   #   elif defined(PEGASUS_OS_PASE)
               pid = (int)fork400("QUMEPRVAGT",0);
 #else #else
             pid = (int)fork();             pid = (int)fork();
 #endif #endif
  
             if (pid < 0)             if (pid < 0)
               {
                   PEG_TRACE((TRC_SERVER, Tracer::LEVEL1,
                        "Fork for provider agent fails: errno = %d",errno));
                   PEG_METHOD_EXIT();
                 return -1;                 return -1;
               }
             // If child proceses.  
  
             if (pid == 0)             if (pid == 0)
             {             {
                   // Child process
   
   #   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 358 
Line 455 
  
 #endif /* !defined(PEGASUS_OS_VMS) */ #endif /* !defined(PEGASUS_OS_VMS) */
  
                 // Set uid and gid for the new provider agent process.  
   
 # if !defined(PEGASUS_DISABLE_PROV_USERCTXT)  
   
                 if (uid != -1 && gid != -1)  
                 {  
                     if ((int)getgid() != gid)  
                     {  
                         // ATTN: log failure!  
                         setgid(gid);  
                     }  
   
                     if ((int)getuid() != uid)  
                     {  
                         // ATTN: log failure!  
                         setuid(uid);  
                     }  
                 }  
   
 # endif /* !defined(PEGASUS_DISABLE_PROV_USERCTXT) */  
   
                 // Exec the cimprovagt program.                 // Exec the cimprovagt program.
  
                 char arg1[32];  
                 char arg2[32];  
                 sprintf(arg1, "%d", to[0]);  
                 sprintf(arg2, "%d", from[1]);  
   
                 {                 {
                     CString cstr = path.getCString();                      if (execl(
                     execl(cstr, cstr, arg1, arg2, module, (char*)0);                              agentProgramPath,
                               agentProgramPath,
                               setUserContextFlag,
                               toPipeArg,
                               fromPipeArg,
                               (const char*)userNameCString,
                               module,
                               (char*)0) == -1)
                       {
                           PEG_TRACE((TRC_SERVER, Tracer::LEVEL1,
                               "execl() failed.  errno = %d.", errno));
                     _exit(1);                     _exit(1);
                 }                 }
   
                 // ATTN: log failure!  
             }             }
         }         }
   #  endif /* PEGASUS_OS_ZOS */
           }
         while (0);         while (0);
  
           PEG_TRACE((TRC_SERVER, Tracer::LEVEL4,
               "Provider agent started: pid(%d).", pid));
   
         // Close unused pipe descriptors.         // Close unused pipe descriptors.
  
         close(to[0]);         close(to[0]);
Line 418 
Line 502 
         readPipe = new AnonymousPipe(readFdStr, 0);         readPipe = new AnonymousPipe(readFdStr, 0);
         writePipe = new AnonymousPipe(0, writeFdStr);         writePipe = new AnonymousPipe(0, writeFdStr);
  
   #  if defined(PEGASUS_HAS_SIGNALS) && \
         !(defined(PEGASUS_DISABLE_PROV_USERCTXT) || defined(PEGASUS_OS_ZOS))
           // The cimprovagt forks and returns right away.  Clean up the zombie
           // process now instead of in reapProviderAgent().
           int status = 0;
           while ((status = waitpid(pid, 0, 0)) == -1 && errno == EINTR)
               ;
   #  endif
   
           PEG_METHOD_EXIT();
         return 0;         return 0;
  
 #endif /* !defined(START_PROVIDER_AGENT) */  # endif /* POSIX CASE */
   
   #else /* PEGASUS_ENABLE_PRIVILEGE_SEPARATION is defined */
   
           // Out-of-Process providers are never started by the cimserver process
           // when Privilege Separation is enabled.
           return -1;
   
   #endif
     }     }
  
     virtual int daemonizeExecutor()     virtual int daemonizeExecutor()
Line 428 
Line 530 
         return -1;         return -1;
     }     }
  
     virtual int reapProviderAgent(  #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
         int pid)      virtual int reapProviderAgent(int)
     {     {
         int status;          // Out-of-Process providers are never started by the cimserver process
           // when Privilege Separation is enabled.
           return -1;
       }
   #else  /* PEGASUS_ENABLE_PRIVILEGE_SEPARATION is NOT defined */
   # if defined(PEGASUS_HAS_SIGNALS) && \
        (defined(PEGASUS_DISABLE_PROV_USERCTXT) || defined(PEGASUS_OS_ZOS))
       virtual int reapProviderAgent(int pid)
       {
           int status = 0;
           // When provider user context is enabled, this is done in
           // startProviderAgent().
         while ((status = waitpid(pid, 0, 0)) == -1 && errno == EINTR)         while ((status = waitpid(pid, 0, 0)) == -1 && errno == EINTR)
             ;          {
           };
         return status;         return status;
     }     }
   # else
       virtual int reapProviderAgent(int)
       {
           return 0;
       }
   # endif
   #endif
   
  
   #if defined(PEGASUS_PAM_AUTHENTICATION)
     virtual int authenticatePassword(     virtual int authenticatePassword(
         const char* username,         const char* username,
         const char* password)         const char* password)
     {     {
 #if defined(PEGASUS_PAM_AUTHENTICATION)  
         return PAMAuthenticate(username, password);         return PAMAuthenticate(username, password);
 #else  
         // ATTN: not handled so don't call in this case.  
         return -1;  
 #endif  
     }     }
  
     virtual int validateUser(     virtual int validateUser(
         const char* username)         const char* username)
     {     {
     #if defined(PEGASUS_PAM_AUTHENTICATION)  
         return PAMValidateUser(username);         return PAMValidateUser(username);
       }
     #else     #else
       virtual int authenticatePassword(
           const char*,
           const char*)
       {
         // ATTN: not handled so don't call in this case.         // ATTN: not handled so don't call in this case.
         return -1;         return -1;
     #endif  
     }     }
  
     virtual int challengeLocal(      virtual int validateUser(
         const char* username,          const char*)
         char challenge[EXECUTOR_BUFFER_SIZE])  
     {     {
         // ATTN: not handled so don't call in this case.         // ATTN: not handled so don't call in this case.
         return -1;         return -1;
     }     }
   #endif
  
     virtual int authenticateLocal(      virtual int challengeLocal(
         const char* challenge,          const char*,
         const char* response)          char[EXECUTOR_BUFFER_SIZE])
     {     {
         // ATTN: not handled so don't call in this case.         // ATTN: not handled so don't call in this case.
         return -1;         return -1;
     }     }
  
 private:      virtual int authenticateLocal(
           const char*,
     static int _getProviderAgentPath(String& path)          const char*)
     {  
         path = PEGASUS_PROVIDER_AGENT_PROC_NAME;  
   
         if (path[0] != '/')  
         {         {
             const char* env = getenv("PEGASUS_HOME");          // ATTN: not handled so don't call in this case.
   
             if (!env)  
                 return -1;                 return -1;
   
             path = String(env) + String("/") + path;  
         }         }
  
       virtual int updateLogLevel(
           const char*)
       {
           // If Privilege Separation is not enabled, we don't need to update
           // the log level in the Executor.
         return 0;         return 0;
     }     }
  
   private:
   
     Mutex _mutex;     Mutex _mutex;
 }; };
  
Line 531 
Line 649 
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
         // _send request header:          // Send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
         header.code = EXECUTOR_PING_MESSAGE;         header.code = EXECUTOR_PING_MESSAGE;
  
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))          if (SendBlock(_sock, &header, sizeof(header)) != sizeof(header))
             return -1;             return -1;
  
         ExecutorPingResponse response;         ExecutorPingResponse response;
  
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))          if (RecvBlock(_sock, &response, sizeof(response)) != sizeof(response))
             return -1;             return -1;
  
         if (response.magic == EXECUTOR_PING_MAGIC)         if (response.magic == EXECUTOR_PING_MAGIC)
Line 559 
Line 677 
         if (mode != 'r' && mode != 'w' && mode != 'a')         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_MESSAGE;         header.code = EXECUTOR_OPEN_FILE_MESSAGE;
  
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))          if (SendBlock(_sock, &header, sizeof(header)) != sizeof(header))
             return NULL;             return NULL;
  
         // _send request body.          // Send request body.
  
         ExecutorOpenFileRequest request;         ExecutorOpenFileRequest request;
         memset(&request, 0, sizeof(request));         memset(&request, 0, sizeof(request));
         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 (SendBlock(_sock, &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 (RecvBlock(_sock, &response, sizeof(response)) != sizeof(response))
             return NULL;             return NULL;
  
         // Receive descriptor (if response successful).         // Receive descriptor (if response successful).
Line 613 
Line 731 
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
         // _send request header:          // Send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
         header.code = EXECUTOR_RENAME_FILE_MESSAGE;         header.code = EXECUTOR_RENAME_FILE_MESSAGE;
  
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))          if (SendBlock(_sock, &header, sizeof(header)) != sizeof(header))
             return -1;             return -1;
  
         // _send request body.          // Send request body.
  
         ExecutorRenameFileRequest request;         ExecutorRenameFileRequest request;
         memset(&request, 0, sizeof(request));         memset(&request, 0, sizeof(request));
         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 (SendBlock(_sock, &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 (RecvBlock(_sock, &response, sizeof(response)) != sizeof(response))
             return -1;             return -1;
  
         return response.status;         return response.status;
Line 646 
Line 764 
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
         // _send request header:          // Send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
         header.code = EXECUTOR_REMOVE_FILE_MESSAGE;         header.code = EXECUTOR_REMOVE_FILE_MESSAGE;
  
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))          if (SendBlock(_sock, &header, sizeof(header)) != sizeof(header))
             return -1;             return -1;
  
         // _send request body.          // Send request body.
  
         ExecutorRemoveFileRequest request;         ExecutorRemoveFileRequest request;
         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 (SendBlock(_sock, &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 (RecvBlock(_sock, &response, sizeof(response)) != sizeof(response))
             return -1;             return -1;
  
         return response.status;         return response.status;
     }     }
  
     virtual int startProviderAgent(     virtual int startProviderAgent(
           unsigned short bitness,
         const char* module,         const char* module,
         int uid,          const String& pegasusHome,
         int gid,          const String& userName,
         int& pid,         int& pid,
         AnonymousPipe*& readPipe,         AnonymousPipe*& readPipe,
         AnonymousPipe*& writePipe)         AnonymousPipe*& writePipe)
Line 688 
Line 807 
  
         // Reject strings longer than EXECUTOR_BUFFER_SIZE.         // Reject strings longer than EXECUTOR_BUFFER_SIZE.
  
         size_t n = strlen(module);          size_t moduleNameLength = strlen(module);
   
           if (moduleNameLength >= EXECUTOR_BUFFER_SIZE)
               return -1;
   
           CString userNameCString = userName.getCString();
           size_t userNameLength = strlen(userNameCString);
  
         if (n >= EXECUTOR_BUFFER_SIZE)          if (userNameLength >= EXECUTOR_BUFFER_SIZE)
             return -1;             return -1;
  
         // _send request header:          // Send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
         header.code = EXECUTOR_START_PROVIDER_AGENT_MESSAGE;         header.code = EXECUTOR_START_PROVIDER_AGENT_MESSAGE;
  
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))          if (SendBlock(_sock, &header, sizeof(header)) != sizeof(header))
             return -1;             return -1;
  
         // _send request body.          // Send request body.
  
         ExecutorStartProviderAgentRequest request;         ExecutorStartProviderAgentRequest request;
         memset(&request, 0, sizeof(request));         memset(&request, 0, sizeof(request));
         memcpy(request.module, module, n);          memcpy(request.module, module, moduleNameLength);
         request.uid = uid;          memcpy(request.userName, userNameCString, userNameLength);
         request.gid = gid;          request.moduleBitness = bitness;
  
         if (_send(_sock, &request, sizeof(request)) != sizeof(request))          if (SendBlock(_sock, &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 (RecvBlock(_sock, &response, sizeof(response)) != sizeof(response))
             return -1;             return -1;
  
         // Check response status and pid.         // Check response status and pid.
Line 757 
Line 882 
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
         // _send request header:          // Send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
         header.code = EXECUTOR_DAEMONIZE_EXECUTOR_MESSAGE;         header.code = EXECUTOR_DAEMONIZE_EXECUTOR_MESSAGE;
  
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))          if (SendBlock(_sock, &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 (RecvBlock(_sock, &response, sizeof(response)) != sizeof(response))
             return -1;             return -1;
  
         return response.status;         return response.status;
Line 778 
Line 903 
     virtual int reapProviderAgent(     virtual int reapProviderAgent(
         int pid)         int pid)
     {     {
         AutoMutex autoMutex(_mutex);          // The Executor process automatically cleans up all its child
           // processes, so it does not need to explicitly harvest the
           // exit status of the cimprovagt processes it starts.
  
         // _send request header:          return 0;
   
         ExecutorRequestHeader header;  
         header.code = EXECUTOR_REAP_PROVIDER_AGENT;  
   
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))  
             return -1;  
   
         // _send request body:  
   
         ExecutorReapProviderAgentRequest request;  
         memset(&request, 0, sizeof(request));  
         request.pid = pid;  
   
         if (_send(_sock, &request, sizeof(request)) != sizeof(request))  
             return -1;  
   
         // Receive the response  
   
         ExecutorReapProviderAgentResponse response;  
   
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))  
             return -1;  
   
         return response.status;  
     }     }
  
     virtual int authenticatePassword(     virtual int authenticatePassword(
Line 813 
Line 916 
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
         // _send request header:          // Send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
         header.code = EXECUTOR_AUTHENTICATE_PASSWORD_MESSAGE;         header.code = EXECUTOR_AUTHENTICATE_PASSWORD_MESSAGE;
  
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))          if (SendBlock(_sock, &header, sizeof(header)) != sizeof(header))
             return -1;             return -1;
  
         // _send request body.          // Send request body.
  
         ExecutorAuthenticatePasswordRequest request;         ExecutorAuthenticatePasswordRequest 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);         Strlcpy(request.password, password, EXECUTOR_BUFFER_SIZE);
  
         if (_send(_sock, &request, sizeof(request)) != sizeof(request))          if (SendBlock(_sock, &request, sizeof(request)) != sizeof(request))
             return -1;             return -1;
  
         // Receive the response         // Receive the response
  
         ExecutorAuthenticatePasswordResponse response;         ExecutorAuthenticatePasswordResponse response;
  
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))          if (RecvBlock(_sock, &response, sizeof(response)) != sizeof(response))
             return -1;             return -1;
  
         return response.status;         return response.status;
Line 846 
Line 949 
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
         // _send request header:          // Send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
         header.code = EXECUTOR_VALIDATE_USER_MESSAGE;         header.code = EXECUTOR_VALIDATE_USER_MESSAGE;
  
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))          if (SendBlock(_sock, &header, sizeof(header)) != sizeof(header))
             return -1;             return -1;
  
         // _send request body.          // Send request body.
  
         ExecutorValidateUserRequest 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);
  
         if (_send(_sock, &request, sizeof(request)) != sizeof(request))          if (SendBlock(_sock, &request, sizeof(request)) != sizeof(request))
             return -1;             return -1;
  
         // Receive the response         // Receive the response
  
         ExecutorValidateUserResponse response;         ExecutorValidateUserResponse response;
  
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))          if (RecvBlock(_sock, &response, sizeof(response)) != sizeof(response))
             return -1;             return -1;
  
         return response.status;         return response.status;
Line 875 
Line 978 
  
     virtual int challengeLocal(     virtual int challengeLocal(
         const char* username,         const char* username,
         char challenge[EXECUTOR_BUFFER_SIZE])          char challengeFilePath[EXECUTOR_BUFFER_SIZE])
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
         // _send request header:          // Send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
         header.code = EXECUTOR_CHALLENGE_LOCAL_MESSAGE;         header.code = EXECUTOR_CHALLENGE_LOCAL_MESSAGE;
  
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))          if (SendBlock(_sock, &header, sizeof(header)) != sizeof(header))
             return -1;             return -1;
  
         // _send request body.          // Send request body.
  
         ExecutorChallengeLocalRequest request;         ExecutorChallengeLocalRequest request;
         memset(&request, 0, sizeof(request));         memset(&request, 0, sizeof(request));
         Strlcpy(request.user, username, EXECUTOR_BUFFER_SIZE);         Strlcpy(request.user, username, EXECUTOR_BUFFER_SIZE);
  
         if (_send(_sock, &request, sizeof(request)) != sizeof(request))          if (SendBlock(_sock, &request, sizeof(request)) != sizeof(request))
             return -1;             return -1;
  
         // Receive the response         // Receive the response
  
         ExecutorChallengeLocalResponse response;         ExecutorChallengeLocalResponse response;
  
         if (_recv(_sock, &response, sizeof(response)) != sizeof(response))          if (RecvBlock(_sock, &response, sizeof(response)) != sizeof(response))
             return -1;             return -1;
  
         Strlcpy(challenge, response.challenge, EXECUTOR_BUFFER_SIZE);          Strlcpy(challengeFilePath, response.challenge, EXECUTOR_BUFFER_SIZE);
  
         return response.status;         return response.status;
     }     }
  
     virtual int authenticateLocal(     virtual int authenticateLocal(
         const char* challenge,          const char* challengeFilePath,
         const char* response)         const char* response)
     {     {
         AutoMutex autoMutex(_mutex);         AutoMutex autoMutex(_mutex);
  
         // _send request header:          // Send request header:
  
         ExecutorRequestHeader header;         ExecutorRequestHeader header;
         header.code = EXECUTOR_AUTHENTICATE_LOCAL_MESSAGE;         header.code = EXECUTOR_AUTHENTICATE_LOCAL_MESSAGE;
  
         if (_send(_sock, &header, sizeof(header)) != sizeof(header))          if (SendBlock(_sock, &header, sizeof(header)) != sizeof(header))
             return -1;             return -1;
  
         // _send request body.          // Send request body.
  
         ExecutorAuthenticateLocalRequest request;         ExecutorAuthenticateLocalRequest request;
         memset(&request, 0, sizeof(request));         memset(&request, 0, sizeof(request));
         Strlcpy(request.challenge, challenge, EXECUTOR_BUFFER_SIZE);          Strlcpy(request.challenge, challengeFilePath, EXECUTOR_BUFFER_SIZE);
         Strlcpy(request.response, response, EXECUTOR_BUFFER_SIZE);         Strlcpy(request.response, response, EXECUTOR_BUFFER_SIZE);
  
         if (_send(_sock, &request, sizeof(request)) != sizeof(request))          if (SendBlock(_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 (RecvBlock(_sock, &response_, sizeof(response_)) !=
                   sizeof(response_))
           {
             return -1;             return -1;
           }
  
         return response_.status;         return response_.status;
     }     }
  
 private:      virtual int updateLogLevel(
           const char* logLevel)
     static ssize_t _recv(int sock, void* buffer, size_t size)  
     {     {
         size_t r = size;          AutoMutex autoMutex(_mutex);
         char* p = (char*)buffer;  
   
         if (size == 0)  
             return -1;  
  
         while (r)          // Send request header:
         {  
             ssize_t n;  
  
             EXECUTOR_RESTART(read(sock, p, r), n);          ExecutorRequestHeader header;
           header.code = EXECUTOR_UPDATE_LOG_LEVEL_MESSAGE;
  
             if (n == -1)          if (SendBlock(_sock, &header, sizeof(header)) != sizeof(header))
                 return -1;                 return -1;
             else if (n == 0)  
                 return size - r;  
  
             r -= n;          // Send request body:
             p += n;  
         }  
  
         return size - r;          ExecutorUpdateLogLevelRequest request;
     }          memset(&request, 0, sizeof(request));
           Strlcpy(request.logLevel, logLevel, EXECUTOR_BUFFER_SIZE);
  
     static ssize_t _send(int sock, void* buffer, size_t size)          if (SendBlock(_sock, &request, sizeof(request)) != sizeof(request))
     {              return -1;
         size_t r = size;  
         char* p = (char*)buffer;  
  
         while (r)          // Receive the response
         {  
             ssize_t n;  
             EXECUTOR_RESTART(write(sock, p, r), n);  
  
             if (n == -1)          ExecutorUpdateLogLevelResponse response;
   
           if (RecvBlock(_sock, &response, sizeof(response)) != sizeof(response))
                 return -1;                 return -1;
             else if (n == 0)  
                 return size - r;  
  
             r -= n;          return response.status;
             p += n;  
         }         }
  
         return size - r;  private:
     }  
  
     int _sock;     int _sock;
     Mutex _mutex;     Mutex _mutex;
Line 1006 
Line 1096 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 static int _sock = -1;  static int _executorSock = -1;
 static ExecutorImpl* _impl = 0;  static AutoPtr<ExecutorImpl> _executorImpl;
 static Mutex _mutex;  static Once _executorImplOnce = PEGASUS_ONCE_INITIALIZER;
   
 static ExecutorImpl* _getImpl()  
 {  
     // Use the double-checked locking technique to avoid the overhead of a lock  
     // on every call.  
   
     if (_impl == 0)  
     {  
         _mutex.lock();  
  
         if (_impl == 0)  static void _initExecutorImpl()
         {         {
 #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
             if (_sock == -1)      if (_executorSock == -1)
                 _impl = new ExecutorLoopbackImpl();          _executorImpl.reset(new ExecutorLoopbackImpl());
             else             else
                 _impl = new ExecutorSocketImpl(_sock);          _executorImpl.reset(new ExecutorSocketImpl(_executorSock));
 #else #else
             _impl = new ExecutorLoopbackImpl();      _executorImpl.reset(new ExecutorLoopbackImpl());
 #endif #endif
         }         }
  
         _mutex.unlock();  
     }  
   
     return _impl;  
 }  
   
 void Executor::setSock(int sock) void Executor::setSock(int sock)
 { {
     _mutex.lock();      _executorSock = sock;
     _sock = sock;  
     _mutex.unlock();  
 } }
  
 int Executor::detectExecutor() int Executor::detectExecutor()
 { {
     return _getImpl()->detectExecutor();      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->detectExecutor();
 } }
  
 int Executor::ping() int Executor::ping()
 { {
     return _getImpl()->ping();      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->ping();
 } }
  
 FILE* Executor::openFile( FILE* Executor::openFile(
     const char* path,     const char* path,
     int mode)     int mode)
 { {
     return _getImpl()->openFile(path, mode);      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->openFile(path, mode);
 } }
  
 int Executor::renameFile( int Executor::renameFile(
     const char* oldPath,     const char* oldPath,
     const char* newPath)     const char* newPath)
 { {
     return _getImpl()->renameFile(oldPath, newPath);      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->renameFile(oldPath, newPath);
 } }
  
 int Executor::removeFile( int Executor::removeFile(
     const char* path)     const char* path)
 { {
     return _getImpl()->removeFile(path);      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->removeFile(path);
 } }
  
 int Executor::startProviderAgent( int Executor::startProviderAgent(
       unsigned short bitness,
     const char* module,     const char* module,
     int uid,      const String& pegasusHome,
     int gid,      const String& userName,
     int& pid,     int& pid,
     AnonymousPipe*& readPipe,     AnonymousPipe*& readPipe,
     AnonymousPipe*& writePipe)     AnonymousPipe*& writePipe)
 { {
     return _getImpl()->startProviderAgent(module,      once(&_executorImplOnce, _initExecutorImpl);
         uid, gid, pid, readPipe, writePipe);      return _executorImpl->startProviderAgent(bitness,
           module, pegasusHome, userName, pid, readPipe, writePipe);
 } }
  
 int Executor::daemonizeExecutor() int Executor::daemonizeExecutor()
 { {
     return _getImpl()->daemonizeExecutor();      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->daemonizeExecutor();
 } }
  
 int Executor::reapProviderAgent( int Executor::reapProviderAgent(
     int pid)     int pid)
 { {
     return _getImpl()->reapProviderAgent(pid);      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->reapProviderAgent(pid);
 } }
  
 int Executor::authenticatePassword( int Executor::authenticatePassword(
     const char* username,     const char* username,
     const char* password)     const char* password)
 { {
     return _getImpl()->authenticatePassword(username, password);      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->authenticatePassword(username, password);
 } }
  
 int Executor::validateUser( int Executor::validateUser(
     const char* username)     const char* username)
 { {
     return _getImpl()->validateUser(username);      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->validateUser(username);
 } }
  
 int Executor::challengeLocal( int Executor::challengeLocal(
     const char* user,     const char* user,
     char challenge[EXECUTOR_BUFFER_SIZE])      char challengeFilePath[EXECUTOR_BUFFER_SIZE])
 { {
     return _getImpl()->challengeLocal(user, challenge);      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->challengeLocal(user, challengeFilePath);
 } }
  
 int Executor::authenticateLocal( int Executor::authenticateLocal(
     const char* challenge,      const char* challengeFilePath,
     const char* response)     const char* response)
 { {
     return _getImpl()->authenticateLocal(challenge, response);      once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->authenticateLocal(challengeFilePath, response);
   }
   
   int Executor::updateLogLevel(
       const char* logLevel)
   {
       once(&_executorImplOnce, _initExecutorImpl);
       return _executorImpl->updateLogLevel(logLevel);
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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