calls.c

ftam等标准协议服务器和客户端的源代码。

  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');
}

void quipu_error(err)
     struct DSError *err;
{
  switch(err->dse_type) {
  case DSE_LOCALERROR:
    xprint(" SD internal error!\n");
    break;
  case DSE_REMOTEERROR:
    xprint(" Problem with remote directory server!\n");
    break;
  case DSE_ATTRIBUTEERROR:
    xprint(" Faulty data found in database!\n");
    break;
  case DSE_REFERRAL:
  case DSE_DSAREFERRAL:
    xprint(" Requested data unavailable at present.\n");
    break;
  case DSE_SECURITYERROR:
    xprint(" You do not have the privileges required\n to make this request!");
    break;
  case DSE_NAMEERROR:
    xprint(" Invalid directory position!\n");
    break;
  case DSE_SERVICEERROR:
    xprint(" Directory Service Error!\n");
    break;
  default:
    xprint(" Requested data unavailable at present.\n");
  }
}

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

void 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, curr_dnseq)) 
    if(!isleafnode(sptr)) {
      cleartext();
      str = get_from_seq(count+1, back_seq);
      
      while (str && 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';
}

void scrollbar(command)
     char command;
{
  register char *str;
  char *base_rdn;
  register int rdn_count = 0;
  int lines, count = 0;
  str_seq thisseq;
  
  if (!entry_number)
    return;
  
  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 = curr_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;
}

void 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, ", ");
  }
}
   
void goto_addr()
{
  set_default_type();
  rd_start();
}

int isleafnode(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);
  }
}

void 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);
    sptr++;
  }
}

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++;
  }
}

void 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;
}


char *GetSurname(name)
     register char *name;
{
  while (*name != '\0') name++;
  while (*name != ' ' && *name != '=') name--;
  return ++name;
}

char *GetWholeRelName(name)
     register char *name;
{
  while (*name!= '\0') name++;
  while (*name != '=') name--;
  while (!isalpha(*name)) name++;
  return name;
}

str_seq SortList(list)
     str_seq list;
{
  register str_seq currEntry, lastSortedEntry , currSortedEntry; 
  str_seq sortedList;
  char *sortedName, *currName;
  register DN curr_dn;
  DN dn;

  if (!list) return 0;

  currEntry = list;
  sortedList = 0;

  while (currEntry) {
    dn = curr_dn = str2dn(currEntry->dname);

    while (curr_dn && curr_dn->dn_parent != NULLDN) 
      curr_dn = curr_dn->dn_parent;
    
    if (!strcmp(curr_dn->dn_rdn->rdn_at->oa_ot.ot_stroid, "2.5.4.3"))
      currName = GetSurname(currEntry->dname);
    else 
      currName = GetWholeRelName(currEntry->dname);

    dn_free(dn);

    if (!sortedList) {
      sortedList = currEntry;
      currEntry = currEntry->next;
      sortedList->next = 0;
    } else {
      lastSortedEntry = 0;
      currSortedEntry = sortedList;

      while (currSortedEntry != 0) {
	dn = curr_dn = str2dn(currSortedEntry->dname);
	
	while (curr_dn && curr_dn->dn_parent != NULLDN) 
	  curr_dn = curr_dn->dn_parent;
	
	if (!strcmp(curr_dn->dn_rdn->rdn_at->oa_ot.ot_stroid, 
		    "2.5.4.3"))
	  sortedName = GetSurname(currSortedEntry->dname);
	else 
	  sortedName = GetWholeRelName(currSortedEntry->dname);
	
	dn_free(dn);

	if (strcmp(currName, sortedName) <= 0) {
	  if (lastSortedEntry) {
	    lastSortedEntry->next = currEntry;
	    currEntry = currEntry->next;
	    lastSortedEntry->next->next = currSortedEntry;
	  } else {
	    sortedList = currEntry;
	    currEntry = currEntry->next;
	    sortedList->next = currSortedEntry;
	  }
	  currSortedEntry = 0;
	} else {
	  lastSortedEntry = currSortedEntry;
	  currSortedEntry = currSortedEntry->next;
	  if (!currSortedEntry) {
	    lastSortedEntry->next = currEntry;
	    currEntry = currEntry->next;
	    lastSortedEntry->next->next = 0;
	    currSortedEntry = 0;
	  }
	}
      }
    }
  }
  return sortedList;
}