bf3e04c8fa30bd26ab6919657615b25578224eff
[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     struct session *se = cl->session;
509     ZOOM_connection link = connection_get_link(co);
510     ZOOM_resultset resultset = cl->resultset;
511
512     const char *error, *addinfo = 0;
513     
514     if (ZOOM_connection_error(link, &error, &addinfo))
515     {
516         cl->hits = 0;
517         client_set_state(cl, Client_Error);
518         yaz_log(YLOG_WARN, "Search error %s (%s): %s",
519                 error, addinfo, client_get_id(cl));
520     }
521     else
522     {
523         yaz_log(YLOG_DEBUG, "client_search_response: hits "
524                 ODR_INT_PRINTF, cl->hits);
525         client_report_facets(cl, resultset);
526         cl->record_offset = cl->startrecs;
527         cl->hits = ZOOM_resultset_size(resultset);
528         if (se) {
529             se->total_hits += cl->hits;
530             yaz_log(YLOG_DEBUG, "client_search_response: total hits "
531                     ODR_INT_PRINTF, se->total_hits);
532         }
533     }
534 }
535
536 void client_got_records(struct client *cl)
537 {
538     struct session *se = cl->session;
539     if (se)
540     {
541         client_unlock(cl);
542         session_alert_watch(se, SESSION_WATCH_SHOW);
543         session_alert_watch(se, SESSION_WATCH_RECORD);
544         client_lock(cl);
545     }
546 }
547
548 void client_record_response(struct client *cl)
549 {
550     struct connection *co = cl->connection;
551     ZOOM_connection link = connection_get_link(co);
552     ZOOM_resultset resultset = cl->resultset;
553     const char *error, *addinfo;
554
555     if (ZOOM_connection_error(link, &error, &addinfo))
556     {
557         client_set_state(cl, Client_Error);
558         yaz_log(YLOG_WARN, "Search error %s (%s): %s",
559             error, addinfo, client_get_id(cl));
560     }
561     else
562     {
563         ZOOM_record rec = 0;
564         const char *msg, *addinfo;
565         
566         if (cl->show_raw && cl->show_raw->active)
567         {
568             if ((rec = ZOOM_resultset_record(resultset,
569                                              cl->show_raw->position-1)))
570             {
571                 cl->show_raw->active = 0;
572                 ingest_raw_record(cl, rec);
573             }
574             else
575             {
576                 yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d",
577                         cl->show_raw->position-1);
578             }
579         }
580         else
581         {
582             int offset = cl->record_offset;
583             if ((rec = ZOOM_resultset_record(resultset, offset)))
584             {
585                 cl->record_offset++;
586                 if (cl->session == 0)
587                     ;
588                 else if (ZOOM_record_error(rec, &msg, &addinfo, 0))
589                 {
590                     yaz_log(YLOG_WARN, "Record error %s (%s): %s (rec #%d)",
591                             msg, addinfo, client_get_id(cl),
592                             cl->record_offset);
593                 }
594                 else
595                 {
596                     struct session_database *sdb = client_get_database(cl);
597                     NMEM nmem = nmem_create();
598                     const char *xmlrec;
599                     char type[80];
600
601                     if (nativesyntax_to_type(sdb, type, rec))
602                         yaz_log(YLOG_WARN, "Failed to determine record type");
603                     xmlrec = ZOOM_record_get(rec, type, NULL);
604                     if (!xmlrec)
605                         yaz_log(YLOG_WARN, "ZOOM_record_get failed from %s",
606                                 client_get_id(cl));
607                     else
608                     {
609                         /* OK = 0, -1 = failure, -2 = Filtered */
610                         if (ingest_record(cl, xmlrec, cl->record_offset, nmem) == -1)
611                             yaz_log(YLOG_WARN, "Failed to ingest from %s", client_get_id(cl));
612                     }
613                     nmem_destroy(nmem);
614                 }
615             }
616             else
617             {
618                 yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d",
619                         offset);
620             }
621         }
622     }
623 }
624
625 static void client_set_facets_request(struct client *cl, ZOOM_connection link)
626 {
627     struct session_database *sdb = client_get_database(cl);
628
629     WRBUF w = wrbuf_alloc();
630     
631     struct setting *s;
632
633     for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
634     {
635         const char *p = strchr(s->name + 3, ':');
636         if (!p)
637         {
638             yaz_log(YLOG_WARN, "Malformed facetmap name: %s", s->name);
639         }
640         else if (s->value && s->value[0])
641         {
642             wrbuf_puts(w, "@attr 1=");
643             yaz_encode_pqf_term(w, s->value, strlen(s->value));
644             if (s->next)
645                 wrbuf_puts(w, ",");
646         }
647     }
648     yaz_log(YLOG_LOG, "using facets str: %s", wrbuf_cstr(w));
649     ZOOM_connection_option_set(link, "facets",
650                                wrbuf_len(w) ? wrbuf_cstr(w) : 0);
651     wrbuf_destroy(w);
652 }
653
654 int client_has_facet(struct client *cl, const char *name)
655 {
656     struct session_database *sdb = client_get_database(cl);
657     struct setting *s;
658
659     for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
660     {
661         const char *p = strchr(s->name + 3, ':');
662         if (p && !strcmp(name, p + 1))
663             return 1;
664     }
665     return 0;
666 }
667
668 void client_start_search(struct client *cl, const char *sort_strategy,
669                          const char *sort_spec)
670 {
671     struct session_database *sdb = client_get_database(cl);
672     struct connection *co = client_get_connection(cl);
673     ZOOM_connection link = connection_get_link(co);
674     ZOOM_resultset rs;
675     const char *opt_piggyback   = session_setting_oneval(sdb, PZ_PIGGYBACK);
676     const char *opt_queryenc    = session_setting_oneval(sdb, PZ_QUERYENCODING);
677     const char *opt_elements    = session_setting_oneval(sdb, PZ_ELEMENTS);
678     const char *opt_requestsyn  = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
679     const char *opt_maxrecs     = session_setting_oneval(sdb, PZ_MAXRECS);
680     const char *opt_sru         = session_setting_oneval(sdb, PZ_SRU);
681     const char *opt_sort        = session_setting_oneval(sdb, PZ_SORT);
682     const char *opt_preferred   = session_setting_oneval(sdb, PZ_PREFERRED);
683     const char *extra_args      = session_setting_oneval(sdb, PZ_EXTRA_ARGS);
684     char maxrecs_str[24], startrecs_str[24];
685
686     assert(link);
687
688     cl->hits = -1;
689     cl->record_offset = 0;
690     cl->diagnostic = 0;
691
692     if (extra_args && *extra_args)
693         ZOOM_connection_option_set(link, "extraArgs", extra_args);
694
695     if (opt_preferred) {
696         cl->preferred = atoi(opt_preferred);
697         if (cl->preferred)
698             yaz_log(YLOG_LOG, "Target %s has preferred status: %d",
699                     client_get_id(cl), cl->preferred);
700     }
701     client_set_state(cl, Client_Working);
702
703     if (*opt_piggyback)
704         ZOOM_connection_option_set(link, "piggyback", opt_piggyback);
705     else
706         ZOOM_connection_option_set(link, "piggyback", "1");
707     if (*opt_queryenc)
708         ZOOM_connection_option_set(link, "rpnCharset", opt_queryenc);
709     if (*opt_sru && *opt_elements)
710         ZOOM_connection_option_set(link, "schema", opt_elements);
711     else if (*opt_elements)
712         ZOOM_connection_option_set(link, "elementSetName", opt_elements);
713     if (*opt_requestsyn)
714         ZOOM_connection_option_set(link, "preferredRecordSyntax", opt_requestsyn);
715
716     if (opt_maxrecs && *opt_maxrecs)
717     {
718         cl->maxrecs = atoi(opt_maxrecs);
719     }
720
721     /* convert back to string representation used in ZOOM API */
722     sprintf(maxrecs_str, "%d", cl->maxrecs);
723     ZOOM_connection_option_set(link, "count", maxrecs_str);
724
725     if (cl->maxrecs > 20)
726         ZOOM_connection_option_set(link, "presentChunk", "20");
727     else
728         ZOOM_connection_option_set(link, "presentChunk", maxrecs_str);
729
730     sprintf(startrecs_str, "%d", cl->startrecs);
731     ZOOM_connection_option_set(link, "start", startrecs_str);
732
733     /* TODO Verify does it break something for CQL targets(non-SOLR) ? */
734     /* facets definition is in PQF */
735     client_set_facets_request(cl, link);
736
737     if (cl->cqlquery)
738     {
739         ZOOM_query q = ZOOM_query_create();
740         yaz_log(YLOG_LOG, "Search %s CQL: %s", client_get_id(cl),
741                 cl->cqlquery);
742         ZOOM_query_cql(q, cl->cqlquery);
743         if (*opt_sort)
744             ZOOM_query_sortby(q, opt_sort);
745         if (sort_strategy && sort_spec)
746         {
747             yaz_log(YLOG_LOG, "applying %s %s", sort_strategy, sort_spec);
748             ZOOM_query_sortby2(q, sort_strategy, sort_spec);
749         }
750         rs = ZOOM_connection_search(link, q);
751         ZOOM_query_destroy(q);
752     }
753     else
754     {
755         ZOOM_query q = ZOOM_query_create();
756
757         yaz_log(YLOG_LOG, "Search %s PQF: %s", client_get_id(cl), cl->pquery);
758
759         ZOOM_query_prefix(q, cl->pquery);
760
761         if (sort_strategy && sort_spec)
762         {
763             yaz_log(YLOG_LOG, "applying %s %s", sort_strategy, sort_spec);
764             ZOOM_query_sortby2(q, sort_strategy, sort_spec);
765         }
766         rs = ZOOM_connection_search(link, q);
767         ZOOM_query_destroy(q);
768     }
769     ZOOM_resultset_destroy(cl->resultset);
770     cl->resultset = rs;
771     connection_continue(co);
772 }
773
774 struct client *client_create(const char *id)
775 {
776     struct client *cl = xmalloc(sizeof(*cl));
777     cl->maxrecs = 100;
778     cl->startrecs = 0;
779     cl->pquery = 0;
780     cl->cqlquery = 0;
781     cl->database = 0;
782     cl->connection = 0;
783     cl->session = 0;
784     cl->hits = 0;
785     cl->record_offset = 0;
786     cl->diagnostic = 0;
787     cl->state = Client_Disconnected;
788     cl->show_raw = 0;
789     cl->resultset = 0;
790     cl->mutex = 0;
791     pazpar2_mutex_create(&cl->mutex, "client");
792     cl->preferred = 0;
793     cl->ref_count = 1;
794     assert(id);
795     cl->id = xstrdup(id);
796     client_use(1);
797     
798     return cl;
799 }
800
801 void client_lock(struct client *c)
802 {
803     yaz_mutex_enter(c->mutex);
804 }
805
806 void client_unlock(struct client *c)
807 {
808     yaz_mutex_leave(c->mutex);
809 }
810
811 void client_incref(struct client *c)
812 {
813     pazpar2_incref(&c->ref_count, c->mutex);
814     yaz_log(YLOG_DEBUG, "client_incref c=%p %s cnt=%d",
815             c, client_get_id(c), c->ref_count);
816 }
817
818 int client_destroy(struct client *c)
819 {
820     if (c)
821     {
822         yaz_log(YLOG_DEBUG, "client_destroy c=%p %s cnt=%d",
823                 c, client_get_id(c), c->ref_count);
824         if (!pazpar2_decref(&c->ref_count, c->mutex))
825         {
826             xfree(c->pquery);
827             c->pquery = 0;
828             xfree(c->cqlquery);
829             c->cqlquery = 0;
830             xfree(c->id);
831             assert(!c->connection);
832
833             if (c->resultset)
834             {
835                 ZOOM_resultset_destroy(c->resultset);
836             }
837             yaz_mutex_destroy(&c->mutex);
838             xfree(c);
839             client_use(-1);
840             return 1;
841         }
842     }
843     return 0;
844 }
845
846 void client_set_connection(struct client *cl, struct connection *con)
847 {
848     if (cl->resultset)
849         ZOOM_resultset_release(cl->resultset);
850     if (con)
851     {
852         assert(cl->connection == 0);
853         cl->connection = con;
854         client_incref(cl);
855     }
856     else
857     {
858         cl->connection = con;
859         client_destroy(cl);
860     }
861 }
862
863 void client_disconnect(struct client *cl)
864 {
865     if (cl->state != Client_Idle)
866         client_set_state(cl, Client_Disconnected);
867     client_set_connection(cl, 0);
868 }
869
870
871 // Initialize CCL map for a target
872 static CCL_bibset prepare_cclmap(struct client *cl)
873 {
874     struct session_database *sdb = client_get_database(cl);
875     struct setting *s;
876     CCL_bibset res;
877
878     if (!sdb->settings)
879         return 0;
880     res = ccl_qual_mk();
881     for (s = sdb->settings[PZ_CCLMAP]; s; s = s->next)
882     {
883         char *p = strchr(s->name + 3, ':');
884         if (!p)
885         {
886             yaz_log(YLOG_WARN, "Malformed cclmap name: %s", s->name);
887             ccl_qual_rm(&res);
888             return 0;
889         }
890         p++;
891         ccl_qual_fitem(res, s->value, p);
892     }
893     return res;
894 }
895
896 // returns a xmalloced CQL query corresponding to the pquery in client
897 static char *make_cqlquery(struct client *cl)
898 {
899     cql_transform_t cqlt = cql_transform_create();
900     Z_RPNQuery *zquery;
901     char *r;
902     WRBUF wrb = wrbuf_alloc();
903     int status;
904     ODR odr_out = odr_createmem(ODR_ENCODE);
905
906     zquery = p_query_rpn(odr_out, cl->pquery);
907     yaz_log(YLOG_LOG, "PQF: %s", cl->pquery);
908     if ((status = cql_transform_rpn2cql_wrbuf(cqlt, wrb, zquery)))
909     {
910         yaz_log(YLOG_WARN, "Failed to generate CQL query, code=%d", status);
911         r = 0;
912     }
913     else
914     {
915         r = xstrdup(wrbuf_cstr(wrb));
916     }     
917     wrbuf_destroy(wrb);
918     odr_destroy(odr_out);
919     cql_transform_close(cqlt);
920     return r;
921 }
922
923 // returns a xmalloced SOLR query corresponding to the pquery in client
924 // TODO Could prob. be merge with the similar make_cqlquery
925 static char *make_solrquery(struct client *cl)
926 {
927     solr_transform_t sqlt = solr_transform_create();
928     Z_RPNQuery *zquery;
929     char *r;
930     WRBUF wrb = wrbuf_alloc();
931     int status;
932     ODR odr_out = odr_createmem(ODR_ENCODE);
933
934     zquery = p_query_rpn(odr_out, cl->pquery);
935     if (zquery == 0) {
936         yaz_log(YLOG_WARN, "Failed to generate RPN from PQF: %s", cl->pquery);
937         return 0;
938     }
939     yaz_log(YLOG_LOG, "PQF: %s", cl->pquery);
940     if ((status = solr_transform_rpn2solr_wrbuf(sqlt, wrb, zquery)))
941     {
942         yaz_log(YLOG_WARN, "Failed to generate SOLR query from PQF %s, code=%d", cl->pquery, status);
943         r = 0;
944     }
945     else
946     {
947         r = xstrdup(wrbuf_cstr(wrb));
948     }
949     wrbuf_destroy(wrb);
950     odr_destroy(odr_out);
951     solr_transform_close(sqlt);
952     return r;
953 }
954
955 static void apply_limit(struct session_database *sdb,
956                         facet_limits_t facet_limits,
957                         WRBUF w_pqf, WRBUF w_ccl)
958 {
959     int i = 0;
960     const char *name;
961     const char *value;
962     NMEM nmem_tmp = nmem_create();
963     for (i = 0; (name = facet_limits_get(facet_limits, i, &value)); i++)
964     {
965         struct setting *s = 0;
966         
967         for (s = sdb->settings[PZ_LIMITMAP]; s; s = s->next)
968         {
969             const char *p = strchr(s->name + 3, ':');
970             if (p && !strcmp(p + 1, name) && s->value)
971             {
972                 char **values = 0;
973                 int i, num = 0;
974                 nmem_strsplit_escape2(nmem_tmp, "|", value, &values,
975                                       &num, 1, '\\', 1);
976
977                 if (!strncmp(s->value, "rpn:", 4))
978                 {
979                     const char *pqf = s->value + 4;
980
981                     wrbuf_puts(w_pqf, "@and ");
982                     wrbuf_puts(w_pqf, pqf);
983                     wrbuf_puts(w_pqf, " ");
984                     for (i = 0; i < num; i++)
985                     {
986                         if (i < num - 1)
987                             wrbuf_puts(w_pqf, "@or ");
988                         yaz_encode_pqf_term(w_pqf, values[i],
989                                             strlen(values[i]));
990                     }
991                 }
992                 else if (!strncmp(s->value, "ccl:", 4))
993                 {
994                     const char *ccl = s->value + 4;
995
996                     wrbuf_puts(w_ccl, " and (");
997
998                     for (i = 0; i < num; i++)
999                     {
1000                         if (i)
1001                             wrbuf_puts(w_ccl, " or ");
1002                         wrbuf_puts(w_ccl, ccl);
1003                         wrbuf_puts(w_ccl, "=\"");
1004                         wrbuf_puts(w_ccl, values[i]);
1005                         wrbuf_puts(w_ccl, "\"");
1006                     }
1007                     wrbuf_puts(w_ccl, ")");
1008
1009                 }
1010                 break;
1011             }
1012         }
1013         nmem_reset(nmem_tmp);
1014         if (!s)
1015         {
1016             yaz_log(YLOG_WARN, "Target %s: limit %s used, but no limitmap defined",
1017                     (sdb->database ? sdb->database->id : "<no id>"), name);
1018         }
1019     }
1020     nmem_destroy(nmem_tmp);
1021 }
1022                         
1023 // Parse the query given the settings specific to this client
1024 int client_parse_query(struct client *cl, const char *query,
1025                        facet_limits_t facet_limits)
1026 {
1027     struct session *se = client_get_session(cl);
1028     struct session_database *sdb = client_get_database(cl);
1029     struct ccl_rpn_node *cn;
1030     int cerror, cpos;
1031     CCL_bibset ccl_map = prepare_cclmap(cl);
1032     const char *sru = session_setting_oneval(sdb, PZ_SRU);
1033     const char *pqf_prefix = session_setting_oneval(sdb, PZ_PQF_PREFIX);
1034     const char *pqf_strftime = session_setting_oneval(sdb, PZ_PQF_STRFTIME);
1035     const char *query_syntax = session_setting_oneval(sdb, PZ_QUERY_SYNTAX);
1036     WRBUF w_ccl, w_pqf;
1037     if (!ccl_map)
1038         return -1;
1039
1040     w_ccl = wrbuf_alloc();
1041     wrbuf_puts(w_ccl, query);
1042
1043     w_pqf = wrbuf_alloc();
1044     if (*pqf_prefix)
1045     {
1046         wrbuf_puts(w_pqf, pqf_prefix);
1047         wrbuf_puts(w_pqf, " ");
1048     }
1049
1050     apply_limit(sdb, facet_limits, w_pqf, w_ccl);
1051
1052     yaz_log(YLOG_LOG, "CCL query: %s", wrbuf_cstr(w_ccl));
1053     cn = ccl_find_str(ccl_map, wrbuf_cstr(w_ccl), &cerror, &cpos);
1054     ccl_qual_rm(&ccl_map);
1055     if (!cn)
1056     {
1057         client_set_state(cl, Client_Error);
1058         session_log(se, YLOG_WARN, "Failed to parse CCL query '%s' for %s",
1059                     wrbuf_cstr(w_ccl),
1060                     client_get_id(cl));
1061         wrbuf_destroy(w_ccl);
1062         wrbuf_destroy(w_pqf);
1063         return -1;
1064     }
1065     wrbuf_destroy(w_ccl);
1066
1067     if (!pqf_strftime || !*pqf_strftime)
1068         ccl_pquery(w_pqf, cn);
1069     else
1070     {
1071         time_t cur_time = time(0);
1072         struct tm *tm =  localtime(&cur_time);
1073         char tmp_str[300];
1074         const char *cp = tmp_str;
1075
1076         /* see man strftime(3) for things .. In particular %% gets converted
1077          to %.. And That's our original query .. */
1078         strftime(tmp_str, sizeof(tmp_str)-1, pqf_strftime, tm);
1079         for (; *cp; cp++)
1080         {
1081             if (cp[0] == '%')
1082                 ccl_pquery(w_pqf, cn);
1083             else
1084                 wrbuf_putc(w_pqf, cp[0]);
1085         }
1086     }
1087     xfree(cl->pquery);
1088     cl->pquery = xstrdup(wrbuf_cstr(w_pqf));
1089     wrbuf_destroy(w_pqf);
1090
1091     yaz_log(YLOG_LOG, "PQF query: %s", cl->pquery);
1092
1093     xfree(cl->cqlquery);
1094
1095     /* Support for PQF on SRU targets. */
1096     /* TODO Refactor */
1097     yaz_log(YLOG_DEBUG, "Query syntax: %s", query_syntax);
1098     if (strcmp(query_syntax, "pqf") != 0 && *sru)
1099     {
1100         if (!strcmp(sru, "solr")) {
1101             if (!(cl->cqlquery = make_solrquery(cl)))
1102                 return -1;
1103         }
1104         else {
1105             if (!(cl->cqlquery = make_cqlquery(cl)))
1106                 return -1;
1107         }
1108     }
1109     else
1110         cl->cqlquery = 0;
1111
1112     /* TODO FIX Not thread safe */
1113     if (!se->relevance)
1114     {
1115         // Initialize relevance structure with query terms
1116         se->relevance = relevance_create_ccl(
1117             se->service->charsets, se->nmem, cn);
1118     }
1119
1120     ccl_rpn_delete(cn);
1121     return 0;
1122 }
1123
1124 void client_set_session(struct client *cl, struct session *se)
1125 {
1126     cl->session = se;
1127 }
1128
1129 int client_is_active(struct client *cl)
1130 {
1131     if (cl->connection && (cl->state == Client_Connecting ||
1132                            cl->state == Client_Working))
1133         return 1;
1134     return 0;
1135 }
1136
1137 int client_is_active_preferred(struct client *cl)
1138 {
1139     /* only count if this is a preferred target. */
1140     if (!cl->preferred)
1141         return 0;
1142     /* TODO No sure this the condition that Seb wants */
1143     if (cl->connection && (cl->state == Client_Connecting ||
1144                            cl->state == Client_Working))
1145         return 1;
1146     return 0;
1147 }
1148
1149 Odr_int client_get_hits(struct client *cl)
1150 {
1151     return cl->hits;
1152 }
1153
1154 int client_get_num_records(struct client *cl)
1155 {
1156     return cl->record_offset;
1157 }
1158
1159 void client_set_diagnostic(struct client *cl, int diagnostic)
1160 {
1161     cl->diagnostic = diagnostic;
1162 }
1163
1164 int client_get_diagnostic(struct client *cl)
1165 {
1166     return cl->diagnostic;
1167 }
1168
1169 void client_set_database(struct client *cl, struct session_database *db)
1170 {
1171     cl->database = db;
1172 }
1173
1174 const char *client_get_id(struct client *cl)
1175 {
1176     return cl->id;
1177 }
1178
1179 void client_set_maxrecs(struct client *cl, int v)
1180 {
1181     cl->maxrecs = v;
1182 }
1183
1184 int client_get_maxrecs(struct client *cl)
1185 {
1186     return cl->maxrecs;
1187 }
1188
1189 void client_set_startrecs(struct client *cl, int v)
1190 {
1191     cl->startrecs = v;
1192 }
1193
1194 void client_set_preferred(struct client *cl, int v)
1195 {
1196     cl->preferred = v;
1197 }
1198
1199
1200 /*
1201  * Local variables:
1202  * c-basic-offset: 4
1203  * c-file-style: "Stroustrup"
1204  * indent-tabs-mode: nil
1205  * End:
1206  * vim: shiftwidth=4 tabstop=8 expandtab
1207  */
1208