(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.7 and 1.17

version 1.7, 2007/06/13 21:21:53 version 1.17, 2008/02/05 19:19:17
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 70 
Line 71 
 # 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 130 
Line 139 
     virtual int authenticateLocal(     virtual int authenticateLocal(
         const char* challengeFilePath,         const char* challengeFilePath,
         const char* response) = 0;         const char* response) = 0;
   
       virtual int updateLogLevel(
           const char* logLevel) = 0;
 }; };
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Line 165 
Line 177 
         switch (mode)         switch (mode)
         {         {
             case 'r':             case 'r':
                 return fopen(path, "rb");                  return fopen(path, "r");
  
             case 'w':             case 'w':
                 return fopen(path, "wb");                  return fopen(path, "w");
  
             case 'a':             case 'a':
                 return fopen(path, "a+");                 return fopen(path, "a+");
Line 201 
Line 213 
         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)
  
 # if defined(PEGASUS_OS_TYPE_WINDOWS) # if defined(PEGASUS_OS_TYPE_WINDOWS)
Line 263 
Line 276 
             &siStartInfo,  //  STARTUPINFO             &siStartInfo,  //  STARTUPINFO
             &piProcInfo))  //  PROCESS_INFORMATION             &piProcInfo))  //  PROCESS_INFORMATION
         {         {
               PEG_METHOD_EXIT();
             return -1;             return -1;
         }         }
  
Line 277 
Line 291 
         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 294 
Line 309 
         int to[2];         int to[2];
         int from[2];         int from[2];
  
   #  if defined(PEGASUS_OS_ZOS)
           // zOS is using __spawn2() instead of frok()
           struct __inheritance inherit;
           const char *c_argv[5];
           char arg1[32];
           char arg2[32];
   
   #  endif
   
         do         do
         {         {
             // Resolve full path of "cimprovagt".             // Resolve full path of "cimprovagt".
Line 301 
Line 325 
             String path = FileSystem::getAbsolutePath(             String path = FileSystem::getAbsolutePath(
                 pegasusHome.getCString(), PEGASUS_PROVIDER_AGENT_PROC_NAME);                 pegasusHome.getCString(), PEGASUS_PROVIDER_AGENT_PROC_NAME);
  
 #  if !defined(PEGASUS_DISABLE_PROV_USERCTXT)  #  if !defined(PEGASUS_DISABLE_PROV_USERCTXT) && !defined(PEGASUS_OS_ZOS)
  
             PEGASUS_UID_T newUid = (PEGASUS_UID_T)-1;             PEGASUS_UID_T newUid = (PEGASUS_UID_T)-1;
             PEGASUS_GID_T newGid = (PEGASUS_GID_T)-1;             PEGASUS_GID_T newGid = (PEGASUS_GID_T)-1;
Line 311 
Line 335 
                 if (!System::lookupUserId(                 if (!System::lookupUserId(
                          userName.getCString(), newUid, newGid))                          userName.getCString(), newUid, newGid))
                 {                 {
                     PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL2,                      PEG_TRACE((TRC_SERVER, Tracer::LEVEL2,
                         "System::lookupUserId(%s) failed.",                          "System::lookupUserId(%s) for provider user "
                               "context failed.",
                         (const char*)userName.getCString()));                         (const char*)userName.getCString()));
                       PEG_METHOD_EXIT();
                     return -1;                     return -1;
                 }                 }
             }             }
Line 323 
Line 349 
             // 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;
               }
   
               // Start provider agent:
   
   #  if defined(PEGASUS_OS_ZOS)
               // zOS is using __spawn2() to start provider agent
               sprintf(arg1, "%d", to[0]);
               sprintf(arg2, "%d", from[1]);
  
             // Fork process:              CString program_name = path.getCString();
  
 #  if defined(PEGASUS_OS_VMS)              c_argv[0] = program_name;
               c_argv[1] = arg1;
               c_argv[2] = arg2;
               c_argv[3] = module;
               c_argv[4] = 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));
   
               CString program = path.getCString();
   
               PEG_TRACE((TRC_SERVER, Tracer::LEVEL4,
                          "Starting provider agent: %s %s %s %s %s",
                          program,program_name,arg1,arg2,module));
   
               pid = __spawn2(program,0,NULL,&inherit,
                              c_argv,(const char **)environ);
   
               if (pid < 0)
               {
                   PEG_TRACE((TRC_SERVER, Tracer::LEVEL4,
                       "Spawn of provider agent fails:%s "
                           "( errno %d , reason code %08X )",
                       strerror(errno) ,errno,__errno2()));
                   PEG_METHOD_EXIT();
                   return -1;
               }
   
   #  elif 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 !defined(PEGASUS_OS_ZOS)
   
             if (pid < 0)             if (pid < 0)
               {
                   PEG_TRACE((TRC_SERVER, Tracer::LEVEL4,
                        "Fork for provider agent fails: errno = %d",errno));
                   PEG_METHOD_EXIT();
                 return -1;                 return -1;
               }
  
             // If child proceses.             // If child proceses.
   
             if (pid == 0)             if (pid == 0)
             {             {
 #  if !defined(PEGASUS_OS_VMS) #  if !defined(PEGASUS_OS_VMS)
Line 394 
Line 475 
                     CString cstr = path.getCString();                     CString cstr = path.getCString();
                     if (execl(cstr, cstr, arg1, arg2, module, (char*)0) == -1)                     if (execl(cstr, cstr, arg1, arg2, module, (char*)0) == -1)
                     {                     {
                         PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL2,                          PEG_TRACE((TRC_SERVER, Tracer::LEVEL2,
                             "execl() failed.  errno = %d.", errno));                             "execl() failed.  errno = %d.", errno));
                         _exit(1);                         _exit(1);
                     }                     }
                 }                 }
             }             }
   #  else  /* PEGASUS_OS_ZOS */
               if (pid > 0)
               {
                   PEG_TRACE((TRC_SERVER, Tracer::LEVEL4,
                        "Provider agent started suggessfully: Pid(%d).",pid));
                   break;
               }
   #endif /* PEGASUS_OS_ZOS */
   
         }         }
         while (0);         while (0);
  
Line 424 
Line 514 
         readPipe = new AnonymousPipe(readFdStr, 0);         readPipe = new AnonymousPipe(readFdStr, 0);
         writePipe = new AnonymousPipe(0, writeFdStr);         writePipe = new AnonymousPipe(0, writeFdStr);
  
           PEG_METHOD_EXIT();
         return 0;         return 0;
  
 # endif /* POSIX CASE */ # endif /* POSIX CASE */
Line 504 
Line 595 
         return -1;         return -1;
     }     }
  
       virtual int updateLogLevel(
           const char* logLevel)
       {
           // If Privilege Separation is not enabled, we don't need to update
           // the log level in the Executor.
           return 0;
       }
   
 private: private:
  
     Mutex _mutex;     Mutex _mutex;
Line 540 
Line 639 
     {     {
         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 568 
Line 667 
         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 622 
Line 721 
     {     {
         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 655 
Line 754 
     {     {
         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;
Line 708 
Line 807 
         if (userNameLength >= 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, moduleNameLength);         memcpy(request.module, module, moduleNameLength);
         memcpy(request.userName, userNameCString, userNameLength);         memcpy(request.userName, userNameCString, userNameLength);
  
         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 771 
Line 870 
     {     {
         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 792 
Line 891 
     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
         // _send request header:          // exit status of the cimprovagt processes it starts.
  
         ExecutorRequestHeader header;          return 0;
         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 827 
Line 904 
     {     {
         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 860 
Line 937 
     {     {
         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 893 
Line 970 
     {     {
         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(challengeFilePath, response.challenge, EXECUTOR_BUFFER_SIZE);         Strlcpy(challengeFilePath, response.challenge, EXECUTOR_BUFFER_SIZE);
Line 928 
Line 1005 
     {     {
         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, challengeFilePath, 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)          // Send request header:
             return -1;  
  
         while (r)          ExecutorRequestHeader header;
         {          header.code = EXECUTOR_UPDATE_LOG_LEVEL_MESSAGE;
             ssize_t n;  
   
             EXECUTOR_RESTART(read(sock, p, r), n);  
  
             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;          ExecutorUpdateLogLevelResponse response;
             EXECUTOR_RESTART(write(sock, p, r), n);  
  
             if (n == -1)          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 1133 
Line 1197 
     return _executorImpl->authenticateLocal(challengeFilePath, response);     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.7  
changed lines
  Added in v.1.17
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2