From ec05778d5718a7912e506764d443a78d6a6179e3 Mon Sep 17 00:00:00 2001 From: Mike Buland Date: Mon, 5 Nov 2012 22:41:51 +0000 Subject: Converted tabs to spaces with tabconv. --- src/stable/process.cpp | 820 ++++++++++++++++++++++++------------------------- 1 file changed, 410 insertions(+), 410 deletions(-) (limited to 'src/stable/process.cpp') diff --git a/src/stable/process.cpp b/src/stable/process.cpp index a1adb23..a88ee7c 100644 --- a/src/stable/process.cpp +++ b/src/stable/process.cpp @@ -27,422 +27,422 @@ Bu::Process::ProcData::ProcData() : #ifdef WIN32 - hStdIn( NULL ), - hStdOut( NULL ), - hStdErr( NULL ) + hStdIn( NULL ), + hStdOut( NULL ), + hStdErr( NULL ) #else - iStdIn( -1 ), - iStdOut( -1 ), - iStdErr( -1 ) + iStdIn( -1 ), + iStdOut( -1 ), + iStdErr( -1 ) #endif { } Bu::Process::Process( Flags eFlags, const char *sName, char *const argv[] ) : - iProcStatus( 0 ), - bBlocking( true ), - bStdOutEos( true ), - bStdErrEos( true ) + iProcStatus( 0 ), + bBlocking( true ), + bStdOutEos( true ), + bStdErrEos( true ) { - gexec( eFlags, sName, argv ); + gexec( eFlags, sName, argv ); } Bu::Process::Process( Flags eFlags, const char *sName, const char *argv, ...) : - iProcStatus( 0 ), - bBlocking( true ), - bStdOutEos( true ), - bStdErrEos( true ) -{ - int iCnt = 0; - va_list ap; - va_start( ap, argv ); - for(; va_arg( ap, const char *); iCnt++ ) { } - va_end( ap ); - - char const **list = new char const *[iCnt+2]; - va_start( ap, argv ); - list[0] = argv; - for( int j = 1; j <= iCnt; j++ ) - { - list[j] = va_arg( ap, const char *); - } - list[iCnt+1] = NULL; - va_end( ap ); - - gexec( eFlags, sName, (char *const *)list ); - delete[] list; + iProcStatus( 0 ), + bBlocking( true ), + bStdOutEos( true ), + bStdErrEos( true ) +{ + int iCnt = 0; + va_list ap; + va_start( ap, argv ); + for(; va_arg( ap, const char *); iCnt++ ) { } + va_end( ap ); + + char const **list = new char const *[iCnt+2]; + va_start( ap, argv ); + list[0] = argv; + for( int j = 1; j <= iCnt; j++ ) + { + list[j] = va_arg( ap, const char *); + } + list[iCnt+1] = NULL; + va_end( ap ); + + gexec( eFlags, sName, (char *const *)list ); + delete[] list; } Bu::Process::Process( Flags eFlags, const Bu::Process::Options &opt, const char *sName, char *const argv[] ) : - iProcStatus( 0 ), - bBlocking( true ), - bStdOutEos( true ), - bStdErrEos( true ), - opt( opt ) + iProcStatus( 0 ), + bBlocking( true ), + bStdOutEos( true ), + bStdErrEos( true ), + opt( opt ) { - gexec( eFlags, sName, argv ); + gexec( eFlags, sName, argv ); } Bu::Process::Process( Flags eFlags, const Bu::Process::Options &opt, const char *sName, const char *argv, ...) : - iProcStatus( 0 ), - bBlocking( true ), - bStdOutEos( true ), - bStdErrEos( true ), - opt( opt ) -{ - int iCnt = 0; - va_list ap; - va_start( ap, argv ); - for(; va_arg( ap, const char *); iCnt++ ) { } - va_end( ap ); - - char const **list = new char const *[iCnt+2]; - va_start( ap, argv ); - list[0] = argv; - for( int j = 1; j <= iCnt; j++ ) - { - list[j] = va_arg( ap, const char *); - } - list[iCnt+1] = NULL; - va_end( ap ); - - gexec( eFlags, sName, (char *const *)list ); - delete[] list; + iProcStatus( 0 ), + bBlocking( true ), + bStdOutEos( true ), + bStdErrEos( true ), + opt( opt ) +{ + int iCnt = 0; + va_list ap; + va_start( ap, argv ); + for(; va_arg( ap, const char *); iCnt++ ) { } + va_end( ap ); + + char const **list = new char const *[iCnt+2]; + va_start( ap, argv ); + list[0] = argv; + for( int j = 1; j <= iCnt; j++ ) + { + list[j] = va_arg( ap, const char *); + } + list[iCnt+1] = NULL; + va_end( ap ); + + gexec( eFlags, sName, (char *const *)list ); + delete[] list; } Bu::Process::~Process() { - close(); + close(); } void Bu::Process::wait() { - close(); + close(); } void Bu::Process::gexec( Flags eFlags, const char *sName, char *const argv[] ) { #ifdef WIN32 - bStdErrEos = true; - SECURITY_ATTRIBUTES saAttr; - HANDLE hChildStd_IN_Rd; - HANDLE hChildStd_IN_Wr; - HANDLE hChildStd_OUT_Rd; - HANDLE hChildStd_OUT_Wr; - PROCESS_INFORMATION piProcInfo; - - saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); - saAttr.bInheritHandle = TRUE; - saAttr.lpSecurityDescriptor = NULL; - - // Create a pipe for the child process's STDOUT. - if ( ! CreatePipe( - &hChildStd_OUT_Rd, - &hChildStd_OUT_Wr, - &saAttr, 0) ) - throw "StdoutRd CreatePipe"; - - // Ensure the read handle to the pipe for STDOUT is not inherited. - if ( ! SetHandleInformation( - hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) ) - throw "Stdout SetHandleInformation"; - - // Create a pipe for the child process's STDIN. - if (! CreatePipe( - &hChildStd_IN_Rd, - &hChildStd_IN_Wr, - &saAttr, 0)) - throw "Stdin CreatePipe"; - - // Ensure the write handle to the pipe for STDIN is not inherited. - if ( ! SetHandleInformation( - hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) ) - throw "Stdin SetHandleInformation"; - - //TCHAR szCmdline[] = TEXT( sName ); - //PROCESS_INFORMATION pd.piProcInfo; - STARTUPINFO siStartInfo; - BOOL bSuccess = FALSE; - - // Set up members of the PROCESS_INFORMATION structure. - ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) ); - - // Set up members of the STARTUPINFO structure. - // This structure specifies the STDIN and STDOUT handles for redirection. - ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) ); - siStartInfo.cb = sizeof(STARTUPINFO); - siStartInfo.hStdError = hChildStd_OUT_Wr; - siStartInfo.hStdOutput = hChildStd_OUT_Wr; - siStartInfo.hStdInput = hChildStd_IN_Rd; - siStartInfo.dwFlags |= STARTF_USESTDHANDLES; - - Bu::String sCmd; - for( char *const *arg = argv; *arg; arg++ ) - { - if( arg != argv ) - sCmd += " "; - sCmd += *arg; - } - - // Create the child process. - bSuccess = CreateProcessA( - sName, //sName, //module name - sCmd.getStr(), //(TCHAR *) sName, //szCmdline, // command line - NULL, // process security attributes - NULL, // primary thread security attributes - TRUE, // handles are inherited - CREATE_NO_WINDOW, // creation flags - NULL, // use parent's environment - NULL, // use parent's current directory - &siStartInfo, // STARTUPINFO pointer - &piProcInfo ); // receives PROCESS_INFORMATION - - // If an error occurs, exit the application. - if ( ! bSuccess ) - { - throw Bu::ExceptionBase("Error spawning child process."); - return; - } - else - { - // Close handles to the child process and its primary thread. - // Some applications might keep these handles to monitor the status - // of the child process, for example. - - //CloseHandle(pData->pd.piProcInfo.hProcess); - CloseHandle(piProcInfo.hThread); - pd.hProcess = piProcInfo.hProcess; - - // Close the ends we can't use - CloseHandle( hChildStd_OUT_Wr ); - CloseHandle( hChildStd_IN_Rd ); - pd.hStdIn = hChildStd_IN_Wr; - pd.hStdOut = hChildStd_OUT_Rd; - } + bStdErrEos = true; + SECURITY_ATTRIBUTES saAttr; + HANDLE hChildStd_IN_Rd; + HANDLE hChildStd_IN_Wr; + HANDLE hChildStd_OUT_Rd; + HANDLE hChildStd_OUT_Wr; + PROCESS_INFORMATION piProcInfo; + + saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); + saAttr.bInheritHandle = TRUE; + saAttr.lpSecurityDescriptor = NULL; + + // Create a pipe for the child process's STDOUT. + if ( ! CreatePipe( + &hChildStd_OUT_Rd, + &hChildStd_OUT_Wr, + &saAttr, 0) ) + throw "StdoutRd CreatePipe"; + + // Ensure the read handle to the pipe for STDOUT is not inherited. + if ( ! SetHandleInformation( + hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) ) + throw "Stdout SetHandleInformation"; + + // Create a pipe for the child process's STDIN. + if (! CreatePipe( + &hChildStd_IN_Rd, + &hChildStd_IN_Wr, + &saAttr, 0)) + throw "Stdin CreatePipe"; + + // Ensure the write handle to the pipe for STDIN is not inherited. + if ( ! SetHandleInformation( + hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) ) + throw "Stdin SetHandleInformation"; + + //TCHAR szCmdline[] = TEXT( sName ); + //PROCESS_INFORMATION pd.piProcInfo; + STARTUPINFO siStartInfo; + BOOL bSuccess = FALSE; + + // Set up members of the PROCESS_INFORMATION structure. + ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) ); + + // Set up members of the STARTUPINFO structure. + // This structure specifies the STDIN and STDOUT handles for redirection. + ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) ); + siStartInfo.cb = sizeof(STARTUPINFO); + siStartInfo.hStdError = hChildStd_OUT_Wr; + siStartInfo.hStdOutput = hChildStd_OUT_Wr; + siStartInfo.hStdInput = hChildStd_IN_Rd; + siStartInfo.dwFlags |= STARTF_USESTDHANDLES; + + Bu::String sCmd; + for( char *const *arg = argv; *arg; arg++ ) + { + if( arg != argv ) + sCmd += " "; + sCmd += *arg; + } + + // Create the child process. + bSuccess = CreateProcessA( + sName, //sName, //module name + sCmd.getStr(), //(TCHAR *) sName, //szCmdline, // command line + NULL, // process security attributes + NULL, // primary thread security attributes + TRUE, // handles are inherited + CREATE_NO_WINDOW, // creation flags + NULL, // use parent's environment + NULL, // use parent's current directory + &siStartInfo, // STARTUPINFO pointer + &piProcInfo ); // receives PROCESS_INFORMATION + + // If an error occurs, exit the application. + if ( ! bSuccess ) + { + throw Bu::ExceptionBase("Error spawning child process."); + return; + } + else + { + // Close handles to the child process and its primary thread. + // Some applications might keep these handles to monitor the status + // of the child process, for example. + + //CloseHandle(pData->pd.piProcInfo.hProcess); + CloseHandle(piProcInfo.hThread); + pd.hProcess = piProcInfo.hProcess; + + // Close the ends we can't use + CloseHandle( hChildStd_OUT_Wr ); + CloseHandle( hChildStd_IN_Rd ); + pd.hStdIn = hChildStd_IN_Wr; + pd.hStdOut = hChildStd_OUT_Rd; + } #else - int iaStdIn[2]; - int iaStdOut[2]; - int iaStdErr[2]; - pipe( iaStdIn ); - if( eFlags & StdOut ) - { - pipe( iaStdOut ); - pd.iStdOut = iaStdOut[0]; - bStdOutEos = false; - } - if( eFlags & StdErr ) - { - pipe( iaStdErr ); - pd.iStdErr = iaStdErr[0]; - bStdErrEos = false; - } - - pd.iStdIn = iaStdIn[1]; - -// fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK ); - - pd.iPid = fork(); - if( pd.iPid == 0 ) - { - ::close( iaStdIn[1] ); - dup2( iaStdIn[0], 0 ); - if( eFlags & StdOut ) - { - ::close( iaStdOut[0] ); - dup2( iaStdOut[1], 1 ); - } - if( eFlags & StdErr ) - { - ::close( iaStdErr[0] ); - dup2( iaStdErr[1], 2 ); - } - if( (opt.eFlags&Options::SetGid) ) - { - setgid( opt.iGid ); - } - if( (opt.eFlags&Options::SetUid) ) - { - setuid( opt.iUid ); - } - execvp( sName, argv ); - throw Bu::ExceptionBase("Hey, execvp failed!"); - } - ::close( iaStdIn[0] ); - if( eFlags & StdOut ) - ::close( iaStdOut[1] ); - if( eFlags & StdErr ) - ::close( iaStdErr[1] ); + int iaStdIn[2]; + int iaStdOut[2]; + int iaStdErr[2]; + pipe( iaStdIn ); + if( eFlags & StdOut ) + { + pipe( iaStdOut ); + pd.iStdOut = iaStdOut[0]; + bStdOutEos = false; + } + if( eFlags & StdErr ) + { + pipe( iaStdErr ); + pd.iStdErr = iaStdErr[0]; + bStdErrEos = false; + } + + pd.iStdIn = iaStdIn[1]; + +// fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK ); + + pd.iPid = fork(); + if( pd.iPid == 0 ) + { + ::close( iaStdIn[1] ); + dup2( iaStdIn[0], 0 ); + if( eFlags & StdOut ) + { + ::close( iaStdOut[0] ); + dup2( iaStdOut[1], 1 ); + } + if( eFlags & StdErr ) + { + ::close( iaStdErr[0] ); + dup2( iaStdErr[1], 2 ); + } + if( (opt.eFlags&Options::SetGid) ) + { + setgid( opt.iGid ); + } + if( (opt.eFlags&Options::SetUid) ) + { + setuid( opt.iUid ); + } + execvp( sName, argv ); + throw Bu::ExceptionBase("Hey, execvp failed!"); + } + ::close( iaStdIn[0] ); + if( eFlags & StdOut ) + ::close( iaStdOut[1] ); + if( eFlags & StdErr ) + ::close( iaStdErr[1] ); #endif } void Bu::Process::close() { #ifdef WIN32 - if( pd.hStdIn ) - { - CloseHandle( pd.hStdIn ); - CloseHandle( pd.hStdOut ); - - pd.hStdIn = pd.hStdOut = pd.hStdErr = NULL; - - if( !TerminateProcess(pd.hProcess, 1) ) - { - throw Bu::ExceptionBase("Error closing process."); - } - - GetExitCodeProcess( pd.hProcess, (PDWORD)&iProcStatus ); - - CloseHandle( pd.hProcess ); - pd.hProcess = NULL; - } + if( pd.hStdIn ) + { + CloseHandle( pd.hStdIn ); + CloseHandle( pd.hStdOut ); + + pd.hStdIn = pd.hStdOut = pd.hStdErr = NULL; + + if( !TerminateProcess(pd.hProcess, 1) ) + { + throw Bu::ExceptionBase("Error closing process."); + } + + GetExitCodeProcess( pd.hProcess, (PDWORD)&iProcStatus ); + + CloseHandle( pd.hProcess ); + pd.hProcess = NULL; + } #else - if( pd.iPid ) - { - if( pd.iStdIn > -1 ) - ::close( pd.iStdIn ); - if( pd.iStdOut > -1 ) - ::close( pd.iStdOut ); - if( pd.iStdErr > -1 ) - ::close( pd.iStdErr ); - waitpid( pd.iPid, &iProcStatus, 0 ); - pd.iPid = 0; - } + if( pd.iPid ) + { + if( pd.iStdIn > -1 ) + ::close( pd.iStdIn ); + if( pd.iStdOut > -1 ) + ::close( pd.iStdOut ); + if( pd.iStdErr > -1 ) + ::close( pd.iStdErr ); + waitpid( pd.iPid, &iProcStatus, 0 ); + pd.iPid = 0; + } #endif } void Bu::Process::closeStdIn() { #ifdef WIN32 - CloseHandle( pd.hStdIn ); - pd.hStdIn = NULL; + CloseHandle( pd.hStdIn ); + pd.hStdIn = NULL; #else - ::close( pd.iStdIn ); - pd.iStdIn = -1; + ::close( pd.iStdIn ); + pd.iStdIn = -1; #endif } void Bu::Process::closeStdOut() { #ifdef WIN32 - CloseHandle( pd.hStdOut ); - pd.hStdOut = NULL; + CloseHandle( pd.hStdOut ); + pd.hStdOut = NULL; #else - ::close( pd.iStdOut ); - pd.iStdOut = -1; + ::close( pd.iStdOut ); + pd.iStdOut = -1; #endif } Bu::size Bu::Process::read( void *pBuf, Bu::size nBytes ) { #ifdef WIN32 - DWORD dwRead; - DWORD lExitCode; - BOOL bSuccess = FALSE; - DWORD dwLen = (DWORD) nBytes; - bSuccess = ReadFile( - pd.hStdOut, (char *) pBuf, - dwLen, &dwRead, NULL); -// if( dwRead < dwLen ) - { - bSuccess = GetExitCodeProcess( pd.hProcess, &lExitCode ); - if( lExitCode != STILL_ACTIVE ) - { - bStdOutEos = true; - } - } - return (int32_t) dwRead; + DWORD dwRead; + DWORD lExitCode; + BOOL bSuccess = FALSE; + DWORD dwLen = (DWORD) nBytes; + bSuccess = ReadFile( + pd.hStdOut, (char *) pBuf, + dwLen, &dwRead, NULL); +// if( dwRead < dwLen ) + { + bSuccess = GetExitCodeProcess( pd.hProcess, &lExitCode ); + if( lExitCode != STILL_ACTIVE ) + { + bStdOutEos = true; + } + } + return (int32_t) dwRead; #else - if( bStdOutEos ) - return 0; - fd_set rfds; - FD_ZERO( &rfds ); - FD_SET( pd.iStdOut, &rfds ); - struct timeval tv = {0, 0}; - if( ::bu_select( pd.iStdOut+1, &rfds, NULL, NULL, &tv ) < 0 ) - throw Bu::ExceptionBase( strerror( errno ) ); - if( FD_ISSET( pd.iStdOut, &rfds ) || bBlocking ) - { - Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdOut, pBuf, nBytes ) ); - if( nRead == 0 ) - { - bStdOutEos = true; - checkClose(); - return 0; - } - if( nRead < 0 ) - { - if( errno == EAGAIN ) - return 0; - throw Bu::ExceptionBase( strerror( errno ) ); - } - return nRead; - } - return 0; + if( bStdOutEos ) + return 0; + fd_set rfds; + FD_ZERO( &rfds ); + FD_SET( pd.iStdOut, &rfds ); + struct timeval tv = {0, 0}; + if( ::bu_select( pd.iStdOut+1, &rfds, NULL, NULL, &tv ) < 0 ) + throw Bu::ExceptionBase( strerror( errno ) ); + if( FD_ISSET( pd.iStdOut, &rfds ) || bBlocking ) + { + Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdOut, pBuf, nBytes ) ); + if( nRead == 0 ) + { + bStdOutEos = true; + checkClose(); + return 0; + } + if( nRead < 0 ) + { + if( errno == EAGAIN ) + return 0; + throw Bu::ExceptionBase( strerror( errno ) ); + } + return nRead; + } + return 0; #endif } Bu::size Bu::Process::readErr( void *pBuf, Bu::size nBytes ) { #ifdef WIN32 - if( !pd.hStdErr ) - return 0; - DWORD dwRead; - BOOL bSuccess = FALSE; - DWORD dwLen = (DWORD) nBytes; - bSuccess = ReadFile( - pd.hStdErr, (char *) pBuf, - dwLen, &dwRead, NULL); - return (int32_t) dwRead; + if( !pd.hStdErr ) + return 0; + DWORD dwRead; + BOOL bSuccess = FALSE; + DWORD dwLen = (DWORD) nBytes; + bSuccess = ReadFile( + pd.hStdErr, (char *) pBuf, + dwLen, &dwRead, NULL); + return (int32_t) dwRead; #else - if( bStdErrEos ) - return 0; - fd_set rfds; - FD_ZERO( &rfds ); - FD_SET( pd.iStdErr, &rfds ); - struct timeval tv = {0, 0}; - if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, &tv ) < 0 ) - throw Bu::ExceptionBase( strerror( errno ) ); - if( FD_ISSET( pd.iStdErr, &rfds ) || bBlocking ) - { - Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdErr, pBuf, nBytes ) ); - if( nRead == 0 ) - { - bStdErrEos = true; - checkClose(); - return 0; - } - if( nRead < 0 ) - { - if( errno == EAGAIN ) - return 0; - throw Bu::ExceptionBase( strerror( errno ) ); - } - return nRead; - } - return 0; + if( bStdErrEos ) + return 0; + fd_set rfds; + FD_ZERO( &rfds ); + FD_SET( pd.iStdErr, &rfds ); + struct timeval tv = {0, 0}; + if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, &tv ) < 0 ) + throw Bu::ExceptionBase( strerror( errno ) ); + if( FD_ISSET( pd.iStdErr, &rfds ) || bBlocking ) + { + Bu::size nRead = TEMP_FAILURE_RETRY( ::read( pd.iStdErr, pBuf, nBytes ) ); + if( nRead == 0 ) + { + bStdErrEos = true; + checkClose(); + return 0; + } + if( nRead < 0 ) + { + if( errno == EAGAIN ) + return 0; + throw Bu::ExceptionBase( strerror( errno ) ); + } + return nRead; + } + return 0; #endif } Bu::size Bu::Process::write( const void *pBuf, Bu::size nBytes ) { #ifdef WIN32 - DWORD dwWritten; - BOOL bSuccess = FALSE; - DWORD dwLen = (DWORD) nBytes; - bSuccess = WriteFile( - pd.hStdIn, (const char *) pBuf, - dwLen, &dwWritten, NULL ); - FlushFileBuffers( pd.hStdIn ); - return (int32_t) dwWritten; + DWORD dwWritten; + BOOL bSuccess = FALSE; + DWORD dwLen = (DWORD) nBytes; + bSuccess = WriteFile( + pd.hStdIn, (const char *) pBuf, + dwLen, &dwWritten, NULL ); + FlushFileBuffers( pd.hStdIn ); + return (int32_t) dwWritten; #else - return TEMP_FAILURE_RETRY( ::write( pd.iStdIn, pBuf, nBytes ) ); + return TEMP_FAILURE_RETRY( ::write( pd.iStdIn, pBuf, nBytes ) ); #endif } Bu::size Bu::Process::tell() { - return 0; + return 0; } void Bu::Process::seek( Bu::size ) @@ -460,15 +460,15 @@ void Bu::Process::setPosEnd( Bu::size ) bool Bu::Process::isEos() { #ifdef WIN32 - return (pd.hProcess == NULL); + return (pd.hProcess == NULL); #else - return (pd.iPid == 0); + return (pd.iPid == 0); #endif } bool Bu::Process::isOpen() { - return !isEos(); + return !isEos(); } void Bu::Process::flush() @@ -477,53 +477,53 @@ void Bu::Process::flush() bool Bu::Process::canRead() { - return true; + return true; } bool Bu::Process::canWrite() { - return true; + return true; } bool Bu::Process::isReadable() { - return true; + return true; } bool Bu::Process::isWritable() { - return true; + return true; } bool Bu::Process::isSeekable() { - return false; + return false; } bool Bu::Process::isBlocking() { - return true; + return true; } void Bu::Process::setBlocking( bool bBlocking ) { #ifdef WIN32 #else - if( bBlocking ) - { - if( !bStdOutEos ) - fcntl( pd.iStdOut, F_SETFL, fcntl(pd.iStdOut,F_GETFL,0 )&(~O_NONBLOCK) ); - if( !bStdErrEos ) - fcntl( pd.iStdErr, F_SETFL, fcntl(pd.iStdErr,F_GETFL,0 )&(~O_NONBLOCK) ); - } - else - { - if( !bStdOutEos ) - fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK ); - if( !bStdErrEos ) - fcntl( pd.iStdErr, F_SETFL, fcntl( pd.iStdErr, F_GETFL, 0 )|O_NONBLOCK ); - } - this->bBlocking = bBlocking; + if( bBlocking ) + { + if( !bStdOutEos ) + fcntl( pd.iStdOut, F_SETFL, fcntl(pd.iStdOut,F_GETFL,0 )&(~O_NONBLOCK) ); + if( !bStdErrEos ) + fcntl( pd.iStdErr, F_SETFL, fcntl(pd.iStdErr,F_GETFL,0 )&(~O_NONBLOCK) ); + } + else + { + if( !bStdOutEos ) + fcntl( pd.iStdOut, F_SETFL, fcntl( pd.iStdOut, F_GETFL, 0 )|O_NONBLOCK ); + if( !bStdErrEos ) + fcntl( pd.iStdErr, F_SETFL, fcntl( pd.iStdErr, F_GETFL, 0 )|O_NONBLOCK ); + } + this->bBlocking = bBlocking; #endif } @@ -533,128 +533,128 @@ void Bu::Process::setSize( Bu::size ) Bu::size Bu::Process::getBlockSize() const { - return 0; + return 0; } Bu::size Bu::Process::getSize() const { - return 0; + return 0; } Bu::String Bu::Process::getLocation() const { - return ""; + return ""; } void Bu::Process::select( bool &bStdOut, bool &bStdErr ) { #ifdef WIN32 #else - fd_set rfds; - FD_ZERO( &rfds ); - if( !bStdOutEos ) - FD_SET( pd.iStdOut, &rfds ); - if( !bStdErrEos ) - FD_SET( pd.iStdErr, &rfds ); - if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, NULL ) < 0 ) - throw Bu::ExceptionBase( strerror( errno ) ); - - if( FD_ISSET( pd.iStdOut, &rfds ) ) - bStdOut = true; - else - bStdOut = false; - - if( FD_ISSET( pd.iStdErr, &rfds ) ) - bStdErr = true; - else - bStdErr = false; + fd_set rfds; + FD_ZERO( &rfds ); + if( !bStdOutEos ) + FD_SET( pd.iStdOut, &rfds ); + if( !bStdErrEos ) + FD_SET( pd.iStdErr, &rfds ); + if( ::bu_select( pd.iStdErr+1, &rfds, NULL, NULL, NULL ) < 0 ) + throw Bu::ExceptionBase( strerror( errno ) ); + + if( FD_ISSET( pd.iStdOut, &rfds ) ) + bStdOut = true; + else + bStdOut = false; + + if( FD_ISSET( pd.iStdErr, &rfds ) ) + bStdErr = true; + else + bStdErr = false; #endif } bool Bu::Process::isRunning() { #ifdef WIN32 - DWORD lExitCode; - GetExitCodeProcess( pd.hProcess, &lExitCode ); - if( lExitCode != STILL_ACTIVE ) - checkClose(); + DWORD lExitCode; + GetExitCodeProcess( pd.hProcess, &lExitCode ); + if( lExitCode != STILL_ACTIVE ) + checkClose(); #else - if( waitpid( pd.iPid, NULL, WNOHANG ) == pd.iPid ) - checkClose(); + if( waitpid( pd.iPid, NULL, WNOHANG ) == pd.iPid ) + checkClose(); #endif - return isOpen(); + return isOpen(); } void Bu::Process::ignoreStdErr() { #ifdef WIN32 #else - if( pd.iStdErr == -1 ) - return; - ::close( pd.iStdErr ); - pd.iStdErr = -1; - bStdErrEos = true; + if( pd.iStdErr == -1 ) + return; + ::close( pd.iStdErr ); + pd.iStdErr = -1; + bStdErrEos = true; #endif } pid_t Bu::Process::getPid() { #ifdef WIN32 - return 0; + return 0; #else - return pd.iPid; + return pd.iPid; #endif } bool Bu::Process::childExited() { #ifdef WIN32 - return pd.hProcess != NULL; + return pd.hProcess != NULL; #else - return WIFEXITED( iProcStatus ); + return WIFEXITED( iProcStatus ); #endif } int Bu::Process::childExitStatus() { #ifdef WIN32 - return iProcStatus; + return iProcStatus; #else - return WEXITSTATUS( iProcStatus ); + return WEXITSTATUS( iProcStatus ); #endif } bool Bu::Process::childSignaled() { #ifdef WIN32 - return false; + return false; #else - return WIFSIGNALED( iProcStatus ); + return WIFSIGNALED( iProcStatus ); #endif } int Bu::Process::childSignal() { #ifdef WIN32 - return 0; + return 0; #else - return WTERMSIG( iProcStatus ); + return WTERMSIG( iProcStatus ); #endif } bool Bu::Process::childCoreDumped() { #ifdef WIN32 - return false; + return false; #else - return WCOREDUMP( iProcStatus ); + return WCOREDUMP( iProcStatus ); #endif } void Bu::Process::checkClose() { - if( bStdOutEos && bStdErrEos ) - { - close(); - } + if( bStdOutEos && bStdErrEos ) + { + close(); + } } -- cgit v1.2.3