src/client.c

   1 /* This file is part of Pazpar2.
   2    Copyright (C) 2006-2013 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 #ifdef WIN32
  37 #include <windows.h>
  38 #endif
  39 #include <signal.h>
  40 #include <assert.h>
  41
  42 #include <yaz/marcdisp.h>
  43 #include <yaz/comstack.h>
  44 #include <yaz/tcpip.h>
  45 #include <yaz/proto.h>
  46 #include <yaz/readconf.h>
  47 #include <yaz/pquery.h>
  48 #include <yaz/otherinfo.h>
  49 #include <yaz/yaz-util.h>
  50 #include <yaz/nmem.h>
  51 #include <yaz/query-charset.h>
  52 #include <yaz/querytowrbuf.h>
  53 #include <yaz/oid_db.h>
  54 #include <yaz/diagbib1.h>
  55 #include <yaz/snprintf.h>
  56 #include <yaz/rpn2cql.h>
  57 #include <yaz/rpn2solr.h>
  58 #include <yaz/gettimeofday.h>
  59
  60 #define USE_TIMING 0
  61 #if USE_TIMING
  62 #include <yaz/timing.h>
  63 #endif
  64
  65 #include "ppmutex.h"
  66 #include "session.h"
  67 #include "parameters.h"
  68 #include "client.h"
  69 #include "connection.h"
  70 #include "settings.h"
  71 #include "relevance.h"
  72 #include "incref.h"
  73
  74 static YAZ_MUTEX g_mutex = 0;
  75 static int no_clients = 0;
  76 static int no_clients_total = 0;
  77
  78 static int client_use(int delta)
  79 {
  80     int clients;
  81     if (!g_mutex)
  82         yaz_mutex_create(&g_mutex);
  83     yaz_mutex_enter(g_mutex);
  84     no_clients += delta;
  85     if (delta > 0)
  86         no_clients_total += delta;
  87     clients = no_clients;
  88     yaz_mutex_leave(g_mutex);
  89     yaz_log(YLOG_DEBUG, "%s clients=%d", delta == 0 ? "" : (delta > 0 ? "INC" : "DEC"), clients);
  90     return clients;
  91 }
  92
  93 int  clients_count(void) {
  94     return client_use(0);
  95 }
  96
  97 int  clients_count_total(void) {
  98     int total = 0;
  99     if (!g_mutex)
 100         return 0;
 101     yaz_mutex_enter(g_mutex);
 102     total = no_clients_total;
 103     yaz_mutex_leave(g_mutex);
 104     return total;
 105 }
 106
 107
 108 /** \brief Represents client state for a connection to one search target */
 109 struct client {
 110     struct session_database *database;
 111     struct connection *connection;
 112     struct session *session;
 113     char *pquery; // Current search
 114     char *cqlquery; // used for SRU targets only
 115     char *addinfo; // diagnostic info for most resent error
 116     Odr_int hits;
 117     int record_offset;
 118     int filtered; // When using local:, this will count the number of filtered records.
 119     int maxrecs;
 120     int startrecs;
 121     int diagnostic;
 122     char *message;
 123     int preferred;
 124     struct suggestions *suggestions;
 125     enum client_state state;
 126     struct show_raw *show_raw;
 127     ZOOM_resultset resultset;
 128     int ref_count;
 129     char *id;
 130     facet_limits_t facet_limits;
 131     int same_search;
 132     char *sort_strategy;
 133     char *sort_criteria;
 134 };
 135
 136 struct suggestions {
 137     NMEM nmem;
 138     int num;
 139     char **misspelled;
 140     char **suggest;
 141     char *passthrough;
 142 };
 143
 144 struct show_raw {
 145     int active; // whether this request has been sent to the server
 146     int position;
 147     int binary;
 148     char *syntax;
 149     char *esn;
 150     char *nativesyntax;
 151     void (*error_handler)(void *data, const char *addinfo);
 152     void (*record_handler)(void *data, const char *buf, size_t sz);
 153     void *data;
 154     struct show_raw *next;
 155 };
 156
 157 static const char *client_states[] = {
 158     "Client_Connecting",
 159     "Client_Idle",
 160     "Client_Working",
 161     "Client_Error",
 162     "Client_Failed",
 163     "Client_Disconnected"
 164 };
 165
 166 const char *client_get_state_str(struct client *cl)
 167 {
 168     return client_states[cl->state];
 169 }
 170
 171 enum client_state client_get_state(struct client *cl)
 172 {
 173     return cl->state;
 174 }
 175
 176 void client_set_state_nb(struct client *cl, enum client_state st)
 177 {
 178     cl->state = st;
 179 }
 180
 181 void client_set_state(struct client *cl, enum client_state st)
 182 {
 183     int was_active = 0;
 184     if (client_is_active(cl))
 185         was_active = 1;
 186     cl->state = st;
 187     /* If client is going from being active to inactive and all clients
 188        are now idle we fire a watch for the session . The assumption is
 189        that session is not mutex locked if client is already active */
 190     if (was_active && !client_is_active(cl) && cl->session)
 191     {
 192
 193         int no_active = session_active_clients(cl->session);
 194         yaz_log(YLOG_DEBUG, "%s: releasing watches on zero active: %d",
 195                 client_get_id(cl), no_active);
 196         if (no_active == 0) {
 197             session_alert_watch(cl->session, SESSION_WATCH_SHOW);
 198             session_alert_watch(cl->session, SESSION_WATCH_BYTARGET);
 199             session_alert_watch(cl->session, SESSION_WATCH_TERMLIST);
 200             session_alert_watch(cl->session, SESSION_WATCH_SHOW_PREF);
 201         }
 202     }
 203 }
 204
 205 static void client_show_raw_error(struct client *cl, const char *addinfo);
 206
 207 struct connection *client_get_connection(struct client *cl)
 208 {
 209     return cl->connection;
 210 }
 211
 212 struct session_database *client_get_database(struct client *cl)
 213 {
 214     return cl->database;
 215 }
 216
 217 struct session *client_get_session(struct client *cl)
 218 {
 219     return cl->session;
 220 }
 221
 222 const char *client_get_pquery(struct client *cl)
 223 {
 224     return cl->pquery;
 225 }
 226
 227 static void client_send_raw_present(struct client *cl);
 228 static int nativesyntax_to_type(const char *s, char *type, ZOOM_record rec);
 229
 230 static void client_show_immediate(
 231     ZOOM_resultset resultset, struct session_database *sdb, int position,
 232     void *data,
 233     void (*error_handler)(void *data, const char *addinfo),
 234     void (*record_handler)(void *data, const char *buf, size_t sz),
 235     int binary,
 236     const char *nativesyntax)
 237 {
 238     ZOOM_record rec = 0;
 239     char type[80];
 240     const char *buf;
 241     int len;
 242
 243     if (!resultset)
 244     {
 245         error_handler(data, "no resultset");
 246         return;
 247     }
 248     rec = ZOOM_resultset_record_immediate(resultset, position-1);
 249     if (!rec)
 250     {
 251         error_handler(data, "no record");
 252         return;
 253     }
 254     nativesyntax_to_type(nativesyntax, type, rec);
 255     buf = ZOOM_record_get(rec, type, &len);
 256     if (!buf)
 257     {
 258         error_handler(data, "no record");
 259         return;
 260     }
 261     record_handler(data, buf, len);
 262 }
 263
 264
 265 int client_show_raw_begin(struct client *cl, int position,
 266                           const char *syntax, const char *esn,
 267                           void *data,
 268                           void (*error_handler)(void *data, const char *addinfo),
 269                           void (*record_handler)(void *data, const char *buf,
 270                                                  size_t sz),
 271                           int binary,
 272                           const char *nativesyntax)
 273 {
 274     if (!nativesyntax)
 275     {
 276         if (binary)
 277             nativesyntax = "raw";
 278         else
 279         {
 280             struct session_database *sdb = client_get_database(cl);
 281             nativesyntax = session_setting_oneval(sdb, PZ_NATIVESYNTAX);
 282         }
 283     }
 284
 285     if (syntax == 0 && esn == 0)
 286         client_show_immediate(cl->resultset, client_get_database(cl),
 287                               position, data,
 288                               error_handler, record_handler,
 289                               binary, nativesyntax);
 290     else
 291     {
 292         struct show_raw *rr, **rrp;
 293
 294         if (!cl->connection)
 295             return -1;
 296
 297
 298         rr = xmalloc(sizeof(*rr));
 299         rr->position = position;
 300         rr->active = 0;
 301         rr->data = data;
 302         rr->error_handler = error_handler;
 303         rr->record_handler = record_handler;
 304         rr->binary = binary;
 305         if (syntax)
 306             rr->syntax = xstrdup(syntax);
 307         else
 308             rr->syntax = 0;
 309         if (esn)
 310             rr->esn = xstrdup(esn);
 311         else
 312             rr->esn = 0;
 313
 314         assert(nativesyntax);
 315         rr->nativesyntax = xstrdup(nativesyntax);
 316
 317         rr->next = 0;
 318
 319         for (rrp = &cl->show_raw; *rrp; rrp = &(*rrp)->next)
 320             ;
 321         *rrp = rr;
 322
 323         if (cl->state == Client_Failed)
 324         {
 325             client_show_raw_error(cl, "client failed");
 326         }
 327         else if (cl->state == Client_Disconnected)
 328         {
 329             client_show_raw_error(cl, "client disconnected");
 330         }
 331         else
 332         {
 333             client_send_raw_present(cl);
 334         }
 335     }
 336     return 0;
 337 }
 338
 339 static void client_show_raw_delete(struct show_raw *r)
 340 {
 341     xfree(r->syntax);
 342     xfree(r->esn);
 343     xfree(r->nativesyntax);
 344     xfree(r);
 345 }
 346
 347 void client_show_raw_remove(struct client *cl, void *data)
 348 {
 349     struct show_raw *rr = data;
 350     struct show_raw **rrp = &cl->show_raw;
 351     while (*rrp != rr)
 352         rrp = &(*rrp)->next;
 353     if (*rrp)
 354     {
 355         *rrp = rr->next;
 356         client_show_raw_delete(rr);
 357     }
 358 }
 359
 360 void client_show_raw_dequeue(struct client *cl)
 361 {
 362     struct show_raw *rr = cl->show_raw;
 363
 364     cl->show_raw = rr->next;
 365     client_show_raw_delete(rr);
 366 }
 367
 368 static void client_show_raw_error(struct client *cl, const char *addinfo)
 369 {
 370     while (cl->show_raw)
 371     {
 372         cl->show_raw->error_handler(cl->show_raw->data, addinfo);
 373         client_show_raw_dequeue(cl);
 374     }
 375 }
 376
 377 static void client_send_raw_present(struct client *cl)
 378 {
 379     struct session_database *sdb = client_get_database(cl);
 380     struct connection *co = client_get_connection(cl);
 381     ZOOM_resultset set = cl->resultset;
 382
 383     int offset = cl->show_raw->position;
 384     const char *syntax = 0;
 385     const char *elements = 0;
 386
 387     assert(cl->show_raw);
 388     assert(set);
 389
 390     yaz_log(YLOG_DEBUG, "%s: trying to present %d record(s) from %d",
 391             client_get_id(cl), 1, offset);
 392
 393     if (cl->show_raw->syntax)
 394         syntax = cl->show_raw->syntax;
 395     else
 396         syntax = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
 397     ZOOM_resultset_option_set(set, "preferredRecordSyntax", syntax);
 398
 399     if (cl->show_raw->esn)
 400         elements = cl->show_raw->esn;
 401     else
 402         elements = session_setting_oneval(sdb, PZ_ELEMENTS);
 403     if (elements && *elements)
 404         ZOOM_resultset_option_set(set, "elementSetName", elements);
 405
 406     ZOOM_resultset_records(set, 0, offset-1, 1);
 407     cl->show_raw->active = 1;
 408
 409     connection_continue(co);
 410 }
 411
 412 static int nativesyntax_to_type(const char *s, char *type,
 413                                 ZOOM_record rec)
 414 {
 415     if (s && *s)
 416     {
 417         if (!strncmp(s, "iso2709", 7))
 418         {
 419             const char *cp = strchr(s, ';');
 420             yaz_snprintf(type, 80, "xml; charset=%s", cp ? cp+1 : "marc-8s");
 421         }
 422         else if (!strncmp(s, "txml", 4))
 423         {
 424             const char *cp = strchr(s, ';');
 425             yaz_snprintf(type, 80, "txml; charset=%s", cp ? cp+1 : "marc-8s");
 426         }
 427         else /* pass verbatim to ZOOM - including "xml" */
 428             strcpy(type, s);
 429         return 0;
 430     }
 431     else  /* attempt to deduce structure */
 432     {
 433         const char *syntax = ZOOM_record_get(rec, "syntax", NULL);
 434         if (syntax)
 435         {
 436             if (!strcmp(syntax, "XML"))
 437             {
 438                 strcpy(type, "xml");
 439                 return 0;
 440             }
 441             else if (!strcmp(syntax, "USmarc") || !strcmp(syntax, "MARC21"))
 442             {
 443                 strcpy(type, "xml; charset=marc8-s");
 444                 return 0;
 445             }
 446             else return -1;
 447         }
 448         else return -1;
 449     }
 450 }
 451
 452 /**
 453  * TODO Consider thread safety!!!
 454  *
 455  */
 456 void client_report_facets(struct client *cl, ZOOM_resultset rs)
 457 {
 458     struct session_database *sdb = client_get_database(cl);
 459     ZOOM_facet_field *facets = ZOOM_resultset_facets(rs);
 460
 461     if (sdb && facets)
 462     {
 463         struct session *se = client_get_session(cl);
 464         int facet_num = ZOOM_resultset_facets_size(rs);
 465         struct setting *s;
 466
 467         for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
 468         {
 469             const char *p = strchr(s->name + 3, ':');
 470             if (p && p[1] && s->value && s->value[0])
 471             {
 472                 int facet_idx;
 473                 p++; /* p now holds logical facet name */
 474                 for (facet_idx = 0; facet_idx < facet_num; facet_idx++)
 475                 {
 476                     const char *native_name =
 477                         ZOOM_facet_field_name(facets[facet_idx]);
 478                     if (native_name && !strcmp(s->value, native_name))
 479                     {
 480                         size_t term_idx;
 481                         size_t term_num =
 482                             ZOOM_facet_field_term_count(facets[facet_idx]);
 483                         for (term_idx = 0; term_idx < term_num; term_idx++ )
 484                         {
 485                             int freq;
 486                             const char *term =
 487                                 ZOOM_facet_field_get_term(facets[facet_idx],
 488                                                           term_idx, &freq);
 489                             if (term)
 490                                 add_facet(se, p, term, freq);
 491                         }
 492                         break;
 493                     }
 494                 }
 495             }
 496         }
 497     }
 498 }
 499
 500 static void ingest_raw_record(struct client *cl, ZOOM_record rec)
 501 {
 502     const char *buf;
 503     int len;
 504     char type[80];
 505
 506     nativesyntax_to_type(cl->show_raw->nativesyntax, type, rec);
 507     buf = ZOOM_record_get(rec, type, &len);
 508     cl->show_raw->record_handler(cl->show_raw->data,  buf, len);
 509     client_show_raw_dequeue(cl);
 510 }
 511
 512 void client_check_preferred_watch(struct client *cl)
 513 {
 514     struct session *se = cl->session;
 515
 516     session_enter_ro(se, "client_check_preferred_watch");
 517     yaz_log(YLOG_DEBUG, "client_check_preferred_watch: %s ", client_get_id(cl));
 518     if (se)
 519     {
 520         /* TODO possible threading issue. Session can have been destroyed */
 521         assert(cl->session);
 522         if (session_is_preferred_clients_ready(se)) {
 523             assert(cl->session);
 524             session_alert_watch(se, SESSION_WATCH_SHOW_PREF);
 525             assert(cl->session);
 526         }
 527         else
 528             yaz_log(YLOG_DEBUG, "client_check_preferred_watch: Still locked on preferred targets.");
 529         assert(cl->session);
 530     }
 531     else
 532         yaz_log(YLOG_WARN, "client_check_preferred_watch: %s. No session!", client_get_id(cl));
 533
 534     session_leave_ro(se, "client_check_preferred_watch");
 535 }
 536
 537 struct suggestions* client_suggestions_create(const char* suggestions_string);
 538 static void client_suggestions_destroy(struct client *cl);
 539
 540 void client_search_response(struct client *cl)
 541 {
 542     struct connection *co = cl->connection;
 543     ZOOM_connection link = connection_get_link(co);
 544     ZOOM_resultset resultset = cl->resultset;
 545
 546     const char *error, *addinfo = 0;
 547
 548     session_enter_rw(cl->session, "client_search_response");
 549     if (ZOOM_connection_error(link, &error, &addinfo))
 550     {
 551         cl->hits = 0;
 552         client_set_state(cl, Client_Error);
 553         yaz_log(YLOG_WARN, "Search error %s (%s): %s",
 554                 error, addinfo, client_get_id(cl));
 555     }
 556     else
 557     {
 558         client_report_facets(cl, resultset);
 559         cl->record_offset = cl->startrecs;
 560         cl->hits = ZOOM_resultset_size(resultset);
 561         yaz_log(YLOG_DEBUG, "client_search_response: hits " ODR_INT_PRINTF, cl->hits);
 562         if (cl->suggestions)
 563             client_suggestions_destroy(cl);
 564         cl->suggestions = client_suggestions_create(ZOOM_resultset_option_get(resultset, "suggestions"));
 565     }
 566     session_leave_rw(cl->session, "client_search_response");
 567 }
 568
 569 void client_got_records(struct client *cl)
 570 {
 571     struct session *se = cl->session;
 572
 573     session_enter_ro(se, "client_got_records");
 574     if (reclist_get_num_records(se->reclist) > 0)
 575     {
 576         session_alert_watch(se, SESSION_WATCH_SHOW);
 577         session_alert_watch(se, SESSION_WATCH_BYTARGET);
 578         session_alert_watch(se, SESSION_WATCH_TERMLIST);
 579         session_alert_watch(se, SESSION_WATCH_RECORD);
 580     }
 581     session_leave_ro(se, "client_got_records");
 582 }
 583
 584 static void client_record_ingest(struct client *cl)
 585 {
 586     const char *msg, *addinfo;
 587     ZOOM_record rec = 0;
 588     ZOOM_resultset resultset = cl->resultset;
 589     struct session *se = client_get_session(cl);
 590
 591     if ((rec = ZOOM_resultset_record_immediate(resultset, cl->record_offset)))
 592     {
 593         int offset = ++cl->record_offset;
 594         if (cl->session == 0) {
 595             /* no operation */
 596         }
 597         else if (ZOOM_record_error(rec, &msg, &addinfo, 0))
 598         {
 599             session_log(se, YLOG_WARN, "Record error %s (%s): %s #%d",
 600                         msg, addinfo, client_get_id(cl), offset);
 601         }
 602         else
 603         {
 604             struct session_database *sdb = client_get_database(cl);
 605             NMEM nmem = nmem_create();
 606             const char *xmlrec;
 607             char type[80];
 608
 609             const char *s = session_setting_oneval(sdb, PZ_NATIVESYNTAX);
 610             if (nativesyntax_to_type(s, type, rec))
 611                 session_log(se, YLOG_WARN, "Failed to determine record type");
 612             xmlrec = ZOOM_record_get(rec, type, NULL);
 613             if (!xmlrec)
 614             {
 615                 const char *rec_syn =  ZOOM_record_get(rec, "syntax", NULL);
 616                 session_log(se, YLOG_WARN, "ZOOM_record_get failed from %s #%d",
 617                             client_get_id(cl), offset);
 618                 session_log(se, YLOG_LOG, "pz:nativesyntax=%s . "
 619                             "ZOOM record type=%s . Actual record syntax=%s",
 620                             s ? s : "null", type,
 621                             rec_syn ? rec_syn : "null");
 622             }
 623             else
 624             {
 625                 /* OK = 0, -1 = failure, -2 = Filtered */
 626                 int rc = ingest_record(cl, xmlrec, cl->record_offset, nmem);
 627                 if (rc == -1)
 628                 {
 629                     const char *rec_syn =  ZOOM_record_get(rec, "syntax", NULL);
 630                     session_log(se, YLOG_WARN,
 631                                 "Failed to ingest record from %s #%d",
 632                                 client_get_id(cl), offset);
 633                     session_log(se, YLOG_LOG, "pz:nativesyntax=%s . "
 634                                 "ZOOM record type=%s . Actual record syntax=%s",
 635                                 s ? s : "null", type,
 636                                 rec_syn ? rec_syn : "null");
 637                 }
 638                 if (rc == -2)
 639                     cl->filtered += 1;
 640             }
 641             nmem_destroy(nmem);
 642         }
 643     }
 644     else
 645     {
 646         session_log(se, YLOG_WARN, "Got NULL record from %s #%d",
 647                     client_get_id(cl), cl->record_offset);
 648     }
 649 }
 650
 651 void client_record_response(struct client *cl)
 652 {
 653     struct connection *co = cl->connection;
 654     ZOOM_connection link = connection_get_link(co);
 655     ZOOM_resultset resultset = cl->resultset;
 656     const char *error, *addinfo;
 657
 658     session_enter_rw(cl->session, "client_record_response");
 659     if (ZOOM_connection_error(link, &error, &addinfo))
 660     {
 661         client_set_state(cl, Client_Error);
 662         yaz_log(YLOG_WARN, "Search error %s (%s): %s",
 663             error, addinfo, client_get_id(cl));
 664     }
 665     else
 666     {
 667         if (cl->show_raw && cl->show_raw->active)
 668         {
 669             ZOOM_record rec = 0;
 670             if ((rec = ZOOM_resultset_record_immediate(
 671                      resultset, cl->show_raw->position-1)))
 672             {
 673                 cl->show_raw->active = 0;
 674                 ingest_raw_record(cl, rec);
 675             }
 676             else
 677             {
 678                 yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d",
 679                         cl->show_raw->position-1);
 680             }
 681         }
 682         else
 683         {
 684             client_record_ingest(cl);
 685         }
 686     }
 687     session_leave_rw(cl->session, "client_record_response");
 688 }
 689
 690 int client_reingest(struct client *cl)
 691 {
 692     int i = cl->startrecs;
 693     int to = cl->record_offset;
 694     cl->filtered = 0;
 695
 696     cl->record_offset = i;
 697     for (; i < to; i++)
 698         client_record_ingest(cl);
 699     return 0;
 700 }
 701
 702 static void client_set_facets_request(struct client *cl, ZOOM_connection link)
 703 {
 704     struct session_database *sdb = client_get_database(cl);
 705
 706     WRBUF w = wrbuf_alloc();
 707
 708     struct setting *s;
 709
 710     for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
 711     {
 712         const char *p = strchr(s->name + 3, ':');
 713         if (!p)
 714         {
 715             yaz_log(YLOG_WARN, "Malformed facetmap name: %s", s->name);
 716         }
 717         else if (s->value && s->value[0])
 718         {
 719             wrbuf_puts(w, "@attr 1=");
 720             yaz_encode_pqf_term(w, s->value, strlen(s->value));
 721             if (s->next)
 722                 wrbuf_puts(w, ",");
 723         }
 724     }
 725     yaz_log(YLOG_DEBUG, "using facets str: %s", wrbuf_cstr(w));
 726     ZOOM_connection_option_set(link, "facets",
 727                                wrbuf_len(w) ? wrbuf_cstr(w) : 0);
 728     wrbuf_destroy(w);
 729 }
 730
 731 int client_has_facet(struct client *cl, const char *name)
 732 {
 733     struct session_database *sdb = client_get_database(cl);
 734     struct setting *s;
 735
 736     for (s = sdb->settings[PZ_FACETMAP]; s; s = s->next)
 737     {
 738         const char *p = strchr(s->name + 3, ':');
 739         if (p && !strcmp(name, p + 1))
 740             return 1;
 741     }
 742     return 0;
 743 }
 744
 745 static const char *get_strategy_plus_sort(struct client *l, const char *field)
 746 {
 747     struct session_database *sdb = client_get_database(l);
 748     struct setting *s;
 749
 750     const char *strategy_plus_sort = 0;
 751
 752     for (s = sdb->settings[PZ_SORTMAP]; s; s = s->next)
 753     {
 754         char *p = strchr(s->name + 3, ':');
 755         if (!p)
 756         {
 757             yaz_log(YLOG_WARN, "Malformed sortmap name: %s", s->name);
 758             continue;
 759         }
 760         p++;
 761         if (!strcmp(p, field))
 762         {
 763             strategy_plus_sort = s->value;
 764             break;
 765         }
 766     }
 767     return strategy_plus_sort;
 768 }
 769
 770 int client_parse_init(struct client *cl, int same_search)
 771 {
 772     cl->same_search = same_search;
 773     return 0;
 774 }
 775
 776 /*
 777  * TODO consider how to extend the range
 778  * */
 779 int client_parse_range(struct client *cl, const char *startrecs, const char *maxrecs)
 780 {
 781     if (maxrecs && atoi(maxrecs) != cl->maxrecs)
 782     {
 783         cl->same_search = 0;
 784         cl->maxrecs = atoi(maxrecs);
 785     }
 786
 787     if (startrecs && atoi(startrecs) != cl->startrecs)
 788     {
 789         cl->same_search = 0;
 790         cl->startrecs = atoi(startrecs);
 791     }
 792
 793     return 0;
 794 }
 795
 796 int client_start_search(struct client *cl)
 797 {
 798     struct session_database *sdb = client_get_database(cl);
 799     struct connection *co = 0;
 800     ZOOM_connection link = 0;
 801     struct session *se = client_get_session(cl);
 802     ZOOM_resultset rs;
 803     const char *opt_piggyback   = session_setting_oneval(sdb, PZ_PIGGYBACK);
 804     const char *opt_queryenc    = session_setting_oneval(sdb, PZ_QUERYENCODING);
 805     const char *opt_elements    = session_setting_oneval(sdb, PZ_ELEMENTS);
 806     const char *opt_requestsyn  = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
 807     const char *opt_maxrecs     = session_setting_oneval(sdb, PZ_MAXRECS);
 808     const char *opt_sru         = session_setting_oneval(sdb, PZ_SRU);
 809     const char *opt_sort        = session_setting_oneval(sdb, PZ_SORT);
 810     const char *opt_preferred   = session_setting_oneval(sdb, PZ_PREFERRED);
 811     const char *extra_args      = session_setting_oneval(sdb, PZ_EXTRA_ARGS);
 812     const char *opt_present_chunk = session_setting_oneval(sdb, PZ_PRESENT_CHUNK);
 813     ZOOM_query query;
 814     char maxrecs_str[24], startrecs_str[24], present_chunk_str[24];
 815     struct timeval tval;
 816     int present_chunk = 20; // Default chunk size
 817     int rc_prep_connection;
 818
 819
 820     yaz_gettimeofday(&tval);
 821     tval.tv_sec += 5;
 822
 823     if (opt_present_chunk && strcmp(opt_present_chunk,"")) {
 824         present_chunk = atoi(opt_present_chunk);
 825         yaz_log(YLOG_DEBUG, "Present chunk set to %d", present_chunk);
 826     }
 827     rc_prep_connection =
 828         client_prep_connection(cl, se->service->z3950_operation_timeout,
 829                                se->service->z3950_session_timeout,
 830                                se->service->server->iochan_man,
 831                                &tval);
 832     /* Nothing has changed and we already have a result */
 833     if (cl->same_search == 1 && rc_prep_connection == 2)
 834     {
 835         session_log(se, YLOG_LOG, "client %s REUSE result", client_get_id(cl));
 836         return client_reingest(cl);
 837     }
 838     else if (!rc_prep_connection)
 839     {
 840         session_log(se, YLOG_LOG, "client %s FAILED to search: No connection.", client_get_id(cl));
 841         return -1;
 842     }
 843     co = client_get_connection(cl);
 844     assert(cl);
 845     link = connection_get_link(co);
 846     assert(link);
 847
 848     session_log(se, YLOG_LOG, "client %s NEW search", client_get_id(cl));
 849
 850     cl->diagnostic = 0;
 851     cl->filtered = 0;
 852
 853     if (extra_args && *extra_args)
 854         ZOOM_connection_option_set(link, "extraArgs", extra_args);
 855
 856     if (opt_preferred) {
 857         cl->preferred = atoi(opt_preferred);
 858         if (cl->preferred)
 859             yaz_log(YLOG_LOG, "Target %s has preferred status: %d",
 860                     client_get_id(cl), cl->preferred);
 861     }
 862
 863     if (*opt_piggyback)
 864         ZOOM_connection_option_set(link, "piggyback", opt_piggyback);
 865     else
 866         ZOOM_connection_option_set(link, "piggyback", "1");
 867     if (*opt_queryenc)
 868         ZOOM_connection_option_set(link, "rpnCharset", opt_queryenc);
 869     if (*opt_sru && *opt_elements)
 870         ZOOM_connection_option_set(link, "schema", opt_elements);
 871     else if (*opt_elements)
 872         ZOOM_connection_option_set(link, "elementSetName", opt_elements);
 873     if (*opt_requestsyn)
 874         ZOOM_connection_option_set(link, "preferredRecordSyntax", opt_requestsyn);
 875
 876     if (opt_maxrecs && *opt_maxrecs)
 877     {
 878         cl->maxrecs = atoi(opt_maxrecs);
 879     }
 880
 881     /* convert back to string representation used in ZOOM API */
 882     sprintf(maxrecs_str, "%d", cl->maxrecs);
 883     ZOOM_connection_option_set(link, "count", maxrecs_str);
 884
 885     /* A present_chunk less than 1 will disable chunking. */
 886     if (present_chunk > 0 && cl->maxrecs > present_chunk) {
 887         sprintf(present_chunk_str, "%d", present_chunk);
 888         ZOOM_connection_option_set(link, "presentChunk", present_chunk_str);
 889         yaz_log(YLOG_DEBUG, "Present chunk set to %s", present_chunk_str);
 890     }
 891     else {
 892         ZOOM_connection_option_set(link, "presentChunk", maxrecs_str);
 893         yaz_log(YLOG_DEBUG, "Present chunk set to %s (maxrecs)", maxrecs_str);
 894     }
 895     sprintf(startrecs_str, "%d", cl->startrecs);
 896     ZOOM_connection_option_set(link, "start", startrecs_str);
 897
 898     /* TODO Verify does it break something for CQL targets(non-SOLR) ? */
 899     /* facets definition is in PQF */
 900     client_set_facets_request(cl, link);
 901
 902     query = ZOOM_query_create();
 903     if (cl->cqlquery)
 904     {
 905         yaz_log(YLOG_LOG, "Client %s: Search CQL: %s", client_get_id(cl), cl->cqlquery);
 906         ZOOM_query_cql(query, cl->cqlquery);
 907         if (*opt_sort)
 908             ZOOM_query_sortby(query, opt_sort);
 909     }
 910     else
 911     {
 912         yaz_log(YLOG_LOG, "Client %s: Search PQF: %s", client_get_id(cl), cl->pquery);
 913
 914         ZOOM_query_prefix(query, cl->pquery);
 915     }
 916     if (cl->sort_strategy && cl->sort_criteria) {
 917         yaz_log(YLOG_LOG, "Client %s: Setting ZOOM sort strategy and criteria: %s %s",
 918                 client_get_id(cl), cl->sort_strategy, cl->sort_criteria);
 919         ZOOM_query_sortby2(query, cl->sort_strategy, cl->sort_criteria);
 920     }
 921
 922     yaz_log(YLOG_DEBUG,"Client %s: Starting search", client_get_id(cl));
 923     client_set_state(cl, Client_Working);
 924     cl->hits = 0;
 925     cl->record_offset = 0;
 926     rs = ZOOM_connection_search(link, query);
 927     ZOOM_query_destroy(query);
 928     ZOOM_resultset_destroy(cl->resultset);
 929     cl->resultset = rs;
 930     connection_continue(co);
 931     return 0;
 932 }
 933
 934 struct client *client_create(const char *id)
 935 {
 936     struct client *cl = xmalloc(sizeof(*cl));
 937     cl->maxrecs = 100;
 938     cl->startrecs = 0;
 939     cl->pquery = 0;
 940     cl->cqlquery = 0;
 941     cl->addinfo = 0;
 942     cl->message = 0;
 943     cl->database = 0;
 944     cl->connection = 0;
 945     cl->session = 0;
 946     cl->hits = 0;
 947     cl->record_offset = 0;
 948     cl->filtered = 0;
 949     cl->diagnostic = 0;
 950     cl->state = Client_Disconnected;
 951     cl->show_raw = 0;
 952     cl->resultset = 0;
 953     cl->suggestions = 0;
 954     cl->preferred = 0;
 955     cl->ref_count = 1;
 956     cl->facet_limits = 0;
 957     cl->sort_strategy = 0;
 958     cl->sort_criteria = 0;
 959     assert(id);
 960     cl->id = xstrdup(id);
 961     client_use(1);
 962
 963     return cl;
 964 }
 965
 966 void client_incref(struct client *c)
 967 {
 968     c->ref_count++;
 969     yaz_log(YLOG_DEBUG, "client_incref c=%p %s cnt=%d",
 970             c, client_get_id(c), c->ref_count);
 971 }
 972
 973 int client_destroy(struct client *c)
 974 {
 975     if (c)
 976     {
 977         yaz_log(YLOG_DEBUG, "client_destroy c=%p %s cnt=%d",
 978                 c, client_get_id(c), c->ref_count);
 979         if (--c->ref_count == 0)
 980         {
 981             xfree(c->pquery);
 982             c->pquery = 0;
 983             xfree(c->cqlquery);
 984             c->cqlquery = 0;
 985             xfree(c->addinfo);
 986             c->addinfo = 0;
 987             xfree(c->message);
 988             c->message = 0;
 989             xfree(c->id);
 990             xfree(c->sort_strategy);
 991             xfree(c->sort_criteria);
 992             assert(!c->connection);
 993             facet_limits_destroy(c->facet_limits);
 994
 995             if (c->resultset)
 996             {
 997                 ZOOM_resultset_destroy(c->resultset);
 998             }
 999             xfree(c);
1000             client_use(-1);
1001             return 1;
1002         }
1003     }
1004     return 0;
1005 }
1006
1007 void client_set_connection(struct client *cl, struct connection *con)
1008 {
1009     if (cl->resultset)
1010         ZOOM_resultset_release(cl->resultset);
1011     if (con)
1012     {
1013         assert(cl->connection == 0);
1014         cl->connection = con;
1015         client_incref(cl);
1016     }
1017     else
1018     {
1019         cl->connection = con;
1020         client_destroy(cl);
1021     }
1022 }
1023
1024 void client_disconnect(struct client *cl)
1025 {
1026     if (cl->state != Client_Idle)
1027         client_set_state(cl, Client_Disconnected);
1028     client_set_connection(cl, 0);
1029 }
1030
1031
1032 // Initialize CCL map for a target
1033 static CCL_bibset prepare_cclmap(struct client *cl, CCL_bibset base_bibset)
1034 {
1035     struct session_database *sdb = client_get_database(cl);
1036     struct setting *s;
1037     CCL_bibset res;
1038
1039     if (!sdb->settings)
1040         return 0;
1041     if (base_bibset)
1042         res = ccl_qual_dup(base_bibset);
1043     else
1044         res = ccl_qual_mk();
1045     for (s = sdb->settings[PZ_CCLMAP]; s; s = s->next)
1046     {
1047         const char *addinfo = 0;
1048         char *p = strchr(s->name + 3, ':');
1049         if (!p)
1050         {
1051             WRBUF w = wrbuf_alloc();
1052             wrbuf_printf(w, "Malformed cclmap. name=%s", s->name);
1053             yaz_log(YLOG_WARN, "%s: %s", client_get_id(cl), wrbuf_cstr(w));
1054             client_set_diagnostic(cl, ZOOM_ERROR_CCL_CONFIG,
1055                                   ZOOM_diag_str(ZOOM_ERROR_CCL_CONFIG),
1056                                   wrbuf_cstr(w));
1057             client_set_state_nb(cl, Client_Error);
1058             ccl_qual_rm(&res);
1059             wrbuf_destroy(w);
1060             return 0;
1061         }
1062         p++;
1063         if (ccl_qual_fitem2(res, s->value, p, &addinfo))
1064         {
1065             WRBUF w = wrbuf_alloc();
1066
1067             wrbuf_printf(w, "Malformed cclmap. name=%s: value=%s (%s)",
1068                          s->name, p, addinfo);
1069             yaz_log(YLOG_WARN, "%s: %s", client_get_id(cl), wrbuf_cstr(w));
1070             client_set_diagnostic(cl, ZOOM_ERROR_CCL_CONFIG,
1071                                   ZOOM_diag_str(ZOOM_ERROR_CCL_CONFIG),
1072                                   wrbuf_cstr(w));
1073             client_set_state_nb(cl, Client_Error);
1074             ccl_qual_rm(&res);
1075             wrbuf_destroy(w);
1076             return 0;
1077         }
1078     }
1079     return res;
1080 }
1081
1082 // returns a xmalloced CQL query corresponding to the pquery in client
1083 static char *make_cqlquery(struct client *cl, Z_RPNQuery *zquery)
1084 {
1085     cql_transform_t cqlt = cql_transform_create();
1086     char *r = 0;
1087     WRBUF wrb = wrbuf_alloc();
1088     int status;
1089
1090     if ((status = cql_transform_rpn2cql_wrbuf(cqlt, wrb, zquery)))
1091     {
1092         yaz_log(YLOG_WARN, "Failed to generate CQL query, code=%d", status);
1093     }
1094     else
1095     {
1096         r = xstrdup(wrbuf_cstr(wrb));
1097     }
1098     wrbuf_destroy(wrb);
1099     cql_transform_close(cqlt);
1100     return r;
1101 }
1102
1103 // returns a xmalloced SOLR query corresponding to the pquery in client
1104 // TODO Could prob. be merge with the similar make_cqlquery
1105 static char *make_solrquery(struct client *cl, Z_RPNQuery *zquery)
1106 {
1107     solr_transform_t sqlt = solr_transform_create();
1108     char *r = 0;
1109     WRBUF wrb = wrbuf_alloc();
1110     int status;
1111
1112     if ((status = solr_transform_rpn2solr_wrbuf(sqlt, wrb, zquery)))
1113     {
1114         yaz_log(YLOG_WARN, "Failed to generate SOLR query, code=%d", status);
1115     }
1116     else
1117     {
1118         r = xstrdup(wrbuf_cstr(wrb));
1119     }
1120     wrbuf_destroy(wrb);
1121     solr_transform_close(sqlt);
1122     return r;
1123 }
1124
1125 const char *client_get_facet_limit_local(struct client *cl,
1126                                          struct session_database *sdb,
1127                                          int *l,
1128                                          NMEM nmem, int *num, char ***values)
1129 {
1130     const char *name = 0;
1131     const char *value = 0;
1132     for (; (name = facet_limits_get(cl->facet_limits, *l, &value)); (*l)++)
1133     {
1134         struct setting *s = 0;
1135
1136         for (s = sdb->settings[PZ_LIMITMAP]; s; s = s->next)
1137         {
1138             const char *p = strchr(s->name + 3, ':');
1139             if (p && !strcmp(p + 1, name) && s->value)
1140             {
1141                 int j, cnum;
1142                 char **cvalues;
1143                 nmem_strsplit_escape2(nmem, ",", s->value, &cvalues,
1144                                       &cnum, 1, '\\', 1);
1145                 for (j = 0; j < cnum; j++)
1146                 {
1147                     const char *cvalue = cvalues[j];
1148                     while (*cvalue == ' ')
1149                         cvalue++;
1150                     if (!strncmp(cvalue, "local:", 6))
1151                     {
1152                         const char *cp = cvalue + 6;
1153                         while (*cp == ' ')
1154                             cp++;
1155                         nmem_strsplit_escape2(nmem, "|", value, values,
1156                                               num, 1, '\\', 1);
1157                         (*l)++;
1158                         return *cp ? cp : name;
1159                     }
1160                 }
1161             }
1162         }
1163     }
1164     return 0;
1165 }
1166
1167 static int apply_limit(struct session_database *sdb,
1168                        facet_limits_t facet_limits,
1169                        WRBUF w_pqf, CCL_bibset ccl_map,
1170                        struct conf_service *service)
1171 {
1172     int ret = 0;
1173     int i = 0;
1174     const char *name;
1175     const char *value;
1176
1177     NMEM nmem_tmp = nmem_create();
1178     for (i = 0; (name = facet_limits_get(facet_limits, i, &value)); i++)
1179     {
1180         struct setting *s = 0;
1181         nmem_reset(nmem_tmp);
1182         /* name="pz:limitmap:author" value="rpn:@attr 1=4|local:other" */
1183         for (s = sdb->settings[PZ_LIMITMAP]; s; s = s->next)
1184         {
1185             const char *p = strchr(s->name + 3, ':');
1186             if (p && !strcmp(p + 1, name) && s->value)
1187             {
1188                 char **values = 0;
1189                 int i, num = 0;
1190                 char **cvalues = 0;
1191                 int j, cnum = 0;
1192                 nmem_strsplit_escape2(nmem_tmp, "|", value, &values,
1193                                       &num, 1, '\\', 1);
1194
1195                 nmem_strsplit_escape2(nmem_tmp, ",", s->value, &cvalues,
1196                                       &cnum, 1, '\\', 1);
1197
1198                 for (j = 0; ret == 0 && j < cnum; j++)
1199                 {
1200                     const char *cvalue = cvalues[j];
1201                     while (*cvalue == ' ')
1202                         cvalue++;
1203                     if (!strncmp(cvalue, "rpn:", 4))
1204                     {
1205                         const char *pqf = cvalue + 4;
1206                         wrbuf_puts(w_pqf, "@and ");
1207                         wrbuf_puts(w_pqf, pqf);
1208                         wrbuf_puts(w_pqf, " ");
1209                         for (i = 0; i < num; i++)
1210                         {
1211                             if (i < num - 1)
1212                                 wrbuf_puts(w_pqf, "@or ");
1213                             yaz_encode_pqf_term(w_pqf, values[i],
1214                                                 strlen(values[i]));
1215                         }
1216                     }
1217                     else if (!strncmp(cvalue, "ccl:", 4))
1218                     {
1219                         const char *ccl = cvalue + 4;
1220                         WRBUF ccl_w = wrbuf_alloc();
1221                         for (i = 0; i < num; i++)
1222                         {
1223                             int cerror, cpos;
1224                             struct ccl_rpn_node *cn;
1225                             wrbuf_rewind(ccl_w);
1226                             wrbuf_puts(ccl_w, ccl);
1227                             wrbuf_puts(ccl_w, "=\"");
1228                             wrbuf_puts(ccl_w, values[i]);
1229                             wrbuf_puts(ccl_w, "\"");
1230
1231                             cn = ccl_find_str(ccl_map, wrbuf_cstr(ccl_w),
1232                                               &cerror, &cpos);
1233                             if (cn)
1234                             {
1235                                 if (i == 0)
1236                                     wrbuf_printf(w_pqf, "@and ");
1237
1238                                 /* or multiple values.. could be bad if last
1239                                    CCL parse fails, but this is unlikely to
1240                                    happen */
1241                                 if (i < num - 1)
1242                                     wrbuf_printf(w_pqf, "@or ");
1243                                 ccl_pquery(w_pqf, cn);
1244                                 ccl_rpn_delete(cn);
1245                             }
1246                         }
1247                         wrbuf_destroy(ccl_w);
1248                     }
1249                     else if (!strncmp(cvalue, "local:", 6)) {
1250                         /* no operation */
1251                     }
1252                     else
1253                     {
1254                         yaz_log(YLOG_WARN, "Target %s: Bad limitmap '%s'",
1255                                 sdb->database->id, cvalue);
1256                         ret = -1; /* bad limitmap */
1257                     }
1258                     break;
1259                 }
1260             }
1261         }
1262         if (!s)
1263         {
1264             int i;
1265             for (i = 0; i < service->num_metadata; i++)
1266             {
1267                 struct conf_metadata *md = service->metadata + i;
1268                 if (!strcmp(md->name, name) && md->limitcluster)
1269                 {
1270                     yaz_log(YLOG_LOG, "limitcluster in use for %s",
1271                             md->name);
1272                     break;
1273                 }
1274             }
1275             if (i == service->num_metadata)
1276             {
1277                 yaz_log(YLOG_WARN, "Target %s: limit %s used, but no limitmap defined",
1278                         (sdb->database ? sdb->database->id : "<no id>"), name);
1279             }
1280         }
1281     }
1282     nmem_destroy(nmem_tmp);
1283     return ret;
1284 }
1285
1286 // Parse the query given the settings specific to this client
1287 // client variable same_search is set as below as well as returned:
1288 // 0 if query is OK but different from before
1289 // 1 if query is OK but same as before
1290 // return -1 on query error
1291 // return -2 on limit error
1292 int client_parse_query(struct client *cl, const char *query,
1293                        facet_limits_t facet_limits)
1294 {
1295     struct session *se = client_get_session(cl);
1296     struct conf_service *service = se->service;
1297     struct session_database *sdb = client_get_database(cl);
1298     struct ccl_rpn_node *cn;
1299     int cerror, cpos;
1300     ODR odr_out;
1301     CCL_bibset ccl_map = prepare_cclmap(cl, service->ccl_bibset);
1302     const char *sru = session_setting_oneval(sdb, PZ_SRU);
1303     const char *pqf_prefix = session_setting_oneval(sdb, PZ_PQF_PREFIX);
1304     const char *pqf_strftime = session_setting_oneval(sdb, PZ_PQF_STRFTIME);
1305     const char *query_syntax = session_setting_oneval(sdb, PZ_QUERY_SYNTAX);
1306     WRBUF w_ccl, w_pqf;
1307     int ret_value = 1;
1308     Z_RPNQuery *zquery;
1309
1310     if (!ccl_map)
1311         return -3;
1312
1313     w_ccl = wrbuf_alloc();
1314     wrbuf_puts(w_ccl, query);
1315
1316     w_pqf = wrbuf_alloc();
1317     if (*pqf_prefix)
1318     {
1319         wrbuf_puts(w_pqf, pqf_prefix);
1320         wrbuf_puts(w_pqf, " ");
1321     }
1322
1323     if (apply_limit(sdb, facet_limits, w_pqf, ccl_map, service))
1324     {
1325         ccl_qual_rm(&ccl_map);
1326         return -2;
1327     }
1328
1329     facet_limits_destroy(cl->facet_limits);
1330     cl->facet_limits = facet_limits_dup(facet_limits);
1331
1332     yaz_log(YLOG_LOG, "Client %s: CCL query: %s limit: %s", client_get_id(cl), wrbuf_cstr(w_ccl), wrbuf_cstr(w_pqf));
1333     cn = ccl_find_str(ccl_map, wrbuf_cstr(w_ccl), &cerror, &cpos);
1334     ccl_qual_rm(&ccl_map);
1335     if (!cn)
1336     {
1337         client_set_state(cl, Client_Error);
1338         session_log(se, YLOG_WARN, "Client %s: Failed to parse CCL query '%s'",
1339                     client_get_id(cl),
1340                     wrbuf_cstr(w_ccl));
1341         wrbuf_destroy(w_ccl);
1342         wrbuf_destroy(w_pqf);
1343         return -1;
1344     }
1345     wrbuf_destroy(w_ccl);
1346
1347     if (!pqf_strftime || !*pqf_strftime)
1348         ccl_pquery(w_pqf, cn);
1349     else
1350     {
1351         time_t cur_time = time(0);
1352         struct tm *tm =  localtime(&cur_time);
1353         char tmp_str[300];
1354         const char *cp = tmp_str;
1355
1356         /* see man strftime(3) for things .. In particular %% gets converted
1357          to %.. And That's our original query .. */
1358         strftime(tmp_str, sizeof(tmp_str)-1, pqf_strftime, tm);
1359         for (; *cp; cp++)
1360         {
1361             if (cp[0] == '%')
1362                 ccl_pquery(w_pqf, cn);
1363             else
1364                 wrbuf_putc(w_pqf, cp[0]);
1365         }
1366     }
1367
1368     /* Compares query and limit with old one. If different we need to research */
1369     if (!cl->pquery || strcmp(cl->pquery, wrbuf_cstr(w_pqf)))
1370     {
1371         if (cl->pquery)
1372             session_log(se, YLOG_LOG, "Client %s: Re-search due query/limit change: %s to %s",
1373                         client_get_id(cl), cl->pquery, wrbuf_cstr(w_pqf));
1374         xfree(cl->pquery);
1375         cl->pquery = xstrdup(wrbuf_cstr(w_pqf));
1376         // return value is no longer used.
1377         ret_value = 0;
1378         // Need to (re)search
1379         cl->same_search= 0;
1380     }
1381     wrbuf_destroy(w_pqf);
1382
1383     xfree(cl->cqlquery);
1384     cl->cqlquery = 0;
1385
1386     odr_out = odr_createmem(ODR_ENCODE);
1387     zquery = p_query_rpn(odr_out, cl->pquery);
1388     if (!zquery)
1389     {
1390
1391         session_log(se, YLOG_WARN, "Invalid PQF query for Client %s: %s",
1392                     client_get_id(cl), cl->pquery);
1393         ret_value = -1;
1394     }
1395     else
1396     {
1397         session_log(se, YLOG_LOG, "PQF for Client %s: %s",
1398                     client_get_id(cl), cl->pquery);
1399
1400         /* Support for PQF on SRU targets. */
1401         if (strcmp(query_syntax, "pqf") != 0 && *sru)
1402         {
1403             if (!strcmp(sru, "solr"))
1404                 cl->cqlquery = make_solrquery(cl, zquery);
1405             else
1406                 cl->cqlquery = make_cqlquery(cl, zquery);
1407             if (!cl->cqlquery)
1408                 ret_value = -1;
1409             else
1410                 session_log(se, YLOG_LOG, "Client %s native query: %s (%s)",
1411                             client_get_id(cl), cl->cqlquery, sru);
1412         }
1413     }
1414     odr_destroy(odr_out);
1415
1416     /* TODO FIX Not thread safe */
1417     if (!se->relevance)
1418     {
1419         // Initialize relevance structure with query terms
1420         se->relevance = relevance_create_ccl(se->service->charsets, cn,
1421                                              se->service->rank_cluster,
1422                                              se->service->rank_follow,
1423                                              se->service->rank_lead,
1424                                              se->service->rank_length);
1425     }
1426     ccl_rpn_delete(cn);
1427     return ret_value;
1428 }
1429
1430 int client_parse_sort(struct client *cl, struct reclist_sortparms *sp)
1431 {
1432     if (sp)
1433     {
1434         const char *sort_strategy_and_spec =
1435             get_strategy_plus_sort(cl, sp->name);
1436         int increasing = sp->increasing;
1437         if (sort_strategy_and_spec && strlen(sort_strategy_and_spec) < 40)
1438         {
1439             char strategy[50], *p;
1440             strcpy(strategy, sort_strategy_and_spec);
1441             p = strchr(strategy, ':');
1442             if (p)
1443             {
1444                 // Split the string in two
1445                 *p++ = 0;
1446                 while (*p == ' ')
1447                     p++;
1448                 if (increasing)
1449                     strcat(p, " <");
1450                 else
1451                     strcat(p, " >");
1452                 yaz_log(YLOG_LOG, "Client %s: applying sorting %s %s", client_get_id(cl), strategy, p);
1453                 if (!cl->sort_strategy || strcmp(cl->sort_strategy, strategy))
1454                     cl->same_search = 0;
1455                 if (!cl->sort_criteria || strcmp(cl->sort_criteria, p))
1456                     cl->same_search = 0;
1457                 if (cl->same_search == 0) {
1458                     xfree(cl->sort_strategy);
1459                     cl->sort_strategy = xstrdup(strategy);
1460                     xfree(cl->sort_criteria);
1461                     cl->sort_criteria = xstrdup(p);
1462                 }
1463             }
1464             else {
1465                 yaz_log(YLOG_LOG, "Client %s: Invalid sort strategy and spec found %s", client_get_id(cl), sort_strategy_and_spec);
1466                 xfree(cl->sort_strategy);
1467                 cl->sort_strategy  = 0;
1468                 xfree(cl->sort_criteria);
1469                 cl->sort_criteria = 0;
1470             }
1471         } else {
1472             yaz_log(YLOG_DEBUG, "Client %s: No sort strategy and spec found.", client_get_id(cl));
1473             xfree(cl->sort_strategy);
1474             cl->sort_strategy  = 0;
1475             xfree(cl->sort_criteria);
1476             cl->sort_criteria = 0;
1477         }
1478
1479     }
1480     return !cl->same_search;
1481 }
1482
1483 void client_set_session(struct client *cl, struct session *se)
1484 {
1485     cl->session = se;
1486 }
1487
1488 int client_is_active(struct client *cl)
1489 {
1490     if (cl->connection && (cl->state == Client_Connecting ||
1491                            cl->state == Client_Working))
1492         return 1;
1493     return 0;
1494 }
1495
1496 int client_is_active_preferred(struct client *cl)
1497 {
1498     /* only count if this is a preferred target. */
1499     if (!cl->preferred)
1500         return 0;
1501     /* TODO No sure this the condition that Seb wants */
1502     if (cl->connection && (cl->state == Client_Connecting ||
1503                            cl->state == Client_Working))
1504         return 1;
1505     return 0;
1506 }
1507
1508 Odr_int client_get_hits(struct client *cl)
1509 {
1510     return cl->hits;
1511 }
1512
1513 Odr_int client_get_approximation(struct client *cl)
1514 {
1515     if (cl->record_offset > 0) {
1516         Odr_int approx = ((10 * cl->hits * (cl->record_offset - cl->filtered)) / cl->record_offset + 5) /10;
1517         yaz_log(YLOG_DEBUG, "%s: Approx: %lld * %d / %d = %lld ", client_get_id(cl), cl->hits, cl->record_offset - cl->filtered, cl->record_offset, approx);
1518         return approx;
1519     }
1520     return cl->hits;
1521 }
1522
1523 int client_get_num_records(struct client *cl)
1524 {
1525     return cl->record_offset;
1526 }
1527
1528 int client_get_num_records_filtered(struct client *cl)
1529 {
1530     return cl->filtered;
1531 }
1532
1533 void client_set_diagnostic(struct client *cl, int diagnostic,
1534                            const char *message, const char *addinfo)
1535 {
1536     cl->diagnostic = diagnostic;
1537     xfree(cl->message);
1538     cl->message = xstrdup(message);
1539     xfree(cl->addinfo);
1540     cl->addinfo = 0;
1541     if (addinfo)
1542         cl->addinfo = xstrdup(addinfo);
1543 }
1544
1545 int client_get_diagnostic(struct client *cl, const char **message,
1546                           const char **addinfo)
1547 {
1548     if (message)
1549         *message = cl->message;
1550     if (addinfo)
1551         *addinfo = cl->addinfo;
1552     return cl->diagnostic;
1553 }
1554
1555 const char * client_get_suggestions_xml(struct client *cl, WRBUF wrbuf)
1556 {
1557     /* int idx; */
1558     struct suggestions *suggestions = cl->suggestions;
1559
1560     if (!suggestions) {
1561         //yaz_log(YLOG_DEBUG, "No suggestions found");
1562         return "";
1563     }
1564     if (suggestions->passthrough) {
1565         yaz_log(YLOG_DEBUG, "Passthrough Suggestions: \n%s\n", suggestions->passthrough);
1566         return suggestions->passthrough;
1567     }
1568     if (suggestions->num == 0) {
1569         return "";
1570     }
1571     /*
1572     for (idx = 0; idx < suggestions->num; idx++) {
1573         wrbuf_printf(wrbuf, "<suggest term=\"%s\"", suggestions->suggest[idx]);
1574         if (suggestions->misspelled[idx] && suggestions->misspelled[idx]) {
1575             wrbuf_puts(wrbuf, suggestions->misspelled[idx]);
1576             wrbuf_puts(wrbuf, "</suggest>\n");
1577         }
1578         else
1579             wrbuf_puts(wrbuf, "/>\n");
1580     }
1581     */
1582     return wrbuf_cstr(wrbuf);
1583 }
1584
1585
1586 void client_set_database(struct client *cl, struct session_database *db)
1587 {
1588     cl->database = db;
1589 }
1590
1591 const char *client_get_id(struct client *cl)
1592 {
1593     return cl->id;
1594 }
1595
1596 int client_get_maxrecs(struct client *cl)
1597 {
1598     return cl->maxrecs;
1599 }
1600
1601 void client_set_preferred(struct client *cl, int v)
1602 {
1603     cl->preferred = v;
1604 }
1605
1606
1607 struct suggestions* client_suggestions_create(const char* suggestions_string)
1608 {
1609     int i;
1610     NMEM nmem;
1611     struct suggestions *suggestions;
1612     if (suggestions_string == 0 || suggestions_string[0] == 0 )
1613         return 0;
1614     nmem = nmem_create();
1615     suggestions = nmem_malloc(nmem, sizeof(*suggestions));
1616     yaz_log(YLOG_DEBUG, "client target suggestions: %s.", suggestions_string);
1617
1618     suggestions->nmem = nmem;
1619     suggestions->num = 0;
1620     suggestions->misspelled = 0;
1621     suggestions->suggest = 0;
1622     suggestions->passthrough = nmem_strdup_null(nmem, suggestions_string);
1623
1624     if (suggestions_string)
1625         nmem_strsplit_escape2(suggestions->nmem, "\n", suggestions_string, &suggestions->suggest,
1626                               &suggestions->num, 1, '\\', 0);
1627     /* Set up misspelled array */
1628     suggestions->misspelled = (char **) nmem_malloc(nmem, suggestions->num * sizeof(**suggestions->misspelled));
1629     /* replace = with \0 .. for each item */
1630     for (i = 0; i < suggestions->num; i++)
1631     {
1632         char *cp = strchr(suggestions->suggest[i], '=');
1633         if (cp) {
1634             *cp = '\0';
1635             suggestions->misspelled[i] = cp+1;
1636         }
1637     }
1638     return suggestions;
1639 }
1640
1641 static void client_suggestions_destroy(struct client *cl)
1642 {
1643     NMEM nmem = cl->suggestions->nmem;
1644     cl->suggestions = 0;
1645     nmem_destroy(nmem);
1646 }
1647
1648 int client_test_sort_order(struct client *cl, struct reclist_sortparms *sp)
1649 {
1650     //TODO implement correctly.
1651     return 1;
1652 }
1653 /*
1654  * Local variables:
1655  * c-basic-offset: 4
1656  * c-file-style: "Stroustrup"
1657  * indent-tabs-mode: nil
1658  * End:
1659  * vim: shiftwidth=4 tabstop=8 expandtab
1660  */
1661