modify.c

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

	for (x=b; x != NULLAV; x=x->avseq_next) {
		emnew = NULLMOD;
		for (y=a; y != NULLAV; y=y->avseq_next) 
			if (AttrV_cmp (&x->avseq_av,&y->avseq_av) == 0)
				break;
		if (y == NULLAV) {
			emnew = em_alloc ();
			emnew->em_type = EM_REMOVEVALUES;
			emnew->em_what = as_comp_new (at,avs_comp_new(AttrV_cpy(&x->avseq_av)),NULLACL_INFO);
			emnew->em_next = NULLMOD;
		} else
			removed_all = FALSE;
		if (emnew != NULLMOD)
			em = ems_append (em,emnew);
	}

	if (removed_all) {
		ems_part_free (em);
		emnew = em_alloc ();
		emnew->em_type = EM_REMOVEATTRIBUTE;
		emnew->em_what = as_comp_new (at,b,NULLACL_INFO);
		emnew->em_next = em_alloc();
		emnew->em_next->em_type = EM_ADDATTRIBUTE;
		emnew->em_next->em_what = as_comp_new (at,avs_cpy(a),NULLACL_INFO);
		emnew->em_next->em_next = NULLMOD;
		return (emnew);
	}

	for (x=a; x != NULLAV; x=x->avseq_next) {
		emnew = NULLMOD;
		for (y=b; y != NULLAV; y=y->avseq_next) 
			if (AttrV_cmp (&x->avseq_av,&y->avseq_av) == 0)
				break;
		if (y == NULLAV) {
			if (at->oa_syntax == oc_sntx) {
				/* Don't add 'top' if missing */
				objectclass * oc;
				if (!top)
					top = oid_cpy(str2oid (TOP_OC));

				if (oc = (objectclass *) x->avseq_av.av_struct) 	/* assign */
					if (oid_cmp(oc->oc_ot.ot_oid, top) == 0)
						continue;
			}
			emnew = em_alloc ();
			emnew->em_type = EM_ADDVALUES;
			emnew->em_what = as_comp_new (at,avs_comp_new(AttrV_cpy(&x->avseq_av)),NULLACL_INFO);
			emnew->em_next = NULLMOD;
		}
		if (emnew != NULLMOD)
			em = ems_append (em,emnew);
	}

		
	return (em);
}

ems_part_free(emp)
struct entrymod *emp;
{
	if(emp == NULLMOD)
		return;
	ems_part_free(emp->em_next);
	free((char *)emp);
}

static	int	raboof = 0;

static char *foobar (string)
char   *string;
{
    DN	    fb;
    PS	    ps;
    static char    buffer[BUFSIZ];
    DN	    sequence_dn ();

    if (!isdigit (*string))
	return string;
    if ((fb = sequence_dn (atoi (string))) == NULLDN) {
	ps_printf (OPT, "Invalid sequence in directive %s\n", string);
you_lose: ;
	raboof = 1;
	return string;
    }

    if ((ps = ps_alloc (str_open)) == NULLPS) {
	ps_printf (OPT, "ps_alloc: failed");
	goto you_lose;
    }
    if (str_setup (ps, buffer, sizeof buffer - 2, 1) == NOTOK) {
	ps_printf (OPT, "str_setup: %s", ps_error (ps -> ps_errno));
	ps_free (ps);
	goto you_lose;
    }

    dn_print (ps, fb, EDBOUT);
    ps_print (ps, " ");
    *--ps -> ps_ptr = NULL, ps -> ps_cnt++;

    ps_free (ps);

    return buffer;    
}

dsa_control (argc, argv)
int             argc;
char          **argv;
{
	static struct entrymod mod = {
				      EM_ADDATTRIBUTE,
				      NULLATTR,
				      NULLMOD
	};

	static struct ds_modifyentry_arg mod_arg =
	{
	 default_common_args,
	 NULLDN,
	 &mod
	};

	AttributeType at;
	struct DSError  error;
	char            buffer[100];
	char * 		msg = "Done\n";
	char 		do_unbind = FALSE;

	if (argc < 2) {
		Usage(argv[0]);
		return;
	}

	if (test_arg (argv[1], "-dump",1))
		if (argc != 3) goto out; else
		(void) sprintf (buffer, "d %s", argv[2]);
	else if (test_arg (argv[1], "-tailor",1))
		if (argc != 3) goto out; else
		(void) sprintf (buffer, "t %s", argv[2]);
	else if (test_arg (argv[1], "-abort",1)) {
		(void) strcpy (buffer,"a");
		argc++;		/* to get through if (argc != 3) */
		do_unbind = TRUE;
	}
	else if (test_arg (argv[1], "-restart",1)) {
		(void) strcpy (buffer,"b");
		argc++;		/* to get through if (argc != 3) */
		do_unbind = TRUE;
	}
	else if (test_arg (argv[1], "-refresh",3))
		if (argc != 3) goto out; else
		(void) sprintf (buffer, "r %s", foobar (argv[2]));
	else if (test_arg (argv[1], "-resync",2))
		if (argc != 3) goto out; else
		(void) sprintf (buffer, "f %s", foobar (argv[2]));
	else if (test_arg (argv[1], "-lock",1))
		if (argc != 3) goto out; else
		(void) sprintf (buffer, "l %s", foobar (argv[2]));
	else if (test_arg (argv[1], "-unlock",1))
		if (argc != 3) goto out; else
		(void) sprintf (buffer, "u %s", foobar (argv[2]));
	else if (test_arg (argv[1], "-info",1)) {
		dsa_control_info();
		return;
	} else if (test_arg (argv[1], "-slave",1)) {
		msg = "Scheduled\n";
		if (argc == 2) {
		    (void) strcpy (buffer,"s");
		    argc++;		/* to get through if (argc != 3) */
		}
		else
		    if (argc != 3) goto out; else
		    (void) sprintf (buffer, "s %s", foobar (argv[2]));
	}
	else
		argc = 1;	/* to force error */

	if (raboof) {
	    raboof = 0;
	    return;
	}

	if (argc != 3) {
out:;
		Usage (argv[0]);
		return;
	}
	mod_arg.mea_object = dn;
	at = AttrT_new (CONTROL_OID);
	mod_arg.mea_changes->em_what = as_comp_new (at, avs_comp_new (str_at2AttrV (buffer, at)), NULLACL_INFO);

	if (rebind () != OK) 
		return;

	if (ds_modifyentry (&mod_arg, &error) != DS_OK) {
		/* deal with error */
		(void) dish_error (OPT, &error);
	} else {
		ps_print (RPS, msg);
	}

	if (do_unbind) 
	    unbind_from_dsa();
	    

	/* as_free (mod_arg.mea_changes->em_what); */
}

dsa_control_info ()
{
struct ds_read_arg read_arg;
struct DSError  error;
struct ds_read_result result;
static CommonArgs      ca = default_common_args;

	read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
	read_arg.rda_eis.eis_allattributes = FALSE;
	read_arg.rda_eis.eis_select = as_comp_new (AttrT_new (CONTROL_OID), NULLAV, NULLACL_INFO);
	read_arg.rda_common = ca;	/* struct copy */
	read_arg.rda_object = NULLDN;

	if (rebind () != OK)
		return;

	if (ds_read (&read_arg, &error, &result) != DS_OK) {
		(void) dish_error (OPT, &error);
		return;
	}

	if (result.rdr_entry.ent_attr) {
		avs_print (RPS,result.rdr_entry.ent_attr->attr_value,READOUT);
	} else
		ps_printf (OPT, "No information !!!\n");
}

mod_template (name,noedit)
char           *name;
char 		noedit;
{
	FILE           *fptr;
	PS              ps;
	extern AttributeType at_objectclass;
	Attr_Sequence   as;
	Attr_Sequence   nas, tas, make_template_as ();
	int		um;

	if (! new_draft)
		if ((fptr = fopen (name, "r")) != NULL) {
			(void) fclose (fptr);
			if (!noedit) {
				if (!yesno ("Use existing draft file ? "))
					return OK;
				else
					make_old (fname,FALSE);
			} else
				return (OK);	/* template already exists ! */
				
		}

	um = umask (0177);
	if ((fptr = fopen (name, "w")) == NULL) {
		ps_printf (OPT, "Can't open template entry %s\n", name);
		return (-1);
	}
	(void) umask (um);

	if ((ps = ps_alloc (std_open)) == NULLPS) {
		return (-1);
	}
	if (std_setup (ps, fptr) == NOTOK) {
		return (-1);
	}
	for (as = current_entry->e_attributes; as != NULLATTR; as = as->attr_link) 
		if (as->attr_type == at_objectclass)
			break;

	tas = make_template_as (as->attr_value);
	nas = as_cpy(current_entry->e_attributes);
	
	tas = as_merge (tas,nas);

	as_print (ps,tas,EDBOUT);

	as_free (tas);
	ps_free (ps);
	(void) fclose (fptr);

	return (OK);
}

build_modify(start, mod_arg)
struct	list_element	*start ;
struct  ds_modifyentry_arg      *mod_arg ;
{
struct	list_element	*temp_elem ;
struct	entrymod	*emnew ;
	AttributeType	a_t ;
	AV_Sequence	tmp_avs ;
	Attr_Sequence	eptr ;

	char   *ptr ;
	int    num_attr_vals = 0 ;
	int    attr_val_match = 0 ;

	while (start)
	{
		emnew = em_alloc() ;

		ptr = start->mod;

		while (*ptr != 0)
			if (*ptr == '=')
				break;
			else
				ptr++;

		if (*ptr == 0) {
			if ((a_t = AttrT_new (start->mod)) == NULLAttrT) {
				ps_printf(OPT, "invalid attribute type '%s'",
					  start->mod) ;
				return (NOTOK) ;
			}
			emnew->em_what = as_comp_new (a_t, NULLAV, 
						      NULLACL_INFO);
			
		} else 	if ((emnew->em_what = str2as (start->mod)) == 
			    					NULLATTR) {
			  ps_printf(OPT, "invalid attribute '%s' ",
				    start->mod) ;
			  return (NOTOK) ;
		}
			
		emnew->em_type = -1 ;
	        a_t = emnew->em_what->attr_type;

		for (eptr = current_entry->e_attributes; eptr != NULLATTR; 
		     				eptr = eptr->attr_link)
		{
		   if ( AttrT_cmp (eptr->attr_type, a_t) == 0 )
		   {
		      if (emnew->em_type == -1)
   		      {
			 if (start->add == 0) /* Removing... */
			 {
			    if (emnew->em_what->attr_value == NULLAV)
			    {
			       emnew->em_type = EM_REMOVEATTRIBUTE ;
			    }
			    else
			    {
			       num_attr_vals = 0 ;
			       attr_val_match = 0 ;

			       for (tmp_avs = eptr->attr_value; 
				    tmp_avs != NULLAV; 
				    tmp_avs = tmp_avs->avseq_next)
			       {			       
				  if (AttrV_cmp(&(tmp_avs->avseq_av),
				      &emnew->em_what->attr_value->avseq_av) 
				      == OK)
			          {
				     attr_val_match = 1 ;
				  }
				  num_attr_vals++ ;
			       }
			       if (num_attr_vals == 1)
			          emnew->em_type = EM_REMOVEATTRIBUTE ;
			       else
				   emnew->em_type = EM_REMOVEVALUES ;
			       if (attr_val_match == 0)
			       {
				  ps_printf(OPT,"Can't remove value that is not present.\n") ;
				  return (NOTOK) ;
			       }
			    }
			 }
			 else 
			    emnew->em_type = EM_ADDVALUES ;
		      }
		   }
		}

		if (emnew->em_type == -1) /* No matches, so attrType is a new one */
		{
			if (start->add == 0) /* Remove */
			{
				ps_print(OPT, "Removing attribute that is not present.\n") ;
				return (NOTOK) ;
			}
			emnew->em_type = EM_ADDATTRIBUTE ;
		}
		temp_elem = start ;
		start = start->next ;
		free (temp_elem->mod) ;
		free ((char *)temp_elem) ;
		emnew->em_next = NULLMOD ;
		mod_arg->mea_changes = ems_append (mod_arg->mea_changes, emnew) ;
	}
	mod_arg->mea_object = dn;

	return (OK) ;
}