DataMuseum.dk

top - metrics - download

    Length: 16975 (0x424f)
    Types: TextFile
    Names: »fred.c«

└─⟦2d1937cfd⟧ Bits:30007241 EUUGD22: P.P 5.0
    └─⟦35176feda⟧ »EurOpenD22/isode/isode-6.tar.Z« 
        └─⟦de7628f85⟧ 
            └─⟦this⟧ »isode-6.0/quipu/dish/fred.c« 

TextFile

/* fred.c - DiSH support for FrED */

#ifndef	lint
static char *rcsid = "$Header: /f/osi/quipu/dish/RCS/fred.c,v 7.3 90/01/11 18:37:38 mrose Exp $";
#endif

/* 
 * $Header: /f/osi/quipu/dish/RCS/fred.c,v 7.3 90/01/11 18:37:38 mrose Exp $
 *
 *
 * $Log:	fred.c,v $
 * Revision 7.3  90/01/11  18:37:38  mrose
 * real-sync
 * 
 * Revision 7.2  89/12/19  16:21:03  mrose
 * sync
 * 
 * Revision 7.1  89/11/26  14:25:47  mrose
 * sync
 * 
 * Revision 7.0  89/11/23  22:20:08  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.
 *
 */


#include <ctype.h>
#include <stdio.h>
#include "quipu/ds_search.h"
#include "quipu/entry.h"


#define	OPT	(!frompipe || rps -> ps_byteno == 0 ? opt : rps)
#define	RPS	(!frompipe || opt -> ps_byteno == 0 ? rps : opt)
extern	char	frompipe;
extern	PS	opt, rps;


static	int	dsa_status;

struct dn_seq *dm2dn_seq ();


struct dn_seq *dn_seq_push ();

/* \f

   FRED BACK-END */

int	call_fred (argc, argv)
int	argc;
char  **argv;
{
    if (argc < 2)
	goto usage;

    if (test_arg (argv[1], "-dm2dn", 5)) {
	int	seqno;
	register struct dn_seq *dlist,
			       *dp;

	if (argc != 3)
	    goto usage;

	if ((dlist = dm2dn_seq (argv[2])) == NULLDNSEQ) {
	    if (dsa_status == OK)
		ps_printf (OPT, "Unable to resolve domain.\n");
	    return;
	}

	for (dp = dlist; dp; dp = dp -> dns_next) {
	    if (seqno = add_sequence (dp -> dns_dn))
		ps_printf (RPS, "%-3d ", seqno);
	    dn_print (RPS, dp -> dns_dn, RDNOUT);
	    ps_printf (RPS, "\n");
	}

	dn_seq_free (dlist);
	return;
    }

usage: ;
    Usage (argv[0]);
}

/* \f

 */

#define	ADOMAIN	"associatedDomain"

static	int	dlevel = 0;

struct dn_seq *dm2dn_seq_aux ();


static struct dn_seq *dm2dn_seq (dm)
char   *dm;
{
    register char *dp;

    for (dp = dm; *dp; dp++)
	if (isupper (*dp))
	    *dp = tolower (*dp);

    dlevel = 0;
    dsa_status = OK;

    return dm2dn_seq_aux (dm, NULLDN, NULLDNSEQ);
}

/* \f

 */

static struct dn_seq *dm2dn_seq_aux (dm, dn, dlist)
char   *dm;
DN	dn;
struct dn_seq *dlist;
{
    register char   *dp;
    register CommonArgs *ca;
    struct ds_search_arg search_arg;
    register struct ds_search_arg *sa = &search_arg;
    struct ds_search_result search_result;
    register struct ds_search_result *sr = &search_result;
    struct DSError error;
    register struct DSError *se = &error;

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

			    /* perhaps later initialize this from user, etc. */
    ca = &sa -> sra_common;
    ca -> ca_servicecontrol.svc_options = SVC_OPT_PREFERCHAIN;
    ca -> ca_servicecontrol.svc_prio = SVC_PRIO_LOW;
    ca -> ca_servicecontrol.svc_timelimit = SVC_NOTIMELIMIT;
    ca -> ca_servicecontrol.svc_sizelimit = SVC_NOSIZELIMIT;
    ca -> ca_servicecontrol.svc_scopeofreferral = SVC_REFSCOPE_NONE;

    sa -> sra_baseobject = dn;
    sa -> sra_subset = SRA_ONELEVEL;
    sa -> sra_searchaliases = FALSE;

    dp = dm;
    for (;;) {
	int	    i;
	EntryInfo  *ptr;
	register filter *fi;
	register AttributeType at;

	if ((dsa_status = rebind ()) != OK)
	    return dlist;

	if ((i = strlen (dp)) < dlevel)
	    break;

	sa -> sra_filter = fi = filter_alloc ();

	bzero ((char *) fi, sizeof *fi);
	fi -> flt_type = FILTER_ITEM;
	fi -> FUITEM.fi_type = FILTERITEM_EQUALITY;
	if ((fi -> FUITEM.UNAVA.ava_type = at = AttrT_new (ADOMAIN)) == NULL)
	    fatal (-100, "associatedDomain: invalid attribute type");
	fi -> FUITEM.UNAVA.ava_value =
	    str2AttrV (dp, at -> at_table -> oa_syntax);

	while (ds_search (sa, se, sr) != DS_OK) {
	    if (dish_error (OPT, se) == 0) {
		dsa_status = NOTOK;
		goto free_filter;
	    }

	    sa -> sra_baseobject =
			    se -> ERR_REFERRAL.DSE_ref_candidates -> cr_name;
	}

	if (sr -> srr_correlated != TRUE)
	    correlate_search_results (sr);

	if (sr -> CSR_entries == NULLENTRYINFO) {
	    filter_free (sa -> sra_filter);
	    if (dp = index (dp, '.'))
		dp++;
	    if (dp == NULL)
		break;
	    continue;
	}

	if (i > dlevel) {
	    dlevel = i;
	    if (dlist)
		dn_seq_free (dlist), dlist = NULLDNSEQ;
	}

	if (i == dlevel)
	    for (ptr = sr -> CSR_entries; ptr; ptr = ptr -> ent_next) {
		struct dn_seq *dprev = dlist;
		(void) dn_decode (ptr -> ent_dn);

		dlist = dm2dn_seq_aux (dm, ptr -> ent_dn, dlist);

		if (dprev == dlist)
		    dlist = dn_seq_push (ptr -> ent_dn, dlist);
		else
		    if (i < dlevel)
			break;
	    }

	entryinfo_free (sr -> CSR_entries, 0);
free_filter: ;
	filter_free (sa -> sra_filter);
	break;
    }

    return dlist;
}

/* \f

   SHOWENTRY SUPPORT */

#include "quipu/list.h"
#include "quipu/read.h"

char		fred_flag;
char		fred_expand;
char		fred_long;
char		fred_sequence;
char		fred_subdisplay;

/* \f

 */

static AttributeType t_mbox = NULLAttrT;
static AttributeType t_phone = NULLAttrT;
static AttributeType t_modtime = NULLAttrT;
static AttributeType t_modwhom = NULLAttrT;
static AttributeType t_postal = NULLAttrT;
static AttributeType t_title = NULLAttrT;
static AttributeType t_photo = NULLAttrT;

extern int postal_indent;

static struct template {
    char   *t_name;
    char   *t_prefix;

    int	    t_level;

    AttributeType t_at;    
} default_template[] = {
    "title",				NULL,
		0, NULL,
    "documentTitle",			NULL,
		0, NULL,
#define	LEVEL_POSTAL	0
    "organizationName", 		NULL,
		0, NULL,
    "organizationalUnitName",		NULL,
		0, NULL,
	"roomNumber",			"  Room ",
		0, NULL,
	"streetAddress",		"  ",
		0, NULL,
	"postOfficeBox",		"  POB ",
		0, NULL,
	"physicalDeliveryOfficeName",	"  ",
		0, NULL,
	"stateOrProvinceName",		"  ",
		0, NULL,
	"postalCode", 			"  ",
		0, NULL,

    "postalAddress",			NULL,
		1, NULL,
    "documentAuthor",			"Author: ",
		1, NULL,

    "registeredAddress",		"Registered Address: ",
		2, NULL,
    "documentVersion",			"Version of: ",
		2, NULL,
    
    "telephoneNumber",			"Telephone: ",
		3, NULL,
    "mobileTelephoneNumber",		"Mobile:    ",
		3, NULL,
    "pagerTelephoneNumber",		"Pager:     ",
		3, NULL,
    "facsimileTelephoneNumber",		"FAX:       ",
		3, NULL,
    "telexNumber",			"Telex:     ",
		3, NULL,
    "teletexTerminalIdentifier",	"Teletex:   ",
		3, NULL,
    "x121Address",			"X.121:     ",
		3, NULL,
    "internationaliSDNNumber",		"ISDN:      ",
		3, NULL,
    "presentationAddress",		"OSI:       ",
		3, NULL,

#define	LEVEL_MBOX	4
    "rfc822Mailbox",			"  Mailbox: ",
		4, NULL,
        "otherMailbox",			"  ",
		4, NULL,
	"textEncodedORaddress",		"  ",
		4, NULL,

    "destinationIndicator",		"Destination Indicator:     ",
		5, NULL,
    "preferredDeliveryMethod",		"Preferred Delivery Method: ",
		5, NULL,

    "description",			NULL,
		6, NULL,

    "info",				"Information: ",
		7, NULL,
    "businessCategory",			"Business:    ",
		7, NULL,
    "userClass",			"User Class:  ",
		7, NULL,
    "localityName",			"Locality:    ",
    		7, NULL,
    "documentLocation",			"Location:    ",
		7, NULL,

    "aliasedObjectName",		"Alias to:  ",
		8, NULL,
    "roleOccupant",			"Occupant:  ",
		8, NULL,
    "seeAlso",				"See Also:  ",
		8, NULL,
    "secretary",			"Secretary: ",
		8, NULL,
    "manager",				"Manager:   ",
		8, NULL,

    "homePostalAddress",		"Home Address: ",
		9, NULL,
    "homePhone",			"Home Phone:   ",
		9, NULL,
    "favouriteDrink",			"Drinks:       ",
		9, NULL,
    "photo",				"Picture:      ",
		9, NULL,

    NULL
};


Entry	fredentry ();

/* \f

 */

showfred (mydn, islong, subdisplay)
DN	mydn;
char	islong,
	subdisplay;
{
    int	    didtime,
	    haspost,
	    level,
	    nchild,
	    pos,
	    seqno;
    register struct template *t;
    register Attr_Sequence eptr;
    register AV_Sequence avs,
			 avp;
    AttributeType rdn_at,
		  inf_at;
    AttributeValue rdn_av;
    Entry	myentry = fredentry (mydn = dn_cpy (mydn), islong);
    PS	    ps = NULLPS;
    RDN	    myrdn;
    static int once_only = 0;

    if (once_only == 0) {
	once_only++;

	t_mbox = AttrT_new ("rfc822Mailbox");
	t_phone = AttrT_new ("telephoneNumber");
	t_modtime = AttrT_new ("lastModifiedTime");
	t_modwhom = AttrT_new ("lastModifiedBy");
	t_postal = AttrT_new ("postalAddress");
	t_title = AttrT_new ("title");
	t_photo = AttrT_new ("photo");

	for (t = default_template; t -> t_name; t++)
	    t -> t_at = AttrT_new (t -> t_name);
    }

    pos = RPS -> ps_byteno;

    seqno = fred_sequence ? add_sequence (mydn) : 0;
    if (islong == FALSE) {
	if (seqno)
	    ps_printf (RPS, "%3d. ", seqno);
	else
	    ps_printf (RPS, "     ");
    }

    if (mydn) {
	register DN	adn;
	register RDN	rdn;

	for (adn = mydn; adn -> dn_parent; adn = adn -> dn_parent)
	    continue;
	myrdn = adn -> dn_rdn;
	rdn_at = &myrdn -> rdn_at, rdn_av = &myrdn -> rdn_av;
	AttrV_print (RPS, rdn_av, EDBOUT);
	for (rdn = myrdn -> rdn_next; rdn; rdn = rdn -> rdn_next) {
	    ps_print (RPS, " / ");
	    AttrV_print (RPS, &rdn -> rdn_av, EDBOUT);
	}
    }
    else {
	myrdn = NULLRDN, rdn_at = NULLAttrT, rdn_av = NULLAttrV;
	ps_print (RPS, "@");
    }

    if (islong == TRUE && seqno)
	ps_printf (RPS, " (%d)", seqno);

    if ((pos += 52 - RPS -> ps_byteno) <= 0)
	pos = 1;

    inf_at = NULLAttrT;
    if (myentry) {
	for (eptr = myentry -> e_attributes; eptr; eptr = eptr -> attr_link)
	    if (AttrT_cmp (&eptr -> attr_type, t_mbox) == 0) {
		inf_at = t_mbox;

		if (avs = eptr -> attr_value) {
		    ps_printf (RPS, "%*s", pos, "");
		    showfredattr (&avs -> avseq_av);
		}
		break;
	    }
	    else
		if (AttrT_cmp (&eptr -> attr_type, t_phone) == 0) {
		    inf_at = t_phone;
		    avp = eptr -> attr_value;
		}

	if (inf_at == t_phone && avp) {
	    ps_printf (RPS, "%*s", pos, "");
	    showfredattr (&avp -> avseq_av);
	}
    }

    ps_print (RPS, "\n");

    if (myentry == NULLENTRY)
	goto out;
    if (islong == FALSE)
	goto children;

   for (eptr = myentry -> e_attributes; eptr; eptr = eptr -> attr_link)
	if (AttrT_cmp (&eptr -> attr_type, t_photo) == 0) {
	    if (eptr -> attr_value) {
		if (rdn_av
		        && (ps = ps_alloc (str_open)) != NULLPS
		        && str_setup (ps, NULLCP, 0, 0) != NOTOK) {
		    register RDN rdn;

		    AttrV_print (ps, rdn_av, EDBOUT);
		    for (rdn = myrdn -> rdn_next; rdn; rdn = rdn -> rdn_next) {
			ps_print (ps, "/");
			AttrV_print (ps, &rdn -> rdn_av, EDBOUT);
		    }
		    ps_print (ps, " ");
		    *--ps -> ps_ptr = NULL, ps -> ps_cnt++;
		    (void) setenv ("RDN", ps -> ps_base);
		}
		else
		    (void) setenv ("RDN", "Photo");
	    }
	    break;
	}

    level = 0;
    for (eptr = myentry -> e_attributes; eptr; eptr = eptr -> attr_link)
	if (AttrT_cmp (&eptr -> attr_type, rdn_at) == 0) {
	    for (avp = eptr -> attr_value; avp; avp = avp -> avseq_next)
		if (AttrV_cmp (&avp -> avseq_av, rdn_av)) {
		    ps_print (RPS, "     aka: ");
		    showfredattr (&avp -> avseq_av);
		    ps_print (RPS, "\n");
		    level++;
		}

	    break;
	}

    haspost = 0;
    for (eptr = myentry -> e_attributes; eptr; eptr = eptr -> attr_link)
	if (AttrT_cmp (&eptr -> attr_type, t_postal) == 0) {
	    if (eptr -> attr_value)
		haspost = 1;
	}
    ps_print (RPS, "\n");

    level = -1;
    for (t = default_template; t -> t_name; t++) {
	if (AttrT_cmp (t -> t_at, rdn_at) == 0)
	    continue;

	for (eptr = myentry -> e_attributes;
	         eptr;
	         eptr = eptr -> attr_link)
	    if (AttrT_cmp (&eptr -> attr_type, t -> t_at) == 0) {
		int	i;

		if (AttrT_cmp (&eptr -> attr_type, inf_at) == 0
		        && (avs = eptr -> attr_value)
		        && !avs -> avseq_next)
		    continue;

		if (haspost
			&& t -> t_level == LEVEL_POSTAL
			&& AttrT_cmp (&eptr -> attr_type, t_title)) {
		    level = t -> t_level + 1;
		    continue;
		}

		if (t -> t_level != level) {
		    if (level >= 0)
			ps_print (RPS, "\n");
		    if ((level = t -> t_level) == LEVEL_MBOX)
			ps_print (RPS, "Mailbox information:\n");
		}
		
		if (t -> t_prefix) {
		    i = strlen (t -> t_prefix);
		    ps_printf (RPS, "%s", t -> t_prefix);
		}
		else
		    i = 0;

		if (avs = eptr -> attr_value) {
		    postal_indent = i;
		    showfredattr (&avs -> avseq_av);
		    ps_print (RPS, "\n");
		    for (avp = avs -> avseq_next;
			     avp;
			     avp = avp -> avseq_next) {
			if (t -> t_prefix)
			    ps_printf (RPS, "%*s", i, "");

			showfredattr (&avp -> avseq_av);

			ps_print (RPS, "\n");
		    }
		}
		else
		    ps_print (RPS, "no value?!?\n");

		break;
	    }
    }

    if (mydn) {
	ps_print (RPS, "\nHandle:   @");
	dn_print (RPS, mydn, EDBOUT);
	if (seqno)
	    ps_printf (RPS, " (%d)", seqno);
    }

    ps_print (RPS, "\n");

    didtime = 0;
    for (eptr = myentry -> e_attributes; eptr; eptr = eptr -> attr_link)
	if (AttrT_cmp (&eptr -> attr_type, t_modtime) == 0) {
	    if (avs = eptr -> attr_value) {
		ps_print (RPS, "Modified: ");
		showfredattr (&avs -> avseq_av);
		ps_print (RPS, "\n");

		didtime = 1;
	    }
	    break;
	}
    if (didtime)
	for (eptr = myentry -> e_attributes; eptr; eptr = eptr -> attr_link)
	    if (AttrT_cmp (&eptr -> attr_type, t_modwhom) == 0) {
		if ((avs = eptr -> attr_value)
			&& dn_cmp ((DN) avs -> avseq_av.av_struct, mydn)) {
		    ps_print (RPS, "      by: ");
		    showfredattr (&avs -> avseq_av);
		    ps_print (RPS, "\n");
		}
		break;
	    }

children: ;
    nchild = 0;
    if (subdisplay) {
	struct ds_list_arg list_arg;
	struct ds_list_result list_result;
	struct DSError list_error;
	struct list_cache *ptr;

	(void) ps_flush (RPS);

	(void) service_control (OPT, 0, NULLVP, &list_arg.lsa_common);
	list_arg.lsa_common.ca_servicecontrol.svc_options |=
						SVC_OPT_DONTDEREFERENCEALIAS;

	if (ptr = find_list_cache (list_arg.lsa_object = mydn,
				   SVC_NOSIZELIMIT)) {
	    if (ptr -> list_subs)
		nchild = fred_children (mydn, ptr -> list_subs,
					ptr -> list_problem, TRUE);

	    goto out;
	}

	if (rebind () != OK)
	    goto out;

	if (ds_list (&list_arg, &list_error, &list_result) != DS_OK) {
	    ds_error (RPS, &list_error);
	    goto out;
	}

	if (list_result.lsr_subordinates)
	    nchild = fred_children (mydn, list_result.lsr_subordinates,
			   list_result.lsr_limitproblem, FALSE);

	cache_list (list_result.lsr_subordinates, list_result.lsr_limitproblem,
		    mydn, SVC_NOSIZELIMIT);
	subords_free (list_result.lsr_subordinates);
    }

out: ;
    if (mydn)
	dn_free (mydn);
    if (ps)
	ps_free (ps);
    postal_indent = -1;

    return nchild;
}

/* \f

 */

static	fred_children (parentdn, ptr, prob, cached)
DN	parentdn;
register struct subordinate *ptr;
int	prob;
char	cached;
{
    int	    i,
	    nchild;
    register struct subordinate *qtr;
    register DN	adn,
		newdn;

    newdn = dn_comp_new (rdn_comp_new (NULLAttrT, NULLAttrV));
    if (adn = dn_cpy (parentdn))
	dn_append (adn, newdn);
    else
	adn = newdn;

    i = 0;
    for (qtr = ptr; qtr; qtr = qtr -> sub_next)
	i++;
    nchild = i;

    if (i > 0)
	ps_printf (RPS, "%d child%s.\n-----\n", i, i != 1 ? "ren" : "");

    for (i = 0; ptr; ptr = ptr -> sub_next, i++) {
	if (!cached)
	    (void) rdn_decode (ptr -> sub_rdn);
	rdn_free (newdn -> dn_rdn);
	dn_comp_fill (newdn, rdn_cpy (ptr -> sub_rdn));
	(void) add_sequence (adn);

	(void) showfred (adn, 0, FALSE);
    }

    dn_free (adn);

    if (prob != LSR_NOLIMITPROBLEM)
	ps_print (RPS, "(Limit problem)\n");

    return nchild;
}


/* \f

 */

static showfredattr (av)
register AttributeValue av;
{
    int	    format,
	    seqno;
    static int once_only = 0;
    static int s_dn;

    if (once_only == 0) {
	once_only++;

	s_dn = str2syntax ("DN");
    }

    if (av -> av_syntax == s_dn) {
	ps_print (RPS, "@");
	format = EDBOUT;
    }
    else
	format = READOUT;

    AttrV_print (RPS, av, format);

    if (av -> av_syntax == s_dn
	    && fred_sequence
	    && (seqno = add_sequence ((DN) av -> av_struct)))
	ps_printf (RPS, " (%d)", seqno);
}

/* \f

 */

static  Entry fredentry (adn, islong)
DN	adn;
char	islong;
{
    register Entry newentry;

    struct ds_read_arg read_arg;
    struct ds_read_result read_result;
    struct DSError read_error;
    
    if (adn == NULLDN)
	return NULLENTRY;

    if ((newentry = local_find_entry (read_arg.rda_object = adn,
				      FALSE)) == NULLENTRY
	    || !newentry -> e_lock
	    || (islong && !newentry -> e_complete)) {
	if (rebind () != OK)
	    return newentry;

	(void) service_control (OPT, 0, NULLVP, &read_arg.rda_common);
	read_arg.rda_common.ca_servicecontrol.svc_options |=
						SVC_OPT_DONTDEREFERENCEALIAS;
	read_arg.rda_eis.eis_infotypes = TRUE;
	read_arg.rda_eis.eis_allattributes = TRUE;
	read_arg.rda_eis.eis_select = NULLATTR;

	if (ds_read (&read_arg, &read_error, &read_result) != DS_OK) {
#ifdef	notdef
	    ds_error (RPS, &read_error);
#endif
	    return newentry;
	}

	cache_entry (&read_result.rdr_entry,
		     read_arg.rda_eis.eis_allattributes,
		     read_arg.rda_eis.eis_infotypes);

	entryinfo_comp_free (&read_result.rdr_entry, 0);

	newentry = local_find_entry (adn, FALSE);
    }

    return newentry;
}