nrs_info.c

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

int			  format;
{
	struct nrs_routes	* rt;

	for (rt=routes; rt != (struct nrs_routes *)NULL; rt = rt->next)
	{
		if (format == READOUT)
			ps_printf (ps, "\n---> ");

		if (rt->cost)
			pe_print (ps, rt->cost, format);

		ps_printf (ps, "#");

		if (rt->addr_info)
			addr_info_print (ps, rt->addr_info, format);

		if (rt->next != (struct nrs_routes *)NULL)
			ps_printf (ps, "|");
	}
}

static struct nrs_routes	* str2nrs_routes (orig)
char * orig;
{
	struct nrs_routes	* result;
	struct nrs_routes	**rt;
	char			* copy;
	char			* ptr_prev;
	char			* ptr_next;
	char			* ptr_mid;

	result = (struct nrs_routes *) smalloc (sizeof (struct nrs_routes));

	ptr_prev = SkipSpace(orig);

	if ((ptr_prev == NULLCP) || ((*ptr_prev) == '\0'))
	{
		return ((struct nrs_routes *)NULL);
	}

	rt = &(result);

	while ( (ptr_next=index (ptr_prev, '|')) != NULLCP)
	{
		*ptr_next = '\0';
		ptr_next++;
		(*rt) = (struct nrs_routes *) smalloc (sizeof (struct nrs_routes));

		copy = strdup (ptr_prev);

		if ( (ptr_mid=index (ptr_prev, '#')) == NULLCP)
		{
			parse_error ("separator(#) missing in nrs_route '%s'", copy);
			free (copy);
			free ((char *) result);
			return ((struct nrs_routes *) NULL);
		}
		*ptr_mid = '\0';
		ptr_mid++;

		/*
		* route-cost is not optional - use encoding of NULL
		* when this element is absent
		*/
		if ((*ptr_prev) == '\0')
		{
			(*rt)->cost = pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_NULL);
		}
		else if (((*rt)->cost = asnstr2pe (ptr_prev)) == NULLPE)
		{
			parse_error ("route-cost ASN malformed in nrs_route '%s'", copy);
			free (copy);
			free ((char *) result);
			return ((struct nrs_routes *) NULL);
		}

		ptr_prev = SkipSpace (ptr_mid);

		(*rt)->addr_info = str2addr_info (ptr_prev);

		rt = &((*rt)->next);
		ptr_prev = SkipSpace(ptr_next);
	}

	(*rt) = (struct nrs_routes *) smalloc (sizeof (struct nrs_routes));

	copy = strdup (ptr_prev);

	if ( (ptr_mid=index (ptr_prev, '#')) == NULLCP)
	{
		parse_error ("separator(#) missing in nrs_route '%s'", copy);
		free (copy);
		free ((char *) result);
		return ((struct nrs_routes *) NULL);
	}
	*ptr_mid = '\0';
	ptr_mid++;

	/*
	* route-cost is not optional - use encoding of NULL
	* when this element is absent
	*/
	if ((ptr_prev == NULLCP) || ((*ptr_prev) == '\0'))
	{
		(*rt)->cost = pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_NULL);
	}
	else if (((*rt)->cost = asnstr2pe (ptr_prev)) == NULLPE)
	{
		parse_error ("route-cost ASN malformed in nrs_route '%s'", copy);
		free (copy);
		free ((char *) result);
		return ((struct nrs_routes *) NULL);
	}

	ptr_prev = SkipSpace (ptr_mid);

	(*rt)->addr_info = str2addr_info (ptr_prev);

	(*rt)->next = (struct nrs_routes *)NULL;

	return (result);
}

static nrs_info_free (arg)
struct nrs_info * arg;
{
	if (arg == (struct nrs_info *)NULL)
		return;

	if (arg->routes)
		nrs_routes_free (arg->routes);

	free ((char *) arg);
}

static struct nrs_info * nrs_info_cpy (arg)
struct nrs_info * arg;
{
	struct nrs_info * result;

	if (arg == (struct nrs_info *)NULL)
                return ((struct nrs_info *)NULL);

	result = (struct nrs_info *) smalloc (sizeof (struct nrs_info));

	result->context = arg->context;

	result->addr_sp_id = arg->addr_sp_id;

	result->routes = nrs_routes_cpy (arg->routes);

	return (result);
}

static nrs_info_cmp (arg1, arg2)
struct nrs_info * arg1;
struct nrs_info * arg2;
{
	if (arg1 == (struct nrs_info *) NULL)
		if (arg2 == (struct nrs_info *) NULL)
			return (0);
		else 
			return (-1);

	if (arg2 == (struct nrs_info *) NULL)
		return (1);

	if (arg1->context < arg2->context)
		return (-1);

	if (arg1->context > arg2->context)
		return (1);

	if (arg1->addr_sp_id < arg2->addr_sp_id)
		return (-1);

	if (arg1->addr_sp_id > arg2->addr_sp_id)
		return (1);

	return (nrs_routes_cmp (arg1->routes, arg2->routes));
}

static context_print (ps, ctx, format)
register PS	  ps;
int		  ctx;
int		  format;
{
	if (format != READOUT)
	{
		ps_printf (ps, "%d", ctx);
		return;
	}

	switch(ctx)
	{
	case NRS_Context_X29:
		ps_printf (ps, "x29");
		break;
	case NRS_Context_TS29:
		ps_printf (ps, "ts29");
		break;
	case NRS_Context_NIFTP:
		ps_printf (ps, "niftp");
		break;
	case NRS_Context_MAIL_NIFTP:
		ps_printf (ps, "mail-niftp");
		break;
	case NRS_Context_MAIL_TELEX:
		ps_printf (ps, "mail-telex");
		break;
	case NRS_Context_JTMP:
		ps_printf (ps, "jtmp");
		break;
	case NRS_Context_JTMP_FILES:
		ps_printf (ps, "jtmp-files");
		break;
	case NRS_Context_JTMP_REG:
		ps_printf (ps, "jtmp-reg");
		break;
	case NRS_Context_YBTS_NODE:
		ps_printf (ps, "ybts-node");
		break;
	case NRS_Context_YBTS:
		ps_printf (ps, "ybts");
		break;
	case NRS_Context_FTAM:
		ps_printf (ps, "ftam");
		break;
	case NRS_Context_JTM:
		ps_printf (ps, "jtm");
		break;
	case NRS_Context_JTM_REG:
		ps_printf (ps, "jtm-reg");
		break;
	case NRS_Context_VT:
		ps_printf (ps, "vt");
		break;
	case NRS_Context_MOTIS:
		ps_printf (ps, "motis");
		break;
	default:
		ps_printf (ps, "%d", ctx);
		break;
	}
}

static addr_sp_id_print (ps, asi, format)
register PS	  ps;
int		  asi;
int		  format;
{
	if (format != READOUT)
	{
		ps_printf (ps, "%d", asi);
		return;
	}

	switch(asi)
	{
	case NRS_Address_Space_Id_PSS:
		ps_printf (ps, "pss");
		break;
	case NRS_Address_Space_Id_JANET:
		ps_printf (ps, "janet");
		break;
	case NRS_Address_Space_Id_TELEX:
		ps_printf (ps, "telex");
		break;
	case NRS_Address_Space_Id_OSI_CONS:
		ps_printf (ps, "osi-cons");
		break;
	default:
		ps_printf (ps, "%d", asi);
		break;
	}
}

static nrs_info_print (ps, nrs, format)
register PS	  ps;
struct nrs_info	* nrs;
int		  format;
{
	context_print (ps, nrs->context, format);

	ps_printf (ps, "$");

	addr_sp_id_print (ps, nrs->addr_sp_id, format);

	ps_printf (ps, "$");

	if (nrs->routes)
		nrs_routes_print (ps, nrs->routes, format);
}

static str2context (orig)
char	* orig;
{
	char	* str;
	char	* cc;
	int	  its_all_digits;

	str = SkipSpace(orig);
	its_all_digits = 1;

	if ((str == NULLCP) || ((*str) == '\0'))
	{
		parse_error ("no context string", NULLCP);
		return(-1);
	}

	/* Check for numeric-ness and strip trailing spaces */
	for (cc=str; (*cc)!='\0'; cc++)
	{
		if (isspace(*cc))
		{
			(*cc) = '\0';
			cc++;
			break;
		}

		if (!isdigit(*cc))
		{
			its_all_digits = 0;
		}
	}

	while (isspace(*cc))
		cc++;
	if ((*cc) != '\0')
	{
		parse_error ("malformed context string", NULLCP);
		return(-1);
	}

	if (its_all_digits)
	{
		return(atoi(str));
	}
	else if (strcmp (str, "x29") == 0)
	{
		return (NRS_Context_X29);
	}
	else if (strcmp (str, "ts29") == 0)
	{
		return (NRS_Context_TS29);
	}
	else if (strcmp (str, "niftp") == 0)
	{
		return (NRS_Context_NIFTP);
	}
	else if (strcmp (str, "mail-niftp") == 0)
	{
		return (NRS_Context_MAIL_NIFTP);
	}
	else if (strcmp (str, "mail-telex") == 0)
	{
		return (NRS_Context_MAIL_TELEX);
	}
	else if (strcmp (str, "jtmp") == 0)
	{
		return (NRS_Context_JTMP);
	}
	else if (strcmp (str, "jtmp-files") == 0)
	{
		return (NRS_Context_JTMP_FILES);
	}
	else if (strcmp (str, "jtmp-reg") == 0)
	{
		return (NRS_Context_JTMP_REG);
	}
	else if (strcmp (str, "ybts-node") == 0)
	{
		return (NRS_Context_YBTS_NODE);
	}
	else if (strcmp (str, "ybts") == 0)
	{
		return (NRS_Context_YBTS);
	}
	else if (strcmp (str, "ftam") == 0)
	{
		return (NRS_Context_FTAM);
	}
	else if (strcmp (str, "jtm") == 0)
	{
		return (NRS_Context_JTM);
	}
	else if (strcmp (str, "jtm-reg") == 0)
	{
		return (NRS_Context_JTM_REG);
	}
	else if (strcmp (str, "vt") == 0)
	{
		return (NRS_Context_VT);
	}
	else if (strcmp (str, "motis") == 0)
	{
		return (NRS_Context_MOTIS);
	}
	else
	{
		parse_error ("unknown context string '%s'", str);
		return (-1);
	}
}

static str2addr_sp_id (orig)
char	* orig;
{
	char	* str;
	char	* cc;
	int	  its_all_digits;

	str = SkipSpace(orig);
	its_all_digits = 1;

	if ((str == NULLCP) || ((*str) == '\0'))
	{
		parse_error ("no address space string", NULLCP);
		return(-1);
	}

	/* Check for numeric-ness and strip trailing spaces */
	for (cc=str; (*cc)!='\0'; cc++)
	{
		if (isspace(*cc))
		{
			(*cc) = '\0';
			cc++;
			break;
		}

		if (!isdigit(*cc))
		{
			its_all_digits = 0;
		}
	}

	while (isspace(*cc))
		cc++;
	if ((*cc) != '\0')
	{
		parse_error ("malformed address space string", NULLCP);
		return(-1);
	}

	if (its_all_digits)
	{
		return(atoi(str));
	}
	else if (strcmp (str, "pss") == 0)
	{
		return(NRS_Address_Space_Id_PSS);
	}
	else if (strcmp (str, "janet") == 0)
	{
		return(NRS_Address_Space_Id_JANET);
	}
	else if (strcmp (str, "telex") == 0)
	{
		return(NRS_Address_Space_Id_TELEX);
	}
	else if (strcmp (str, "osi-cons") == 0)
	{
		return(NRS_Address_Space_Id_OSI_CONS);
	}
	else
	{
		parse_error ("unknown address space string '%s'", str);
		return (-1);
	}
}

static struct nrs_info	* str2nrs_info (orig)
char * orig;
{
	struct nrs_info	* result;
	char		* copy;
	char		* ptr_prev;
	char		* ptr_next;

	result = (struct nrs_info *) smalloc (sizeof (struct nrs_info));

	copy = strdup (orig);
	ptr_prev = copy;

	if ( (ptr_next=index (ptr_prev, '$')) == NULLCP)
	{
		parse_error ("first separator($) missing in nrs_info '%s'", orig);
		free (copy);
		free ((char *) result);
		return ((struct nrs_info *) NULL);
	}
	*ptr_next = '\0';
	ptr_next++;

	if ((result->context = str2context (ptr_prev)) == -1)
	{
		parse_error ("malformed context '%s'", orig);
		free (copy);
		free ((char *) result);
		return ((struct nrs_info *) NULL);
	}

	ptr_prev = ptr_next;

	if ( (ptr_next=index (ptr_prev, '$')) == NULLCP)
	{
		parse_error ("second separator($) missing in nrs_info '%s'", orig);
		free (copy);
		free ((char *) result);
		return ((struct nrs_info *) NULL);
	}
	*ptr_next = '\0';
	ptr_next++;

	if ((result->addr_sp_id = str2addr_sp_id (ptr_prev)) == -1)
	{
		parse_error ("malformed context '%s'", orig);
		free (copy);
		free ((char *) result);
		return ((struct nrs_info *) NULL);
	}

	if (((ptr_prev = SkipSpace (ptr_next)) == NULLCP) || ((*ptr_prev) == '\0'))
	{
		result->routes = ((struct nrs_routes *)NULL);
		return (result);
	}

	if ((result->routes = str2nrs_routes (ptr_prev)) == (struct nrs_routes *)NULL)
	{
		parse_error ("unparseable routes in nrs_info '%s'", orig);
		free (copy);
		free ((char *) result);
		return ((struct nrs_info *) NULL);
	}

	return (result);
}

static PE nrs_info_enc (nrs)
struct nrs_info * nrs;
{
PE ret_pe;

        if (encode_NRS_NRSInformation (&ret_pe, 1, 0, NULLCP, nrs) != OK)
		return (NULLPE);

	return (ret_pe);
}

static struct nrs_info * nrs_info_dec (pe)
PE pe;
{
	struct nrs_info	* nrs;

	if (decode_NRS_NRSInformation (pe, 1, NULLIP, NULLVP, &nrs) != OK)
	{
		return ((struct nrs_info *) NULL);
	}

	return (nrs);
}

nrs_info_syntax ()
{
	(void) add_attribute_syntax ("NRSInformation",
		(IFP) nrs_info_enc,	(IFP) nrs_info_dec,
		(IFP) str2nrs_info,	nrs_info_print,
		(IFP) nrs_info_cpy,	nrs_info_cmp,
		nrs_info_free,		NULLCP,
		NULLIFP,		TRUE);
}