(file) Return to PAMBasicAuthenticatorUnix.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Security / Authentication

Diff for /pegasus/src/Pegasus/Security/Authentication/PAMBasicAuthenticatorUnix.cpp between version 1.36 and 1.36.2.1

version 1.36, 2007/03/16 17:16:58 version 1.36.2.1, 2007/03/23 21:53:54
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Nag Boranna, Hewlett-Packard Company(nagaraja_boranna@hp.com)  
 //  
 // Modified By: Yi Zhou, Hewlett-Packard Company(yi_zhou@hp.com)  
 //            : Sushma Fernandes, Hewlett-Packard Company  
 //                (sushma_fernandes@hp.com)  
 //                Josephine Eskaline Joyce (jojustin@in.ibm.com) for PEP#101  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <Pegasus/Common/System.h>  #include <Pegasus/Common/Executor.h>
 #include <Pegasus/Common/Tracer.h>  
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
 #include <Pegasus/Common/FileSystem.h>  #include <Pegasus/Common/Tracer.h>
 #include <Pegasus/Common/Signal.h>  
   
 #if defined (PEGASUS_OS_HPUX)  
 #include <prot.h>  
 #endif  
   
 #if defined (PEGASUS_USE_PAM_STANDALONE_PROC)  
 #include <Pegasus/Common/Logger.h>  
 #include <pwd.h>  
 #include <sys/stat.h>  
 #include <unistd.h>  
 #include <sys/types.h>  
 #include <sys/resource.h>  
 #if defined(PEGASUS_HAS_SIGNALS)  
 # include <sys/wait.h>  
 #endif  
 #endif  
   
   
 #include "PAMBasicAuthenticator.h" #include "PAMBasicAuthenticator.h"
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 #include <security/pam_appl.h>  
   
 #if defined(PEGASUS_OS_LSB)  
 #ifndef PAM_MAX_MSG_SIZE  
 #define PAM_MAX_MSG_SIZE      512  
 #endif  
 #endif  
   
 #define BUFFERLEN 1024  
   
 /**  
     Constant representing the Basic authentication challenge header.  
 */  
 static const String BASIC_CHALLENGE_HEADER = "WWW-Authenticate: Basic \"";  
   
 Mutex PAMBasicAuthenticator::_authSerializeMutex;  
   
 /** Service name for pam_start */  
 const char *service = "wbem";  
   
 typedef struct  
 {  
     CString userPassword;  
 } APP_DATA;  
   
 /* constructor. */  
 PAMBasicAuthenticator::PAMBasicAuthenticator() PAMBasicAuthenticator::PAMBasicAuthenticator()
 { {
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,     PEG_METHOD_ENTER(TRC_AUTHENTICATION,
         "PAMBasicAuthenticator::PAMBasicAuthenticator()");         "PAMBasicAuthenticator::PAMBasicAuthenticator()");
  
     //      // Build up realm: <hostname>:<port>
     // get the local system name  
     //  
     _realm.assign(System::getHostName());     _realm.assign(System::getHostName());
  
     //  
     // get the configured port number     // get the configured port number
     //  
     ConfigManager* configManager = ConfigManager::getInstance();     ConfigManager* configManager = ConfigManager::getInstance();
   
     String port = configManager->getCurrentValue("httpPort");     String port = configManager->getCurrentValue("httpPort");
  
     //     //
Line 119 
Line 62 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 /* destructor. */  
 PAMBasicAuthenticator::~PAMBasicAuthenticator() PAMBasicAuthenticator::~PAMBasicAuthenticator()
 { {
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,     PEG_METHOD_ENTER(TRC_AUTHENTICATION,
Line 130 
Line 72 
  
 Boolean PAMBasicAuthenticator::authenticate( Boolean PAMBasicAuthenticator::authenticate(
     const String& userName,     const String& userName,
     const String& password)      const String& password,
       SessionKey& sessionKey)
 { {
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,     PEG_METHOD_ENTER(TRC_AUTHENTICATION,
         "PAMBasicAuthenticator::authenticate()");         "PAMBasicAuthenticator::authenticate()");
  
     Boolean authenticated;      if (Executor::authenticatePassword(
           userName.getCString(), password.getCString(), sessionKey) != 0)
 #if !defined(PEGASUS_USE_PAM_STANDALONE_PROC)  
         authenticated = _authenticateByPAM(userName, password);  
 #else  
         //  
         // Mutex to Serialize Authentication calls.  
         //  
         PEG_TRACE_CSTRING(TRC_AUTHENTICATION, Tracer::LEVEL4,  
            "Authentication Mutex lock.");  
         AutoMutex lock(_authSerializeMutex);  
         authenticated = _pamBasicAuthenticatorStandAlone.authenticate(  
             userName, password);  
 #endif  
   
     PEG_METHOD_EXIT();  
     return (authenticated);  
 }  
   
 Boolean PAMBasicAuthenticator::_authenticateByPAM(  
     const String& userName,  
     const String& password)  
 { {
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,          return false;
         "PAMBasicAuthenticator::_authenticateByPAM()");  
   
     Boolean authenticated = false;  
     struct pam_conv pconv;  
     pam_handle_t *phandle;  
     char *name;  
     APP_DATA mydata;  
   
     //  
     // Store the password for PAM authentication  
     //  
     mydata.userPassword = password.getCString();  
   
     pconv.conv = PAMBasicAuthenticator::PAMCallback;  
     pconv.appdata_ptr = &mydata;  
   
 //    WARNING: Should only be uncommented for debugging in a secure environment.  
 //    PEG_TRACE((TRC_AUTHENTICATION, Tracer::LEVEL4,  
 //       "PAMBasicAuthenticator::_authenticateByPAM() - userName = %s; userPassword = %s",  
 //       (const char *)userName.getCString(), (const char *)password.getCString()));  
   
     //  
     //Call pam_start since you need to before making any other PAM calls  
     //  
     int rc = pam_start(service,  
                        (const char *)userName.getCString(), &pconv, &phandle);  
     if ( rc != PAM_SUCCESS )  
     {  
         PEG_TRACE((TRC_AUTHENTICATION, Tracer::LEVEL4,  
            "PAMBasicAuthenticator::_authenticateByPAM() - pam_start failed! %d", rc));  
         PEG_METHOD_EXIT();  
         return (authenticated);  
     }     }
  
     //  
     //Call pam_authenticate to authenticate the user  
     //  
     rc = pam_authenticate(phandle, 0);  
     if ( rc == PAM_SUCCESS )  
     {  
        PEG_TRACE_CSTRING(TRC_AUTHENTICATION, Tracer::LEVEL4,  
          "pam_authenticate successful.");  
         //  
         //Call pam_acct_mgmt, to check if the user account is valid. This includes  
         //checking for password and account expiration, as well as verifying access  
         //hour restrictions.  
         //  
         rc = pam_acct_mgmt(phandle, 0);  
         if ( rc == PAM_SUCCESS )  
         {  
            PEG_TRACE_CSTRING(TRC_AUTHENTICATION, Tracer::LEVEL4,  
               "pam_acct_mgmt successful.");  
             authenticated = true;  
         }  
         else  
         {  
            PEG_TRACE((TRC_AUTHENTICATION, Tracer::LEVEL4,  
               "PAMBasicAuthenticator::_authenticateByPAM() - pam_acct_mgmt failed! %d", rc));  
         }  
     }  
     else  
     {  
         PEG_TRACE((TRC_AUTHENTICATION, Tracer::LEVEL4,  
            "PAMBasicAuthenticator::_authenticateByPAM() - pam_authenticate failed! %d", rc));  
     }  
   
     //  
     //Call pam_end to end our PAM work  
     //  
     pam_end(phandle, 0);  
   
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
       return true;
     return (authenticated);  
 } }
  
 Boolean PAMBasicAuthenticator::validateUser(const String& userName) Boolean PAMBasicAuthenticator::validateUser(const String& userName)
Line 240 
Line 93 
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,     PEG_METHOD_ENTER(TRC_AUTHENTICATION,
         "PAMBasicAuthenticator::validateUser()");         "PAMBasicAuthenticator::validateUser()");
  
     Boolean authenticated = false;      if (Executor::validateUser(userName.getCString()) != 0)
           return false;
 #if !defined(PEGASUS_USE_PAM_STANDALONE_PROC)  
     struct pam_conv pconv;  
     pam_handle_t *phandle;  
     char *name;  
     APP_DATA mydata;  
   
     const char *service = "wbem";  
     pconv.conv = PAMBasicAuthenticator::pamValidateUserCallback;  
     pconv.appdata_ptr = &mydata;  
   
     //  
     // Call pam_start since you need to before making any other PAM calls  
     //  
     int rc = pam_start(service,  
                        (const char *)userName.getCString(), &pconv, &phandle);  
     if ( rc != PAM_SUCCESS )  
     {  
         PEG_TRACE((TRC_AUTHENTICATION, Tracer::LEVEL4,  
            "PAMBasicAuthenticator::validateUser() - pam_start failed! %d", rc));  
         PEG_METHOD_EXIT();  
         return (authenticated);  
     }  
   
     //  
     // Call pam_acct_mgmt, to check if the user account is valid. This includes  
     // checking for account expiration, as well as verifying access  
     // hour restrictions.  
     //  
     rc = pam_acct_mgmt(phandle, 0);  
     if ( rc == PAM_SUCCESS )  
     {  
         authenticated = true;  
     }  
     else  
     {  
         PEG_TRACE((TRC_AUTHENTICATION, Tracer::LEVEL4,  
            "PAMBasicAuthenticator::validateUser() - pam_acct_mgmt failed! %d", rc));  
     }  
   
     //  
     //Call pam_end to end our PAM work  
     //  
     pam_end(phandle, 0);  
   
 #else  
     //  
     // Mutex to Serialize Authentication calls.  
     //  
     PEG_TRACE_CSTRING(TRC_AUTHENTICATION, Tracer::LEVEL4,  
            "Authentication Mutex lock.");  
     AutoMutex lock(_authSerializeMutex);  
     authenticated = _pamBasicAuthenticatorStandAlone.validateUser(  
             userName);  
 #endif  
   
     PEG_METHOD_EXIT();  
     return (authenticated);  
   
 }  
   
 Sint32 PAMBasicAuthenticator::pamValidateUserCallback( Sint32 num_msg,  
 #if defined (PEGASUS_OS_LINUX)  
         const struct pam_message **msg,  
 #else  
         struct pam_message **msg,  
 #endif  
         struct pam_response **resp,  
         void *appdata_ptr)  
 {  
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,  
         "PAMBasicAuthenticator::pamValidateUserCallback()");  
  
     //  
     // Allocate the response buffers  
     //  
     if ( num_msg > 0 )  
     {  
         //  
         // Since resp->resp needs to be initialized in all possible scenarios,  
         // use calloc for memory allocation.  
         //  
         *resp =  
           (struct pam_response *)calloc(num_msg, sizeof(struct pam_response));  
   
         if ( *resp == NULL )  
         {  
             PEG_METHOD_EXIT();  
             return PAM_BUF_ERR;  
         }  
     }  
     else  
     {  
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         return PAM_CONV_ERR;      return true;
     }     }
  
     PEG_METHOD_EXIT();  
     return PAM_SUCCESS;  
 }  
  
 //  
 // Create authentication response header  
 //  
 String PAMBasicAuthenticator::getAuthResponseHeader() String PAMBasicAuthenticator::getAuthResponseHeader()
 { {
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,     PEG_METHOD_ENTER(TRC_AUTHENTICATION,
         "PAMBasicAuthenticator::getAuthResponseHeader()");         "PAMBasicAuthenticator::getAuthResponseHeader()");
  
     //      // Build response header: WWW-Authenticate: Basic "<hostname>:<port>"
     // build response header using realm  
     //      String responseHeader = "WWW-Authenticate: Basic \"";
     String responseHeader = BASIC_CHALLENGE_HEADER;  
     responseHeader.append(_realm);     responseHeader.append(_realm);
     responseHeader.append("\"");     responseHeader.append("\"");
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
       return responseHeader;
     return (responseHeader);  
 }  
   
 #if defined PEGASUS_OS_LINUX  
 Sint32 PAMBasicAuthenticator::PAMCallback(Sint32 num_msg, const struct pam_message **msg,  
         struct pam_response **resp, void *appdata_ptr)  
 #else  
 Sint32 PAMBasicAuthenticator::PAMCallback(Sint32 num_msg, struct pam_message **msg,  
         struct pam_response **resp, void *appdata_ptr)  
 #endif  
 {  
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,  
         "PAMBasicAuthenticator::PAMCallback()");  
   
     //  
     // Copy the application specific data from the PAM structure.  
     //  
     APP_DATA *mydata;  
     mydata = (APP_DATA *) appdata_ptr;  
   
     //  
     // Allocate the response buffers  
     //  
     if ( num_msg > 0 )  
     {  
         //  
         // Since resp->resp needs to be initialized in all possible scenarios,  
         // use calloc for memory allocation.  
         //  
         *resp = (struct pam_response *)calloc(num_msg, sizeof(struct pam_response));  
   
         if ( *resp == NULL )  
         {  
             PEG_METHOD_EXIT();  
             return PAM_BUF_ERR;  
         }  
     }  
     else  
     {  
         PEG_METHOD_EXIT();  
         return PAM_CONV_ERR;  
     }  
   
     for ( Sint32 i = 0; i < num_msg; i++ )  
     {  
         switch ( msg[i]->msg_style )  
         {  
             case PAM_PROMPT_ECHO_OFF:  
                 //  
                 // copy the user password  
                 //  
                 resp[i]->resp = (char *)malloc(PAM_MAX_MSG_SIZE);  
                 strcpy(resp[i]->resp, mydata->userPassword);  
                 resp[i]->resp_retcode = 0;  
                 break;  
   
             default:  
                PEG_METHOD_EXIT();  
                return PAM_CONV_ERR;  
         }  
     }  
   
     PEG_METHOD_EXIT();  
   
     return PAM_SUCCESS;  
 }  
   
 /** Routines to access PAM Authentication via a standalone process **/  
   
 #if defined(PEGASUS_USE_PAM_STANDALONE_PROC)  
   
 int     fd_1[2], fd_2[2];  
 Boolean continue_PAMauthentication;  
 Boolean printed_err_since_success=false;  
   
 const String PAMBasicAuthenticatorStandAlone::PAM_OPERATION_SUCCESS = "T";  
   
 const String PAMBasicAuthenticatorStandAlone::OPERATION_PAM_AUTHENTICATION = "A";  
   
 const String PAMBasicAuthenticatorStandAlone::OPERATION_PAM_ACCT_MGMT = "M";  
   
 /* constructor. */  
 PAMBasicAuthenticatorStandAlone::PAMBasicAuthenticatorStandAlone()  
 {  
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,  
         "PAMBasicAuthenticatorStandAlone::PAMBasicAuthenticatorStandAlone()");  
   
 #if defined(PEGASUS_HAS_SIGNALS)  
     _pid = -1;  
 #endif  
   
     _createPAMStandalone();  
   
     SignalHandler::ignore(PEGASUS_SIGPIPE);  
   
     PEG_METHOD_EXIT();  
 }  
   
 /* destructor. */  
 PAMBasicAuthenticatorStandAlone::~PAMBasicAuthenticatorStandAlone()  
 {  
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,  
         "PAMBasicAuthenticatorStandAlone::~PAMBasicAuthenticatorStandAlone()");  
   
 #if defined(PEGASUS_HAS_SIGNALS)  
     // Harvest the status of the previous standalone process, if any  
     if (_pid != -1)  
     {  
         waitpid(_pid, 0, WNOHANG);  
         _pid = -1;  
     }  
 #endif  
   
     PEG_METHOD_EXIT();  
 }  
   
 Boolean PAMBasicAuthenticatorStandAlone::authenticate(  
     const String& userName,  
     const String& password)  
 {  
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,  
         "PAMBasicAuthenticatorStandAlone::authenticate()");  
   
     Boolean authenticated = false;  
   
     // Send over the username ...  
     if (continue_PAMauthentication)  
     {  
         //  
         // On a broken connection, try restarting the authentication process  
         // and resend username.  
         //  
         if (_writeString (userName) ==  
                 PAMBasicAuthenticatorStandAlone::BROKEN_CONNECTION)  
         {  
             _restartProcess();  
             _writeString (userName);  
         }  
     }  
   
     // Send over the password ...  
     if (continue_PAMauthentication)  
     {  
         _writeString (password);  
     }  
   
     // Send over the operation code.  
     if (continue_PAMauthentication)  
     {  
         _writeString (OPERATION_PAM_AUTHENTICATION);  
     }  
   
     // Now read back the PAM Authentication status value (T/F)  
     if (continue_PAMauthentication)  
     {  
         if (_readString() == PAM_OPERATION_SUCCESS)  
         {  
             authenticated = true;  
             printed_err_since_success = false;  
         }  
     }  
   
     PEG_METHOD_EXIT();  
     return (authenticated);  
 }  
   
 Boolean PAMBasicAuthenticatorStandAlone::validateUser(  
     const String& userName)  
 {  
     PEG_METHOD_ENTER(TRC_AUTHENTICATION,  
         "PAMBasicAuthenticatorStandAlone::validateUser()");  
   
     Boolean authenticated = false;  
   
     // Send over the username ...  
     if (continue_PAMauthentication)  
     {  
         //  
         // On a broken connection, try restarting the authentication process  
         // and resend username.  
         //  
         if (_writeString (userName) ==  
                 PAMBasicAuthenticatorStandAlone::BROKEN_CONNECTION)  
         {  
             _restartProcess();  
             _writeString(userName);  
         }  
     }  
   
     // Send over the password ...  
     if (continue_PAMauthentication)  
     {  
         _writeString(String::EMPTY);  
     }  
   
     // Send over the operation code.  
     if (continue_PAMauthentication)  
     {  
         _writeString (OPERATION_PAM_ACCT_MGMT);  
     }  
   
     // Now read back the PAM Authentication status value (T/F)  
     if (continue_PAMauthentication)  
     {  
         if (_readString() == PAM_OPERATION_SUCCESS)  
         {  
             authenticated = true;  
             printed_err_since_success = false;  
         }  
     }  
   
     PEG_METHOD_EXIT();  
     return (authenticated);  
 }  
   
 PAMBasicAuthenticatorStandAlone::_Status  
          PAMBasicAuthenticatorStandAlone::_writeString(const String& text)  
 {  
     char        line[BUFFERLEN];  
     int         n, ret_code;  
     PAMBasicAuthenticatorStandAlone::_Status    status =  
                         PAMBasicAuthenticatorStandAlone::SUCCESS;  
   
     CString copy_of_text=text.getCString();  
     n = strlen(copy_of_text);  
   
     sprintf(line, "%4u%s", n, (const char*)copy_of_text);  
     n = strlen(line);  
   
     continue_PAMauthentication = true;  
     ret_code = write(fd_1[1], line, n);  
   
     if (ret_code != n)  
     {  
         continue_PAMauthentication = false;  
         status = PAMBasicAuthenticatorStandAlone::OTHER_ERROR;  
   
         if (errno == EPIPE)  
         {  
             status = PAMBasicAuthenticatorStandAlone::BROKEN_CONNECTION;  
         }  
         if (printed_err_since_success == false)  
         {  
             printed_err_since_success = true;  
             Logger::put(Logger::ERROR_LOG, System::CIMSERVER,  
                         Logger::SEVERE,  
                        "Error processing PAM Authentication request (write).");  
         }  
     }     }
  
     return status;  
 }  
   
   
 void PAMBasicAuthenticatorStandAlone::_restartProcess(void)  
 {  
     _createPAMStandalone();  
 }  
   
 String PAMBasicAuthenticatorStandAlone::_readString()  
 {  
     char authReply[10];  
   
     authReply[0] = '\0';  
     int n = read(fd_2[0], authReply, 2);  /* read back the reply */  
   
     if (n < 0)  
     {  
         continue_PAMauthentication = false;  
         if (printed_err_since_success == false)  
         {  
             printed_err_since_success = true;  
             //L10N TODO  
             Logger::put(Logger::ERROR_LOG, System::CIMSERVER,  
               Logger::SEVERE,  
              "Error processing PAM Authentication request (read).");  
         }  
     }  
     else  
     {  
         authReply[n] = '\0';  
     }  
   
     return (String(authReply));  
 }  
   
 void PAMBasicAuthenticatorStandAlone::_createPAMStandalone()  
 {  
     pid_t   pid;  
   
 #if defined(PEGASUS_HAS_SIGNALS)  
     // Harvest the status of the previous standalone process, if any  
     if (_pid != -1)  
     {  
         waitpid(_pid, 0, WNOHANG);  
         _pid = -1;  
     }  
 #endif  
   
     continue_PAMauthentication = true;  
     if (pipe(fd_1) < 0)   // Pipe to write to authentication proc  
     {  
         continue_PAMauthentication = false;  
         if (printed_err_since_success == false)  
         {  
             printed_err_since_success = true;  
             //L10N TODO  
             Logger::put(Logger::ERROR_LOG, System::CIMSERVER,  
                   Logger::SEVERE,  
                   "Error processing PAM Authentication request (pipe).");  
         }  
     }  
     if (continue_PAMauthentication)  
     {  
         if (pipe(fd_2) < 0)   // Pipe to read from the authentication proc  
         {  
             continue_PAMauthentication = false;  
             if (printed_err_since_success == false)  
             {  
                 printed_err_since_success = true;  
                 //L10N TODO  
                 Logger::put(Logger::ERROR_LOG, System::CIMSERVER,  
                       Logger::SEVERE,  
                       "Error processing PAM Authentication request (pipe).");  
             }  
         }  
     }  
   
     if (continue_PAMauthentication)  
     {  
         if ((pid = fork()) < 0)  
         {  
             continue_PAMauthentication = false;  
             if (printed_err_since_success == false)  
             {  
                 printed_err_since_success = true;  
                 //L10N TODO  
                 Logger::put(Logger::ERROR_LOG, System::CIMSERVER,  
                       Logger::SEVERE,  
                       "Error processing PAM Authentication request (fork).");  
             }  
         }  
         else if (pid > 0)       // This is the PARENT side of the fork  
         {  
             close(fd_1[0]);     // close read end on 1st pipe  
             close(fd_2[1]);     // close write end on 2nd pipe  
 #if defined(PEGASUS_HAS_SIGNALS)  
             _pid = pid;  
 #endif  
         }  
         else                     // This is the CHILD side of the fork  
         {  
   
             // Direct standard error to /dev/null,  
             // since we are running as a daemon.  
             close(2);  
             open("/dev/null", O_RDWR);  
   
             close(fd_1[1]);      // close write end on 1st pipe  
             close(fd_2[0]);      // close read end on 2nd pipe  
             if (fd_1[0] != STDIN_FILENO)  
             {  
                 if (dup2(fd_1[0], STDIN_FILENO) == -1)  
                 {  
                     continue_PAMauthentication = false;  
                     if (printed_err_since_success == false)  
                     {  
                         printed_err_since_success = true;  
                         //L10N TODO  
                         Logger::put(Logger::ERROR_LOG, System::CIMSERVER,  
                               Logger::SEVERE,  
                               "Error processing PAM Authentication request (dup2).");  
                     }  
                 }  
                 close(fd_1[0]);  // don't need this after dup2  
             }  
             if (continue_PAMauthentication)  
             {  
                 if (fd_2[1] != STDOUT_FILENO)  
                 {  
                     if (dup2(fd_2[1], STDOUT_FILENO) == -1)  
                     {  
                         continue_PAMauthentication = false;  
                         if (printed_err_since_success == false)  
                         {  
                             printed_err_since_success = true;  
                             //L10N TODO  
                             Logger::put(Logger::ERROR_LOG, System::CIMSERVER,  
                                 Logger::SEVERE,  
                                 "Error processing PAM Authentication request (dup2).");  
                         }  
                     }  
                     close(fd_2[1]);   // don't need this after dup2  
                 }  
                 if (continue_PAMauthentication)  
                 {  
                     //  
                     // Get environment variables:  
                     //  
                     String certpath = ConfigManager::getHomedPath(  
                         PEGASUS_PAM_STANDALONE_PROC_NAME);  
                     if (execl((const char*)certpath.getCString(),  
                               (const char*)certpath.getCString(), (char*)0) < 0)  
                     {  
                         continue_PAMauthentication = false;  
                         if (printed_err_since_success == false)  
                         {  
                             printed_err_since_success = true;  
                             //L10N TODO  
                             Logger::put(Logger::ERROR_LOG, System::CIMSERVER,  
                                 Logger::SEVERE,  
                                 "Error creating PAM Authentication process (execl).");  
                         }  
                         exit(0);  
                     }  
                 }  
             }  
         }  
     }  
 }  
   
 #endif  /* if defined(PEGASUS_OS_HPUX) || ... */  
   
   
   
   
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
   

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