ufsearch.c

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

		  tmp_ex_filt = *exfilt_ptr;
		  exfilt_ptr = &tmp_ex_filt->flt_next;
		}
	      
	      if (make_filter_items(curr_val_list->type,
				    curr_val->string,
				    exfilt_ptr,
				    apfilt_ptr) != QERR_ok)
		{
		  filter_free(exact_filter);
		  filter_free(approx_filter);
		  
		  if (get_attrs != NULLATTR)
		    as_free(get_attrs);

		  return QERR_bad_value_syntax;
		}
	      
	      (void) strcat(valbuf, ", ");
	      (void) strcat(valbuf, curr_val->string);
	    }
	  
	  get_attrs = as_merge(get_attrs,
			       as_comp_new(curr_val_list->type,
					   NULLAV,
					   NULLACL_INFO));
	}
    }
  else
    {
      if (make_filter_items(search_vals->type,
			    search_vals->values->string,
			    &exact_filter,
			    &approx_filter) != QERR_ok)
	{
	  filter_free(exact_filter);
	  filter_free(approx_filter);
	  
	  if (get_attrs != NULLATTR) as_free(get_attrs);
	  return QERR_bad_value_syntax;
	}
      
      (void) strcat(valbuf, ", ");
      (void) strcat(valbuf, search_vals->values->string);
      
      get_attrs = as_merge(get_attrs,
			   as_comp_new(search_vals->type,
				       NULLAV,
				       NULLACL_INFO));
    }
  
  if (ufsrec->trying_target_search == TRUE && level_count >= 2)
    search_arg.sra_subset = SRA_WHOLESUBTREE;
  else
    search_arg.sra_subset = SRA_ONELEVEL;
    
  /* First invoke exact match, then invoke approx match. */
  /* Record task invocation. */
  /* Record task invocation for this particular request. */
  for (count = 0;
       ufsrec->exact_task_ids[count] != NO_TASK && count < MaxUfsearchTasks;
       count++)
    ;

  if (count == MaxUfsearchTasks)
    {
      filter_free(exact_filter);
      filter_free(approx_filter);

      if (get_attrs != NULLATTR)
	as_free(get_attrs);

      return QERR_internal_limit_reached;
    }
  
  if (_task_invoked(SEARCH_TASK, baseobject, ufsrec->request_id, &task_id)
      != QERR_ok)
    {
      filter_free(exact_filter);
      filter_free(approx_filter);
      
      if (get_attrs != NULLATTR)
	as_free(get_attrs);

      return QERR_internal_limit_reached;
    }
  
  /* Invoke search using exact match. */
  search_arg.sra_filter = exact_filter;
  search_arg.sra_eis.eis_select = get_attrs;

  if (DapSearch(dsap_ad, task_id, &search_arg, &di, ROS_ASYNC) == NOTOK)
    {
      filter_free(exact_filter);
      filter_free(approx_filter);
      
      _task_complete(task_id);

      if (get_attrs != NULLATTR)
	as_free(get_attrs);

      return QERR_request_failed;
    }
  else
    {
      ufsrec->exact_task_count++;
      ufsrec->exact_task_ids[count] = task_id;
      ufsrec->tasks_sent++;
    }
  
#ifndef NO_STATS
  LLOG (log_stat, LLOG_NOTICE,
        ("EXACT MATCH +%s, task %d, extent %d%s",
         baseobject, task_id, search_arg.sra_subset, valbuf));
#endif

  if (count == MaxUfsearchTasks)
    {
      filter_free(exact_filter);
      filter_free(approx_filter);
      
      if (get_attrs != NULLATTR)
	as_free(get_attrs);

      return QERR_internal_limit_reached;
    }
  
  /* Invoke approx match. */
  /* Record task invocation. */
  /* Record task invocation for this particular request. */
  for (count = 0;
       ufsrec->approx_task_ids[count] != NO_TASK && count < MaxUfsearchTasks;
       count++)
    ;

  if (count == MaxUfsearchTasks)
    {
      filter_free(exact_filter);
      filter_free(approx_filter);
      
      if (get_attrs != NULLATTR)
	as_free(get_attrs);

      return QERR_internal_limit_reached;
    }
  
  if (_task_invoked(SEARCH_TASK, baseobject, ufsrec->request_id, &task_id)
      != QERR_ok)
    {
      filter_free(exact_filter);
      filter_free(approx_filter);
      
      if (get_attrs != NULLATTR)
	as_free(get_attrs);

      return QERR_internal_limit_reached;
    }
  
  search_arg.sra_filter = approx_filter;

  if (DapSearch(dsap_ad, task_id, &search_arg, &di, ROS_ASYNC) == NOTOK)
    {
      filter_free(exact_filter);
      filter_free(approx_filter);
      
      _task_complete(task_id);
      if (get_attrs != NULLATTR) as_free(get_attrs);
      return QERR_request_failed;
    }
  else
    {
      ufsrec->approx_task_count++;
      ufsrec->approx_task_ids[count] = task_id;
      ufsrec->tasks_sent++;
    }

#ifndef NO_STATS
  LLOG (log_stat, LLOG_NOTICE,
        ("APPROX MATCH +%s, task %d, extent %d, vals%s",
         baseobject, task_id, search_arg.sra_subset, valbuf));
#endif  
	
  if (get_attrs != NULLATTR)
    as_free(get_attrs);

  filter_free(exact_filter);
  filter_free(approx_filter);

  return QERR_ok;
} /* do_directory_search */

/*
 * - process_ufs_ds_result() -
 *
 *
 */
request_state process_ufs_ds_result(request, task_id, ds_result)
     requestRec request;
     int task_id;
     struct DSResult *ds_result;
{
  DsTask task_rec;
  ufsearchRec ufsrec = request->UFSEARCH_REC;
  int *ufs_task_array;
  QBool is_exact_match_result;
  QCardinal aindex, hit_count;
  struct ds_search_result *search_result;

  task_rec = _get_task_of_id(task_id);

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

  /* Check if result comes from a search using exact or approx match. */
  for (aindex = 0, ufs_task_array = ufsrec->exact_task_ids;
       ufs_task_array[aindex] != task_id && aindex < MaxUfsearchTasks;
       aindex++)
    ;

  /* Not an exact search, so must have been an approx search. */
  if (aindex >= MAX_TASKS_PER_REQ)
    {
      for (aindex = 0, ufs_task_array = ufsrec->approx_task_ids;
	   ufs_task_array[aindex] != task_id && aindex < MaxUfsearchTasks;
	   aindex++)
	;
      
      if (aindex < MaxUfsearchTasks)
	is_exact_match_result = FALSE;
    }
  else
    is_exact_match_result = TRUE;

  /* If not an approx search, then something's wrong! */
  if (aindex >= MaxUfsearchTasks)
    {
      _task_complete(task_id);
      return RQ_processing;
    }
  
  /* Now get the search results. */
  search_result = &ds_result->res_sr;
  correlate_search_results(search_result);

  search_result->srr_next = NULLSRR;

  hit_count = 0;
  if (search_result->CSR_entries != NULLENTRYINFO)
    {
      EntryInfo *entry_ptr;
      register stringCell curr_attr;
      attrValList got_attrs = NULLAVList, curr_av;
      searchPair search_vals, curr_val_list;
      stringCell curr_val;
      char *curr_name;
      void get_read_attrs();
      QBool good_match;

      search_vals = ufsrec->trying_target_search == TRUE?
	ufsrec->target_data:
	ufsrec->search_data;
      
      /* Decode and add found entry names */
      for (entry_ptr = search_result->CSR_entries;
	   entry_ptr != NULLENTRYINFO;
	   entry_ptr = entry_ptr->ent_next)
	{
	  curr_name = qy_dn2str(entry_ptr->ent_dn);
	  good_match = FALSE;
	  
	  get_read_attrs(entry_ptr->ent_attr, &got_attrs, READOUT);
	  
	  if (!is_exact_match_result)
	    {
	      if (got_attrs != NULLAVList)
		for (curr_av = got_attrs, good_match = FALSE;
		     curr_av != NULLAVList && good_match == FALSE;
		     curr_av = curr_av->next)
		  for (curr_attr = curr_av->val_list;
		       curr_attr != NULLStrCell && good_match == FALSE;
		       curr_attr = curr_attr->next)
		    for (curr_val_list = search_vals;
			 curr_val_list != NULLSearchPair &&
			 good_match == FALSE;
			 curr_val_list = curr_val_list->next)
		      for (curr_val = curr_val_list->values;
			   curr_val != NULLStrCell;
			   curr_val = curr_val->next)
			if (is_good_match(curr_val->string, curr_attr->string))
			  good_match = TRUE;
	    }
	  else
	    good_match = TRUE;
      
	  /* It is a good_match. If it's objectClass can be found in the
	     `ditmodel' or if it is a match against target data kep it */
	  if (good_match == TRUE)
	    {
	      AttributeType val_type, oclass_type, target_type;
	      objectclass *target_class, *val_class;
	      ditRelation dit_objects;
	      extern ditRelation ditmodel;
	      objectclass *name2oc();
	      
	      oclass_type = AttrT_new("2.5.4.0");
	      
	      for (curr_av = got_attrs;
		   curr_av != NULLAVList &&
		   AttrT_new(curr_av->attr_name->string) != oclass_type;
		   curr_av = curr_av->next)
		;
	      
	      if (ufsrec->trying_target_search == FALSE)
		{
		  QBool is_dit_type = FALSE;
		  
		  if (AttrT_new(curr_av->attr_name->string) == oclass_type)
		    {
		      char *start, *end, save;
		      
		      for (curr_val = curr_av->val_list;
			   curr_val != NULLStrCell && is_dit_type == FALSE;
			   curr_val = curr_val->next)
			{
			  end = curr_val->string;
			  
			  while (*end != '\0' &&
				 *end != '\n' &&
				 is_dit_type == FALSE)
			    {
			      start = end;
			      
			      while (isspace(*start))
				start++;

			      end = start;
			      
			      while (!isspace(*end))
				end++;
			      save = *end;
			      
			      *end = '\0';
			      
			      val_class = name2oc(start);
			      val_type = AttrT_new(val_class->oc_ot.ot_stroid);

			      for (dit_objects = ditmodel;
				   dit_objects != NULLDitRelation &&
				   is_dit_type == FALSE;
				   dit_objects = dit_objects->next)
				if (val_type == dit_objects->parent_type ||
				    (dit_objects->parent_type != NULLAttrT &&
				     qy_in_hierarchy
				     (name2oc(dit_objects->parent_type->oa_ot.
					      ot_stroid),
				      val_class)))
				  {
				    /* In case it's a subclass of
				     * the dit type
				     */
				    val_type = dit_objects->parent_type;
				    
				    is_dit_type = TRUE;
				  }
			      
			      *end = save;
			      while (is_dit_type == FALSE &&
				     *end != '\0' &&
				     *end != '\n' &&
				     !isalnum(*end))
				end++;
			    }
			}
		    }
		  
		  if (is_dit_type == TRUE)
		    (void) dn_list_add(curr_name,
				       &ufsrec->to_follow, val_type);
		}
	      else
		{
		  QBool is_target_type = FALSE;
		  target_type = ufsrec->target_data->type;
		  target_class = name2oc(target_type->oa_ot.ot_name);
		  
		  if (AttrT_new(curr_av->attr_name->string) == oclass_type)
		    {
		      char *start, *end, save;
		      
		      for (curr_val = curr_av->val_list;
			   curr_val != NULLStrCell && is_target_type == FALSE;
			   curr_val = curr_val->next)
			{
			  end = curr_val->string;
			  
			  while (*end != '\0' &&
				 *end != '\n' &&
				 is_target_type == FALSE)
			    {
			      start = end;
			      
			      while (isspace(*start))
				start++;

			      end = start;
			      
			      while (!isspace(*end))
				end++;

			      save = *end;
			      
			      *end = '\0';

			      val_class = name2oc(start);

			      if (val_class == target_class ||
				  qy_in_hierarchy(target_class, val_class))
				is_target_type = TRUE;
			      
			      *end = save;
			      
			      while (is_target_type == FALSE &&
				     *end != '\0' &&
				     *end != '\n' &&
				     !isalnum(*end))
				end++;
			    }
			}
		    }
		  
		  if (is_target_type)
		    (void) dn_list_add(curr_name,
				       &ufsrec->to_follow, NULLAttrT);
		}
	    }
	  
	  if (got_attrs != NULLAVList)
	    {
	      free_string_seq(&(got_attrs->attr_name));
	      free_string_seq(&(got_attrs->val_list));

	      (void) free((char *) got_attrs);