39190c0098616c18277b2953239304d6fc4951ef
[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_and_spec,
663                          int increasing)
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     ZOOM_query q;
680
681     assert(link);
682
683     cl->record_offset = 0;
684     cl->diagnostic = 0;
685
686     if (extra_args && *extra_args)
687         ZOOM_connection_option_set(link, "extraArgs", extra_args);
688
689     if (opt_preferred) {
690         cl->preferred = atoi(opt_preferred);
691         if (cl->preferred)
692             yaz_log(YLOG_LOG, "Target %s has preferred status: %d",
693                     client_get_id(cl), cl->preferred);
694     }
695     client_set_state(cl, Client_Working);
696
697     if (*opt_piggyback)
698         ZOOM_connection_option_set(link, "piggyback", opt_piggyback);
699     else
700         ZOOM_connection_option_set(link, "piggyback", "1");
701     if (*opt_queryenc)
702         ZOOM_connection_option_set(link, "rpnCharset", opt_queryenc);
703     if (*opt_sru && *opt_elements)
704         ZOOM_connection_option_set(link, "schema", opt_elements);
705     else if (*opt_elements)
706         ZOOM_connection_option_set(link, "elementSetName", opt_elements);
707     if (*opt_requestsyn)
708         ZOOM_connection_option_set(link, "preferredRecordSyntax", opt_requestsyn);
709
710     if (opt_maxrecs && *opt_maxrecs)
711     {
712         cl->maxrecs = atoi(opt_maxrecs);
713     }
714
715     /* convert back to string representation used in ZOOM API */
716     sprintf(maxrecs_str, "%d", cl->maxrecs);
717     ZOOM_connection_option_set(link, "count", maxrecs_str);
718
719     if (cl->maxrecs > 20)
720         ZOOM_connection_option_set(link, "presentChunk", "20");
721     else
722         ZOOM_connection_option_set(link, "presentChunk", maxrecs_str);
723
724     sprintf(startrecs_str, "%d", cl->startrecs);
725     ZOOM_connection_option_set(link, "start", startrecs_str);
726
727     /* TODO Verify does it break something for CQL targets(non-SOLR) ? */
728     /* facets definition is in PQF */
729     client_set_facets_request(cl, link);
730
731     q = ZOOM_query_create();
732     if (cl->cqlquery)
733     {
734         yaz_log(YLOG_LOG, "Search %s CQL: %s", client_get_id(cl),
735                 cl->cqlquery);
736         ZOOM_query_cql(q, cl->cqlquery);
737         if (*opt_sort)
738             ZOOM_query_sortby(q, opt_sort);
739     }
740     else
741     {
742         yaz_log(YLOG_LOG, "Search %s PQF: %s", client_get_id(cl), cl->pquery);
743         
744         ZOOM_query_prefix(q, cl->pquery);
745     }
746     if (sort_strategy_and_spec &&
747         strlen(sort_strategy_and_spec) < 40 /* spec below */)
748     {
749         char spec[50], *p;
750         strcpy(spec, sort_strategy_and_spec);
751         p = strchr(spec, ':');
752         if (p)
753         {
754             *p++ = '\0'; /* cut the string in two */
755             while (*p == ' ')
756                 p++;
757             if (increasing)
758                 strcat(p, " <");
759             else
760                 strcat(p, " >");
761             yaz_log(YLOG_LOG, "applying %s %s", spec, p);
762             ZOOM_query_sortby2(q, spec, p);
763         }
764     }
765     rs = ZOOM_connection_search(link, q);
766     ZOOM_query_destroy(q);
767     ZOOM_resultset_destroy(cl->resultset);
768     cl->resultset = rs;
769     connection_continue(co);
770 }
771
772 struct client *client_create(const char *id)
773 {
774     struct client *cl = xmalloc(sizeof(*cl));
775     cl->maxrecs = 100;
776     cl->startrecs = 0;
777     cl->pquery = 0;
778     cl->cqlquery = 0;
779     cl->database = 0;
780     cl->connection = 0;
781     cl->session = 0;
782     cl->hits = 0;
783     cl->record_offset = 0;
784     cl->diagnostic = 0;
785     cl->state = Client_Disconnected;
786     cl->show_raw = 0;
787     cl->resultset = 0;
788     cl->mutex = 0;
789     pazpar2_mutex_create(&cl->mutex, "client");
790     cl->preferred = 0;
791     cl->ref_count = 1;
792     assert(id);
793     cl->id = xstrdup(id);
794     client_use(1);
795     
796     return cl;
797 }
798
799 void client_lock(struct client *c)
800 {
801     yaz_mutex_enter(c->mutex);
802 }
803
804 void client_unlock(struct client *c)
805 {
806     yaz_mutex_leave(c->mutex);
807 }
808
809 void client_incref(struct client *c)
810 {
811     pazpar2_incref(&c->ref_count, c->mutex);
812     yaz_log(YLOG_DEBUG, "client_incref c=%p %s cnt=%d",
813             c, client_get_id(c), c->ref_count);
814 }
815
816 int client_destroy(struct client *c)
817 {
818     if (c)
819     {
820         yaz_log(YLOG_DEBUG, "client_destroy c=%p %s cnt=%d",
821                 c, client_get_id(c), c->ref_count);
822         if (!pazpar2_decref(&c->ref_count, c->mutex))
823         {
824             xfree(c->pquery);
825             c->pquery = 0;
826             xfree(c->cqlquery);
827             c->cqlquery = 0;
828             xfree(c->id);
829             assert(!c->connection);
830
831             if (c->resultset)
832             {
833                 ZOOM_resultset_destroy(c->resultset);
834             }
835             yaz_mutex_destroy(&c->mutex);
836             xfree(c);
837             client_use(-1);
838             return 1;
839         }
840     }
841     return 0;
842 }
843
844 void client_set_connection(struct client *cl, struct connection *con)
845 {
846     if (cl->resultset)
847         ZOOM_resultset_release(cl->resultset);
848     if (con)
849     {
850         assert(cl->connection == 0);
851         cl->connection = con;
852         client_incref(cl);
853     }
854     else
855     {
856         cl->connection = con;
857         client_destroy(cl);
858     }
859 }
860
861 void client_disconnect(struct client *cl)
862 {
863     if (cl->state != Client_Idle)
864         client_set_state(cl, Client_Disconnected);
865     client_set_connection(cl, 0);
866 }
867
868
869 // Initialize CCL map for a target
870 static CCL_bibset prepare_cclmap(struct client *cl)
871 {
872     struct session_database *sdb = client_get_database(cl);
873     struct setting *s;
874     CCL_bibset res;
875
876     if (!sdb->settings)
877         return 0;
878     res = ccl_qual_mk();
879     for (s = sdb->settings[PZ_CCLMAP]; s; s = s->next)
880     {
881         char *p = strchr(s->name + 3, ':');
882         if (!p)
883         {
884             yaz_log(YLOG_WARN, "Malformed cclmap name: %s", s->name);
885             ccl_qual_rm(&res);
886             return 0;
887         }
888         p++;
889         ccl_qual_fitem(res, s->value, p);
890     }
891     return res;
892 }
893
894 // returns a xmalloced CQL query corresponding to the pquery in client
895 static char *make_cqlquery(struct client *cl)
896 {
897     cql_transform_t cqlt = cql_transform_create();
898     Z_RPNQuery *zquery;
899     char *r;
900     WRBUF wrb = wrbuf_alloc();
901     int status;
902     ODR odr_out = odr_createmem(ODR_ENCODE);
903
904     zquery = p_query_rpn(odr_out, cl->pquery);
905     yaz_log(YLOG_LOG, "PQF: %s", cl->pquery);
906     if ((status = cql_transform_rpn2cql_wrbuf(cqlt, wrb, zquery)))
907     {
908         yaz_log(YLOG_WARN, "Failed to generate CQL query, code=%d", status);
909         r = 0;
910     }
911     else
912     {
913         r = xstrdup(wrbuf_cstr(wrb));
914     }     
915     wrbuf_destroy(wrb);
916     odr_destroy(odr_out);
917     cql_transform_close(cqlt);
918     return r;
919 }
920
921 // returns a xmalloced SOLR query corresponding to the pquery in client
922 // TODO Could prob. be merge with the similar make_cqlquery
923 static char *make_solrquery(struct client *cl)
924 {
925     solr_transform_t sqlt = solr_transform_create();
926     Z_RPNQuery *zquery;
927     char *r;
928     WRBUF wrb = wrbuf_alloc();
929     int status;
930     ODR odr_out = odr_createmem(ODR_ENCODE);
931
932     zquery = p_query_rpn(odr_out, cl->pquery);
933     if (zquery == 0) {
934         yaz_log(YLOG_WARN, "Failed to generate RPN from PQF: %s", cl->pquery);
935         return 0;
936     }
937     yaz_log(YLOG_LOG, "PQF: %s", cl->pquery);
938     if ((status = solr_transform_rpn2solr_wrbuf(sqlt, wrb, zquery)))
939     {
940         yaz_log(YLOG_WARN, "Failed to generate SOLR query from PQF %s, code=%d", cl->pquery, status);
941         r = 0;
942     }
943     else
944     {
945         r = xstrdup(wrbuf_cstr(wrb));
946     }
947     wrbuf_destroy(wrb);
948     odr_destroy(odr_out);
949     solr_transform_close(sqlt);
950     return r;
951 }
952
953 static void apply_limit(struct session_database *sdb,
954                         facet_limits_t facet_limits,
955                         WRBUF w_pqf, WRBUF w_ccl)
956 {
957     int i = 0;
958     const char *name;
959     const char *value;
960     NMEM nmem_tmp = nmem_create();
961     for (i = 0; (name = facet_limits_get(facet_limits, i, &value)); i++)
962     {
963         struct setting *s = 0;
964         
965         for (s = sdb->settings[PZ_LIMITMAP]; s; s = s->next)
966         {
967             const char *p = strchr(s->name + 3, ':');
968             if (p && !strcmp(p + 1, name) && s->value)
969             {
970                 char **values = 0;
971                 int i, num = 0;
972                 nmem_strsplit_escape2(nmem_tmp, "|", value, &values,
973                                       &num, 1, '\\', 1);
974
975                 if (!strncmp(s->value, "rpn:", 4))
976                 {
977                     const char *pqf = s->value + 4;
978
979                     wrbuf_puts(w_pqf, "@and ");
980                     wrbuf_puts(w_pqf, pqf);
981                     wrbuf_puts(w_pqf, " ");
982                     for (i = 0; i < num; i++)
983                     {
984                         if (i < num - 1)
985                             wrbuf_puts(w_pqf, "@or ");
986                         yaz_encode_pqf_term(w_pqf, values[i],
987                                             strlen(values[i]));
988                     }
989                 }
990                 else if (!strncmp(s->value, "ccl:", 4))
991                 {
992                     const char *ccl = s->value + 4;
993
994                     wrbuf_puts(w_ccl, " and (");
995
996                     for (i = 0; i < num; i++)
997                     {
998                         if (i)
999                             wrbuf_puts(w_ccl, " or ");
1000                         wrbuf_puts(w_ccl, ccl);
1001                         wrbuf_puts(w_ccl, "=\"");
1002                         wrbuf_puts(w_ccl, values[i]);
1003                         wrbuf_puts(w_ccl, "\"");
1004                     }
1005                     wrbuf_puts(w_ccl, ")");
1006
1007                 }
1008                 break;
1009             }
1010         }
1011         nmem_reset(nmem_tmp);
1012         if (!s)
1013         {
1014             yaz_log(YLOG_WARN, "Target %s: limit %s used, but no limitmap defined",
1015                     (sdb->database ? sdb->database->id : "<no id>"), name);
1016         }
1017     }
1018     nmem_destroy(nmem_tmp);
1019 }
1020                         
1021 // Parse the query given the settings specific to this client
1022 int client_parse_query(struct client *cl, const char *query,
1023                        facet_limits_t facet_limits)
1024 {
1025     struct session *se = client_get_session(cl);
1026     struct session_database *sdb = client_get_database(cl);
1027     struct ccl_rpn_node *cn;
1028     int cerror, cpos;
1029     CCL_bibset ccl_map = prepare_cclmap(cl);
1030     const char *sru = session_setting_oneval(sdb, PZ_SRU);
1031     const char *pqf_prefix = session_setting_oneval(sdb, PZ_PQF_PREFIX);
1032     const char *pqf_strftime = session_setting_oneval(sdb, PZ_PQF_STRFTIME);
1033     const char *query_syntax = session_setting_oneval(sdb, PZ_QUERY_SYNTAX);
1034     WRBUF w_ccl, w_pqf;
1035     if (!ccl_map)
1036         return -1;
1037
1038     cl->hits = -1;
1039     w_ccl = wrbuf_alloc();
1040     wrbuf_puts(w_ccl, query);
1041
1042     w_pqf = wrbuf_alloc();
1043     if (*pqf_prefix)
1044     {
1045         wrbuf_puts(w_pqf, pqf_prefix);
1046         wrbuf_puts(w_pqf, " ");
1047     }
1048
1049     apply_limit(sdb, facet_limits, w_pqf, w_ccl);
1050
1051     yaz_log(YLOG_LOG, "CCL query: %s", wrbuf_cstr(w_ccl));
1052     cn = ccl_find_str(ccl_map, wrbuf_cstr(w_ccl), &cerror, &cpos);
1053     ccl_qual_rm(&ccl_map);
1054     if (!cn)
1055     {
1056         client_set_state(cl, Client_Error);
1057         session_log(se, YLOG_WARN, "Failed to parse CCL query '%s' for %s",
1058                     wrbuf_cstr(w_ccl),
1059                     client_get_id(cl));
1060         wrbuf_destroy(w_ccl);
1061         wrbuf_destroy(w_pqf);
1062         return -1;
1063     }
1064     wrbuf_destroy(w_ccl);
1065
1066     if (!pqf_strftime || !*pqf_strftime)
1067         ccl_pquery(w_pqf, cn);
1068     else
1069     {
1070         time_t cur_time = time(0);
1071         struct tm *tm =  localtime(&cur_time);
1072         char tmp_str[300];
1073         const char *cp = tmp_str;
1074
1075         /* see man strftime(3) for things .. In particular %% gets converted
1076          to %.. And That's our original query .. */
1077         strftime(tmp_str, sizeof(tmp_str)-1, pqf_strftime, tm);
1078         for (; *cp; cp++)
1079         {
1080             if (cp[0] == '%')
1081                 ccl_pquery(w_pqf, cn);
1082             else
1083                 wrbuf_putc(w_pqf, cp[0]);
1084         }
1085     }
1086     xfree(cl->pquery);
1087     cl->pquery = xstrdup(wrbuf_cstr(w_pqf));
1088     wrbuf_destroy(w_pqf);
1089
1090     yaz_log(YLOG_LOG, "PQF query: %s", cl->pquery);
1091
1092     xfree(cl->cqlquery);
1093
1094     /* Support for PQF on SRU targets. */
1095     /* TODO Refactor */
1096     yaz_log(YLOG_DEBUG, "Query syntax: %s", query_syntax);
1097     if (strcmp(query_syntax, "pqf") != 0 && *sru)
1098     {
1099         if (!strcmp(sru, "solr")) {
1100             if (!(cl->cqlquery = make_solrquery(cl)))
1101                 return -1;
1102         }
1103         else {
1104             if (!(cl->cqlquery = make_cqlquery(cl)))
1105                 return -1;
1106         }
1107     }
1108     else
1109         cl->cqlquery = 0;
1110
1111     /* TODO FIX Not thread safe */
1112     if (!se->relevance)
1113     {
1114         // Initialize relevance structure with query terms
1115         se->relevance = relevance_create_ccl(
1116             se->service->charsets, se->nmem, cn);
1117     }
1118
1119     ccl_rpn_delete(cn);
1120     return 0;
1121 }
1122
1123 void client_set_session(struct client *cl, struct session *se)
1124 {
1125     cl->session = se;
1126 }
1127
1128 int client_is_active(struct client *cl)
1129 {
1130     if (cl->connection && (cl->state == Client_Connecting ||
1131                            cl->state == Client_Working))
1132         return 1;
1133     return 0;
1134 }
1135
1136 int client_is_active_preferred(struct client *cl)
1137 {
1138     /* only count if this is a preferred target. */
1139     if (!cl->preferred)
1140         return 0;
1141     /* TODO No sure this the condition that Seb wants */
1142     if (cl->connection && (cl->state == Client_Connecting ||
1143                            cl->state == Client_Working))
1144         return 1;
1145     return 0;
1146 }
1147
1148 Odr_int client_get_hits(struct client *cl)
1149 {
1150     return cl->hits;
1151 }
1152
1153 int client_get_num_records(struct client *cl)
1154 {
1155     return cl->record_offset;
1156 }
1157
1158 void client_set_diagnostic(struct client *cl, int diagnostic)
1159 {
1160     cl->diagnostic = diagnostic;
1161 }
1162
1163 int client_get_diagnostic(struct client *cl)
1164 {
1165     return cl->diagnostic;
1166 }
1167
1168 void client_set_database(struct client *cl, struct session_database *db)
1169 {
1170     cl->database = db;
1171 }
1172
1173 const char *client_get_id(struct client *cl)
1174 {
1175     return cl->id;
1176 }
1177
1178 void client_set_maxrecs(struct client *cl, int v)
1179 {
1180     cl->maxrecs = v;
1181 }
1182
1183 int client_get_maxrecs(struct client *cl)
1184 {
1185     return cl->maxrecs;
1186 }
1187
1188 void client_set_startrecs(struct client *cl, int v)
1189 {
1190     cl->startrecs = v;
1191 }
1192
1193 void client_set_preferred(struct client *cl, int v)
1194 {
1195     cl->preferred = v;
1196 }
1197
1198
1199 /*
1200  * Local variables:
1201  * c-basic-offset: 4
1202  * c-file-style: "Stroustrup"
1203  * indent-tabs-mode: nil
1204  * End:
1205  * vim: shiftwidth=4 tabstop=8 expandtab
1206  */
1207