ntp_osi.c

来自「ftam等标准协议服务器和客户端的源代码。」· C语言 代码 · 共 1,625 行 · 第 1/3 页

char *addr;
struct RoSAPindication *roi;
{
	int	    sd;
	struct SSAPref sfs;
	register struct SSAPref *sf;
	register struct PSAPaddr *pa, *pa2;
	struct AcSAPconnect accs;
	register struct AcSAPconnect   *acc = &accs;
	struct AcSAPindication  acis;
	register struct AcSAPindication *aci = &acis;
	register struct AcSAPabort   *aca = &aci -> aci_abort;
	OID	    ctx,
		pci;
	PE	pep[1];
	struct PSAPctxlist pcs;
	register struct PSAPctxlist *pc = &pcs;
	struct intf *ap;
	int	acount;
	int	result;

	if (peer -> src.type != AF_OSI)
		return NOTOK;
	ap = getintf (&acount);
	ap->addr = peer->src;
	ap->fd = -1;
	ap->name = "OSI";
	peer-> sock = acount;

	pa = &ap -> addr.psap_ad;
	TRACE (2, ("Making connection to %s", paddr2str (pa, NULLNA)));

	if ((pa2 = str2paddr (addr)) == NULLPA) {
		advise (LLOG_EXCEPTIONS, NULLCP, "Can't translate %s", addr);
                return NOTOK;
        }

	pep[0] = build_bind_arg (pa2, peer);
	if ((ctx = ode2oid (mycontext)) == NULLOID) {
		advise (LLOG_EXCEPTIONS, NULLCP,
			"%s: unknown object descriptor", mycontext);
		return NOTOK;
	}
	if ((ctx = oid_cpy (ctx)) == NULLOID) {
		advise (LLOG_EXCEPTIONS, "memory", "out of");
		return NOTOK;
	}
	if ((pci = ode2oid (mypci)) == NULLOID) {
		advise (LLOG_EXCEPTIONS, NULLCP,
			"%s: unknown object descriptor", mypci);
		return NOTOK;
	}
	if ((pci = oid_cpy (pci)) == NULLOID) {
		advise (LLOG_EXCEPTIONS, "memory", "out of");
		return NOTOK;
	}
	pc -> pc_nctx = 1;
	pc -> pc_ctx[0].pc_id = 1;
	pc -> pc_ctx[0].pc_asn = pci;
	pc -> pc_ctx[0].pc_atn = NULLOID;

	if ((sf = addr2ref (PLocalHostName ())) == NULL) {
		sf = &sfs;
		(void) bzero ((char *) sf, sizeof *sf);
	}

	result = AcAsynAssocRequest (ctx, NULLAEI, NULLAEI, pa2, pa,
				     pc, NULLOID,
				     0, ROS_MYREQUIRE, SERIAL_NONE, 0, sf,
				     pep, 1, NULLQOS,
				     acc, aci, 1);
	pe_free (pep[0]);
	switch (result) {
	    case NOTOK:
		acs_advise (aca, "A-ASSOCIATE.REQUEST");
		ap -> flags = 0;
		return result;

	    case CONNECTING_1:
	    case CONNECTING_2:
		ap -> fd = sd = acc -> acc_sd;
		ap -> flags |= INTF_PENDING;
		FD_SET (sd, &globwmask);
		if (sd >= selfds)
			selfds = sd + 1;
		ACCFREE (acc);
		return result;
	    case DONE:
		if (acc -> acc_result != ACS_ACCEPT)
			return handle_reject (acc, ap);
		return check_accept (acc, ap, peer);

	    default:
		advise (LLOG_EXCEPTIONS, NULLCP, "Unknown response (%d)",
			result);
		break;
	}
	return NOTOK;
}

static int check_accept (acc, ap, peer)
struct AcSAPconnect *acc;
struct intf *ap;
struct ntp_peer *peer;
{
	struct RoSAPindication rois;
	struct RoSAPindication *roi = &rois;
	struct RoSAPpreject *rop = &roi -> roi_preject;
	int	sd;
	int	version, mode;
	struct type_NTP_BindResult *bindres;

	if (acc -> acc_ninfo > 0) {
		PLOG (pgm_log, print_NTP_BindResult, acc -> acc_info[0],
		      "NTP.BindResult", 1);
		if (decode_NTP_BindResult (acc -> acc_info[0], 1,
					   NULLIP, NULLVP,
					   &bindres) == NOTOK) {
			advise (LLOG_EXCEPTIONS,  NULLCP,
				"decode bindresult failed [%s]", PY_pepy);
			terminate (ap, roi);
			return NOTOK;
		}
		version = bindres -> version;
		mode = bindres -> mode -> parm;
		free_NTP_BindResult (bindres);
	}
	else {
		version = 1;
		mode = int_NTP_BindMode_normal;
	}
					   
	sd = acc -> acc_sd;
		
	ACCFREE (acc);

	if (RoSetService (sd, RoPService, roi) == NOTOK) {
		ros_advise (rop, "set RO/PS fails");
		terminate (ap, roi);
		ap -> flags = 0;
		return NOTOK;
	}
	FD_SET (sd, &globmask);
	if (sd >= selfds)
		selfds = sd + 1;

	peer -> flags |= PEER_FL_CONNECTED;
	peer -> vers = version;
	peer -> mode = mode;
	ap -> fd = sd;
	ap->flags = INTF_VALID;

	TRACE (1,  ("CONNECTED to %s on %d if %d",
		    paddr2str (&peer->src.psap_ad, NULLNA),
		    sd, peer->sock));
	return DONE;
}

/* ARGSUSED */
static PE build_bind_arg (psap, peer)
struct PSAPaddr *psap;
struct ntp_peer *peer;
{
	struct type_NTP_BindArgument *bindarg;
	char	*str;
	PE	pe;

	bindarg = (struct type_NTP_BindArgument *)
		calloc (1, sizeof *bindarg);
	str = _paddr2str (psap, NULLNA, -1);
	bindarg -> psap = str2qb (str, strlen(str), 1);
	bindarg -> version =
		pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM,
			  PE_PRIM_BITS);
	(void) bit_on (bindarg -> version,
		bit_NTP_version_version__1);
	(void) bit_on (bindarg -> version,
		bit_NTP_version_version__2);

	bindarg -> mode = (struct type_NTP_BindMode *)
		calloc (1, sizeof *bindarg-> mode);
	bindarg -> mode -> parm =
		int_NTP_BindMode_normal;
	if (encode_NTP_BindArgument (&pe, 1, 0, NULLCP,
				     bindarg) == NOTOK) {
		pe = NULLPE;
		advise (LLOG_EXCEPTIONS, NULLCP,
			"encode Bindargument failed [%s]", PY_pepy);
	}
	else	{
		pe -> pe_context = 3;
		PLOG (pgm_log, print_NTP_BindArgument, pe,
		      "NTP.BindArgument", 0);
	}
	free_NTP_BindArgument (bindarg);
	return pe;
}

	
static int acsap_retry (peer, roi)
struct ntp_peer *peer;
struct RoSAPindication *roi;
{
	struct AcSAPconnect accs;
        register struct AcSAPconnect   *acc = &accs;
        struct AcSAPindication  acis;
        register struct AcSAPindication *aci = &acis;
        register struct AcSAPabort *aca = &aci -> aci_abort;
	int	result;
	struct intf *ap;

	TRACE (2, ("retry request on %s", paddr (&peer->src)));
	ap = &addrs[peer->sock];

	switch (result = AcAsynRetryRequest (ap -> fd, acc, aci)) {
	    case CONNECTING_1:
	    case CONNECTING_2:
		return result;
	    case NOTOK:
		acs_advise (aca, "A-ASSOCIATE.REQUEST");
		ap -> flags = 0;
		return NOTOK;

	    case DONE:
		if (acc -> acc_result != ACS_ACCEPT)
			return handle_reject (acc, ap);
		return check_accept (acc, ap, peer);

	    default:
		advise (LLOG_EXCEPTIONS, NULLCP,
			"Bad response from retry %d", result);
		terminate (ap, roi);
		break;
	}
	return NOTOK;
}

static int handle_reject (acc, ap)
struct AcSAPconnect *acc;
struct intf *ap;
{
	if (acc -> acc_ninfo > 0) {
		struct type_NTP_BindError *binderr;
		char	*cp = NULLCP;

		PLOG (pgm_log, print_NTP_BindError, acc -> acc_info[0],
		      "NTP.BindError", 1);
		if (decode_NTP_BindError (acc -> acc_info[0], 1,
					  NULLIP, NULLVP,
					  &binderr) != NOTOK) {
			if (binderr -> supplementary)
				cp = qb2str (binderr -> supplementary);
			switch (binderr -> reason) {
			    case int_NTP_reason_refused:
				advise (LLOG_EXCEPTIONS,
					"connection refused: %s",
					cp ? cp : "");
				break;
			    case int_NTP_reason_validation:
				advise (LLOG_EXCEPTIONS,
					"validation failure: %s",
					cp ? cp : "");
				break;
			    case int_NTP_reason_version:
				advise (LLOG_EXCEPTIONS,
					"version mismatch: %s",
					cp ? cp : "");
				break;
			    case int_NTP_reason_badarg:
				advise (LLOG_EXCEPTIONS,
					"bad connect argument: %s",
					cp ? cp : "");
				break;
			    case int_NTP_reason_congested:
				advise (LLOG_EXCEPTIONS,
					"congested: %s",
					cp ? cp : "");
				break;
			    default:
				advise (LLOG_EXCEPTIONS, NULLCP,
					"Unknown reason (%d) %s",
					binderr -> reason,
					cp ? cp : "");
				break;
			}
			free_NTP_BindError (binderr);
		}
		else
			advise (LLOG_EXCEPTIONS, NULLCP,
				"decode bind error failed [%s]", PY_pepy);
	}
	else
		advise (LLOG_EXCEPTIONS, NULLCP,
			"Connection failed: %s",
			AcErrString (acc -> acc_result));
	ACCFREE (acc);
	ap -> flags = 0;
	return 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_EXCEPTIONS, NULLCP, "%s: %s", event, buffer);
}

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_EXCEPTIONS, NULLCP, "%s: %s (source %d)", event, buffer,
                aca -> aca_source);
}

static double
ul2_fixed_to_double(t)
struct type_NTP_TimeStamp *t;
{
	double a, b;
#ifdef	GENERIC_UNS_BUG
	register int i;

	i = t->fraction;
	a = (long)((i >> 1) & 0x7fffffff);
	a *= 2.0;
	if (i & 1)
		a += 1.0;
	a = a / (4.294967296e9);	/* shift dec point over by 32 bits */
	i = t->integer;
	b = (long)((i >> 1) & 0x7fffffff);
	b *= 2.0;
	if (i & 1)
		b += 1.0;
#else	/* GENERIC_UNS_BUG */
	a = (unsigned long) t->fraction;
#ifdef	VAX_COMPILER_FLT_BUG
	if (a < 0.0) a += 4.294967296e9;
#endif
	a = a / (4.294967296e9);/* shift dec point over by 32 bits */
	b = (unsigned long) t->integer;
#ifdef	VAX_COMPILER_FLT_BUG
	if (b < 0.0) b += 4.294967296e9;
#endif
#endif	/* GENERIC_UNS_BUG */
	return (a + b);
}

static double
ul_fixed_to_doublep(t)
	struct l_fixedpt *t;
{
	double a, b;
#ifdef	GENERIC_UNS_BUG
	register int i;

	i = t->fraction;
	a = (long)((i >> 1) & 0x7fffffff);
	a *= 2.0;
	if (i & 1)
		a += 1.0;
	a = a / (4.294967296e9);	/* shift dec point over by 32 bits */
	i = t->int_part;
	b = (long)((i >> 1) & 0x7fffffff);
	b *= 2.0;
	if (i & 1)
		b += 1.0;
#else	/* GENERIC_UNS_BUG */
	a = (unsigned long) t->fraction;
#ifdef	VAX_COMPILER_FLT_BUG
	if (a < 0.0) a += 4.294967296e9;
#endif
	a = a / (4.294967296e9);/* shift dec point over by 32 bits */
	b = (unsigned long) t->int_part;
#ifdef	VAX_COMPILER_FLT_BUG
	if (b < 0.0) b += 4.294967296e9;
#endif
#endif	/* GENERIC_UNS_BUG */
	return (a + b);
}

#ifdef	SUN_FLT_BUG
static void
tstamp_osi (stampp, tvp)
struct l_fixedpt *stampp;
struct timeval *tvp;
{
	int tt;
	double dd;

	stampp->int_part = JAN_1970 + tvp->tv_sec;
	dd = (float) tvp->tv_usec / 1000000.0;
	tt = dd * 2147483648.0;
	stampp->fraction = tt << 1;
}
#else
static void
tstamp_osi (stampp, tvp)
	struct l_fixedpt *stampp;
	struct timeval *tvp;
{
	stampp->int_part = JAN_1970 + tvp->tv_sec;
	stampp->fraction = (float) tvp->tv_usec * 4294.967295;
}
#endif

struct type_NTP_ClockIdentifier *cli_refid (refid)
Refid refid;
{
	struct type_NTP_ClockIdentifier *rid;
	char	*cp;

	rid = (struct type_NTP_ClockIdentifier *) malloc (sizeof *rid);

	switch (refid.rid_type) {
	    case 0:
		free ((char *)rid);
		return NULL;

	    case RID_STRING:
		rid -> offset = type_NTP_ClockIdentifier_referenceClock;
		rid -> un.referenceClock = str2qb (refid.rid_string,
						   strlen(refid.rid_string),
						   1);
		break;
	    case RID_INET:
		rid -> offset = type_NTP_ClockIdentifier_inetaddr;
		cp = ntoa((struct sockaddr_in *)&refid.rid_inet);
		rid -> un.inetaddr = str2qb(cp, strlen(cp), 1);
		break;
	    case RID_PSAP:
		rid -> offset = type_NTP_ClockIdentifier_psapaddr;
		cp = paddr2str (&refid.rid_psap, NULLNA);
		rid -> un.inetaddr = str2qb (cp, strlen (cp), 1);
		break;
	}
	return rid;
}


struct type_NTP_ClockInfo *peer2clock (peer)
struct ntp_peer *peer;
{
	struct type_NTP_ClockInfo *ci;
	char	*cp;

	ci = (struct type_NTP_ClockInfo *) calloc (1, sizeof *ci);

	if (peer -> sock < 0)
		cp = "none";
	else
		cp = paddr (&addrs[peer->sock].addr);
	ci -> localAddress = str2qb (cp, strlen (cp), 1);

	cp = paddr (&peer -> src);
	ci -> remoteAddress = str2qb (cp, strlen (cp), 1);
	ci -> flags = pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_BITS);
#define setflbit(x,y) if (peer -> flags & (x)) (void) bit_on (ci -> flags, (y))
	setflbit (PEER_FL_CONFIG, bit_NTP_flags_configured);
	setflbit (PEER_FL_AUTHENABLE, bit_NTP_flags_authentable);
	setflbit (PEER_FL_SANE, bit_NTP_flags_sane);
	setflbit (PEER_FL_CANDIDATE, bit_NTP_flags_candidate);
	setflbit (PEER_FL_SYNC, bit_NTP_flags_sync);
	setflbit (PEER_FL_BCAST, bit_NTP_flags_broadcast);
	setflbit (PEER_FL_REFCLOCK, bit_NTP_flags_referenceClock);
	setflbit (PEER_FL_SELECTED, bit_NTP_flags_selected);
	setflbit (PEER_FL_SNOOZE, bit_NTP_flags_inactive);
	if (sys.peer == peer)
		(void) bit_on (ci -> flags, bit_NTP_flags_selected);
#undef setflbit
	ci -> packetsSent = peer -> pkt_sent;
	ci -> packetsReceived = peer -> pkt_rcvd;
	ci -> packetsDropped = peer -> pkt_dropped;
	ci -> timer = peer -> timer;
	ci -> leap = (struct type_NTP_Leap *) calloc (1, sizeof *ci -> leap);
	ci -> leap -> parm = peer -> leap;
	ci -> stratum = peer -> stratum;
	ci -> ppoll = peer -> ppoll;
	ci -> hpoll = peer -> hpoll;
	ci -> precision = peer -> precision;
	ci -> reachability = peer -> reach & NTP_WINDOW_SHIFT_MASK;
	ci -> estdisp = peer -> estdisp * 1000.0;
	ci -> estdelay = peer -> estdelay * 1000.0;
	ci -> estoffset = peer -> estoffset * 1000.0;
	ci -> reference = cli_refid (peer -> refid);
	ci -> reftime = sstamp (&peer -> reftime);
	ci -> filters = NULL;
	return ci;
}

/* ARGSUSED */
int query_func (sd, ryo, rox, in, roi)
int     sd;
struct RyOperation *ryo;
struct RoSAPinvoke *rox;
caddr_t in;
struct RoSAPindication *roi;
{
	struct type_NTP_ClockInfoList *clbase, *cl;
	struct ntp_peer *peer;

	clbase = cl = NULL;
	for (peer = peer_list.head; peer != NULL; peer = peer -> next) {
		if (clbase == NULL)
			clbase = cl = (struct type_NTP_ClockInfoList *)
				calloc (1, sizeof *cl);
		else {
			cl -> next = (struct type_NTP_ClockInfoList *)
				calloc (1, sizeof *cl);
			cl = cl -> next;
		}

		cl -> ClockInfo = peer2clock (peer);
	}
	if (RyDsResult (sd, rox -> rox_id, (caddr_t) clbase,
			ROS_NOPRIO, roi) == NOTOK)
		ros_advise (&roi -> roi_preject, "RyDsResult failed");
	free_NTP_ClockInfoList (clbase);
	return OK;
}