[continued from previous message]

+ const ns_type q_type;
+ const int is_search;
+ enum looking_up * looking_up_p;
+ char ** search_name_p;
+ int * have_error_p;
+ int * other_p;
+ struct cancel_data ** cancel_p
+ /* May be NULL, Used if dns lookup was cancelable
+ -- not really canceled, just
+ stop waiting of result
+ */;
+ {
+ struct resolv_cache * ret = NULL;
+ int err = 0;
+ struct resolv_query_item * query = NULL;
+ int root_searched = 0;
+ int dots = -1;
+
+ struct check_query_answer_f flags = NULL_check_query_answer_f;
+
+ if (cancel_p && !*cancel_p) {
+
+ enum name_lookup_cancel_v cancel_mode = give_dt_enumerate_as_int(&name_lookup_cancel);
+
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: name-lookup-cancel = %d\n",
+ name,cancel_mode));
+
+ switch (cancel_mode) {
+ case name_lookup_cancel_enabled:
+ case name_lookup_cancel_auto: /* "auto" applies to non-blocking queries */
+ *cancel_p =
+ new_schedule_cancel(100 /* print after 100 ms */,
+ CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvLookingUp,
+ "Looking up %s ..."),
+ name);
+ break;
+ case name_lookup_cancel_disabled:
+ case NUM_name_lookup_cancel:
+ break;
+ }
+ }
+
+
+ if (have_error_p)
+ flags.have_error = 0 != *have_error_p;
+ if (other_p)
+ flags.other = 0 != *other_p;
+
+ if (is_search) {
+ const char *c;
+ const char * found_dot = NULL;
+ const char * alias;
+
+ dots = 0;
+
+ for (c = name;*c; c++) {
+ if ('.' == *c) {
+ dots++;
+ found_dot = c;
+ }
+ }
+
+ DPRINT(Debug,14,(&Debug,"lookup_resolv_cache_nonblocked: %s: %d dots\n",
+ name,dots));
+
+ /* Need to similar than res_search */
+
+ if (found_dot && !found_dot[1]) {
+ DPRINT(Debug,14,(&Debug,"lookup_resolv_cache_nonblocked: %s: trailing dot\n",
+ name));
+
+ query = query_one_name(record,name,NULL,now,q_type,
+ looking_up_p,&err,
+ 0 /* not search */);
+ root_searched = 1;
+
+ } else if (!dots && (alias = hostalias(name))) {
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: No dots, searching alias: %s\n",
+ name,alias));
+
+ query = query_one_name(record,alias,NULL,now,q_type,
+ looking_up_p,&err,
+ 0 /* not search */);
+ root_searched = 1;
+
+ } else {
+ char * default_domain_searched = NULL;
+
+ if (!dots && 0 != (_res.options & RES_DEFNAMES)) {
+
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: No dots, (RES_DEFNAMES) searching from default domain: %s\n",
+ name,_res.defdname));
+
+ default_domain_searched = _res.defdname;
+
+ if ( ! _res.defdname[0] || 0 == strcmp(_res.defdname,".")) {
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: ... default domain is root\n"));
+ root_searched = 1;
+ }
+
+ query = query_one_name(record,name,_res.defdname,now,q_type,
+ looking_up_p,&err,
+ 1 /* have search */);
+
+ } else if (dots >= _res.ndots) {
+
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: %d dots, doing absolute query (ndots:%d)\n",
+ name,dots,_res.ndots));
+
+ query = query_one_name(record,name,NULL,now,q_type,
+ looking_up_p,&err,
+ (_res.dnsrch[0] != '\0') /* maybe have search */);
+ root_searched = 1;
+ }
+
+ end_query_helper(&query,err,name,&ret,looking_up_p,
+ search_name_p,&flags,cancel_p);
+
+ if (!ret && cancel_p && *cancel_p &&
+ is_canceled(*cancel_p)) {
+
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: DNS lookup canceled\n",
+ name));
+
+ /* Flag this as error, so query is marked as failed */
+ if (have_error_p && !*have_error_p) {
+ DPRINT(Debug,14,(&Debug, "lookup_resolv_cache_nonblocked: %s: marking as failed\n",
+ name));
+ *have_error_p = 1;
+ }
+
+ goto fail;
+
+ } else if (!flags.end_search && !ret &&
+ !query &&
+ flags.no_name /* searching only when NRXDOMAIN was previous result */
+ &&
+ 0 != (_res.options & RES_DNSRCH) &&
+ (dots ||
+ 0 != (_res.options & RES_DEFNAMES))
+ ) {
+
+ int x;
+
+
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: %d dots%s, (RES_DNSRCH) using search list\n",
+ name,dots,
+ 0 != (_res.options & RES_DEFNAMES) ? " (RES_DEFNAMES)" : ""));
+
+ for (x = 0 ;
+ x < (sizeof _res.dnsrch) / sizeof (_res.dnsrch[0]) &&
+ _res.dnsrch[x] &&
+ !flags.end_search && !ret &&
+ !query &&
+ flags.no_name /* searching only when NRXDOMAIN was previous result */;
+ x++) {
+
+ if (default_domain_searched &&
+ 0 == strcmp(default_domain_searched,
+ _res.dnsrch[x])) {
+
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: skipping %d: %s (default domain already searched)\n",
+ name, x, _res.dnsrch[x]));
+
+ } else {
+ int is_root =
+ ( ! _res.dnsrch[x][0] || 0 == strcmp( _res.dnsrch[x],"."));
+
+ if (root_searched && is_root) {
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: skipping %d: %s (root already searched)\n",
+ name,x, _res.dnsrch[x]));
+
+ } else {
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: searching %d: %s%s\n",
+ name,x, _res.dnsrch[x],
+ is_root ? " (is root)" : ""));
+
+ query = query_one_name(record,name,_res.dnsrch[x], + now,q_type,
+ looking_up_p,&err,
+ 1 /* have search */);
+
+ if (is_root)
+ root_searched = 1;
+
+ end_query_helper(&query,err,name,&ret,looking_up_p, + search_name_p,&flags,cancel_p);
+
+ if (!ret && cancel_p && *cancel_p &&
+ is_canceled(*cancel_p)) {
+
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: DNS lookup canceled\n",
+ name));
+
+ /* Flag this as error, so query is marked as failed */
+ if (have_error_p && !*have_error_p) {
+ DPRINT(Debug,14,(&Debug, "lookup_resolv_cache_nonblocked: %s: marking as failed\n",
+ name));
+ *have_error_p = 1;
+ }
+
+ goto fail;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ } else
+ flags.no_name = 1; /* searching only when NRXDOMAIN was previous result */
+
+ /* dots == -1 not search
+ dots >= 0 search
+ */
+
+ if (!flags.end_search && !ret &&
+ !query && !root_searched &&
+ flags.no_name /* searching only when NRXDOMAIN was previous result */
+ #ifdef RES_NOTLDQUERY
+ && (dots != 0 || 0 == (_res.options & RES_NOTLDQUERY) )
+ #endif
+ ) {
+
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: ",
+ name));
+ if (dots < 0) {
+ DPRINT(Debug,14,(&Debug, "not search"));
+ } else {
+ DPRINT(Debug,14,(&Debug, "search, dots %d",
+ dots));
+ }
+ DPRINT(Debug,14,(&Debug, ", doing absolute query\n"));
+
+ query = query_one_name(record,name,NULL,now,q_type,
+ looking_up_p,&err,
+ 0 /* is not search */);
+
+ end_query_helper(&query,err,name,&ret,looking_up_p,
+ search_name_p,&flags,cancel_p);
+
+ if (!ret && cancel_p && *cancel_p &&
+ is_canceled(*cancel_p)) {
+
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked: %s: DNS lookup canceled\n",
+ name));
+
+ /* Flag this as error, so query is marked as failed */
+ if (have_error_p && !*have_error_p) {
+ DPRINT(Debug,14,(&Debug, "lookup_resolv_cache_nonblocked: %s: marking as failed\n",
+ name));
+ *have_error_p = 1;
+ }
+
+ goto fail;
+ }
+ }
+
+ if (have_error_p)
+ *have_error_p = flags.have_error;
+ else if (flags.have_error && (!looking_up_p &&
+ *looking_up_p < l_up_error)) {
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvLookingUpSomeFailure,
+ "Looking up %s: some failure?"),
+ name);
+
+ if (looking_up_p)
+ *looking_up_p = l_up_error;
+ }
+
+ if (other_p)
+ *other_p = flags.other;
+ else if (flags.other && (!looking_up_p &&
+ *looking_up_p < l_up_error)) {
+
+ lib_transient(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvLookNoData,
+ "Looking up %s: no data"),
+ name);
+
+ if (looking_up_p)
+ *looking_up_p = l_up_error;
+
+ }
+
+ fail:
+
+ if (query) {
+ free_resolv_query_item(&query);
+ }
+
+ DPRINT(Debug,14,(&Debug,
+ "lookup_resolv_cache_nonblocked=%d (%s): %s",
+ ret,
+ ret ? "have result" : "no result",
+ name));
+
+ if (search_name_p && *search_name_p) {
+ DPRINT(Debug,14,(&Debug,"; search name = %s",
+ *search_name_p));
+ }
+
+ DPRINT(Debug,14,(&Debug,"\n"));
+ return ret;
+ }
+
+
+ struct resolv_query_mode nonblocked_query_mode = {
+ RESOLV_QUERY_MODE_magic,
+ have_non_blocking_qm,
+ lookup_resolv_cache_nonblocked
+ };
+
+
+ const char * QUERY_MODE[NUM_query_mode] = { "blocking",
+ "non-blocking" };
+
+ enum query_mode_val query_mode =
+ #if defined(RESOLV_SENDOK) && defined(RESOLV_SEQPACKET) && defined(BACKGROUD_PROCESSES)
+ qm_non_blocking
+ #else
+ qm_blocking
+ #endif
+ ;
+
+ const struct resolv_query_mode * query_modes [NUM_query_mode] = {
+ &blocked_query_mode,
+ &nonblocked_query_mode
+ };
+
+ static const char * HELPER_INTERRUPT[NUM_helper_interrupt] = {
+ "allow-interrupt",
+ "ignore-interrupt",
+ };
+
+ static char * query_mode_func_return_buffer = NULL;
+
+ void free_resolv_config()
+ {
+ if (query_mode_func_return_buffer) {
+ free(query_mode_func_return_buffer);
+ query_mode_func_return_buffer = NULL;
+ }
+ }
+
+ enum query_mode_param_kw {
+ qmp_helper,
+ qmp_helper_skip_limit,
+ qmp_parallel_lookup_max_time,
+ NUM_query_mode_param
+ };
+
+ static const char * QUERY_MODE_PARAM[NUM_query_mode_param] = {
+ "helper",
+ "helper-skip-limit",
+ "parallel-lookup-max-time"
+ };
+
+ int query_mode_func(value,enter,lineno,filename)
+ char **value;
+ int enter;
+ int lineno;
+ const char *filename;
+ {
+ int ok = 0;
+
+ if (enter) {
+ char * WALK;
+ char * temp = safe_strdup(*value);
+ char * f = mime_parse_content_opts(temp, &WALK);
+
+ int x;
+
+ if (!f) {
+ goto fail;
+ }
+
+ if (conf_select_value(f, QUERY_MODE,NUM_query_mode,
+ &x)) {
+ ok = 1;
+ query_mode = x;
+ }
+
+ if (ok) {
+ #ifndef RESOLV_SENDOK
+ if (query_mode) {
+ ok = 0;
+ }
+ #endif
+ #ifndef RESOLV_SEQPACKET
+ if (query_mode) {
+ ok = 0;
+ }
+ #endif
+ #ifndef BACKGROUD_PROCESSES
+ if (query_mode) {
+ ok = 0;
+ }
+ #endif
+ if (!ok) {
+ if (filename)
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvParallelLookupNotAvailFile,
+ "Parallel DNS lookup is not availeble (query-mode keyword %s on line %d on file %s)"),
+ f,lineno,filename);
+ else
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvParallelLookupNotAvail,
+ "Parallel DNS lookup is not availeble (query-mode keyword %s)"),
+ f);
+
+ query_mode = 0;
+ }
+
+
+ } else {
+
+ if (filename)
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvUnknowKeywordPLFile,
+ "Unknown query-mode keyword %s on line %d on file %s"),
+ f,lineno,filename);
+ else
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvUnknowKeywordPL,
+ "Unknown query-mode keyword %s"),
+ f);
+ }
+
+ while (NULL != (f = mime_parse_content_opts(NULL, &WALK))) {
+ /* modifies string f, return param value or NULL */
+ char * q = conf_split_param_value(f);
+ int p;
+
+ if (conf_select_value(f,QUERY_MODE_PARAM,
+ NUM_query_mode_param,
+ &p)) {
+ enum query_mode_param_kw param = p;
+
+ switch (param) {
+ case qmp_helper:
+ if (q) {
+ errno = 0;
+ if (conf_select_value(q,HELPER_INTERRUPT,
+ NUM_helper_interrupt,
+ &x)) {
+ helper_int_handling = x;
+ } else {
+ char * end = NULL;
+ long val = strtol(q,&end,10);
+ int err;
+
+ err = errno;
+
+ if (0 != err ||
+ '\0' != *end ||
+ val < 1 ||
+ val > MAX_prx_processes) {
+
+ ok = 0;
+
+ if (err) {
+ if (filename)
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPLFileErr,
+ "Bad value %s on query-mode keyword %s on line %d on file %s: %s"),
+ q,f,lineno,filename,
+ strerror(err));
+ else
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPLErr,
+ "Bad value %s on query-mode keyword %s: %s"),
+ q,f,
+ strerror(err));
+
+ } else {
+ if (filename)
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPLFile,
+ "Bad value %s on query-mode keyword %s on line %d on file %s"),
+ q,f,lineno,filename);
+ else
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPL,
+ "Bad value %s on query-mode keyword %s"),
+ q,f);
+ }
+
+ if (end > q) { /* If not keyword */
+ if (val < 1)
+ prx_max_processes = 1;
+ else if (val > MAX_prx_processes)
+ prx_max_processes = MAX_prx_processes; + else
+ prx_max_processes = val;
+ }
+
+ } else
+ prx_max_processes = val;
+ }
+
+ } else
+ goto value_missing;
+ break;
+
+ case qmp_helper_skip_limit:
+ errno = 0;
+ if (q) {
+ char * end = NULL;
+ long val = strtol(q,&end,10);
+ int err;
+
+ err = errno;
+
+ if (0 != err ||
+ '\0' != *end ||
+ val < 0 ||
+ val > MAX_prx_processes) {
+
+ ok = 0;
+
+ if (err) {
+ if (filename)
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPLFileErr,
+ "Bad value %s on query-mode keyword %s on line %d on file %s: %s"),
+ q,f,lineno,filename,
+ strerror(err));
+ else
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPLErr,
+ "Bad value %s on query-mode keyword %s: %s"),
+ q,f,
+ strerror(err));
+
+ } else {
+ if (filename)
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPLFile,
+ "Bad value %s on query-mode keyword %s on line %d on file %s"),
+ q,f,lineno,filename);
+ else
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPL,
+ "Bad value %s on query-mode keyword %s"),
+ q,f);
+ }
+
+ if (end > q) { /* If not keyword */
+ if (val < 0)
+ prx_max_skip_process = 0;
+ else if (val > MAX_prx_processes)
+ prx_max_processes = MAX_prx_processes;
+ else
+ prx_max_skip_process = val;
+ }
+
+ } else
+ prx_max_skip_process = val;
+
+ } else
+ goto value_missing;
+ break;
+
+ case qmp_parallel_lookup_max_time:
+ errno = 0;
+ if (q) {
+ char * end = NULL;
+ long val = strtol(q,&end,10);
+ int err = errno;
+
+ resolv_stalled_seconds_value[0] = '\0';
+
+ if (0 == err) {
+ if ('\0' == *end ||
+ 0 == strcmp(end,"s")) { /* seconds */
+
+ if (val >= MIN_stalled_seconds && val <= MAX_stalled_seconds) {
+ resolv_stalled_seconds = val;
+
+ if (strlen(q) < sizeof resolv_stalled_seconds_value)
+ strfcpy(resolv_stalled_seconds_value,q, + sizeof resolv_stalled_seconds_value);
+ } else {
+
+ if (val < MIN_stalled_seconds)
+ resolv_stalled_seconds = MIN_stalled_seconds;
+ else
+ resolv_stalled_seconds = MAX_stalled_seconds;
+
+ goto bad_value;
+ }
+
+ } else if ( 0 == strcmp(end,"m")) { /* minutes */ + const int factor = 60;
+
+ /* Check overflow first */
+ if (val >= MIN_stalled_seconds / factor &&
+ val <= MAX_stalled_seconds / factor) {
+
+ /* Check exact value when multiplation does not overflow */
+
+ int res = val * factor;
+
+
+ if (res >= MIN_stalled_seconds && res <= MAX_stalled_seconds) {
+ resolv_stalled_seconds = res;
+
+ if (strlen(q) < sizeof resolv_stalled_seconds_value)
+ strfcpy(resolv_stalled_seconds_value,q,
+ sizeof resolv_stalled_seconds_value);
+ } else {
+
+ if (res < MIN_stalled_seconds)
+ resolv_stalled_seconds = MIN_stalled_seconds;
+ else
+ resolv_stalled_seconds = MAX_stalled_seconds;
+
+ goto bad_value;
+ }
+
+ } else {
+ if (val < MIN_stalled_seconds / factor)
+ resolv_stalled_seconds = MIN_stalled_seconds;
+ else
+ resolv_stalled_seconds = MAX_stalled_seconds;
+
+ goto bad_value;
+ }
+
+ } else {
+ bad_value:
+ ok = 0;
+
+ if (filename)
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPLFile,
+ "Bad value %s on query-mode keyword %s on line %d on file %s"),
+ q,f,lineno,filename);
+ else
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPL,
+ "Bad value %s on query-mode keyword %s"),
+ q,f);
+ }
+
+ } else {
+ ok = 0;
+
+ if (filename)
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPLFileErr,
+ "Bad value %s on query-mode keyword %s on line %d on file %s: %s"),
+ q,f,lineno,filename,
+ strerror(err));
+ else
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvBadValueKwPLErr,
+ "Bad value %s on query-mode keyword %s: %s"),
+ q,f,
+ strerror(err));
+ }
+
+ } else {
+ value_missing:
+ ok = 0;
+
+ if (filename)
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvMissingValueKwPLFile,
+ "Missing value on query-mode keyword %s on line %d on file %s"),
+ f,lineno,filename);
+ else
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvMissingValueKwPL,
+ "Missing value on query-mode keyword %s"),
+ f);
+
+
+ }
+ break;
+
+ case NUM_query_mode_param: /* Not used */ break;
+ }
+
+ } else {
+
+ if (filename)
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvUnknowKeywordPLFile,
+ "Unknown query-mode keyword %s on line %d on file %s"),
+ f,lineno,filename);
+ else
+ lib_error(CATGETS(elm_msg_cat,
+ ResolvSet,
+ ResolvUnknowKeywordPL,
+ "Unknown query-mode keyword %s"),
+ f);
+
+ ok = 0;
+ }
+ }
+
+ fail:
+ free(temp);
+
+
+ } else {
+
+ if (query_mode >= 0 && query_mode < NUM_query_mode) {
+ query_mode_func_return_buffer =
+ strmcpy(query_mode_func_return_buffer,
+ QUERY_MODE[query_mode]);
+ ok = 1;
+ } else
+ goto fail1;
+
+ if (query_mode ||
+ helper_int_handling != DEFAULT_helper_int_handling) {
+ if (helper_int_handling >= 0 &&
+ helper_int_handling < NUM_helper_interrupt) {
+
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,"; ");
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,
+ QUERY_MODE_PARAM[qmp_helper]);
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,"=");
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,
+ HELPER_INTERRUPT[helper_int_handling]);
+
+ } else
+ ok = 0;
+ }
+
+ if (query_mode ||
+ prx_max_processes != MAX_PROCESS) {
+ if (prx_max_processes > 0) {
+
+ char * t = elm_message(FRM("; %s=%d"),
+ QUERY_MODE_PARAM[qmp_helper],
+ prx_max_processes);
+
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,t);
+ free(t);
+ } else
+ ok = 0;
+ }
+
+ if (query_mode ||
+ prx_max_skip_process != MAX_SKIP_PROCESS
+ ) {
+
+ if (prx_max_skip_process >= 0) {
+ char * t = elm_message(FRM("; %s=%d"),
+ QUERY_MODE_PARAM[qmp_helper_skip_limit],
+ prx_max_skip_process);
+
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,t);
+ free(t);
+ } else
+ ok = 0;
+ }
+
+ if (resolv_stalled_seconds_value[0]) {
+
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,"; ");
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,
+ QUERY_MODE_PARAM[qmp_parallel_lookup_max_time]);
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,"=");
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,
+ resolv_stalled_seconds_value);
+
+ } else if (query_mode ||
+ resolv_stalled_seconds != STALLED_SECONDS_DEFAULT) {
+
+ if (resolv_stalled_seconds > 0) {
+ if (resolv_stalled_seconds >= 60 &&
+ resolv_stalled_seconds % 60 == 0) {
+ int min = resolv_stalled_seconds / 60;
+
+ char * t = elm_message(FRM("; %s=%dm"),
+ QUERY_MODE_PARAM[qmp_parallel_lookup_max_time],
+ min);
+
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,t);
+ free(t);
+ } else {
+ char * t = elm_message(FRM("; %s=%ds"),
+ QUERY_MODE_PARAM[qmp_parallel_lookup_max_time],
+ resolv_stalled_seconds);
+
+ query_mode_func_return_buffer =
+ strmcat(query_mode_func_return_buffer,t);
+ free(t);
+ }
+ } else
+ ok = 0;
+ }
+
+ *value = query_mode_func_return_buffer;
+ }
+
+ fail1:
+ return ok;
+ }
+ /*
+ * Local Variables:
+ * mode:c
+ * c-basic-offset:4
+ * buffer-file-coding-system: iso-8859-1
+ * End:
+ */
+

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)