DataMuseum.dk

top - metrics - download

    Length: 19281 (0x4b51)
    Types: TextFile
    Names: »calls.c«

└─⟦3d0c2be1b⟧ Bits:30001254 ISODE-5.0 Tape
    └─⟦eba4602b1⟧ »./isode-5.0.tar.Z« 
        └─⟦d3ac74d73⟧ 
            └─⟦this⟧ »isode-5.0/others/quipu/uips/widget/calls.c« 

TextFile

/* calls.c - */

#ifndef	lint
static char *rcsid = "$Header: /f/osi/others/quipu/uips/widget/RCS/calls.c,v 6.0 89/03/18 23:34:44 mrose Rel $";
#endif

/* 
 * $Header: /f/osi/others/quipu/uips/widget/RCS/calls.c,v 6.0 89/03/18 23:34:44 mrose Rel $
 *
 *
 * $Log:	calls.c,v $
 * Revision 6.0  89/03/18  23:34:44  mrose
 * Release 5.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 "quipu/util.h"
#include "quipu/common.h"
#include "quipu/entry.h"
#include "tailor.h"

#define DEFEDITOR "/usr/ucb/vi"
#define RESBUF 100000
#define debug(a,b)

PS opt;

int dn_print (), rdn_print(), as_print(), avs_comp_print();

char bound = FALSE;  /* indication of wether bound */
char * TidyString();

/* hack to get isode/curses compatability */
#define WINDOW char

#include "widget.h"
#include "wdgtdefs.h"

/* These are common operation variables */
char * addobj = NULLCP;

char            goto_path[128];         /* Used by the 'G:goto' command */
char            base_path[128];         /* Used by all DS operations    */
char            namestr[128];
char		cache [128];
char		bindpass [128];
char		srchvalue[128];		/* Used by search */
char		limit [128];		/* used by search / add */

char		mtype [128];
char		mvalue [128];

static char	*mtog[] = {"Modify ", "Add ", "Remove ", 
			   "Add Values ", "Remove Values ",
			  (char *)NULL };

static char     *xtntstrs[] = {"This object ","Children ",
			       "Subtree ", (char *)NULL};

static char     *filttype[] = {"commonName", "Surname", "UserClass","RoomNumber",
				"OrganizationName", "OrganizationalUnitName", "LocalityName","ObjectClass",
				"countryName", NULLCP};

static char     *filtmatch[]= {"= ","Substring ","< ","> ","Present ","Approx ",NULLCP};

#ifndef NO_STATS
static  LLog    lstat_log =
{
	"widget.log",
	NULLCP,
	NULLCP,
	LLOG_NOTICE,
	LLOG_NONE,
	50,
	LLOGCLS | LLOGCRT | LLOGZER,
	NOTOK,
};

LLog    *log_stat = &lstat_log;
#endif 

/* These are used as the data for the binding connection */
char   passwd[16];
extern char     currentpath[];
extern char *   myname;

extern int sizelimit;
DN user_name;

Filter search_filter;


user_tailor ()
{
	char           *part1;
	char           *part2;
	char           *getenv ();
	char           *ptr = "/.quipurc";
	char            Dish_Home[BUFSIZ];

	FILE           *file;
	char            Read_in_Stuff[132];
	char           *p, 
		       *TidyString(),
		       *SkipSpace();
	extern char    *local_dit;
	
#ifndef NO_STATS
    	ll_hdinit (log_stat,"widget");
#endif

    	if ((opt = ps_alloc (std_open)) == NULLPS)
             fatal (-1,"ps_alloc failed");
	if (std_setup (opt,stdout) == NOTOK)
             fatal (-1,"std_setup failed");

	(void) sprintf (limit,"%d",sizelimit);
	namestr[0] = '\0';
	*passwd = '\0';
	cache[0] = '\0';
	currentpath[0] = '\0';

	(void) strcpy (Dish_Home, getenv ("HOME"));
	(void) strcat (Dish_Home, ptr);

	if ((file = fopen (Dish_Home, "r")) == 0) 
		return;

	while (fgets (Read_in_Stuff, 80, file) != 0) {
		p = SkipSpace (Read_in_Stuff);
		if (( *p == '#') || (*p == '\0'))
			continue;  /* ignore comments and blanks */
			
		part1 = p;
		if ((part2 = index (p,':')) == NULLCP) 
			continue; /* ignore it */
		
		*part2++ = '\0';
		part2 = TidyString(part2);

		if (strcmp (part1, "username") == 0) 
			(void) strcpy (namestr, part2);
		else if (strcmp (part1, "password") == 0) 
			(void) strcpy (passwd, part2);
		else if (lexequ (part1, "dsap") == 0)
			(void) tai_string (part2);
		else if (lexequ (part1, "isode") == 0) {
			char * split;
			if ((split = index (part2,' ')) != NULLCP) {
				*split++ = 0;
				isodesetvar (part2,split,0);
			}
		} else if (strcmp (part1, "service") == 0) 
			new_service (part2);
	}

	if (local_dit != NULLCP) {
		(void) strcpy (currentpath,local_dit);
		showcurrentpath(currentpath);
	}

	isodexport ();
}

/* These are the functions called by the main level of widgets */

main_quit()
{
    cleartext();
    setwidgets(quitwdgts,-1);
}

main_help()
{
    cleartext();
    killwidgets(mainwdgts);
    setwidgets(helpwdgts,-1);
}


main_bind()
{
    cleartext();
    if (*passwd != 0)
    	(void) strcpy(bindpass,"******");
    else
   	bindpass[0] = '\0';
	
    setdialogstr(getwidget(cnnctwdgts, 'p'), bindpass,255);
    setdialogstr(getwidget(cnnctwdgts, 'd'), myname,255);
    setdialogstr(getwidget(cnnctwdgts, 'u'), namestr,255);
    setdialogstr(getwidget(cnnctwdgts, 'c'), cache,255);
    setwidgets(cnnctwdgts, -1);
}

main_goto()
{
    cleartext();
/* If we've got a 'valid' path, then show it and add it to history */
	(void) strcpy(currentpath, goto_path);
	showcurrentpath(currentpath);

}

main_read()
{
    cleartext();
    killwidgets(mainwdgts);
    setdialogstr(getwidget(rdwdgts,'b'),base_path,256);
    (void) strcpy(base_path, currentpath);
    setwidgets(rdwdgts,-1);
}

main_list()
{
    cleartext(); 
    killwidgets(mainwdgts);
    setdialogstr(getwidget(listwdgts,'b'),base_path,256);
    setdialogstr(getwidget(listwdgts,'l'),limit,256);
    (void) strcpy(base_path, currentpath);
    setwidgets(listwdgts,-1);
}

main_search()
{
    cleartext();
    killwidgets(mainwdgts);
    (void) strcpy(base_path, currentpath);
    setdialogstr(getwidget(srchwdgts,'b'),base_path,256);
    setdialogstr(getwidget(srchwdgts,'v'),srchvalue,256);
    setdialogstr(getwidget(srchwdgts,'l'),limit,256);
    settogglstrs(getwidget(srchwdgts,'e'),xtntstrs,1);
    settogglstrs(getwidget(srchwdgts,'t'),filttype,0);
    settogglstrs(getwidget(srchwdgts,'m'),filtmatch,0);
    setwidgets(srchwdgts, -1);
}

main_modify()
{
    cleartext();

    killwidgets(mainwdgts);
    setdialogstr(getwidget(modwdgts,'b'),base_path,256);
    setdialogstr(getwidget(modwdgts,'v'),mvalue,256);
    setdialogstr(getwidget(modwdgts,'t'),mtype,256);
    settogglstrs(getwidget(modwdgts,'o'),mtog,0);
    (void) strcpy(base_path, currentpath);
    setwidgets(modwdgts, -1);

}

cache_quit()
{
	cleartext ();
	eprint ("Sorry can't write cache - not implemented\n");
}

cnnct_help()
{
    cleartext();
    help_connect();
}

cnnct_quit ()
{
	quit (-1);
}

cnnct_bind()
{
struct ds_bind_arg bindarg;
struct ds_bind_arg bindresult;
struct ds_bind_error binderr;
extern  char * dsa_address,
	     * myname;
extern  char * tailfile;
FILE * fp;
char buf [BUFSIZ];

    cleartext();

	/* set dsa_address */
	dsa_address = NULLCP;
	/* read tailor file to get address */
	if( (fp = fopen(isodefile(tailfile), "r")) == (FILE *)NULL) {
		tprint ("Cannot open tailor file %s\n",isodefile(tailfile));
		return;
	}
	while(fgets(buf, sizeof(buf), fp) != NULLCP)
		if ( (*buf != '#') && (*buf != '\n') )
			(void) tai_string (buf);

	(void) fclose(fp);

	if (dsa_address == NULLCP)
		dsa_address = myname;

	/* set password */
	if (bindpass[0] != 0) {
		if (strcmp (bindpass,"******") != 0)
			(void) strcpy (passwd,bindpass);
	} else 
		passwd[0] = 0;
		
	/* now bind */
	bindarg.dba_version = DBA_VERSION_V1988;
	if (passwd[0] == 0) {
		bindarg.dba_passwd_len = 0;
		bindarg.dba_passwd [0] = '\0';
	} else {
		bindarg.dba_passwd_len = strlen (passwd);
		(void) strcpy (bindarg.dba_passwd,passwd);
	}

	if (*namestr == 0)
		bindarg.dba_dn = NULLDN;	
	else
		bindarg.dba_dn = str2dn (namestr);

	if (ds_bind (&bindarg,&binderr,&bindresult) != DS_OK) {
	   if (binderr.dbe_type == DBE_TYPE_SECURITY)
		tprint ("Bind security error - Check name and pasword"); 
	   else
		tprint ("Bind service error - Can't contact DSA"); 
	} else {
		killwidgets (cnnctwdgts);
		setwidgets (mainwdgts,-1);
		user_name = bindarg.dba_dn;
#ifndef NO_STATS
		LLOG (log_stat,LLOG_NOTICE,("bound ('%s' to '%s')",namestr,dsa_address));
#endif
		eprint("Directory Bind Successful.");
	}
}

cnnct_read ()
{
	cleartext();
	eprint ("Sorry - Disk cache not implemented yet\n");
}



/* These are the functions called by the read level widgets */

rd_start()
{
struct ds_read_arg read_arg;
struct ds_read_result   result;
struct DSError          error;
Entry read_entry;
		
    cleartext ();
    hide_picture(); 	

    tprint("Reading attributes of '%s'\n", base_path);

    if ( get_default_service (&read_arg.rda_common) != 0) {
   	eprint ("Default service error -> check your .quipurc\n");
	return ;
    }

	read_arg.rda_eis.eis_allattributes = TRUE;
	read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
	read_arg.rda_eis.eis_select = NULLATTR;
	
	read_arg.rda_object = str2dn(base_path);

	if ((read_entry = local_find_entry (read_arg.rda_object, FALSE)) != NULLENTRY) {
		quipu_print (as_print,(caddr_t)read_entry->e_attributes);
		return;
	}
#ifndef NO_STATS
	LLOG (log_stat,LLOG_NOTICE,("read +%s",base_path));
#endif
	
	if (ds_read (&read_arg,&error,&result) != DS_OK) {
		/* deal with error */
		quipu_error (&error);
	} else {
		/* use data */
		if (result.rdr_entry.ent_attr == NULLATTR) {
			eprint("No attributes");
			return;
		}
		eprint("Result of look up ...\n");
		if (result.rdr_common.cr_aliasdereferenced)
			eprint("Alias dereferenced)\n");

		dn_decode (result.rdr_entry.ent_dn);
		as_decode (result.rdr_entry.ent_attr);
		cache_entry (&(result.rdr_entry),TRUE,TRUE);
		quipu_print (as_print,(caddr_t)result.rdr_entry.ent_attr);
	}
}

rd_help()
{
    cleartext(); 
    help_read();
}

/* These are the functions called by the list level widgets */

list_start()
{

struct ds_list_arg list_arg;

struct ds_list_result   result;
struct DSError          error;
struct subordinate      *ptr;
struct list_cache *cptr;

    cleartext();
    tprint("Listing children of '%s'...\n",base_path);

   if (get_default_service (&list_arg.lsa_common) != 0) {
   	eprint ("Default service error -> check your .quipurc\n");
	return ;
   }

	list_arg.lsa_common.ca_servicecontrol.svc_sizelimit = atoi(limit);

	list_arg.lsa_object = str2dn(base_path);
	
	if ((cptr = find_list_cache (list_arg.lsa_object,list_arg.lsa_common.ca_servicecontrol.svc_sizelimit)) != NULLCACHE) {
		for (ptr=cptr->list_subs;ptr!=NULLSUBORD;ptr=ptr->sub_next) {
			quipu_print (rdn_print,(caddr_t)ptr->sub_rdn);
			eprint("\n");
		}
		if (cptr->list_problem != LSR_NOLIMITPROBLEM)
			eprint("(Limit problem)\n");
        	return;
	}
	
#ifndef NO_STATS
	LLOG (log_stat,LLOG_NOTICE,("list +%s",base_path));
#endif
						               
	if (ds_list (&list_arg,&error,&result) != DS_OK) {
		/* deal with error */
		quipu_error (&error);
	} else {
		/* use data */
		eprint("Result of list operation ...\n");
		if (result.lsr_common.cr_aliasdereferenced) {
			eprint("Alias dereferenced - ");
			dn_decode (result.lsr_object);
			quipu_print (dn_print,(caddr_t)result.lsr_object);
			dn_free (result.lsr_object);
			eprint("\n");
		}
		for (ptr=result.lsr_subordinates;ptr!=NULLSUBORD;ptr=ptr->sub_next) {
			rdn_decode (ptr->sub_rdn);
			quipu_print (rdn_print,(caddr_t)ptr->sub_rdn);
			eprint("\n");
		}
		if (result.lsr_limitproblem != LSR_NOLIMITPROBLEM)
			eprint("(Limit problem)\n");

		cache_list (result.lsr_subordinates, result.lsr_limitproblem,list_arg.lsa_object,
			list_arg.lsa_common.ca_servicecontrol.svc_sizelimit);
	}


}

list_help()
{
    cleartext();
    help_list();
}


/* search ... */

void filt_substr (substr,at,str)
Filter_Substrings * substr;
AttributeType at;
char *str;
{
char * ptr;
AttributeValue av;

    if ((ptr = index (str,'*')) == NULLCP)
    	ptr = str + strlen (str);

    substr->fi_sub_initial = NULLAV;
    substr->fi_sub_any     = NULLAV;
    substr->fi_sub_final   = NULLAV;
    substr->fi_sub_type    = at;

/* This is the 'initial' section of the string - maybe NULL */
    *ptr = '\0';
    str = TidyString (str);
    if (*str != 0) {
	av = str2AttrV (str, at->at_table->oa_syntax);
	substr->fi_sub_initial = avs_comp_new (av);
    }
    str = ptr + 1;

/* Test for whether there are going to be any 'any' bits */
    if ((ptr = rindex(str, '*')) == NULLCP) {
	str = TidyString (str);
	if (*str != 0) {
		av = str2AttrV (str, at->at_table->oa_syntax);
		substr->fi_sub_final = avs_comp_new (av);
	}
	return;
    }

    *ptr = '\0';
    ptr = TidyString (ptr + 1);
    if ( *ptr != 0) {
	av = str2AttrV (str, at->at_table->oa_syntax);
	substr->fi_sub_final = avs_comp_new (av);
	}

/* There are some internal 'any's to be found */
    do {
	if ((ptr = index(str, '*')) != NULLCP)
	    *ptr = '\0';

	if (*str != 0) {
		str = TidyString (str);
			av = str2AttrV (str, at->at_table->oa_syntax);
		if (substr->fi_sub_any == NULLAV)
			substr->fi_sub_any = avs_comp_new (av);
		else
			substr->fi_sub_any = avs_merge (substr->fi_sub_any,avs_comp_new (av));
	}
	if (ptr != NULLCP)
	    str = ptr + 1;
    } while(ptr != NULLCP);
    

}

srch_start()
{
int                     extent;
struct ds_search_arg search_arg;
struct DSError error;
struct ds_search_result result;

   cleartext();

   if (get_default_service (&search_arg.sra_common) != 0) {
   	eprint ("Default service error -> check your .quipurc\n");
	return ;
   }

   tprint ("Searching ...");
   search_arg.sra_common.ca_servicecontrol.svc_sizelimit = atoi(limit);
   search_arg.sra_baseobject = str2dn (base_path);
   search_arg.sra_eis.eis_allattributes = TRUE;
   search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
   search_arg.sra_eis.eis_select = NULLATTR;

   extent = gettogglindx(getwidget(srchwdgts,'e'));
   switch (extent) {
   case 0: search_arg.sra_subset = SRA_BASEOBJECT;
	   break;
   case 1: search_arg.sra_subset = SRA_ONELEVEL;
	   break;
   default:search_arg.sra_subset = SRA_WHOLESUBTREE;
	   break;
   }
   search_arg.sra_filter = filter_alloc ();
   search_arg.sra_filter->flt_next = NULLFILTER;
   search_arg.sra_filter->flt_type = FILTER_ITEM;
   search_arg.sra_filter->FUITEM.fi_type = gettogglindx(getwidget(srchwdgts,'m'));

   switch (search_arg.sra_filter->FUITEM.fi_type) {
   case FILTERITEM_PRESENT:
        search_arg.sra_filter->FUITEM.UNTYPE = AttrT_new (filttype[gettogglindx(getwidget(srchwdgts,'t'))]);
	break;
   case FILTERITEM_SUBSTRINGS: {
	AttributeType at;

	at = AttrT_new (filttype[gettogglindx(getwidget(srchwdgts,'t'))]);
	if ((at->at_table->oa_syntax != AV_CASEEXACTSTRING) || (at->at_table->oa_syntax != AV_CASEIGNORESTRING)) {
		eprint ("Cant do a substring search if the type is not a string !!!");
		return;
	}
   	filt_substr(&search_arg.sra_filter->FUITEM.UNSUB,at,srchvalue);
	break;
   }
   default:
        search_arg.sra_filter->FUITEM.UNAVA.ava_type = AttrT_new (filttype[gettogglindx(getwidget(srchwdgts,'t'))]);
	search_arg.sra_filter->FUITEM.UNAVA.ava_value = str2AttrV (srchvalue,search_arg.sra_filter->FUITEM.UNAVA.ava_type->at_table->oa_syntax);
	break;
   }
#ifndef NO_STATS
	LLOG (log_stat,LLOG_NOTICE,("search +%s, extent %d, val %s",base_path,search_arg.sra_subset,srchvalue));
#endif
   if (ds_search (&search_arg,&error,&result) != DS_OK) {
	/* deal with error */
	quipu_error (&error);
    } else {
	correlate_search_results (&result);
	if (result.CSR_entries != NULLENTRYINFO) {
		 EntryInfo *ptr;
		 eprint ("Result of search ...\n");
		 if (result.CSR_common.cr_aliasdereferenced) {
			 eprint ("(Alias dereferenced - base object is ");
			 dn_decode (result.CSR_object);
			 quipu_print (dn_print ,(caddr_t)result.CSR_object);
			 dn_free (result.CSR_object);
			 eprint (")\n");
		 }
  		 for (ptr = result.CSR_entries; ptr != NULLENTRYINFO; ptr = ptr->ent_next) {
			dn_decode (ptr->ent_dn);
			quipu_print (dn_print,(caddr_t)ptr->ent_dn);
			eprint ("\n");
			cache_entry (ptr,TRUE,TRUE);
		 }

	 } else
		 eprint("Nothing found\n");
 	
	 if (result.CSR_limitproblem != LSR_NOLIMITPROBLEM) {
		if (result.CSR_limitproblem == LSR_TIMELIMITEXCEEDED)
			eprint ("(Time limit exceeded)\n");
		else
			eprint ("(Size limit exceeded)\n");
	 }
    }
}

srch_help()
{
    cleartext();
    help_search();
}

/* modify */

mod_help()
{
    cleartext(); 
    help_modify();
}

mod_start()
{
	struct ds_modifyentry_arg mod_arg;
	struct DSError  error;
	Attr_Sequence   as;
	AttributeType   at;
	AV_Sequence     avst;
	AttributeValue  av;

    cleartext();
    
    if (get_default_service (&mod_arg.mea_common) != 0) {
   	eprint ("Default service error -> check your .quipurc\n");
	return ;
    }

    if ((at = AttrT_new (mtype)) == NULLAttrT) {
    	eprint ("Invalid Attribute Type\n");
	return;
    } 

    if ((av =str_at2AttrV (mvalue,at)) == NULLAttrV) {
	eprint ("invalid Attribute Syntax");
	return;
    }

    if ((avst = avs_comp_new (av)) == NULLAV) {
	eprint ("error in attribute");
	return;
    }
    as = as_comp_new (at,avst,NULLACL_INFO);

    tprint ("Modification at '%s'\n ",base_path);

    switch (gettogglindx(getwidget(modwdgts,'o'))) {
    case 3: /* add value */
    	mod_arg.mea_changes = em_alloc ();
	mod_arg.mea_changes->em_type = EM_ADDVALUES;
	mod_arg.mea_changes->em_what = as;
	mod_arg.mea_changes->em_next = NULLMOD;
        break;
    case 4:
    	mod_arg.mea_changes = em_alloc ();
	mod_arg.mea_changes->em_type = EM_REMOVEVALUES;
	mod_arg.mea_changes->em_what = as;
	mod_arg.mea_changes->em_next = NULLMOD;
	break;
    case 2: /* remove */
	mod_arg.mea_changes = em_alloc ();
	mod_arg.mea_changes->em_type = EM_REMOVEATTRIBUTE;
	mod_arg.mea_changes->em_what = as;
	mod_arg.mea_changes->em_next = NULLMOD;
	break;
    case 1: /* add */
	mod_arg.mea_changes = em_alloc ();
	mod_arg.mea_changes->em_type = EM_ADDATTRIBUTE;
	mod_arg.mea_changes->em_what = as;
	mod_arg.mea_changes->em_next = NULLMOD;
    	break;
    default: /* replace */
    	mod_arg.mea_changes = em_alloc ();
	mod_arg.mea_changes->em_type = EM_REMOVEATTRIBUTE;
	mod_arg.mea_changes->em_what = as;
	mod_arg.mea_changes->em_next = em_alloc ();
	mod_arg.mea_changes->em_next->em_type = EM_ADDATTRIBUTE;
	mod_arg.mea_changes->em_next->em_what = as;
	mod_arg.mea_changes->em_next->em_next = NULLMOD;
    	break;
    }
   mod_arg.mea_object = str2dn (base_path);
   
#ifndef NO_STATS
	LLOG (log_stat,LLOG_NOTICE,("modify %s (%s)",base_path,mtype));
#endif

	if (ds_modifyentry (&mod_arg, &error) != DS_OK) {
		quipu_error (&error);
		return;
	}
	eprint ("Done\n");
	
	/* force re-read to update cache */
	delete_cache (mod_arg.mea_object);
}


quipu_print (func,ptr)
int (*func) ();         /* assumes func (PS ,dataptr,(int) format); */
caddr_t ptr;
{
	/* log info to pstream */
PS ps;
char buffer [RESBUF];
int i;
char *str, *sptr;
char save;

    if ((ps = ps_alloc (str_open)) == NULLPS) {
	return ;
    }
    if (str_setup (ps,buffer,RESBUF,1) == NOTOK) {
	return ;
    }

    (*func) (ps,ptr,READOUT);
    *ps->ps_ptr = 0;

    ps_free (ps);

    /* print in blocks of 100 bytes - larger appears to be too much for curses */
    str = buffer;
    sptr = str + 100;
    for (i=0; i< ps->ps_byteno; i += 100) {
	    save = *sptr;
	    *sptr = 0;
	    eprint (str);
	    *sptr = save;
	    str = sptr;
	    sptr = str + 100;
    }
}

quipu_error (err)
struct DSError * err;
{
PS ps;
char buffer [RESBUF];

    if ((ps = ps_alloc (str_open)) == NULLPS) {
	return ;
    }
    if (str_setup (ps,buffer,RESBUF,1) == NOTOK) {
	return ;
    }
    ds_error (ps,err);

    *ps->ps_ptr = 0;
    eprint (buffer);
}

returnmain ()
{
	QUITFN();
	setwidgets (mainwdgts,-1);
}

/* ARGSUSED */
set_sequence (a)
char * a;
{
;
}

unset_sequence ()
{
;
}