server/seshigh.c

   1 /*
   2  * Copyright (c) 1995-1998, Index Data
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: seshigh.c,v $
   7  * Revision 1.82  1998-10-20 14:00:30  quinn
   8  * Fixed Scan
   9  *
  10  * Revision 1.81  1998/10/13 16:12:24  adam
  11  * Added support for Surrogate Diagnostics for Scan Term entries.
  12  *
  13  * Revision 1.80  1998/09/02 12:41:53  adam
  14  * Added decode stream in bend search structures.
  15  *
  16  * Revision 1.79  1998/08/19 16:10:08  adam
  17  * Changed som member names of DeleteResultSetRequest/Response.
  18  *
  19  * Revision 1.78  1998/08/03 10:23:55  adam
  20  * Fixed bug regarding Options for Sort.
  21  *
  22  * Revision 1.77  1998/07/20 12:38:42  adam
  23  * Implemented delete result set service to server API.
  24  *
  25  * Revision 1.76  1998/05/27 16:57:07  adam
  26  * Support for surrogate diagnostic records added for bend_fetch.
  27  *
  28  * Revision 1.75  1998/05/18 10:13:07  adam
  29  * Fixed call to es_request handler - extra argument was passed.
  30  *
  31  * Revision 1.74  1998/03/31 15:13:20  adam
  32  * Development towards compiled ASN.1.
  33  *
  34  * Revision 1.73  1998/03/31 11:07:45  adam
  35  * Furhter work on UNIverse resource report.
  36  * Added Extended Services handling in frontend server.
  37  *
  38  * Revision 1.72  1998/02/11 11:53:35  adam
  39  * Changed code so that it compiles as C++.
  40  *
  41  * Revision 1.71  1998/02/10 11:03:57  adam
  42  * Added support for extended handlers in backend server interface.
  43  *
  44  * Revision 1.70  1998/01/29 13:15:35  adam
  45  * Implemented sort for the backend interface.
  46  *
  47  * Revision 1.69  1997/09/30 11:48:12  adam
  48  * Fixed bug introduced by previous commit.
  49  *
  50  * Revision 1.68  1997/09/29 13:18:59  adam
  51  * Added function, oid_ent_to_oid, to replace the function
  52  * oid_getoidbyent, which is not thread safe.
  53  *
  54  * Revision 1.67  1997/09/17 12:10:40  adam
  55  * YAZ version 1.4.
  56  *
  57  * Revision 1.66  1997/09/05 15:26:44  adam
  58  * Added ODR encode in search and scen bend request structures.
  59  * Fixed a few enums that caused trouble with C++.
  60  *
  61  * Revision 1.65  1997/09/01 08:53:01  adam
  62  * New windows NT/95 port using MSV5.0. The test server 'ztest' was
  63  * moved a separate directory. MSV5.0 project server.dsp created.
  64  * As an option, the server can now operate as an NT service.
  65  *
  66  * Revision 1.64  1997/04/30 08:52:11  quinn
  67  * Null
  68  *
  69  * Revision 1.63  1996/10/11  11:57:26  quinn
  70  * Smallish
  71  *
  72  * Revision 1.62  1996/07/06  19:58:35  quinn
  73  * System headerfiles gathered in yconfig
  74  *
  75  * Revision 1.61  1996/06/10  08:56:16  quinn
  76  * Work on Summary.
  77  *
  78  * Revision 1.60  1996/05/30  11:03:10  quinn
  79  * Fixed NextresultSetPosition bug fixed.
  80  *
  81  * Revision 1.59  1996/05/14  09:26:46  quinn
  82  * Added attribute set to scan backend
  83  *
  84  * Revision 1.58  1996/02/20  12:53:04  quinn
  85  * Chanes to SCAN
  86  *
  87  * Revision 1.57  1996/01/02  08:57:47  quinn
  88  * Changed enums in the ASN.1 .h files to #defines. Changed oident.class to oclass
  89  *
  90  * Revision 1.56  1995/12/14  11:09:57  quinn
  91  * Work on Explain
  92  *
  93  * Revision 1.55  1995/11/08  17:41:37  quinn
  94  * Smallish.
  95  *
  96  * Revision 1.54  1995/11/08  15:11:29  quinn
  97  * Log of close transmit.
  98  *
  99  * Revision 1.53  1995/11/01  13:54:58  quinn
 100  * Minor adjustments
 101  *
 102  * Revision 1.52  1995/11/01  12:19:13  quinn
 103  * Second attempt to fix same bug.
 104  *
 105  * Revision 1.50  1995/10/25  16:58:32  quinn
 106  * Simple.
 107  *
 108  * Revision 1.49  1995/10/16  13:51:53  quinn
 109  * Changes to provide Especs to the backend.
 110  *
 111  * Revision 1.48  1995/10/06  08:51:20  quinn
 112  * Added Write-buffer.
 113  *
 114  * Revision 1.47  1995/08/29  14:24:16  quinn
 115  * Added second half of close-handshake
 116  *
 117  * Revision 1.46  1995/08/29  11:17:58  quinn
 118  * Added code to receive close
 119  *
 120  * Revision 1.45  1995/08/21  09:11:00  quinn
 121  * Smallish fixes to suppport new formats.
 122  *
 123  * Revision 1.44  1995/08/17  12:45:25  quinn
 124  * Fixed minor problems with GRS-1. Added support in c&s.
 125  *
 126  * Revision 1.43  1995/08/15  12:00:31  quinn
 127  * Updated External
 128  *
 129  * Revision 1.42  1995/08/15  11:16:50  quinn
 130  *
 131  * Revision 1.41  1995/08/02  10:23:06  quinn
 132  * Smallish
 133  *
 134  * Revision 1.40  1995/07/31  14:34:26  quinn
 135  * Fixed bug in process_searchResponse (numberOfRecordsReturned).
 136  *
 137  * Revision 1.39  1995/06/27  13:21:00  quinn
 138  * SUTRS support
 139  *
 140  * Revision 1.38  1995/06/19  12:39:11  quinn
 141  * Fixed bug in timeout code. Added BER dumper.
 142  *
 143  * Revision 1.37  1995/06/16  13:16:14  quinn
 144  * Fixed Defaultdiagformat.
 145  *
 146  * Revision 1.36  1995/06/16  10:31:36  quinn
 147  * Added session timeout.
 148  *
 149  * Revision 1.35  1995/06/15  07:45:14  quinn
 150  * Moving to v3.
 151  *
 152  * Revision 1.34  1995/06/14  15:26:46  quinn
 153  * *** empty log message ***
 154  *
 155  * Revision 1.33  1995/06/06  14:57:05  quinn
 156  * Better diagnostics.
 157  *
 158  * Revision 1.32  1995/06/06  08:41:44  quinn
 159  * Better diagnostics.
 160  *
 161  * Revision 1.31  1995/06/06  08:15:37  quinn
 162  * Cosmetic.
 163  *
 164  * Revision 1.30  1995/06/05  10:53:32  quinn
 165  * Added a better SCAN.
 166  *
 167  * Revision 1.29  1995/06/01  11:25:03  quinn
 168  * Smallish.
 169  *
 170  * Revision 1.28  1995/06/01  11:21:01  quinn
 171  * Attempting to fix a bug in pack-records. replaced break with continue
 172  * for large records, according to standard.
 173  *
 174  * Revision 1.27  1995/05/29  08:12:06  quinn
 175  * Moved oid to util
 176  *
 177  * Revision 1.26  1995/05/18  13:02:12  quinn
 178  * Smallish.
 179  *
 180  * Revision 1.25  1995/05/17  08:42:26  quinn
 181  * Transfer auth info to backend. Allow backend to reject init gracefully.
 182  *
 183  * Revision 1.24  1995/05/16  08:51:04  quinn
 184  * License, documentation, and memory fixes
 185  *
 186  * Revision 1.23  1995/05/15  13:25:10  quinn
 187  * Fixed memory bug.
 188  *
 189  * Revision 1.22  1995/05/15  11:56:39  quinn
 190  * Asynchronous facilities. Restructuring of seshigh code.
 191  *
 192  * Revision 1.21  1995/05/02  08:53:19  quinn
 193  * Trying in vain to fix comm with ISODE
 194  *
 195  * Revision 1.20  1995/04/20  15:13:00  quinn
 196  * Cosmetic
 197  *
 198  * Revision 1.19  1995/04/18  08:15:34  quinn
 199  * Added dynamic memory allocation on encoding (whew). Code is now somewhat
 200  * neater. We'll make the same change for decoding one day.
 201  *
 202  * Revision 1.18  1995/04/17  11:28:25  quinn
 203  * Smallish
 204  *
 205  * Revision 1.17  1995/04/10  10:23:36  quinn
 206  * Some work to add scan and other things.
 207  *
 208  * Revision 1.16  1995/03/31  09:18:55  quinn
 209  * Added logging.
 210  *
 211  * Revision 1.15  1995/03/30  14:03:23  quinn
 212  * Added RFC1006 as separate library
 213  *
 214  * Revision 1.14  1995/03/30  12:18:17  quinn
 215  * Fixed bug.
 216  *
 217  * Revision 1.13  1995/03/30  09:09:24  quinn
 218  * Added state-handle and some support for asynchronous activities.
 219  *
 220  * Revision 1.12  1995/03/29  15:40:16  quinn
 221  * Ongoing work. Statserv is now dynamic by default
 222  *
 223  * Revision 1.11  1995/03/28  09:16:21  quinn
 224  * Added record packing to the search request
 225  *
 226  * Revision 1.10  1995/03/27  08:34:24  quinn
 227  * Added dynamic server functionality.
 228  * Released bindings to session.c (is now redundant)
 229  *
 230  * Revision 1.9  1995/03/22  15:01:26  quinn
 231  * Adjusting record packing.
 232  *
 233  * Revision 1.8  1995/03/22  10:13:21  quinn
 234  * Working on record packer
 235  *
 236  * Revision 1.7  1995/03/21  15:53:31  quinn
 237  * Little changes.
 238  *
 239  * Revision 1.6  1995/03/21  12:30:09  quinn
 240  * Beginning to add support for record packing.
 241  *
 242  * Revision 1.5  1995/03/17  10:44:13  quinn
 243  * Added catch of null-string in makediagrec
 244  *
 245  * Revision 1.4  1995/03/17  10:18:08  quinn
 246  * Added memory management.
 247  *
 248  * Revision 1.3  1995/03/16  17:42:39  quinn
 249  * Little changes
 250  *
 251  * Revision 1.2  1995/03/16  13:29:01  quinn
 252  * Partitioned server.
 253  *
 254  * Revision 1.1  1995/03/15  16:02:10  quinn
 255  * Modded session.c to seshigh.c
 256  *
 257  */
 258
 259 /*
 260  * Frontend server logic.
 261  *
 262  * This code receives incoming APDUs, and handles client requests by means
 263  * of the backend API.
 264  *
 265  * Some of the code is getting quite involved, compared to simpler servers -
 266  * primarily because it is asynchronous both in the communication with
 267  * the user and the backend. We think the complexity will pay off in
 268  * the form of greater flexibility when more asynchronous facilities
 269  * are implemented.
 270  *
 271  * Memory management has become somewhat involved. In the simple case, where
 272  * only one PDU is pending at a time, it will simply reuse the same memory,
 273  * once it has found its working size. When we enable multiple concurrent
 274  * operations, perhaps even with multiple parallel calls to the backend, it
 275  * will maintain a pool of buffers for encoding and decoding, trying to
 276  * minimize memory allocation/deallocation during normal operation.
 277  *
 278  * TODOs include (and will be done in order of public interest):
 279  *
 280  * Support for EXPLAIN - provide simple meta-database system.
 281  * Support for access control.
 282  * Support for resource control.
 283  * Support for extended services - primarily Item Order.
 284  * Rest of Z39.50-1994
 285  *
 286  */
 287
 288 #include <yconfig.h>
 289 #include <stdlib.h>
 290 #include <stdio.h>
 291 #ifdef WINDOWS
 292 #include <process.h>
 293 #else
 294 #include <unistd.h>
 295 #endif
 296 #include <assert.h>
 297
 298 #include <xmalloc.h>
 299 #include <comstack.h>
 300 #include "eventl.h"
 301 #include "session.h"
 302 #include <proto.h>
 303 #include <oid.h>
 304 #include <log.h>
 305 #include <statserv.h>
 306
 307 #include <backend.h>
 308
 309 static int process_request(association *assoc, request *req);
 310 void backend_response(IOCHAN i, int event);
 311 static int process_response(association *assoc, request *req, Z_APDU *res);
 312 static Z_APDU *process_initRequest(association *assoc, request *reqb);
 313 static Z_APDU *process_searchRequest(association *assoc, request *reqb,
 314     int *fd);
 315 static Z_APDU *response_searchRequest(association *assoc, request *reqb,
 316     bend_search_rr *bsrr, int *fd);
 317 static Z_APDU *process_presentRequest(association *assoc, request *reqb,
 318     int *fd);
 319 static Z_APDU *process_scanRequest(association *assoc, request *reqb, int *fd);
 320 static Z_APDU *process_sortRequest(association *assoc, request *reqb, int *fd);
 321 static void process_close(association *assoc, request *reqb);
 322 void save_referenceId (request *reqb, Z_ReferenceId *refid);
 323 static Z_APDU *process_deleteRequest(association *assoc, request *reqb,
 324     int *fd);
 325
 326 static FILE *apduf = 0; /* for use in static mode */
 327 static statserv_options_block *control_block = 0;
 328
 329 /* Chas: Added in from DALI */
 330 static Z_APDU *process_ESRequest(association *assoc, request *reqb, int *fd);
 331 /* Chas: End of addition from DALI */
 332
 333 /*
 334  * Create and initialize a new association-handle.
 335  *  channel  : iochannel for the current line.
 336  *  link     : communications channel.
 337  * Returns: 0 or a new association handle.
 338  */
 339 association *create_association(IOCHAN channel, COMSTACK link)
 340 {
 341     association *anew;
 342
 343     if (!control_block)
 344         control_block = statserv_getcontrol();
 345     if (!(anew = (association *)xmalloc(sizeof(*anew))))
 346         return 0;
 347     anew->client_chan = channel;
 348     anew->client_link = link;
 349     if (!(anew->decode = odr_createmem(ODR_DECODE)) ||
 350         !(anew->encode = odr_createmem(ODR_ENCODE)))
 351         return 0;
 352     if (*control_block->apdufile)
 353     {
 354         char filename[256];
 355         FILE *f;
 356
 357         strcpy(filename, control_block->apdufile);
 358         if (!(anew->print = odr_createmem(ODR_PRINT)))
 359             return 0;
 360         if (*control_block->apdufile != '-')
 361         {
 362             strcpy(filename, control_block->apdufile);
 363             if (!control_block->dynamic)
 364             {
 365                 if (!apduf)
 366                 {
 367                     if (!(apduf = fopen(filename, "w")))
 368                     {
 369                         logf(LOG_WARN|LOG_ERRNO, "%s", filename);
 370                         return 0;
 371                     }
 372                     setvbuf(apduf, 0, _IONBF, 0);
 373                 }
 374                 f = apduf;
 375             }
 376             else
 377             {
 378                 sprintf(filename + strlen(filename), ".%d", getpid());
 379                 if (!(f = fopen(filename, "w")))
 380                 {
 381                     logf(LOG_WARN|LOG_ERRNO, "%s", filename);
 382                     return 0;
 383                 }
 384                 setvbuf(f, 0, _IONBF, 0);
 385             }
 386             odr_setprint(anew->print, f);
 387         }
 388     }
 389     else
 390         anew->print = 0;
 391     anew->input_buffer = 0;
 392     anew->input_buffer_len = 0;
 393     anew->backend = 0;
 394     anew->state = ASSOC_NEW;
 395     request_initq(&anew->incoming);
 396     request_initq(&anew->outgoing);
 397     anew->proto = cs_getproto(link);
 398     return anew;
 399 }
 400
 401 /*
 402  * Free association and release resources.
 403  */
 404 void destroy_association(association *h)
 405 {
 406     odr_destroy(h->decode);
 407     odr_destroy(h->encode);
 408     if (h->print)
 409         odr_destroy(h->print);
 410     if (h->input_buffer)
 411     xfree(h->input_buffer);
 412     if (h->backend)
 413         bend_close(h->backend);
 414     while (request_deq(&h->incoming));
 415     while (request_deq(&h->outgoing));
 416     request_delq(&h->incoming);
 417     request_delq(&h->outgoing);
 418     xfree(h);
 419 }
 420
 421 static void do_close_req(association *a, int reason, char *message,
 422                          request *req)
 423 {
 424     Z_APDU apdu;
 425     Z_Close *cls = zget_Close(a->encode);
 426
 427     /* Purge request queue */
 428     while (request_deq(&a->incoming));
 429     while (request_deq(&a->outgoing));
 430     if (a->version >= 3)
 431     {
 432         logf(LOG_LOG, "Sending Close PDU, reason=%d, message=%s",
 433             reason, message ? message : "none");
 434         apdu.which = Z_APDU_close;
 435         apdu.u.close = cls;
 436         *cls->closeReason = reason;
 437         cls->diagnosticInformation = message;
 438         process_response(a, req, &apdu);
 439         iochan_settimeout(a->client_chan, 60);
 440     }
 441     else
 442     {
 443         logf(LOG_DEBUG, "v2 client. No Close PDU");
 444         iochan_setevent(a->client_chan, EVENT_TIMEOUT); /* force imm close */
 445     }
 446     a->state = ASSOC_DEAD;
 447 }
 448
 449 static void do_close(association *a, int reason, char *message)
 450 {
 451     do_close_req (a, reason, message, request_get(&a->outgoing));
 452 }
 453
 454 /*
 455  * This is where PDUs from the client are read and the further
 456  * processing is initiated. Flow of control moves down through the
 457  * various process_* functions below, until the encoded result comes back up
 458  * to the output handler in here.
 459  *
 460  *  h     : the I/O channel that has an outstanding event.
 461  *  event : the current outstanding event.
 462  */
 463 void ir_session(IOCHAN h, int event)
 464 {
 465     int res;
 466     association *assoc = (association *)iochan_getdata(h);
 467     COMSTACK conn = assoc->client_link;
 468     request *req;
 469
 470     assert(h && conn && assoc);
 471     if (event == EVENT_TIMEOUT)
 472     {
 473         if (assoc->state != ASSOC_UP)
 474         {
 475             logf(LOG_LOG, "Final timeout - closing connection.");
 476             cs_close(conn);
 477             destroy_association(assoc);
 478             iochan_destroy(h);
 479         }
 480         else
 481         {
 482             logf(LOG_LOG, "Session idle too long. Sending close.");
 483             do_close(assoc, Z_Close_lackOfActivity, 0);
 484         }
 485         return;
 486     }
 487     if (event & EVENT_INPUT || event & EVENT_WORK) /* input */
 488     {
 489         if (event & EVENT_INPUT)
 490         {
 491             logf(LOG_DEBUG, "ir_session (input)");
 492             assert(assoc && conn);
 493             /* We aren't speaking to this fellow */
 494             if (assoc->state == ASSOC_DEAD)
 495             {
 496                 logf(LOG_LOG, "Closed connection after reject");
 497                 cs_close(conn);
 498                 destroy_association(assoc);
 499                 iochan_destroy(h);
 500                 return;
 501             }
 502             if ((res = cs_get(conn, &assoc->input_buffer,
 503                 &assoc->input_buffer_len)) <= 0)
 504             {
 505                 logf(LOG_LOG, "Connection closed by client");
 506                 cs_close(conn);
 507                 destroy_association(assoc);
 508                 iochan_destroy(h);
 509                 return;
 510             }
 511             else if (res == 1) /* incomplete read - wait for more  */
 512                 return;
 513             if (cs_more(conn)) /* more stuff - call us again later, please */
 514                 iochan_setevent(h, EVENT_INPUT);
 515
 516             /* we got a complete PDU. Let's decode it */
 517             logf(LOG_DEBUG, "Got PDU, %d bytes", res);
 518             req = request_get(&assoc->incoming); /* get a new request structure */
 519             odr_reset(assoc->decode);
 520             odr_setbuf(assoc->decode, assoc->input_buffer, res, 0);
 521             if (!z_APDU(assoc->decode, &req->request, 0))
 522             {
 523                 logf(LOG_LOG, "ODR error on incoming PDU: %s [near byte %d] ",
 524                     odr_errmsg(odr_geterror(assoc->decode)),
 525                     odr_offset(assoc->decode));
 526                 logf(LOG_LOG, "PDU dump:");
 527                 odr_dumpBER(log_file(), assoc->input_buffer, res);
 528                 do_close(assoc, Z_Close_protocolError, "Malformed package");
 529                 return;
 530             }
 531             req->request_mem = odr_extract_mem(assoc->decode);
 532             if (assoc->print && !z_APDU(assoc->print, &req->request, 0))
 533             {
 534                 logf(LOG_WARN, "ODR print error: %s",
 535                     odr_errmsg(odr_geterror(assoc->print)));
 536                 odr_reset(assoc->print);
 537             }
 538             request_enq(&assoc->incoming, req);
 539         }
 540
 541         /* can we do something yet? */
 542         req = request_head(&assoc->incoming);
 543         if (req->state == REQUEST_IDLE)
 544         {
 545             request_deq(&assoc->incoming);
 546             if (process_request(assoc, req) < 0)
 547                 do_close_req(assoc, Z_Close_systemProblem, "Unknown error",
 548                              req);
 549         }
 550     }
 551     if (event & EVENT_OUTPUT)
 552     {
 553         request *req = request_head(&assoc->outgoing);
 554
 555         logf(LOG_DEBUG, "ir_session (output)");
 556         req->state = REQUEST_PENDING;
 557         switch (res = cs_put(conn, req->response, req->len_response))
 558         {
 559             case -1:
 560                 logf(LOG_LOG, "Connection closed by client");
 561                 cs_close(conn);
 562                 destroy_association(assoc);
 563                 iochan_destroy(h);
 564                 break;
 565             case 0: /* all sent - release the request structure */
 566                 logf(LOG_DEBUG, "Wrote PDU, %d bytes", req->len_response);
 567                 nmem_destroy(req->request_mem);
 568                 request_deq(&assoc->outgoing);
 569                 request_release(req);
 570                 if (!request_head(&assoc->outgoing))
 571                     iochan_clearflag(h, EVENT_OUTPUT);
 572                 break;
 573             /* value of 1 -- partial send -- is simply ignored */
 574         }
 575     }
 576     if (event & EVENT_EXCEPT)
 577     {
 578         logf(LOG_DEBUG, "ir_session (exception)");
 579         cs_close(conn);
 580         destroy_association(assoc);
 581         iochan_destroy(h);
 582     }
 583 }
 584
 585 /*
 586  * Initiate request processing.
 587  */
 588 static int process_request(association *assoc, request *req)
 589 {
 590     int fd = -1;
 591     Z_APDU *res;
 592     int retval;
 593
 594     assert(req && req->state == REQUEST_IDLE);
 595     switch (req->request->which)
 596     {
 597         case Z_APDU_initRequest:
 598             res = process_initRequest(assoc, req); break;
 599         case Z_APDU_searchRequest:
 600             res = process_searchRequest(assoc, req, &fd); break;
 601         case Z_APDU_presentRequest:
 602             res = process_presentRequest(assoc, req, &fd); break;
 603         case Z_APDU_scanRequest:
 604             res = process_scanRequest(assoc, req, &fd); break;
 605         case Z_APDU_extendedServicesRequest:
 606             if (assoc->bend_esrequest)
 607                 res = process_ESRequest(assoc, req, &fd);
 608             else
 609             {
 610                 logf(LOG_WARN, "Cannot handle EXTENDED SERVICES APDU");
 611                 return -1;
 612             }
 613             break;
 614         case Z_APDU_sortRequest:
 615             if (assoc->bend_sort)
 616                 res = process_sortRequest(assoc, req, &fd);
 617             else
 618             {
 619                 logf(LOG_WARN, "Cannot handle SORT APDU");
 620                 return -1;
 621             }
 622             break;
 623         case Z_APDU_close:
 624             process_close(assoc, req); return 0;
 625         case Z_APDU_deleteResultSetRequest:
 626             if (assoc->bend_delete)
 627                 res = process_deleteRequest(assoc, req, &fd);
 628             else
 629             {
 630                 logf (LOG_WARN, "Cannot handle Delete APDU");
 631                 return -1;
 632             }
 633             break;
 634         default:
 635             logf(LOG_WARN, "Bad APDU received");
 636             return -1;
 637     }
 638     if (res)
 639     {
 640         logf(LOG_DEBUG, "  result immediately available");
 641         retval = process_response(assoc, req, res);
 642     }
 643     else if (fd < 0)
 644     {
 645         logf(LOG_DEBUG, "  result unavailble");
 646         retval = 0;
 647     }
 648     else /* no result yet - one will be provided later */
 649     {
 650         IOCHAN chan;
 651
 652         /* Set up an I/O handler for the fd supplied by the backend */
 653
 654         logf(LOG_DEBUG, "   establishing handler for result");
 655         req->state = REQUEST_PENDING;
 656         if (!(chan = iochan_create(fd, backend_response, EVENT_INPUT)))
 657             abort();
 658         iochan_setdata(chan, assoc);
 659         retval = 0;
 660     }
 661     return retval;
 662 }
 663
 664 /*
 665  * Handle message from the backend.
 666  */
 667 void backend_response(IOCHAN i, int event)
 668 {
 669     association *assoc = (association *)iochan_getdata(i);
 670     request *req = request_head(&assoc->incoming);
 671     Z_APDU *res;
 672     int fd;
 673
 674     logf(LOG_DEBUG, "backend_response");
 675     assert(assoc && req && req->state != REQUEST_IDLE);
 676     /* determine what it is we're waiting for */
 677     switch (req->request->which)
 678     {
 679         case Z_APDU_searchRequest:
 680             res = response_searchRequest(assoc, req, 0, &fd); break;
 681 #if 0
 682         case Z_APDU_presentRequest:
 683             res = response_presentRequest(assoc, req, 0, &fd); break;
 684         case Z_APDU_scanRequest:
 685             res = response_scanRequest(assoc, req, 0, &fd); break;
 686 #endif
 687         default:
 688             logf(LOG_WARN, "Serious programmer's lapse or bug");
 689             abort();
 690     }
 691     if ((res && process_response(assoc, req, res) < 0) || fd < 0)
 692     {
 693         logf(LOG_LOG, "Fatal error when talking to backend");
 694         do_close(assoc, Z_Close_systemProblem, 0);
 695         iochan_destroy(i);
 696         return;
 697     }
 698     else if (!res) /* no result yet - try again later */
 699     {
 700         logf(LOG_DEBUG, "   no result yet");
 701         iochan_setfd(i, fd); /* in case fd has changed */
 702     }
 703 }
 704
 705 /*
 706  * Encode response, and transfer the request structure to the outgoing queue.
 707  */
 708 static int process_response(association *assoc, request *req, Z_APDU *res)
 709 {
 710     odr_setbuf(assoc->encode, req->response, req->size_response, 1);
 711     if (!z_APDU(assoc->encode, &res, 0))
 712     {
 713         logf(LOG_WARN, "ODR error when encoding response: %s",
 714             odr_errmsg(odr_geterror(assoc->decode)));
 715         odr_reset(assoc->encode);
 716         return -1;
 717     }
 718     req->response = odr_getbuf(assoc->encode, &req->len_response,
 719         &req->size_response);
 720     odr_setbuf(assoc->encode, 0, 0, 0); /* don'txfree if we abort later */
 721     if (assoc->print && !z_APDU(assoc->print, &res, 0))
 722     {
 723         logf(LOG_WARN, "ODR print error: %s",
 724             odr_errmsg(odr_geterror(assoc->print)));
 725         odr_reset(assoc->print);
 726     }
 727     odr_reset(assoc->encode);
 728     req->state = REQUEST_IDLE;
 729     request_enq(&assoc->outgoing, req);
 730     /* turn the work over to the ir_session handler */
 731     iochan_setflag(assoc->client_chan, EVENT_OUTPUT);
 732     /* Is there more work to be done? give that to the input handler too */
 733 #if 1
 734     if (request_head(&assoc->incoming))
 735     {
 736         logf (LOG_DEBUG, "more work to be done");
 737         iochan_setevent(assoc->client_chan, EVENT_WORK);
 738     }
 739 #endif
 740     return 0;
 741 }
 742
 743 /*
 744  * Handle init request.
 745  * At the moment, we don't check the options
 746  * anywhere else in the code - we just try not to do anything that would
 747  * break a naive client. We'll toss 'em into the association block when
 748  * we need them there.
 749  */
 750 static Z_APDU *process_initRequest(association *assoc, request *reqb)
 751 {
 752     Z_InitRequest *req = reqb->request->u.initRequest;
 753     Z_APDU *apdu = zget_APDU(assoc->encode, Z_APDU_initResponse);
 754     Z_InitResponse *resp = apdu->u.initResponse;
 755     bend_initrequest binitreq;
 756     bend_initresult *binitres;
 757     char options[100];
 758
 759     logf(LOG_LOG, "Got initRequest");
 760     if (req->implementationId)
 761         logf(LOG_LOG, "Id:        %s", req->implementationId);
 762     if (req->implementationName)
 763         logf(LOG_LOG, "Name:      %s", req->implementationName);
 764     if (req->implementationVersion)
 765         logf(LOG_LOG, "Version:   %s", req->implementationVersion);
 766
 767     binitreq.stream = assoc->encode;
 768     binitreq.configname = "default-config";
 769     binitreq.auth = req->idAuthentication;
 770     binitreq.bend_sort = NULL;
 771     binitreq.bend_search = NULL;
 772     binitreq.bend_present = NULL;
 773     binitreq.bend_esrequest = NULL;
 774     binitreq.bend_delete = NULL;
 775     if (!(binitres = bend_init(&binitreq)))
 776     {
 777         logf(LOG_WARN, "Bad response from backend.");
 778         return 0;
 779     }
 780
 781     assoc->backend = binitres->handle;
 782     if ((assoc->bend_sort = (int (*)())binitreq.bend_sort))
 783         logf (LOG_DEBUG, "Sort handler installed");
 784     if ((assoc->bend_search = (int (*)())binitreq.bend_search))
 785         logf (LOG_DEBUG, "Search handler installed");
 786     if ((assoc->bend_present = (int (*)())binitreq.bend_present))
 787         logf (LOG_DEBUG, "Present handler installed");
 788     if ((assoc->bend_esrequest = (int (*)())binitreq.bend_esrequest))
 789         logf (LOG_DEBUG, "ESRequest handler installed");
 790     if ((assoc->bend_delete = (int (*)())binitreq.bend_delete))
 791         logf (LOG_DEBUG, "Delete handler installed");
 792
 793     resp->referenceId = req->referenceId;
 794     *options = '\0';
 795     /* let's tell the client what we can do */
 796     if (ODR_MASK_GET(req->options, Z_Options_search))
 797     {
 798         ODR_MASK_SET(resp->options, Z_Options_search);
 799         strcat(options, "srch");
 800     }
 801     if (ODR_MASK_GET(req->options, Z_Options_present))
 802     {
 803         ODR_MASK_SET(resp->options, Z_Options_present);
 804         strcat(options, " prst");
 805     }
 806     if (ODR_MASK_GET(req->options, Z_Options_delSet) && binitreq.bend_delete)
 807     {
 808         ODR_MASK_SET(resp->options, Z_Options_delSet);
 809         strcat(options, " del");
 810     }
 811     if (ODR_MASK_GET(req->options, Z_Options_extendedServices) &&
 812         binitreq.bend_esrequest)
 813     {
 814         ODR_MASK_SET(resp->options, Z_Options_extendedServices);
 815         strcat (options, " extendedServices");
 816     }
 817     if (ODR_MASK_GET(req->options, Z_Options_namedResultSets))
 818     {
 819         ODR_MASK_SET(resp->options, Z_Options_namedResultSets);
 820         strcat(options, " namedresults");
 821     }
 822     if (ODR_MASK_GET(req->options, Z_Options_scan))
 823     {
 824         ODR_MASK_SET(resp->options, Z_Options_scan);
 825         strcat(options, " scan");
 826     }
 827     if (ODR_MASK_GET(req->options, Z_Options_concurrentOperations))
 828     {
 829         ODR_MASK_SET(resp->options, Z_Options_concurrentOperations);
 830         strcat(options, " concurop");
 831     }
 832     if (ODR_MASK_GET(req->options, Z_Options_sort) && binitreq.bend_sort)
 833     {
 834         ODR_MASK_SET(resp->options, Z_Options_sort);
 835         strcat(options, " sort");
 836     }
 837     if (ODR_MASK_GET(req->protocolVersion, Z_ProtocolVersion_1))
 838     {
 839         ODR_MASK_SET(resp->protocolVersion, Z_ProtocolVersion_1);
 840         assoc->version = 2; /* 1 & 2 are equivalent */
 841     }
 842     if (ODR_MASK_GET(req->protocolVersion, Z_ProtocolVersion_2))
 843     {
 844         ODR_MASK_SET(resp->protocolVersion, Z_ProtocolVersion_2);
 845         assoc->version = 2;
 846     }
 847     if (ODR_MASK_GET(req->protocolVersion, Z_ProtocolVersion_3))
 848     {
 849         ODR_MASK_SET(resp->protocolVersion, Z_ProtocolVersion_3);
 850         assoc->version = 3;
 851     }
 852     logf(LOG_LOG, "Negotiated to v%d: %s", assoc->version, options);
 853     assoc->maximumRecordSize = *req->maximumRecordSize;
 854     if (assoc->maximumRecordSize > control_block->maxrecordsize)
 855         assoc->maximumRecordSize = control_block->maxrecordsize;
 856     assoc->preferredMessageSize = *req->preferredMessageSize;
 857     if (assoc->preferredMessageSize > assoc->maximumRecordSize)
 858         assoc->preferredMessageSize = assoc->maximumRecordSize;
 859     resp->preferredMessageSize = &assoc->preferredMessageSize;
 860     resp->maximumRecordSize = &assoc->maximumRecordSize;
 861     resp->implementationName = "Index Data/YAZ Generic Frontend Server";
 862     if (binitres->errcode)
 863     {
 864         logf(LOG_LOG, "Connection rejected by backend.");
 865         *resp->result = 0;
 866         assoc->state = ASSOC_DEAD;
 867     }
 868     else
 869         assoc->state = ASSOC_UP;
 870     return apdu;
 871 }
 872
 873 /*
 874  * These functions should be merged.
 875  */
 876
 877 static void set_addinfo (Z_DefaultDiagFormat *dr, char *addinfo)
 878 {
 879 #if ASN_COMPILED
 880     dr->which = Z_DefaultDiagFormat_v2Addinfo;
 881     dr->u.v2Addinfo = addinfo ? addinfo : "";
 882 #else
 883     dr->which = Z_DiagForm_v2AddInfo;
 884     dr->addinfo = addinfo ? addinfo : "";
 885 #endif
 886 }
 887
 888 /*
 889  * nonsurrogate diagnostic record.
 890  */
 891 static Z_Records *diagrec(association *assoc, int error, char *addinfo)
 892 {
 893     int oid[OID_SIZE];
 894     Z_Records *rec = (Z_Records *)
 895         odr_malloc (assoc->encode, sizeof(*rec));
 896     oident bib1;
 897     int *err = (int *)
 898         odr_malloc (assoc->encode, sizeof(*err));
 899     Z_DiagRec *drec = (Z_DiagRec *)
 900         odr_malloc (assoc->encode, sizeof(*drec));
 901     Z_DefaultDiagFormat *dr = (Z_DefaultDiagFormat *)
 902         odr_malloc (assoc->encode, sizeof(*dr));
 903
 904     bib1.proto = assoc->proto;
 905     bib1.oclass = CLASS_DIAGSET;
 906     bib1.value = VAL_BIB1;
 907
 908     logf(LOG_DEBUG, "Diagnostic: %d -- %s", error, addinfo ? addinfo :
 909         "NULL");
 910     *err = error;
 911     rec->which = Z_Records_NSD;
 912 #if ASN_COMPILED
 913     rec->u.nonSurrogateDiagnostic = dr;
 914 #else
 915 #ifdef Z_95
 916     rec->u.nonSurrogateDiagnostic = drec;
 917     drec->which = Z_DiagRec_defaultFormat;
 918     drec->u.defaultFormat = dr;
 919 #else
 920     rec->u.nonSurrogateDiagnostic = dr;
 921 #endif
 922 #endif
 923     dr->diagnosticSetId = odr_oiddup (assoc->encode,
 924                                       oid_ent_to_oid(&bib1, oid));
 925     dr->condition = err;
 926     set_addinfo (dr, addinfo);
 927     return rec;
 928 }
 929
 930 /*
 931  * surrogate diagnostic.
 932  */
 933 static Z_NamePlusRecord *surrogatediagrec(association *assoc, char *dbname,
 934                                           int error, char *addinfo)
 935 {
 936     int oid[OID_SIZE];
 937     Z_NamePlusRecord *rec = (Z_NamePlusRecord *)odr_malloc (assoc->encode, sizeof(*rec));
 938     int *err = (int *)odr_malloc (assoc->encode, sizeof(*err));
 939     oident bib1;
 940     Z_DiagRec *drec = (Z_DiagRec *)odr_malloc (assoc->encode, sizeof(*drec));
 941     Z_DefaultDiagFormat *dr = (Z_DefaultDiagFormat *)odr_malloc (assoc->encode, sizeof(*dr));
 942
 943     bib1.proto = assoc->proto;
 944     bib1.oclass = CLASS_DIAGSET;
 945     bib1.value = VAL_BIB1;
 946
 947     logf(LOG_DEBUG, "SurrogateDiagnotic: %d -- %s", error, addinfo);
 948     *err = error;
 949     rec->databaseName = dbname;
 950     rec->which = Z_NamePlusRecord_surrogateDiagnostic;
 951     rec->u.surrogateDiagnostic = drec;
 952     drec->which = Z_DiagRec_defaultFormat;
 953     drec->u.defaultFormat = dr;
 954     dr->diagnosticSetId = odr_oiddup (assoc->encode,
 955                                       oid_ent_to_oid(&bib1, oid));
 956     dr->condition = err;
 957     set_addinfo (dr, addinfo);
 958
 959     return rec;
 960 }
 961
 962 /*
 963  * multiple nonsurrogate diagnostics.
 964  */
 965 static Z_DiagRecs *diagrecs(association *assoc, int error, char *addinfo)
 966 {
 967     int oid[OID_SIZE];
 968     Z_DiagRecs *recs = (Z_DiagRecs *)odr_malloc (assoc->encode, sizeof(*recs));
 969     int *err = (int *)odr_malloc (assoc->encode, sizeof(*err));
 970     oident bib1;
 971     Z_DiagRec **recp = (Z_DiagRec **)odr_malloc (assoc->encode, sizeof(*recp));
 972     Z_DiagRec *drec = (Z_DiagRec *)odr_malloc (assoc->encode, sizeof(*drec));
 973     Z_DefaultDiagFormat *rec = (Z_DefaultDiagFormat *)odr_malloc (assoc->encode, sizeof(*rec));
 974
 975     logf(LOG_DEBUG, "DiagRecs: %d -- %s", error, addinfo);
 976     bib1.proto = assoc->proto;
 977     bib1.oclass = CLASS_DIAGSET;
 978     bib1.value = VAL_BIB1;
 979
 980     *err = error;
 981     recs->num_diagRecs = 1;
 982     recs->diagRecs = recp;
 983     recp[0] = drec;
 984     drec->which = Z_DiagRec_defaultFormat;
 985     drec->u.defaultFormat = rec;
 986
 987     rec->diagnosticSetId = odr_oiddup (assoc->encode,
 988                                       oid_ent_to_oid(&bib1, oid));
 989     rec->condition = err;
 990
 991 #ifdef ASN_COMPILED
 992     rec->which = Z_DefaultDiagFormat_v2Addinfo;
 993     rec->u.v2Addinfo = addinfo ? addinfo : "";
 994 #else
 995     rec->which = Z_DiagForm_v2AddInfo;
 996     rec->addinfo = addinfo ? addinfo : "";
 997 #endif
 998     return recs;
 999 }
1000
1001 static Z_Records *pack_records(association *a, char *setname, int start,
1002                                 int *num, Z_RecordComposition *comp,
1003                                 int *next, int *pres, oid_value format)
1004 {
1005     int oid[OID_SIZE];
1006     int recno, total_length = 0, toget = *num, dumped_records = 0;
1007     Z_Records *records = (Z_Records *)odr_malloc (a->encode, sizeof(*records));
1008     Z_NamePlusRecordList *reclist = (Z_NamePlusRecordList *)odr_malloc (a->encode, sizeof(*reclist));
1009     Z_NamePlusRecord **list = (Z_NamePlusRecord **)odr_malloc (a->encode, sizeof(*list) * toget);
1010     oident recform;
1011
1012     records->which = Z_Records_DBOSD;
1013     records->u.databaseOrSurDiagnostics = reclist;
1014     reclist->num_records = 0;
1015     reclist->records = list;
1016     *pres = Z_PRES_SUCCESS;
1017     *num = 0;
1018     *next = 0;
1019
1020     logf(LOG_DEBUG, "Request to pack %d+%d", start, toget);
1021     logf(LOG_DEBUG, "pms=%d, mrs=%d", a->preferredMessageSize,
1022         a->maximumRecordSize);
1023     for (recno = start; reclist->num_records < toget; recno++)
1024     {
1025         bend_fetchrequest freq;
1026         bend_fetchresult *fres;
1027         Z_NamePlusRecord *thisrec;
1028         Z_DatabaseRecord *thisext;
1029         int this_length = 0;
1030
1031         /*
1032          * we get the number of bytes allocated on the stream before any
1033          * allocation done by the backend - this should give us a reasonable
1034          * idea of the total size of the data so far.
1035          */
1036         total_length = odr_total(a->encode) - dumped_records;
1037         freq.setname = setname;
1038         freq.number = recno;
1039         freq.comp = comp;
1040         freq.format = format;
1041         freq.stream = a->encode;
1042         freq.surrogate_flag = 0;
1043         if (!(fres = bend_fetch(a->backend, &freq, 0)))
1044         {
1045             *pres = Z_PRES_FAILURE;
1046             return diagrec(a, 2, "Backend interface problem");
1047         }
1048         /* backend should be able to signal whether error is system-wide
1049            or only pertaining to current record */
1050         if (fres->errcode)
1051         {
1052             if (!freq.surrogate_flag)
1053             {
1054                 *pres = Z_PRES_FAILURE;
1055                 return diagrec(a, fres->errcode, fres->errstring);
1056             }
1057             reclist->records[reclist->num_records] =
1058                 surrogatediagrec(a, fres->basename, fres->errcode,
1059                                  fres->errstring);
1060             reclist->num_records++;
1061             *next = fres->last_in_set ? 0 : recno + 1;
1062             continue;
1063         }
1064         if (fres->len >= 0)
1065             this_length = fres->len;
1066         else
1067             this_length = odr_total(a->encode) - total_length;
1068         logf(LOG_DEBUG, "  fetched record, len=%d, total=%d",
1069             this_length, total_length);
1070         if (this_length + total_length > a->preferredMessageSize)
1071         {
1072             /* record is small enough, really */
1073             if (this_length <= a->preferredMessageSize)
1074             {
1075                 logf(LOG_DEBUG, "  Dropped last normal-sized record");
1076                 *pres = Z_PRES_PARTIAL_2;
1077                 break;
1078             }
1079             /* record can only be fetched by itself */
1080             if (this_length < a->maximumRecordSize)
1081             {
1082                 logf(LOG_DEBUG, "  Record > prefmsgsz");
1083                 if (toget > 1)
1084                 {
1085                     logf(LOG_DEBUG, "  Dropped it");
1086                     reclist->records[reclist->num_records] =
1087                          surrogatediagrec(a, fres->basename, 16, 0);
1088                     reclist->num_records++;
1089                     *next = fres->last_in_set ? 0 : recno + 1;
1090                     dumped_records += this_length;
1091                     continue;
1092                 }
1093             }
1094             else /* too big entirely */
1095             {
1096                 logf(LOG_DEBUG, "Record > maxrcdsz");
1097                 reclist->records[reclist->num_records] =
1098                     surrogatediagrec(a, fres->basename, 17, 0);
1099                 reclist->num_records++;
1100                 *next = fres->last_in_set ? 0 : recno + 1;
1101                 dumped_records += this_length;
1102                 continue;
1103             }
1104         }
1105
1106         if (!(thisrec = (Z_NamePlusRecord *)odr_malloc(a->encode, sizeof(*thisrec))))
1107             return 0;
1108         if (!(thisrec->databaseName = (char *)odr_malloc(a->encode,
1109             strlen(fres->basename) + 1)))
1110             return 0;
1111         strcpy(thisrec->databaseName, fres->basename);
1112         thisrec->which = Z_NamePlusRecord_databaseRecord;
1113         if (!(thisrec->u.databaseRecord = thisext = (Z_External *)odr_malloc(a->encode,
1114             sizeof(Z_DatabaseRecord))))
1115             return 0;
1116         recform.proto = a->proto;
1117         recform.oclass = CLASS_RECSYN;
1118         recform.value = fres->format;
1119         thisext->direct_reference = odr_oiddup(a->encode,
1120                                                oid_ent_to_oid(&recform, oid));
1121         thisext->indirect_reference = 0;
1122         thisext->descriptor = 0;
1123         if (fres->len < 0) /* Structured data */
1124         {
1125             switch (fres->format)
1126             {
1127                 case VAL_SUTRS: thisext->which = Z_External_sutrs; break;
1128                 case VAL_GRS1: thisext->which = Z_External_grs1; break;
1129                 case VAL_EXPLAIN: thisext->which = Z_External_explainRecord;
1130                     break;
1131                 case VAL_SUMMARY: thisext->which = Z_External_summary; break;
1132                 case VAL_OPAC: thisext->which = Z_External_OPAC; break;
1133
1134                 default:
1135                     logf(LOG_FATAL, "Unknown structured format from backend.");
1136                     return 0;
1137             }
1138
1139             /*
1140              * We cheat on the pointers here. Obviously, the record field
1141              * of the backend-fetch structure should have been a union for
1142              * correctness, but we're stuck with this for backwards
1143              * compatibility.
1144              */
1145             thisext->u.grs1 = (Z_GenericRecord*) fres->record;
1146         }
1147         else if (fres->format == VAL_SUTRS) /* SUTRS is a single-ASN.1-type */
1148         {
1149 #if 0
1150             Z_SUTRS *sutrs = (Z_SUTRS *)odr_malloc(a->encode, 1+fres->len);
1151
1152             memcpy(sutrs, fres->record, fres->len);
1153             sutrs[fres->len] = '\0';
1154 #else
1155             Odr_oct *sutrs = (Odr_oct *)odr_malloc(a->encode, sizeof(*sutrs));
1156
1157             thisext->which = Z_External_sutrs;
1158             thisext->u.sutrs = sutrs;
1159             sutrs->buf = (unsigned char *)odr_malloc(a->encode, fres->len);
1160             sutrs->len = sutrs->size = fres->len;
1161             memcpy(sutrs->buf, fres->record, fres->len);
1162 #endif
1163         }
1164         else /* octet-aligned record. */
1165         {
1166             thisext->which = Z_External_octet;
1167             if (!(thisext->u.octet_aligned = (Odr_oct *)odr_malloc(a->encode,
1168                 sizeof(Odr_oct))))
1169                 return 0;
1170             if (!(thisext->u.octet_aligned->buf = (unsigned char *)odr_malloc(a->encode,
1171                 fres->len)))
1172                 return 0;
1173             memcpy(thisext->u.octet_aligned->buf, fres->record, fres->len);
1174             thisext->u.octet_aligned->len = thisext->u.octet_aligned->size =
1175                 fres->len;
1176         }
1177         reclist->records[reclist->num_records] = thisrec;
1178         reclist->num_records++;
1179         *next = fres->last_in_set ? 0 : recno + 1;
1180     }
1181     *num = reclist->num_records;
1182     return records;
1183 }
1184
1185 static Z_APDU *process_searchRequest(association *assoc, request *reqb,
1186     int *fd)
1187 {
1188     Z_SearchRequest *req = reqb->request->u.searchRequest;
1189     bend_search_rr *bsrr = (bend_search_rr *)nmem_malloc (reqb->request_mem, sizeof(*bsrr));
1190
1191     logf(LOG_LOG, "Got SearchRequest.");
1192     save_referenceId (reqb, req->referenceId);
1193     /* store ref id in request */
1194     bsrr->fd = fd;
1195     bsrr->request = reqb;
1196     bsrr->association = assoc;
1197     if (assoc->bend_search)
1198     {
1199         bsrr->setname = req->resultSetName;
1200         bsrr->replace_set = *req->replaceIndicator;
1201         bsrr->num_bases = req->num_databaseNames;
1202         bsrr->basenames = req->databaseNames;
1203         bsrr->query = req->query;
1204         bsrr->stream = assoc->encode;
1205         bsrr->decode = assoc->decode;
1206         bsrr->errcode = 0;
1207         bsrr->hits = 0;
1208         bsrr->errstring = NULL;
1209         ((int (*)(void *, bend_search_rr *))(assoc->bend_search))(assoc->backend, bsrr);
1210         if (!bsrr->request)
1211             return 0;
1212     }
1213     else
1214     {
1215         bend_searchrequest bsrq;
1216         bend_searchresult *bsrt;
1217
1218         bsrq.setname = req->resultSetName;
1219         bsrq.replace_set = *req->replaceIndicator;
1220         bsrq.num_bases = req->num_databaseNames;
1221         bsrq.basenames = req->databaseNames;
1222         bsrq.query = req->query;
1223         bsrq.stream = assoc->encode;
1224         bsrq.decode = assoc->decode;
1225         if (!(bsrt = bend_search(assoc->backend, &bsrq, fd)))
1226             return 0;
1227         bsrr->hits = bsrt->hits;
1228         bsrr->errcode = bsrt->errcode;
1229         bsrr->errstring = bsrt->errstring;
1230     }
1231     return response_searchRequest(assoc, reqb, bsrr, fd);
1232 }
1233
1234 int bend_searchresponse(void *handle, bend_search_rr *bsrr) {return 0;}
1235
1236 /*
1237  * Prepare a searchresponse based on the backend results. We probably want
1238  * to look at making the fetching of records nonblocking as well, but
1239  * so far, we'll keep things simple.
1240  * If bsrt is null, that means we're called in response to a communications
1241  * event, and we'll have to get the response for ourselves.
1242  */
1243 static Z_APDU *response_searchRequest(association *assoc, request *reqb,
1244     bend_search_rr *bsrt, int *fd)
1245 {
1246     Z_SearchRequest *req = reqb->request->u.searchRequest;
1247     Z_APDU *apdu = (Z_APDU *)odr_malloc (assoc->encode, sizeof(*apdu));
1248     Z_SearchResponse *resp = (Z_SearchResponse *)odr_malloc (assoc->encode, sizeof(*resp));
1249     int *nulint = (int *)odr_malloc (assoc->encode, sizeof(*nulint));
1250     bool_t *sr = (bool_t *)odr_malloc (assoc->encode, sizeof(*sr));
1251     int *next = (int *)odr_malloc (assoc->encode, sizeof(*next));
1252     int *none = (int *)odr_malloc (assoc->encode, sizeof(*none));
1253
1254     *nulint = 0;
1255     *sr = 1;
1256     *next = 0;
1257     *none = Z_RES_NONE;
1258
1259     apdu->which = Z_APDU_searchResponse;
1260     apdu->u.searchResponse = resp;
1261     resp->referenceId = req->referenceId;
1262     resp->additionalSearchInfo = 0;
1263     resp->otherInfo = 0;
1264     *fd = -1;
1265     if (!bsrt && !bend_searchresponse(assoc->backend, bsrt))
1266     {
1267         logf(LOG_FATAL, "Bad result from backend");
1268         return 0;
1269     }
1270     else if (bsrt->errcode)
1271     {
1272         resp->records = diagrec(assoc, bsrt->errcode, bsrt->errstring);
1273         resp->resultCount = nulint;
1274         resp->numberOfRecordsReturned = nulint;
1275         resp->nextResultSetPosition = nulint;
1276         resp->searchStatus = nulint;
1277         resp->resultSetStatus = none;
1278         resp->presentStatus = 0;
1279     }
1280     else
1281     {
1282         int *toget = (int *)odr_malloc (assoc->encode, sizeof(*toget));
1283         int *presst = (int *)odr_malloc (assoc->encode, sizeof(*presst));
1284         Z_RecordComposition comp, *compp = 0;
1285
1286         *toget = 0;
1287         *presst = 0;
1288         resp->records = 0;
1289         resp->resultCount = &bsrt->hits;
1290
1291         comp.which = Z_RecordComp_simple;
1292         /* how many records does the user agent want, then? */
1293         if (bsrt->hits <= *req->smallSetUpperBound)
1294         {
1295             *toget = bsrt->hits;
1296             if ((comp.u.simple = req->smallSetElementSetNames))
1297                 compp = &comp;
1298         }
1299         else if (bsrt->hits < *req->largeSetLowerBound)
1300         {
1301             *toget = *req->mediumSetPresentNumber;
1302             if (*toget > bsrt->hits)
1303                 *toget = bsrt->hits;
1304             if ((comp.u.simple = req->mediumSetElementSetNames))
1305                 compp = &comp;
1306         }
1307         else
1308             *toget = 0;
1309
1310         if (*toget && !resp->records)
1311         {
1312             oident *prefformat;
1313             oid_value form;
1314
1315             if (!(prefformat = oid_getentbyoid(req->preferredRecordSyntax)) ||
1316                 prefformat->oclass != CLASS_RECSYN)
1317                 form = VAL_NONE;
1318             else
1319                 form = prefformat->value;
1320             resp->records = pack_records(assoc, req->resultSetName, 1,
1321                 toget, compp, next, presst, form);
1322             if (!resp->records)
1323                 return 0;
1324             resp->numberOfRecordsReturned = toget;
1325             resp->nextResultSetPosition = next;
1326             resp->searchStatus = sr;
1327             resp->resultSetStatus = 0;
1328             resp->presentStatus = presst;
1329         }
1330         else
1331         {
1332             if (*resp->resultCount)
1333                 *next = 1;
1334             resp->numberOfRecordsReturned = nulint;
1335             resp->nextResultSetPosition = next;
1336             resp->searchStatus = sr;
1337             resp->resultSetStatus = 0;
1338             resp->presentStatus = 0;
1339         }
1340     }
1341     return apdu;
1342 }
1343
1344 /*
1345  * Maybe we got a little over-friendly when we designed bend_fetch to
1346  * get only one record at a time. Some backends can optimise multiple-record
1347  * fetches, and at any rate, there is some overhead involved in
1348  * all that selecting and hopping around. Problem is, of course, that the
1349  * frontend can't know ahead of time how many records it'll need to
1350  * fill the negotiated PDU size. Annoying. Segmentation or not, Z/SR
1351  * is downright lousy as a bulk data transfer protocol.
1352  *
1353  * To start with, we'll do the fetching of records from the backend
1354  * in one operation: To save some trips in and out of the event-handler,
1355  * and to simplify the interface to pack_records. At any rate, asynch
1356  * operation is more fun in operations that have an unpredictable execution
1357  * speed - which is normally more true for search than for present.
1358  */
1359 static Z_APDU *process_presentRequest(association *assoc, request *reqb,
1360     int *fd)
1361 {
1362     Z_PresentRequest *req = reqb->request->u.presentRequest;
1363     oident *prefformat;
1364     oid_value form;
1365     Z_APDU *apdu;
1366     Z_PresentResponse *resp;
1367     int *presst;
1368     int *next;
1369     int *num;
1370
1371     logf(LOG_LOG, "Got PresentRequest.");
1372
1373     if (!(prefformat = oid_getentbyoid(req->preferredRecordSyntax)) ||
1374         prefformat->oclass != CLASS_RECSYN)
1375         form = VAL_NONE;
1376     else
1377         form = prefformat->value;
1378     if (assoc->bend_present)
1379     {
1380         bend_present_rr *bprr = (bend_present_rr *)nmem_malloc (reqb->request_mem, sizeof(*bprr));
1381         bprr->setname = req->resultSetId;
1382         bprr->start = *req->resultSetStartPoint;
1383         bprr->number = *req->numberOfRecordsRequested;
1384         bprr->format = form;
1385         bprr->comp = req->recordComposition;
1386         bprr->stream = assoc->encode;
1387         bprr->request = reqb;
1388         bprr->association = assoc;
1389         bprr->errcode = 0;
1390         bprr->errstring = NULL;
1391         ((int (*)(void *, bend_present_rr *))(*assoc->bend_present))(assoc->backend, bprr);
1392
1393         if (!bprr->request)
1394             return 0;
1395     }
1396     apdu = (Z_APDU *)odr_malloc (assoc->encode, sizeof(*apdu));
1397     resp = (Z_PresentResponse *)odr_malloc (assoc->encode, sizeof(*resp));
1398     presst = (int *)odr_malloc (assoc->encode, sizeof(*presst));
1399     next = (int *)odr_malloc (assoc->encode, sizeof(*next));
1400     num = (int *)odr_malloc (assoc->encode, sizeof(*num));
1401     *presst = 0;
1402     *next = 0;
1403     *num = *req->numberOfRecordsRequested;
1404
1405     apdu->which = Z_APDU_presentResponse;
1406     apdu->u.presentResponse = resp;
1407     resp->referenceId = req->referenceId;
1408     resp->otherInfo = 0;
1409
1410     resp->records =
1411         pack_records(assoc, req->resultSetId, *req->resultSetStartPoint,
1412                      num, req->recordComposition, next, presst, form);
1413     if (!resp->records)
1414         return 0;
1415     resp->numberOfRecordsReturned = num;
1416     resp->presentStatus = presst;
1417     resp->nextResultSetPosition = next;
1418
1419     return apdu;
1420 }
1421
1422 /*
1423  * Scan was implemented rather in a hurry, and with support for only the basic
1424  * elements of the service in the backend API. Suggestions are welcome.
1425  */
1426 static Z_APDU *process_scanRequest(association *assoc, request *reqb, int *fd)
1427 {
1428     Z_ScanRequest *req = reqb->request->u.scanRequest;
1429     Z_APDU *apdu = (Z_APDU *)odr_malloc (assoc->encode, sizeof(*apdu));
1430     Z_ScanResponse *res = (Z_ScanResponse *)odr_malloc (assoc->encode, sizeof(*res));
1431     int *scanStatus = (int *)odr_malloc (assoc->encode, sizeof(*scanStatus));
1432     int *numberOfEntriesReturned =
1433          (int *)odr_malloc (assoc->encode, sizeof(*numberOfEntriesReturned));
1434     Z_ListEntries *ents = (Z_ListEntries *)odr_malloc (assoc->encode, sizeof(*ents));
1435     Z_DiagRecs *diagrecs_p = NULL;
1436     oident *attent;
1437     bend_scanrequest srq;
1438     bend_scanresult *srs;
1439     oident *attset;
1440
1441     logf(LOG_LOG, "Got ScanRequest");
1442     *scanStatus = Z_Scan_failure;
1443     *numberOfEntriesReturned = 0;
1444
1445     apdu->which = Z_APDU_scanResponse;
1446     apdu->u.scanResponse = res;
1447     res->referenceId = req->referenceId;
1448     res->stepSize = 0;
1449     res->scanStatus = scanStatus;
1450     res->numberOfEntriesReturned = numberOfEntriesReturned;
1451     res->positionOfTerm = 0;
1452     res->entries = ents;
1453     ents->num_entries = 0;
1454     ents->entries = NULL;
1455     ents->num_nonsurrogateDiagnostics = 0;
1456     ents->nonsurrogateDiagnostics = NULL;
1457     res->attributeSet = 0;
1458     res->otherInfo = 0;
1459
1460     if (req->attributeSet && (!(attent = oid_getentbyoid(req->attributeSet)) ||
1461                               attent->oclass != CLASS_ATTSET
1462                               || attent->value != VAL_BIB1))
1463         diagrecs_p = diagrecs(assoc, 121, 0);
1464     else if (req->stepSize && *req->stepSize > 0)
1465         diagrecs_p = diagrecs(assoc, 205, 0);
1466     else
1467     {
1468         if (req->termListAndStartPoint->term->which == Z_Term_general)
1469             logf(LOG_DEBUG, " term: '%.*s'",
1470                  req->termListAndStartPoint->term->u.general->len,
1471                  req->termListAndStartPoint->term->u.general->buf);
1472         srq.num_bases = req->num_databaseNames;
1473         srq.basenames = req->databaseNames;
1474         srq.num_entries = *req->numberOfTermsRequested;
1475         srq.term = req->termListAndStartPoint;
1476         srq.stream = assoc->encode;
1477         if (!(attset = oid_getentbyoid(req->attributeSet)) ||
1478             attset->oclass != CLASS_RECSYN)
1479             srq.attributeset = VAL_NONE;
1480         else
1481             srq.attributeset = attset->value;
1482         srq.term_position = req->preferredPositionInResponse ?
1483             *req->preferredPositionInResponse : 1;
1484         if (!(srs = bend_scan(assoc->backend, &srq, 0)))
1485             diagrecs_p = diagrecs(assoc, 2, 0);
1486         else if (srs->errcode)
1487             diagrecs_p = diagrecs(assoc, srs->errcode, srs->errstring);
1488         else
1489         {
1490             int i;
1491             Z_Entry **tab = (Z_Entry **)
1492                 odr_malloc (assoc->encode, sizeof(*tab) * srs->num_entries);
1493
1494             if (srs->status == BEND_SCAN_PARTIAL)
1495                 *scanStatus = Z_Scan_partial_5;
1496             else
1497                 *scanStatus = Z_Scan_success;
1498             ents->entries = tab;
1499             ents->num_entries = srs->num_entries;
1500             res->numberOfEntriesReturned = &ents->num_entries;
1501             res->positionOfTerm = &srs->term_position;
1502             for (i = 0; i < srs->num_entries; i++)
1503             {
1504                 Z_Entry *e;
1505                 Z_TermInfo *t;
1506                 Odr_oct *o;
1507
1508                 tab[i] = e = (Z_Entry *)odr_malloc(assoc->encode, sizeof(*e));
1509                 if (srs->entries[i].occurrences >= 0)
1510                 {
1511                     e->which = Z_Entry_termInfo;
1512                     e->u.termInfo = t = (Z_TermInfo *)
1513                         odr_malloc(assoc->encode, sizeof(*t));
1514                     t->suggestedAttributes = 0;
1515                     t->displayTerm = 0;
1516                     t->alternativeTerm = 0;
1517                     t->byAttributes = 0;
1518                     t->otherTermInfo = 0;
1519                     t->globalOccurrences = &srs->entries[i].occurrences;
1520                     t->term = (Z_Term *)
1521                         odr_malloc(assoc->encode, sizeof(*t->term));
1522                     t->term->which = Z_Term_general;
1523                     t->term->u.general = o =
1524                         (Odr_oct *)odr_malloc(assoc->encode, sizeof(Odr_oct));
1525                     o->buf = (unsigned char *)
1526                         odr_malloc(assoc->encode, o->len = o->size =
1527                                    strlen(srs->entries[i].term));
1528                     memcpy(o->buf, srs->entries[i].term, o->len);
1529                     logf(LOG_DEBUG, "  term #%d: '%s' (%d)", i,
1530                          srs->entries[i].term, srs->entries[i].occurrences);
1531                 }
1532                 else
1533                 {
1534                     Z_Records *zrecords = diagrec (assoc,
1535                                                    srs->entries[i].errcode,
1536                                                    srs->entries[i].errstring);
1537                     logf(LOG_DEBUG, "  term sd code=%d addinfo=%s",
1538                          srs->entries[i].errcode,
1539                          (srs->entries[i].errstring?srs->entries[i].errstring :
1540                           "<null>"));
1541                     assert (zrecords->which == Z_Records_NSD);
1542                     e->which = Z_Entry_surrogateDiagnostic;
1543                     e->u.surrogateDiagnostic =
1544                         zrecords->u.nonSurrogateDiagnostic;
1545                 }
1546             }
1547         }
1548     }
1549     if (diagrecs_p)
1550     {
1551         ents->num_nonsurrogateDiagnostics = diagrecs_p->num_diagRecs;
1552         ents->nonsurrogateDiagnostics = diagrecs_p->diagRecs;
1553     }
1554     return apdu;
1555 }
1556
1557 static Z_APDU *process_sortRequest(association *assoc, request *reqb,
1558     int *fd)
1559 {
1560     Z_SortRequest *req = reqb->request->u.sortRequest;
1561     Z_SortResponse *res = (Z_SortResponse *)odr_malloc (assoc->encode, sizeof(*res));
1562     bend_sort_rr *bsrr = (bend_sort_rr *)odr_malloc (assoc->encode, sizeof(*bsrr));
1563
1564     Z_APDU *apdu = (Z_APDU *)odr_malloc (assoc->encode, sizeof(*apdu));
1565
1566     logf(LOG_LOG, "Got SortRequest.");
1567
1568 #ifdef ASN_COMPILED
1569     bsrr->num_input_setnames = req->num_inputResultSetNames;
1570     bsrr->input_setnames = req->inputResultSetNames;
1571 #else
1572     bsrr->num_input_setnames = req->inputResultSetNames->num_strings;
1573     bsrr->input_setnames = req->inputResultSetNames->strings;
1574 #endif
1575     bsrr->output_setname = req->sortedResultSetName;
1576     bsrr->sort_sequence = req->sortSequence;
1577     bsrr->stream = assoc->encode;
1578
1579     bsrr->sort_status = Z_SortStatus_failure;
1580     bsrr->errcode = 0;
1581     bsrr->errstring = 0;
1582
1583     ((int (*)(void *, bend_sort_rr *))(*assoc->bend_sort))(assoc->backend, bsrr);
1584
1585     res->referenceId = req->referenceId;
1586     res->sortStatus = (int *)odr_malloc (assoc->encode, sizeof(*res->sortStatus));
1587     *res->sortStatus = bsrr->sort_status;
1588     res->resultSetStatus = 0;
1589     if (bsrr->errcode)
1590     {
1591         Z_DiagRecs *dr = diagrecs (assoc, bsrr->errcode, bsrr->errstring);
1592 #ifdef ASN_COMPILED
1593         res->diagnostics = dr->diagRecs;
1594         res->num_diagnostics = dr->num_diagRecs;
1595 #else
1596         res->diagnostics = dr;
1597 #endif
1598     }
1599     else
1600     {
1601 #ifdef ASN_COMPILED
1602         res->num_diagnostics = 0;
1603 #endif
1604         res->diagnostics = 0;
1605     }
1606     res->otherInfo = 0;
1607
1608     apdu->which = Z_APDU_sortResponse;
1609     apdu->u.sortResponse = res;
1610     return apdu;
1611 }
1612
1613 static Z_APDU *process_deleteRequest(association *assoc, request *reqb,
1614     int *fd)
1615 {
1616     Z_DeleteResultSetRequest *req = reqb->request->u.deleteResultSetRequest;
1617     Z_DeleteResultSetResponse *res = (Z_DeleteResultSetResponse *)
1618         odr_malloc (assoc->encode, sizeof(*res));
1619     bend_delete_rr *bdrr = (bend_delete_rr *)
1620         odr_malloc (assoc->encode, sizeof(*bdrr));
1621     Z_APDU *apdu = (Z_APDU *)odr_malloc (assoc->encode, sizeof(*apdu));
1622
1623     logf(LOG_LOG, "Got DeleteRequest.");
1624
1625     bdrr->num_setnames = req->num_resultSetList;
1626     bdrr->setnames = req->resultSetList;
1627     bdrr->stream = assoc->encode;
1628     bdrr->function = *req->deleteFunction;
1629
1630     ((int (*)(void *, bend_delete_rr *))
1631      (*assoc->bend_delete))(assoc->backend, bdrr);
1632
1633     res->referenceId = req->referenceId;
1634
1635     res->deleteOperationStatus = (int *)
1636         odr_malloc (assoc->encode, sizeof(*res->deleteOperationStatus));
1637     *res->deleteOperationStatus = bdrr->delete_status;
1638
1639     res->deleteListStatuses = 0;
1640     res->numberNotDeleted = 0;
1641     res->bulkStatuses = 0;
1642     res->deleteMessage = 0;
1643     res->otherInfo = 0;
1644
1645     apdu->which = Z_APDU_deleteResultSetResponse;
1646     apdu->u.deleteResultSetResponse = res;
1647     return apdu;
1648 }
1649
1650 static void process_close(association *assoc, request *reqb)
1651 {
1652     Z_Close *req = reqb->request->u.close;
1653     static char *reasons[] =
1654     {
1655         "finished",
1656         "shutdown",
1657         "systemProblem",
1658         "costLimit",
1659         "resources",
1660         "securityViolation",
1661         "protocolError",
1662         "lackOfActivity",
1663         "peerAbort",
1664         "unspecified"
1665     };
1666
1667     logf(LOG_LOG, "Got Close, reason %s, message %s",
1668         reasons[*req->closeReason], req->diagnosticInformation ?
1669         req->diagnosticInformation : "NULL");
1670     if (assoc->version < 3) /* to make do_force respond with close */
1671         assoc->version = 3;
1672     do_close_req(assoc, Z_Close_finished, "Association terminated by client",
1673                  reqb);
1674 }
1675
1676 void save_referenceId (request *reqb, Z_ReferenceId *refid)
1677 {
1678     if (refid)
1679     {
1680         reqb->len_refid = refid->len;
1681         reqb->refid = (char *)nmem_malloc (reqb->request_mem, refid->len);
1682         memcpy (reqb->refid, refid->buf, refid->len);
1683     }
1684     else
1685     {
1686         reqb->len_refid = 0;
1687         reqb->refid = NULL;
1688     }
1689 }
1690
1691 void bend_request_send (bend_association a, bend_request req, Z_APDU *res)
1692 {
1693     process_response (a, req, res);
1694 }
1695
1696 bend_request bend_request_mk (bend_association a)
1697 {
1698     request *nreq = request_get (&a->outgoing);
1699     nreq->request_mem = nmem_create ();
1700     return nreq;
1701 }
1702
1703 Z_ReferenceId *bend_request_getid (ODR odr, bend_request req)
1704 {
1705     Z_ReferenceId *id;
1706     if (!req->refid)
1707         return 0;
1708     id = (Odr_oct *)odr_malloc (odr, sizeof(*odr));
1709     id->buf = (unsigned char *)odr_malloc (odr, req->len_refid);
1710     id->len = id->size = req->len_refid;
1711     memcpy (id->buf, req->refid, req->len_refid);
1712     return id;
1713 }
1714
1715 void bend_request_destroy (bend_request *req)
1716 {
1717     nmem_destroy((*req)->request_mem);
1718     request_release(*req);
1719     *req = NULL;
1720 }
1721
1722 int bend_backend_respond (bend_association a, bend_request req)
1723 {
1724     return process_request (a, req);
1725 }
1726
1727 void bend_request_setdata(bend_request r, void *p)
1728 {
1729     r->clientData = p;
1730 }
1731
1732 void *bend_request_getdata(bend_request r)
1733 {
1734     return r->clientData;
1735 }
1736
1737 /* Chas: Added in from DALI */
1738 static Z_APDU *process_ESRequest(association *assoc, request *reqb, int *fd)
1739 {
1740     bend_esrequest_rr esrequest;
1741
1742     Z_ExtendedServicesRequest *req = reqb->request->u.extendedServicesRequest;
1743     Z_APDU *apdu = zget_APDU(assoc->encode, Z_APDU_extendedServicesResponse);
1744
1745     Z_ExtendedServicesResponse *resp = apdu->u.extendedServicesResponse;
1746
1747     logf(LOG_DEBUG,"inside Process esRequest");
1748
1749     esrequest.esr = reqb->request->u.extendedServicesRequest;
1750     esrequest.stream = assoc->encode;
1751     esrequest.errcode = 0;
1752     esrequest.errstring = NULL;
1753     esrequest.request = reqb;
1754     esrequest.association = assoc;
1755
1756     ((int (*)(void *, bend_esrequest_rr *))(*assoc->bend_esrequest))(assoc->backend,
1757                                                                    &esrequest);
1758
1759     /* If the response is being delayed, return NULL */
1760     if (esrequest.request == NULL)
1761         return(NULL);
1762
1763     resp->referenceId = req->referenceId;
1764
1765     if ( esrequest.errcode == 0 )
1766     {
1767         /* Backend service indicates request will be processed */
1768         logf(LOG_DEBUG,"Request will be processed...Good !");
1769         *resp->operationStatus = Z_ExtendedServicesResponse_done;
1770     }
1771     else
1772     {
1773         /* Backend indicates error, request will not be processed */
1774         logf(LOG_DEBUG,"Request will not be processed...BAD !");
1775         *resp->operationStatus = Z_ExtendedServicesResponse_failure;
1776     }
1777     /* Do something with the members of bend_extendedservice */
1778
1779     logf(LOG_DEBUG,"Send the result apdu");
1780
1781     return apdu;
1782 }
1783
1784 /* Chas: End of addition from DALI */