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