popen.c File Reference

#include <precomp.h>
#include <tchar.h>

Include dependency graph for popen.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	sT   "s"
#define	MK_STR(s)   #s

Functions
int	msvcrt_alloc_fd (HANDLE hand, int flag)
unsigned	split_oflags (unsigned oflags)
void	msvcrt_free_popen_data (void)
FILE *	_tpopen (const _TCHAR *cm, const _TCHAR *md)
int CDECL	_pclose (FILE *file)

Variables
struct popen_handle *	popen_handles = NULL
DWORD	popen_handles_size = 0

Macro Definition Documentation

MK_STR

#define MK_STR

(

s

)

#s

Definition at line 20 of file popen.c.

sT

#define sT   "s"

Definition at line 17 of file popen.c.

Function Documentation

_pclose()

int CDECL _pclose

(

FILE *

file

)

Definition at line 175 of file popen.c.

{
    HANDLE h;
    DWORD i;
 
    if (!MSVCRT_CHECK_PMT(file != NULL)) return -1;
 
    _mlock(_POPEN_LOCK);
    for(i=0; i<popen_handles_size; i++)
    {
        if (popen_handles[i].f == file)
            break;
    }
    if(i == popen_handles_size)
    {
        _munlock(_POPEN_LOCK);
        *_errno() = EBADF;
        return -1;
    }
 
    h = popen_handles[i].proc;
    popen_handles[i].f = NULL;
    _munlock(_POPEN_LOCK);
 
    fclose(file);
    if(WaitForSingleObject(h, INFINITE)==WAIT_FAILED || !GetExitCodeProcess(h, &i))
    {
        _dosmaperr(GetLastError());
        CloseHandle(h);
        return -1;
    }
 
    CloseHandle(h);
    return i;
}

_tpopen()

FILE * _tpopen	(	const _TCHAR *	cm,
		const _TCHAR *	md
	)

Definition at line 38 of file popen.c.

{
    _TCHAR *szCmdLine=NULL;
    _TCHAR *szComSpec=NULL;
    _TCHAR *s;
    FILE *ret;
    HANDLE hReadPipe, hWritePipe;
    BOOL result;
    STARTUPINFO StartupInfo;
    PROCESS_INFORMATION ProcessInformation;
    SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
    struct popen_handle *container;
    DWORD i;
 
    TRACE(MK_STR(_tpopen)"('%"sT"', '%"sT"')\n", cm, md);
 
    if (cm == NULL)
        return NULL;
 
    szComSpec = _tgetenv(_T("COMSPEC"));
    if (szComSpec == NULL)
    {
        szComSpec = _T("cmd.exe");
    }
 
    s = max(_tcsrchr(szComSpec, '\\'), _tcsrchr(szComSpec, '/'));
    if (s == NULL)
        s = szComSpec;
    else
        s++;
 
    szCmdLine = malloc((_tcslen(s) + 4 + _tcslen(cm) + 1) * sizeof(_TCHAR));
    if (szCmdLine == NULL)
    {
        return NULL;
    }
 
    _tcscpy(szCmdLine, s);
    s = _tcsrchr(szCmdLine, '.');
    if (s)
        *s = 0;
    _tcscat(szCmdLine, _T(" /C "));
    _tcscat(szCmdLine, cm);
 
    if ( !CreatePipe(&hReadPipe,&hWritePipe,&sa,1024))
    {
        free (szCmdLine);
        return NULL;
    }
 
    memset(&ProcessInformation, 0, sizeof(ProcessInformation));
    memset(&StartupInfo, 0, sizeof(STARTUPINFO));
    StartupInfo.cb = sizeof(STARTUPINFO);
 
    if (*md == 'r' ) {
        StartupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
        StartupInfo.hStdOutput = hWritePipe;
        StartupInfo.dwFlags |= STARTF_USESTDHANDLES;
    }
    else if ( *md == 'w' ) {
        StartupInfo.hStdInput = hReadPipe;
        StartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
        StartupInfo.dwFlags |= STARTF_USESTDHANDLES;
    }
 
    if (StartupInfo.dwFlags & STARTF_USESTDHANDLES)
        StartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
 
    result = CreateProcess(szComSpec,
        szCmdLine,
        NULL,
        NULL,
        TRUE,
        0,
        NULL,
        NULL,
        &StartupInfo,
        &ProcessInformation);
    free (szCmdLine);
 
    if (result == FALSE)
    {
        CloseHandle(hReadPipe);
        CloseHandle(hWritePipe);
        return NULL;
    }
 
    CloseHandle(ProcessInformation.hThread);
 
    _mlock(_POPEN_LOCK);
    for(i=0; i<popen_handles_size; i++)
    {
        if (!popen_handles[i].f)
            break;
    }
    if (i==popen_handles_size)
    {
        i = (popen_handles_size ? popen_handles_size*2 : 8);
        container = realloc(popen_handles, i*sizeof(*container));
        if (!container) goto error;
 
        popen_handles = container;
        container = popen_handles+popen_handles_size;
        memset(container, 0, (i-popen_handles_size)*sizeof(*container));
        popen_handles_size = i;
    }
    else container = popen_handles+i;
 
    if ( *md == 'r' )
    {
        ret = _tfdopen(msvcrt_alloc_fd(hReadPipe,  split_oflags(_fmode)) , _T("r"));
        CloseHandle(hWritePipe);
    }
    else
    {
        ret = _tfdopen( msvcrt_alloc_fd(hWritePipe, split_oflags(_fmode)) , _T("w"));
        CloseHandle(hReadPipe);
    }
 
    container->f = ret;
    container->proc = ProcessInformation.hProcess;
    _munlock(_POPEN_LOCK);
 
    return ret;
 
error:
    _munlock(_POPEN_LOCK);
    if (ProcessInformation.hProcess != 0)
        CloseHandle(ProcessInformation.hProcess);
    return NULL;
}

msvcrt_alloc_fd()

int msvcrt_alloc_fd	(	HANDLE	hand,
		int	flag
	)

Definition at line 343 of file file.c.

{
    int fd;
    ioinfo *info = get_ioinfo_alloc(&fd);
 
    TRACE(":handle (%p) allocating fd (%d)\n", hand, fd);
 
    if(info == &__badioinfo)
        return -1;
 
    msvcrt_set_fd(info, hand, flag);
    release_ioinfo(info);
    return fd;
}

Referenced by _open_osfhandle(), _pipe(), _tpopen(), and _wsopen_s().

msvcrt_free_popen_data()

void msvcrt_free_popen_data

(

void

)

Definition at line 29 of file popen.c.

{
    free(popen_handles);
}

Referenced by DllMain().

split_oflags()

unsigned split_oflags

(

unsigned

oflags

)

Definition at line 1671 of file file.c.

{
    int wxflags = 0;
    unsigned unsupp; /* until we support everything */
 
    if (oflags & _O_APPEND)              wxflags |= WX_APPEND;
    if (oflags & _O_BINARY)              {/* Nothing to do */}
    else if (oflags & _O_TEXT)           wxflags |= WX_TEXT;
    else if (oflags & _O_WTEXT)          wxflags |= WX_TEXT;
    else if (oflags & _O_U16TEXT)        wxflags |= WX_TEXT;
    else if (oflags & _O_U8TEXT)         wxflags |= WX_TEXT;
    else if (*__p__fmode() & _O_BINARY)  {/* Nothing to do */}
    else                                        wxflags |= WX_TEXT; /* default to TEXT*/
    if (oflags & _O_NOINHERIT)           wxflags |= WX_DONTINHERIT;
 
    if ((unsupp = oflags & ~(
                    _O_BINARY|_O_TEXT|_O_APPEND|
                    _O_TRUNC|_O_EXCL|_O_CREAT|
                    _O_RDWR|_O_WRONLY|_O_TEMPORARY|
                    _O_NOINHERIT|
                    _O_SEQUENTIAL|_O_RANDOM|_O_SHORT_LIVED|
                    _O_WTEXT|_O_U16TEXT|_O_U8TEXT
                    )))
        ERR(":unsupported oflags 0x%04x\n",unsupp);
 
    return wxflags;
}

Referenced by _open_osfhandle(), _pipe(), _tpopen(), and _wsopen_s().

Variable Documentation

popen_handles

struct popen_handle* popen_handles = NULL

Definition at line 26 of file popen.c.

Referenced by _pclose(), _tpopen(), and msvcrt_free_popen_data().

popen_handles_size

DWORD popen_handles_size = 0

Definition at line 27 of file popen.c.

Referenced by _pclose(), and _tpopen().