modify.c

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

  templaterec->result->may_exc = may_out;

  templaterec->include_attrs = NULLModifyAttr;
  templaterec->result->errors = templaterec->errors = NULLError;

  templaterec->result->base_object = templaterec->base_object;
  templaterec->base_object = NULLCP;

  return RQ_results_returned;
} /* process_template_ds_result */

/*
 * - process_template_ds_error() -
 *
 *
 */
request_state process_template_ds_error(request, task_id, error)
     requestRec request;
     int task_id;
     struct DSError *error;
{
  DsTask task_rec;
  makeTemplateRec temprec = request->TEMPLATE_REC;
  QE_error_code error_type;

  task_rec = _get_task_of_id(task_id);

  /*
   *	This shouldn't happen
   */

  if (task_rec == NULLDsTask) return RQ_processing;


  /*
   *	Save error and log it
   */
  
  error_type = get_log_error_type(error, task_id);
  add_error_to_request_rec(request, task_rec->baseobject, error_type, error);


  /*
   *	Put the results structure into the request record
   *	for later retrieval.
   *
   */

  temprec->result = template_result_alloc();

  temprec->errors = request->errors;
  request->errors = NULLError;

  temprec->result->base_object = temprec->base_object;
  temprec->base_object = NULLCP;

  temprec->result->must_request = NULLModifyAttr;
  temprec->result->must_exc = NULLModifyAttr;

  temprec->result->may_request = NULLModifyAttr;
  temprec->result->must_exc = NULLModifyAttr;


  /*
   *	Remove invocation record for this task
   */

  _task_complete(task_id);

  return RQ_results_returned;
} /* process_template_ds_error */

/*
 * - get_template_attrs() -
 *
 * Copy values in an `Attr_Sequence' linked list into a `modify_attr'
 * linked list.
 *
 * Uses EDBOUT format for the output style as READOUT isn't allowed
 * for modification operations.
 *
 */
static void get_template_attrs(readattrs, template)
     Attr_Sequence readattrs;
     modifyAttr template;
{
  PS valps;
  modifyValue curr_val = NULLModifyValue;
  modifyAttr this_attr;
  AV_Sequence curr_av;
  Attr_Sequence curr_as;
  extern int oidformat;

  for (curr_as = readattrs; curr_as != NULLATTR; curr_as = curr_as->attr_link)
    {
      for (this_attr = template;
	   this_attr != NULLModifyAttr;
	   this_attr = this_attr->next)
	if (curr_as->attr_type == this_attr->attr_type &&
	    /* Don't want to read file attributes at present! */
	    AS_SYNTAX(curr_as) < AV_WRITE_FILE)
	  /* The attribute corresponds to one in the template. */
	  {
	    curr_val = NULLModifyValue;
	    
	    for (curr_av = curr_as->attr_value;
		 curr_av != NULLAV;
		 curr_av = curr_av->avseq_next)
	      {
		if ((valps = ps_alloc(str_open)) == NULLPS) return;
		
		if (str_setup(valps, NULLCP, 0, 0) == NOTOK)
		  {
		    ps_free(valps);
		    return;
		  }
		
		avs_comp_print(valps, curr_av, EDBOUT);
		
		if (valps->ps_ptr != NULLCP)
		  {
		    *(valps->ps_ptr) = NULL;
		    valps->ps_cnt++;
		  }

		if (curr_val == NULLModifyValue)
		  this_attr->values = curr_val = modify_value_alloc();
		else
		  {
		    curr_val->next = modify_value_alloc();
		    curr_val = curr_val->next;
		  }
		
		if (valps->ps_base == NULLCP)
		  curr_val->value = NULLCP;
		else
		  curr_val->value = copy_string(valps->ps_base);

		curr_val->new_value = NULLCP;
		curr_val->status = unchanged;

		curr_val->next = NULLModifyValue;

		ps_free(valps);
	      }
	  }
    }
} /* get_template_attrs */

/*
 *
 * Proc's to free structures.
 *
 */

void free_mod_attr_list(mod_attr_list_ptr)
     modifyAttr *mod_attr_list_ptr;
{
  modifyAttr curr_attr = *mod_attr_list_ptr, last_attr;

  while (curr_attr != NULLModifyAttr)
    {
      free_mod_val_list(&curr_attr->values);

      if (curr_attr->attr_name != NULLCP)
	(void) free(curr_attr->attr_name);

      last_attr = curr_attr;
      curr_attr = curr_attr->next;

      (void) free((char *) last_attr);
    }

  *mod_attr_list_ptr = NULLModifyAttr;
} /* free_mod_attr_list */


void free_mod_val_list(mod_val_list_ptr)
     modifyValue *mod_val_list_ptr;
{
  modifyValue curr_val = *mod_val_list_ptr, last_val;

  while (curr_val != NULLModifyValue)
    {
      if (curr_val->value != NULLCP)
	(void) free(curr_val->value);

      if (curr_val->new_value != NULLCP)
	(void) free(curr_val->new_value);

      last_val = curr_val;
      curr_val = curr_val->next;

      (void) free((char *) last_val);
    }

  *mod_val_list_ptr = NULLModifyValue;
} /* free_mod_val_list */

void free_modify_result(result_ptr)
     modifyResult *result_ptr;
{
  modifyResult result = *result_ptr;

  if (result == NULLModifyResult)
    return;

  if (result->errors != NULLError)
    error_list_free(&result->errors);

  (void) free((char *) result);
  
  *result_ptr = NULLModifyResult;
} /* free_modify_result */


void modify_rec_free(record)
     modifyRec record;
{
  if (record == NULLModifyRec)
    return;
  
  if (record->base_object != NULLCP)
    (void) free(record->base_object);

  if (record->result != NULLModifyResult)
    free_modify_result(&record->result);
} /* free_modify_rec */


void free_make_template_result(result_ptr)
     makeTemplateResult *result_ptr;
{
  makeTemplateResult result = *result_ptr;

  if (result->base_object != NULLCP)
    (void) free(result->base_object);
  
  if (result->must_request != NULLModifyAttr)
    free_mod_attr_list(&result->must_request);

  if (result->must_exc != NULLModifyAttr)
    free_mod_attr_list(&result->must_exc);

  if (result->may_request != NULLModifyAttr)
    free_mod_attr_list(&result->may_request);

  if (result->may_exc != NULLModifyAttr)
    free_mod_attr_list(&result->may_exc);

  if (result->errors != NULLError)
    error_list_free(&result->errors);

  (void) free((char *) result);

  *result_ptr = NULLTemplateResult;
} /* free_make_template_result */

void free_make_template_rec(record)
     makeTemplateRec record;
{
  if (record == NULLTemplateRec) return;

  if (record->base_object != NULLCP)
    (void) free(record->base_object);

  if (record->include_attrs != NULLModifyAttr)
    free_mod_attr_list(&record->include_attrs);

  if (record->errors != NULLError)
    error_list_free(&record->errors);

  (void) free((char *) record);
} /* free_make_template_rec */


/*
 * Miscellaneous modify procedures.
 *
 *
 */

static struct entrymod * ems_append (a,b)
     struct entrymod *a;
     struct entrymod *b;
{
  struct entrymod *ptr;

  if ((ptr = a) == NULLMOD)
    return b;
  
  for ( ; ptr->em_next != NULLMOD; ptr = ptr->em_next)
    ;

  ptr->em_next = b;

  return a;
}

modifyAttr avList2modifyAttr(attr_list)
     attrValList attr_list;
{
  modifyAttr curr_mod_attr, head = NULLModifyAttr;
  modifyValue curr_mod_val;
  stringCell curr_val;
  attrValList curr_attr;

  for (curr_attr = attr_list;
       curr_attr != NULLAVList;
       curr_attr = curr_attr->next)
    {
      if (head == NULLModifyAttr)
	{
	  head = curr_mod_attr = modify_attr_alloc();
	}
      else
	{
	  curr_mod_attr->next = modify_attr_alloc();
	  curr_mod_attr = curr_mod_attr->next;
	}

      curr_mod_attr->next = NULLModifyAttr;

      curr_mod_attr->attr_name = copy_string(curr_attr->attr_name->string);
      curr_mod_attr->attr_type = AttrT_new(curr_attr->attr_name->string);

      curr_mod_attr->values = NULLModifyValue;
      curr_mod_attr->to_modify = FALSE;

      for (curr_val = curr_attr->val_list, curr_mod_val = NULLModifyValue;
	   curr_val != NULLStrCell;
	   curr_val = curr_val->next)
	{
	  if (curr_mod_attr->values == NULLModifyValue)
	    {
	      curr_mod_attr->values = curr_mod_val = modify_value_alloc();
	    }
	  else
	    {
	      curr_mod_val->next = modify_value_alloc();
	      curr_mod_val = curr_mod_val->next;
	    }

	  curr_mod_val->next = NULLModifyValue;
	  
	  curr_mod_val->new_value = NULLCP;
	  curr_mod_val->status = unchanged;

	  curr_mod_val->value = copy_string(curr_val->string);
	}
    }

  return head;
} /* avList2modifyAttr */


/*
 * - remove_common_attrs() -
 *
 *
 */
static modifyAttr remove_common_attrs(primary, secondary)
     modifyAttr primary, secondary;
{
  register modifyAttr curr_sec, last_sec;
  modifyAttr tmp;

  if (primary == NULLModifyAttr || secondary == NULLModifyAttr)
    return secondary;

  while (primary != NULLModifyAttr)
    {
      curr_sec = secondary;
      last_sec = NULLModifyAttr;

      while (curr_sec != NULLModifyAttr)
	{
	  if (primary->attr_type == curr_sec->attr_type)
	    {
	      tmp = curr_sec;

	      if (last_sec != NULLModifyAttr)
		{
		  last_sec->next = curr_sec->next;
		  curr_sec = curr_sec->next;
		}
	      else
		curr_sec = secondary = curr_sec->next;

	      tmp->next = NULLModifyAttr;
	      free_mod_attr_list(&tmp);
	    }
	  else
	    {
	      last_sec = curr_sec;
	      curr_sec = curr_sec->next;
	    }
	}

      primary = primary->next;
    }

  return secondary;
}

/*
 * - remove_double_attrs() -
 *
 *
 */
static modifyAttr remove_double_attrs(primary)
     modifyAttr primary;
{
  register modifyAttr curr_attr, last_attr;
  modifyAttr curr_primary, tmp;

  if (primary == NULLModifyAttr)
    return primary;

  for (curr_primary = primary;
       curr_primary != NULLModifyAttr;
       curr_primary = curr_primary->next)
    {
      curr_attr = curr_primary->next;
      last_attr = NULLModifyAttr;

      while (curr_attr != NULLModifyAttr)
	if (curr_primary->attr_type == curr_attr->attr_type)
	  {
	    tmp = curr_attr;
	    
	    if (last_attr != NULLModifyAttr)
		curr_attr = last_attr->next = curr_attr->next;
	    else
	      {
		curr_attr = curr_primary = curr_attr->next;
		
		if (curr_attr != NULLModifyAttr)
		  curr_attr = curr_attr->next;
		
		if (primary->next == curr_primary)
		  primary = curr_primary;
	      }
	    
	    tmp->next = NULLModifyAttr;
	    free_mod_attr_list(&tmp);
	  }
	else
	  {
	    last_attr = curr_attr;
	    curr_attr = curr_attr->next;
	  }
    }

  return primary;
}