(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.14 and 1.20

version 1.14, 2008/01/28 10:10:58 version 1.20, 2008/08/28 17:24:36
Line 41 
Line 41 
 # include <windows.h> # include <windows.h>
 #else #else
 # include <unistd.h> # include <unistd.h>
   # include <errno.h>
 # include <sys/types.h> # include <sys/types.h>
 # include <sys/time.h> # include <sys/time.h>
 # include <sys/resource.h> # include <sys/resource.h>
Line 74 
Line 75 
 # include <as400_protos.h> // For fork400() # include <as400_protos.h> // For fork400()
 #endif #endif
  
   #ifdef PEGASUS_OS_ZOS
   # include <spawn.h>
   #endif
   
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Line 169 
Line 174 
         const char* path,         const char* path,
         int mode)         int mode)
     {     {
           FILE* fhandle = NULL;
         switch (mode)         switch (mode)
         {         {
             case 'r':             case 'r':
                 return fopen(path, "rt");                  fhandle = fopen(path, "r");
                   break;
  
             case 'w':             case 'w':
                 return fopen(path, "wt");                  fhandle = fopen(path, "w");
                   break;
  
             case 'a':             case 'a':
                 return fopen(path, "at+");                  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 208 
Line 226 
         AnonymousPipe*& readPipe,         AnonymousPipe*& readPipe,
         AnonymousPipe*& writePipe)         AnonymousPipe*& writePipe)
     {     {
           PEG_METHOD_ENTER(TRC_SERVER,"ExecutorLoopbackImpl::startProviderAgent");
   
 #if !defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION) #if !defined(PEGASUS_ENABLE_PRIVILEGE_SEPARATION)
  
           // Resolve full path of "cimprovagt" program.
   
           String path = FileSystem::getAbsolutePath(
               pegasusHome.getCString(), 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)
           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 241 
Line 277 
         ZeroMemory(&siStartInfo, sizeof (STARTUPINFO));         ZeroMemory(&siStartInfo, sizeof (STARTUPINFO));
         siStartInfo.cb = sizeof (STARTUPINFO);         siStartInfo.cb = sizeof (STARTUPINFO);
  
         // Build full path of "cimprovagt" program.  
   
         String path = FileSystem::getAbsolutePath(  
             pegasusHome.getCString(), PEGASUS_PROVIDER_AGENT_PROC_NAME);  
   
         // 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 270 
Line 303 
             &siStartInfo,  //  STARTUPINFO             &siStartInfo,  //  STARTUPINFO
             &piProcInfo))  //  PROCESS_INFORMATION             &piProcInfo))  //  PROCESS_INFORMATION
         {         {
               PEG_METHOD_EXIT();
             return -1;             return -1;
         }         }
  
Line 284 
Line 318 
         readPipe = pipeFromAgent.release();         readPipe = pipeFromAgent.release();
         writePipe = pipeToAgent.release();         writePipe = pipeToAgent.release();
  
           PEG_METHOD_EXIT();
         return 0;         return 0;
  
 # else /* POSIX CASE FOLLOWS */ # else /* POSIX CASE FOLLOWS */
Line 300 
Line 335 
  
         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".              // Create "to-agent" pipe:
   
             String path = FileSystem::getAbsolutePath(  
                 pegasusHome.getCString(), PEGASUS_PROVIDER_AGENT_PROC_NAME);  
  
 #  if !defined(PEGASUS_DISABLE_PROV_USERCTXT) && !defined(PEGASUS_OS_ZOS)              if (pipe(to) != 0)
               {
                   PEG_METHOD_EXIT();
                   return -1;
               }
  
             PEGASUS_UID_T newUid = (PEGASUS_UID_T)-1;              // Create "from-agent" pipe:
             PEGASUS_GID_T newGid = (PEGASUS_GID_T)-1;  
  
             if (userName != System::getEffectiveUserName())              if (pipe(from) != 0)
             {  
                 if (!System::lookupUserId(  
                          userName.getCString(), newUid, newGid))  
                 {                 {
                     PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL2,                  PEG_METHOD_EXIT();
                         "System::lookupUserId(%s) failed.",  
                         (const char*)userName.getCString()));  
                     return -1;                     return -1;
                 }                 }
             }  
  
 #  endif /* !defined(PEGASUS_DISABLE_PROV_USERCTXT) */              // Initialize the cimprovagt pipe arguments:
  
             // Create "to-agent" pipe:              sprintf(toPipeArg, "%d", to[0]);
               sprintf(fromPipeArg, "%d", from[1]);
  
             if (pipe(to) != 0)              // Start provider agent:
                 return -1;  
  
             // Create "from-agent" pipe:  #  if defined(PEGASUS_OS_ZOS)
               // zOS uses __spawn2() instead of fork() to start provider agent
  
             if (pipe(from) != 0)              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;                 return -1;
               }
  
             // Fork process:  #  else    // !defined(PEGASUS_OS_ZOS)
  
 #  if defined(PEGASUS_OS_VMS) #  if defined(PEGASUS_OS_VMS)
             pid = (int)vfork();             pid = (int)vfork();
Line 348 
Line 419 
 #  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) #  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]);
  
   
                 // 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 377 
Line 452 
  
 #  endif /* !defined(PEGASUS_OS_VMS) */ #  endif /* !defined(PEGASUS_OS_VMS) */
  
 #  if !defined(PEGASUS_DISABLE_PROV_USERCTXT) && !defined(PEGASUS_OS_ZOS)  
   
                 // Set uid and gid for the new provider agent process.  
   
                 if (newUid != (PEGASUS_UID_T)-1 && newGid != (PEGASUS_GID_T)-1)  
                 {  
                     if (!System::changeUserContext_SingleThreaded(  
                              userName.getCString(), newUid, newGid))  
                     {  
                         return -1;  
                     }  
                 }  
   
 #  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(
                     if (execl(cstr, cstr, arg1, arg2, module, (char*)0) == -1)                              agentProgramPath,
                               agentProgramPath,
                               setUserContextFlag,
                               toPipeArg,
                               fromPipeArg,
                               (const char*)userNameCString,
                               module,
                               (char*)0) == -1)
                     {                     {
                         PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL2,                          PEG_TRACE((TRC_SERVER, Tracer::LEVEL1,
                             "execl() failed.  errno = %d.", errno));                             "execl() failed.  errno = %d.", errno));
                         _exit(1);                         _exit(1);
                     }                     }
                 }                 }
             }             }
   #  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 433 
Line 499 
         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)
   #   if !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
   #  endif
   
           PEG_METHOD_EXIT();
         return 0;         return 0;
  
 # endif /* POSIX CASE */ # endif /* POSIX CASE */
Line 459 
Line 536 
         int status = 0;         int status = 0;
  
 # if defined(PEGASUS_HAS_SIGNALS) # if defined(PEGASUS_HAS_SIGNALS)
   #  if defined(PEGASUS_DISABLE_PROV_USERCTXT) || defined(PEGASUS_OS_ZOS)
           // 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)
             ;             ;
 # endif # endif
   # endif
  
         return status;         return status;
  

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