/* hosts/amiga/signal.c
**
** Adapt the default-signal handling for inclusion of timer-
** and user-generated signals. In detail this means setting the
** task_exception_code hook on a stub which 'raise()s' the appropriate
** signals.
** This is closely coupled with the timer functions so they are also
** implemented here.
**
** LPMud uses the signals SIGHUP (driver process abortion by the user),
** SIGALRM (alarm timed out) and an interrupt signal for select().
** Amylaar additionally uses SIGUSR1 (update of the master by the user).
** These three signals are not caused by other program parts (as the standard
** implementation assumes), but instead are caused by timer time-outs or
** keypresses. Therefore these are implemented explicitely by using
** the Amiga's internal task signal system, which allows the setting of
** an exception handler which is called whenever a task signal is raised.
** The other signals are passed through to the standard clib signal().
**
** For easier compilation, the catch_exception() which needs registerized
** args is put in a separate file signal_rr.c .
**
** This code is based on the UnixLib by Erik van Roode.
**
**   18-Oct-92 [lars]  Done for DICE 2.06.40
**   24-Feb-93 [lars]  Small fix to support compilation for OS 1.3
**   28-Feb-93 [lars]  Moved to DICE 2.07.53
**   09-Feb-93 [lars]  Added check_signals() and default break handling.
*/

#include <sys/types.h>
#include <exec/types.h>
#include <exec/memory.h>
#include <exec/tasks.h>
#include <exec/interrupts.h>
#include <devices/timer.h>
#ifdef INCLUDE_VERSION
#include <dos/dos.h>
#include <clib/alib_protos.h>
#include <clib/dos_protos.h>
#include <clib/exec_protos.h>
#else
#include <libraries/dos.h>
#endif
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <fcntl.h>
#include "nsignal.h"
#undef signal			/* This macro is implemented here! */

/*-----------------------------------------------------------------------*/

extern __regargs __geta4 ULONG catch_exception(__D0 ULONG);

ULONG sys_signal_alarm = 0,	/* The system-signal-masks */
      sys_signal_hup = 0, sys_signal_usr = 0;

void (*handler_hup) (void), (*handler_alarm) (void), (*handler_usr) (void);

static struct timerequest *treq = NULL;	/* the alarm()-timer */

/*-----------------------------------------------------------------------
** int start_timer (struct timeval *tv, struct timerequest *tr)
**
**   Start a timer <tr> with given timeval <tv>.
*/

__stkargs int start_timer(struct timeval * tv, struct timerequest * tr)
{
    if (!tr) {
	printf("no request structure\n");
	return 0;
    }
    if (tv->tv_secs == 0L && tv->tv_micro < 2L)
	tv->tv_micro = 2L;	/* minimal delay */

    tr->tr_time = *tv;
    tr->tr_node.io_Command = TR_ADDREQUEST;

    SendIO((struct IORequest *) tr);
    return 1;
}

/*-----------------------------------------------------------------------
** int setup_timer (LONG unit, struct timerequest **tr)
**
**   Setup a timer counting in <unit>, and store it in <tr>.
*/

__stkargs int setup_timer(LONG unit, struct timerequest ** tr)
{
    struct MsgPort *timerport;
    struct timerequest *req;

    if (*tr)
	return 1;

    if (!(timerport = (struct MsgPort *) CreatePort(0L, 0L))) {
	*tr = NULL;
	printf("setup_timer: could not create port\n");
	return 0;
    }
    if (!(req = (struct timerequest *) CreateExtIO(timerport
						,sizeof(struct timerequest))
	)) {
	DeletePort(timerport);
	*tr = NULL;
	printf("setup_timer: could not get request\n");
	return 0;
    }
    if (OpenDevice(TIMERNAME, unit, (struct IORequest *) req, 0L)) {
	CloseDevice((struct IORequest *) req);
	DeleteExtIO((struct IORequest *) req);
	DeletePort(timerport);
	printf("setup_timer: could not open timer\n");
	*tr = NULL;
	return 0;
    }
    *tr = req;
    return 1;
}

/*-----------------------------------------------------------------------
** void cleanup_timer (struct timerequest **tr)
**
**   Cleanup given timer <tr>.
*/

__stkargs void cleanup_timer(struct timerequest ** tr)
{
    struct MsgPort *tp;
    struct timerequest *tmp;
    UBYTE pFlags;

    if (*tr) {
	tmp = *tr;
	tp = tmp->tr_node.io_Message.mn_ReplyPort;
	if (tp) {
	    /* abort the current request */
	    pFlags = tp->mp_Flags;	/* still needed for DeletePort */
	    tp->mp_Flags = PA_IGNORE;
	    AbortIO((struct IORequest *) tmp);
	    WaitIO((struct IORequest *) tmp);
	    while (GetMsg(tp));
	    Forbid();
	    tp->mp_Flags = pFlags;
	    DeletePort(tp);
	    Permit();
	}
	CloseDevice((struct IORequest *) tmp);
	DeleteExtIO((struct IORequest *) tmp);
    }
    *tr = NULL;
}

/*-----------------------------------------------------------------------
** __stkargs int alarm (int seconds)
**
**   Start a timer which raises SIGALRM after <seconds>.
**   Also cleans up the mess made by a previous alarm.
**   Specifying a zero time count just cleans up.
*/

__stkargs unsigned int alarm(unsigned int seconds)
{
    static struct timeval tv;
    static first = 1;

    if (!treq) {
	printf("No handler installed !\n");
	if (seconds > 0)
	    return 0;		/* Heartbeat won't work :+( */
    }
    tv.tv_secs = seconds;
    tv.tv_micro = 0;

    if (seconds > 0) {
	/* first call of alarm() : WaitIO on unsent request ..... */
	if (!first) {
	    treq->tr_node.io_Message.mn_ReplyPort->mp_Flags = PA_IGNORE;
	    AbortIO((struct IORequest *) treq);
	    WaitIO((struct IORequest *) treq);
	    treq->tr_node.io_Message.mn_ReplyPort->mp_Flags = PA_SIGNAL;
	}
	first = 0;
	start_timer(&tv, treq);
    } else {
	/*
	 * if I don't use this code, AbortIO will generate a signal, which
	 * will trigger catch_alarm. catch_alarm will then generate CTRL-E.
	 * This can be resolved by preventing the signal to occur :+)
	 */
	treq->tr_node.io_Message.mn_ReplyPort->mp_Flags = PA_IGNORE;
	AbortIO((struct IORequest *) treq);
	WaitIO((struct IORequest *) treq);
	cleanup_timer(&treq);
	first = 1;
    }
    return 0;
}


/*-----------------------------------------------------------------------
** __sigfunc new_signal (int signo, __sigfunc handler)
**
**   Set the <handler> for <signo>.
**   The signals SIGHUP, SIGUSR1 and SIGALRM are treated manually to
**   allow the system-signals call the handlers via external exceptions.
*/

__stkargs __sigfunc new_signal(int signo, __sigfunc handler)
{
    register struct Task *this_task;

    this_task = (struct Task *) FindTask(NULL);

    switch (signo) {
    case SIGALRM:{
	    ULONG sigalrm;

	    sigalrm = sys_signal_alarm;
	    if ((__sigfunc) handler == SIG_IGN) {	/* remove SIGALRM
							 * handler */
		SetExcept(0L, sigalrm);	/* Only sigalrm !! */
		sys_signal_alarm = 0;
		handler_alarm = NULL;
		cleanup_timer(&treq);
	    } else {		/* install handler */
		if (!setup_timer(UNIT_VBLANK, &treq)) {
		    printf("Could not setup_timer\n");
		    break;	/* What else ?? */
		}
		sigalrm = 1L << (treq->tr_node.io_Message.mn_ReplyPort->mp_SigBit);

		this_task->tc_ExceptCode = (APTR) catch_exception;
		sys_signal_alarm = sigalrm;
		handler_alarm = (void (*) ()) handler;
		SetExcept(sigalrm, sigalrm);
		/* If we start treq, handler will be called */
	    }
	    break;
	}
    case SIGHUP:{
	    ULONG sighup;

	    sighup = (((__sigfunc) handler == SIG_IGN) || ((__sigfunc) handler == SIG_DFL))
		? 0 : EXT_SIGHUP;

	    this_task->tc_ExceptCode = (APTR) catch_exception;
	    sys_signal_hup = sighup;
	    handler_hup = (void (*) ()) handler;
	    SetExcept(sighup, EXT_SIGHUP);
	    break;
	}
    case SIGUSR1:{
	    ULONG sigusr;

	    sigusr = (((__sigfunc) handler == SIG_IGN) || ((__sigfunc) handler == SIG_DFL))
		? 0 : EXT_SIGUSR;

	    this_task->tc_ExceptCode = (APTR) catch_exception;
	    sys_signal_usr = sigusr;
	    handler_usr = (void (*) ()) handler;
	    SetExcept(sigusr, EXT_SIGUSR);
	    break;
	}
    default:
	signal(signo, handler);
	break;
    }
    return handler;
}

/*-----------------------------------------------------------------------
** ULONG check_signals (void)
**
**   Check the tasks external signals and call the associated handler
**   (if any).
**   Result is the signal mask.
*/

static int _ChkSignalLockout = 0;	/* simple semaphore for
					 * check_signals() */

ULONG check_signals(void)
{
    ULONG mask;

    if (_ChkSignalLockout)
	return 0L;
    ++_ChkSignalLockout;

    mask = ((struct Task *) FindTask(NULL))->tc_SigRecvd;

    /* Default Ctrl-C handling */
    if (!sys_signal_hup && (mask & SIGBREAKF_CTRL_C)) {
	SetSignal(0L, SIGBREAKF_CTRL_C);
	write(2, "*** Break.\n", 11);
	exit(EXIT_FAILURE);
    }
    /* Handle our special exceptions */
    if (mask & sys_signal_alarm) {
	(*handler_alarm) ();
	SetSignal(0L, sys_signal_alarm);
    }
    if (mask & sys_signal_hup) {
	(*handler_hup) ();
	SetSignal(0L, sys_signal_hup);
    }
    if (mask & sys_signal_usr) {
	(*handler_usr) ();
	SetSignal(0L, sys_signal_usr);
    }
    --_ChkSignalLockout;
    return mask;
}

/*************************************************************************/