src/client.c

   1 /* This file is part of Pazpar2.
   2    Copyright (C) 2006-2009 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
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #if HAVE_SYS_TIME_H
  32 #include <sys/time.h>
  33 #endif
  34 #if HAVE_UNISTD_H
  35 #include <unistd.h>
  36 #endif
  37 #include <signal.h>
  38 #include <assert.h>
  39
  40 #include <yaz/marcdisp.h>
  41 #include <yaz/comstack.h>
  42 #include <yaz/tcpip.h>
  43 #include <yaz/proto.h>
  44 #include <yaz/readconf.h>
  45 #include <yaz/pquery.h>
  46 #include <yaz/otherinfo.h>
  47 #include <yaz/yaz-util.h>
  48 #include <yaz/nmem.h>
  49 #include <yaz/query-charset.h>
  50 #include <yaz/querytowrbuf.h>
  51 #include <yaz/oid_db.h>
  52 #include <yaz/diagbib1.h>
  53 #include <yaz/snprintf.h>
  54 #include <yaz/rpn2cql.h>
  55
  56 #define USE_TIMING 0
  57 #if USE_TIMING
  58 #include <yaz/timing.h>
  59 #endif
  60
  61 #include "pazpar2.h"
  62 #include "parameters.h"
  63 #include "client.h"
  64 #include "connection.h"
  65 #include "settings.h"
  66 #include "relevance.h"
  67
  68 /** \brief Represents client state for a connection to one search target */
  69 struct client {
  70     struct session_database *database;
  71     struct connection *connection;
  72     struct session *session;
  73     char *pquery; // Current search
  74     char *cqlquery; // used for SRU targets only
  75     int hits;
  76     int record_offset;
  77     int maxrecs;
  78     int diagnostic;
  79     enum client_state state;
  80     struct show_raw *show_raw;
  81     struct client *next;     // next client in session or next in free list
  82     ZOOM_resultset resultset;
  83 };
  84
  85 struct show_raw {
  86     int active; // whether this request has been sent to the server
  87     int position;
  88     int binary;
  89     char *syntax;
  90     char *esn;
  91     void (*error_handler)(void *data, const char *addinfo);
  92     void (*record_handler)(void *data, const char *buf, size_t sz);
  93     void *data;
  94     struct show_raw *next;
  95 };
  96
  97 static const char *client_states[] = {
  98     "Client_Connecting",
  99     "Client_Idle",
 100     "Client_Working",
 101     "Client_Error",
 102     "Client_Failed",
 103     "Client_Disconnected"
 104 };
 105
 106 static struct client *client_freelist = 0; /* thread pr */
 107
 108 const char *client_get_state_str(struct client *cl)
 109 {
 110     return client_states[cl->state];
 111 }
 112
 113 enum client_state client_get_state(struct client *cl)
 114 {
 115     return cl->state;
 116 }
 117
 118 void client_set_state(struct client *cl, enum client_state st)
 119 {
 120     cl->state = st;
 121     if (cl->session)
 122     {
 123         int no_active = session_active_clients(cl->session);
 124         if (no_active == 0)
 125             session_alert_watch(cl->session, SESSION_WATCH_SHOW);
 126     }
 127 }
 128
 129 static void client_show_raw_error(struct client *cl, const char *addinfo);
 130
 131 // Close connection and set state to error
 132 void client_fatal(struct client *cl)
 133 {
 134     yaz_log(YLOG_WARN, "Fatal error from %s", client_get_url(cl));
 135     connection_destroy(cl->connection);
 136     client_set_state(cl, Client_Error);
 137 }
 138
 139 struct connection *client_get_connection(struct client *cl)
 140 {
 141     return cl->connection;
 142 }
 143
 144 struct session_database *client_get_database(struct client *cl)
 145 {
 146     return cl->database;
 147 }
 148
 149 struct session *client_get_session(struct client *cl)
 150 {
 151     return cl->session;
 152 }
 153
 154 const char *client_get_pquery(struct client *cl)
 155 {
 156     return cl->pquery;
 157 }
 158
 159 static void client_send_raw_present(struct client *cl);
 160 static int nativesyntax_to_type(struct session_database *sdb, char *type,
 161                                 ZOOM_record rec);
 162
 163 static void client_show_immediate(
 164     ZOOM_resultset resultset, struct session_database *sdb, int position,
 165     void *data,
 166     void (*error_handler)(void *data, const char *addinfo),
 167     void (*record_handler)(void *data, const char *buf, size_t sz),
 168     int binary)
 169 {
 170     ZOOM_record rec = 0;
 171     char type[80];
 172     const char *buf;
 173     int len;
 174
 175     if (!resultset)
 176     {
 177         error_handler(data, "no resultset");
 178         return;
 179     }
 180     rec = ZOOM_resultset_record(resultset, position-1);
 181     if (!rec)
 182     {
 183         error_handler(data, "no record");
 184         return;
 185     }
 186     if (binary)
 187         strcpy(type, "raw");
 188     else
 189         nativesyntax_to_type(sdb, type, rec);
 190     buf = ZOOM_record_get(rec, type, &len);
 191     if (!buf)
 192     {
 193         error_handler(data, "no record");
 194         return;
 195     }
 196     record_handler(data, buf, len);
 197 }
 198
 199
 200 int client_show_raw_begin(struct client *cl, int position,
 201                           const char *syntax, const char *esn,
 202                           void *data,
 203                           void (*error_handler)(void *data, const char *addinfo),
 204                           void (*record_handler)(void *data, const char *buf,
 205                                                  size_t sz),
 206                           int binary)
 207 {
 208     if (syntax == 0 && esn == 0)
 209         client_show_immediate(cl->resultset, client_get_database(cl),
 210                               position, data,
 211                               error_handler, record_handler,
 212                               binary);
 213     else
 214     {
 215         struct show_raw *rr, **rrp;
 216
 217         if (!cl->connection)
 218             return -1;
 219
 220
 221         rr = xmalloc(sizeof(*rr));
 222         rr->position = position;
 223         rr->active = 0;
 224         rr->data = data;
 225         rr->error_handler = error_handler;
 226         rr->record_handler = record_handler;
 227         rr->binary = binary;
 228         if (syntax)
 229             rr->syntax = xstrdup(syntax);
 230         else
 231             rr->syntax = 0;
 232         if (esn)
 233             rr->esn = xstrdup(esn);
 234         else
 235             rr->esn = 0;
 236         rr->next = 0;
 237
 238         for (rrp = &cl->show_raw; *rrp; rrp = &(*rrp)->next)
 239             ;
 240         *rrp = rr;
 241
 242         if (cl->state == Client_Failed)
 243         {
 244             client_show_raw_error(cl, "client failed");
 245         }
 246         else if (cl->state == Client_Disconnected)
 247         {
 248             client_show_raw_error(cl, "client disconnected");
 249         }
 250         else
 251         {
 252             client_send_raw_present(cl);
 253         }
 254     }
 255     return 0;
 256 }
 257
 258 static void client_show_raw_delete(struct show_raw *r)
 259 {
 260     xfree(r->syntax);
 261     xfree(r->esn);
 262     xfree(r);
 263 }
 264
 265 void client_show_raw_remove(struct client *cl, void *data)
 266 {
 267     struct show_raw *rr = data;
 268     struct show_raw **rrp = &cl->show_raw;
 269     while (*rrp != rr)
 270         rrp = &(*rrp)->next;
 271     if (*rrp)
 272     {
 273         *rrp = rr->next;
 274         client_show_raw_delete(rr);
 275     }
 276 }
 277
 278 void client_show_raw_dequeue(struct client *cl)
 279 {
 280     struct show_raw *rr = cl->show_raw;
 281
 282     cl->show_raw = rr->next;
 283     client_show_raw_delete(rr);
 284 }
 285
 286 static void client_show_raw_error(struct client *cl, const char *addinfo)
 287 {
 288     while (cl->show_raw)
 289     {
 290         cl->show_raw->error_handler(cl->show_raw->data, addinfo);
 291         client_show_raw_dequeue(cl);
 292     }
 293 }
 294
 295 static void client_send_raw_present(struct client *cl)
 296 {
 297     struct session_database *sdb = client_get_database(cl);
 298     struct connection *co = client_get_connection(cl);
 299     ZOOM_resultset set = cl->resultset;
 300
 301     int offset = cl->show_raw->position;
 302     const char *syntax = 0;
 303     const char *elements = 0;
 304
 305     assert(cl->show_raw);
 306     assert(set);
 307
 308     yaz_log(YLOG_DEBUG, "%s: trying to present %d record(s) from %d",
 309             client_get_url(cl), 1, offset);
 310
 311     if (cl->show_raw->syntax)
 312         syntax = cl->show_raw->syntax;
 313     else
 314         syntax = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
 315     ZOOM_resultset_option_set(set, "preferredRecordSyntax", syntax);
 316
 317     if (cl->show_raw->esn)
 318         elements = cl->show_raw->esn;
 319     else
 320         elements = session_setting_oneval(sdb, PZ_ELEMENTS);
 321     if (elements && *elements)
 322         ZOOM_resultset_option_set(set, "elementSetName", elements);
 323
 324     ZOOM_resultset_records(set, 0, offset-1, 1);
 325     cl->show_raw->active = 1;
 326
 327     connection_continue(co);
 328 }
 329
 330 static int nativesyntax_to_type(struct session_database *sdb, char *type,
 331                                 ZOOM_record rec)
 332 {
 333     const char *s = session_setting_oneval(sdb, PZ_NATIVESYNTAX);
 334
 335     if (s && *s)
 336     {
 337         if (!strncmp(s, "iso2709", 7))
 338         {
 339             const char *cp = strchr(s, ';');
 340             yaz_snprintf(type, 80, "xml; charset=%s", cp ? cp+1 : "marc-8s");
 341         }
 342         else if (!strncmp(s, "xml", 3))
 343         {
 344             strcpy(type, "xml");
 345         }
 346         else
 347             return -1;
 348         return 0;
 349     }
 350     else  /* attempt to deduce structure */
 351     {
 352         const char *syntax = ZOOM_record_get(rec, "syntax", NULL);
 353         if (syntax)
 354         {
 355             if (!strcmp(syntax, "XML"))
 356             {
 357                 strcpy(type, "xml");
 358                 return 0;
 359             }
 360             else if (!strcmp(syntax, "USmarc") || !strcmp(syntax, "MARC21"))
 361             {
 362                 strcpy(type, "xml; charset=marc8-s");
 363                 return 0;
 364             }
 365             else return -1;
 366         }
 367         else return -1;
 368     }
 369 }
 370
 371 static void ingest_raw_record(struct client *cl, ZOOM_record rec)
 372 {
 373     const char *buf;
 374     int len;
 375     char type[80];
 376
 377     if (cl->show_raw->binary)
 378         strcpy(type, "raw");
 379     else
 380     {
 381         struct session_database *sdb = client_get_database(cl);
 382         nativesyntax_to_type(sdb, type, rec);
 383     }
 384
 385     buf = ZOOM_record_get(rec, type, &len);
 386     cl->show_raw->record_handler(cl->show_raw->data,  buf, len);
 387     client_show_raw_dequeue(cl);
 388 }
 389
 390 void client_search_response(struct client *cl)
 391 {
 392     struct connection *co = cl->connection;
 393     struct session *se = cl->session;
 394     ZOOM_connection link = connection_get_link(co);
 395     ZOOM_resultset resultset = cl->resultset;
 396     const char *error, *addinfo;
 397
 398     if (ZOOM_connection_error(link, &error, &addinfo))
 399     {
 400         cl->hits = 0;
 401         client_set_state(cl, Client_Error);
 402         yaz_log(YLOG_WARN, "Search error %s (%s): %s",
 403             error, addinfo, client_get_url(cl));
 404     }
 405     else
 406     {
 407         cl->record_offset = 0;
 408         cl->hits = ZOOM_resultset_size(resultset);
 409         se->total_hits += cl->hits;
 410     }
 411 }
 412
 413
 414 void client_record_response(struct client *cl)
 415 {
 416     struct connection *co = cl->connection;
 417     ZOOM_connection link = connection_get_link(co);
 418     ZOOM_resultset resultset = cl->resultset;
 419     const char *error, *addinfo;
 420
 421     if (ZOOM_connection_error(link, &error, &addinfo))
 422     {
 423         client_set_state(cl, Client_Error);
 424         yaz_log(YLOG_WARN, "Search error %s (%s): %s",
 425             error, addinfo, client_get_url(cl));
 426     }
 427     else
 428     {
 429         ZOOM_record rec = 0;
 430         const char *msg, *addinfo;
 431
 432         if (cl->show_raw && cl->show_raw->active)
 433         {
 434             if ((rec = ZOOM_resultset_record(resultset,
 435                                              cl->show_raw->position-1)))
 436             {
 437                 cl->show_raw->active = 0;
 438                 ingest_raw_record(cl, rec);
 439             }
 440             else
 441             {
 442                 yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d",
 443                         cl->show_raw->position-1);
 444             }
 445         }
 446         else
 447         {
 448             int offset = cl->record_offset;
 449             if ((rec = ZOOM_resultset_record(resultset, offset)))
 450             {
 451                 cl->record_offset++;
 452                 if (ZOOM_record_error(rec, &msg, &addinfo, 0))
 453                     yaz_log(YLOG_WARN, "Record error %s (%s): %s (rec #%d)",
 454                             error, addinfo, client_get_url(cl),
 455                             cl->record_offset);
 456                 else
 457                 {
 458                     struct session_database *sdb = client_get_database(cl);
 459                     const char *xmlrec;
 460                     char type[80];
 461                     if (nativesyntax_to_type(sdb, type, rec))
 462                         yaz_log(YLOG_WARN, "Failed to determine record type");
 463                     if ((xmlrec = ZOOM_record_get(rec, type, NULL)))
 464                     {
 465                         if (ingest_record(cl, xmlrec, cl->record_offset))
 466                         {
 467                             session_alert_watch(cl->session, SESSION_WATCH_SHOW);
 468                             session_alert_watch(cl->session, SESSION_WATCH_RECORD);
 469                         }
 470                         else
 471                             yaz_log(YLOG_WARN, "Failed to ingest");
 472                     }
 473                     else
 474                         yaz_log(YLOG_WARN, "Failed to extract ZOOM record");
 475                 }
 476
 477             }
 478             else
 479             {
 480                 yaz_log(YLOG_WARN, "Expected record, but got NULL, offset=%d",
 481                         offset);
 482             }
 483         }
 484     }
 485 }
 486
 487 void client_start_search(struct client *cl)
 488 {
 489     struct session_database *sdb = client_get_database(cl);
 490     struct connection *co = client_get_connection(cl);
 491     ZOOM_connection link = connection_get_link(co);
 492     ZOOM_resultset rs;
 493     char *databaseName = sdb->database->databases[0];
 494     const char *opt_piggyback = session_setting_oneval(sdb, PZ_PIGGYBACK);
 495     const char *opt_queryenc = session_setting_oneval(sdb, PZ_QUERYENCODING);
 496     const char *opt_elements = session_setting_oneval(sdb, PZ_ELEMENTS);
 497     const char *opt_requestsyn = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
 498     const char *opt_maxrecs = session_setting_oneval(sdb, PZ_MAXRECS);
 499     const char *opt_sru = session_setting_oneval(sdb, PZ_SRU);
 500     const char *opt_sort = session_setting_oneval(sdb, PZ_SORT);
 501     char maxrecs_str[24];
 502
 503     assert(link);
 504
 505     cl->hits = -1;
 506     cl->record_offset = 0;
 507     cl->diagnostic = 0;
 508     client_set_state(cl, Client_Working);
 509
 510     if (*opt_piggyback)
 511         ZOOM_connection_option_set(link, "piggyback", opt_piggyback);
 512     else
 513         ZOOM_connection_option_set(link, "piggyback", "1");
 514     if (*opt_queryenc)
 515         ZOOM_connection_option_set(link, "rpnCharset", opt_queryenc);
 516     if (*opt_sru && *opt_elements)
 517         ZOOM_connection_option_set(link, "schema", opt_elements);
 518     else if (*opt_elements)
 519         ZOOM_connection_option_set(link, "elementSetName", opt_elements);
 520     if (*opt_requestsyn)
 521         ZOOM_connection_option_set(link, "preferredRecordSyntax", opt_requestsyn);
 522
 523     if (!*opt_maxrecs)
 524     {
 525         sprintf(maxrecs_str, "%d", cl->maxrecs);
 526         opt_maxrecs = maxrecs_str;
 527     }
 528     ZOOM_connection_option_set(link, "count", opt_maxrecs);
 529
 530     if (atoi(opt_maxrecs) > 20)
 531         ZOOM_connection_option_set(link, "presentChunk", "20");
 532     else
 533         ZOOM_connection_option_set(link, "presentChunk", opt_maxrecs);
 534
 535     if (databaseName)
 536         ZOOM_connection_option_set(link, "databaseName", databaseName);
 537
 538     if (cl->cqlquery)
 539     {
 540         ZOOM_query q = ZOOM_query_create();
 541         yaz_log(YLOG_LOG, "Search %s CQL: %s", sdb->database->url, cl->cqlquery);
 542         ZOOM_query_cql(q, cl->cqlquery);
 543         if (*opt_sort)
 544             ZOOM_query_sortby(q, opt_sort);
 545         rs = ZOOM_connection_search(link, q);
 546         ZOOM_query_destroy(q);
 547     }
 548     else
 549     {
 550         yaz_log(YLOG_LOG, "Search %s PQF: %s", sdb->database->url, cl->pquery);
 551         rs = ZOOM_connection_search_pqf(link, cl->pquery);
 552     }
 553     ZOOM_resultset_destroy(cl->resultset);
 554     cl->resultset = rs;
 555     connection_continue(co);
 556 }
 557
 558 struct client *client_create(void)
 559 {
 560     struct client *r;
 561     if (client_freelist)
 562     {
 563         r = client_freelist;
 564         client_freelist = client_freelist->next;
 565     }
 566     else
 567         r = xmalloc(sizeof(struct client));
 568     r->maxrecs = 100;
 569     r->pquery = 0;
 570     r->cqlquery = 0;
 571     r->database = 0;
 572     r->connection = 0;
 573     r->session = 0;
 574     r->hits = 0;
 575     r->record_offset = 0;
 576     r->diagnostic = 0;
 577     r->state = Client_Disconnected;
 578     r->show_raw = 0;
 579     r->resultset = 0;
 580     r->next = 0;
 581     return r;
 582 }
 583
 584 void client_destroy(struct client *c)
 585 {
 586     struct session *se = c->session;
 587     if (c == se->clients)
 588         se->clients = c->next;
 589     else
 590     {
 591         struct client *cc;
 592         for (cc = se->clients; cc && cc->next != c; cc = cc->next)
 593             ;
 594         if (cc)
 595             cc->next = c->next;
 596     }
 597     xfree(c->pquery);
 598     xfree(c->cqlquery);
 599
 600     if (c->connection)
 601         connection_release(c->connection);
 602
 603     ZOOM_resultset_destroy(c->resultset);
 604     c->resultset = 0;
 605     c->next = client_freelist;
 606     client_freelist = c;
 607 }
 608
 609 void client_set_connection(struct client *cl, struct connection *con)
 610 {
 611     cl->connection = con;
 612 }
 613
 614 void client_disconnect(struct client *cl)
 615 {
 616     if (cl->state != Client_Idle)
 617         client_set_state(cl, Client_Disconnected);
 618     client_set_connection(cl, 0);
 619 }
 620
 621 // Extract terms from query into null-terminated termlist
 622 static void extract_terms(NMEM nmem, struct ccl_rpn_node *query, char **termlist)
 623 {
 624     int num = 0;
 625
 626     pull_terms(nmem, query, termlist, &num);
 627     termlist[num] = 0;
 628 }
 629
 630 // Initialize CCL map for a target
 631 static CCL_bibset prepare_cclmap(struct client *cl)
 632 {
 633     struct session_database *sdb = client_get_database(cl);
 634     struct setting *s;
 635     CCL_bibset res;
 636
 637     if (!sdb->settings)
 638         return 0;
 639     res = ccl_qual_mk();
 640     for (s = sdb->settings[PZ_CCLMAP]; s; s = s->next)
 641     {
 642         char *p = strchr(s->name + 3, ':');
 643         if (!p)
 644         {
 645             yaz_log(YLOG_WARN, "Malformed cclmap name: %s", s->name);
 646             ccl_qual_rm(&res);
 647             return 0;
 648         }
 649         p++;
 650         ccl_qual_fitem(res, s->value, p);
 651     }
 652     return res;
 653 }
 654
 655 // returns a xmalloced CQL query corresponding to the pquery in client
 656 static char *make_cqlquery(struct client *cl)
 657 {
 658     cql_transform_t cqlt = cql_transform_create();
 659     Z_RPNQuery *zquery;
 660     char *r;
 661     WRBUF wrb = wrbuf_alloc();
 662     int status;
 663     ODR odr_out = odr_createmem(ODR_ENCODE);
 664
 665     zquery = p_query_rpn(odr_out, cl->pquery);
 666     yaz_log(YLOG_LOG, "PQF: %s", cl->pquery);
 667     if ((status = cql_transform_rpn2cql_wrbuf(cqlt, wrb, zquery)))
 668     {
 669         yaz_log(YLOG_WARN, "Failed to generate CQL query, code=%d", status);
 670         r = 0;
 671     }
 672     else
 673     {
 674         r = xstrdup(wrbuf_cstr(wrb));
 675     }
 676     wrbuf_destroy(wrb);
 677     odr_destroy(odr_out);
 678     cql_transform_close(cqlt);
 679     return r;
 680 }
 681
 682 // Parse the query given the settings specific to this client
 683 int client_parse_query(struct client *cl, const char *query)
 684 {
 685     struct session *se = client_get_session(cl);
 686     struct session_database *sdb = client_get_database(cl);
 687     struct ccl_rpn_node *cn;
 688     int cerror, cpos;
 689     CCL_bibset ccl_map = prepare_cclmap(cl);
 690     const char *sru = session_setting_oneval(sdb, PZ_SRU);
 691     const char *pqf_prefix = session_setting_oneval(sdb, PZ_PQF_PREFIX);
 692
 693     if (!ccl_map)
 694         return -1;
 695
 696     cn = ccl_find_str(ccl_map, query, &cerror, &cpos);
 697     ccl_qual_rm(&ccl_map);
 698     if (!cn)
 699     {
 700         client_set_state(cl, Client_Error);
 701         yaz_log(YLOG_WARN, "Failed to parse CCL query %s for %s",
 702                 query,
 703                 client_get_database(cl)->database->url);
 704         return -1;
 705     }
 706     wrbuf_rewind(se->wrbuf);
 707     if (*pqf_prefix)
 708     {
 709         wrbuf_puts(se->wrbuf, pqf_prefix);
 710         wrbuf_puts(se->wrbuf, " ");
 711     }
 712     ccl_pquery(se->wrbuf, cn);
 713     xfree(cl->pquery);
 714     cl->pquery = xstrdup(wrbuf_cstr(se->wrbuf));
 715
 716     xfree(cl->cqlquery);
 717     if (*sru)
 718     {
 719         if (!(cl->cqlquery = make_cqlquery(cl)))
 720             return -1;
 721     }
 722     else
 723         cl->cqlquery = 0;
 724
 725     if (!se->relevance)
 726     {
 727         // Initialize relevance structure with query terms
 728         char *p[512];
 729         extract_terms(se->nmem, cn, p);
 730         se->relevance = relevance_create(
 731             se->service->relevance_pct,
 732             se->nmem, (const char **) p);
 733     }
 734
 735     ccl_rpn_delete(cn);
 736     return 0;
 737 }
 738
 739 void client_set_session(struct client *cl, struct session *se)
 740 {
 741     cl->session = se;
 742     cl->next = se->clients;
 743     se->clients = cl;
 744 }
 745
 746 int client_is_active(struct client *cl)
 747 {
 748     if (cl->connection && (cl->state == Client_Connecting ||
 749                            cl->state == Client_Working))
 750         return 1;
 751     return 0;
 752 }
 753
 754 struct client *client_next_in_session(struct client *cl)
 755 {
 756     if (cl)
 757         return cl->next;
 758     return 0;
 759
 760 }
 761
 762 int client_get_hits(struct client *cl)
 763 {
 764     return cl->hits;
 765 }
 766
 767 int client_get_num_records(struct client *cl)
 768 {
 769     return cl->record_offset;
 770 }
 771
 772 int client_get_diagnostic(struct client *cl)
 773 {
 774     return cl->diagnostic;
 775 }
 776
 777 void client_set_database(struct client *cl, struct session_database *db)
 778 {
 779     cl->database = db;
 780 }
 781
 782 struct host *client_get_host(struct client *cl)
 783 {
 784     return client_get_database(cl)->database->host;
 785 }
 786
 787 const char *client_get_url(struct client *cl)
 788 {
 789     return client_get_database(cl)->database->url;
 790 }
 791
 792 void client_set_maxrecs(struct client *cl, int v)
 793 {
 794     cl->maxrecs = v;
 795 }
 796
 797 /*
 798  * Local variables:
 799  * c-basic-offset: 4
 800  * c-file-style: "Stroustrup"
 801  * indent-tabs-mode: nil
 802  * End:
 803  * vim: shiftwidth=4 tabstop=8 expandtab
 804  */
 805