DataMuseum.dk

Presents historical artifacts from the history of:

DKUUG/EUUG Conference tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about DKUUG/EUUG Conference tapes

Excavated with: AutoArchaeologist - Free & Open Source Software. 

top - metrics - download
Index: T a

⟦8aef12563⟧ TextFile

    Length: 8854 (0x2296)
    Types: TextFile
    Names: »ad_parse.c«

Derivation

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

TextFile

/* ad_parse.c: parse and address */

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

/*
 * $Header: /cs/research/pp/hubris/pp-beta/Lib/parse/RCS/ad_parse.c,v 5.0 90/09/20 16:09:27 pp Exp Locker: pp $
 *
 * $Log:	ad_parse.c,v $
 * Revision 5.0  90/09/20  16:09:27  pp
 * rcsforce : 5.0 public release
 * 
 */



#include "util.h"
#include <varargs.h>
#include "retcode.h"
#include "adr.h"
#include "ap.h"
#include "or.h"

extern  char            or_error[];
static int parselose_exception ();

static int		rfc822thenx400(), x400thenrfc822(), ad_parse_aux();
#define MAX_LOOP	10

/* ---------------------  Begin  Routines  -------------------------------- */

int ad_fullparse (ad, rp, order_pref)
register ADDR	*ad;
RP_Buf		*rp;
int		order_pref;
{
	return ad_parse_aux (ad, rp, order_pref, OK);
}

int ad_parse (ad, rp, order_pref)
register ADDR	*ad;
RP_Buf		*rp;
int		order_pref;
{
	return ad_parse_aux (ad, rp, order_pref, NOTOK);
}

static int ad_parse_aux (ad, rp, order_pref, full)
register ADDR           *ad;
RP_Buf  *rp;
int     order_pref;
int	full;
{
	PP_DBG (("ad_parse ('%s', '%d')", ad->ad_value, ad->ad_type));
	or_myinit();
	switch (ad -> ad_type) {
	case AD_X400_TYPE:
		return x400thenrfc822(ad,rp, order_pref, full);
	default:
		PP_TRACE(("Unknown address type '%d' will try as rfc822", 
			ad->ad_type));
	case AD_822_TYPE:
		return rfc822thenx400(ad,rp,order_pref, full);
	}
}



/* \f

 */

static int rfc822thenx400(ad, rp, order_pref, full)
register ADDR	*ad;
RP_Buf		*rp;
int		order_pref;
int		full;
{
	AP_ptr	group,
	name,
	local,
	domain,
	route;
	int	retval;
	char	*first_error = NULLCP, *second_error = NULLCP;
	int	cont = TRUE, count = 0;
	OR_ptr	or;
	char	tmp[BUFSIZ];
	ADDR	*newadr;
	char	*first822 = NULLCP;
	char	*first400 = NULLCP;

	PP_DBG (("rfc822thenx400 ('%s', '%d')", ad->ad_value, ad->ad_type));

	/* parse 822 */
	if (rp_isbad (retval = 
		      rfc822_parse (ad, order_pref, full, 
				    &group, &name,
				    &local, &domain, &route)))
		return parselose_exception(rp, retval, ad->ad_parse_message);

	do {
		/* validate 822 */
		retval = rfc822_validate(group, name, local, domain, route, 
					 ad, order_pref, full, rp);

		/* convert 822 to x400 */
		or_error[0] = '\0';
		if (rp_isbad (rfc822_x400(ad, &or))) {
			if (first400 != NULLCP) {
				if (ad->ad_r400adr != NULLCP) 
					free(ad->ad_r400adr);
				ad->ad_r400adr = first400;
			}
			if (first822 != NULLCP) {
				if (ad->ad_r822adr != NULLCP)
					free(ad->ad_r822adr);
				ad->ad_r822adr = first822;
			}
			return parselose_exception(rp, retval, ad->ad_parse_message);
		}	
		/* 822 is okay */
		if (!rp_isbad (retval)) {
			if (first822) free(first822);
			if (first400) free(first400);
			return RP_AOK;
		}
		if (first_error == NULLCP) {
			first_error = ad->ad_parse_message;
			ad->ad_parse_message = NULLCP;
		}
		or_error[0] = '\0';
	
		/* validate x400 */
		retval = x400_validate(ad, or, rp);

		if (!rp_isbad(retval)) {
			ad->ad_type = AD_X400_TYPE;
			if (first822) free(first822);
			if (first400) free(first400);
			return RP_AOK;
		}
	
		if (second_error == NULLCP) {
			second_error = ad->ad_parse_message;
			ad->ad_parse_message = NULLCP;
		}

		if (first822 == NULLCP)
			first822 = strdup(ad->ad_r822adr);
		if (first400 == NULLCP)
			first400 = strdup(ad->ad_r400adr);

		newadr = adr_new(ad->ad_r400adr,
				 AD_X400_TYPE,
				 ad->ad_no);
		newadr->ad_r400adr = strdup(ad->ad_r400adr);
		
		if (rp_isbad(x400_rfc822 (newadr, or, order_pref, full,
					  &group, &name, &local,
					  &domain, &route))
		    || newadr->ad_r822adr == NULLCP
		    || lexequ(newadr->ad_r822adr, ad->ad_r822adr) == 0
		    || lexequ(newadr->ad_r822adr, ad->ad_value) == 0)
			cont = FALSE;
		else {
			count++;
			if (ad->ad_r822adr) free(ad->ad_r822adr);
			ad->ad_r822adr = strdup(newadr->ad_r822adr);
		}
		adr_free(newadr);
	} while (count < MAX_LOOP && cont == TRUE);

	if (first_error) {
		if (!second_error || strcmp(first_error, second_error) == 0)
			(void) sprintf (tmp, "%s", first_error);
		else
			(void) sprintf (tmp, "%s (%s)", 
					first_error, second_error);
	} else if (second_error)
		(void) sprintf(tmp, "%s", second_error);
	else
		/* oops no error */
		(void) sprintf(tmp, "no error message given ???");

	if (first_error) free(first_error);
	if (second_error) free(second_error);
	if (ad->ad_parse_message) free (ad->ad_parse_message);
	ad->ad_parse_message = strdup(tmp);
	/* reset back to first parse attempts */
	if (first400 != NULLCP) {
		if (ad->ad_r400adr != NULLCP) 
			free(ad->ad_r400adr);
		ad->ad_r400adr = first400;
	}
	if (first822 != NULLCP) {
		if (ad->ad_r822adr != NULLCP)
			free(ad->ad_r822adr);
		ad->ad_r822adr = first822;
	}
	return parselose_exception(rp, retval, ad->ad_parse_message);
}

/* \f

 */

static int x400thenrfc822(ad, rp, order_pref, full)
register ADDR	*ad;
RP_Buf		*rp;
int		order_pref;
int		full;
{
	OR_ptr	or;
	int	retval;
	char	tmp[BUFSIZ];
	AP_ptr	group,
		name,
		local,
		domain,
		route;
	char	*first_error = NULLCP, *second_error = NULLCP;
	int	count = 0,
		cont = TRUE;
	ADDR	*newadr;
	char	*first822 = NULLCP;
	char	*first400 = NULLCP;

	PP_DBG (("x400thenrfc822 ('%s', '%d')", ad->ad_value, ad->ad_type));
	
	/* parse x400 */
	or_error[0] = '\0';
	if (rp_isbad(retval = x400_parse(ad, &or)))
		return parselose_exception(rp, retval, ad->ad_parse_message);

	do {
		/* validate x400 */
		or_error[0] = '\0';
		retval = x400_validate(ad, or, rp);

		/* convert x400 to rfc */
		if (rp_isbad (x400_rfc822(ad, or, order_pref, full,
					  &group, &name, &local, &domain, &route))) {
			/* reset back to first parse attempts */
			if (first400 != NULLCP) {
				if (ad->ad_r400adr != NULLCP) 
					free(ad->ad_r400adr);
				ad->ad_r400adr = first400;
			}
			if (first822 != NULLCP) {
				if (ad->ad_r822adr != NULLCP)
					free(ad->ad_r822adr);
				ad->ad_r822adr = first822;
			}
			/* can't convert */
			return parselose_exception(rp, retval, ad->ad_parse_message);
		}
		/* x400 is okay */
		if (!rp_isbad(retval)) {
			if (first822) free(first822);
			if (first400) free(first400);
			return RP_AOK;
		}
		if (first_error == NULLCP) {
			first_error = ad->ad_parse_message;
			ad->ad_parse_message = NULLCP;
		}
		
		/* validate 822 */
		retval = rfc822_validate (group, name, local, domain, route,
					  ad, order_pref, full, rp);
		
		/* 822 is okay */
		if (!rp_isbad(retval)) {
			if (first822) free(first822);
			if (first400) free(first400);
			return RP_AOK;
		}
		
		if (second_error == NULLCP) {
			second_error = ad->ad_parse_message;
			ad->ad_parse_message = NULLCP;
		}
		
		if (first822 == NULLCP)
			first822 = strdup(ad->ad_r822adr);
		if (first400 == NULLCP)
			first400 = strdup(ad->ad_r400adr);

		newadr = adr_new(ad->ad_r822adr, 
				 AD_822_TYPE,
				 ad->ad_no);
		newadr->ad_r822adr = strdup(ad->ad_r822adr);

		or_error[0] = '\0';
		if (rp_isbad (rfc822_x400(newadr, &or))
		    || newadr->ad_r400adr == NULLCP
		    || lexequ(newadr->ad_r400adr, ad->ad_r400adr) == 0
		    || lexequ(newadr->ad_r400adr, ad->ad_value) == 0)
			cont = FALSE;
		else {
			count++;
			if (ad->ad_r400adr != NULLCP) free(ad->ad_r400adr);
			ad->ad_r400adr = strdup(newadr->ad_r400adr);
		}
		adr_free(newadr);
		
	} while (count < MAX_LOOP && cont == TRUE);
			
	if (strcmp(first_error, second_error) == 0)
		(void) sprintf(tmp, "%s", first_error);
	else
		(void) sprintf(tmp, "%s (%s)", 
			       first_error, second_error);

	if (first_error) free(first_error);
	if (second_error) free(second_error);
	if (ad->ad_parse_message) free (ad->ad_parse_message);
	ad->ad_parse_message = strdup(tmp);
	/* reset back to first parse attempts */
	if (first400 != NULLCP) {
		if (ad->ad_r400adr != NULLCP) 
			free(ad->ad_r400adr);
		ad->ad_r400adr = first400;
	}
	if (first822 != NULLCP) {
		if (ad->ad_r822adr != NULLCP)
			free(ad->ad_r822adr);
		ad->ad_r822adr = first822;
	}
	return parselose_exception(rp, retval, ad->ad_parse_message);
}
		
static int parselose_exception (rp, val, str)
RP_Buf  *rp;
int     val;
char    *str;
{
	PP_LOG (LLOG_EXCEPTIONS, 
		("parselose (%s, '%s')", rp_valstr (val), str));

	rp -> rp_val = val;
	(void) strncpy (rp -> rp_line, str, sizeof (rp -> rp_line) - 1);

	return val;
}

	
#ifdef lint
/* VARARGS3 */
int parselose (rp, val, str)
RP_Buf  *rp;
int     val;
char    *str;
{
	return parselose (rp, val, str);
}
#else
int parselose (va_alist)
va_dcl
{
	va_list ap;
	RP_Buf  *rp;
	int     val;
	char    buf[BUFSIZ];

	va_start (ap);

	rp = va_arg (ap, RP_Buf *);
	val = va_arg (ap, int);

	_asprintf (buf, NULLCP, ap);

	PP_LOG (LLOG_TRACE, 
		("parselose (%s, '%s')", rp_valstr (val), buf));

	rp -> rp_val = val;
	(void) strncpy (rp -> rp_line, buf, sizeof (rp -> rp_line) - 1);

	va_end (ap);

	return val;
}
#endif