fred.c

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

		    qos_indent = ufn_indent = postal_indent + 2;
		    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, "");
			else
			    ps_print (RPS, "\n");

			showfredattr (&avp -> avseq_av);

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

		break;
	    }
    }

    ufn_indent = (sizeof "Modified: " - 1) + 2;
    if (mydn) {
	ps_print (RPS, "\nName:     ");
	ufn_dn_print_aux (RPS, mydn, NULLDN, 1);
	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);

	    goto out;
	}

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

	for (;;) {
	    if (ds_list (&list_arg, &list_error, &list_result) == DS_OK)
		break;
	    if (dish_error (OPT, &list_error) == NOTOK)
		goto out;
	    
	    list_arg.lsa_object =
			list_error.ERR_REFERRAL.DSE_ref_candidates -> cr_name;
	}

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

	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;
    qos_indent = 24;
    ufn_indent = 16;

    return nchild;
}

/*  */

static	fred_children (parentdn, ptr, prob)
DN	parentdn;
register struct subordinate *ptr;
int	prob;
{
    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++) {
	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;
}

/*  */

static showfredattr (av)
register AttributeValue av;
{
    int	    seqno;

    if (av -> av_syntax == s_dn) {
	ufn_dn_print_aux (RPS, (DN) av -> av_struct, NULLDN, 1);

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

/*    MISC */


static struct pair {
    char   *p_name;
    AttributeType *p_at;
}	pairs[] = {
    "aliasedObjectName",	&t_alias,
    "documentAuthor",		&t_author,
    "documentAuthorCommonName",	&t_authorCN,
    "documentAuthorSurName",	&t_authorSN,
    "associatedDomain",		&t_domain,
    "masterDSA",		&t_master,
    "rfc822Mailbox",		&t_mbox,
    "lastModifiedTime",		&t_modtime,
    "lastModifiedBy",		&t_modwhom,
    "objectClass",		&t_object,
    "otherMailbox",		&t_othermbox,
    "telephoneNumber",		&t_phone,
    "photo",			&t_photo,
    "postalAddress",		&t_postal,
    "slaveDSA",			&t_slave,
    "surName",			&t_surname,
    "title",			&t_title,

    NULL
};
    
/*  */

static	fred_init ()
{
    register struct pair *p;
    register struct template *t;
    static int once_only = 1;

    if (!once_only)
	return;
    once_only = 0;
    
    s_dn = str2syntax ("DN");
    s_photo = str2syntax ("Photo");

    for (p = pairs; p -> p_name; p++)
	*p -> p_at = AttrT_new (p -> p_name);

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

/*  */

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_allattributes = FALSE;
	read_arg.rda_eis.eis_select = islong ? fred_full () : fred_as ();
	read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;

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

	cache_entry (&read_result.rdr_entry, islong ? TRUE : FALSE,
		     read_arg.rda_eis.eis_infotypes);

	entryinfo_comp_free (&read_result.rdr_entry, 0);

	newentry = local_find_entry (adn, FALSE);
    }

    return newentry;
}

/*  */

showfredDNs (dn, islong)
DN	dn;
int	islong;
{
    register Attr_Sequence eptr;
    register AV_Sequence avs;
    Entry    theEntry;
    PS	     nps;

    fred_init ();

    if (!(theEntry = fredentry (dn, islong)))
	return;

    if ((nps = ps_alloc (str_open)) == NULLPS
	    || str_setup (nps, NULLCP, 0, 0) == NOTOK) {
	if (nps)
	    ps_free (nps);

	return;
    }

    for (eptr = theEntry -> e_attributes; eptr; eptr = eptr -> attr_link)
	if (eptr -> attr_type -> oa_syntax == s_dn) {
	    if (AttrT_cmp (eptr -> attr_type, t_master) == 0
		    || AttrT_cmp (eptr -> attr_type, t_slave) == 0)
		continue;

	    for (avs = eptr -> attr_value; avs; avs = avs -> avseq_next) {
		char	buffer[BUFSIZ];
		DN	adn = (DN) avs -> avseq_av.av_struct;

		ufn_dn_print_aux (nps, adn, NULLDN, 0);
		ps_print (nps, "$");
		dn_print (nps, adn, EDBOUT);
		ps_print (nps, " ");
		*--nps -> ps_ptr = NULL, nps -> ps_cnt++;

		(void) sprintf (buffer, "d%s\n", nps -> ps_base);

		nps -> ps_ptr = nps -> ps_base, nps -> ps_cnt = nps -> ps_bufsiz;

		send_pipe_aux (buffer);

		if (read_pipe_aux (buffer, sizeof buffer) < 1) {
		    (void) fprintf (stderr, "read failure\n");
		    remote_prob = TRUE;
		    goto losing;
		}
	    }
	}
	else
	    if (fred_photo
		    && (eptr -> attr_type -> oa_syntax == s_photo
			    || eptr -> attr_type -> oa_syntax - AV_WRITE_FILE
				    == s_photo)) {
		int	avsno;

		for (avs = eptr -> attr_value, avsno = 1;
		         avs;
		         avs = avs -> avseq_next, avsno++) {
		    int	    cc,
			    i,
			    j;
		    register char *cp,
				  *dp;
		    char    buffer[BUFSIZ],
		    	    faxtopbm[BUFSIZ],
		    	    tmp1[BUFSIZ],
		    	    tmp2[BUFSIZ];
		    AttributeValue av;
		    FILE   *fp;
		    PE	    pe;
		    PS	    ps;
		    struct stat st;

		    if ((av = &avs -> avseq_av) -> av_syntax != AV_FILE)
			av = ((struct file_syntax *) av -> av_struct)
								    -> fs_attr;

		    (void) strcpy (faxtopbm, isodefile ("g3fax/faxtopbm", 1));
		    if (access (faxtopbm, X_OK) == NOTOK) {
#ifndef	NO_STATS
			(void) ll_log (dad_log, LLOG_EXCEPTIONS, "failed",
				"check for X_OK access on %s", faxtopbm);
#endif
			break;
		    }

		    (void) strcpy (tmp1, "/tmp/faxXXXXXX");
		    (void) unlink (mktemp (tmp1));
		    (void) strcpy (tmp2, "/tmp/pbmXXXXXX");
		    (void) unlink (mktemp (tmp2));

		    if ((fp = fopen (tmp1, "w")) == NULL)
			break;

		    if ((ps = ps_alloc (std_open)) == NULLPS
		            || std_setup (ps, fp) == NOTOK) {
			if (ps)
			    ps_free (ps);
			(void) unlink (tmp1);
			(void) fclose (fp);
			break;
		    }
		    (void) pe2ps (ps, pe = grab_pe (av));

		    pe_free (pe);
		    ps_free (ps);

		    (void) fclose (fp);

		    (void) sprintf (buffer, "%s < %s > %s",
				    faxtopbm, tmp1, tmp2);

		    i = system (buffer);

		    (void) unlink (tmp1);

		    if (i
			    || (fp = fopen (tmp2, "r")) == NULL
			    || fstat (fileno (fp), &st) == NOTOK
			    || (cc = st.st_size) == 0) {
			if (!i && fp)
			    (void) fclose (fp);
			(void) unlink (tmp2);

			continue;
		    }
		
		    if ((cp = malloc ((unsigned) (cc))) == NULL) {
			(void) fprintf (stderr, "out of memory\n");
			goto out;
		    }
		    for (dp = cp, j = cc; j > 0; dp += i, j -= i)
			switch (i = fread (dp, sizeof *dp, j, fp)) {
			    case NOTOK:
			        (void) fprintf (stderr, "error reading %s: %s\n",
					   tmp2, sys_errname (errno));
				goto out2;

			    case OK:
				(void) fprintf (stderr, "premature eof reading %s\n",
					   tmp2);
out2: ;
				free (cp);
				goto out;

			    default:
				break;
			}

		    (void) sprintf (buffer, "P%d %s", cc,
				    attr2name (eptr -> attr_type, OIDPART));
		    if (avs != eptr -> attr_value || avs -> avseq_next)
			(void) sprintf (buffer + strlen (buffer), "#%d",
					avsno);

		    ufn_dn_print_aux (nps, dn, NULLDN, 0);
		    ps_print (nps, "$");
		    dn_print (nps, dn, EDBOUT);
		    ps_print (nps, " ");
		    *--nps -> ps_ptr = NULL, nps -> ps_cnt++;

		    (void) sprintf (buffer + strlen (buffer), "$%s\n",
				    nps -> ps_base);

		    nps -> ps_ptr = nps -> ps_base, nps -> ps_cnt = nps -> ps_bufsiz;

		    send_pipe_aux (buffer);

		    if ((i = read_pipe_aux (buffer, sizeof buffer)) < 1) {
			(void) fprintf (stderr, "read failure\n");
			remote_prob = TRUE;
out: ;
			(void) fclose (fp);
			(void) unlink (tmp2);
			goto losing;
		    }
		    else
			if ((i == 1) && (*buffer == 'P')) {
			    remote_prob = FALSE;
			    (void) fclose (fp);
			    (void) unlink (tmp2);
			    break;
			}

		    send_pipe_aux2 (cp, cc);
		    free (cp);

		    if ((i = read_pipe_aux (buffer, sizeof buffer)) < 1) {
			(void) ps_printf (OPT, "read failure\n");
			remote_prob = TRUE;
			goto out;
		    }

		    (void) fclose (fp);
		    (void) unlink (tmp2);
		}
	    }

losing: ;

    ps_free (nps);
}

/*  */

Attr_Sequence fred_as ()
{
    static Attr_Sequence as = NULL;

    if (!as) {
	AttributeType at;

	fred_init ();

	if (at = t_mbox)
	    as = as_merge (as,
			   as_comp_new (AttrT_cpy (at), NULLAV, NULLACL_INFO));
	if (at = t_phone)
	    as = as_merge (as,
			   as_comp_new (AttrT_cpy (at), NULLAV, NULLACL_INFO));
	if (at = t_surname)
	    as = as_merge (as,
			   as_comp_new (AttrT_cpy (at), NULLAV, NULLACL_INFO));
	if (at = t_alias)
	    as = as_merge (as,
			   as_comp_new (AttrT_cpy (at), NULLAV, NULLACL_INFO));
    }
    
    return as;
}

/*  */

Attr_Sequence fred_full ()
{
    static Attr_Sequence as = NULL;

    if (!as) {
	register struct pair *p;
	register struct template *t;
	AttributeType at;
	
	fred_init ();

	for (p = pairs; p -> p_name; p++)
	    if (at = *p -> p_at)
		as = as_merge (as, as_comp_new (AttrT_cpy (at), NULLAV,
						NULLACL_INFO));

	for (t = default_template; t -> t_name; t++)
	    if (at = t -> t_at)
		as = as_merge (as, as_comp_new (AttrT_cpy (at), NULLAV,
						NULLACL_INFO));
    }

    if (t_photo) {
	sntx_table *s;

	if (dad_flag
	    	|| (s_photo
		        && (s = get_syntax_table (s_photo))
			&& s -> s_pe_print))
	    as = as_merge (as, as_comp_new (AttrT_cpy (t_photo), NULLAV,
					    NULLACL_INFO));
	else {
	    int	    i;
	    register Attr_Sequence  ptr,
				   *pptr;
	    
	    for (pptr = &as, ptr = *pptr;
		     ptr;
		     pptr = &ptr -> attr_link, ptr = *pptr) {
		if ((i = AttrT_cmp (ptr -> attr_type, t_photo)) == 0) {
		    *pptr = ptr -> attr_link;
		    as_comp_free (ptr);
		}
		if (i <= 0)
		    break;
	    }
	}
    }

    return as;
}