DataMuseum.dk

top - metrics - download

    Length: 10646 (0x2996)
    Types: TextFile
    Names: »ryresponder.c«

└─⟦2d1937cfd⟧ Bits:30007241 EUUGD22: P.P 5.0
    └─⟦dc59850a2⟧ »EurOpenD22/pp5.0/pp-5.tar.Z« 
        └─⟦e5a54fb17⟧ 
            └─⟦this⟧ »pp-5.0/Src/qmgr/ryresponder.c« 

TextFile

/* ryresponder.c - responder stuff - mackled out of ryresponder.c */

# ifndef lint
static char Rcsid[] = "@(#)$Header: /cs/research/pp/hubris/pp-beta/Src/qmgr/RCS/ryresponder.c,v 5.0 90/09/20 16:21:41 pp Exp Locker: pp $";
# endif

/*
 * $Header: /cs/research/pp/hubris/pp-beta/Src/qmgr/RCS/ryresponder.c,v 5.0 90/09/20 16:21:41 pp Exp Locker: pp $
 *
 * $Log:	ryresponder.c,v $
 * Revision 5.0  90/09/20  16:21:41  pp
 * rcsforce : 5.0 public release
 * 
 */



#include "util.h"
#include "ryresponder.h"
#include "Qmgr-ops.h"
#include <isode/tsap.h>         /* for listening */
#include <varargs.h>

/* \f

   DATA */

char     *myname = "qmgr";
static jmp_buf  toplevel;
static IFP      startfnx;
static IFP      stopfnx;
static int      ros_init (),
		ros_work ();
static void	ros_indication (),
		ros_lose ();
extern int      errno;
fd_set          perf_rfds,
		perf_wfds;
int             perf_nfds;
int		delaytime = NOTOK;
extern time_t current_time;

void		start_specials (), schedule ();
/* \f

   RESPONDER */

int     ryresponder (argc, argv, host, myservice, dispatches, ops, start, stop)
int     argc;
char  **argv,
       *host,
       *myservice;
struct server_dispatch *dispatches;
struct RyOperation *ops;
IFP     start,
	stop;
{
	register struct server_dispatch   *ds;
	AEI     aei;
	struct TSAPdisconnect   tds;
	struct TSAPdisconnect  *td = &tds;
	struct RoSAPindication  rois;
	register struct RoSAPindication *roi = &rois;
	register struct RoSAPpreject   *rop = &roi -> roi_preject;
	fd_set      rfds;
	fd_set      wfds;
	int	n;
	int fd;

	PP_TRACE (("ryresponder (%d, argv, %s, %s...)",
		   argc, host, myservice));
	FD_ZERO (&perf_rfds);
	FD_ZERO (&rfds);
	FD_ZERO (&perf_wfds);
	FD_ZERO (&wfds);

	if (myname = rindex (argv[0], '/'))
		myname++;
	if (myname == NULL || *myname == NULL)
		myname = argv[0];

	isodetailor (myname, 0);
	ll_hdinit (pp_log_norm, myname);

	if (isatty (fileno (stderr)))
		pp_log_norm -> ll_stat |= LLOGTTY;
	else {
		int fd = open("/dev/null", 2);
		if (fd != 0)
			dup2 (fd, 0);
		dup2 (fd, 1);
		dup2 (fd, 2);
		if (fd != 0)
			(void) close (fd);
	}

	advise (LLOG_NOTICE, NULLCP, "starting");

	init_chans ();

	for (ds = dispatches; ds -> ds_name; ds++)
		if (RyDispatch (NOTOK, ops, ds -> ds_operation,
				ds -> ds_vector, roi) == NOTOK)
			ros_adios (rop, ds -> ds_name);

	startfnx = start;
	stopfnx = stop;

	for (n = 1;; n++) {
		if ((aei = str2aei (host, myservice)) == NULLAEI &&
		    (aei = str2aei (host, "pp-qmgr")) == NULLAEI)
			adios (NULLCP, "%s-%s: unknown application-entity",
			       host, myservice);

		if (iserver_init (0, argv, aei, ros_init, td) == NOTOK) {
			if (n > 15) {
				if (td -> td_cc > 0)
					adios (NULLCP, 
					       "iserver_init: [%s] %*.*s",
					       TErrString (td -> td_reason),
					       td -> td_cc, td -> td_cc,
					       td -> td_data);
				else
					adios (NULLCP, "iserver_init: [%s]",
					       TErrString (td -> td_reason));
			}
			if (td -> td_cc > 0)
				advise (LLOG_EXCEPTIONS, NULLCP,
					"iserver_init: [%s] %*.*s",
					TErrString (td -> td_reason),
					td -> td_cc, td -> td_cc,
					td -> td_data);
			else
				advise (LLOG_EXCEPTIONS, NULLCP,
					"iserver_init: [%s]",
					TErrString (td -> td_reason));
			sleep (5 * n);
			continue;
		}
		break;
	}

	start_specials ();

	PP_TRACE(("Listening"));

	for (;;) {
		schedule ();
		rfds = perf_rfds;
		wfds = perf_wfds;
		PP_TRACE (("Main loop..."));
		switch (iserver_wait (ros_init, ros_work, ros_lose, perf_nfds,
				      &rfds, &wfds, NULLFD, delaytime, td)) {
		    case DONE:
			return 0;

		    case NOTOK:
			if (td -> td_cc > 0)
				adios (NULLCP, "iserver_wait: [%s] %*.*s",
				       TErrString (td -> td_reason),
				       td -> td_cc, td -> td_cc,
				       td -> td_data);
			else
				adios (NULLCP, "iserver_wait: [%s]",
				       TErrString (td -> td_reason));
			break;
		    case OK:
			(void) time (&current_time);

			for (fd = 0; fd < perf_nfds; fd++)
				if (FD_ISSET (fd, &rfds) ||
				    FD_ISSET (fd, &wfds))
					chan_manage (fd);
			break;
		    default:
			adios (NULLCP, "Illegal return from iserver_wait");
		}
	}
}

/* \f

 */

static int  ros_init (vecp, vec)
int     vecp;
char  **vec;
{
	int     reply,
		result,
		sd;
	PE	pep[1];
	int	npe = 0;
	struct AcSAPstart   acss;
	register struct AcSAPstart *acs = &acss;
	struct AcSAPindication  acis;
	register struct AcSAPindication *aci = &acis;
	register struct AcSAPabort   *aca = &aci -> aci_abort;
	register struct PSAPstart *ps = &acs -> acs_start;
	struct RoSAPindication  rois;
	register struct RoSAPindication *roi = &rois;
	register struct RoSAPpreject   *rop = &roi -> roi_preject;

	PP_TRACE (("ros_init (%d, vec)", vecp));

	if (AcInit (vecp, vec, acs, aci) == NOTOK) {
		acs_advise (aca, "initialization fails");
		return NOTOK;
	}
	advise (LLOG_NOTICE, NULLCP,
		"A-ASSOCIATE.INDICATION: <%d, %s, %s, %s, %d>",
		acs -> acs_sd, sprintoid (acs -> acs_context),
		sprintaei (&acs -> acs_callingtitle),
		sprintaei (&acs -> acs_calledtitle), acs -> acs_ninfo);

	sd = acs -> acs_sd;

	for (vec++; *vec; vec++)
		advise (LLOG_NOTICE, NULLCP, "unknown argument \"%s\"", *vec);

	pep[0] = NULLPE;
	reply = startfnx ? (*startfnx) (sd, acs, pep, &npe) : ACS_ACCEPT;

	result = AcAssocResponse (sd, reply, 
				  reply != ACS_ACCEPT ?
				  ACS_USER_NOREASON : ACS_USER_NULL, 
				  NULLOID, NULLAEI, NULLPA, NULLPC,
				  ps -> ps_defctxresult,
				  ps -> ps_prequirements,
				  ps -> ps_srequirements, SERIAL_NONE,
				  ps -> ps_settings, &ps -> ps_connect,
				  pep, npe, aci);

	if (pep[0])
		pe_free (pep[0]);
	ACSFREE (acs);

	if (result == NOTOK) {
		acs_advise (aca, "A-ASSOCIATE.RESPONSE");
		return NOTOK;
	}
	if (reply != ACS_ACCEPT)
		return NOTOK;

	if (RoSetService (sd, RoPService, roi) == NOTOK)
		ros_adios (rop, "set RO/PS fails");

	return sd;
}

/* \f

 */

static int  ros_work (fd)
int     fd;
{
	int     result;
	caddr_t out;
	struct AcSAPindication  acis;
	struct RoSAPindication  rois;
	register struct RoSAPindication *roi = &rois;
	register struct RoSAPpreject   *rop = &roi -> roi_preject;

	PP_TRACE (("ros_work (%d)", fd));

	(void) time (&current_time);
	switch (setjmp (toplevel)) {
	    case OK: 
		break;

	    default: 
		if (stopfnx)
			(void) (*stopfnx) (fd, (struct AcSAPfinish *) 0);
	    case DONE:
		(void) AcUAbortRequest (fd, NULLPEP, 0, &acis);
		(void) RyLose (fd, roi);
		return NOTOK;
	}

	switch (result = RyWait (fd, NULLIP, &out, OK, roi)) {
	    case NOTOK: 
		if (rop -> rop_reason == ROS_TIMER)
			break;
	    case OK: 
	    case DONE: 
		ros_indication (fd, roi);
		break;

	    default: 
		adios (NULLCP, "unknown return from RoWaitRequest=%d", result);
	}

	return OK;
}

/* \f

 */

static void ros_indication (sd, roi)
int     sd;
register struct RoSAPindication *roi;
{
	int     reply,
	result;

	PP_TRACE (("ros_indication (%d)", sd));

	switch (roi -> roi_type) {
	    case ROI_INVOKE: 
	    case ROI_RESULT: 
	    case ROI_ERROR: 
		adios (NULLCP, "unexpected indication type=%d",
		       roi -> roi_type);
		break;

	    case ROI_UREJECT: 
		{
			register struct RoSAPureject   *rou =
				&roi -> roi_ureject;

			if (rou -> rou_noid)
				advise (LLOG_NOTICE, NULLCP,
					"RO-REJECT-U.INDICATION/%d: %s",
					sd, RoErrString (rou -> rou_reason));
			else
				advise (LLOG_NOTICE, NULLCP,
					"RO-REJECT-U.INDICATION/%d: %s (id=%d)",
					sd, RoErrString (rou -> rou_reason),
					rou -> rou_id);
		}
		break;

	    case ROI_PREJECT: 
		{
			register struct RoSAPpreject   *rop = &roi -> roi_preject;

			if (ROS_FATAL (rop -> rop_reason))
				ros_adios (rop, "RO-REJECT-P.INDICATION");
			ros_advise (rop, "RO-REJECT-P.INDICATION");
		}
		break;

	    case ROI_FINISH: 
		{
			register struct AcSAPfinish *acf = &roi -> roi_finish;
			struct AcSAPindication  acis;
			register struct AcSAPabort *aca = &acis.aci_abort;

			advise (LLOG_NOTICE, NULLCP, "A-RELEASE.INDICATION/%d: %d",
				sd, acf -> acf_reason);

			reply = stopfnx ? (*stopfnx) (sd, acf) : ACS_ACCEPT;

#ifdef CONNECTING_1
			result = AcRelResponse (sd, reply, ACR_NORMAL,
						NULLPEP, 0, NOTOK, &acis);
#else
			result = AcRelResponse (sd, reply, ACR_NORMAL,
						NULLPEP, 0, &acis);
#endif
			ACFFREE (acf);

			if (result == NOTOK)
				acs_advise (aca, "A-RELEASE.RESPONSE");
			else
				if (reply != ACS_ACCEPT)
					break;
			longjmp (toplevel, DONE);
		}
		/* NOTREACHED */

	    default: 
		adios (NULLCP, "unknown indication type=%d", roi -> roi_type);
	}
}

/* \f

 */

static void  ros_lose (td)
struct TSAPdisconnect *td;
{
	PP_TRACE (("ros_lose ()"));

	if (td -> td_cc > 0)
		advise (LLOG_NOTICE, NULLCP, "TNetAccept: [%s] %*.*s",
			TErrString (td -> td_reason), td -> td_cc, td -> td_cc,
			td -> td_data);
	else
		advise (LLOG_NOTICE, NULLCP, "TNetAccept: [%s]",
			TErrString (td -> td_reason));
}

/* \f

   ERRORS */

void    ros_adios (rop, event)
register struct RoSAPpreject *rop;
char   *event;
{
	ros_advise (rop, event);

	longjmp (toplevel, NOTOK);
}


void    ros_advise (rop, event)
register struct RoSAPpreject *rop;
char   *event;
{
	char    buffer[BUFSIZ];

	if (rop -> rop_cc > 0)
		(void) sprintf (buffer, "[%s] %*.*s",
				RoErrString (rop -> rop_reason),
				rop -> rop_cc, rop -> rop_cc, rop -> rop_data);
	else
		(void) sprintf (buffer, "[%s]",
				RoErrString (rop -> rop_reason));

	advise (LLOG_NOTICE, NULLCP, "%s: %s", event, buffer);
}

/* \f

 */

void    acs_advise (aca, event)
register struct AcSAPabort *aca;
char   *event;
{
	char    buffer[BUFSIZ];

	if (aca -> aca_cc > 0)
		(void) sprintf (buffer, "[%s] %*.*s",
				AcErrString (aca -> aca_reason),
				aca -> aca_cc, aca -> aca_cc, aca -> aca_data);
	else
		(void) sprintf (buffer, "[%s]",
				AcErrString (aca -> aca_reason));

	advise (LLOG_NOTICE, NULLCP, "%s: %s (source %d)", event, buffer,
		aca -> aca_source);
}

/* \f

 */

#ifndef lint
void    adios (va_alist)
va_dcl
{
	va_list ap;

	va_start (ap);

	_ll_log (pp_log_norm, LLOG_FATAL, ap);

	va_end (ap);

	_exit (1);
}
#else
/* VARARGS2 */

void    adios (what, fmt)
char   *what,
       *fmt;
{
	adios (what, fmt);
}
#endif


#ifndef lint
void    advise (va_alist)
va_dcl
{
	int     code;
	va_list ap;

	va_start (ap);

	code = va_arg (ap, int);

	_ll_log (pp_log_norm, code, ap);

	va_end (ap);
}
#else
/* VARARGS3 */

void    advise (code, what, fmt)
char   *what,
       *fmt;
int     code;
{
	advise (code, what, fmt);
}
#endif


#ifndef lint
void    ryr_advise (va_alist)
va_dcl
{
	va_list ap;

	va_start (ap);

	_ll_log (pp_log_norm, LLOG_NOTICE, ap);

	va_end (ap);
}
#else
/* VARARGS2 */

void    ryr_advise (what, fmt)
char   *what,
       *fmt;
{
	ryr_advise (what, fmt);
}
#endif