Return to calls.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / quipu / uips / sd

BSD 4.3reno

/* calls.c - */

#ifndef lint
static char *rcsid = "$Header: /var/lib/cvsd/repos/CSRG/43BSDReno/contrib/isode-beta/others/quipu/uips/sd/calls.c,v 1.1.1.1 2018/04/24 16:12:56 root Exp $";
#endif

/*
 * $Header: /var/lib/cvsd/repos/CSRG/43BSDReno/contrib/isode-beta/others/quipu/uips/sd/calls.c,v 1.1.1.1 2018/04/24 16:12:56 root Exp $
 */

/*
 * $Log: calls.c,v $
 * Revision 1.1.1.1  2018/04/24 16:12:56  root
 * BSD 4.3reno
 *
 * Revision 7.2  90/07/27  08:45:41  mrose
 * update
 * 
 * Revision 7.1  90/07/09  14:41:49  mrose
 * sync
 * 
 * Revision 7.0  90/06/12  13:14:03  mrose
 * *** empty log message ***
 * 
 * Revision 1.6  90/04/26  10:36:16  emsrdsm
 * *** empty log message ***
 * 
 * Revision 1.5  90/04/25  15:07:22  emsrdsm
 * i) lint'ed
 * 
 * Revision 1.4  90/04/20  17:57:33  emsrdsm
 * i) no more freeing
 * 
 * Revision 1.3  90/04/18  18:26:06  emsrdsm
 * fixed i) does not move to leaves
 *       ii) added default mechanism described using "typeDefaults" file.
 * 	 iii) added 'sorting' to attribute display
 * 
 * Revision 1.2  90/03/15  16:29:40  emsrdsm
 * fixes i) Prints messages correctly on exit.
 *      ii) Added rfc822 to greybook mailbox conversion
 *     iii) Removed bug that caused crash if 'local_dit' undefined
 * 
 * Revision 1.1  90/03/09  17:40:20  emsrdsm
 * Initial revision
 * 
 * Revision 1.1  90/03/09  13:36:22  emsrdsm
 * Initial revision
 * 
 */

#include "manifest.h"
#include "quipu/util.h"
#include "quipu/common.h"
#include "quipu/entry.h"
#include "usr.dirent.h"
#include "tailor.h"
#include "sequence.h"
#include "filt.h"
#include "y.tab.h"
#include "symtab.h"

#define RESBUF 10000

struct attrcomp * sort_attrs();
static dn2str ();

typedef enum {rfc822, greybook} mailtype;
mailtype mailformat = rfc822;

int scrollize;
PS opt;
Attr_Sequence read_types = 0, read_types2 = 0, oclass = 0;

D_seq dnseq, textseq, back_seq;
table_entry symtab = 0;

int current_entry, entry_number, display_entry;
int back_buf_num;

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"

extern text_height;
int text_state;

#define DN_LIST 0
#define TEXT 1
#define BACK_LIST 3

/* These are common operation variables */
#define STRINGLEN 1000
#define SMALLSTRING 255
#define MAXTYPES  255

char            goto_path[STRINGLEN];         /* Used by the 'G:goto' command*/
char            base_path[STRINGLEN];         /* Used by all DS operations   */
char 		friendly_base_path[STRINGLEN];
char		friendly_name[STRINGLEN];
char            namestr[STRINGLEN];
char            cache [STRINGLEN];
char            bindpass [STRINGLEN];
char            srchvalue[STRINGLEN];         /* Used by search */
char            svalue [STRINGLEN];
char            mvalue [STRINGLEN];

unsigned int curr_filt = 0;
unsigned int filt_num = 0;
unsigned int typeindx = 0;
filt_struct *filt_arr[MAXTYPES];
char	*filtvalue[MAXTYPES];
static char  *filttype[MAXTYPES];

int default_num;
int *av_typeindx;
int *available_types[MAXTYPES];
char  *levels[MAXTYPES];
int  defaults[MAXTYPES];

#ifndef NO_STATS
extern LLog    *log_stat;
#endif 

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

extern int sizelimit;
extern char    *local_dit;
DN user_name;

char * addobj = NULLCP;

Filter search_filter;

FILE *file;
char	       *file_names[MAXTYPES];

char *get_strioid(ptr)
register char *ptr;
{
  register char *end_ptr;

  while(*ptr == '"') ptr++;
  while(*ptr != '"') ptr++;

  while(*ptr > '9' || *ptr < '0') ptr++;

  end_ptr = ptr;
  while(*end_ptr != '\n') end_ptr++;

  *end_ptr = '\0';
  return ptr;
}


user_tailor ()
{
  char           *part1;
  char           *part2;
  char           *getenv ();
  char           *ptr = "/.quipurc";
  char	         *config_dir = "/.duaconfig/";
  char           *isode_config_dir = "sd/duaconfig/";
  char	         *type_dir = "filterTypes/";
  char	         *read_File = "readTypes";
  char           *type_defaults = "typeDefaults";

  char            Dish_Home[BUFSIZ];
  char		  read_Home[BUFSIZ];
  char		  type_Home[BUFSIZ];
  char            type_defaults_Home[BUFSIZ];

  char	          stroid_buf[BUFSIZ];

  DIR 	         *dir;

  struct dirent  *dir_ent;
  
  char            Read_in_Stuff[STRINGLEN];
  char           *p, 
  		 *TidyString(),
  		 *SkipSpace(),
  		 *end;

  int             count, n, num;
  int     tempints[MAXTYPES];

#ifndef NO_STATS
  ll_hdinit (log_stat,"sd");
#endif

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

  namestr[0] = '\0';
  *passwd = '\0';
  cache[0] = '\0';
  currentpath[0] = '\0';

  (void) strcpy (Dish_Home, getenv ("HOME"));
  (void) strcpy(read_Home, Dish_Home);
  (void) strcpy(type_Home, Dish_Home);
  (void) strcpy(type_defaults_Home, Dish_Home);
  
  (void) strcat(Dish_Home, ptr);
  (void) strcat(read_Home, config_dir);
  (void) strcat(read_Home, read_File);
  (void) strcat(type_Home, config_dir);
  (void) strcat(type_Home, type_dir);
  (void) strcat(type_defaults_Home, type_defaults);
	
  if (!(dir = opendir(type_Home))) {
    (void) strcpy(type_Home, isodefile(isode_config_dir,0));
    (void) strcat(type_Home, type_dir);
    if(!(dir = opendir(type_Home))) {
      quit("Can't find directory filterTypes.\n", 1);
    }
  }

  rewinddir(dir);
  filt_num = 0;
  while(dir_ent = readdir(dir)) {
    if (!(strncmp(dir_ent->d_name, "Type_", 5))) {
      file_names[filt_num] = 
	(char *) malloc(strlen(dir_ent->d_name) + strlen(type_Home) + 2);
      (void) strcpy(file_names[filt_num], type_Home);
      (void) strcat(file_names[filt_num], dir_ent->d_name);
      filt_num++;
    }
  }
  (void) closedir(dir);
  
  if ((file = fopen (Dish_Home, "r")) == 0);
  else {
    while (fgets (Read_in_Stuff, STRINGLEN, 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 (strcmp(part1, "prefergreybook") == 0)
	mailformat = greybook;
      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;
	(void) isodesetvar (part2,split,0);
	}
      } else if (strcmp (part1, "service") == 0) 
	new_service (part2);
    }
    isodexport (NULLCP);
    (void) fclose(file);
  }

  if (!(file = fopen(read_Home, "r"))) {
    (void) strcpy(read_Home, isodefile(isode_config_dir,0));
    (void) strcat(read_Home, read_File);
    if (!(file = fopen(read_Home, "r"))) {
      quit("Can't find file readTypes.\n", 1);
    }
  }
  load_oid_table("oidtable");
  
  while(fgets(Read_in_Stuff, STRINGLEN, file) != 0) {
    (void) strcpy(stroid_buf, get_strioid(Read_in_Stuff));
    if (*stroid_buf) {
      if (!read_types)
	read_types = as_comp_new(AttrT_new(stroid_buf), NULLAV, NULLACL_INFO);
      else {
	read_types2 = as_comp_new(AttrT_new(stroid_buf) ,NULLAV, NULLACL_INFO);
	read_types = as_merge(read_types, read_types2);
      }
    }
  }
  (void) fclose(file);
  
  for (curr_filt = 0; curr_filt < filt_num; curr_filt++) {
    if (!(file = fopen(file_names[curr_filt], "r"))) {
      quit("Can't find filter template file\n", 1);
    }
    filtvalue[curr_filt] = (char *) malloc(STRINGLEN);
    *filtvalue[curr_filt] = '\0';
    
    (void) yyparse();
    (void) fclose(file);
  }
  filttype[curr_filt] = NULLCP;
  for (count = 0; count < filt_num; count++)
    free(file_names[count]);

  if (!(file = fopen(type_defaults_Home, "r"))) {
    (void) strcpy(type_defaults_Home, isodefile(isode_config_dir,0));
    (void) strcat(type_defaults_Home, type_defaults);
    if (!(file = fopen(type_defaults_Home, "r"))) {
      (void) strcpy(type_defaults_Home, "./sd/duaconfig/");
            (void) strcat(type_defaults_Home, type_defaults);
      if (!(file = fopen(type_defaults_Home, "r"))) {
        (void) fprintf(stderr, "Can't open typeDefaults file\n");
        quit(1);
      }
    }
  }

  default_num = 0;
  while (fgets (Read_in_Stuff, STRINGLEN, file) != 0) {
    p = SkipSpace(Read_in_Stuff);
    if (( *p == '#') || (*p == '\0'))
      continue;

    part1 = p;
    if ((part2 = index (p,':')) == NULLCP)
      continue;

    end = part2 - 1;
    while (isspace(*end)) end--;
    *++end = '\0';

    *part2++ = '\0';

    while (isspace(*part2)) part2++;
    end = part2;

    while (!isspace(*end) && *end != ',' && *end != ':') end++;

    count = 0;
    while (*part2 != ':') {
      n = 0;
      while (n < filt_num && strncmp(filttype[n], part2,
                                    (int) (end - part2))) n++;

      if (n == filt_num) {
        (void) fprintf(stderr, "Parsing error in typeDefaults file!");
	quit(1);
      } else {
        tempints[count] = n;
        count++;
        part2 = end;
        while (!isalpha(*part2) && *part2 != ':' && part2 != '\0') part2++;

        if (*part2 == '\0') {
          (void) fprintf(stderr, "Parsing error in typeDefaults file!");
          quit(1);
        }

        if (*part2 != ':') {
          while (!isalpha(*part2)) part2++;
          end = part2;
          while (!isspace(*end) && *end != ',' &&
                 *end != ':' && *end != '\0') end++;
          if (*end == '\0') {
            (void) fprintf(stderr, "Parsing error in typeDefaults file!");
            quit(1);
          }
        } else end = part2;
      }
    }
    if (*end == ':') {
      while(isspace(*++end));
      p = end;
      while(!isspace(*++end));
      *end = '\0';

      n = 0;
      while (n < filt_num && strcmp(filttype[n], p)) n++;

      if (n == filt_num) {
        (void) fprintf(stderr, "Parsing error in typeDefaults file!");
        quit(1);
      } else {
        num = 0;
        while (num < count && n != tempints[num]) num++;
        if (num == count) {
          (void) fprintf(stderr, "Parsing error in typeDefaults file!");
          quit(1);
        }
      }

      defaults[default_num] = n;

      levels[default_num] = malloc(strlen(part1) + 1);
      (void) strcpy(levels[default_num], part1);
      available_types[default_num] =
        (int *) malloc(sizeof(int) * (count+1));

      for (n = 0; n < count; n++)
        available_types[default_num][n] = tempints[n];

      available_types[default_num][n] = -1;
      default_num++;
    }
  }
}

make_type(name_val, filt)
char * name_val;
filt_struct * filt;
{
  filttype[curr_filt] = (char *) malloc(strlen(name_val) + 1);
  (void) strcpy(filttype[curr_filt], name_val);
  
  filt_arr[curr_filt] = filt;
}

filt_struct *
make_item_filter(oid, match, value)
char *oid;
int match;
char *value;
{
  register filt_struct * filt = (filt_struct *) malloc(sizeof(filt_struct));
  
  filt->flt_type = ITEM;
  filt->next = 0;
  
  filt->fu_cont.item.fi_type = match;
  filt->fu_cont.item.stroid = (char *) malloc(strlen(oid) + 1);
  (void) strcpy(filt->fu_cont.item.stroid, oid);
  
  if (*value == '*') filt->fu_cont.item.name = (char *) 0;
  else {
    filt->fu_cont.item.name = (char *) malloc(strlen(value) + 1);
    (void) strcpy(filt->fu_cont.item.name, value);
  }
  return filt;
}

filt_struct *
link_filters(filt1, filt2)
filt_struct *filt1;
filt_struct *filt2;
{
  filt1->next = filt2;
  return filt1;
}

filt_struct *
make_parent_filter(filt_type, filt1, filt2, filt3)
int filt_type;
filt_struct * filt1;
filt_struct * filt2;
filt_struct * filt3;
{
  filt_struct * parent = (filt_struct *) malloc(sizeof(filt_struct));

  switch (filt_type) {

  case NOT:
    parent->flt_type = NOT;
    parent->fu_cont.sub_filt = filt1;
    parent->next = 0;
    break;

  case AND:
    parent->flt_type = AND;
    parent->fu_cont.sub_filt = filt1;
    filt1->next = filt2;
    filt2->next = filt3;
    parent->next = 0;
    break;

  default:
    parent->flt_type = OR;
    parent->fu_cont.sub_filt = filt1;
    filt1->next = filt2;
    filt2->next = filt3;
    parent->next = 0;
    break;
  }

  return parent;
}

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

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

main_bind()
{
  cleartext();
  if (*passwd != 0)
    (void) strcpy(bindpass,"******");
  else
    bindpass[0] = '\0';
}

cnnct_quit ()
{
  quit("Exiting sd.\n", 0);
}

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];

  /* set dsa_address */
  dsa_address = NULLCP;
  /* read tailor file to get address */
  if( (fp = fopen(isodefile(tailfile,0), "r")) == (FILE *)NULL) {
    tprint ("Cannot open tailor file %s\n",isodefile(tailfile,0));
    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);
  }
  
  bindarg.dba_dn = (*namestr == 0? NULLDN: str2dn(namestr));

  if (ds_bind (&bindarg,&binderr,&bindresult) != DS_OK) {
    if (binderr.dbe_type == DBE_TYPE_SECURITY)
      quit("Bind security error - Check name and pasword.\n", 0);
    else 
      quit("Bind service error - Can't contact DSA!\n", 1);
  } else {
    setdialogstr(getwidget(mainwdgts, '\0'), friendly_base_path, STRINGLEN);
    setdialogstr(getwidget(mainwdgts, 's'), mvalue, STRINGLEN);
    setdialogstr(getwidget(mainwdgts, '*'), srchvalue, 6);
    settogglstrs(getwidget(mainwdgts, 't'), filttype, 0);
    setwidgets (mainwdgts,-1);
    user_name = bindarg.dba_dn;

    if(local_dit && *local_dit)
      (void) strcpy(base_path, local_dit);
    else 
      (void) strcpy(base_path, "The World");

    oclass = as_comp_new(AttrT_new("objectClass"), NULLAV, NULLACL_INFO);
    make_friendly(friendly_base_path, base_path);
    printdialog(getwidget(mainwdgts,'\0'));
    set_default_type();

    (void) strcpy (buf, "TERM");

#ifndef NO_STATS
    LLOG (log_stat,LLOG_NOTICE,("bound ('%s' to '%s')",namestr,dsa_address));
#endif
#ifndef NO_STATS
    LLOG (log_stat,LLOG_NOTICE,("sd called from a ('%s')", getenv(buf)));
#endif
  }
  display_entry = current_entry = 1;
  entry_number = 0;
  back_buf_num = 0;
  textseq = back_seq = dnseq = NULLDS;
  text_state = TEXT;
}

rd_start()
{
  struct ds_read_arg read_arg;
  struct ds_read_result   result;
  struct DSError          error;
  Entry read_entry;
  
  cleartext();
  if (*friendly_base_path == 'T') {
    free_seq(textseq);
    if (text_state == DN_LIST) free_seq(dnseq);
    dnseq = textseq = NULLDS;
    text_state = TEXT;
    entry_number  = 0;
    return;
  }

  xprint("Reading data on ");
  xprint(friendly_base_path);
  xprint(".\n");
  tprint("Chugging along.....");

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

  read_arg.rda_common.ca_servicecontrol.svc_options = 1;
  read_arg.rda_eis.eis_allattributes = FALSE;
  read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
  read_arg.rda_eis.eis_select = read_types;

  read_arg.rda_object = (*friendly_base_path != 'T'? str2dn(base_path): NULLDN);
  if ((read_entry = 
       local_find_entry (read_arg.rda_object, FALSE)) != NULLENTRY) {
    read_entry->e_attributes = sort_attrs(read_entry->e_attributes);
    read_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 */
    cleartext();
    xprint("Read error due to:\n");
    quipu_error(&error);
  } else {
    /* use data */
    if (result.rdr_entry.ent_attr == NULLATTR) {
      free_seq(textseq);
      if (text_state == DN_LIST) free_seq(dnseq);
      dnseq = textseq = NULLDS;
      entry_number = 0;
      text_state = TEXT;
      xprint("No attributes");
      return;
    }
    xprint("Result of look up ...\n");
    if (result.rdr_common.cr_aliasdereferenced)
      xprint("Alias dereferenced)\n");
    
    result.rdr_entry.ent_attr = sort_attrs(result.rdr_entry.ent_attr);
    cache_entry(&(result.rdr_entry), TRUE, TRUE);
    read_print(as_print, (caddr_t) result.rdr_entry.ent_attr);
  }
}

back_start()
{
  if (!back_buf_num) {
    cleartext();
    tprint("You haven't been anywhere yet!\n");
    sleep(3);
    scrollbar('\0');
    return;
  }

  if (text_state == DN_LIST) free_seq(dnseq);

  free_seq(textseq);
  textseq = NULLDS;
  dnseq = back_seq;
  text_state = BACK_LIST;
  entry_number = back_buf_num;
  current_entry = display_entry = 1;
  scrollbar('\0');
}

widen()
{
  register char *str, *sptr;
  int count = 0;

  str = get_from_seq(count+1, back_seq);
  while (count < back_buf_num && strcmp(str, base_path)){
    count++;
    str = get_from_seq(count+1, back_seq);
  }	
  if (count == back_buf_num) {
    add_seq(&back_seq, base_path);
    back_buf_num++;
  }

  str = base_path;
  if (*str != 'T') {

    for (sptr = str; *sptr != '\0'; sptr++)
      if (*sptr == '@')	str = sptr;

    sptr = str;
    typetoggled = 0;

    if (str != base_path) {
      if (*--sptr == ' ')
	str = sptr;
      *str = '\0';
    } else
      (void) strcpy(base_path, "The World");

    make_friendly(friendly_base_path, base_path);
    set_default_type();
    printdialog(getwidget(mainwdgts, '\0'));
    rd_start();
  }
}

set_default_type()
{
  int count, lastindx;
  WIDGET *wdgt, *vwdgt;
  DN base_name;

  wdgt = getwidget(mainwdgts,'t');
  vwdgt = getwidget(mainwdgts, 's');

  if (av_typeindx)
    lastindx = wdgt->tindx;
  else
    lastindx = 0;

  if (*base_path != 'T') {
    if (!typetoggled) {
      base_name = str2dn(base_path);
      while (base_name->dn_parent) base_name = base_name->dn_parent;
      for (count = 0; count < default_num &&
	   strcmp(levels[count] ,base_name->dn_rdn->rdn_at->
		  oa_ot.ot_stroid);
	   count++);
      
      if (count < default_num) {
	av_typeindx = available_types[count];
	typeindx = defaults[count];
      } else {
	av_typeindx = available_types[0];
	typeindx = defaults[0];
      }
      count = typeindx;

      if (count < filt_num) {
	if (lastindx)
	  (void) strcpy(filtvalue[lastindx], vwdgt->dstr);
	wdgt->tindx = count;
	(void) strcpy(vwdgt->dstr, filtvalue[wdgt->tindx]);
      }
    } 
  } else {
    for(count = 0; count < default_num && strcmp(levels[count], "@"); count++);
    if (count < default_num) {
      av_typeindx = available_types[count];
      typeindx = defaults[count];
    } else {
      av_typeindx = available_types[0];
      typeindx = defaults[0];
    }
    count = typeindx;
    if (count < filt_num) {
      if (lastindx)
	(void) strcpy(filtvalue[lastindx], vwdgt->dstr);
      wdgt->tindx = count;
      (void) strcpy(vwdgt->dstr, filtvalue[wdgt->tindx]);
    }
  }

  make_friendly(friendly_base_path, base_path);
  typetoggled = 0;
  printtoggle(wdgt);
  printdialog(vwdgt);
}

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

list_start()
{
  struct ds_search_arg search_arg;
  struct ds_search_result result;
  struct DSError          error;

  cleartext();
  xprint("OK, listing.\n");
  tprint("Chugging along.....");

  if (get_default_service (&search_arg.sra_common) != 0) {
    xprint ("Default service error -> check your .quipurc\n");
    return ;
  }
  
  search_arg.sra_common.ca_servicecontrol.svc_sizelimit = sizelimit;
  search_arg.sra_common.ca_servicecontrol.svc_options = 1;
  search_arg.sra_baseobject = (*base_path != 'T'?
			       str2dn (base_path):
			       NULLDN);
  search_arg.sra_eis.eis_allattributes = FALSE;
  search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
  search_arg.sra_eis.eis_select = read_types;
  search_arg.sra_subset = SRA_ONELEVEL;

  search_arg.sra_filter = filter_alloc();
  search_arg.sra_filter->flt_type = FILTER_NOT;
  search_arg.sra_filter->flt_next = NULLFILTER;
  search_arg.sra_filter->flt_un.flt_un_filter = filter_alloc();
  search_arg.sra_filter->flt_un.flt_un_filter->flt_type = FILTER_ITEM;
  search_arg.sra_filter->flt_un.flt_un_filter->flt_next = NULLFILTER;
  search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.fi_type
    = FILTERITEM_EQUALITY;

  search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.fi_un.
    fi_un_ava.ava_type = AttrT_new("2.5.4.0");

  search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.fi_un.
    fi_un_ava.ava_value = 
      str2AttrV("dsa", search_arg.sra_filter->flt_un.flt_un_filter->
		flt_un.flt_un_item.fi_un.fi_un_ava.ava_type->
		oa_syntax);

  if (search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.
      fi_un.fi_un_ava.ava_value == NULLAttrV) {
    cleartext();
    xprint("No can do. Sorry!");
  } else if (ds_search (&search_arg,&error,&result) != DS_OK) {
    /* deal with error */
    free_seq(textseq);
    if (text_state == DN_LIST) free_seq(dnseq);
    dnseq = textseq = NULLDS;
    text_state = TEXT;
    entry_number = 0;
    cleartext();
    xprint("Search error due to:\n");
    quipu_error(&error);
  } else {
    cleartext();
    correlate_search_results (&result);
    if (result.CSR_entries != NULLENTRYINFO) {
      register EntryInfo *ptr;
      
      xprint ("Result of search ...\n");
      if (result.CSR_common.cr_aliasdereferenced) {
	xprint ("(Alias dereferenced -  object is ");
	quipu_print (dn_print, (caddr_t) result.CSR_object);
	dn_free (result.CSR_object);
	xprint (")\n");
      }

      if (text_state == DN_LIST) free_seq(dnseq);
      free_seq(textseq);
      dnseq = textseq = NULLDS;
      display_entry = current_entry = 1;
      entry_number = 0;
      text_state = DN_LIST;

      for (ptr = result.CSR_entries; ptr != NULLENTRYINFO;
	   ptr = ptr->ent_next) {
	entry_number++;
	dn2str ((caddr_t)ptr->ent_dn, goto_path);
	add_seq (&dnseq, goto_path);
	cache_entry (ptr,TRUE,TRUE);
      }
      scrollbar('\0');
    } else if (result.CSR_limitproblem != LSR_TIMELIMITEXCEEDED) {
      free_seq(textseq);
      if (text_state == DN_LIST) free_seq(dnseq);
      dnseq = textseq = NULLDS;
      entry_number  = 0;
      text_state = TEXT;
      xprint("Nothing found");
    }

    if(result.CSR_limitproblem != LSR_NOLIMITPROBLEM) {
      if(result.CSR_limitproblem == LSR_TIMELIMITEXCEEDED) {
	free_seq(textseq);
	if (text_state == DN_LIST) free_seq(dnseq);
	dnseq = textseq = NULLDS;
	entry_number = 0;
	text_state = TEXT;
	xprint("(Time limit exceeded)");
      } else
	xprint("(Size limit exceeded)");
    }

    entryinfo_free(result.CSR_entries, 0);
  }

  filter_free(search_arg.sra_filter);
}

rdn2str(ptr,cptr)
caddr_t ptr;
char * cptr;
{
  PS ps;
  char buffer [RESBUF];
  
  if ((ps = ps_alloc(str_open)) == NULLPS) {
    return ;
  }
  if (str_setup(ps, buffer, RESBUF, 1) == NOTOK) {
    return ;
  }
  rdn_print(ps, (RDN) ptr, READOUT);
  
  ps_free(ps);
  *ps->ps_ptr = 0;
  
  (void) strcpy(cptr, buffer);
}


/* search ... */

Filter
make_filter(filt)
filt_struct *filt;
{
  int type, count;
  char *value;
  Filter rfilt, sfilt = filter_alloc();
  
  if (!filt)
    return (Filter) 0;
  
  switch(filt->flt_type) {

  case ITEM:
    sfilt->flt_type = FILTER_ITEM;
    sfilt->flt_next = make_filter(filt->next);
    
    if (strcmp(filt->fu_cont.item.stroid, "2.5.4.4"))
      (void) strcpy(svalue, (filt->fu_cont.item.name?
                             filt->fu_cont.item.name:
                             mvalue));
    else if (!filt->fu_cont.item.name) {
      count = strlen(mvalue);
      value = mvalue + count - 1;

      while(!isalpha(*value) && value > mvalue) value--;
      while (!isspace(*value) && value > mvalue) value--;

      if (mvalue < value) (void) strcpy(svalue, ++value);
      else (void) strcpy(svalue, mvalue);
    } else (void) strcpy(svalue, filt->fu_cont.item.name);
    type = filt->fu_cont.item.fi_type;

    switch(type) {
    case APPROX:
    case EQUAL:
      sfilt->flt_un.flt_un_item.fi_un.fi_un_ava.ava_type =
        AttrT_new(filt->fu_cont.item.stroid);

      if ((sfilt->flt_un.flt_un_item.fi_un.fi_un_ava.ava_value =
           str2AttrV(svalue,
                     sfilt->flt_un.flt_un_item.fi_un.fi_un_ava.ava_type->
                     oa_syntax)) == NULL) {

        rfilt = sfilt->flt_next;
        sfilt->flt_next = NULLFILTER;
        filter_free(sfilt);
        return rfilt;
      }

      if (type == EQUAL)
        sfilt->flt_un.flt_un_item.fi_type = FILTERITEM_EQUALITY;
      else
        sfilt->flt_un.flt_un_item.fi_type = FILTERITEM_APPROX;

      break;

    case SUBSTRING:
      sfilt->flt_un.flt_un_item.fi_type = FILTERITEM_SUBSTRINGS;
      sfilt->flt_un.flt_un_item.fi_un.fi_un_substrings.fi_sub_type =
        AttrT_new(filt->fu_cont.item.stroid);

      sfilt->flt_un.flt_un_item.fi_un.fi_un_substrings.fi_sub_initial =
        NULLAV;
      sfilt->flt_un.flt_un_item.fi_un.fi_un_substrings.fi_sub_final =
        NULLAV;
      sfilt->flt_un.flt_un_item.fi_un.fi_un_substrings.fi_sub_any =
        avs_comp_new(str2AttrV(svalue,
                               sfilt->flt_un.flt_un_item.fi_un.
                               fi_un_substrings.fi_sub_type->
                               oa_syntax));
      break;
      
    default:
      sfilt->flt_un.flt_un_item.fi_type = FILTERITEM_APPROX;
      break;
    }
    return sfilt;
    break;
    
  case AND:
    sfilt->flt_type = FILTER_AND;
    sfilt->flt_un.flt_un_filter = make_filter(filt->fu_cont.sub_filt);
    sfilt->flt_next = make_filter(filt->next);
    return sfilt;
    break;
    
  case OR:
    sfilt->flt_type = FILTER_OR;
    sfilt->flt_un.flt_un_filter = make_filter(filt->fu_cont.sub_filt);
    sfilt->flt_next = make_filter(filt->next);
    return sfilt;
    break;

  case NOT:
    sfilt->flt_type = FILTER_NOT;
    sfilt->flt_next = make_filter(filt->next);
    sfilt->flt_un.flt_un_filter = make_filter(filt->fu_cont.sub_filt);
    return sfilt;
    break;

  default:
    return NULLFILTER;
  }
}


srch_start()
{
  struct ds_search_arg search_arg;
  struct ds_search_result result;
  struct DSError          error;
  WIDGET *wdgt;
  char *str = base_path;

  if (*mvalue == '\0') {
    list_start();
    return;
  }
  
  cleartext();
  xprint("OK. Starting search.\n");
	tprint("Chugging along.....");

  wdgt = getwidget(mainwdgts,'t');
  
  if (get_default_service (&search_arg.sra_common) != 0) {
    xprint ("Default service error -> check your .quipurc\n");
    return ;
  }
  
  search_arg.sra_common.ca_servicecontrol.svc_options = 1;
  search_arg.sra_common.ca_servicecontrol.svc_sizelimit = sizelimit;
  search_arg.sra_baseobject = (*base_path != 'T'? 
			       str2dn (base_path):
			       NULLDN);
  search_arg.sra_eis.eis_allattributes = FALSE;
  search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
  search_arg.sra_eis.eis_select = read_types;
  
  while (*str != '\0' && *str != '@') str++;
  
  search_arg.sra_subset = ((*base_path != 'T' && *str == '@')?
			 SRA_WHOLESUBTREE:
			 SRA_ONELEVEL); 
  search_arg.sra_filter =
    make_filter(filt_arr[gettogglindx(wdgt)]);

#ifndef NO_STATS
  LLOG (log_stat,LLOG_NOTICE,("search +%s, extent %d, val %s",base_path,search_arg.sra_subset,mvalue));
#endif

  if(ds_search (&search_arg,&error,&result) != DS_OK) {
    /* deal with error */
    free_seq(textseq);
    if (text_state == DN_LIST) free_seq(dnseq);
    dnseq = textseq = NULLDS;
    entry_number = 0;
    text_state = TEXT;
    cleartext();
    xprint(" Search error due to:\n ");
    quipu_error(&error);
  } else {
    cleartext();
    correlate_search_results (&result);

    if (result.CSR_entries != NULLENTRYINFO) {
      register EntryInfo *ptr;

      if (result.CSR_common.cr_aliasdereferenced) {
	xprint (" (Alias dereferenced - object is ");
	quipu_print (dn_print, (caddr_t) result.CSR_object);
	dn_free (result.CSR_object);
	xprint (")\n");
      }

      if (text_state == DN_LIST) free_seq(dnseq);
      free_seq(textseq);
      dnseq = textseq = NULLDS;
      display_entry = current_entry = 1;
      entry_number = 0;
      text_state = DN_LIST;

      for (ptr = result.CSR_entries; 
	   ptr != NULLENTRYINFO; ptr = ptr->ent_next){
	entry_number++;
	dn2str ((caddr_t) ptr->ent_dn, goto_path);
	add_seq (&dnseq, goto_path);
	cache_entry (ptr,TRUE,TRUE);
      }

      if (entry_number != 1)
	scrollbar('\0');
      else {
	if  (!isleaf(goto_path)) {
	  get_listed_object('1', 0);
	} else {
	  char temp[1024];
	  (void) strcpy(temp, base_path);
	  (void) strcpy(base_path, goto_path);
	  rd_start();
	  (void) strcpy(base_path, temp);
	}
      }
    } else if(result.CSR_limitproblem != LSR_TIMELIMITEXCEEDED) {
      free_seq(textseq);
      if (text_state == DN_LIST) free_seq(dnseq);
      dnseq = textseq = NULLDS;
      entry_number = 0;
      text_state = TEXT;
      xprint("Nothing found using current search parameters. Sorry!\n");
    }
    
    if(result.CSR_limitproblem != LSR_NOLIMITPROBLEM)
      if(result.CSR_limitproblem == LSR_TIMELIMITEXCEEDED) {
	free_seq(textseq);
	if (text_state == DN_LIST) free_seq(dnseq);
	dnseq = textseq = NULLDS;
	entry_number = 0;
	text_state = TEXT;
	xprint("(Time limit exceeded)");
      } else
	xprint("(Size limit exceeded)");
    
    entryinfo_free(result.CSR_entries, 0);
  }

  filter_free(search_arg.sra_filter);
}

static dn2str (ptr,cptr)
caddr_t ptr;
char * cptr;
{
  PS ps;
  char buffer [RESBUF];
  
  if((ps = ps_alloc(str_open)) == NULLPS) return ;

  if(str_setup(ps, buffer, RESBUF, 1) == NOTOK) return ;
  
  dn_print(ps, (DN) ptr, EDBOUT);
  *ps->ps_ptr = 0;
  
  ps_free (ps);

  (void) strcpy(cptr, buffer);
}


read_print(func,ptr)
int (*func) ();
caddr_t ptr;
{
  PS ps;
  char buffer [RESBUF];
  char save;
  int i, size;
  register char *str, *sptr;
  
  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);
  str = buffer ;
  sptr = str;
  size = strlen(buffer);
  
  if (text_state == DN_LIST) free_seq(dnseq);
  dnseq = NULLDS;
  free_seq(textseq);
  textseq = NULLDS;
  display_entry = current_entry = 1;
  entry_number = 0;
  text_state = TEXT;
  
  for (i = 0; i <= size; i++, sptr++)
    if (*sptr == '\n' || *sptr == '\0') {
      entry_number++;
      save = *sptr ;
      *sptr = '\0';

      if (mailformat == greybook && indexstring(str, "rfc822") >= 0)
        (void) rfc2jnt(str);
      add_seq(&textseq, str);

      str = sptr+1;
      *sptr = save;
    }

  scrollbar('\0');
}

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 count;
  register 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 seems too much for curses*/
  str = buffer;
  do {
    for (count = 0, sptr = str; *sptr != '\0' &&
	 count < 100; sptr++, count++);
    save = *sptr;
    *sptr = 0;
    xprint (str);
    *sptr = save;
    str = sptr;
  } while (*sptr != '\0');
}

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;
  xprint(buffer);
}

returnmain()
{
  QUITFN();
  setwidgets (mainwdgts,-1);
  rd_start();
  scrollbar('\0');
}

free_filt(filt)
filt_struct *filt;
{
  if (filt) {
    free_filt(filt->next);

    if (filt->flt_type = ITEM) {
      free(filt->fu_cont.item.stroid);
      if (filt->fu_cont.item.name) free(filt->fu_cont.item.name);
    } else 
      free_filt(filt->fu_cont.sub_filt);

    free(filt);
  } else 
    return;
}

get_listed_object(number, wdgt)
char number;
WIDGET *wdgt;
{
  int entrynum, count = 0;
  char *sptr, *str;
  char buffer[1024];
  
  if (text_state != DN_LIST && text_state != BACK_LIST) {
    *wdgt->dstr = '\0';
    printdialog(wdgt);
    return;
  }
  
  *srchvalue = number;
  *(srchvalue+1) = '\0';

  if (wdgt) {
    printdialog(wdgt);
    dialog(wdgt);
  }
  
  entrynum = atoi(srchvalue);

  if (entrynum > entry_number) {
    *wdgt->dstr = '\0';
    printdialog(wdgt);
    return;
  }

  if (sptr = get_from_seq (entrynum, dnseq)) 
    if(!isleaf(sptr)) {
      cleartext();
      str = get_from_seq(count+1, back_seq);
      
      while (count < back_buf_num && strcmp(str, base_path)){
	count++;
	str = get_from_seq(count+1, back_seq);
      }
      
      if (count == back_buf_num) {
	add_seq(&back_seq, base_path);
	back_buf_num++;
      }
      
      (void) strcpy(base_path, sptr);
      make_friendly(friendly_base_path, base_path);
      wdgt = getwidget(mainwdgts, '\0');
      printdialog(wdgt);
      rd_start();
      typetoggled = 0;
      set_default_type();
    } else {
      (void) strcpy(buffer, base_path);
      (void) strcpy(base_path, sptr);
      make_friendly(friendly_base_path, base_path);
      rd_start();
      (void) strcpy(base_path, buffer);
    }
  *srchvalue = '\0';
}

scrollbar(command)
char command;
{
  register char *str;
  char *base_rdn;
  register int rdn_count = 0;
  int lines, count = 0;
  D_seq thisseq;
  
  if (!entry_number)
    return 0;
  
  if(command == '[') {
    if(display_entry >= entry_number)
      return;

    for (count = 0; (display_entry + count) < entry_number && 
	 count < text_height/2; count++);

    current_entry += count;
  } else if(command == ']') {

    for (count = 0; (current_entry - count) > 1 && 
	 count < text_height/2; count++);

    current_entry -= count;
  }
  
  cleartext();
  
  switch(text_state) {

  case BACK_LIST:
    thisseq = back_seq;
    break;

  case DN_LIST:
    base_rdn = base_path;
    while(*base_rdn != '\0') {
      if(*base_rdn == '@')
	rdn_count++;
      base_rdn++;
    }
    if (*base_path != 'T') rdn_count++;
    thisseq = dnseq;
    break;

  case TEXT:
    thisseq = textseq;
    break;
  }
  
  if (current_entry > entry_number) 
    current_entry = 1;
  
  lines = linec()-2;
  count = 0;
  
  for (display_entry = current_entry; display_entry <= entry_number 
       && gety() < lines; display_entry++) {

    if (text_state == DN_LIST || text_state == BACK_LIST)
      xprintint(" %d ", display_entry) ;
    
    base_rdn = str = get_from_seq(display_entry, thisseq);

    if (text_state == DN_LIST && rdn_count) {
      while (rdn_count) {
	if (*str == '@') rdn_count--;
	str++;
      }

      while(*str == ' ') str++;
      count = (int) (str - base_rdn);

    } else if (count) str += count;
    
    if (str) {
      if (text_state != TEXT) {
	make_friendly(friendly_name, str);
	xprint(friendly_name);
      } else
	xprint(str);
      xprint("\n");
    }
  }

  if (text_state == DN_LIST)
    if (current_entry >= entry_number) xprint("<List finished>");
    else        xprintint("<Total of %d entries>", entry_number);

  printbar(entry_number, current_entry, display_entry-current_entry);
  display_entry--;
  return 1;
}

make_friendly(fstr, str)
char *fstr;
register char *str;
{
  register char *end_ptr;
  char save;
  
  *fstr = '\0';
  if (!strcmp(str, "The World")) {
    (void) strcpy(fstr, str);
    return;
  }

  while (*str != '\0') {
    while (*str != '=') str++;
    while (*str == ' ') str++;

    end_ptr = ++str;
    while (*end_ptr != '@' && *end_ptr != '\0') end_ptr++;
    save = *end_ptr;
    *end_ptr = '\0';
    if (*fstr == '\0')
      (void) strcpy(fstr, str);
    else
      (void) strcat(fstr, str);
    *end_ptr = save;
    str = end_ptr;
    if (*str != '\0')
      (void) strcat(fstr, ", ");
  }
}
  
  
goto_addr()
{
  set_default_type();
  rd_start();
}

int
isleaf(name)
char *name;
{
  struct ds_list_arg list_arg;
  struct ds_list_result   list_result;

  struct ds_read_arg read_arg;
  struct ds_read_result   read_result;

  struct DSError          list_error, read_error;
  char entry_str[1024];

  if (get_default_service (&read_arg.rda_common) != 0) return(1);

  read_arg.rda_common.ca_servicecontrol.svc_options = 1;
  read_arg.rda_eis.eis_allattributes = FALSE;
  read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
  read_arg.rda_eis.eis_select = oclass;

  read_arg.rda_object = (*name? str2dn(name): NULLDN);
  if (ds_read (&read_arg,&read_error,&read_result) != DS_OK) return(1);
  else {
    if (read_result.rdr_entry.ent_attr == NULLATTR) return(0);
    entry2str((caddr_t) read_result.rdr_entry.ent_attr, entry_str, 1024);
    if (issubstr(entry_str, "NonLeaf")) return(0);
  }
  if (get_default_service (&list_arg.lsa_common) != 0) return(1);

  list_arg.lsa_common.ca_servicecontrol.svc_sizelimit = 1;
  list_arg.lsa_common.ca_servicecontrol.svc_options = 1;

  if (*name) 
    list_arg.lsa_object = str2dn(name);
  else
    list_arg.lsa_object = NULLDN;

  if (ds_list (&list_arg,&list_error,&list_result) != DS_OK) 
    return (1);
  else {
    if (list_result.lsr_subordinates == NULLSUBORD) return(1);
    else return(0);
  }
}

entry2str(ptr, cptr, size)
caddr_t ptr;
char *cptr;
int size;
{
  PS ps;

  if ((ps = ps_alloc (str_open)) == NULLPS) return ;
  if (str_setup (ps, cptr, size, 1) == NOTOK) return ;

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

  ps_free(ps);
}

int issubstr(str, substr)
char *str;
char *substr;
{
  register char *sptr;
  char c;
  int substrlen = strlen(substr);
  int count;

  if (*substr == '\0' || *str == '\0') return(0);

  sptr = str;
  c = *substr;

  while (1) {
    while (*sptr != '\0' && *sptr != c) sptr++;
    if (*sptr == '\0') return(0);
    for (count = 0; count >= 0 && count < substrlen; count++) {
      if (sptr[count] == '\0') return(0);
      else if (substr[count] != sptr[count]) count = -2;
    }
    if (count == substrlen) return(1);
  }
}

int indexstring(string, substring)
char *string,
     *substring;
{
  register char *sub, *str;
  char c, s;
  int indx = 0;

  while (1) {
    str = string + indx;;
    if (*str == '\0') return(-1);
    sub = substring;

    if (*str == *sub) {
      s = *str;
      c = *sub;
      while(c == s && c != '\0') {
        c = *++sub;
        s = *++str;
      }
      if (c == '\0') return((int) indx);
      else if(s == '\0') return(-1);
    }
    indx++;
  }
}

rfc2jnt(string)
char *string;
{
  char reversed[STRINGLEN];
  char front[STRINGLEN];
  register char *part;
  char *mailbox;

  mailbox = string;
  while (*mailbox != '-') mailbox++;

  reversed[0] = '\0';
  part = string + strlen(string);

  if (*part != '\0') return;
  
  while(1) {
    while (*part != '.' && *part != '@') --part;

    if (*part == '.') {
      if (reversed[0] != '\0') (void) strcat(reversed, ".");
      part++;
      (void) strcat(reversed, part);
      *--part = '\0';
      --part;
    } else {
      part++;
      (void) strcat(reversed, ".");
      (void) strcat(reversed, part);
      *part-- = '\0';
      while (!isspace(*part)) --part;
      ++part;
      (void) strcpy(front, part);
      (void) strcpy(string, "mailbox               - ");
      (void) strcat(string, front);
      (void) strcat(string, reversed);
      return;
    }
  }
}
  
struct attrcomp *
sort_attrs(entry_attrs)
struct attrcomp *entry_attrs;
{
  struct attrcomp *last, *next, *curr, *first, *firstn;

  first = curr = entry_attrs;
  firstn = last = next = 0;

  while (curr)
    if (!strcmp("2.5.4.3", curr->attr_type->oa_ot.ot_stroid) ||
        !strcmp("2.5.4.4", curr->attr_type->oa_ot.ot_stroid) ||
        !strcmp("0.9.2342.19200300.100.1.3",
                curr->attr_type->oa_ot.ot_stroid) ||
        !strcmp("0.9.2342.19200300.100.1.2",
                curr->attr_type->oa_ot.ot_stroid) ||
        !strcmp("2.5.4.20", curr->attr_type->oa_ot.ot_stroid)) {

      if (first == curr) first = curr->attr_link;

      if (next)
        next->attr_link = curr;
      else
        firstn = curr;

      next = curr;

      if (last)
        last->attr_link = curr->attr_link;

      curr = curr->attr_link;
      next->attr_link = 0;
    } else {
      last = curr;
      curr = curr->attr_link;
    }

  if (next) {
    next->attr_link = first;
    return firstn;
  } else
    return first;
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.