static int init_console(void)
{
# if defined(GAUCHE_WINDOWS_NOCONSOLE)
char buf[100];
int in_fd, out_fd;
#define ERR(msg) do {sprintf(buf, msg, strerror(errno));goto fail;} while(0)
if ((in_fd = open("NUL", O_RDONLY)) < 0) ERR("couldn't open NUL: %s");
if ((out_fd = open("NUL", O_WRONLY))< 0) ERR("couldn't open NUL: %s");
if (_dup2(in_fd, 0) < 0) ERR("dup2(0) failed (%s)");
if (_dup2(out_fd, 1) < 0) ERR("dup2(1) failed (%s)");
if (_dup2(out_fd, 2) < 0) ERR("dup2(2) failed (%s)");
close(in_fd);
close(out_fd);
return FALSE;
#undef ERR
fail:
MessageBoxA(NULL, buf, "gosh-noconsole", MB_OK|MB_ICONERROR);
Scm_Exit(1);
# else /*!defined(GAUCHE_WINDOWS_NOCONSOLE)*/
/* This saves so much trouble */
_setmode(_fileno(stdin), _O_BINARY);
_setmode(_fileno(stdout), _O_BINARY);
_setmode(_fileno(stderr), _O_BINARY);
return TRUE;
# endif /*!defined(GAUCHE_WINDOWS_NOCONSOLE)*/
}
static int init_console(void)
{
# if defined(GAUCHE_WINDOWS_NOCONSOLE)
char buf[100];
int in_fd, out_fd;
#define ERR(msg) do {sprintf(buf, msg, strerror(errno));goto fail;} while(0)
/* If we don't have console, we'll start off with stdio to be redirected
to NUL; but whenever Scheme program tries to do I/O from/to
standard Scheme ports, we open the console and reconnect the
ports. */
if ((in_fd = open("NUL", O_RDONLY)) < 0) ERR("couldn't open NUL: %s");
if ((out_fd = open("NUL", O_WRONLY)) < 0) ERR("couldn't open NUL: %s");
if (_dup2(in_fd, 0) < 0) ERR("dup2(0) failed (%s)");
if (_dup2(out_fd, 1) < 0) ERR("dup2(1) failed (%s)");
if (_dup2(out_fd, 2) < 0) ERR("dup2(2) failed (%s)");
close(in_fd);
close(out_fd);
return FALSE;
#undef ERR
fail:
MessageBoxA(NULL, buf, "gosh-noconsole", MB_OK|MB_ICONERROR);
Scm_Exit(1);
# else /*!defined(GAUCHE_WINDOWS_NOCONSOLE)*/
/* This saves so much trouble */
_setmode(_fileno(stdin), _O_BINARY);
_setmode(_fileno(stdout), _O_BINARY);
_setmode(_fileno(stderr), _O_BINARY);
return TRUE;
# endif /*!defined(GAUCHE_WINDOWS_NOCONSOLE)*/
}
static void init_dbgfp()
{
#if _DBG
if (!dbgfp) {
#if (!HIME_IME || 1) && !CONSOLE_OFF
AllocConsole();
fclose(stdout);
fclose(stderr);
int fh = _open_osfhandle((long)GetStdHandle(STD_OUTPUT_HANDLE), 0);
_dup2(fh, 1);
_dup2(fh, 2);
_fdopen(1, "wt");
_fdopen(2, "wt");
fflush(stdout);
#endif
char tt[512];
#if HIME_IME
sprintf(tt, "C:\\dbg\\ime%x", GetCurrentProcessId());
#elif HIME_SVR
sprintf(tt, "C:\\dbg\\svr%x", GetCurrentProcessId());
#else
sprintf(tt, "C:\\dbg\\other%x", GetCurrentProcessId());
#endif
dbgfp=_fsopen(tt, "wt", _SH_DENYWR);
setbuf(dbgfp, NULL);
char exe[MAX_PATH];
GetModuleFileNameA(NULL, exe, sizeof(exe));
dbg("started %s\n", exe);
}
#endif
}
int main(int ac, char **av)
{
int savo, savi;
FILE *fnul;
char name[256];
char fullname[256];
char *p;
kpse_set_program_name(av[0], "mkocp");
if(ac != 2) {
fprintf(stderr,"%s : Usage %s ocpname\n", av[0], av[0]);
return 1;
}
p = strrchr(av[1], '.');
if(p)
*p = '\0';
strcpy(name, av[1]);
strcpy(fullname, name);
strcat(fullname, ".ocp");
/* save stdout and stdin */
savo = _dup(fileno(stdout));
savi = _dup(fileno(stdin));
/* connect stdout to stderr */
_dup2(fileno(stderr), fileno(stdout));
/* connect stdin to nul device */
if(!(fnul = fopen("nul", "r"))) {
fprintf(stderr, "Cannot open nul device to read\n");
exit(100);
}
_dup2(fileno(fnul), fileno(stdin));
/* COMMAND */
_spawnlp(_P_WAIT, "otp2ocp", "otp2ocp", name, NULL);
/* END COMMAND */
/* return to original stdout and stdin */
_dup2(savo, fileno(stdout));
close(savo);
_dup2(savi, fileno(stdin));
close(savi);
/* close nul device */
fclose(fnul);
if(_access(fullname, 0) == 0)
printf("%s\n", fullname);
return 0;
}
int main(int argc, char **argv)
#endif /* __APPLE__ */
{
bool commit_dune_cfg = false;
#if defined(_WIN32)
#if defined(__MINGW32__) && defined(__STRICT_ANSI__)
int __cdecl __MINGW_NOTHROW _fileno (FILE*);
#endif
FILE *err = fopen("error.log", "w");
FILE *out = fopen("output.log", "w");
#if defined(_MSC_VER)
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
#endif
if (err != NULL) _dup2(_fileno(err), _fileno(stderr));
if (out != NULL) _dup2(_fileno(out), _fileno(stdout));
FreeConsole();
#endif
CrashLog_Init();
VARIABLE_NOT_USED(argc);
VARIABLE_NOT_USED(argv);
if (!File_Init()) {
Error("Cannot initialise files. Does %s directory exist ?\n", DATA_DIR);
exit(1);
}
/* Loading / writing config from/to dune.cfg */
if (!Config_Read("dune.cfg", &g_config)) {
Config_Default(&g_config);
commit_dune_cfg = true;
}
if (commit_dune_cfg && !Config_Write("dune.cfg", &g_config)) {
Error("Error writing to dune.cfg file.\n");
exit(1);
}
Input_Init();
Drivers_All_Init();
if (!Unknown_25C4_000E()) exit(1);
g_var_7097 = 0;
GameLoop_Main();
printf("%s\n", String_Get_ByIndex(STR_THANK_YOU_FOR_PLAYING_DUNE_II));
PrepareEnd();
exit(0);
}
static FILE* fopenZIPped(const char* filename, const char* mode)
{
// check mode
if (mode[0] == 'r')
{
// create the pipe
int hPipe[2];
if (_pipe(hPipe, 2048, ((mode[1] =='b') ? _O_BINARY : _O_TEXT) | _O_NOINHERIT) == -1)
{
fprintf(stderr, "could not create pipe\n");
return NULL;
}
// duplicate stdin/stdout handle so we can restore them later
int hStdOut = _dup(_fileno(stdout));
// make the write end of pipe go to stdout
if (_dup2(hPipe[WRITE_HANDLE], _fileno(stdout)) != 0)
{
fprintf(stderr, "could not set pipe output\n");
return NULL;
}
// redirect read end of pipe to input file
if (_dup2(hPipe[READ_HANDLE], _fileno(stdin)) != 0)
{
fprintf(stderr, "could not redirect input file\n");
return NULL;
}
// close original write end of pipe
close(hPipe[WRITE_HANDLE]);
// Spawn process
HANDLE hProcess = (HANDLE) spawnlp(P_NOWAIT, "unzip", "unzip", "-p", filename, NULL);
// redirect stdout back into stdout
if (_dup2(hStdOut, _fileno(stdout)) != 0)
{
fprintf(stderr, "could not reconstruct stdout\n");
return NULL;
}
// return redirected stdin
return stdin;
}
else
{
return NULL;
}
}
int
daemon(int nochdir, int noclose)
{
struct sigaction osa, sa;
int fd;
pid_t newgrp;
int oerrno;
int osa_ok;
/* A SIGHUP may be thrown when the parent exits below. */
sigemptyset(&sa.sa_mask);
sa.sa_handler = SIG_IGN;
sa.sa_flags = 0;
osa_ok = __libc_sigaction(SIGHUP, &sa, &osa);
switch (fork()) {
case -1:
return (-1);
case 0:
break;
default:
/*
* A fine point: _exit(0), not exit(0), to avoid triggering
* atexit(3) processing
*/
_exit(0);
}
newgrp = setsid();
oerrno = errno;
if (osa_ok != -1)
__libc_sigaction(SIGHUP, &osa, NULL);
if (newgrp == -1) {
errno = oerrno;
return (-1);
}
if (!nochdir)
(void)chdir("/");
if (!noclose && (fd = _open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
(void)_dup2(fd, STDIN_FILENO);
(void)_dup2(fd, STDOUT_FILENO);
(void)_dup2(fd, STDERR_FILENO);
if (fd > 2)
(void)_close(fd);
}
return (0);
}
static aug_bool
createconsole_(const char* sname)
{
int fd;
FILE* fp;
HANDLE h;
CONSOLE_SCREEN_BUFFER_INFO info;
if (!interactive_(sname) || !AllocConsole())
return AUG_FALSE;
fflush(NULL);
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
info.dwSize.Y = 512;
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), info.dwSize);
h = GetStdHandle(STD_INPUT_HANDLE);
fd = _open_osfhandle((intptr_t)h, _O_TEXT);
_dup2(fd, 0);
fp = _fdopen(fd, "r");
*stdin = *fp;
setvbuf(stdin, NULL, _IONBF, 0);
h = GetStdHandle(STD_OUTPUT_HANDLE);
fd = _open_osfhandle((intptr_t)h, _O_TEXT);
_dup2(fd, 1);
fp = _fdopen(fd, "w");
*stdout = *fp;
setvbuf(stdout, NULL, _IONBF, 0);
h = GetStdHandle(STD_ERROR_HANDLE);
fd = _open_osfhandle((intptr_t)h, _O_TEXT);
_dup2(fd, 2);
fp = _fdopen(fd, "w");
*stderr = *fp;
setvbuf(stderr, NULL, _IONBF, 0);
#if defined(_MSC_VER)
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
#endif /* _MSC_VER */
return AUG_TRUE;
}
int main(int argc, char** argv)
{
UNUSED(argc);
UNUSED(argv);
FileHash_Init();
Mouse_Init();
if (A5_InitOptions() == false)
exit(1);
char filename[1024];
snprintf(filename, sizeof(filename), "%s/error.log", g_dune_data_dir);
FILE* err = fopen(filename, "w");
snprintf(filename, sizeof(filename), "%s/output.log", g_dune_data_dir);
FILE* out = fopen(filename, "w");
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
if (err != NULL)
_dup2(_fileno(err), _fileno(stderr));
if (out != NULL)
_dup2(_fileno(out), _fileno(stdout));
FreeConsole();
if (!Unknown_25C4_000E())
exit(1);
if (A5_Init() == false)
exit(1);
Scenario_InitTables();
Input_Init();
Audio_LoadSampleSet(SAMPLESET_INVALID);
String_Init();
Sprites_Init();
Sprites_LoadTiles();
VideoA5_InitSprites();
GameLoop_TweakWidgetDimensions();
Audio_PlayVoice(VOICE_STOP);
GameLoop_GameIntroAnimationMenu();
printf("%s\n", String_Get_ByIndex(STR_THANK_YOU_FOR_PLAYING_DUNE_II));
PrepareEnd();
exit(0);
}
OcaOctaveController::OcaOctaveController()
:
m_state( e_StateStopped ),
m_lastError( 0 ),
m_historyFileName( ".octaudio_history" ),
m_historyBackupFileName( ".octaudio_history_old" ),
m_host( NULL )
{
int fds[2] = { -1, -1 };
#ifndef Q_OS_WIN32
pipe( fds );
dup2( fds[1], fileno(stdout) );
setvbuf( stdout, NULL, _IOLBF, 0 );
close( fds[1] );
m_pipeFd = fds[0];
int result = fcntl( m_pipeFd, F_SETFL, O_NONBLOCK );
Q_ASSERT( 0 == result );
(void) result;
QSocketNotifier* pNotifier = new QSocketNotifier( m_pipeFd,
QSocketNotifier::Read, this );
connect( pNotifier, SIGNAL(activated(int)), SLOT(readStdout()) );
#else
_pipe( fds, 4096, O_BINARY );
_dup2( fds[1], fileno(stdout) );
setvbuf( stdout, NULL, _IOLBF, 0 );
close( fds[1] );
m_pipeFd = fds[0];
m_stdoutThread = new OcaStdoutThread( this );
m_stdoutThread->start();
#endif
}
R_API int r_cons_pipe_open(const char *file, int append) {
int fd = open (file, O_BINARY | O_RDWR | O_CREAT | (append?O_APPEND:O_TRUNC), 0644);
if (fd==-1) {
eprintf ("Cannot open file '%s'\n", file);
return -1;
}// else eprintf ("%s created\n", file);
if (backup_fd != -1)
close (backup_fd);
#if __WINDOWS__
backup_fd = 2002-(fd-2); // windows xp has 2048 as limit fd
if (_dup2 (1, backup_fd) == -1) {
#else
backup_fd = sysconf (_SC_OPEN_MAX)-(fd-2); // portable getdtablesize()
if (dup2 (1, backup_fd) == -1) {
#endif
eprintf ("Cannot dup stdout to %d\n", backup_fd);
return -1;
}
close (1);
dup2 (fd, 1);
return fd;
}
R_API void r_cons_pipe_close(int fd) {
if (fd == -1)
return;
close (fd);
if (backup_fd != -1) {
dup2 (backup_fd, 1);
close (backup_fd);
backup_fd = -1;
}
}
CGlobal::CGlobal()
{
debugger_.reset(new Debugger());
// redirect 'stdout' to the pipe
char path[MAX_PATH];
::GetTempPath(MAX_PATH, path);
char temp[MAX_PATH];
::GetTempFileName(path, "lu-", ::GetTickCount(), temp);
// open stdout first, or else dup2 won't work
if (freopen(temp, "w", stdout) == 0)
throw std::exception("error redirecting stdout to temp file");
if (_pipe(stdout_fds_, 0, _O_BINARY) != 0 || _dup2(stdout_fds_[1], _fileno(stdout)) != 0)
throw std::exception("error redirecting stdout to the pipe");
// no buffering for stdout, to make output window refresh instant
setvbuf(stdout, NULL, _IONBF, 0);
//TODO: delete temp
::DeleteFile(temp);
output_position_ = 0;
output_.reserve(200);
thread_ = ::AfxBeginThread(ReadStdoutText, this, 0, 0, CREATE_SUSPENDED);
if (thread_ == 0)
throw std::exception("cannot create worker thread");
thread_->m_bAutoDelete = false;
thread_->ResumeThread();
}
int
duplicate(int fd, int newfd, Bool useDup2) {
if (useDup2) {
return _dup2(fd, newfd);
}
return _dup(fd);
}
void DynamicResponseState::execveCgiProgram(){
char *emptylist[]={NULL};
if(_fork()==0){
setenv("QUERY_STRING",cgiArgs.c_str(),1);
_dup2(getFileDescriptor(),STDOUT_FILENO);
_execve(getFileName().c_str(),emptylist,environ);
}
_wait(NULL);
}
DevNull::~DevNull()
{
_close(null_);
if (orig_ != INVALID_FD)
{
_dup2(clone_, orig_);
_close(clone_);
}
}
static int do_dump_do(sc_card_t *card, unsigned int tag)
{
int r;
size_t length;
unsigned char buffer[254]; // Private DO are specified up to 254 bytes
memset(buffer, '\0', sizeof(buffer));
if (tag < 0x101 || tag > 0x104) {
util_error("illegal DO identifier %04X", tag);
return SC_ERROR_INVALID_ARGUMENTS;
}
r = sc_get_data(card, tag, buffer, sizeof(buffer));
if (r < 0) {
util_error("failed to get data object DO %04X: %s", tag, sc_strerror(r));
if (SC_ERROR_SECURITY_STATUS_NOT_SATISFIED == r) {
util_error("make sure the 'verify' and 'pin' parameters are correct");
}
return r;
}
length = (size_t) r; /* r is guaranteed to be non-negative */
if (opt_raw) {
int tmp;
FILE *fp;
#ifndef _WIN32
tmp = dup(fileno(stdout));
#else
tmp = _dup(_fileno(stdout));
#endif
if (tmp < 0)
return EXIT_FAILURE;
fp = freopen(NULL, "wb", stdout);
if (fp) {
r = (int) fwrite(buffer, sizeof(char), length, fp);
}
#ifndef _WIN32
dup2(tmp, fileno(stdout));
#else
_dup2(tmp, _fileno(stdout));
#endif
clearerr(stdout);
close(tmp);
if (length != (size_t) r) /* fail on write errors */
return EXIT_FAILURE;
} else {
util_hex_dump_asc(stdout, buffer, length, -1);
}
return EXIT_SUCCESS;
}
pid_t
background_and_capture(char cmd[], int user_sh, FILE **out, FILE **err)
{
int out_fd, out_pipe[2];
int err_fd, err_pipe[2];
pid_t pid;
if(_pipe(out_pipe, 512, O_NOINHERIT) != 0)
{
show_error_msg("File pipe error", "Error creating pipe");
return (pid_t)-1;
}
if(_pipe(err_pipe, 512, O_NOINHERIT) != 0)
{
show_error_msg("File pipe error", "Error creating pipe");
close(out_pipe[0]);
close(out_pipe[1]);
return (pid_t)-1;
}
out_fd = dup(_fileno(stdout));
err_fd = dup(_fileno(stderr));
pid = background_and_capture_internal(cmd, user_sh, out, err, out_pipe,
err_pipe);
_close(out_pipe[1]);
_close(err_pipe[1]);
_dup2(out_fd, _fileno(stdout));
_dup2(err_fd, _fileno(stderr));
if(pid == (pid_t)-1)
{
_close(out_pipe[0]);
_close(err_pipe[0]);
}
return pid;
}
void
ns_os_daemonize(void) {
/*
* Try to set stdin, stdout, and stderr to /dev/null, but press
* on even if it fails.
*/
if (devnullfd != -1) {
if (devnullfd != _fileno(stdin)) {
close(_fileno(stdin));
(void)_dup2(devnullfd, _fileno(stdin));
}
if (devnullfd != _fileno(stdout)) {
close(_fileno(stdout));
(void)_dup2(devnullfd, _fileno(stdout));
}
if (devnullfd != _fileno(stderr)) {
close(_fileno(stderr));
(void)_dup2(devnullfd, _fileno(stderr));
}
}
}
OutputLogger::~OutputLogger(void)
{
// Replace fd with it's original details
if (fileOld && fd >= 0) {
_dup2(_fileno(fileOld),fd);
fd = -1;
}
if (pThread) {
// Wait for the thread to exit (the write handle is now invalid so it will have broken the pipe)
SDL_WaitThread(pThread,NULL);
pThread = NULL;
}
// Close the read end of the pipe, completely closing the pipe
if (fdPipeRead >= 0) {
_close(fdPipeRead);
fdPipeRead = -1;
}
// Close the duplicated original file
if (fileOld) {
std::fclose(fileOld);
fileOld = NULL;
}
// Close the log file
if (fileLog) {
// In the event that we did a freopen on the handle remove the windows
// output std handle
#ifdef WIN32
DWORD stdhandle = 0;
if (fileLog == stdout)
stdhandle = STD_OUTPUT_HANDLE;
else if (fileLog == stderr)
stdhandle = STD_ERROR_HANDLE;
if (stdhandle)
SetStdHandle(stdhandle,NULL);
#endif
// Get the size written to the log file
int sizeLog = std::ftell(fileLog);
std::fclose(fileLog);
fileLog = NULL;
// Delete the log file if it was empty
if (!sizeLog) std::remove(filenameLog.c_str());
filenameLog = std::string();
}
}
//!
//! Nullify given open file descriptor.
//!
DevNull::DevNull(int fd)
{
orig_ = fd;
clone_ = _dup(orig_);
#pragma warning(push)
#pragma warning(disable: 4996)
null_ = _wopen(DEV_NULL, _O_RDWR);
#pragma warning(pop)
_dup2(null_, orig_);
}
ShellWrapper()
{
int iReturn;
iReturn = _pipe(iPipeIn_, 512, _O_TEXT | O_NOINHERIT);
assert(iReturn != -1);
iReturn = _pipe(iPipeOut_, 512, _O_TEXT | O_NOINHERIT);
assert(iReturn != -1);
//save old handle
int iStdin = _dup(_fileno(stdin));
int iStdout = _dup(_fileno(stdout));
int iStderr = _dup(_fileno(stderr));
iReturn = _dup2(iPipeOut_[0], _fileno(stdin));
assert(iReturn == 0);
iReturn = _dup2(iPipeIn_[1], _fileno(stdout));
assert(iReturn == 0);
iReturn = _dup2(iPipeIn_[1], _fileno(stderr));
assert(iReturn == 0);
char *arg[] = {"cmd.exe", "/Q", "/A", NULL};
iSubProcess_ = spawnvp(P_NOWAIT, arg[0], arg);
//restore old handle
iReturn = _dup2(iStdin, _fileno(stdin));
iReturn = _dup2(iStdout, _fileno(stdout));
iReturn = _dup2(iStderr, _fileno(stderr));
}
R_API int r_cons_pipe_open(const char *file, int fdn, int append) {
char *targetFile;
if (fdn < 1) {
return -1;
}
if (!strncmp (file, "~/", 2) || !strncmp (file, "~\\", 2)) {
targetFile = r_str_home (file + 2);
} else {
targetFile = strdup (file);
}
int fd = r_sandbox_open (targetFile,
O_BINARY | O_RDWR | O_CREAT | (append? O_APPEND: O_TRUNC), 0644);
if (fd==-1) {
eprintf ("r_cons_pipe_open: Cannot open file '%s'\n", file);
free (targetFile);
return -1;
}// else eprintf ("%s created\n", file);
if (backup_fd != -1) {
close (backup_fd);
}
backup_fdn = fdn;
#if __WINDOWS__ && !__CYGWIN__
backup_fd = 2002-(fd-2); // windows xp has 2048 as limit fd
if (_dup2 (fdn, backup_fd) == -1) {
#else
backup_fd = sysconf (_SC_OPEN_MAX)-(fd-2); // portable getdtablesize()
if (backup_fd < 2) {
backup_fd = 2002 - (fd - 2); // fallback
}
if (dup2 (fdn, backup_fd) == -1) {
#endif
eprintf ("Cannot dup stdout to %d\n", backup_fd);
free (targetFile);
return -1;
}
close (fdn);
dup2 (fd, fdn);
free (targetFile);
return fd;
}
R_API void r_cons_pipe_close(int fd) {
if (fd == -1) {
return;
}
close (fd);
if (backup_fd != -1) {
dup2 (backup_fd, backup_fdn);
close (backup_fd);
backup_fd = -1;
}
}
void Log::SetMode(int mode) {
if (mode & ToDebug)
m_todebug = true;
else
m_todebug = false;
if (mode & ToFile) {
m_tofile = true;
} else {
CloseFile();
m_tofile = false;
}
#ifdef _WIN32_WCE
m_toconsole = false;
#else
if (mode & ToConsole) {
if (!m_toconsole) {
AllocConsole();
fclose(stdout);
fclose(stderr);
#ifdef _MSC_VER
int fh = _open_osfhandle((long)GetStdHandle(STD_OUTPUT_HANDLE), 0);
_dup2(fh, 1);
_dup2(fh, 2);
_fdopen(1, "wt");
_fdopen(2, "wt");
printf("fh is %d\n",fh);
fflush(stdout);
#endif
}
m_toconsole = true;
} else {
m_toconsole = false;
}
#endif
}
OutputLogger::OutputLogger(FILE *file, const std::string &filename) :
fd(-1), fileOld(NULL), filenameLog(filename), fileLog(NULL),
fdPipeRead(-1), pThread(NULL)
{
// Get the underlying file descriptor for the FILE stream
fd = _fileno(file);
// Probably on windows and there is no stdout/stderr in Subsystem Windows
if (fd < 0) {
fileLog = freopen(filenameLog.c_str(),"w",file);
#ifdef WIN32
DWORD stdhandle = 0;
if (fileLog == stdout)
stdhandle = STD_OUTPUT_HANDLE;
else if (fileLog == stderr)
stdhandle = STD_ERROR_HANDLE;
if (stdhandle)
SetStdHandle(stdhandle,(HANDLE)_get_osfhandle(_fileno(fileLog)));
#endif
return;
}
// Create the pipe
int fdsPipe[2];
if (_pipe(fdsPipe,256,_O_BINARY) != 0) {
return;
}
fdPipeRead = fdsPipe[0];
int fdPipeWrite = fdsPipe[1];
// Make sure that buffering is turned off on the incoming file
std::setvbuf(file,NULL,_IONBF,0);
// Duplicate the fd and create new filestream for it
fileOld = _fdopen(_dup(fd),"w");
// If the file was stderr, make sure the new file doesn't have buffering
if (fileOld && file == stderr) std::setvbuf(fileOld,NULL,_IONBF,0);
// Create the output log file
fileLog = std::fopen(filenameLog.c_str(),"w");
// Duplicate pipe write file descriptor and replace original
_dup2(fdPipeWrite,fd);
// Close the fd for the write end of the pipe
_close(fdPipeWrite);
fdPipeWrite = -1;
// Create the thread
pThread = SDL_CreateThread( (int (SDLCALL*)(void*)) &OutputLogger::sThreadMain,this);
}
static void
IoRedirect(signal_user_data_t *ud)
{
GIOChannel *channel;
gint pfd[2];
gchar *config, *path, *str;
pid_t pid;
// I'm opening a pipe and attaching the writer end to stderr
// The reader end will be polled by main event loop and I'll get
// a callback when there is data available.
if (pipe( pfd ) < 0)
{
g_warning("Failed to redirect IO. Logging impaired\n");
return;
}
clean_old_logs();
// Open activity log.
config = ghb_get_user_config_dir(NULL);
pid = getpid();
path = g_strdup_printf("%s/Activity.log.%d", config, pid);
ud->activity_log = g_io_channel_new_file (path, "w", NULL);
ud->job_activity_log = NULL;
str = g_strdup_printf("<big><b>%s</b></big>", path);
ghb_ui_update(ud, "activity_location", ghb_string_value(str));
g_free(str);
g_free(path);
g_free(config);
// Set encoding to raw.
g_io_channel_set_encoding(ud->activity_log, NULL, NULL);
// redirect stderr to the writer end of the pipe
#if defined(_WIN32)
_dup2(pfd[1], _fileno(stderr));
#else
dup2(pfd[1], STDERR_FILENO);
#endif
setvbuf(stderr, NULL, _IONBF, 0);
#if defined(_WIN32)
channel = g_io_channel_win32_new_fd(pfd[0]);
#else
channel = g_io_channel_unix_new(pfd[0]);
#endif
// I was getting an this error:
// "Invalid byte sequence in conversion input"
// Set disable encoding on the channel.
g_io_channel_set_encoding(channel, NULL, NULL);
g_io_add_watch(channel, G_IO_IN, ghb_log_cb, (gpointer)ud );
}
int main( int argc, char** argv ) {
if ( argc < 2 ) puts( "err2out is stdERR TO stdOUT redirector, version 2.2\nCopyright (c) 2002-2003 Denis Ryzhkov ( Creon )\nhttp://creon.cjb.net/?soft/err2out\n\nExamples:\nerr2out \"C:\\Program Files\\jdk\\bin\\javac\" Some.java | more\nerr2out \"C:\\Program Files\\jdk\\bin\\javac\" Some.java > err.txt\nerr2out \"C:\\Program Files\\jdk\\bin\\javac\" Some.java >> err.txt" );
else {
_dup2( 1, 2 ); // redirect 2=stderr to 1=stdout
char** argz = new char*[ argc ]; // -argv[ 0 ], +end0
argz[ argc - 1 ] = 0; // end0
for ( int i = 0; i < argc - 1; i++ )
sprintf( argz[ i ] = new char[ strlen( argv[ i + 1 ] ) + 3 ], // \" \" \000
"\"%s\"", argv[ i + 1 ] );
_spawnv( _P_WAIT, argv[ 1 ], argz );
for ( i = 0; i < argc - 1; i++ ) delete[] argz[ i ];
delete[] argz;
}
return 0;
}
INT32 ossDup2( int oldFd, int newFd )
{
#if defined( _WINDOWS )
if ( _dup2( oldFd, newFd ) != 0 )
{
return SDB_SYS ;
}
#else
if ( dup2( oldFd, newFd ) < 0 )
{
return SDB_SYS ;
}
#endif // _WINDOWS
return SDB_OK ;
}
/**
* @brief
* manipulates the file descriptor fd.
*
* @param[in] fd - file descriptor
* @param[in] cmd - operation to be performed
* @param[in] arg - new fd
*
* @return int
* @retval 0 success
* @retval -2 error
*
*/
int
fcntl(int fd, int cmd, long arg)
{
if (cmd == F_DUPFD) {
/* dup2 is deprecated POSIX function. Hence using the ISO C++ conformant
* _dup2 instead. _dup2 functions associate a second file descriptor with
* a currently open file and returns 0 to indicate success.
*/
if (_dup2(fd, arg)== 0)
return (arg);
}
return (-2);
}
static int do_dump_do(sc_card_t *card, unsigned int tag)
{
int r, tmp;
FILE *fp;
// Private DO are specified up to 254 bytes
unsigned char buffer[254];
memset(buffer, '\0', sizeof(buffer));
r = sc_get_data(card, tag, buffer, sizeof(buffer));
if (r < 0) {
printf("Failed to get data object: %s\n", sc_strerror(r));
if(SC_ERROR_SECURITY_STATUS_NOT_SATISFIED == r) {
printf("Make sure the 'verify' and 'pin' parameters are correct.\n");
}
return r;
}
if(opt_raw) {
r = 0;
#ifndef _WIN32
tmp = dup(fileno(stdout));
#else
tmp = _dup(_fileno(stdout));
#endif
if (tmp < 0)
return EXIT_FAILURE;
fp = freopen(NULL, "wb", stdout);
if (fp) {
r = (int)fwrite(buffer, sizeof(char), sizeof(buffer), fp);
}
#ifndef _WIN32
dup2(tmp, fileno(stdout));
#else
_dup2(tmp, _fileno(stdout));
#endif
clearerr(stdout);
close(tmp);
if (sizeof(buffer) != r)
return EXIT_FAILURE;
} else {
util_hex_dump_asc(stdout, buffer, sizeof(buffer), -1);
}
return EXIT_SUCCESS;
}
static FILE *my_win_freopen(const char *path, const char *mode, FILE *stream)
{
int handle_fd, fd= _fileno(stream);
HANDLE osfh;
DBUG_ASSERT(path && stream);
/* Services don't have stdout/stderr on Windows, so _fileno returns -1. */
if (fd < 0)
{
if (!freopen(path, mode, stream))
return NULL;
fd= _fileno(stream);
}
if ((osfh= CreateFile(path, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE |
FILE_SHARE_DELETE, NULL,
OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL,
NULL)) == INVALID_HANDLE_VALUE)
{
_close(fd);
return NULL;
}
if ((handle_fd= _open_osfhandle((intptr_t)osfh,
_O_APPEND | _O_TEXT)) == -1)
{
CloseHandle(osfh);
return NULL;
}
if (_dup2(handle_fd, fd) < 0)
{
CloseHandle(osfh);
return NULL;
}
_close(handle_fd);
return stream;
}