Win32에서 도스 명령어를 실행하고 결과 값을 UniCode 스트링으로 가져오는 샘플 코드입니다.
아래 소스 코드를 참조하세요.
LPWSTR CHARtoWCHAR(LPSTR str, UINT codePage) {
size_t len = strlen(str) + 1;
int size_needed = MultiByteToWideChar(codePage, 0, str, len, NULL, 0);
LPWSTR wstr = (LPWSTR)LocalAlloc(LPTR, sizeof(WCHAR) * size_needed);
MultiByteToWideChar(codePage, 0, str, len, wstr, size_needed);
return wstr;
}
LPSTR UNICODEtoANSI(CString strData)
{
LPWSTR lpData = strData.GetBuffer(0);
LPSTR lpRtt = new char[(wcslen(lpData) + 1) * 2];
WideCharToMultiByte(CP_ACP, 0, lpData, -1, lpRtt, (wcslen(lpData) + 1) * 2,
NULL, NULL);
return lpRtt;
}
LPWSTR OEMtoUNICODE(LPSTR lpStr)
{
int len = (strlen(lpStr) + 1) * 2;
LPWSTR lpwRtt = new TCHAR[len];
memset(lpwRtt, 0x00, strlen(lpStr) / 2 + 1);
MultiByteToWideChar(CP_ACP, 0, lpStr, -1, lpwRtt, (strlen(lpStr) + 1) * 2);
return lpwRtt;
}
/* Execute a DOS command.
If the function succeeds, the return value is a non-NULL pointer to the output of the invoked command.
Command will produce a 8-bit characters stream using OEM code-page.
As charset depends on OS config (ex: CP437 [OEM-US/latin-US], CP850 [OEM 850/latin-1]),
before being returned, output is converted to a wide-char string with function OEMtoUNICODE.
Resulting buffer is allocated with LocalAlloc.
It is the caller's responsibility to free the memory used by the argument list when it is no longer needed.
To free the memory, use a single call to LocalFree function.
*/
LPWSTR DosExec(CString command) {
// Allocate 1Mo to store the output (final buffer will be sized to actual output)
// If output exceeds that size, it will be truncated
const SIZE_T RESULT_SIZE = sizeof(char) * 1024 * 1024;
char* output = (char*)LocalAlloc(LPTR, RESULT_SIZE);
memset(output, 0, RESULT_SIZE);
HANDLE readPipe, writePipe;
SECURITY_ATTRIBUTES security;
STARTUPINFOA start;
PROCESS_INFORMATION processInfo;
security.nLength = sizeof(SECURITY_ATTRIBUTES);
security.bInheritHandle = true;
security.lpSecurityDescriptor = NULL;
if (CreatePipe(
&readPipe, // address of variable for read handle
&writePipe, // address of variable for write handle
&security, // pointer to security attributes
0 // number of bytes reserved for pipe
)) {
GetStartupInfoA(&start);
start.hStdOutput = writePipe;
start.hStdError = writePipe;
start.hStdInput = readPipe;
start.dwFlags = STARTF_USESTDHANDLES + STARTF_USESHOWWINDOW;
start.wShowWindow = SW_HIDE;
char *cmd = UNICODEtoANSI(command);
// We have to start the DOS app the same way cmd.exe does (using the current Win32 ANSI code-page).
// So, we use the "ANSI" version of createProcess, to be able to pass a LPSTR (single/multi-byte character string)
// instead of a LPWSTR (wide-character string) and we use the UNICODEtoANSI function to convert the given command
if (CreateProcessA(NULL, // pointer to name of executable module
cmd, // pointer to command line string
&security, // pointer to process security attributes
&security, // pointer to thread security attributes
TRUE, // handle inheritance flag
NORMAL_PRIORITY_CLASS, // creation flags
NULL, // pointer to new environment block
NULL, // pointer to current directory name
&start, // pointer to STARTUPINFO
&processInfo // pointer to PROCESS_INFORMATION
)) {
OutputDebugStringA("run :");
OutputDebugStringA(cmd);
OutputDebugStringA("\n");
// wait for the child process to start
for (UINT state = WAIT_TIMEOUT; state == WAIT_TIMEOUT; state = WaitForSingleObject(processInfo.hProcess, 100));
DWORD bytesRead = 0, count = 0;
const int BUFF_SIZE = 1024;
char* buffer = (char*)malloc(sizeof(char)*BUFF_SIZE + 1);
//strncpy(output, "", 1);
StringCbCopyA(output, 1, "");
do {
DWORD dwAvail = 0;
if (!PeekNamedPipe(readPipe, NULL, 0, NULL, &dwAvail, NULL)) {
// error, the child process might have ended
break;
}
if (!dwAvail) {
// no data available in the pipe
break;
}
ReadFile(readPipe, buffer, BUFF_SIZE, &bytesRead, NULL);
buffer[bytesRead] = '\0';
if ((count + bytesRead) > RESULT_SIZE) break;
//strncat(output, buffer, bytesRead);
OutputDebugStringA(buffer);
StringCbCatA(output, bytesRead, buffer);
count += bytesRead;
} while (bytesRead >= BUFF_SIZE);
free(buffer);
}
}
CloseHandle(processInfo.hThread);
CloseHandle(processInfo.hProcess);
CloseHandle(writePipe);
CloseHandle(readPipe);
// convert result buffer to a wide-character string
LPWSTR result = OEMtoUNICODE(output);
LocalFree(output);
return result;
}