d5ab3b24159c90c201f2e85a58111d5c6f24e322
[yazpp-moved-to-github.git] / src / yaz-proxy-config.cpp
1 /*
2  * Copyright (c) 1998-2004, Index Data.
3  * See the file LICENSE for details.
4  * 
5  * $Id: yaz-proxy-config.cpp,v 1.25 2004-01-24 21:31:59 adam Exp $
6  */
7
8 #include <ctype.h>
9 #include <yaz/log.h>
10 #include <yaz++/proxy.h>
11
12 Yaz_ProxyConfig::Yaz_ProxyConfig()
13 {
14     m_copy = 0;
15 #if HAVE_XSLT
16     m_docPtr = 0;
17     m_proxyPtr = 0;
18 #endif
19 }
20
21 Yaz_ProxyConfig::~Yaz_ProxyConfig()
22 {
23 #if HAVE_XSLT
24     if (!m_copy && m_docPtr)
25         xmlFreeDoc(m_docPtr);
26 #endif
27 }
28
29 int Yaz_ProxyConfig::read_xml(const char *fname)
30 {
31 #if HAVE_XSLT
32     xmlDocPtr ndoc = xmlParseFile(fname);
33
34     if (!ndoc)
35     {
36         yaz_log(LOG_WARN, "Config file %s not found or parse error", fname);
37         return -1;  // no good
38     }
39     xmlNodePtr proxyPtr = xmlDocGetRootElement(ndoc);
40     if (!proxyPtr || proxyPtr->type != XML_ELEMENT_NODE ||
41         strcmp((const char *) proxyPtr->name, "proxy"))
42     {
43         yaz_log(LOG_WARN, "No proxy element in %s", fname);
44         xmlFreeDoc(ndoc);
45         return -1;
46     }
47     m_proxyPtr = proxyPtr;
48
49     // OK: release previous and make it the current one.
50     if (m_docPtr)
51         xmlFreeDoc(m_docPtr);
52     m_docPtr = ndoc;
53     return 0;
54 #else
55     return -2;
56 #endif
57 }
58
59 #if HAVE_XSLT
60 const char *Yaz_ProxyConfig::get_text(xmlNodePtr ptr)
61 {
62     for(ptr = ptr->children; ptr; ptr = ptr->next)
63         if (ptr->type == XML_TEXT_NODE)
64         {
65             xmlChar *t = ptr->content;
66             if (t)
67             {
68                 while (*t == ' ')
69                     t++;
70                 return (const char *) t;
71             }
72         }
73     return 0;
74 }
75 #endif
76
77 #if HAVE_XSLT
78 void Yaz_ProxyConfig::return_limit(xmlNodePtr ptr,
79                                    int *limit_bw,
80                                    int *limit_pdu,
81                                    int *limit_req)
82 {
83     for (ptr = ptr->children; ptr; ptr = ptr->next)
84     {
85         if (ptr->type == XML_ELEMENT_NODE 
86             && !strcmp((const char *) ptr->name, "bandwidth"))
87         {
88             const char *t = get_text(ptr);
89             if (t)
90                 *limit_bw = atoi(t);
91         }
92         if (ptr->type == XML_ELEMENT_NODE 
93             && !strcmp((const char *) ptr->name, "retrieve"))
94         {
95             const char *t = get_text(ptr);
96             if (t)
97                 *limit_req = atoi(t);
98         }
99         if (ptr->type == XML_ELEMENT_NODE 
100             && !strcmp((const char *) ptr->name, "pdu"))
101         {
102             const char *t = get_text(ptr);
103             if (t)
104                 *limit_pdu = atoi(t);
105         }
106     }
107 }
108 #endif
109
110 #if HAVE_XSLT
111 void Yaz_ProxyConfig::return_target_info(xmlNodePtr ptr,
112                                          const char **url,
113                                          int *limit_bw,
114                                          int *limit_pdu,
115                                          int *limit_req,
116                                          int *target_idletime,
117                                          int *client_idletime,
118                                          int *keepalive_limit_bw,
119                                          int *keepalive_limit_pdu,
120                                          int *pre_init,
121                                          const char **cql2rpn)
122 {
123     *pre_init = 0;
124     int no_url = 0;
125     ptr = ptr->children;
126     for (; ptr; ptr = ptr->next)
127     {
128         if (ptr->type == XML_ELEMENT_NODE 
129             && !strcmp((const char *) ptr->name, "preinit"))
130         {
131             const char *v = get_text(ptr);
132             *pre_init = v ? atoi(v) : 1;
133         }
134         if (ptr->type == XML_ELEMENT_NODE 
135             && !strcmp((const char *) ptr->name, "url"))
136         {
137             const char *t = get_text(ptr);
138             if (t && no_url < MAX_ZURL_PLEX)
139             {
140                 url[no_url++] = t;
141                 url[no_url] = 0;
142             }
143         }
144         if (ptr->type == XML_ELEMENT_NODE 
145             && !strcmp((const char *) ptr->name, "keepalive"))
146         {
147             int dummy;
148             *keepalive_limit_bw = 500000;
149             *keepalive_limit_pdu = 1000;
150             return_limit(ptr, keepalive_limit_bw, keepalive_limit_pdu,
151                          &dummy);
152         }
153         if (ptr->type == XML_ELEMENT_NODE 
154             && !strcmp((const char *) ptr->name, "limit"))
155             return_limit(ptr, limit_bw, limit_pdu, limit_req);
156         if (ptr->type == XML_ELEMENT_NODE 
157             && !strcmp((const char *) ptr->name, "target-timeout"))
158         {
159             const char *t = get_text(ptr);
160             if (t)
161             {
162                 *target_idletime = atoi(t);
163                 if (*target_idletime < 0)
164                     *target_idletime = 0;
165             }
166         }
167         if (ptr->type == XML_ELEMENT_NODE 
168             && !strcmp((const char *) ptr->name, "client-timeout"))
169         {
170             const char *t = get_text(ptr);
171             if (t)
172             {
173                 *client_idletime = atoi(t);
174                 if (*client_idletime < 0)
175                     *client_idletime = 0;
176             }
177         }
178         if (ptr->type == XML_ELEMENT_NODE 
179             && !strcmp((const char *) ptr->name, "cql2rpn"))
180         {
181             const char *t = get_text(ptr);
182             if (t)
183                 *cql2rpn = t;
184         }
185     }
186 }
187 #endif
188
189 int Yaz_ProxyConfig::atoi_l(const char **cp)
190 {
191     int v = 0;
192     while (**cp && isdigit(**cp))
193     {
194         v = v*10 + (**cp - '0');
195         (*cp)++;
196     }
197     return v;
198 }
199
200 int Yaz_ProxyConfig::match_list(int v, const char *m)
201 {
202   while(m && *m)
203   {
204       while(*m && isspace(*m))
205           m++;
206       if (*m == '*')
207           return 1;
208       int l = atoi_l(&m);
209       int h = l;
210       if (*m == '-')
211       {
212           ++m;
213           h = atoi_l(&m);
214       }
215       if (v >= l && v <= h)
216           return 1;
217       if (*m == ',')
218           m++;
219   }
220   return 0;
221 }
222
223 #if HAVE_XSLT
224 int Yaz_ProxyConfig::check_type_1_attributes(ODR odr, xmlNodePtr ptrl,
225                                              Z_AttributeList *attrs,
226                                              char **addinfo)
227 {
228     int i;
229     for (i = 0; i<attrs->num_attributes; i++)
230     {
231         Z_AttributeElement *el = attrs->attributes[i];
232         
233         if (!el->attributeType)
234             continue;
235         int type = *el->attributeType;
236         int *value = 0;
237         
238         if (el->which == Z_AttributeValue_numeric && el->value.numeric)
239             value = el->value.numeric;
240         
241         xmlNodePtr ptr;
242         for(ptr = ptrl->children; ptr; ptr = ptr->next)
243         {
244             if (ptr->type == XML_ELEMENT_NODE &&
245                 !strcmp((const char *) ptr->name, "attribute"))
246             {
247                 const char *match_type = 0;
248                 const char *match_value = 0;
249                 const char *match_error = 0;
250                 struct _xmlAttr *attr;
251                 for (attr = ptr->properties; attr; attr = attr->next)
252                 {
253                     if (!strcmp((const char *) attr->name, "type") &&
254                         attr->children && attr->children->type == XML_TEXT_NODE)
255                         match_type = (const char *) attr->children->content;
256                     if (!strcmp((const char *) attr->name, "value") &&
257                         attr->children && attr->children->type == XML_TEXT_NODE)
258                         match_value = (const char *) attr->children->content;
259                     if (!strcmp((const char *) attr->name, "error") &&
260                         attr->children && attr->children->type == XML_TEXT_NODE)
261                         match_error = (const char *) attr->children->content;
262                 }
263                 if (match_type && match_value)
264                 {
265                     char addinfo_str[20];
266                     if (!match_list(type, match_type))
267                         continue;
268                     
269                     *addinfo_str = '\0';
270                     if (!strcmp(match_type, "*"))
271                         sprintf (addinfo_str, "%d", type);
272                     else if (value)
273                     {
274                         if (!match_list(*value, match_value))
275                             continue;
276                         sprintf (addinfo_str, "%d", *value);
277                     }
278                     else
279                         continue;
280                     
281                     if (match_error)
282                     {
283                         if (*addinfo_str)
284                             *addinfo = odr_strdup(odr, addinfo_str);
285                         return atoi(match_error);
286                     }
287                     break;
288                 }
289             }
290         }
291     }
292     return 0;
293 }
294 #endif
295
296 #if HAVE_XSLT
297 int Yaz_ProxyConfig::check_type_1_structure(ODR odr, xmlNodePtr ptr,
298                                             Z_RPNStructure *q,
299                                             char **addinfo)
300 {
301     if (q->which == Z_RPNStructure_complex)
302     {
303         int e = check_type_1_structure(odr, ptr, q->u.complex->s1, addinfo);
304         if (e)
305             return e;
306         e = check_type_1_structure(odr, ptr, q->u.complex->s2, addinfo);
307         return e;
308     }
309     else if (q->which == Z_RPNStructure_simple)
310     {
311         if (q->u.simple->which == Z_Operand_APT)
312         {
313             return check_type_1_attributes(
314                 odr, ptr, q->u.simple->u.attributesPlusTerm->attributes,
315                 addinfo);
316         }
317     }
318     return 0;
319 }
320 #endif
321
322 #if HAVE_XSLT
323 int Yaz_ProxyConfig::check_type_1(ODR odr, xmlNodePtr ptr, Z_RPNQuery *query,
324                                   char **addinfo)
325 {
326     // possibly check for Bib-1
327     return check_type_1_structure(odr, ptr, query->RPNStructure, addinfo);
328 }
329 #endif
330
331 int Yaz_ProxyConfig::check_query(ODR odr, const char *name, Z_Query *query,
332                                  char **addinfo)
333 {
334 #if HAVE_XSLT
335     xmlNodePtr ptr;
336     
337     ptr = find_target_node(name, 0);
338     if (ptr)
339     {
340         if (query->which == Z_Query_type_1 || query->which == Z_Query_type_101)
341             return check_type_1(odr, ptr, query->u.type_1, addinfo);
342     }
343 #endif
344     return 0;
345 }
346
347 #if HAVE_XSLT
348 int Yaz_ProxyConfig::check_schema(xmlNodePtr ptr, Z_RecordComposition *comp,
349                                   const char *schema_identifier)
350 {
351     char *esn = 0;
352     int default_match = 1;
353     if (comp && comp->which == Z_RecordComp_simple &&
354         comp->u.simple && comp->u.simple->which == Z_ElementSetNames_generic)
355     {
356         esn = comp->u.simple->u.generic;
357     }
358     // if no ESN/schema was given accept..
359     if (!esn)
360         return 1;
361     // check if schema identifier match
362     if (schema_identifier && !strcmp(esn, schema_identifier))
363         return 1;
364     // Check each name element
365     for (; ptr; ptr = ptr->next)
366     {
367         if (ptr->type == XML_ELEMENT_NODE 
368             && !strcmp((const char *) ptr->name, "name"))
369         {
370             xmlNodePtr tptr = ptr->children;
371             default_match = 0;
372             for (; tptr; tptr = tptr->next)
373                 if (tptr->type == XML_TEXT_NODE && tptr->content)
374                 {
375                     xmlChar *t = tptr->content;
376                     while (*t && isspace(*t))
377                         t++;
378                     int i = 0;
379                     while (esn[i] && esn[i] == t[i])
380                         i++;
381                     if (!esn[i] && (!t[i] || isspace(t[i])))
382                         return 1;
383                 }
384         }
385     }
386     return default_match;
387 }
388 #endif
389
390 int Yaz_ProxyConfig::check_syntax(ODR odr, const char *name,
391                                   Odr_oid *syntax, Z_RecordComposition *comp,
392                                   char **addinfo,
393                                   char **stylesheet, char **schema)
394 {
395     if (stylesheet)
396     {
397         xfree (*stylesheet);
398         *stylesheet = 0;
399     }
400     if (schema)
401     {
402         xfree (*schema);
403         *schema = 0;
404     }
405 #if HAVE_XSLT
406     int syntax_has_matched = 0;
407     xmlNodePtr ptr;
408     
409     ptr = find_target_node(name, 0);
410     if (!ptr)
411         return 0;
412     for(ptr = ptr->children; ptr; ptr = ptr->next)
413     {
414         if (ptr->type == XML_ELEMENT_NODE &&
415             !strcmp((const char *) ptr->name, "syntax"))
416         {
417             int match = 0;  // if we match record syntax
418             const char *match_type = 0;
419             const char *match_error = 0;
420             const char *match_marcxml = 0;
421             const char *match_stylesheet = 0;
422             const char *match_identifier = 0;
423             struct _xmlAttr *attr;
424             for (attr = ptr->properties; attr; attr = attr->next)
425             {
426                 if (!strcmp((const char *) attr->name, "type") &&
427                     attr->children && attr->children->type == XML_TEXT_NODE)
428                     match_type = (const char *) attr->children->content;
429                 if (!strcmp((const char *) attr->name, "error") &&
430                     attr->children && attr->children->type == XML_TEXT_NODE)
431                     match_error = (const char *) attr->children->content;
432                 if (!strcmp((const char *) attr->name, "marcxml") &&
433                     attr->children && attr->children->type == XML_TEXT_NODE)
434                     match_marcxml = (const char *) attr->children->content;
435                 if (!strcmp((const char *) attr->name, "stylesheet") &&
436                     attr->children && attr->children->type == XML_TEXT_NODE)
437                     match_stylesheet = (const char *) attr->children->content;
438                 if (!strcmp((const char *) attr->name, "identifier") &&
439                     attr->children && attr->children->type == XML_TEXT_NODE)
440                     match_identifier = (const char *) attr->children->content;
441             }
442             if (match_type)
443             {
444                 if (!strcmp(match_type, "*"))
445                     match = 1;
446                 else if (!strcmp(match_type, "none"))
447                 {
448                     if (syntax == 0)
449                         match = 1;
450                 }
451                 else if (syntax)
452                 {
453                     int match_oid[OID_SIZE];
454                     oid_name_to_oid(CLASS_RECSYN, match_type, match_oid);
455                     if (oid_oidcmp(match_oid, syntax) == 0)
456                         match = 1;
457                 }
458             }
459             if (match)
460             {
461                 if (!match_error)
462                     syntax_has_matched = 1;
463                 match = check_schema(ptr->children, comp, match_identifier);
464             }
465             if (match)
466             {
467                 if (stylesheet && match_stylesheet)
468                 {
469                     xfree(*stylesheet);
470                     *stylesheet = xstrdup(match_stylesheet);
471                 }
472                 if (schema && match_identifier)
473                 {
474                     xfree(*schema);
475                     *schema = xstrdup(match_identifier);
476                 }
477                 if (match_marcxml)
478                 {
479                     return -1;
480                 }
481                 if (match_error)
482                 {
483                     if (syntax_has_matched)  // if syntax OK, bad schema/ESN
484                         return 25;
485                     if (syntax)
486                     {
487                         char dotoid_str[100];
488                         oid_to_dotstring(syntax, dotoid_str);
489                         *addinfo = odr_strdup(odr, dotoid_str);
490                     }
491                     return atoi(match_error);
492                 }
493                 return 0;
494             }
495         }
496     }
497 #endif
498     return 0;
499 }
500
501 #if HAVE_XSLT
502 xmlNodePtr Yaz_ProxyConfig::find_target_db(xmlNodePtr ptr, const char *db)
503 {
504     xmlNodePtr dptr;
505     if (!db)
506         return ptr;
507     if (!ptr)
508         return 0;
509     for (dptr = ptr->children; dptr; dptr = dptr->next)
510         if (dptr->type == XML_ELEMENT_NODE &&
511             !strcmp((const char *) dptr->name, "database"))
512         {
513             struct _xmlAttr *attr;
514             for (attr = dptr->properties; attr; attr = attr->next)
515                 if (!strcmp((const char *) attr->name, "name"))
516                 {
517                     if (attr->children
518                         && attr->children->type==XML_TEXT_NODE
519                         && attr->children->content 
520                         && (!strcmp((const char *) attr->children->content, db)
521                             || !strcmp((const char *) attr->children->content,
522                                        "*")))
523                         return dptr;
524                 }
525         }
526     return ptr;
527 }
528     
529 xmlNodePtr Yaz_ProxyConfig::find_target_node(const char *name, const char *db)
530 {
531     xmlNodePtr ptr;
532     if (!m_proxyPtr)
533         return 0;
534     for (ptr = m_proxyPtr->children; ptr; ptr = ptr->next)
535     {
536         if (ptr->type == XML_ELEMENT_NODE &&
537             !strcmp((const char *) ptr->name, "target"))
538         {
539             // default one ? 
540             if (!name)
541             {
542                 // <target default="1"> ?
543                 struct _xmlAttr *attr;
544                 for (attr = ptr->properties; attr; attr = attr->next)
545                     if (!strcmp((const char *) attr->name, "default") &&
546                         attr->children && attr->children->type == XML_TEXT_NODE)
547                     {
548                         xmlChar *t = attr->children->content;
549                         if (!t || *t == '1')
550                         {
551                             return find_target_db(ptr, db);
552                         }
553                     }
554             }
555             else
556             {
557                 // <target name="name"> ?
558                 struct _xmlAttr *attr;
559                 for (attr = ptr->properties; attr; attr = attr->next)
560                     if (!strcmp((const char *) attr->name, "name"))
561                     {
562                         if (attr->children
563                             && attr->children->type==XML_TEXT_NODE
564                             && attr->children->content 
565                             && (!strcmp((const char *) attr->children->content,
566                                         name)
567                                 || !strcmp((const char *) attr->children->content,
568                                            "*")))
569                         {
570                             return find_target_db(ptr, db);
571                         }
572                     }
573             }
574         }
575     }
576     return 0;
577 }
578 #endif
579
580 int Yaz_ProxyConfig::get_target_no(int no,
581                                    const char **name,
582                                    const char **url,
583                                    int *limit_bw,
584                                    int *limit_pdu,
585                                    int *limit_req,
586                                    int *target_idletime,
587                                    int *client_idletime,
588                                    int *max_clients,
589                                    int *keepalive_limit_bw,
590                                    int *keepalive_limit_pdu,
591                                    int *pre_init,
592                                    const char **cql2rpn)
593 {
594 #if HAVE_XSLT
595     xmlNodePtr ptr;
596     if (!m_proxyPtr)
597         return 0;
598     int i = 0;
599     for (ptr = m_proxyPtr->children; ptr; ptr = ptr->next)
600         if (ptr->type == XML_ELEMENT_NODE &&
601             !strcmp((const char *) ptr->name, "target"))
602         {
603             if (i == no)
604             {
605                 struct _xmlAttr *attr;
606                 for (attr = ptr->properties; attr; attr = attr->next)
607                     if (!strcmp((const char *) attr->name, "name"))
608                     {
609                         if (attr->children
610                             && attr->children->type==XML_TEXT_NODE
611                             && attr->children->content)
612                             *name = (const char *) attr->children->content;
613                     }
614                 return_target_info(ptr, url, limit_bw, limit_pdu, limit_req,
615                                    target_idletime, client_idletime,
616                                    keepalive_limit_bw, keepalive_limit_pdu,
617                                    pre_init, cql2rpn);
618                 return 1;
619             }
620             i++;
621         }
622 #endif
623     return 0;
624 }
625
626 int Yaz_ProxyConfig::mycmp(const char *hay, const char *item, size_t len)
627 {
628     if (len == strlen(item) && memcmp(hay, item, len) == 0)
629         return 1;
630     return 0;
631 }
632
633 void Yaz_ProxyConfig::get_generic_info(int *log_mask,
634                                        int *max_clients)
635 {
636 #if HAVE_XSLT
637     xmlNodePtr ptr;
638     if (!m_proxyPtr)
639         return;
640     for (ptr = m_proxyPtr->children; ptr; ptr = ptr->next)
641     {
642         if (ptr->type == XML_ELEMENT_NODE 
643             && !strcmp((const char *) ptr->name, "log"))
644         {
645             const char *v = get_text(ptr);
646             *log_mask = 0;
647             while (v && *v)
648             {
649                 const char *cp = v;
650                 while (*cp && *cp != ',' && !isspace(*cp))
651                     cp++;
652                 size_t len = cp - v;
653                 if (mycmp(v, "client-apdu", len))
654                     *log_mask |= PROXY_LOG_APDU_CLIENT;
655                 if (mycmp(v, "server-apdu", len))
656                     *log_mask |= PROXY_LOG_APDU_SERVER;
657                 if (mycmp(v, "client-requests", len))
658                     *log_mask |= PROXY_LOG_REQ_CLIENT;
659                 if (mycmp(v, "server-requests", len))
660                     *log_mask |= PROXY_LOG_REQ_SERVER;
661                 if (isdigit(*v))
662                     *log_mask |= atoi(v);
663                 if (*cp == ',')
664                     cp++;
665                 while (*cp && isspace(*cp))
666                     cp++;
667                 v = cp;
668             }
669         }
670         if (ptr->type == XML_ELEMENT_NODE &&
671             !strcmp((const char *) ptr->name, "max-clients"))
672         {
673             const char *t = get_text(ptr);
674             if (t)
675             {
676                 *max_clients = atoi(t);
677                 if (*max_clients  < 1)
678                     *max_clients = 1;
679             }
680         }
681     }
682 #endif
683 }
684
685 char *Yaz_ProxyConfig::get_explain(ODR odr, const char *name, const char *db,
686                                    int *len)
687 {
688 #if HAVE_XSLT
689     xmlNodePtr ptr = find_target_node(name, db);
690     if (ptr)
691     {
692         ptr = ptr->children;
693         for (; ptr; ptr = ptr->next)
694             if (ptr->type == XML_ELEMENT_NODE &&
695                 !strcmp((const char *) ptr->name, "explain"))
696             {
697                 xmlNodePtr ptr1 = ptr->children;
698                 if (db)
699                 {
700                     for (; ptr1; ptr1 = ptr1->next)
701                         if (ptr1->type == XML_ELEMENT_NODE &&
702                             !strcmp((const char *) ptr1->name, "serverInfo"))
703                             break;
704                     if (!ptr1)
705                         continue;
706                     for (ptr1 = ptr1->children; ptr; ptr1 = ptr1->next)
707                         if (ptr1->type == XML_ELEMENT_NODE &&
708                             !strcmp((const char *) ptr1->name, "database"))
709                             break;
710                     
711                     if (!ptr1)
712                         continue;
713                     for (ptr1 = ptr1->children; ptr1; ptr1 = ptr1->next)
714                         if (ptr1->type == XML_TEXT_NODE &&
715                             ptr1->content &&
716                             !strcmp((const char *) ptr1->content, db))
717                             break;
718                     if (!ptr1)
719                         continue;
720                 }
721                 xmlNodePtr ptr2 = xmlCopyNode(ptr, 1);
722
723                 xmlDocPtr doc = xmlNewDoc((const xmlChar *) "1.0");
724                 
725                 xmlDocSetRootElement(doc, ptr2);
726                 
727                 xmlChar *buf_out;
728                 xmlDocDumpMemory(doc, &buf_out, len);
729                 char *content = (char*) odr_malloc(odr, *len);
730                 memcpy(content, buf_out, *len);
731                 
732                 xmlFree(buf_out);
733                 xmlFreeDoc(doc);
734                 return content;
735             }
736     }
737 #endif
738     yaz_log(LOG_WARN, "No explain node");
739     return 0;
740 }
741
742 void Yaz_ProxyConfig::get_target_info(const char *name,
743                                       const char **url,
744                                       int *limit_bw,
745                                       int *limit_pdu,
746                                       int *limit_req,
747                                       int *target_idletime,
748                                       int *client_idletime,
749                                       int *max_clients,
750                                       int *keepalive_limit_bw,
751                                       int *keepalive_limit_pdu,
752                                       int *pre_init,
753                                       const char **cql2rpn)
754 {
755 #if HAVE_XSLT
756     xmlNodePtr ptr;
757     if (!m_proxyPtr)
758     {
759         url[0] = name;
760         url[1] = 0;
761         return;
762     }
763     url[0] = 0;
764     for (ptr = m_proxyPtr->children; ptr; ptr = ptr->next)
765     {
766         if (ptr->type == XML_ELEMENT_NODE &&
767             !strcmp((const char *) ptr->name, "max-clients"))
768         {
769             const char *t = get_text(ptr);
770             if (t)
771             {
772                 *max_clients = atoi(t);
773                 if (*max_clients  < 1)
774                     *max_clients = 1;
775             }
776         }
777     }
778     ptr = find_target_node(name, 0);
779     if (ptr)
780     {
781         if (name)
782         {
783             url[0] = name;
784             url[1] = 0;
785         }
786         return_target_info(ptr, url, limit_bw, limit_pdu, limit_req,
787                            target_idletime, client_idletime,
788                            keepalive_limit_bw, keepalive_limit_pdu,
789                            pre_init, cql2rpn);
790     }
791 #else
792     *url = name;
793     return;
794 #endif
795 }
796
797