6bc8e4f89caeaf866b62c8cd741ca59aeb21a309
[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     /* copy of database->url */
123     char *url;
124 };
125
126 struct show_raw {
127     int active; // whether this request has been sent to the server
128     int position;
129     int binary;
130     char *syntax;
131     char *esn;
132     void (*error_handler)(void *data, const char *addinfo);
133     void (*record_handler)(void *data, const char *buf, size_t sz);
134     void *data;
135     struct show_raw *next;
136 };
137
138 static const char *client_states[] = {
139     "Client_Connecting",
140     "Client_Idle",
141     "Client_Working",
142     "Client_Error",
143     "Client_Failed",
144     "Client_Disconnected"
145 };
146
147 const char *client_get_state_str(struct client *cl)
148 {
149     return client_states[cl->state];
150 }
151
152 enum client_state client_get_state(struct client *cl)
153 {
154     return cl->state;
155 }
156
157 void client_set_state(struct client *cl, enum client_state st)
158 {
159     int was_active = 0;
160     if (client_is_active(cl))
161         was_active = 1;
162     cl->state = st;
163     /* If client is going from being active to inactive and all clients
164        are now idle we fire a watch for the session . The assumption is
165        that session is not mutex locked if client is already active */
166     if (was_active && !client_is_active(cl) && cl->session)
167     {
168
169         int no_active = session_active_clients(cl->session);
170         yaz_log(YLOG_DEBUG, "%s: releasing watches on zero active: %d", client_get_url(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_url(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, "TXML"))
407                 {
408                     strcpy(type, "txml");
409                     return 0;
410                 }
411             else if (!strcmp(syntax, "USmarc") || !strcmp(syntax, "MARC21"))
412             {
413                 strcpy(type, "xml; charset=marc8-s");
414                 return 0;
415             }
416             else return -1;
417         }
418         else return -1;
419     }
420 }
421
422 /**
423  * TODO Consider thread safety!!!
424  *
425  */
426 void client_report_facets(struct client *cl, ZOOM_resultset rs)
427 {
428     struct session_database *sdb = client_get_database(cl);
429     ZOOM_facet_field *facets = ZOOM_resultset_facets(rs);
430
431     if (sdb && facets)
432     {
433         struct session *se = client_get_session(cl);
434         int facet_num = ZOOM_resultset_facets_size(rs);
435         struct setting *s;
436
437         for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
438         {
439             const char *p = strchr(s->name + 3, ':');
440             if (p && p[1] && s->value && s->value[0])
441             {
442                 int facet_idx;
443                 p++; /* p now holds logical facet name */
444                 for (facet_idx = 0; facet_idx < facet_num; facet_idx++)
445                 {
446                     const char *native_name =
447                         ZOOM_facet_field_name(facets[facet_idx]);
448                     if (native_name && !strcmp(s->value, native_name))
449                     {
450                         size_t term_idx;
451                         size_t term_num =
452                             ZOOM_facet_field_term_count(facets[facet_idx]);
453                         for (term_idx = 0; term_idx < term_num; term_idx++ )
454                         {
455                             int freq;
456                             const char *term =
457                                 ZOOM_facet_field_get_term(facets[facet_idx],
458                                                           term_idx, &freq);
459                             if (term)
460                                 add_facet(se, p, term, freq);
461                         }
462                         break;
463                     }
464                 }
465             }
466         }
467     }
468 }
469
470 static void ingest_raw_record(struct client *cl, ZOOM_record rec)
471 {
472     const char *buf;
473     int len;
474     char type[80];
475
476     if (cl->show_raw->binary)
477         strcpy(type, "raw");
478     else
479     {
480         struct session_database *sdb = client_get_database(cl);
481         nativesyntax_to_type(sdb, type, rec);
482     }
483
484     buf = ZOOM_record_get(rec, type, &len);
485     cl->show_raw->record_handler(cl->show_raw->data,  buf, len);
486     client_show_raw_dequeue(cl);
487 }
488
489 void client_check_preferred_watch(struct client *cl)
490 {
491     struct session *se = cl->session;
492     yaz_log(YLOG_DEBUG, "client_check_preferred_watch: %s ", client_get_url(cl));
493     if (se)
494     {
495         client_unlock(cl);
496         /* TODO possible threading issue. Session can have been destroyed */
497         if (session_is_preferred_clients_ready(se)) {
498             session_alert_watch(se, SESSION_WATCH_SHOW_PREF);
499         }
500         else
501             yaz_log(YLOG_DEBUG, "client_check_preferred_watch: Still locked on preferred targets.");
502
503         client_lock(cl);
504     }
505     else
506         yaz_log(YLOG_WARN, "client_check_preferred_watch: %s. No session!", client_get_url(cl));
507
508 }
509
510 void client_search_response(struct client *cl)
511 {
512     struct connection *co = cl->connection;
513     struct session *se = cl->session;
514     ZOOM_connection link = connection_get_link(co);
515     ZOOM_resultset resultset = cl->resultset;
516
517     const char *error, *addinfo = 0;
518     
519     if (ZOOM_connection_error(link, &error, &addinfo))
520     {
521         cl->hits = 0;
522         client_set_state(cl, Client_Error);
523         yaz_log(YLOG_WARN, "Search error %s (%s): %s",
524                 error, addinfo, client_get_url(cl));
525     }
526     else
527     {
528         yaz_log(YLOG_DEBUG, "client_search_response: hits "
529                 ODR_INT_PRINTF, cl->hits);
530         client_report_facets(cl, resultset);
531         cl->record_offset = cl->startrecs;
532         cl->hits = ZOOM_resultset_size(resultset);
533         if (se) {
534             se->total_hits += cl->hits;
535             yaz_log(YLOG_DEBUG, "client_search_response: total hits "
536                     ODR_INT_PRINTF, se->total_hits);
537         }
538     }
539 }
540
541 void client_got_records(struct client *cl)
542 {
543     struct session *se = cl->session;
544     if (se)
545     {
546         client_unlock(cl);
547         session_alert_watch(se, SESSION_WATCH_SHOW);
548         session_alert_watch(se, SESSION_WATCH_RECORD);
549         client_lock(cl);
550     }
551 }
552
553 void client_record_response(struct client *cl)
554 {
555     struct connection *co = cl->connection;
556     ZOOM_connection link = connection_get_link(co);
557     ZOOM_resultset resultset = cl->resultset;
558     const char *error, *addinfo;
559
560     if (ZOOM_connection_error(link, &error, &addinfo))
561     {
562         client_set_state(cl, Client_Error);
563         yaz_log(YLOG_WARN, "Search error %s (%s): %s",
564             error, addinfo, client_get_url(cl));
565     }
566     else
567     {
568         ZOOM_record rec = 0;
569         const char *msg, *addinfo;
570         
571         if (cl->show_raw && cl->show_raw->active)
572         {
573             if ((rec = ZOOM_resultset_record(resultset,
574                                              cl->show_raw->position-1)))
575             {
576                 cl->show_raw->active = 0;
577                 ingest_raw_record(cl, rec);
578             }
579             else
580             {
581                 yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d",
582                         cl->show_raw->position-1);
583             }
584         }
585         else
586         {
587             int offset = cl->record_offset;
588             if ((rec = ZOOM_resultset_record(resultset, offset)))
589             {
590                 cl->record_offset++;
591                 if (cl->session == 0)
592                     ;
593                 else if (ZOOM_record_error(rec, &msg, &addinfo, 0))
594                 {
595                     yaz_log(YLOG_WARN, "Record error %s (%s): %s (rec #%d)",
596                             msg, addinfo, client_get_url(cl),
597                             cl->record_offset);
598                 }
599                 else
600                 {
601                     struct session_database *sdb = client_get_database(cl);
602                     NMEM nmem = nmem_create();
603                     const char *xmlrec;
604                     char type[80];
605
606                     if (nativesyntax_to_type(sdb, type, rec))
607                         yaz_log(YLOG_WARN, "Failed to determine record type");
608                     xmlrec = ZOOM_record_get(rec, type, NULL);
609                     if (!xmlrec)
610                         yaz_log(YLOG_WARN, "ZOOM_record_get failed from %s",
611                                 client_get_url(cl));
612                     else
613                     {
614                         /* OK = 0, -1 = failure, -2 = Filtered */
615                         if (ingest_record(cl, xmlrec, cl->record_offset, nmem) == -1)
616                             yaz_log(YLOG_WARN, "Failed to ingest from %s", client_get_url(cl));
617                     }
618                     nmem_destroy(nmem);
619                 }
620             }
621             else
622             {
623                 yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d",
624                         offset);
625             }
626         }
627     }
628 }
629
630 static void client_set_facets_request(struct client *cl, ZOOM_connection link)
631 {
632     struct session_database *sdb = client_get_database(cl);
633
634     WRBUF w = wrbuf_alloc();
635     
636     struct setting *s;
637
638     for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
639     {
640         const char *p = strchr(s->name + 3, ':');
641         if (!p)
642         {
643             yaz_log(YLOG_WARN, "Malformed facetmap name: %s", s->name);
644         }
645         else if (s->value && s->value[0])
646         {
647             wrbuf_puts(w, "@attr 1=");
648             yaz_encode_pqf_term(w, s->value, strlen(s->value));
649             if (s->next)
650                 wrbuf_puts(w, ",");
651         }
652     }
653     yaz_log(YLOG_LOG, "using facets str: %s", wrbuf_cstr(w));
654     ZOOM_connection_option_set(link, "facets",
655                                wrbuf_len(w) ? wrbuf_cstr(w) : 0);
656     wrbuf_destroy(w);
657 }
658
659 int client_has_facet(struct client *cl, const char *name)
660 {
661     struct session_database *sdb = client_get_database(cl);
662     struct setting *s;
663
664     for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
665     {
666         const char *p = strchr(s->name + 3, ':');
667         if (p && !strcmp(name, p + 1))
668             return 1;
669     }
670     return 0;
671 }
672
673 void client_start_search(struct client *cl)
674 {
675     struct session_database *sdb = client_get_database(cl);
676     struct connection *co = client_get_connection(cl);
677     ZOOM_connection link = connection_get_link(co);
678     ZOOM_resultset rs;
679     char *databaseName = sdb->database->databases[0];
680     const char *opt_piggyback   = session_setting_oneval(sdb, PZ_PIGGYBACK);
681     const char *opt_queryenc    = session_setting_oneval(sdb, PZ_QUERYENCODING);
682     const char *opt_elements    = session_setting_oneval(sdb, PZ_ELEMENTS);
683     const char *opt_requestsyn  = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
684     const char *opt_maxrecs     = session_setting_oneval(sdb, PZ_MAXRECS);
685     const char *opt_sru         = session_setting_oneval(sdb, PZ_SRU);
686     const char *opt_sort        = session_setting_oneval(sdb, PZ_SORT);
687     const char *opt_preferred   = session_setting_oneval(sdb, PZ_PREFERRED);
688     const char *extra_args      = session_setting_oneval(sdb, PZ_EXTRA_ARGS);
689     char maxrecs_str[24], startrecs_str[24];
690
691     assert(link);
692
693     cl->hits = -1;
694     cl->record_offset = 0;
695     cl->diagnostic = 0;
696
697     if (extra_args && *extra_args)
698         ZOOM_connection_option_set(link, "extraArgs", extra_args);
699
700     if (opt_preferred) {
701         cl->preferred = atoi(opt_preferred);
702         if (cl->preferred)
703             yaz_log(YLOG_LOG, "Target %s has preferred status: %d", sdb->database->url, cl->preferred);
704     }
705     client_set_state(cl, Client_Working);
706
707     if (*opt_piggyback)
708         ZOOM_connection_option_set(link, "piggyback", opt_piggyback);
709     else
710         ZOOM_connection_option_set(link, "piggyback", "1");
711     if (*opt_queryenc)
712         ZOOM_connection_option_set(link, "rpnCharset", opt_queryenc);
713     if (*opt_sru && *opt_elements)
714         ZOOM_connection_option_set(link, "schema", opt_elements);
715     else if (*opt_elements)
716         ZOOM_connection_option_set(link, "elementSetName", opt_elements);
717     if (*opt_requestsyn)
718         ZOOM_connection_option_set(link, "preferredRecordSyntax", opt_requestsyn);
719
720     if (opt_maxrecs && *opt_maxrecs)
721     {
722         cl->maxrecs = atoi(opt_maxrecs);
723     }
724
725     /* convert back to string representation used in ZOOM API */
726     sprintf(maxrecs_str, "%d", cl->maxrecs);
727     ZOOM_connection_option_set(link, "count", maxrecs_str);
728
729     if (cl->maxrecs > 20)
730         ZOOM_connection_option_set(link, "presentChunk", "20");
731     else
732         ZOOM_connection_option_set(link, "presentChunk", maxrecs_str);
733
734     sprintf(startrecs_str, "%d", cl->startrecs);
735     ZOOM_connection_option_set(link, "start", startrecs_str);
736
737     if (databaseName)
738         ZOOM_connection_option_set(link, "databaseName", databaseName);
739
740     /* TODO Verify does it break something for CQL targets(non-SOLR) ? */
741     /* facets definition is in PQF */
742     client_set_facets_request(cl, link);
743
744     if (cl->cqlquery)
745     {
746         ZOOM_query q = ZOOM_query_create();
747         yaz_log(YLOG_LOG, "Search %s CQL: %s", sdb->database->url, cl->cqlquery);
748         ZOOM_query_cql(q, cl->cqlquery);
749         if (*opt_sort)
750             ZOOM_query_sortby(q, opt_sort);
751         rs = ZOOM_connection_search(link, q);
752         ZOOM_query_destroy(q);
753     }
754     else
755     {
756         yaz_log(YLOG_LOG, "Search %s PQF: %s", sdb->database->url, cl->pquery);
757         rs = ZOOM_connection_search_pqf(link, cl->pquery);
758     }
759     ZOOM_resultset_destroy(cl->resultset);
760     cl->resultset = rs;
761     connection_continue(co);
762 }
763
764 struct client *client_create(void)
765 {
766     struct client *cl = xmalloc(sizeof(*cl));
767     cl->maxrecs = 100;
768     cl->startrecs = 0;
769     cl->pquery = 0;
770     cl->cqlquery = 0;
771     cl->database = 0;
772     cl->connection = 0;
773     cl->session = 0;
774     cl->hits = 0;
775     cl->record_offset = 0;
776     cl->diagnostic = 0;
777     cl->state = Client_Disconnected;
778     cl->show_raw = 0;
779     cl->resultset = 0;
780     cl->mutex = 0;
781     pazpar2_mutex_create(&cl->mutex, "client");
782     cl->preferred = 0;
783     cl->ref_count = 1;
784     cl->url = 0;
785     client_use(1);
786     
787     return cl;
788 }
789
790 void client_lock(struct client *c)
791 {
792     yaz_mutex_enter(c->mutex);
793 }
794
795 void client_unlock(struct client *c)
796 {
797     yaz_mutex_leave(c->mutex);
798 }
799
800 void client_incref(struct client *c)
801 {
802     pazpar2_incref(&c->ref_count, c->mutex);
803     yaz_log(YLOG_DEBUG, "client_incref c=%p %s cnt=%d",
804             c, client_get_url(c), c->ref_count);
805 }
806
807 int client_destroy(struct client *c)
808 {
809     if (c)
810     {
811         yaz_log(YLOG_DEBUG, "client_destroy c=%p %s cnt=%d",
812                 c, client_get_url(c), c->ref_count);
813         if (!pazpar2_decref(&c->ref_count, c->mutex))
814         {
815             xfree(c->pquery);
816             c->pquery = 0;
817             xfree(c->cqlquery);
818             c->cqlquery = 0;
819             xfree(c->url);
820             assert(!c->connection);
821
822             if (c->resultset)
823             {
824                 ZOOM_resultset_destroy(c->resultset);
825             }
826             yaz_mutex_destroy(&c->mutex);
827             xfree(c);
828             client_use(-1);
829             return 1;
830         }
831     }
832     return 0;
833 }
834
835 void client_set_connection(struct client *cl, struct connection *con)
836 {
837     if (cl->resultset)
838         ZOOM_resultset_release(cl->resultset);
839     if (con)
840     {
841         assert(cl->connection == 0);
842         cl->connection = con;
843         client_incref(cl);
844     }
845     else
846     {
847         cl->connection = con;
848         client_destroy(cl);
849     }
850 }
851
852 void client_disconnect(struct client *cl)
853 {
854     if (cl->state != Client_Idle)
855         client_set_state(cl, Client_Disconnected);
856     client_set_connection(cl, 0);
857 }
858
859 // Extract terms from query into null-terminated termlist
860 static void extract_terms(NMEM nmem, struct ccl_rpn_node *query, char **termlist)
861 {
862     int num = 0;
863
864     pull_terms(nmem, query, termlist, &num);
865     termlist[num] = 0;
866 }
867
868 // Initialize CCL map for a target
869 static CCL_bibset prepare_cclmap(struct client *cl)
870 {
871     struct session_database *sdb = client_get_database(cl);
872     struct setting *s;
873     CCL_bibset res;
874
875     if (!sdb->settings)
876         return 0;
877     res = ccl_qual_mk();
878     for (s = sdb->settings[PZ_CCLMAP]; s; s = s->next)
879     {
880         char *p = strchr(s->name + 3, ':');
881         if (!p)
882         {
883             yaz_log(YLOG_WARN, "Malformed cclmap name: %s", s->name);
884             ccl_qual_rm(&res);
885             return 0;
886         }
887         p++;
888         ccl_qual_fitem(res, s->value, p);
889     }
890     return res;
891 }
892
893 // returns a xmalloced CQL query corresponding to the pquery in client
894 static char *make_cqlquery(struct client *cl)
895 {
896     cql_transform_t cqlt = cql_transform_create();
897     Z_RPNQuery *zquery;
898     char *r;
899     WRBUF wrb = wrbuf_alloc();
900     int status;
901     ODR odr_out = odr_createmem(ODR_ENCODE);
902
903     zquery = p_query_rpn(odr_out, cl->pquery);
904     yaz_log(YLOG_LOG, "PQF: %s", cl->pquery);
905     if ((status = cql_transform_rpn2cql_wrbuf(cqlt, wrb, zquery)))
906     {
907         yaz_log(YLOG_WARN, "Failed to generate CQL query, code=%d", status);
908         r = 0;
909     }
910     else
911     {
912         r = xstrdup(wrbuf_cstr(wrb));
913     }     
914     wrbuf_destroy(wrb);
915     odr_destroy(odr_out);
916     cql_transform_close(cqlt);
917     return r;
918 }
919
920 // returns a xmalloced SOLR query corresponding to the pquery in client
921 // TODO Could prob. be merge with the similar make_cqlquery
922 static char *make_solrquery(struct client *cl)
923 {
924     solr_transform_t sqlt = solr_transform_create();
925     Z_RPNQuery *zquery;
926     char *r;
927     WRBUF wrb = wrbuf_alloc();
928     int status;
929     ODR odr_out = odr_createmem(ODR_ENCODE);
930
931     zquery = p_query_rpn(odr_out, cl->pquery);
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, code=%d", 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     for (i = 0; (name = facet_limits_get(facet_limits, i, &value)); i++)
956     {
957         struct setting *s = 0;
958         
959         for (s = sdb->settings[PZ_LIMITMAP]; s; s = s->next)
960         {
961             const char *p = strchr(s->name + 3, ':');
962             if (p && !strcmp(p + 1, name) && s->value)
963             {
964                 if (!strncmp(s->value, "rpn:", 4))
965                 {
966                     const char *pqf = s->value + 4;
967                     wrbuf_puts(w_pqf, "@and ");
968                     wrbuf_puts(w_pqf, pqf);
969                     wrbuf_puts(w_pqf, " ");
970                     yaz_encode_pqf_term(w_pqf, value, strlen(value));
971                 }
972                 else if (!strncmp(s->value, "ccl:", 4))
973                 {
974                     const char *ccl = s->value + 4;
975                     wrbuf_puts(w_ccl, " and ");
976                     wrbuf_puts(w_ccl, ccl);
977                     wrbuf_puts(w_ccl, "=\"");
978                     wrbuf_puts(w_ccl, value);
979                     wrbuf_puts(w_ccl, "\"");
980                 }
981                 break;
982             }
983         }
984         if (!s)
985         {
986             yaz_log(YLOG_WARN, "limit %s used, but no limitmap defined",
987                     name);
988         }
989     }
990 }
991                         
992 // Parse the query given the settings specific to this client
993 int client_parse_query(struct client *cl, const char *query,
994                        facet_limits_t facet_limits)
995 {
996     struct session *se = client_get_session(cl);
997     struct session_database *sdb = client_get_database(cl);
998     struct ccl_rpn_node *cn;
999     int cerror, cpos;
1000     CCL_bibset ccl_map = prepare_cclmap(cl);
1001     const char *sru = session_setting_oneval(sdb, PZ_SRU);
1002     const char *pqf_prefix = session_setting_oneval(sdb, PZ_PQF_PREFIX);
1003     const char *pqf_strftime = session_setting_oneval(sdb, PZ_PQF_STRFTIME);
1004     const char *query_syntax = session_setting_oneval(sdb, PZ_QUERY_SYNTAX);
1005     WRBUF w_ccl, w_pqf;
1006     if (!ccl_map)
1007         return -1;
1008
1009     w_ccl = wrbuf_alloc();
1010     wrbuf_puts(w_ccl, query);
1011
1012     w_pqf = wrbuf_alloc();
1013     if (*pqf_prefix)
1014     {
1015         wrbuf_puts(w_pqf, pqf_prefix);
1016         wrbuf_puts(w_pqf, " ");
1017     }
1018
1019     apply_limit(sdb, facet_limits, w_pqf, w_ccl);
1020
1021     yaz_log(YLOG_LOG, "CCL query: %s", wrbuf_cstr(w_ccl));
1022     cn = ccl_find_str(ccl_map, wrbuf_cstr(w_ccl), &cerror, &cpos);
1023     ccl_qual_rm(&ccl_map);
1024     if (!cn)
1025     {
1026         client_set_state(cl, Client_Error);
1027         session_log(se, YLOG_WARN, "Failed to parse CCL query '%s' for %s",
1028                     wrbuf_cstr(w_ccl),
1029                     client_get_database(cl)->database->url);
1030         wrbuf_destroy(w_ccl);
1031         wrbuf_destroy(w_pqf);
1032         return -1;
1033     }
1034     wrbuf_destroy(w_ccl);
1035
1036     if (!pqf_strftime || !*pqf_strftime)
1037         ccl_pquery(w_pqf, cn);
1038     else
1039     {
1040         time_t cur_time = time(0);
1041         struct tm *tm =  localtime(&cur_time);
1042         char tmp_str[300];
1043         const char *cp = tmp_str;
1044
1045         /* see man strftime(3) for things .. In particular %% gets converted
1046          to %.. And That's our original query .. */
1047         strftime(tmp_str, sizeof(tmp_str)-1, pqf_strftime, tm);
1048         for (; *cp; cp++)
1049         {
1050             if (cp[0] == '%')
1051                 ccl_pquery(w_pqf, cn);
1052             else
1053                 wrbuf_putc(w_pqf, cp[0]);
1054         }
1055     }
1056     xfree(cl->pquery);
1057     cl->pquery = xstrdup(wrbuf_cstr(w_pqf));
1058     wrbuf_destroy(w_pqf);
1059
1060     yaz_log(YLOG_LOG, "PQF query: %s", cl->pquery);
1061
1062     xfree(cl->cqlquery);
1063
1064     /* Support for PQF on SRU targets. */
1065     /* TODO Refactor */
1066     yaz_log(YLOG_DEBUG, "Query syntax: %s", query_syntax);
1067     if (strcmp(query_syntax, "pqf") != 0 && *sru)
1068     {
1069         if (!strcmp(sru, "solr")) {
1070             if (!(cl->cqlquery = make_solrquery(cl)))
1071                 return -1;
1072         }
1073         else {
1074             if (!(cl->cqlquery = make_cqlquery(cl)))
1075                 return -1;
1076         }
1077     }
1078     else
1079         cl->cqlquery = 0;
1080
1081     /* TODO FIX Not thread safe */
1082     if (!se->relevance)
1083     {
1084         // Initialize relevance structure with query terms
1085         char *p[512];
1086         extract_terms(se->nmem, cn, p);
1087         se->relevance = relevance_create(
1088             se->service->charsets,
1089             se->nmem, (const char **) p);
1090     }
1091
1092     ccl_rpn_delete(cn);
1093     return 0;
1094 }
1095
1096 void client_set_session(struct client *cl, struct session *se)
1097 {
1098     cl->session = se;
1099 }
1100
1101 int client_is_active(struct client *cl)
1102 {
1103     if (cl->connection && (cl->state == Client_Connecting ||
1104                            cl->state == Client_Working))
1105         return 1;
1106     return 0;
1107 }
1108
1109 int client_is_active_preferred(struct client *cl)
1110 {
1111     /* only count if this is a preferred target. */
1112     if (!cl->preferred)
1113         return 0;
1114     /* TODO No sure this the condition that Seb wants */
1115     if (cl->connection && (cl->state == Client_Connecting ||
1116                            cl->state == Client_Working))
1117         return 1;
1118     return 0;
1119 }
1120
1121
1122 Odr_int client_get_hits(struct client *cl)
1123 {
1124     return cl->hits;
1125 }
1126
1127 int client_get_num_records(struct client *cl)
1128 {
1129     return cl->record_offset;
1130 }
1131
1132 void client_set_diagnostic(struct client *cl, int diagnostic)
1133 {
1134     cl->diagnostic = diagnostic;
1135 }
1136
1137 int client_get_diagnostic(struct client *cl)
1138 {
1139     return cl->diagnostic;
1140 }
1141
1142 void client_set_database(struct client *cl, struct session_database *db)
1143 {
1144     cl->database = db;
1145     /* Copy the URL for safe logging even after session is gone */
1146     if (db) {
1147         cl->url = xstrdup(db->database->url);
1148     }
1149 }
1150
1151 struct host *client_get_host(struct client *cl)
1152 {
1153     return client_get_database(cl)->database->host;
1154 }
1155
1156 const char *client_get_url(struct client *cl)
1157 {
1158     if (cl->url)
1159         return cl->url;
1160     else
1161         /* This must not happen anymore, as the url is present until destruction of client  */
1162         return "NOURL";
1163 }
1164
1165 void client_set_maxrecs(struct client *cl, int v)
1166 {
1167     cl->maxrecs = v;
1168 }
1169
1170 int client_get_maxrecs(struct client *cl)
1171 {
1172     return cl->maxrecs;
1173 }
1174
1175 void client_set_startrecs(struct client *cl, int v)
1176 {
1177     cl->startrecs = v;
1178 }
1179
1180 void client_set_preferred(struct client *cl, int v)
1181 {
1182     cl->preferred = v;
1183 }
1184
1185
1186 /*
1187  * Local variables:
1188  * c-basic-offset: 4
1189  * c-file-style: "Stroustrup"
1190  * indent-tabs-mode: nil
1191  * End:
1192  * vim: shiftwidth=4 tabstop=8 expandtab
1193  */
1194