void exit_pragha(GtkWidget *widget, struct con_win *cwin)
{
if (cwin->cpref->save_playlist)
save_current_playlist_state(cwin);
common_cleanup(cwin);
gtk_main_quit();
CDEBUG(DBG_INFO, "Halt.");
}
/*** undo any externally visible effects of an aborted transaction */
void cleanup() {
// make sure we're aborted
assert(tx_state == ABORTED);
// release the locks and restore version numbers
releaseAndRevertLocks();
// undo memory operations
allocator.onTxAbort();
// reset all lists
common_cleanup();
}
/*** commit memops and release inevitability */
void cleanup_inevitable() {
// if I have locks, get a commit time
if (locks.size() != 0)
end_time = 1 + fai(×tamp);
// unmark inevitable reads
cm.onCommit();
cm.postCommit(locks);
// release orecs and clean up
releaseAndIncrementLocks();
allocator.onTxCommit();
common_cleanup();
}
static void
native_npclose(FILE *fp)
{
int term_status;
(void) fflush(fp);
(void) fclose(fp);
if (proc_handle != BAD_PROC_HANDLE)
{
(void) cwait(&term_status, (CWAIT_PARAM_TYPE) proc_handle, 0);
TRACE(("...CreateProcess finished waiting in native_npclose\n"));
close_proc_handle();
}
common_cleanup();
}
/*** undo any externally visible effects of an aborted transaction */
void cleanup() {
// make sure we're aborted
assert(tx_state == ABORTED);
// release the locks and restore version numbers
releaseAndRevertLocks();
// sgla quiescence mechanism
commitStampTable[threadid].val = 0xFFFFFFFF;
startStampTable[threadid].val = 0xFFFFFFFF;
// unroll mm ops
allocator.onTxAbort();
// reset all lists
common_cleanup();
}
static void
tmp_cleanup(void)
{
close_fd(stdin_fd);
close_fd(stdout_fd);
if (stdin_name)
{
(void) remove(stdin_name);
(void) free(stdin_name);
stdin_name = NULL;
}
if (stdout_name)
{
(void) remove(stdout_name);
(void) free(stdout_name);
stdout_name = NULL;
}
common_cleanup();
}
/* Run client and the server if needed. */
static void start_moc (const struct parameters *params, lists_t_strs *args)
{
int server_sock;
if (params->foreground) {
set_me_server ();
server_init (params->debug, params->foreground);
server_loop ();
return;
}
server_sock = server_connect ();
if (server_sock != -1 && params->only_server)
fatal ("Server is already running!");
if (server_sock == -1) {
int i = 0;
int notify_pipe[2];
ssize_t rc;
printf ("Running the server...\n");
/* To notify the client that the server socket is ready */
if (pipe(notify_pipe))
fatal ("pipe() failed: %s", xstrerror (errno));
switch (fork()) {
case 0: /* child - start server */
set_me_server ();
server_init (params->debug, params->foreground);
rc = write (notify_pipe[1], &i, sizeof(i));
if (rc < 0)
fatal ("write() to notify pipe failed: %s", xstrerror (errno));
close (notify_pipe[0]);
close (notify_pipe[1]);
server_loop ();
options_free ();
decoder_cleanup ();
io_cleanup ();
files_cleanup ();
rcc_cleanup ();
common_cleanup ();
exit (EXIT_SUCCESS);
case -1:
fatal ("fork() failed: %s", xstrerror (errno));
default:
close (notify_pipe[1]);
if (read(notify_pipe[0], &i, sizeof(i)) != sizeof(i))
fatal ("Server exited!");
close (notify_pipe[0]);
server_sock = server_connect ();
if (server_sock == -1) {
perror ("server_connect()");
fatal ("Can't connect to the server!");
}
}
}
if (params->only_server)
send_int (server_sock, CMD_DISCONNECT);
else {
xsignal (SIGPIPE, SIG_IGN);
if (!ping_server (server_sock))
fatal ("Can't connect to the server!");
init_interface (server_sock, params->debug, args);
interface_loop ();
interface_end ();
}
close (server_sock);
}
static int
native_inout_popen(FILE **fr, FILE **fw, char *cmd)
{
char buf[NFILEN + 128];
HANDLE handles[3];
int i, rc, rp[3], tmpin_fd, wp[3];
TRACE((T_CALLED "native_inout_popen cmd=%s\n", cmd));
proc_handle = BAD_PROC_HANDLE;
rp[0] = rp[1] = rp[2] = wp[0] = wp[1] = wp[2] = BAD_FD;
handles[0] = handles[1] = handles[2] = INVALID_HANDLE_VALUE;
tmpin_fd = BAD_FD;
tmpin_name = NULL;
set_console_title(cmd);
if (is_win95())
{
char *cmdp;
/*
* If w32pipes is set on a win95 host, you don't ever want slowreadf()
* to periodically update the display while an intrinisic, high
* bandwidth DOS command is in progress. Reason: the win95 shell,
* command.com, will simply hang in the following scenario:
*
* ^X!<high_bandwidth_cmd>
*
* and
*
* PIPESIZ < output of <high_bandwidth_cmd>
*
* I'm assuming that what's going on here is that command.com is
* written in ASM and is using very low level BIOS/DOS calls to
* effect output and, furthermore, that these low level calls don't
* block when the input consumer is busy.
*/
cmdp = skip_blanks(cmd);
nowait_pipe_cmd = (strnicmp(cmdp, "dir", 3) == 0) ||
(strnicmp(cmdp, "type", 4) == 0);
}
do
{
if (fr)
{
*fr = NULL;
/*
* Open (parent's) input pipe in TEXT mode, which will force
* translation of the child's CR/LF record delimiters to NL
* and keep the dreaded ^M chars from temporarily appearing
* in a vile buffer (ugly).
*/
if (_pipe(rp, PIPESIZ, O_TEXT|O_NOINHERIT) == -1)
break;
if ((rp[2] = _dup(rp[1])) == -1)
break;
handles[2] = handles[1] = (HANDLE) _get_osfhandle(rp[2]);
(void) close(rp[1]);
rp[1] = BAD_FD;
if (! fw)
{
/*
* This is a read pipe (only). Connect child's stdin to
* an empty file. Under no circumstances should the
* child's stdin be connected to a device (else lots of
* screwy things will occur). In particular, connecting
* the child's stdin to the parent's stdin will cause
* aborts and hangs on the various Win32 hosts. You've
* been warned.
*/
if ((tmpin_name = _tempnam(getenv("TEMP"), "vile")) == NULL)
break;
if ((tmpin_fd = open(tmpin_name,
O_RDONLY|O_CREAT|O_TRUNC,
_S_IWRITE|_S_IREAD)) == BAD_FD)
{
break;
}
handles[0] = (HANDLE) _get_osfhandle(tmpin_fd);
}
if ((*fr = fdopen(rp[0], "r")) == 0)
break;
}
if (fw)
{
*fw = NULL;
/*
* Open (child's) output pipe in binary mode, which will
* prevent translation of the parent's CR/LF record delimiters
* to NL. Apparently, many apps want those delimiters :-) .
*/
if (_pipe(wp, PIPESIZ, O_BINARY|O_NOINHERIT) == -1)
break;
if ((wp[2] = _dup(wp[0])) == -1)
break;
handles[0] = (HANDLE)_get_osfhandle(wp[2]);
(void) close(wp[0]);
wp[0] = BAD_FD;
if (! fr)
handles[1] = handles[2] = GetStdHandle(STD_OUTPUT_HANDLE);
if ((*fw = fdopen(wp[1], "w")) == 0)
break;
}
rc = (exec_shell(cmd,
handles,
fr != NULL /* Child wdw hidden unless write pipe. */
) == BAD_PROC_HANDLE) ? FALSE : TRUE;
if (fw)
{
if (! rc)
{
/* Shell process failed, put complaint in user's face. */
sprintf(buf, SHELL_ERR_MSG, get_shell());
lastditch_msg(buf);
}
w32_close_handle(handles[0]);
}
if (fr)
{
if (! rc)
{
unsigned len;
/*
* Shell process failed, put complaint in user's buffer.
* Can't write to handles[1] on a win2k host because the
* previously failed CreateProcess() call damaged the
* handle.
*/
len = (unsigned) (lsprintf(buf, SHELL_ERR_MSG, get_shell()) - buf);
(void) write(rp[2], buf, len);
(void) close(rp[2]); /* in weird state; why not? */
}
w32_close_handle(handles[1]);
close_fd(tmpin_fd);
}
returnCode(rc);
}
while (FALSE);
/* If we get here -- some operation has failed. Clean up. */
close_fd(wp[0]);
close_fd(wp[1]);
close_fd(wp[2]);
close_fd(rp[0]);
close_fd(rp[1]);
close_fd(rp[2]);
close_fd(tmpin_fd);
for (i = 0; i < 3; i++)
{
if (handles[i] != INVALID_HANDLE_VALUE)
w32_close_handle(handles[i]);
}
common_cleanup();
returnCode(FALSE);
}
ut_cleanup()
{
common_cleanup();
}
