Refactor how total hits are calculated
[pazpar2-moved-to-github.git] / src / client.c
1 /* This file is part of Pazpar2.
2    Copyright (C) 2006-2011 Index Data
3
4 Pazpar2 is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
18 */
19
20 /** \file client.c
21     \brief Z39.50 client 
22 */
23
24 #if HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #if HAVE_SYS_TIME_H
31 #include <sys/time.h>
32 #endif
33 #if HAVE_UNISTD_H
34 #include <unistd.h>
35 #endif
36 #include <signal.h>
37 #include <assert.h>
38
39 #include <yaz/marcdisp.h>
40 #include <yaz/comstack.h>
41 #include <yaz/tcpip.h>
42 #include <yaz/proto.h>
43 #include <yaz/readconf.h>
44 #include <yaz/pquery.h>
45 #include <yaz/otherinfo.h>
46 #include <yaz/yaz-util.h>
47 #include <yaz/nmem.h>
48 #include <yaz/query-charset.h>
49 #include <yaz/querytowrbuf.h>
50 #include <yaz/oid_db.h>
51 #include <yaz/diagbib1.h>
52 #include <yaz/snprintf.h>
53 #include <yaz/rpn2cql.h>
54 #include <yaz/rpn2solr.h>
55
56 #define USE_TIMING 0
57 #if USE_TIMING
58 #include <yaz/timing.h>
59 #endif
60
61 #include "ppmutex.h"
62 #include "session.h"
63 #include "parameters.h"
64 #include "client.h"
65 #include "connection.h"
66 #include "settings.h"
67 #include "relevance.h"
68 #include "incref.h"
69
70 static YAZ_MUTEX g_mutex = 0;
71 static int no_clients = 0;
72 static int no_clients_total = 0;
73
74 static int client_use(int delta)
75 {
76     int clients;
77     if (!g_mutex)
78         yaz_mutex_create(&g_mutex);
79     yaz_mutex_enter(g_mutex);
80     no_clients += delta;
81     if (delta > 0)
82         no_clients_total += delta;
83     clients = no_clients;
84     yaz_mutex_leave(g_mutex);
85     yaz_log(YLOG_DEBUG, "%s clients=%d", delta == 0 ? "" : (delta > 0 ? "INC" : "DEC"), clients);
86     return clients;
87 }
88
89 int  clients_count(void) {
90     return client_use(0);
91 }
92
93 int  clients_count_total(void) {
94     int total = 0;
95     if (!g_mutex)
96         return 0;
97     yaz_mutex_enter(g_mutex);
98     total = no_clients_total;
99     yaz_mutex_leave(g_mutex);
100     return total;
101 }
102
103
104 /** \brief Represents client state for a connection to one search target */
105 struct client {
106     struct session_database *database;
107     struct connection *connection;
108     struct session *session;
109     char *pquery; // Current search
110     char *cqlquery; // used for SRU targets only
111     Odr_int hits;
112     int record_offset;
113     int maxrecs;
114     int startrecs;
115     int diagnostic;
116     int preferred;
117     enum client_state state;
118     struct show_raw *show_raw;
119     ZOOM_resultset resultset;
120     YAZ_MUTEX mutex;
121     int ref_count;
122     char *id;
123 };
124
125 struct show_raw {
126     int active; // whether this request has been sent to the server
127     int position;
128     int binary;
129     char *syntax;
130     char *esn;
131     void (*error_handler)(void *data, const char *addinfo);
132     void (*record_handler)(void *data, const char *buf, size_t sz);
133     void *data;
134     struct show_raw *next;
135 };
136
137 static const char *client_states[] = {
138     "Client_Connecting",
139     "Client_Idle",
140     "Client_Working",
141     "Client_Error",
142     "Client_Failed",
143     "Client_Disconnected"
144 };
145
146 const char *client_get_state_str(struct client *cl)
147 {
148     return client_states[cl->state];
149 }
150
151 enum client_state client_get_state(struct client *cl)
152 {
153     return cl->state;
154 }
155
156 void client_set_state(struct client *cl, enum client_state st)
157 {
158     int was_active = 0;
159     if (client_is_active(cl))
160         was_active = 1;
161     cl->state = st;
162     /* If client is going from being active to inactive and all clients
163        are now idle we fire a watch for the session . The assumption is
164        that session is not mutex locked if client is already active */
165     if (was_active && !client_is_active(cl) && cl->session)
166     {
167
168         int no_active = session_active_clients(cl->session);
169         yaz_log(YLOG_DEBUG, "%s: releasing watches on zero active: %d",
170                 client_get_id(cl), no_active);
171         if (no_active == 0) {
172             session_alert_watch(cl->session, SESSION_WATCH_SHOW);
173             session_alert_watch(cl->session, SESSION_WATCH_SHOW_PREF);
174         }
175     }
176 }
177
178 static void client_show_raw_error(struct client *cl, const char *addinfo);
179
180 struct connection *client_get_connection(struct client *cl)
181 {
182     return cl->connection;
183 }
184
185 struct session_database *client_get_database(struct client *cl)
186 {
187     return cl->database;
188 }
189
190 struct session *client_get_session(struct client *cl)
191 {
192     return cl->session;
193 }
194
195 const char *client_get_pquery(struct client *cl)
196 {
197     return cl->pquery;
198 }
199
200 static void client_send_raw_present(struct client *cl);
201 static int nativesyntax_to_type(struct session_database *sdb, char *type,
202                                 ZOOM_record rec);
203
204 static void client_show_immediate(
205     ZOOM_resultset resultset, struct session_database *sdb, int position,
206     void *data,
207     void (*error_handler)(void *data, const char *addinfo),
208     void (*record_handler)(void *data, const char *buf, size_t sz),
209     int binary)
210 {
211     ZOOM_record rec = 0;
212     char type[80];
213     const char *buf;
214     int len;
215
216     if (!resultset)
217     {
218         error_handler(data, "no resultset");
219         return;
220     }
221     rec = ZOOM_resultset_record(resultset, position-1);
222     if (!rec)
223     {
224         error_handler(data, "no record");
225         return;
226     }
227     if (binary)
228         strcpy(type, "raw");
229     else
230         nativesyntax_to_type(sdb, type, rec);
231     buf = ZOOM_record_get(rec, type, &len);
232     if (!buf)
233     {
234         error_handler(data, "no record");
235         return;
236     }
237     record_handler(data, buf, len);
238 }
239
240
241 int client_show_raw_begin(struct client *cl, int position,
242                           const char *syntax, const char *esn,
243                           void *data,
244                           void (*error_handler)(void *data, const char *addinfo),
245                           void (*record_handler)(void *data, const char *buf,
246                                                  size_t sz),
247                           int binary)
248 {
249     if (syntax == 0 && esn == 0)
250         client_show_immediate(cl->resultset, client_get_database(cl),
251                               position, data,
252                               error_handler, record_handler,
253                               binary);
254     else
255     {
256         struct show_raw *rr, **rrp;
257
258         if (!cl->connection)
259             return -1;
260     
261
262         rr = xmalloc(sizeof(*rr));
263         rr->position = position;
264         rr->active = 0;
265         rr->data = data;
266         rr->error_handler = error_handler;
267         rr->record_handler = record_handler;
268         rr->binary = binary;
269         if (syntax)
270             rr->syntax = xstrdup(syntax);
271         else
272             rr->syntax = 0;
273         if (esn)
274             rr->esn = xstrdup(esn);
275         else
276             rr->esn = 0;
277         rr->next = 0;
278         
279         for (rrp = &cl->show_raw; *rrp; rrp = &(*rrp)->next)
280             ;
281         *rrp = rr;
282         
283         if (cl->state == Client_Failed)
284         {
285             client_show_raw_error(cl, "client failed");
286         }
287         else if (cl->state == Client_Disconnected)
288         {
289             client_show_raw_error(cl, "client disconnected");
290         }
291         else
292         {
293             client_send_raw_present(cl);
294         }
295     }
296     return 0;
297 }
298
299 static void client_show_raw_delete(struct show_raw *r)
300 {
301     xfree(r->syntax);
302     xfree(r->esn);
303     xfree(r);
304 }
305
306 void client_show_raw_remove(struct client *cl, void *data)
307 {
308     struct show_raw *rr = data;
309     struct show_raw **rrp = &cl->show_raw;
310     while (*rrp != rr)
311         rrp = &(*rrp)->next;
312     if (*rrp)
313     {
314         *rrp = rr->next;
315         client_show_raw_delete(rr);
316     }
317 }
318
319 void client_show_raw_dequeue(struct client *cl)
320 {
321     struct show_raw *rr = cl->show_raw;
322
323     cl->show_raw = rr->next;
324     client_show_raw_delete(rr);
325 }
326
327 static void client_show_raw_error(struct client *cl, const char *addinfo)
328 {
329     while (cl->show_raw)
330     {
331         cl->show_raw->error_handler(cl->show_raw->data, addinfo);
332         client_show_raw_dequeue(cl);
333     }
334 }
335
336 static void client_send_raw_present(struct client *cl)
337 {
338     struct session_database *sdb = client_get_database(cl);
339     struct connection *co = client_get_connection(cl);
340     ZOOM_resultset set = cl->resultset;
341
342     int offset = cl->show_raw->position;
343     const char *syntax = 0;
344     const char *elements = 0;
345
346     assert(cl->show_raw);
347     assert(set);
348
349     yaz_log(YLOG_DEBUG, "%s: trying to present %d record(s) from %d",
350             client_get_id(cl), 1, offset);
351
352     if (cl->show_raw->syntax)
353         syntax = cl->show_raw->syntax;
354     else
355         syntax = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
356     ZOOM_resultset_option_set(set, "preferredRecordSyntax", syntax);
357
358     if (cl->show_raw->esn)
359         elements = cl->show_raw->esn;
360     else
361         elements = session_setting_oneval(sdb, PZ_ELEMENTS);
362     if (elements && *elements)
363         ZOOM_resultset_option_set(set, "elementSetName", elements);
364
365     ZOOM_resultset_records(set, 0, offset-1, 1);
366     cl->show_raw->active = 1;
367
368     connection_continue(co);
369 }
370
371 static int nativesyntax_to_type(struct session_database *sdb, char *type,
372                                 ZOOM_record rec)
373 {
374     const char *s = session_setting_oneval(sdb, PZ_NATIVESYNTAX);
375
376     if (s && *s)
377     {
378         if (!strncmp(s, "iso2709", 7))
379         {
380             const char *cp = strchr(s, ';');
381             yaz_snprintf(type, 80, "xml; charset=%s", cp ? cp+1 : "marc-8s");
382         }
383         else if (!strncmp(s, "xml", 3))
384         {
385             strcpy(type, "xml");
386         }
387         else if (!strncmp(s, "txml", 4))
388         {
389             const char *cp = strchr(s, ';');
390             yaz_snprintf(type, 80, "txml; charset=%s", cp ? cp+1 : "marc-8s");
391         }
392         else
393             return -1;
394         return 0;
395     }
396     else  /* attempt to deduce structure */
397     {
398         const char *syntax = ZOOM_record_get(rec, "syntax", NULL);
399         if (syntax)
400         {
401             if (!strcmp(syntax, "XML"))
402             {
403                 strcpy(type, "xml");
404                 return 0;
405             }
406             else if (!strcmp(syntax, "USmarc") || !strcmp(syntax, "MARC21"))
407             {
408                 strcpy(type, "xml; charset=marc8-s");
409                 return 0;
410             }
411             else return -1;
412         }
413         else return -1;
414     }
415 }
416
417 /**
418  * TODO Consider thread safety!!!
419  *
420  */
421 void client_report_facets(struct client *cl, ZOOM_resultset rs)
422 {
423     struct session_database *sdb = client_get_database(cl);
424     ZOOM_facet_field *facets = ZOOM_resultset_facets(rs);
425
426     if (sdb && facets)
427     {
428         struct session *se = client_get_session(cl);
429         int facet_num = ZOOM_resultset_facets_size(rs);
430         struct setting *s;
431
432         for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
433         {
434             const char *p = strchr(s->name + 3, ':');
435             if (p && p[1] && s->value && s->value[0])
436             {
437                 int facet_idx;
438                 p++; /* p now holds logical facet name */
439                 for (facet_idx = 0; facet_idx < facet_num; facet_idx++)
440                 {
441                     const char *native_name =
442                         ZOOM_facet_field_name(facets[facet_idx]);
443                     if (native_name && !strcmp(s->value, native_name))
444                     {
445                         size_t term_idx;
446                         size_t term_num =
447                             ZOOM_facet_field_term_count(facets[facet_idx]);
448                         for (term_idx = 0; term_idx < term_num; term_idx++ )
449                         {
450                             int freq;
451                             const char *term =
452                                 ZOOM_facet_field_get_term(facets[facet_idx],
453                                                           term_idx, &freq);
454                             if (term)
455                                 add_facet(se, p, term, freq);
456                         }
457                         break;
458                     }
459                 }
460             }
461         }
462     }
463 }
464
465 static void ingest_raw_record(struct client *cl, ZOOM_record rec)
466 {
467     const char *buf;
468     int len;
469     char type[80];
470
471     if (cl->show_raw->binary)
472         strcpy(type, "raw");
473     else
474     {
475         struct session_database *sdb = client_get_database(cl);
476         nativesyntax_to_type(sdb, type, rec);
477     }
478
479     buf = ZOOM_record_get(rec, type, &len);
480     cl->show_raw->record_handler(cl->show_raw->data,  buf, len);
481     client_show_raw_dequeue(cl);
482 }
483
484 void client_check_preferred_watch(struct client *cl)
485 {
486     struct session *se = cl->session;
487     yaz_log(YLOG_DEBUG, "client_check_preferred_watch: %s ", client_get_id(cl));
488     if (se)
489     {
490         client_unlock(cl);
491         /* TODO possible threading issue. Session can have been destroyed */
492         if (session_is_preferred_clients_ready(se)) {
493             session_alert_watch(se, SESSION_WATCH_SHOW_PREF);
494         }
495         else
496             yaz_log(YLOG_DEBUG, "client_check_preferred_watch: Still locked on preferred targets.");
497
498         client_lock(cl);
499     }
500     else
501         yaz_log(YLOG_WARN, "client_check_preferred_watch: %s. No session!", client_get_id(cl));
502
503 }
504
505 void client_search_response(struct client *cl)
506 {
507     struct connection *co = cl->connection;
508     ZOOM_connection link = connection_get_link(co);
509     ZOOM_resultset resultset = cl->resultset;
510
511     const char *error, *addinfo = 0;
512     
513     if (ZOOM_connection_error(link, &error, &addinfo))
514     {
515         cl->hits = 0;
516         client_set_state(cl, Client_Error);
517         yaz_log(YLOG_WARN, "Search error %s (%s): %s",
518                 error, addinfo, client_get_id(cl));
519     }
520     else
521     {
522         yaz_log(YLOG_DEBUG, "client_search_response: hits "
523                 ODR_INT_PRINTF, cl->hits);
524         client_report_facets(cl, resultset);
525         cl->record_offset = cl->startrecs;
526         cl->hits = ZOOM_resultset_size(resultset);
527     }
528 }
529
530 void client_got_records(struct client *cl)
531 {
532     struct session *se = cl->session;
533     if (se)
534     {
535         client_unlock(cl);
536         session_alert_watch(se, SESSION_WATCH_SHOW);
537         session_alert_watch(se, SESSION_WATCH_RECORD);
538         client_lock(cl);
539     }
540 }
541
542 void client_record_response(struct client *cl)
543 {
544     struct connection *co = cl->connection;
545     ZOOM_connection link = connection_get_link(co);
546     ZOOM_resultset resultset = cl->resultset;
547     const char *error, *addinfo;
548
549     if (ZOOM_connection_error(link, &error, &addinfo))
550     {
551         client_set_state(cl, Client_Error);
552         yaz_log(YLOG_WARN, "Search error %s (%s): %s",
553             error, addinfo, client_get_id(cl));
554     }
555     else
556     {
557         ZOOM_record rec = 0;
558         const char *msg, *addinfo;
559         
560         if (cl->show_raw && cl->show_raw->active)
561         {
562             if ((rec = ZOOM_resultset_record(resultset,
563                                              cl->show_raw->position-1)))
564             {
565                 cl->show_raw->active = 0;
566                 ingest_raw_record(cl, rec);
567             }
568             else
569             {
570                 yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d",
571                         cl->show_raw->position-1);
572             }
573         }
574         else
575         {
576             int offset = cl->record_offset;
577             if ((rec = ZOOM_resultset_record(resultset, offset)))
578             {
579                 cl->record_offset++;
580                 if (cl->session == 0)
581                     ;
582                 else if (ZOOM_record_error(rec, &msg, &addinfo, 0))
583                 {
584                     yaz_log(YLOG_WARN, "Record error %s (%s): %s (rec #%d)",
585                             msg, addinfo, client_get_id(cl),
586                             cl->record_offset);
587                 }
588                 else
589                 {
590                     struct session_database *sdb = client_get_database(cl);
591                     NMEM nmem = nmem_create();
592                     const char *xmlrec;
593                     char type[80];
594
595                     if (nativesyntax_to_type(sdb, type, rec))
596                         yaz_log(YLOG_WARN, "Failed to determine record type");
597                     xmlrec = ZOOM_record_get(rec, type, NULL);
598                     if (!xmlrec)
599                         yaz_log(YLOG_WARN, "ZOOM_record_get failed from %s",
600                                 client_get_id(cl));
601                     else
602                     {
603                         /* OK = 0, -1 = failure, -2 = Filtered */
604                         if (ingest_record(cl, xmlrec, cl->record_offset, nmem) == -1)
605                             yaz_log(YLOG_WARN, "Failed to ingest from %s", client_get_id(cl));
606                     }
607                     nmem_destroy(nmem);
608                 }
609             }
610             else
611             {
612                 yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d",
613                         offset);
614             }
615         }
616     }
617 }
618
619 static void client_set_facets_request(struct client *cl, ZOOM_connection link)
620 {
621     struct session_database *sdb = client_get_database(cl);
622
623     WRBUF w = wrbuf_alloc();
624     
625     struct setting *s;
626
627     for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
628     {
629         const char *p = strchr(s->name + 3, ':');
630         if (!p)
631         {
632             yaz_log(YLOG_WARN, "Malformed facetmap name: %s", s->name);
633         }
634         else if (s->value && s->value[0])
635         {
636             wrbuf_puts(w, "@attr 1=");
637             yaz_encode_pqf_term(w, s->value, strlen(s->value));
638             if (s->next)
639                 wrbuf_puts(w, ",");
640         }
641     }
642     yaz_log(YLOG_LOG, "using facets str: %s", wrbuf_cstr(w));
643     ZOOM_connection_option_set(link, "facets",
644                                wrbuf_len(w) ? wrbuf_cstr(w) : 0);
645     wrbuf_destroy(w);
646 }
647
648 int client_has_facet(struct client *cl, const char *name)
649 {
650     struct session_database *sdb = client_get_database(cl);
651     struct setting *s;
652
653     for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
654     {
655         const char *p = strchr(s->name + 3, ':');
656         if (p && !strcmp(name, p + 1))
657             return 1;
658     }
659     return 0;
660 }
661
662 void client_start_search(struct client *cl, const char *sort_strategy,
663                          const char *sort_spec)
664 {
665     struct session_database *sdb = client_get_database(cl);
666     struct connection *co = client_get_connection(cl);
667     ZOOM_connection link = connection_get_link(co);
668     ZOOM_resultset rs;
669     const char *opt_piggyback   = session_setting_oneval(sdb, PZ_PIGGYBACK);
670     const char *opt_queryenc    = session_setting_oneval(sdb, PZ_QUERYENCODING);
671     const char *opt_elements    = session_setting_oneval(sdb, PZ_ELEMENTS);
672     const char *opt_requestsyn  = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
673     const char *opt_maxrecs     = session_setting_oneval(sdb, PZ_MAXRECS);
674     const char *opt_sru         = session_setting_oneval(sdb, PZ_SRU);
675     const char *opt_sort        = session_setting_oneval(sdb, PZ_SORT);
676     const char *opt_preferred   = session_setting_oneval(sdb, PZ_PREFERRED);
677     const char *extra_args      = session_setting_oneval(sdb, PZ_EXTRA_ARGS);
678     char maxrecs_str[24], startrecs_str[24];
679
680     assert(link);
681
682     cl->record_offset = 0;
683     cl->diagnostic = 0;
684
685     if (extra_args && *extra_args)
686         ZOOM_connection_option_set(link, "extraArgs", extra_args);
687
688     if (opt_preferred) {
689         cl->preferred = atoi(opt_preferred);
690         if (cl->preferred)
691             yaz_log(YLOG_LOG, "Target %s has preferred status: %d",
692                     client_get_id(cl), cl->preferred);
693     }
694     client_set_state(cl, Client_Working);
695
696     if (*opt_piggyback)
697         ZOOM_connection_option_set(link, "piggyback", opt_piggyback);
698     else
699         ZOOM_connection_option_set(link, "piggyback", "1");
700     if (*opt_queryenc)
701         ZOOM_connection_option_set(link, "rpnCharset", opt_queryenc);
702     if (*opt_sru && *opt_elements)
703         ZOOM_connection_option_set(link, "schema", opt_elements);
704     else if (*opt_elements)
705         ZOOM_connection_option_set(link, "elementSetName", opt_elements);
706     if (*opt_requestsyn)
707         ZOOM_connection_option_set(link, "preferredRecordSyntax", opt_requestsyn);
708
709     if (opt_maxrecs && *opt_maxrecs)
710     {
711         cl->maxrecs = atoi(opt_maxrecs);
712     }
713
714     /* convert back to string representation used in ZOOM API */
715     sprintf(maxrecs_str, "%d", cl->maxrecs);
716     ZOOM_connection_option_set(link, "count", maxrecs_str);
717
718     if (cl->maxrecs > 20)
719         ZOOM_connection_option_set(link, "presentChunk", "20");
720     else
721         ZOOM_connection_option_set(link, "presentChunk", maxrecs_str);
722
723     sprintf(startrecs_str, "%d", cl->startrecs);
724     ZOOM_connection_option_set(link, "start", startrecs_str);
725
726     /* TODO Verify does it break something for CQL targets(non-SOLR) ? */
727     /* facets definition is in PQF */
728     client_set_facets_request(cl, link);
729
730     if (cl->cqlquery)
731     {
732         ZOOM_query q = ZOOM_query_create();
733         yaz_log(YLOG_LOG, "Search %s CQL: %s", client_get_id(cl),
734                 cl->cqlquery);
735         ZOOM_query_cql(q, cl->cqlquery);
736         if (*opt_sort)
737             ZOOM_query_sortby(q, opt_sort);
738         if (sort_strategy && sort_spec)
739         {
740             yaz_log(YLOG_LOG, "applying %s %s", sort_strategy, sort_spec);
741             ZOOM_query_sortby2(q, sort_strategy, sort_spec);
742         }
743         rs = ZOOM_connection_search(link, q);
744         ZOOM_query_destroy(q);
745     }
746     else
747     {
748         ZOOM_query q = ZOOM_query_create();
749
750         yaz_log(YLOG_LOG, "Search %s PQF: %s", client_get_id(cl), cl->pquery);
751
752         ZOOM_query_prefix(q, cl->pquery);
753
754         if (sort_strategy && sort_spec)
755         {
756             yaz_log(YLOG_LOG, "applying %s %s", sort_strategy, sort_spec);
757             ZOOM_query_sortby2(q, sort_strategy, sort_spec);
758         }
759         rs = ZOOM_connection_search(link, q);
760         ZOOM_query_destroy(q);
761     }
762     ZOOM_resultset_destroy(cl->resultset);
763     cl->resultset = rs;
764     connection_continue(co);
765 }
766
767 struct client *client_create(const char *id)
768 {
769     struct client *cl = xmalloc(sizeof(*cl));
770     cl->maxrecs = 100;
771     cl->startrecs = 0;
772     cl->pquery = 0;
773     cl->cqlquery = 0;
774     cl->database = 0;
775     cl->connection = 0;
776     cl->session = 0;
777     cl->hits = 0;
778     cl->record_offset = 0;
779     cl->diagnostic = 0;
780     cl->state = Client_Disconnected;
781     cl->show_raw = 0;
782     cl->resultset = 0;
783     cl->mutex = 0;
784     pazpar2_mutex_create(&cl->mutex, "client");
785     cl->preferred = 0;
786     cl->ref_count = 1;
787     assert(id);
788     cl->id = xstrdup(id);
789     client_use(1);
790     
791     return cl;
792 }
793
794 void client_lock(struct client *c)
795 {
796     yaz_mutex_enter(c->mutex);
797 }
798
799 void client_unlock(struct client *c)
800 {
801     yaz_mutex_leave(c->mutex);
802 }
803
804 void client_incref(struct client *c)
805 {
806     pazpar2_incref(&c->ref_count, c->mutex);
807     yaz_log(YLOG_DEBUG, "client_incref c=%p %s cnt=%d",
808             c, client_get_id(c), c->ref_count);
809 }
810
811 int client_destroy(struct client *c)
812 {
813     if (c)
814     {
815         yaz_log(YLOG_DEBUG, "client_destroy c=%p %s cnt=%d",
816                 c, client_get_id(c), c->ref_count);
817         if (!pazpar2_decref(&c->ref_count, c->mutex))
818         {
819             xfree(c->pquery);
820             c->pquery = 0;
821             xfree(c->cqlquery);
822             c->cqlquery = 0;
823             xfree(c->id);
824             assert(!c->connection);
825
826             if (c->resultset)
827             {
828                 ZOOM_resultset_destroy(c->resultset);
829             }
830             yaz_mutex_destroy(&c->mutex);
831             xfree(c);
832             client_use(-1);
833             return 1;
834         }
835     }
836     return 0;
837 }
838
839 void client_set_connection(struct client *cl, struct connection *con)
840 {
841     if (cl->resultset)
842         ZOOM_resultset_release(cl->resultset);
843     if (con)
844     {
845         assert(cl->connection == 0);
846         cl->connection = con;
847         client_incref(cl);
848     }
849     else
850     {
851         cl->connection = con;
852         client_destroy(cl);
853     }
854 }
855
856 void client_disconnect(struct client *cl)
857 {
858     if (cl->state != Client_Idle)
859         client_set_state(cl, Client_Disconnected);
860     client_set_connection(cl, 0);
861 }
862
863
864 // Initialize CCL map for a target
865 static CCL_bibset prepare_cclmap(struct client *cl)
866 {
867     struct session_database *sdb = client_get_database(cl);
868     struct setting *s;
869     CCL_bibset res;
870
871     if (!sdb->settings)
872         return 0;
873     res = ccl_qual_mk();
874     for (s = sdb->settings[PZ_CCLMAP]; s; s = s->next)
875     {
876         char *p = strchr(s->name + 3, ':');
877         if (!p)
878         {
879             yaz_log(YLOG_WARN, "Malformed cclmap name: %s", s->name);
880             ccl_qual_rm(&res);
881             return 0;
882         }
883         p++;
884         ccl_qual_fitem(res, s->value, p);
885     }
886     return res;
887 }
888
889 // returns a xmalloced CQL query corresponding to the pquery in client
890 static char *make_cqlquery(struct client *cl)
891 {
892     cql_transform_t cqlt = cql_transform_create();
893     Z_RPNQuery *zquery;
894     char *r;
895     WRBUF wrb = wrbuf_alloc();
896     int status;
897     ODR odr_out = odr_createmem(ODR_ENCODE);
898
899     zquery = p_query_rpn(odr_out, cl->pquery);
900     yaz_log(YLOG_LOG, "PQF: %s", cl->pquery);
901     if ((status = cql_transform_rpn2cql_wrbuf(cqlt, wrb, zquery)))
902     {
903         yaz_log(YLOG_WARN, "Failed to generate CQL query, code=%d", status);
904         r = 0;
905     }
906     else
907     {
908         r = xstrdup(wrbuf_cstr(wrb));
909     }     
910     wrbuf_destroy(wrb);
911     odr_destroy(odr_out);
912     cql_transform_close(cqlt);
913     return r;
914 }
915
916 // returns a xmalloced SOLR query corresponding to the pquery in client
917 // TODO Could prob. be merge with the similar make_cqlquery
918 static char *make_solrquery(struct client *cl)
919 {
920     solr_transform_t sqlt = solr_transform_create();
921     Z_RPNQuery *zquery;
922     char *r;
923     WRBUF wrb = wrbuf_alloc();
924     int status;
925     ODR odr_out = odr_createmem(ODR_ENCODE);
926
927     zquery = p_query_rpn(odr_out, cl->pquery);
928     if (zquery == 0) {
929         yaz_log(YLOG_WARN, "Failed to generate RPN from PQF: %s", cl->pquery);
930         return 0;
931     }
932     yaz_log(YLOG_LOG, "PQF: %s", cl->pquery);
933     if ((status = solr_transform_rpn2solr_wrbuf(sqlt, wrb, zquery)))
934     {
935         yaz_log(YLOG_WARN, "Failed to generate SOLR query from PQF %s, code=%d", cl->pquery, status);
936         r = 0;
937     }
938     else
939     {
940         r = xstrdup(wrbuf_cstr(wrb));
941     }
942     wrbuf_destroy(wrb);
943     odr_destroy(odr_out);
944     solr_transform_close(sqlt);
945     return r;
946 }
947
948 static void apply_limit(struct session_database *sdb,
949                         facet_limits_t facet_limits,
950                         WRBUF w_pqf, WRBUF w_ccl)
951 {
952     int i = 0;
953     const char *name;
954     const char *value;
955     NMEM nmem_tmp = nmem_create();
956     for (i = 0; (name = facet_limits_get(facet_limits, i, &value)); i++)
957     {
958         struct setting *s = 0;
959         
960         for (s = sdb->settings[PZ_LIMITMAP]; s; s = s->next)
961         {
962             const char *p = strchr(s->name + 3, ':');
963             if (p && !strcmp(p + 1, name) && s->value)
964             {
965                 char **values = 0;
966                 int i, num = 0;
967                 nmem_strsplit_escape2(nmem_tmp, "|", value, &values,
968                                       &num, 1, '\\', 1);
969
970                 if (!strncmp(s->value, "rpn:", 4))
971                 {
972                     const char *pqf = s->value + 4;
973
974                     wrbuf_puts(w_pqf, "@and ");
975                     wrbuf_puts(w_pqf, pqf);
976                     wrbuf_puts(w_pqf, " ");
977                     for (i = 0; i < num; i++)
978                     {
979                         if (i < num - 1)
980                             wrbuf_puts(w_pqf, "@or ");
981                         yaz_encode_pqf_term(w_pqf, values[i],
982                                             strlen(values[i]));
983                     }
984                 }
985                 else if (!strncmp(s->value, "ccl:", 4))
986                 {
987                     const char *ccl = s->value + 4;
988
989                     wrbuf_puts(w_ccl, " and (");
990
991                     for (i = 0; i < num; i++)
992                     {
993                         if (i)
994                             wrbuf_puts(w_ccl, " or ");
995                         wrbuf_puts(w_ccl, ccl);
996                         wrbuf_puts(w_ccl, "=\"");
997                         wrbuf_puts(w_ccl, values[i]);
998                         wrbuf_puts(w_ccl, "\"");
999                     }
1000                     wrbuf_puts(w_ccl, ")");
1001
1002                 }
1003                 break;
1004             }
1005         }
1006         nmem_reset(nmem_tmp);
1007         if (!s)
1008         {
1009             yaz_log(YLOG_WARN, "Target %s: limit %s used, but no limitmap defined",
1010                     (sdb->database ? sdb->database->id : "<no id>"), name);
1011         }
1012     }
1013     nmem_destroy(nmem_tmp);
1014 }
1015                         
1016 // Parse the query given the settings specific to this client
1017 int client_parse_query(struct client *cl, const char *query,
1018                        facet_limits_t facet_limits)
1019 {
1020     struct session *se = client_get_session(cl);
1021     struct session_database *sdb = client_get_database(cl);
1022     struct ccl_rpn_node *cn;
1023     int cerror, cpos;
1024     CCL_bibset ccl_map = prepare_cclmap(cl);
1025     const char *sru = session_setting_oneval(sdb, PZ_SRU);
1026     const char *pqf_prefix = session_setting_oneval(sdb, PZ_PQF_PREFIX);
1027     const char *pqf_strftime = session_setting_oneval(sdb, PZ_PQF_STRFTIME);
1028     const char *query_syntax = session_setting_oneval(sdb, PZ_QUERY_SYNTAX);
1029     WRBUF w_ccl, w_pqf;
1030     if (!ccl_map)
1031         return -1;
1032
1033     cl->hits = -1;
1034     w_ccl = wrbuf_alloc();
1035     wrbuf_puts(w_ccl, query);
1036
1037     w_pqf = wrbuf_alloc();
1038     if (*pqf_prefix)
1039     {
1040         wrbuf_puts(w_pqf, pqf_prefix);
1041         wrbuf_puts(w_pqf, " ");
1042     }
1043
1044     apply_limit(sdb, facet_limits, w_pqf, w_ccl);
1045
1046     yaz_log(YLOG_LOG, "CCL query: %s", wrbuf_cstr(w_ccl));
1047     cn = ccl_find_str(ccl_map, wrbuf_cstr(w_ccl), &cerror, &cpos);
1048     ccl_qual_rm(&ccl_map);
1049     if (!cn)
1050     {
1051         client_set_state(cl, Client_Error);
1052         session_log(se, YLOG_WARN, "Failed to parse CCL query '%s' for %s",
1053                     wrbuf_cstr(w_ccl),
1054                     client_get_id(cl));
1055         wrbuf_destroy(w_ccl);
1056         wrbuf_destroy(w_pqf);
1057         return -1;
1058     }
1059     wrbuf_destroy(w_ccl);
1060
1061     if (!pqf_strftime || !*pqf_strftime)
1062         ccl_pquery(w_pqf, cn);
1063     else
1064     {
1065         time_t cur_time = time(0);
1066         struct tm *tm =  localtime(&cur_time);
1067         char tmp_str[300];
1068         const char *cp = tmp_str;
1069
1070         /* see man strftime(3) for things .. In particular %% gets converted
1071          to %.. And That's our original query .. */
1072         strftime(tmp_str, sizeof(tmp_str)-1, pqf_strftime, tm);
1073         for (; *cp; cp++)
1074         {
1075             if (cp[0] == '%')
1076                 ccl_pquery(w_pqf, cn);
1077             else
1078                 wrbuf_putc(w_pqf, cp[0]);
1079         }
1080     }
1081     xfree(cl->pquery);
1082     cl->pquery = xstrdup(wrbuf_cstr(w_pqf));
1083     wrbuf_destroy(w_pqf);
1084
1085     yaz_log(YLOG_LOG, "PQF query: %s", cl->pquery);
1086
1087     xfree(cl->cqlquery);
1088
1089     /* Support for PQF on SRU targets. */
1090     /* TODO Refactor */
1091     yaz_log(YLOG_DEBUG, "Query syntax: %s", query_syntax);
1092     if (strcmp(query_syntax, "pqf") != 0 && *sru)
1093     {
1094         if (!strcmp(sru, "solr")) {
1095             if (!(cl->cqlquery = make_solrquery(cl)))
1096                 return -1;
1097         }
1098         else {
1099             if (!(cl->cqlquery = make_cqlquery(cl)))
1100                 return -1;
1101         }
1102     }
1103     else
1104         cl->cqlquery = 0;
1105
1106     /* TODO FIX Not thread safe */
1107     if (!se->relevance)
1108     {
1109         // Initialize relevance structure with query terms
1110         se->relevance = relevance_create_ccl(
1111             se->service->charsets, se->nmem, cn);
1112     }
1113
1114     ccl_rpn_delete(cn);
1115     return 0;
1116 }
1117
1118 void client_set_session(struct client *cl, struct session *se)
1119 {
1120     cl->session = se;
1121 }
1122
1123 int client_is_active(struct client *cl)
1124 {
1125     if (cl->connection && (cl->state == Client_Connecting ||
1126                            cl->state == Client_Working))
1127         return 1;
1128     return 0;
1129 }
1130
1131 int client_is_active_preferred(struct client *cl)
1132 {
1133     /* only count if this is a preferred target. */
1134     if (!cl->preferred)
1135         return 0;
1136     /* TODO No sure this the condition that Seb wants */
1137     if (cl->connection && (cl->state == Client_Connecting ||
1138                            cl->state == Client_Working))
1139         return 1;
1140     return 0;
1141 }
1142
1143 Odr_int client_get_hits(struct client *cl)
1144 {
1145     return cl->hits;
1146 }
1147
1148 int client_get_num_records(struct client *cl)
1149 {
1150     return cl->record_offset;
1151 }
1152
1153 void client_set_diagnostic(struct client *cl, int diagnostic)
1154 {
1155     cl->diagnostic = diagnostic;
1156 }
1157
1158 int client_get_diagnostic(struct client *cl)
1159 {
1160     return cl->diagnostic;
1161 }
1162
1163 void client_set_database(struct client *cl, struct session_database *db)
1164 {
1165     cl->database = db;
1166 }
1167
1168 const char *client_get_id(struct client *cl)
1169 {
1170     return cl->id;
1171 }
1172
1173 void client_set_maxrecs(struct client *cl, int v)
1174 {
1175     cl->maxrecs = v;
1176 }
1177
1178 int client_get_maxrecs(struct client *cl)
1179 {
1180     return cl->maxrecs;
1181 }
1182
1183 void client_set_startrecs(struct client *cl, int v)
1184 {
1185     cl->startrecs = v;
1186 }
1187
1188 void client_set_preferred(struct client *cl, int v)
1189 {
1190     cl->preferred = v;
1191 }
1192
1193
1194 /*
1195  * Local variables:
1196  * c-basic-offset: 4
1197  * c-file-style: "Stroustrup"
1198  * indent-tabs-mode: nil
1199  * End:
1200  * vim: shiftwidth=4 tabstop=8 expandtab
1201  */
1202