Start development on 386BSD 0.0

[unix-history] / .ref-BSD-4_3_Net_2 / usr / src / contrib / isode / ftam / ftamfaduid.c

/* ftamfaduid.c - FPM: encode/decode FADU identities */

#ifndef	lint
static char *rcsid = "$Header: /f/osi/ftam/RCS/ftamfaduid.c,v 7.1 91/02/22 09:22:51 mrose Interim $";
#endif

/* 
 * $Header: /f/osi/ftam/RCS/ftamfaduid.c,v 7.1 91/02/22 09:22:51 mrose Interim $
 *
 *
 * $Log:	ftamfaduid.c,v $
 * Revision 7.1  91/02/22  09:22:51  mrose
 * Interim 6.8
 * 
 * Revision 7.0  89/11/23  21:53:36  mrose
 * Release 6.0
 * 
 */

/*
 *				  NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


/* LINTLIBRARY */

#include <stdio.h>
#include "fpkt.h"

/* \f */

struct type_FTAM_FADU__Identity *faduid2fpm (fsb, fa, fti)
register struct ftamblk *fsb;
register struct FADUidentity *fa;
struct FTAMindication *fti;
{
    register int    n;
    register char **ap;
    register struct type_FTAM_FADU__Identity *fpm;
    register struct name_element **f4;

    if ((fpm = (struct type_FTAM_FADU__Identity *) calloc (1, sizeof *fpm))
	    == NULL) {
no_mem: ;
	(void) ftamlose (fti, FS_GEN (fsb), 1, NULLCP, "out of memory");
out: ;
	if (fpm)
	    free_FTAM_FADU__Identity (fpm);
	return NULL;
    }

    switch (fa -> fa_type) {
	case FA_FIRSTLAST:
	    fpm -> offset = type_FTAM_FADU__Identity_first__last;
	    switch (fa -> fa_firstlast) {
		case FA_FIRST:
		case FA_LAST:
		    break;

		default:
bad_value:;
		    (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
				     "bad value in FADU identity");
		    goto out;
	    }
	    fpm -> un.first__last = fa -> fa_firstlast;
	    break;

	case FA_RELATIVE:
	    fpm -> offset = type_FTAM_FADU__Identity_relative;
	    switch (fa -> fa_relative) {
		case FA_PREVIOUS:
		case FA_CURRENT:
		case FA_NEXT:
		    break;

		default:
		    goto bad_value;
	    }
	    fpm -> un.relative = fa -> fa_relative;
	    break;

	case FA_BEGINEND:
	    fpm -> offset = type_FTAM_FADU__Identity_begin__end;
	    switch (fa -> fa_beginend) {
		case FA_BEGIN:
		case FA_END:
		    break;

		default:
		    goto out;
	    }
	    fpm -> un.begin__end = fa -> fa_beginend;
	    break;

	case FA_SINGLE:
	    if (!fa -> fa_singlename)
		goto bad_value;
	    fpm -> offset = type_FTAM_FADU__Identity_single__name;
	    if ((fpm -> un.single__name =
			str2qb (fa -> fa_singlename,
				strlen (fa -> fa_singlename),
				1)) == NULL)
		goto no_mem;
	    break;

	case FA_NAMELIST:
	    f4 = &fpm -> un.name__list;
	    for (n = fa -> fa_nname - 1, ap = fa -> fa_names;
		     n >= 0;
		     ap++, n--) {
		if (!*ap)
		    goto bad_value;
		if ((*f4 = (struct name_element *) calloc (1, sizeof **f4))
			    == NULL
		        || ((*f4) -> Node__Name =
			        str2qb (*ap, strlen (*ap), 1)) == NULL)
		    goto no_mem;
	        f4 = &((*f4) -> next);
	    }
	    break;

	case FA_FADUNUMBER:
	    fpm -> offset = type_FTAM_FADU__Identity_fadu__number;
	    fpm -> un.fadu__number = fa -> fa_fadunumber;
	    break;

	default:
	    (void) ftamlose (fti, FS_GEN (fsb), 0, NULLCP,
			     "bad type for FADU identity");
	    goto out;
    }

    return fpm;
}

/* \f */

int	fpm2faduid (fsb, fpm, fa, fti)
register struct ftamblk *fsb;
register struct type_FTAM_FADU__Identity *fpm;
register struct FADUidentity *fa;
struct FTAMindication *fti;
{
    register int    n;
    register char **ap;
    register struct name_element *f4;

    bzero ((char *) fa, sizeof *fa);

    switch (fpm -> offset) {
	case type_FTAM_FADU__Identity_first__last:
	    fa -> fa_type = FA_FIRSTLAST;
	    fa -> fa_firstlast = fpm -> un.first__last;
	    break;

	case type_FTAM_FADU__Identity_relative:
	    fa -> fa_type = FA_RELATIVE;
	    fa -> fa_relative = fpm -> un.relative;
	    break;

	case type_FTAM_FADU__Identity_begin__end:
	    fa -> fa_type = FA_BEGINEND;
	    fa -> fa_beginend = fpm -> un.begin__end;
	    break;

	case type_FTAM_FADU__Identity_single__name:
	    fa -> fa_type = FA_SINGLE;
	    if ((fa -> fa_singlename = qb2str (fpm -> un.single__name))
		    == NULL) {
no_mem: ;
		FUFREE (fa);
		return ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
				 "out of memory");
	    }
	    break;

	case type_FTAM_FADU__Identity_name__list:
	    fa -> fa_type = FA_NAMELIST;
	    ap = fa -> fa_names, n = NANAME;
	    for (f4 = fpm -> un.name__list; f4; f4 = f4 -> next) {
		if (n-- <= 0) {
		    FUFREE (fa);
		    return ftamlose (fti, FS_GEN (fsb), 1, NULLCP,
				     "too many nodes in FADU name");
		}
		if ((*ap++ = qb2str (f4 -> Node__Name)) == NULL)
		    goto no_mem;
	    }
	    break;

	case type_FTAM_FADU__Identity_fadu__number:
	    fa -> fa_type = FA_FADUNUMBER;
	    fa -> fa_fadunumber = fpm -> un.fadu__number;
	    break;
    }

    return OK;
}