ufname.c

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

      if (name_comp->exact_match_num == 0 &&
	  name_comp->good_match_num == 0 &&
	  name_comp->poor_match_num == 0)
	{
	  if (name_comp->is_bottom_level == unknown)
	    name_comp->is_bottom_level = might_not;

	  if (name_comp->is_bottom_level == no ||
	      process_ufn_search(ufnrec) == QERR_nothing_found)
	    {
	      part = ufnrec->name_parts->next;
	      
	      if (ufnrec->path != NULLEntryList && part->is_resolved != TRUE)
		if (follow_path(ufnrec) == TRUE)
		  {
		    (void) free((char *) results);
		    return RQ_processing;
		  }
	      
	      ufnrec->results = results;
	      
	      results->match_num = 0;
	      results->matches = NULLEntryList;

	      results->errors = request->errors;
	      request->errors = NULLError;

	      return RQ_results_returned;
	    }
	  else
	    {
	      (void) free((char *) results);
	      return RQ_processing;
	    }
	}

      /*
       * If final part_name of name has been matched,
       * then return appropriate list of entry names.
       *
       */
      if (name_comp->next == NULLNamePart)
	{
	  ufnrec->results = results;

	  results->tried_intermediate = TRUE;
	  results->unresolved_part = results->resolved_part = NULLCP;

	  results->errors = request->errors;
	  request->errors = NULLError;

	  if (name_comp->exact_match_num > 0)
	    {
	      name_comp->is_resolved = TRUE;

	      results->match_num = name_comp->exact_match_num;
	      results->matches = name_comp->exact_matches;

	      results->match_status = GoodMatches;
	      
	      name_comp->exact_matches = NULLEntryList;
	      name_comp->exact_match_num = 0;
	    }
	  else if (name_comp->good_match_num > 0)
	    {
	      name_comp->is_resolved = TRUE;
    
	      results->match_num = name_comp->good_match_num;
	      results->matches = name_comp->good_matches;

	      results->match_status = GoodMatches;
	      
	      name_comp->good_matches = NULLEntryList;
	      name_comp->good_match_num = 0;
	    }
	  else if (name_comp->poor_match_num > 0)
	    {
	      char resolved_part[LINESIZE], buf[LINESIZE];
		  
	      part = ufnrec->name_parts->next;

	      resolved_part[0] = '\0';
	      buf[0] = '\0';
	      for (curr_part = ufnrec->name_parts;
		   curr_part != NULLNamePart;
		   curr_part = curr_part->next)
		{
		  if (curr_part->part_name != NULLCP)
		    {
		      if (resolved_part[0] != '\0')
			{
			  (void) strcpy(buf, resolved_part);
			  (void) strcpy(resolved_part, curr_part->part_name);
			  (void) strcat(resolved_part, ", ");
			  (void) strcat(resolved_part, buf);
			}
		      else
			(void) strcpy(resolved_part, curr_part->part_name);
		    }
		}
	      
	      results->tried_intermediate =
		(name_comp->is_bottom_level == unknown)? FALSE: TRUE;
	      
	      results->match_num = name_comp->poor_match_num;
	      results->matches = name_comp->poor_matches;

	      results->resolved_part = copy_string(resolved_part);
	      results->unresolved_part = NULLCP;

	      results->match_status = PoorComplete;
	      
	      name_comp->poor_matches = NULLEntryList;
	      name_comp->poor_match_num = 0;
	    }
	  else
	    {
	      part = ufnrec->name_parts->next;
	      
	      if (ufnrec->path != NULLEntryList && part->is_resolved != TRUE)
		if (follow_path(ufnrec) == TRUE)
		  {
		    ufnrec->results = NULLUfnResults;
		    
		    request->errors = results->errors;
		    results->errors = NULLError;

		    free((char *) results);
		    return RQ_processing;
		  }

	      results->match_status = Failed;
	      results->match_num = 0;

	      results->matches = NULLEntryList;
	      results->resolved_part = results->unresolved_part = NULLCP;
	    }
	  
	  return RQ_results_returned;
	}
      else
	{
	  if (name_comp->good_match_num == 0 &&
	      name_comp->exact_match_num == 0)
	    {
	      if (name_comp->poor_match_num > 0)
		{
		  char resolved_part[LINESIZE],
		       unresolved_part[LINESIZE],
		       buf[LINESIZE];
		  
		  part = ufnrec->name_parts->next;

		  resolved_part[0] = '\0';
		  buf[0] = '\0';

		  for (curr_part = ufnrec->name_parts;
		       curr_part != name_comp->next;
		       curr_part = curr_part->next)
		    if (curr_part->part_name != NULLCP)
		      {
			if (resolved_part[0] != '\0')
			  {
			    (void) strcpy(buf, resolved_part);
			    (void) strcpy(resolved_part, curr_part->part_name);
			    (void) strcat(resolved_part, ", ");
			    (void) strcat(resolved_part, buf);
			  }
			else
			  (void) strcpy(resolved_part, curr_part->part_name);
		      }
		  
		  unresolved_part[0] = '\0';
		  buf[0] = '\0';

		  for (; curr_part != NULLNamePart;
		       curr_part = curr_part->next)
		    if (curr_part->part_name != NULLCP)
		      {
			if (unresolved_part[0] != '\0')
			  {
			    (void) strcpy(buf, unresolved_part);
			    (void) strcpy(unresolved_part,
					  curr_part->part_name);
			    (void) strcat(unresolved_part, ", ");
			    (void) strcat(unresolved_part, buf);
			  }
			else
			  (void) strcpy(unresolved_part, curr_part->part_name);
		      }
		  
		  ufnrec->results = results;

		  results->tried_intermediate = TRUE;
		  results->match_status = PoorPartial;

		  results->match_num = name_comp->poor_match_num;
		  results->matches = name_comp->poor_matches;

		  name_comp->poor_matches = NULLEntryList;
		  name_comp->poor_match_num = 0;

		  results->errors = request->errors;
		  request->errors = NULLError;

		  results->resolved_part = copy_string(resolved_part);
		  results->unresolved_part = copy_string(unresolved_part);
	  
		  return RQ_results_returned;
		}
	      else
		{
		  part = ufnrec->name_parts->next;

		  if (ufnrec->path != NULLEntryList && part->is_resolved!=TRUE)
		    if (follow_path(ufnrec) == TRUE)
		      {
			free((char *) results);
			return RQ_processing;
		      }

		  ufnrec->results = results;

		  results->tried_intermediate = TRUE;
		  results->match_status = Failed;

		  results->match_num = 0;
		  results->matches = NULLEntryList;

		  results->unresolved_part = results->resolved_part = NULLCP;

		  results->errors = request->errors;
		  request->errors = NULLError;
		  
		  return RQ_results_returned;
		}
	    }
	  
	  name_comp->is_resolved = TRUE;
	  if (process_ufn_search(ufnrec) == QERR_nothing_found)
	    {
	      ufnrec->results = results;

	      results->tried_intermediate = TRUE;
	      results->match_status = Failed;

	      results->match_num = 0;
	      results->matches = NULLEntryList;

	      results->unresolved_part = results->resolved_part = NULLCP;

	      results->errors = request->errors;
	      request->errors = NULLError;
	      
	      return RQ_results_returned;
	    }
	  else
	    {
	      (void) free((char *) results);
	      return RQ_processing;
	    }
	}
    }

  return RQ_processing;
} /* process_ufn_ds_result */
  

/*
 * - process_ufn_ds_error() -
 *
 *
 */
request_state process_ufn_ds_error(request, task_id, error)
     requestRec request;
     int task_id;
     struct DSError *error;
{
  DsTask task_rec;
  ufnameRec ufnrec = request->UFNAME_REC;
  namePart name_comp, part;
  int *ufn_task_array;
  QBool is_exact_match_error;
  QCardinal aindex;
  QE_error_code error_type;

  task_rec = _get_task_of_id(task_id);

  /* This shouldn't happen */
  if (task_rec == NULLDsTask) return RQ_processing;

  for (name_comp = ufnrec->name_parts;
       name_comp->is_resolved == TRUE && name_comp != NULLNamePart;
       name_comp = name_comp->next) 
    ;
  
  /* This shouldn't happen! */
  if (name_comp == NULLNamePart)
    {
      _task_complete(task_id);
      return RQ_processing;
    }

  /* Check if error comes from a search using exact or approx match. */
  for (aindex = 0, ufn_task_array = ufnrec->dap_exact_task_ids;
       ufn_task_array[aindex] != task_id && aindex < MAX_TASKS_PER_REQ;
       aindex++)
    ;
  
  /* Not an exact search, so must have been an approx search. */
  if (aindex >= MAX_TASKS_PER_REQ)
    {
      for (aindex = 0, ufn_task_array = ufnrec->dap_approx_task_ids;
	   ufn_task_array[aindex] != task_id && aindex < MAX_TASKS_PER_REQ;
	   aindex++)
	;
      
      if (aindex < MAX_TASKS_PER_REQ) is_exact_match_error = FALSE;
    }
  else
    is_exact_match_error = TRUE;

  if (aindex >= MAX_TASKS_PER_REQ)
    {
      _task_complete(task_id);
      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);

  ufnrec->tasks_failed++;
  

  /* Remove invocation record for this task */

  _task_complete(task_id);
  ufn_task_array[aindex] = NO_TASK;


  if (is_exact_match_error)
    ufnrec->exact_task_count--;
  else
    ufnrec->approx_task_count--;


  if (ufnrec->exact_task_count == 0 && ufnrec->approx_task_count == 0)
    {
      ufnResults results = ufn_res_alloc();

      results->tried_intermediate = FALSE;
      results->match_status = Failed;
      results->match_num = 0;
      results->matches = NULLEntryList;
      results->unresolved_part = results->resolved_part = NULLCP;
      results->errors = NULLError;
	      

      if (name_comp->exact_match_num > 0 ||
	  name_comp->good_match_num > 0)
	name_comp->is_resolved = TRUE;
      
      if (name_comp->exact_match_num == 0 &&
	  name_comp->good_match_num == 0 &&
	  name_comp->poor_match_num == 0)
	{
	  if (name_comp->is_bottom_level == unknown)
	    name_comp->is_bottom_level = might_not;

	  if (name_comp->is_bottom_level == no ||
	      process_ufn_search(ufnrec) == QERR_nothing_found)
	    {
	      part = ufnrec->name_parts->next;

	      if (ufnrec->path != NULLEntryList && part->is_resolved != TRUE)
		if (follow_path(ufnrec) == TRUE)
		  {
		    free((char *) results);
		    return RQ_processing;
		  }

	      ufnrec->results = results;

	      results->errors = request->errors;
	      request->errors = NULLError;

	      return RQ_results_returned;
	    }
	  else
	    {
	      free((char *) results);
	      return RQ_processing;
	    }
	}
      

      /*
       * If final component of name has been matched, then return
       * appropriate list of entry names.
       *
       */

      if (name_comp->next == NULLNamePart)
	{
	  ufnrec->results = results;

	  results->tried_intermediate = TRUE;
	  results->unresolved_part = results->resolved_part = NULLCP;

	  results->errors = request->errors;
	  request->errors = NULLError;

	  if (name_comp->exact_match_num > 0)
	    {
	      name_comp->is_resolved = TRUE;
      
	      results->match_num = name_comp->exact_match_num;
	      results->matches = name_comp->exact_matches;

	      name_comp->exact_matches = NULLEntryList;
	      name_comp->exact_match_num = 0;

	      results->match_status = GoodMatches;
	    }
	  else if (name_comp->good_match_num > 0)
	    {
	      name_comp->is_resolved = TRUE;
      
	      results->match_num = name_comp->good_match_num;
	      results->matches = name_comp->good_matches;

	      name_comp->good_matches = NULLEntryList;
	      name_comp->good_match_num = 0;

	      results->match_status = GoodMatches;
	    }
	  else if (name_comp->poor_match_num > 0)
	    {
	      part = ufnrec->name_parts->next;

	      results->tried_intermediate =
		(name_comp->is_bottom_level == unknown)? FALSE : TRUE;

	      results->match_num = name_comp->poor_match_num;
	      results->matches = name_comp->poor_matches;

	      name_comp->poor_matches = NULLEntryList;
	      name_comp->poor_match_num = 0;

	      results->match_status = PoorComplete;
	    }
	  else
	    {
	      part = ufnrec->name_parts->next;

	      if (ufnrec->path != NULLEntryList && part->is_resolved != TRUE)
		if (follow_path(ufnrec) == TRUE)
		  {
		    ufnrec->results = NULLUfnResults;

		    request->errors = results->errors;
		    results->errors = NULLError;

		    free((char *) results);
		    return RQ_processing;
		  }

	      results->match_num = 0;
	      results->matches = NULLEntryList;

	      results->match_status = Failed;
	    }
	  
	  return RQ_results_returned;
	}
      else
	{
	  name_comp->is_resolved = TRUE;

	  if (process_ufn_search(ufnrec) == QERR_nothing_found)
	    {
	      part = ufnrec->name_parts->next;

	      ufnrec->results = results;

	      results->tried_intermediate = TRUE;
	      results->match_status = Failed;

	      results->match_num = 0;
	      results->matches = NULLEntryList;

	      results->unresolved_part = results->resolved_part = NULLCP;
	      results->errors = request->errors;

	      request->errors = NULLError;
	      
	      return RQ_results_returned;
	    }
	  else
	    {
	      (void) free((char *) results);
	      return RQ_processing;
	    }
	}
    }

  return RQ_processing;
} /* process_ufn_ds_error */

  
/*
 *
 *
 *
 */
static QBool follow_path(ufnrec)
     ufnameRec ufnrec;
{
  namePart part;

  for (part = ufnrec->name_parts;
       part != NULLNamePart;
       part = part->next)
    {
      part->exact_match_num =
	part->good_match_num =
	  part->poor_match_num = 0;
      
      if (part->exact_matches != NULLEntryList)
	  dn_list_free(&(part->exact_matches));
      
      if (part->good_matches != NULLEntryList)
	  dn_list_free(&(part->good_matches));
      
      if (part->poor_matches != NULLEntryList)
	  dn_list_free(&(part->poor_matches));

      if (part->next != NULLNamePart)
	part->is_bottom_level = no;
      else
	part->is_bottom_level = unknown;

      part->is_resolved = FALSE;
    }
  
  ufnrec->name_parts->exact_match_num = 1;
  ufnrec->name_parts->is_resolved = TRUE;

  (void) dn_list_add(ufnrec->path->string_dn,
		     &(ufnrec->name_parts->exact_matches),
		     NULLAttrT);
  
  ufnrec->path = ufnrec->path->next;
  
  if (process_ufn_search(ufnrec) != QERR_ok)
    return FALSE;
  else
    return TRUE;
}



/*
 *
 *	Procedures for UFN search path configuration
 *
 */

void add_ufn_path_element(lower, upper, path)
     int lower, upper;
     entryList path;
{
  searchPath curr_path;

  curr_path = search_path_alloc();
  curr_path->next = ufnpaths;

  ufnpaths = curr_path;

  curr_path->upper_bound = upper;
  curr_path->lower_bound = lower;

  curr_path->path = path;
} /* add_ufn_path_element */


entryList get_ufn_path(comp_num)
     int comp_num;
{
  searchPath curr_path;
  int lower, upper;
  
  for (curr_path = ufnpaths;
       curr_path != NULLSearchPath;
       curr_path = curr_path->next)
    {
      lower = curr_path->lower_bound;
      upper = curr_path->upper_bound;

      if (comp_num > lower && (upper == UfnPlus || comp_num <= upper))
	break;

      if (comp_num == lower)
	break;
    }

  if (curr_path != NULLSearchPath)
    return curr_path->path;
  else
    return NULLEntryList;
} /* get_ufn_path */