client/client.c

   1 /*
   2  * Copyright (c) 1995-2001, Index Data
   3  * See the file LICENSE for details.
   4  *
   5  * $Log: client.c,v $
   6  * Revision 1.120  2001-04-06 12:26:46  adam
   7  * Optional CCL module. Moved atoi_n to marcdisp.h from yaz-util.h.
   8  *
   9  * Revision 1.119  2001/04/05 13:08:48  adam
  10  * New configure options: --enable-module.
  11  *
  12  * Revision 1.118  2001/03/27 14:48:06  adam
  13  * Fixed scan for bad CCL.
  14  *
  15  * Revision 1.117  2001/03/25 21:55:12  adam
  16  * Added odr_intdup. Ztest server returns TaskPackage for ItemUpdate.
  17  *
  18  * Revision 1.116  2001/03/21 12:43:36  adam
  19  * Implemented cs_create_host. Better error reporting for SSL comstack.
  20  *
  21  * Revision 1.115  2001/03/13 18:10:58  adam
  22  * Added option -c to set CCL config file.
  23  *
  24  * Revision 1.114  2001/02/21 13:46:53  adam
  25  * C++ fixes.
  26  *
  27  * Revision 1.113  2001/02/21 09:41:15  adam
  28  * Fixed problem with old codecs.
  29  *
  30  * Revision 1.112  2001/02/20 11:25:32  adam
  31  * Added ill_get_APDU and ill_get_Cancel.
  32  *
  33  * Revision 1.111  2001/01/30 15:52:48  ja7
  34  * added command for setting packageName in ES packages!
  35  * command is named packagename default is NULL for server suplyed package name
  36  *
  37  * Revision 1.110  2001/01/29 11:19:05  adam
  38  * Clients prints options in InitResponse.
  39  *
  40  * Revision 1.109  2001/01/22 10:41:47  adam
  41  * Multiple attribute may be specified for sorging.
  42  *
  43  * Revision 1.108  2000/11/23 10:58:32  adam
  44  * SSL comstack support. Separate POSIX thread support library.
  45  *
  46  * Revision 1.107  2000/11/16 13:11:07  adam
  47  * Changed because ccl_rpn_query sets attribute set.
  48  *
  49  * Revision 1.106  2000/11/13 09:44:59  adam
  50  * Work on SCAN: RPN2CCL conversion and proper "next" scan.
  51  *
  52  * Revision 1.105  2000/10/02 11:07:44  adam
  53  * Added peer_name member for bend_init handler. Changed the YAZ
  54  * client so that tcp: can be avoided in target spec.
  55  *
  56  * Revision 1.104  2000/09/04 08:58:15  adam
  57  * Added prefix yaz_ for most logging utility functions.
  58  *
  59  * Revision 1.103  2000/08/10 08:41:26  adam
  60  * Fixes for ILL.
  61  *
  62  * Revision 1.102  2000/05/18 11:57:04  adam
  63  * Client display time elapsed.
  64  *
  65  * Revision 1.101  2000/04/05 07:39:54  adam
  66  * Added shared library support (libtool).
  67  *
  68  * Revision 1.100  2000/03/20 19:29:59  adam
  69  * Minor change.
  70  *
  71  * Revision 1.99  2000/03/20 19:06:25  adam
  72  * Added Segment request for fronend server. Work on admin for client.
  73  *
  74  * Revision 1.98  2000/03/16 13:55:49  ian
  75  * Added commands for sending shutdown and startup admin requests via the admin ES.
  76  *
  77  * Revision 1.97  2000/03/14 14:06:04  ian
  78  * Minor change to order of debugging output for send_apdu,
  79  * fixed encoding of admin request.
  80  *
  81  * Revision 1.96  2000/03/14 09:27:07  ian
  82  * Added code to enable sending of admin extended service requests
  83  *
  84  * Revision 1.95  2000/02/28 11:20:05  adam
  85  * Using autoconf. New definitions: YAZ_BEGIN_CDECL/YAZ_END_CDECL.
  86  *
  87  * Revision 1.94  2000/01/31 13:15:21  adam
  88  * Removed uses of assert(3). Cleanup of ODR. CCL parser update so
  89  * that some characters are not surrounded by spaces in resulting term.
  90  * ILL-code updates.
  91  *
  92  * Revision 1.93  2000/01/15 09:39:50  adam
  93  * Implemented ill_get_ILLRequest. More ILL testing for client.
  94  *
  95  * Revision 1.92  1999/12/21 16:24:48  adam
  96  * More robust ISO2709 handling (in case of real bad formats).
  97  *
  98  * Revision 1.91  1999/12/16 23:36:19  adam
  99  * Implemented ILL protocol. Minor updates ASN.1 compiler.
 100  *
 101  * Revision 1.90  1999/11/30 13:47:11  adam
 102  * Improved installation. Moved header files to include/yaz.
 103  *
 104  * Revision 1.89  1999/11/04 14:58:44  adam
 105  * Added status elements for backend delete result set handler.
 106  * Updated delete result result set command for client.
 107  *
 108  * Revision 1.88  1999/10/11 10:00:29  adam
 109  * Modified printing of records.
 110  *
 111  * Revision 1.87  1999/08/27 09:40:32  adam
 112  * Renamed logf function to yaz_log. Removed VC++ project files.
 113  *
 114  * Revision 1.86  1999/07/06 12:13:35  adam
 115  * Added "schema" command.
 116  *
 117  * Revision 1.85  1999/06/16 11:55:24  adam
 118  * Added APDU log to client.
 119  *
 120  * Revision 1.84  1999/06/01 14:29:11  adam
 121  * Work on Extended Services.
 122  *
 123  * Revision 1.83  1999/05/26 15:24:26  adam
 124  * Fixed minor bugs regarding DB Update (introduced by previous commit).
 125  *
 126  * Revision 1.82  1999/05/26 13:49:12  adam
 127  * DB Update implemented in client (very basic).
 128  *
 129  * Revision 1.81  1999/04/20 09:56:48  adam
 130  * Added 'name' paramter to encoder/decoder routines (typedef Odr_fun).
 131  * Modified all encoders/decoders to reflect this change.
 132  *
 133  * Revision 1.80  1999/03/31 11:18:24  adam
 134  * Implemented odr_strdup. Added Reference ID to backend server API.
 135  *
 136  * Revision 1.79  1999/03/23 14:14:25  adam
 137  * Yet another fix.
 138  *
 139  * Revision 1.78  1999/03/18 12:57:18  adam
 140  * Minor fix.
 141  *
 142  * Revision 1.77  1999/03/11 15:26:51  adam
 143  * Fixed bug (introduced by previous commit).
 144  *
 145  * Revision 1.76  1999/03/11 11:12:07  adam
 146  * Added GNU readline support. HTML display in client.
 147  *
 148  * Revision 1.75  1999/02/01 15:37:32  adam
 149  * Fixed minor bug introduced by previous commit.
 150  *
 151  * Revision 1.74  1999/02/01 15:35:21  adam
 152  * Added XML display.
 153  *
 154  * Revision 1.73  1998/10/20 13:55:43  quinn
 155  * Fixed Scan bug in asn and client
 156  *
 157  * Revision 1.72  1998/10/20 13:23:15  quinn
 158  * changed preferred pos to 1
 159  *
 160  * Revision 1.71  1998/10/20 13:21:43  adam
 161  * Fixed scan response handler.
 162  *
 163  * Revision 1.70  1998/09/22 09:40:37  adam
 164  * Minor changes in sort spec.
 165  *
 166  * Revision 1.69  1998/08/19 16:10:06  adam
 167  * Changed som member names of DeleteResultSetRequest/Response.
 168  *
 169  * Revision 1.68  1998/07/20 12:37:06  adam
 170  * Added 'delete <resultset>' command. Changed open command so that
 171  * it reconnects if already connected.
 172  *
 173  * Revision 1.67  1998/06/09 13:55:06  adam
 174  * Minor changes.
 175  *
 176  * Revision 1.66  1998/05/18 13:06:53  adam
 177  * Changed the way attribute sets are handled by the retriaval module.
 178  * Extended Explain conversion / schema.
 179  * Modified server and client to work with ASN.1 compiled protocol handlers.
 180  *
 181  * Revision 1.65  1998/03/31 15:13:19  adam
 182  * Development towards compiled ASN.1.
 183  *
 184  * Revision 1.64  1998/03/31 11:07:44  adam
 185  * Furhter work on UNIverse resource report.
 186  * Added Extended Services handling in frontend server.
 187  *
 188  * Revision 1.63  1998/03/05 08:05:10  adam
 189  * Added a few casts to make C++ happy.
 190  *
 191  * Revision 1.62  1998/02/11 11:53:33  adam
 192  * Changed code so that it compiles as C++.
 193  *
 194  * Revision 1.61  1998/02/10 11:03:06  adam
 195  * Implemented command refid. Client prints reference-ID's, when present,
 196  * in responses.
 197  *
 198  * Revision 1.60  1998/01/29 14:08:52  adam
 199  * Better sort diagnostics.
 200  *
 201  * Revision 1.59  1998/01/29 13:17:56  adam
 202  * Added sort.
 203  *
 204  * Revision 1.58  1998/01/07 13:51:45  adam
 205  * Minor change.
 206  *
 207  * Revision 1.57  1998/01/07 12:58:22  adam
 208  * Using fgets instead of gets.
 209  *
 210  * Revision 1.56  1997/11/05 09:18:31  adam
 211  * The client handles records with no associated syntax.
 212  *
 213  * Revision 1.55  1997/10/31 12:20:08  adam
 214  * Improved memory debugging for xmalloc/nmem.c. References to NMEM
 215  * instead of ODR in n ESPEC-1 handling in source d1_espec.c.
 216  * Bug fix: missing fclose in data1_read_espec1.
 217  *
 218  * Revision 1.54  1997/10/27 13:52:46  adam
 219  * Header yaz-util includes all YAZ utility header files.
 220  *
 221  * Revision 1.53  1997/09/29 13:18:59  adam
 222  * Added function, oid_ent_to_oid, to replace the function
 223  * oid_getoidbyent, which is not thread safe.
 224  *
 225  * Revision 1.52  1997/09/29 07:20:31  adam
 226  * Client code uses nmem_init.
 227  *
 228  * Revision 1.51  1997/09/26 09:41:55  adam
 229  * Updated client to handle multiple diagnostics.
 230  *
 231  * Revision 1.50  1997/09/17 12:10:29  adam
 232  * YAZ version 1.4.
 233  *
 234  * Revision 1.49  1997/09/04 13:45:17  adam
 235  * Added UNImarc to list of available syntaxes.
 236  *
 237  * Revision 1.48  1997/09/01 08:48:44  adam
 238  * New windows NT/95 port using MSV5.0. Only a few changes made
 239  * to avoid warnings. Sub project created: client.dsp.
 240  *
 241  * Revision 1.47  1997/07/01 13:49:56  adam
 242  * Take care of case when invalid target is specified on command line.
 243  *
 244  * Revision 1.46  1997/06/23 10:30:18  adam
 245  * Added call to ccl_rpn_delete in search. Added ODR stream "out"
 246  * as parameter to ccl_rpn_query to release RPN query.
 247  *
 248  * Revision 1.45  1997/05/14 06:53:29  adam
 249  * C++ support.
 250  *
 251  * Revision 1.44  1997/05/05 11:20:35  adam
 252  * Client uses "options" utility and marc dump filename may be specified
 253  * as an option (-m <file>).
 254  *
 255  * Revision 1.43  1996/11/08 11:03:26  adam
 256  * Client accepts multiple database names.
 257  *
 258  * Revision 1.42  1996/10/08 10:44:57  quinn
 259  * Resolved conflicts.
 260  *
 261  * Revision 1.41  1996/10/07  15:29:03  quinn
 262  * Work
 263  *
 264  * Revision 1.40  1996/08/29  14:19:34  quinn
 265  * Fixed conflict (CVS)
 266  *
 267  * Revision 1.39  1996/08/27  10:43:22  quinn
 268  * Made select() optional
 269  *
 270  * Revision 1.38  1996/08/12  14:09:11  adam
 271  * Default prefix query attribute set defined by using p_query_attset.
 272  *
 273  * Revision 1.37  1996/07/06  19:58:29  quinn
 274  * System headerfiles gathered in yconfig
 275  *
 276  * Revision 1.36  1996/06/10  08:53:47  quinn
 277  * Added Summary
 278  *
 279  * Revision 1.35  1996/06/03  09:45:50  quinn
 280  * Added display of OIDs in the GRS routine.
 281  *
 282  * Revision 1.34  1996/05/09  07:26:49  quinn
 283  * *** empty log message ***
 284  *
 285  * Revision 1.33  1996/05/09  07:25:22  quinn
 286  * Small
 287  *
 288  * Revision 1.32  1996/03/15  11:05:33  adam
 289  * The user can set the preferred query type (prefix, ccl, ..) with the
 290  * querytype command.
 291  *
 292  * Revision 1.31  1996/02/20  12:51:54  quinn
 293  * Fixed problems with EXTERNAL.
 294  *
 295  * Revision 1.30  1996/02/12  18:18:09  quinn
 296  * Fidgeting.
 297  *
 298  * Revision 1.29  1996/01/02  08:57:25  quinn
 299  * Changed enums in the ASN.1 .h files to #defines. Changed oident.class to oclass
 300  *
 301  * Revision 1.28  1995/12/14  11:09:31  quinn
 302  * Added Explain record syntax to the format command.
 303  *
 304  * Revision 1.27  1995/12/12  16:37:02  quinn
 305  * Added destroy element to data1_node.
 306  *
 307  * Revision 1.26  1995/12/12  14:11:00  quinn
 308  * Minimal.
 309  *
 310  * Revision 1.25  1995/11/13  09:27:22  quinn
 311  * Fiddling with the variant stuff.
 312  *
 313  * Revision 1.24  1995/10/30  12:41:13  quinn
 314  * Added hostname lookup for server.
 315  *
 316  * Revision 1.23  1995/10/18  16:12:30  quinn
 317  * Better diagnostics.
 318  *
 319  * Revision 1.22  1995/10/11  14:49:12  quinn
 320  * Smallish.
 321  *
 322  * Revision 1.21  1995/09/29  17:01:47  quinn
 323  * More Windows work
 324  *
 325  * Revision 1.20  1995/08/29  14:24:13  quinn
 326  * Added second half of close-handshake
 327  *
 328  * Revision 1.19  1995/08/29  11:17:28  quinn
 329  * Added code to receive close
 330  *
 331  * Revision 1.18  1995/08/28  12:21:27  quinn
 332  * Client can now ask for simple element set names.
 333  *
 334  * Revision 1.17  1995/08/17  12:45:02  quinn
 335  * Fixed minor problems with GRS-1. Added support in c&s.
 336  *
 337  * Revision 1.16  1995/08/15  12:00:04  quinn
 338  * Updated External
 339  *
 340  * Revision 1.15  1995/06/22  09:28:03  quinn
 341  * Fixed bug in SUTRS processing.
 342  *
 343  * Revision 1.14  1995/06/19  12:37:41  quinn
 344  * Added BER dumper.
 345  *
 346  * Revision 1.13  1995/06/16  10:29:11  quinn
 347  * *** empty log message ***
 348  *
 349  * Revision 1.12  1995/06/15  07:44:57  quinn
 350  * Moving to v3.
 351  *
 352  * Revision 1.11  1995/06/14  15:26:40  quinn
 353  * *** empty log message ***
 354  *
 355  * Revision 1.10  1995/06/06  14:56:58  quinn
 356  * Better diagnostics.
 357  *
 358  * Revision 1.9  1995/06/06  08:15:19  quinn
 359  * Cosmetic.
 360  *
 361  * Revision 1.8  1995/06/05  10:52:22  quinn
 362  * Added SCAN.
 363  *
 364  * Revision 1.7  1995/06/02  09:50:09  quinn
 365  * Smallish.
 366  *
 367  * Revision 1.6  1995/05/31  08:29:21  quinn
 368  * Nothing significant.
 369  *
 370  * Revision 1.5  1995/05/29  08:10:47  quinn
 371  * Moved oid.c to util.
 372  *
 373  * Revision 1.4  1995/05/22  15:30:13  adam
 374  * Client uses prefix query notation.
 375  *
 376  * Revision 1.3  1995/05/22  15:06:53  quinn
 377  * *** empty log message ***
 378  *
 379  * Revision 1.2  1995/05/22  14:56:40  quinn
 380  * *** empty log message ***
 381  *
 382  * Revision 1.1  1995/05/22  11:30:31  quinn
 383  * Added prettier client.
 384  *
 385  *
 386  */
 387
 388 /*
 389  * This is the obligatory little toy client, whose primary purpose is
 390  * to illustrate the use of the YAZ service-level API.
 391  */
 392
 393 #include <stdio.h>
 394 #include <stdlib.h>
 395 #include <time.h>
 396
 397 #include <yaz/yaz-util.h>
 398
 399 #include <yaz/tcpip.h>
 400 #ifdef USE_XTIMOSI
 401 #include <yaz/xmosi.h>
 402 #endif
 403
 404 #include <yaz/proto.h>
 405 #include <yaz/marcdisp.h>
 406 #include <yaz/diagbib1.h>
 407
 408 #include <yaz/pquery.h>
 409
 410 #if YAZ_MODULE_ill
 411 #include <yaz/ill.h>
 412 #endif
 413
 414 #if YAZ_MODULE_ccl
 415 #include <yaz/yaz-ccl.h>
 416 #endif
 417
 418 #if HAVE_READLINE_READLINE_H
 419 #include <readline/readline.h>
 420 #endif
 421 #if HAVE_READLINE_HISTORY_H
 422 #include <readline/history.h>
 423 #endif
 424
 425 #include "admin.h"
 426
 427 #define C_PROMPT "Z> "
 428
 429 static ODR out, in, print;              /* encoding and decoding streams */
 430 static FILE *apdu_file = 0;
 431 static COMSTACK conn = 0;               /* our z-association */
 432 static Z_IdAuthentication *auth = 0;    /* our current auth definition */
 433 char *databaseNames[128];
 434 int num_databaseNames = 0;
 435 static Z_External *record_last = 0;
 436 static int setnumber = 0;               /* current result set number */
 437 static int smallSetUpperBound = 0;
 438 static int largeSetLowerBound = 1;
 439 static int mediumSetPresentNumber = 0;
 440 static Z_ElementSetNames *elementSetNames = 0;
 441 static int setno = 1;                   /* current set offset */
 442 static enum oid_proto protocol = PROTO_Z3950;      /* current app protocol */
 443 static enum oid_value recordsyntax = VAL_USMARC;
 444 static enum oid_value schema = VAL_NONE;
 445 static int sent_close = 0;
 446 static NMEM session_mem = NULL;      /* memory handle for init-response */
 447 static Z_InitResponse *session = 0;     /* session parameters */
 448 static char last_scan_line[512] = "0";
 449 static char last_scan_query[512] = "0";
 450 static char ccl_fields[512] = "default.bib";
 451 static char* esPackageName = 0;
 452
 453 static char last_cmd[100] = "?";
 454 static FILE *marcdump = 0;
 455 static char *refid = NULL;
 456
 457 typedef enum {
 458     QueryType_Prefix,
 459     QueryType_CCL,
 460     QueryType_CCL2RPN
 461 } QueryType;
 462
 463 static QueryType queryType = QueryType_Prefix;
 464
 465 #if YAZ_MODULE_ccl
 466 static CCL_bibset bibset;               /* CCL bibset handle */
 467 #endif
 468
 469 ODR getODROutputStream()
 470 {
 471     return out;
 472 }
 473
 474 void send_apdu(Z_APDU *a)
 475 {
 476     char *buf;
 477     int len;
 478
 479     if (apdu_file)
 480     {
 481         z_APDU(print, &a, 0, 0);
 482         odr_reset(print);
 483     }
 484     if (!z_APDU(out, &a, 0, 0))
 485     {
 486         odr_perror(out, "Encoding APDU");
 487         exit(1);
 488     }
 489     buf = odr_getbuf(out, &len, 0);
 490     /* printf ("sending APDU of size %d\n", len); */
 491     if (cs_put(conn, buf, len) < 0)
 492     {
 493         fprintf(stderr, "cs_put: %s", cs_errmsg(cs_errno(conn)));
 494         exit(1);
 495     }
 496     odr_reset(out); /* release the APDU structure  */
 497 }
 498
 499 static void print_refid (Z_ReferenceId *id)
 500 {
 501     if (id)
 502     {
 503         printf ("ReferenceId: '%.*s'\n", id->len, id->buf);
 504     }
 505 }
 506
 507 static Z_ReferenceId *set_refid (ODR out)
 508 {
 509     Z_ReferenceId *id;
 510     if (!refid)
 511         return 0;
 512     id = (Z_ReferenceId *) odr_malloc (out, sizeof(*id));
 513     id->size = id->len = strlen(refid);
 514     id->buf = (unsigned char *) odr_malloc (out, id->len);
 515     memcpy (id->buf, refid, id->len);
 516     return id;
 517 }
 518
 519 /* INIT SERVICE ------------------------------- */
 520
 521 static void send_initRequest()
 522 {
 523     Z_APDU *apdu = zget_APDU(out, Z_APDU_initRequest);
 524     Z_InitRequest *req = apdu->u.initRequest;
 525
 526     ODR_MASK_SET(req->options, Z_Options_search);
 527     ODR_MASK_SET(req->options, Z_Options_present);
 528     ODR_MASK_SET(req->options, Z_Options_namedResultSets);
 529     ODR_MASK_SET(req->options, Z_Options_triggerResourceCtrl);
 530     ODR_MASK_SET(req->options, Z_Options_scan);
 531     ODR_MASK_SET(req->options, Z_Options_sort);
 532     ODR_MASK_SET(req->options, Z_Options_extendedServices);
 533     ODR_MASK_SET(req->options, Z_Options_delSet);
 534
 535     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_1);
 536     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_2);
 537     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_3);
 538
 539     *req->maximumRecordSize = 1024*1024;
 540     *req->preferredMessageSize = 1024*1024;
 541
 542     req->idAuthentication = auth;
 543
 544     send_apdu(apdu);
 545     printf("Sent initrequest.\n");
 546 }
 547
 548 static int process_initResponse(Z_InitResponse *res)
 549 {
 550     /* save session parameters for later use */
 551     session_mem = odr_extract_mem(in);
 552     session = res;
 553
 554     if (!*res->result)
 555         printf("Connection rejected by target.\n");
 556     else
 557         printf("Connection accepted by target.\n");
 558     if (res->implementationId)
 559         printf("ID     : %s\n", res->implementationId);
 560     if (res->implementationName)
 561         printf("Name   : %s\n", res->implementationName);
 562     if (res->implementationVersion)
 563         printf("Version: %s\n", res->implementationVersion);
 564     if (res->userInformationField)
 565     {
 566         printf("UserInformationfield:\n");
 567         if (!z_External(print, (Z_External**)&res-> userInformationField,
 568             0, 0))
 569         {
 570             odr_perror(print, "Printing userinfo\n");
 571             odr_reset(print);
 572         }
 573         if (res->userInformationField->which == Z_External_octet)
 574         {
 575             printf("Guessing visiblestring:\n");
 576             printf("'%s'\n", res->userInformationField->u. octet_aligned->buf);
 577         }
 578         odr_reset (print);
 579     }
 580     printf ("Options:");
 581     if (ODR_MASK_GET(res->options, Z_Options_search))
 582         printf (" search");
 583     if (ODR_MASK_GET(res->options, Z_Options_present))
 584         printf (" present");
 585     if (ODR_MASK_GET(res->options, Z_Options_delSet))
 586         printf (" delSet");
 587     if (ODR_MASK_GET(res->options, Z_Options_resourceReport))
 588         printf (" resourceReport");
 589     if (ODR_MASK_GET(res->options, Z_Options_resourceCtrl))
 590         printf (" resourceCtrl");
 591     if (ODR_MASK_GET(res->options, Z_Options_accessCtrl))
 592         printf (" accessCtrl");
 593     if (ODR_MASK_GET(res->options, Z_Options_scan))
 594         printf (" scan");
 595     if (ODR_MASK_GET(res->options, Z_Options_sort))
 596         printf (" sort");
 597     if (ODR_MASK_GET(res->options, Z_Options_extendedServices))
 598         printf (" extendedServices");
 599     if (ODR_MASK_GET(res->options, Z_Options_level_1Segmentation))
 600         printf (" level1Segmentation");
 601     if (ODR_MASK_GET(res->options, Z_Options_level_2Segmentation))
 602         printf (" level2Segmentation");
 603     if (ODR_MASK_GET(res->options, Z_Options_concurrentOperations))
 604         printf (" concurrentOperations");
 605     if (ODR_MASK_GET(res->options, Z_Options_namedResultSets))
 606         printf (" namedResultSets");
 607     printf ("\n");
 608     fflush (stdout);
 609     return 0;
 610 }
 611
 612 static int cmd_base(char *arg)
 613 {
 614     int i;
 615     char *cp;
 616
 617     if (!*arg)
 618     {
 619         printf("Usage: base <database> <database> ...\n");
 620         return 0;
 621     }
 622     for (i = 0; i<num_databaseNames; i++)
 623         xfree (databaseNames[i]);
 624     num_databaseNames = 0;
 625     while (1)
 626     {
 627         if (!(cp = strchr(arg, ' ')))
 628             cp = arg + strlen(arg);
 629         if (cp - arg < 1)
 630             break;
 631         databaseNames[num_databaseNames] = (char *)xmalloc (1 + cp - arg);
 632         memcpy (databaseNames[num_databaseNames], arg, cp - arg);
 633         databaseNames[num_databaseNames++][cp - arg] = '\0';
 634         if (!*cp)
 635             break;
 636         arg = cp+1;
 637     }
 638     return 1;
 639 }
 640
 641
 642 int cmd_open(char *arg)
 643 {
 644     void *add;
 645     char type_and_host[101], base[101];
 646     CS_TYPE t;
 647
 648     if (conn)
 649     {
 650         printf("Already connected.\n");
 651
 652         cs_close (conn);
 653         conn = NULL;
 654         if (session_mem)
 655         {
 656             nmem_destroy (session_mem);
 657             session_mem = NULL;
 658         }
 659     }
 660     t = tcpip_type;
 661     base[0] = '\0';
 662     if (sscanf (arg, "%100[^/]/%100s", type_and_host, base) < 1)
 663         return 0;
 664
 665     conn = cs_create_host(type_and_host, 1, &add);
 666     if (!conn)
 667     {
 668         printf ("Couldn't create comstack\n");
 669         return 0;
 670     }
 671     printf("Connecting...");
 672     fflush(stdout);
 673     if (cs_connect(conn, add) < 0)
 674     {
 675         printf ("error = %s\n", cs_strerror(conn));
 676         if (conn->cerrno == CSYSERR)
 677             perror("system");
 678         cs_close(conn);
 679         conn = 0;
 680         return 0;
 681     }
 682     printf("Ok.\n");
 683     send_initRequest();
 684     if (*base)
 685         cmd_base (base);
 686     return 2;
 687 }
 688
 689 int cmd_authentication(char *arg)
 690 {
 691     static Z_IdAuthentication au;
 692     static char open[256];
 693
 694     if (!*arg)
 695     {
 696         printf("Auth field set to null\n");
 697         auth = 0;
 698         return 1;
 699     }
 700     auth = &au;
 701     au.which = Z_IdAuthentication_open;
 702     au.u.open = open;
 703     strcpy(open, arg);
 704     return 1;
 705 }
 706
 707 /* SEARCH SERVICE ------------------------------ */
 708
 709 static void display_variant(Z_Variant *v, int level)
 710 {
 711     int i;
 712
 713     for (i = 0; i < v->num_triples; i++)
 714     {
 715         printf("%*sclass=%d,type=%d", level * 4, "", *v->triples[i]->zclass,
 716             *v->triples[i]->type);
 717         if (v->triples[i]->which == Z_Triple_internationalString)
 718             printf(",value=%s\n", v->triples[i]->value.internationalString);
 719         else
 720             printf("\n");
 721     }
 722 }
 723
 724 static void display_grs1(Z_GenericRecord *r, int level)
 725 {
 726     int i;
 727
 728     if (!r)
 729         return;
 730     for (i = 0; i < r->num_elements; i++)
 731     {
 732         Z_TaggedElement *t;
 733
 734         printf("%*s", level * 4, "");
 735         t = r->elements[i];
 736         printf("(");
 737         if (t->tagType)
 738             printf("%d,", *t->tagType);
 739         else
 740             printf("?,");
 741         if (t->tagValue->which == Z_StringOrNumeric_numeric)
 742             printf("%d) ", *t->tagValue->u.numeric);
 743         else
 744             printf("%s) ", t->tagValue->u.string);
 745         if (t->content->which == Z_ElementData_subtree)
 746         {
 747             printf("\n");
 748             display_grs1(t->content->u.subtree, level+1);
 749         }
 750         else if (t->content->which == Z_ElementData_string)
 751             printf("%s\n", t->content->u.string);
 752         else if (t->content->which == Z_ElementData_numeric)
 753             printf("%d\n", *t->content->u.numeric);
 754         else if (t->content->which == Z_ElementData_oid)
 755         {
 756             int *ip = t->content->u.oid;
 757             oident *oent;
 758
 759             if ((oent = oid_getentbyoid(t->content->u.oid)))
 760                 printf("OID: %s\n", oent->desc);
 761             else
 762             {
 763                 printf("{");
 764                 while (ip && *ip >= 0)
 765                     printf(" %d", *(ip++));
 766                 printf(" }\n");
 767             }
 768         }
 769         else if (t->content->which == Z_ElementData_noDataRequested)
 770             printf("[No data requested]\n");
 771         else if (t->content->which == Z_ElementData_elementEmpty)
 772             printf("[Element empty]\n");
 773         else if (t->content->which == Z_ElementData_elementNotThere)
 774             printf("[Element not there]\n");
 775         else
 776             printf("??????\n");
 777         if (t->appliedVariant)
 778             display_variant(t->appliedVariant, level+1);
 779         if (t->metaData && t->metaData->supportedVariants)
 780         {
 781             int c;
 782
 783             printf("%*s---- variant list\n", (level+1)*4, "");
 784             for (c = 0; c < t->metaData->num_supportedVariants; c++)
 785             {
 786                 printf("%*svariant #%d\n", (level+1)*4, "", c);
 787                 display_variant(t->metaData->supportedVariants[c], level + 2);
 788             }
 789         }
 790     }
 791 }
 792
 793 static void print_record(const unsigned char *buf, size_t len)
 794 {
 795    size_t i;
 796    for (i = 0; i<len; i++)
 797        if ((buf[i] <= 126 && buf[i] >= 32) || strchr ("\n\r\t\f", buf[i]))
 798            fputc (buf[i], stdout);
 799        else
 800            printf ("\\X%02X", buf[i]);
 801    /* add newline if not already added ... */
 802    if (i <= 0 || buf[i-1] != '\n')
 803        fputc ('\n', stdout);
 804 }
 805
 806 static void display_record(Z_DatabaseRecord *p)
 807 {
 808     Z_External *r = (Z_External*) p;
 809     oident *ent = oid_getentbyoid(r->direct_reference);
 810
 811     record_last = r;
 812     /*
 813      * Tell the user what we got.
 814      */
 815     if (r->direct_reference)
 816     {
 817         printf("Record type: ");
 818         if (ent)
 819             printf("%s\n", ent->desc);
 820         else if (!odr_oid(print, &r->direct_reference, 0, 0))
 821         {
 822             odr_perror(print, "print oid");
 823             odr_reset(print);
 824         }
 825     }
 826     /* Check if this is a known, ASN.1 type tucked away in an octet string */
 827     if (ent && r->which == Z_External_octet)
 828     {
 829         Z_ext_typeent *type = z_ext_getentbyref(ent->value);
 830         void *rr;
 831
 832         if (type)
 833         {
 834             /*
 835              * Call the given decoder to process the record.
 836              */
 837             odr_setbuf(in, (char*)p->u.octet_aligned->buf,
 838                 p->u.octet_aligned->len, 0);
 839             if (!(*type->fun)(in, (char **)&rr, 0, 0))
 840             {
 841                 odr_perror(in, "Decoding constructed record.");
 842                 fprintf(stderr, "[Near %d]\n", odr_offset(in));
 843                 fprintf(stderr, "Packet dump:\n---------\n");
 844                 odr_dumpBER(stderr, (char*)p->u.octet_aligned->buf,
 845                     p->u.octet_aligned->len);
 846                 fprintf(stderr, "---------\n");
 847                 exit(1);
 848             }
 849             /*
 850              * Note: we throw away the original, BER-encoded record here.
 851              * Do something else with it if you want to keep it.
 852              */
 853             r->u.sutrs = (Z_SUTRS *) rr; /* we don't actually check the type here. */
 854             r->which = type->what;
 855         }
 856     }
 857     if (ent && ent->value == VAL_SOIF)
 858         print_record((const unsigned char *) r->u.octet_aligned->buf, r->u.octet_aligned->len);
 859     else if (r->which == Z_External_octet && p->u.octet_aligned->len)
 860     {
 861         const char *octet_buf = (char*)p->u.octet_aligned->buf;
 862         if (ent->value == VAL_TEXT_XML || ent->value == VAL_APPLICATION_XML ||
 863             ent->value == VAL_HTML)
 864             print_record((const unsigned char *) octet_buf,
 865                          p->u.octet_aligned->len);
 866         else
 867         {
 868             if (marc_display (octet_buf, NULL) <= 0)
 869             {
 870                 printf ("ISO2709 decoding failed, dumping record as is:\n");
 871                 print_record((const unsigned char*) octet_buf,
 872                               p->u.octet_aligned->len);
 873             }
 874         }
 875         if (marcdump)
 876             fwrite (octet_buf, 1, p->u.octet_aligned->len, marcdump);
 877     }
 878     else if (ent && ent->value == VAL_SUTRS)
 879     {
 880         if (r->which != Z_External_sutrs)
 881         {
 882             printf("Expecting single SUTRS type for SUTRS.\n");
 883             return;
 884         }
 885         print_record(r->u.sutrs->buf, r->u.sutrs->len);
 886     }
 887     else if (ent && ent->value == VAL_GRS1)
 888     {
 889         if (r->which != Z_External_grs1)
 890         {
 891             printf("Expecting single GRS type for GRS.\n");
 892             return;
 893         }
 894         display_grs1(r->u.grs1, 0);
 895     }
 896     else
 897     {
 898         printf("Unknown record representation.\n");
 899         if (!z_External(print, &r, 0, 0))
 900         {
 901             odr_perror(print, "Printing external");
 902             odr_reset(print);
 903         }
 904     }
 905 }
 906
 907
 908 static void display_diagrecs(Z_DiagRec **pp, int num)
 909 {
 910     int i;
 911     oident *ent;
 912     Z_DefaultDiagFormat *r;
 913
 914     printf("Diagnostic message(s) from database:\n");
 915     for (i = 0; i<num; i++)
 916     {
 917         Z_DiagRec *p = pp[i];
 918         if (p->which != Z_DiagRec_defaultFormat)
 919         {
 920             printf("Diagnostic record not in default format.\n");
 921             return;
 922         }
 923         else
 924             r = p->u.defaultFormat;
 925         if (!(ent = oid_getentbyoid(r->diagnosticSetId)) ||
 926             ent->oclass != CLASS_DIAGSET || ent->value != VAL_BIB1)
 927             printf("Missing or unknown diagset\n");
 928         printf("    [%d] %s", *r->condition, diagbib1_str(*r->condition));
 929 #ifdef ASN_COMPILED
 930         switch (r->which)
 931         {
 932         case Z_DefaultDiagFormat_v2Addinfo:
 933             printf (" -- v2 addinfo '%s'\n", r->u.v2Addinfo);
 934             break;
 935         case Z_DefaultDiagFormat_v3Addinfo:
 936             printf (" -- v3 addinfo '%s'\n", r->u.v3Addinfo);
 937             break;
 938         }
 939 #else
 940         if (r->addinfo && *r->addinfo)
 941             printf(" -- '%s'\n", r->addinfo);
 942         else
 943             printf("\n");
 944 #endif
 945     }
 946 }
 947
 948
 949 static void display_nameplusrecord(Z_NamePlusRecord *p)
 950 {
 951     if (p->databaseName)
 952         printf("[%s]", p->databaseName);
 953     if (p->which == Z_NamePlusRecord_surrogateDiagnostic)
 954         display_diagrecs(&p->u.surrogateDiagnostic, 1);
 955     else if (p->which == Z_NamePlusRecord_databaseRecord)
 956         display_record(p->u.databaseRecord);
 957 }
 958
 959 static void display_records(Z_Records *p)
 960 {
 961     int i;
 962
 963     if (p->which == Z_Records_NSD)
 964     {
 965 #ifdef ASN_COMPILED
 966         Z_DiagRec dr, *dr_p = &dr;
 967         dr.which = Z_DiagRec_defaultFormat;
 968         dr.u.defaultFormat = p->u.nonSurrogateDiagnostic;
 969         display_diagrecs (&dr_p, 1);
 970 #else
 971         display_diagrecs (&p->u.nonSurrogateDiagnostic, 1);
 972 #endif
 973     }
 974     else if (p->which == Z_Records_multipleNSD)
 975         display_diagrecs (p->u.multipleNonSurDiagnostics->diagRecs,
 976                           p->u.multipleNonSurDiagnostics->num_diagRecs);
 977     else
 978     {
 979         printf("Records: %d\n", p->u.databaseOrSurDiagnostics->num_records);
 980         for (i = 0; i < p->u.databaseOrSurDiagnostics->num_records; i++)
 981             display_nameplusrecord(p->u.databaseOrSurDiagnostics->records[i]);
 982     }
 983 }
 984
 985 static int send_deleteResultSetRequest(char *arg)
 986 {
 987     char names[8][32];
 988     int i;
 989
 990     Z_APDU *apdu = zget_APDU(out, Z_APDU_deleteResultSetRequest);
 991     Z_DeleteResultSetRequest *req = apdu->u.deleteResultSetRequest;
 992
 993     req->referenceId = set_refid (out);
 994
 995     req->num_resultSetList =
 996         sscanf (arg, "%30s %30s %30s %30s %30s %30s %30s %30s",
 997                 names[0], names[1], names[2], names[3],
 998                 names[4], names[5], names[6], names[7]);
 999
1000     req->deleteFunction = (int *)
1001         odr_malloc (out, sizeof(*req->deleteFunction));
1002     if (req->num_resultSetList > 0)
1003     {
1004         *req->deleteFunction = Z_DeleteRequest_list;
1005         req->resultSetList = (char **)
1006             odr_malloc (out, sizeof(*req->resultSetList)*
1007                         req->num_resultSetList);
1008         for (i = 0; i<req->num_resultSetList; i++)
1009             req->resultSetList[i] = names[i];
1010     }
1011     else
1012     {
1013         *req->deleteFunction = Z_DeleteRequest_all;
1014         req->resultSetList = 0;
1015     }
1016
1017     send_apdu(apdu);
1018     printf("Sent deleteResultSetRequest.\n");
1019     return 2;
1020 }
1021
1022 static int send_searchRequest(char *arg)
1023 {
1024     Z_APDU *apdu = zget_APDU(out, Z_APDU_searchRequest);
1025     Z_SearchRequest *req = apdu->u.searchRequest;
1026     Z_Query query;
1027     int oid[OID_SIZE];
1028 #if YAZ_MODULE_ccl
1029     struct ccl_rpn_node *rpn = NULL;
1030     int error, pos;
1031 #endif
1032     char setstring[100];
1033     Z_RPNQuery *RPNquery;
1034     Odr_oct ccl_query;
1035
1036 #if YAZ_MODULE_ccl
1037     if (queryType == QueryType_CCL2RPN)
1038     {
1039         rpn = ccl_find_str(bibset, arg, &error, &pos);
1040         if (error)
1041         {
1042             printf("CCL ERROR: %s\n", ccl_err_msg(error));
1043             return 0;
1044         }
1045     }
1046 #endif
1047     req->referenceId = set_refid (out);
1048     if (!strcmp(arg, "@big")) /* strictly for troublemaking */
1049     {
1050         static unsigned char big[2100];
1051         static Odr_oct bigo;
1052
1053         /* send a very big referenceid to test transport stack etc. */
1054         memset(big, 'A', 2100);
1055         bigo.len = bigo.size = 2100;
1056         bigo.buf = big;
1057         req->referenceId = &bigo;
1058     }
1059
1060     if (setnumber >= 0)
1061     {
1062         sprintf(setstring, "%d", ++setnumber);
1063         req->resultSetName = setstring;
1064     }
1065     *req->smallSetUpperBound = smallSetUpperBound;
1066     *req->largeSetLowerBound = largeSetLowerBound;
1067     *req->mediumSetPresentNumber = mediumSetPresentNumber;
1068     if (smallSetUpperBound > 0 || (largeSetLowerBound > 1 &&
1069         mediumSetPresentNumber > 0))
1070     {
1071         oident prefsyn;
1072
1073         prefsyn.proto = protocol;
1074         prefsyn.oclass = CLASS_RECSYN;
1075         prefsyn.value = recordsyntax;
1076         req->preferredRecordSyntax =
1077             odr_oiddup(out, oid_ent_to_oid(&prefsyn, oid));
1078         req->smallSetElementSetNames =
1079             req->mediumSetElementSetNames = elementSetNames;
1080     }
1081     req->num_databaseNames = num_databaseNames;
1082     req->databaseNames = databaseNames;
1083
1084     req->query = &query;
1085
1086     switch (queryType)
1087     {
1088     case QueryType_Prefix:
1089         query.which = Z_Query_type_1;
1090         RPNquery = p_query_rpn (out, protocol, arg);
1091         if (!RPNquery)
1092         {
1093             printf("Prefix query error\n");
1094             return 0;
1095         }
1096         query.u.type_1 = RPNquery;
1097         break;
1098     case QueryType_CCL:
1099         query.which = Z_Query_type_2;
1100         query.u.type_2 = &ccl_query;
1101         ccl_query.buf = (unsigned char*) arg;
1102         ccl_query.len = strlen(arg);
1103         break;
1104 #if YAZ_MODULE_ccl
1105     case QueryType_CCL2RPN:
1106         query.which = Z_Query_type_1;
1107         RPNquery = ccl_rpn_query(out, rpn);
1108         if (!RPNquery)
1109         {
1110             printf ("Couldn't convert from CCL to RPN\n");
1111             return 0;
1112         }
1113         query.u.type_1 = RPNquery;
1114         ccl_rpn_delete (rpn);
1115         break;
1116 #endif
1117     default:
1118         printf ("Unsupported query type\n");
1119         return 0;
1120     }
1121     send_apdu(apdu);
1122     setno = 1;
1123     printf("Sent searchRequest.\n");
1124     return 2;
1125 }
1126
1127 static int process_searchResponse(Z_SearchResponse *res)
1128 {
1129     printf ("Received SearchResponse.\n");
1130     print_refid (res->referenceId);
1131     if (*res->searchStatus)
1132         printf("Search was a success.\n");
1133     else
1134         printf("Search was a bloomin' failure.\n");
1135     printf("Number of hits: %d, setno %d\n",
1136         *res->resultCount, setnumber);
1137     printf("records returned: %d\n",
1138         *res->numberOfRecordsReturned);
1139     setno += *res->numberOfRecordsReturned;
1140     if (res->records)
1141         display_records(res->records);
1142     return 0;
1143 }
1144
1145 static void print_level(int iLevel)
1146 {
1147     int i;
1148     for (i = 0; i < iLevel * 4; i++)
1149         printf(" ");
1150 }
1151
1152 static void print_int(int iLevel, const char *pTag, int *pInt)
1153 {
1154     if (pInt != NULL)
1155     {
1156         print_level(iLevel);
1157         printf("%s: %d\n", pTag, *pInt);
1158     }
1159 }
1160
1161 static void print_string(int iLevel, const char *pTag, const char *pString)
1162 {
1163     if (pString != NULL)
1164     {
1165         print_level(iLevel);
1166         printf("%s: %s\n", pTag, pString);
1167     }
1168 }
1169
1170 static void print_oid(int iLevel, const char *pTag, Odr_oid *pOid)
1171 {
1172     if (pOid != NULL)
1173     {
1174         int *pInt = pOid;
1175
1176         print_level(iLevel);
1177         printf("%s:", pTag);
1178         for (; *pInt != -1; pInt++)
1179             printf(" %d", *pInt);
1180         printf("\n");
1181     }
1182 }
1183
1184 static void print_referenceId(int iLevel, Z_ReferenceId *referenceId)
1185 {
1186     if (referenceId != NULL)
1187     {
1188         int i;
1189
1190         print_level(iLevel);
1191         printf("Ref Id (%d, %d): ", referenceId->len, referenceId->size);
1192         for (i = 0; i < referenceId->len; i++)
1193             printf("%c", referenceId->buf[i]);
1194         printf("\n");
1195     }
1196 }
1197
1198 static void print_string_or_numeric(int iLevel, const char *pTag, Z_StringOrNumeric *pStringNumeric)
1199 {
1200     if (pStringNumeric != NULL)
1201     {
1202         switch (pStringNumeric->which)
1203         {
1204             case Z_StringOrNumeric_string:
1205                 print_string(iLevel, pTag, pStringNumeric->u.string);
1206                 break;
1207
1208             case Z_StringOrNumeric_numeric:
1209                 print_int(iLevel, pTag, pStringNumeric->u.numeric);
1210                 break;
1211
1212             default:
1213                 print_level(iLevel);
1214                 printf("%s: valid type for Z_StringOrNumeric\n", pTag);
1215                 break;
1216         }
1217     }
1218 }
1219
1220 static void print_universe_report_duplicate(int iLevel, Z_UniverseReportDuplicate *pUniverseReportDuplicate)
1221 {
1222     if (pUniverseReportDuplicate != NULL)
1223     {
1224         print_level(iLevel);
1225         printf("Universe Report Duplicate: \n");
1226         iLevel++;
1227         print_string_or_numeric(iLevel, "Hit No", pUniverseReportDuplicate->hitno);
1228     }
1229 }
1230
1231 static void print_universe_report_hits(int iLevel, Z_UniverseReportHits *pUniverseReportHits)
1232 {
1233     if (pUniverseReportHits != NULL)
1234     {
1235         print_level(iLevel);
1236         printf("Universe Report Hits: \n");
1237         iLevel++;
1238         print_string_or_numeric(iLevel, "Database", pUniverseReportHits->database);
1239         print_string_or_numeric(iLevel, "Hits", pUniverseReportHits->hits);
1240     }
1241 }
1242
1243 static void print_universe_report(int iLevel, Z_UniverseReport *pUniverseReport)
1244 {
1245     if (pUniverseReport != NULL)
1246     {
1247         print_level(iLevel);
1248         printf("Universe Report: \n");
1249         iLevel++;
1250         print_int(iLevel, "Total Hits", pUniverseReport->totalHits);
1251         switch (pUniverseReport->which)
1252         {
1253             case Z_UniverseReport_databaseHits:
1254                 print_universe_report_hits(iLevel, pUniverseReport->u.databaseHits);
1255                 break;
1256
1257             case Z_UniverseReport_duplicate:
1258                 print_universe_report_duplicate(iLevel, pUniverseReport->u.duplicate);
1259                 break;
1260
1261             default:
1262                 print_level(iLevel);
1263                 printf("Type: %d\n", pUniverseReport->which);
1264                 break;
1265         }
1266     }
1267 }
1268
1269 static void print_external(int iLevel, Z_External *pExternal)
1270 {
1271     if (pExternal != NULL)
1272     {
1273         print_level(iLevel);
1274         printf("External: \n");
1275         iLevel++;
1276         print_oid(iLevel, "Direct Reference", pExternal->direct_reference);
1277         print_int(iLevel, "InDirect Reference", pExternal->indirect_reference);
1278         print_string(iLevel, "Descriptor", pExternal->descriptor);
1279         switch (pExternal->which)
1280         {
1281             case Z_External_universeReport:
1282                 print_universe_report(iLevel, pExternal->u.universeReport);
1283                 break;
1284
1285             default:
1286                 print_level(iLevel);
1287                 printf("Type: %d\n", pExternal->which);
1288                 break;
1289         }
1290     }
1291 }
1292
1293 static int process_resourceControlRequest (Z_ResourceControlRequest *req)
1294 {
1295     printf ("Received ResourceControlRequest.\n");
1296     print_referenceId(1, req->referenceId);
1297     print_int(1, "Suspended Flag", req->suspendedFlag);
1298     print_int(1, "Partial Results Available", req->partialResultsAvailable);
1299     print_int(1, "Response Required", req->responseRequired);
1300     print_int(1, "Triggered Request Flag", req->triggeredRequestFlag);
1301     print_external(1, req->resourceReport);
1302     return 0;
1303 }
1304
1305 void process_ESResponse(Z_ExtendedServicesResponse *res)
1306 {
1307     printf("process_ESResponse status=");
1308     switch (*res->operationStatus)
1309     {
1310     case Z_ExtendedServicesResponse_done:
1311         printf ("done\n");
1312         break;
1313     case Z_ExtendedServicesResponse_accepted:
1314         printf ("accepted\n");
1315         break;
1316     case Z_ExtendedServicesResponse_failure:
1317         printf ("failure\n");
1318         display_diagrecs(res->diagnostics, res->num_diagnostics);
1319         break;
1320     }
1321 }
1322
1323 #if YAZ_MODULE_ill
1324
1325 const char *get_ill_element (void *clientData, const char *element)
1326 {
1327     printf ("%s\n", element);
1328     return 0;
1329 }
1330
1331 static Z_External *create_external_itemRequest()
1332 {
1333     struct ill_get_ctl ctl;
1334     ILL_ItemRequest *req;
1335     Z_External *r = 0;
1336     int item_request_size = 0;
1337     char *item_request_buf = 0;
1338
1339     ctl.odr = out;
1340     ctl.clientData = 0;
1341     ctl.f = get_ill_element;
1342
1343     req = ill_get_ItemRequest(&ctl, "ill", 0);
1344     if (!req)
1345         printf ("ill_get_ItemRequest failed\n");
1346
1347     if (!ill_ItemRequest (out, &req, 0, 0))
1348     {
1349         if (apdu_file)
1350         {
1351             ill_ItemRequest(print, &req, 0, 0);
1352             odr_reset(print);
1353         }
1354         item_request_buf = odr_getbuf (out, &item_request_size, 0);
1355         if (item_request_buf)
1356             odr_setbuf (out, item_request_buf, item_request_size, 1);
1357         printf ("Couldn't encode ItemRequest, size %d\n", item_request_size);
1358         return 0;
1359     }
1360     else
1361     {
1362         oident oid;
1363
1364         item_request_buf = odr_getbuf (out, &item_request_size, 0);
1365         oid.proto = PROTO_GENERAL;
1366         oid.oclass = CLASS_GENERAL;
1367         oid.value = VAL_ISO_ILL_1;
1368
1369         r = (Z_External *) odr_malloc (out, sizeof(*r));
1370         r->direct_reference = odr_oiddup(out,oid_getoidbyent(&oid));
1371         r->indirect_reference = 0;
1372         r->descriptor = 0;
1373         r->which = Z_External_single;
1374
1375         r->u.single_ASN1_type = (Odr_oct *)
1376             odr_malloc (out, sizeof(*r->u.single_ASN1_type));
1377         r->u.single_ASN1_type->buf = (unsigned char *)
1378             odr_malloc (out, item_request_size);
1379         r->u.single_ASN1_type->len = item_request_size;
1380         r->u.single_ASN1_type->size = item_request_size;
1381         memcpy (r->u.single_ASN1_type->buf, item_request_buf,
1382                 item_request_size);
1383         printf ("len = %d\n", item_request_size);
1384     }
1385     return r;
1386 }
1387 #endif
1388
1389 #ifdef YAZ_MODULE_ill
1390 static Z_External *create_external_ILL_APDU(int which)
1391 {
1392     struct ill_get_ctl ctl;
1393     ILL_APDU *ill_apdu;
1394     Z_External *r = 0;
1395     int ill_request_size = 0;
1396     char *ill_request_buf = 0;
1397
1398     ctl.odr = out;
1399     ctl.clientData = 0;
1400     ctl.f = get_ill_element;
1401
1402     ill_apdu = ill_get_APDU(&ctl, "ill", 0);
1403
1404     if (!ill_APDU (out, &ill_apdu, 0, 0))
1405     {
1406         if (apdu_file)
1407         {
1408             printf ("-------------------\n");
1409             ill_APDU(print, &ill_apdu, 0, 0);
1410             odr_reset(print);
1411             printf ("-------------------\n");
1412         }
1413         ill_request_buf = odr_getbuf (out, &ill_request_size, 0);
1414         if (ill_request_buf)
1415             odr_setbuf (out, ill_request_buf, ill_request_size, 1);
1416         printf ("Couldn't encode ILL-Request, size %d\n", ill_request_size);
1417         return 0;
1418     }
1419     else
1420     {
1421         oident oid;
1422         ill_request_buf = odr_getbuf (out, &ill_request_size, 0);
1423
1424         oid.proto = PROTO_GENERAL;
1425         oid.oclass = CLASS_GENERAL;
1426         oid.value = VAL_ISO_ILL_1;
1427
1428         r = (Z_External *) odr_malloc (out, sizeof(*r));
1429         r->direct_reference = odr_oiddup(out,oid_getoidbyent(&oid));
1430         r->indirect_reference = 0;
1431         r->descriptor = 0;
1432         r->which = Z_External_single;
1433
1434         r->u.single_ASN1_type = (Odr_oct *)
1435             odr_malloc (out, sizeof(*r->u.single_ASN1_type));
1436         r->u.single_ASN1_type->buf = (unsigned char *)
1437             odr_malloc (out, ill_request_size);
1438         r->u.single_ASN1_type->len = ill_request_size;
1439         r->u.single_ASN1_type->size = ill_request_size;
1440         memcpy (r->u.single_ASN1_type->buf, ill_request_buf, ill_request_size);
1441         printf ("len = %d\n", ill_request_size);
1442     }
1443     return r;
1444 }
1445 #endif
1446
1447
1448 static Z_External *create_ItemOrderExternal(const char *type, int itemno)
1449 {
1450     Z_External *r = (Z_External *) odr_malloc(out, sizeof(Z_External));
1451     oident ItemOrderRequest;
1452
1453     ItemOrderRequest.proto = PROTO_Z3950;
1454     ItemOrderRequest.oclass = CLASS_EXTSERV;
1455     ItemOrderRequest.value = VAL_ITEMORDER;
1456
1457     r->direct_reference = odr_oiddup(out,oid_getoidbyent(&ItemOrderRequest));
1458     r->indirect_reference = 0;
1459     r->descriptor = 0;
1460
1461     r->which = Z_External_itemOrder;
1462
1463     r->u.itemOrder = (Z_ItemOrder *) odr_malloc(out,sizeof(Z_ItemOrder));
1464     memset(r->u.itemOrder, 0, sizeof(Z_ItemOrder));
1465 #ifdef ASN_COMPILED
1466     r->u.itemOrder->which=Z_IOItemOrder_esRequest;
1467 #else
1468     r->u.itemOrder->which=Z_ItemOrder_esRequest;
1469 #endif
1470
1471     r->u.itemOrder->u.esRequest = (Z_IORequest *)
1472         odr_malloc(out,sizeof(Z_IORequest));
1473     memset(r->u.itemOrder->u.esRequest, 0, sizeof(Z_IORequest));
1474
1475     r->u.itemOrder->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
1476         odr_malloc(out,sizeof(Z_IOOriginPartToKeep));
1477     memset(r->u.itemOrder->u.esRequest->toKeep, 0, sizeof(Z_IOOriginPartToKeep));
1478     r->u.itemOrder->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
1479         odr_malloc(out,sizeof(Z_IOOriginPartNotToKeep));
1480     memset(r->u.itemOrder->u.esRequest->notToKeep, 0, sizeof(Z_IOOriginPartNotToKeep));
1481
1482     r->u.itemOrder->u.esRequest->toKeep->supplDescription = NULL;
1483     r->u.itemOrder->u.esRequest->toKeep->contact = NULL;
1484     r->u.itemOrder->u.esRequest->toKeep->addlBilling = NULL;
1485
1486     r->u.itemOrder->u.esRequest->notToKeep->resultSetItem =
1487         (Z_IOResultSetItem *) odr_malloc(out, sizeof(Z_IOResultSetItem));
1488     memset(r->u.itemOrder->u.esRequest->notToKeep->resultSetItem, 0, sizeof(Z_IOResultSetItem));
1489     r->u.itemOrder->u.esRequest->notToKeep->resultSetItem->resultSetId = "1";
1490
1491     r->u.itemOrder->u.esRequest->notToKeep->resultSetItem->item =
1492         (int *) odr_malloc(out, sizeof(int));
1493     *r->u.itemOrder->u.esRequest->notToKeep->resultSetItem->item = itemno;
1494
1495 #if YAZ_MODULE_ill
1496     if (!strcmp (type, "item") || !strcmp(type, "2"))
1497     {
1498         printf ("using item-request\n");
1499         r->u.itemOrder->u.esRequest->notToKeep->itemRequest =
1500             create_external_itemRequest();
1501     }
1502     else if (!strcmp(type, "ill") || !strcmp(type, "1"))
1503     {
1504         printf ("using ILL-request\n");
1505         r->u.itemOrder->u.esRequest->notToKeep->itemRequest =
1506             create_external_ILL_APDU(ILL_APDU_ILL_Request);
1507     }
1508     else if (!strcmp(type, "xml") || !strcmp(type, "3"))
1509     {
1510         const char *xml_buf =
1511                 "<itemorder>\n"
1512                 "  <type>request</type>\n"
1513                 "  <libraryNo>000200</libraryNo>\n"
1514                 "  <borrowerTicketNo> 1212 </borrowerTicketNo>\n"
1515                 "</itemorder>";
1516         r->u.itemOrder->u.esRequest->notToKeep->itemRequest =
1517             z_ext_record (out, VAL_TEXT_XML, xml_buf, strlen(xml_buf));
1518     }
1519     else
1520         r->u.itemOrder->u.esRequest->notToKeep->itemRequest = 0;
1521
1522 #else
1523     r->u.itemOrder->u.esRequest->notToKeep->itemRequest = 0;
1524 #endif
1525     return r;
1526 }
1527
1528 static int send_itemorder(const char *type, int itemno)
1529 {
1530     Z_APDU *apdu = zget_APDU(out, Z_APDU_extendedServicesRequest);
1531     Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
1532     oident ItemOrderRequest;
1533
1534     ItemOrderRequest.proto = PROTO_Z3950;
1535     ItemOrderRequest.oclass = CLASS_EXTSERV;
1536     ItemOrderRequest.value = VAL_ITEMORDER;
1537     req->packageType = odr_oiddup(out,oid_getoidbyent(&ItemOrderRequest));
1538     req->packageName = esPackageName;
1539
1540     req->taskSpecificParameters = create_ItemOrderExternal(type, itemno);
1541
1542     send_apdu(apdu);
1543     return 0;
1544 }
1545
1546 static int cmd_update(char *arg)
1547 {
1548     Z_APDU *apdu = zget_APDU(out, Z_APDU_extendedServicesRequest );
1549     Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
1550     Z_External *r;
1551     int oid[OID_SIZE];
1552     Z_IUOriginPartToKeep *toKeep;
1553     Z_IUSuppliedRecords *notToKeep;
1554     oident update_oid;
1555     printf ("Update request\n");
1556     fflush(stdout);
1557
1558     if (!record_last)
1559         return 0;
1560     update_oid.proto = PROTO_Z3950;
1561     update_oid.oclass = CLASS_EXTSERV;
1562     update_oid.value = VAL_DBUPDATE;
1563     oid_ent_to_oid (&update_oid, oid);
1564     req->packageType = odr_oiddup(out,oid);
1565     req->packageName = esPackageName;
1566
1567     r = req->taskSpecificParameters = (Z_External *)
1568         odr_malloc (out, sizeof(*r));
1569     r->direct_reference = odr_oiddup(out,oid);
1570     r->indirect_reference = 0;
1571     r->descriptor = 0;
1572     r->which = Z_External_update;
1573     r->u.update = (Z_IUUpdate *) odr_malloc(out, sizeof(*r->u.update));
1574     r->u.update->which = Z_IUUpdate_esRequest;
1575     r->u.update->u.esRequest = (Z_IUUpdateEsRequest *)
1576         odr_malloc(out, sizeof(*r->u.update->u.esRequest));
1577     toKeep = r->u.update->u.esRequest->toKeep = (Z_IUOriginPartToKeep *)
1578         odr_malloc(out, sizeof(*r->u.update->u.esRequest->toKeep));
1579     toKeep->databaseName = databaseNames[0];
1580     toKeep->schema = 0;
1581     toKeep->elementSetName = 0;
1582     toKeep->actionQualifier = 0;
1583     toKeep->action = (int *) odr_malloc(out, sizeof(*toKeep->action));
1584     *toKeep->action = Z_IUOriginPartToKeep_recordInsert;
1585
1586     notToKeep = r->u.update->u.esRequest->notToKeep = (Z_IUSuppliedRecords *)
1587         odr_malloc(out, sizeof(*r->u.update->u.esRequest->notToKeep));
1588     notToKeep->num = 1;
1589     notToKeep->elements = (Z_IUSuppliedRecords_elem **)
1590         odr_malloc(out, sizeof(*notToKeep->elements));
1591     notToKeep->elements[0] = (Z_IUSuppliedRecords_elem *)
1592         odr_malloc(out, sizeof(**notToKeep->elements));
1593     notToKeep->elements[0]->u.number = 0;
1594     notToKeep->elements[0]->supplementalId = 0;
1595     notToKeep->elements[0]->correlationInfo = 0;
1596     notToKeep->elements[0]->record = record_last;
1597
1598     send_apdu(apdu);
1599
1600     return 2;
1601 }
1602
1603 /* II : Added to do DALI Item Order Extended services request */
1604 static int cmd_itemorder(char *arg)
1605 {
1606     char type[12];
1607     int itemno;
1608
1609     if (sscanf (arg, "%10s %d", type, &itemno) != 2)
1610         return 0;
1611
1612     printf("Item order request\n");
1613     fflush(stdout);
1614     send_itemorder(type, itemno);
1615     return(2);
1616 }
1617
1618 static int cmd_find(char *arg)
1619 {
1620     if (!*arg)
1621     {
1622         printf("Find what?\n");
1623         return 0;
1624     }
1625     if (!conn)
1626     {
1627         printf("Not connected yet\n");
1628         return 0;
1629     }
1630     if (!send_searchRequest(arg))
1631         return 0;
1632     return 2;
1633 }
1634
1635 static int cmd_delete(char *arg)
1636 {
1637     if (!conn)
1638     {
1639         printf("Not connected yet\n");
1640         return 0;
1641     }
1642     if (!send_deleteResultSetRequest(arg))
1643         return 0;
1644     return 2;
1645 }
1646
1647 static int cmd_ssub(char *arg)
1648 {
1649     if (!(smallSetUpperBound = atoi(arg)))
1650         return 0;
1651     return 1;
1652 }
1653
1654 static int cmd_lslb(char *arg)
1655 {
1656     if (!(largeSetLowerBound = atoi(arg)))
1657         return 0;
1658     return 1;
1659 }
1660
1661 static int cmd_mspn(char *arg)
1662 {
1663     if (!(mediumSetPresentNumber = atoi(arg)))
1664         return 0;
1665     return 1;
1666 }
1667
1668 static int cmd_status(char *arg)
1669 {
1670     printf("smallSetUpperBound: %d\n", smallSetUpperBound);
1671     printf("largeSetLowerBound: %d\n", largeSetLowerBound);
1672     printf("mediumSetPresentNumber: %d\n", mediumSetPresentNumber);
1673     return 1;
1674 }
1675
1676 static int cmd_setnames(char *arg)
1677 {
1678     if (setnumber < 0)
1679     {
1680         printf("Set numbering enabled.\n");
1681         setnumber = 0;
1682     }
1683     else
1684     {
1685         printf("Set numbering disabled.\n");
1686         setnumber = -1;
1687     }
1688     return 1;
1689 }
1690
1691 /* PRESENT SERVICE ----------------------------- */
1692
1693 static int send_presentRequest(char *arg)
1694 {
1695     Z_APDU *apdu = zget_APDU(out, Z_APDU_presentRequest);
1696     Z_PresentRequest *req = apdu->u.presentRequest;
1697     Z_RecordComposition compo;
1698     oident prefsyn;
1699     int nos = 1;
1700     int oid[OID_SIZE];
1701     char *p;
1702     char setstring[100];
1703
1704     req->referenceId = set_refid (out);
1705     if ((p = strchr(arg, '+')))
1706     {
1707         nos = atoi(p + 1);
1708         *p = 0;
1709     }
1710     if (*arg)
1711         setno = atoi(arg);
1712     if (p && (p=strchr(p+1, '+')))
1713     {
1714         strcpy (setstring, p+1);
1715         req->resultSetId = setstring;
1716     }
1717     else if (setnumber >= 0)
1718     {
1719         sprintf(setstring, "%d", setnumber);
1720         req->resultSetId = setstring;
1721     }
1722 #if 0
1723     if (1)
1724     {
1725         static Z_Range range;
1726         static Z_Range *rangep = &range;
1727     req->num_ranges = 1;
1728 #endif
1729     req->resultSetStartPoint = &setno;
1730     req->numberOfRecordsRequested = &nos;
1731     prefsyn.proto = protocol;
1732     prefsyn.oclass = CLASS_RECSYN;
1733     prefsyn.value = recordsyntax;
1734     req->preferredRecordSyntax =
1735         odr_oiddup (out, oid_ent_to_oid(&prefsyn, oid));
1736
1737     if (schema != VAL_NONE)
1738     {
1739         oident prefschema;
1740
1741         prefschema.proto = protocol;
1742         prefschema.oclass = CLASS_SCHEMA;
1743         prefschema.value = schema;
1744
1745         req->recordComposition = &compo;
1746         compo.which = Z_RecordComp_complex;
1747         compo.u.complex = (Z_CompSpec *)
1748             odr_malloc(out, sizeof(*compo.u.complex));
1749         compo.u.complex->selectAlternativeSyntax = (bool_t *)
1750             odr_malloc(out, sizeof(bool_t));
1751         *compo.u.complex->selectAlternativeSyntax = 0;
1752
1753         compo.u.complex->generic = (Z_Specification *)
1754             odr_malloc(out, sizeof(*compo.u.complex->generic));
1755         compo.u.complex->generic->schema = (Odr_oid *)
1756             odr_oiddup(out, oid_ent_to_oid(&prefschema, oid));
1757         if (!compo.u.complex->generic->schema)
1758         {
1759             /* OID wasn't a schema! Try record syntax instead. */
1760             prefschema.oclass = CLASS_RECSYN;
1761             compo.u.complex->generic->schema = (Odr_oid *)
1762                 odr_oiddup(out, oid_ent_to_oid(&prefschema, oid));
1763         }
1764         if (!elementSetNames)
1765             compo.u.complex->generic->elementSpec = 0;
1766         else
1767         {
1768             compo.u.complex->generic->elementSpec = (Z_ElementSpec *)
1769                 odr_malloc(out, sizeof(Z_ElementSpec));
1770             compo.u.complex->generic->elementSpec->which =
1771                 Z_ElementSpec_elementSetName;
1772             compo.u.complex->generic->elementSpec->u.elementSetName =
1773                 elementSetNames->u.generic;
1774         }
1775         compo.u.complex->num_dbSpecific = 0;
1776         compo.u.complex->dbSpecific = 0;
1777         compo.u.complex->num_recordSyntax = 0;
1778         compo.u.complex->recordSyntax = 0;
1779     }
1780     else if (elementSetNames)
1781     {
1782         req->recordComposition = &compo;
1783         compo.which = Z_RecordComp_simple;
1784         compo.u.simple = elementSetNames;
1785     }
1786     send_apdu(apdu);
1787     printf("Sent presentRequest (%d+%d).\n", setno, nos);
1788     return 2;
1789 }
1790
1791 void process_close(Z_Close *req)
1792 {
1793     Z_APDU *apdu = zget_APDU(out, Z_APDU_close);
1794     Z_Close *res = apdu->u.close;
1795
1796     static char *reasons[] =
1797     {
1798         "finished",
1799         "shutdown",
1800         "system problem",
1801         "cost limit reached",
1802         "resources",
1803         "security violation",
1804         "protocolError",
1805         "lack of activity",
1806         "peer abort",
1807         "unspecified"
1808     };
1809
1810     printf("Reason: %s, message: %s\n", reasons[*req->closeReason],
1811         req->diagnosticInformation ? req->diagnosticInformation : "NULL");
1812     if (sent_close)
1813     {
1814         cs_close (conn);
1815         conn = NULL;
1816         if (session_mem)
1817         {
1818             nmem_destroy (session_mem);
1819             session_mem = NULL;
1820         }
1821         sent_close = 0;
1822     }
1823     else
1824     {
1825         *res->closeReason = Z_Close_finished;
1826         send_apdu(apdu);
1827         printf("Sent response.\n");
1828         sent_close = 1;
1829     }
1830 }
1831
1832 static int cmd_show(char *arg)
1833 {
1834     if (!conn)
1835     {
1836         printf("Not connected yet\n");
1837         return 0;
1838     }
1839     if (!send_presentRequest(arg))
1840         return 0;
1841     return 2;
1842 }
1843
1844 int cmd_quit(char *arg)
1845 {
1846     printf("See you later, alligator.\n");
1847     exit(0);
1848     return 0;
1849 }
1850
1851 int cmd_cancel(char *arg)
1852 {
1853     Z_APDU *apdu = zget_APDU(out, Z_APDU_triggerResourceControlRequest);
1854     Z_TriggerResourceControlRequest *req =
1855         apdu->u.triggerResourceControlRequest;
1856     bool_t rfalse = 0;
1857
1858     if (!conn)
1859     {
1860         printf("Session not initialized yet\n");
1861         return 0;
1862     }
1863     if (!ODR_MASK_GET(session->options, Z_Options_triggerResourceCtrl))
1864     {
1865         printf("Target doesn't support cancel (trigger resource ctrl)\n");
1866         return 0;
1867     }
1868     *req->requestedAction = Z_TriggerResourceCtrl_cancel;
1869     req->resultSetWanted = &rfalse;
1870
1871     send_apdu(apdu);
1872     printf("Sent cancel request\n");
1873     return 2;
1874 }
1875
1876 int send_scanrequest(const char *query, int pp, int num, const char *term)
1877 {
1878     Z_APDU *apdu = zget_APDU(out, Z_APDU_scanRequest);
1879     Z_ScanRequest *req = apdu->u.scanRequest;
1880     int use_rpn = 1;
1881 #if YAZ_MODULE_ccl
1882     int oid[OID_SIZE];
1883
1884     if (queryType == QueryType_CCL2RPN)
1885     {
1886         oident bib1;
1887         int error, pos;
1888         struct ccl_rpn_node *rpn;
1889
1890         rpn = ccl_find_str (bibset,  query, &error, &pos);
1891         if (error)
1892         {
1893             printf("CCL ERROR: %s\n", ccl_err_msg(error));
1894             return -1;
1895         }
1896         use_rpn = 0;
1897         bib1.proto = PROTO_Z3950;
1898         bib1.oclass = CLASS_ATTSET;
1899         bib1.value = VAL_BIB1;
1900         req->attributeSet = oid_ent_to_oid (&bib1, oid);
1901         if (!(req->termListAndStartPoint = ccl_scan_query (out, rpn)))
1902         {
1903             printf("Couldn't convert CCL to Scan term\n");
1904             return -1;
1905         }
1906         ccl_rpn_delete (rpn);
1907     }
1908 #endif
1909     if (use_rpn && !(req->termListAndStartPoint =
1910                      p_query_scan(out, protocol, &req->attributeSet, query)))
1911     {
1912         printf("Prefix query error\n");
1913         return -1;
1914     }
1915     if (term && *term)
1916     {
1917         if (req->termListAndStartPoint->term &&
1918             req->termListAndStartPoint->term->which == Z_Term_general &&
1919             req->termListAndStartPoint->term->u.general)
1920         {
1921             req->termListAndStartPoint->term->u.general->buf =
1922                 (unsigned char *) odr_strdup(out, term);
1923             req->termListAndStartPoint->term->u.general->len =
1924                 req->termListAndStartPoint->term->u.general->size =
1925                 strlen(term);
1926         }
1927     }
1928     req->referenceId = set_refid (out);
1929     req->num_databaseNames = num_databaseNames;
1930     req->databaseNames = databaseNames;
1931     req->numberOfTermsRequested = &num;
1932     req->preferredPositionInResponse = &pp;
1933     send_apdu(apdu);
1934     return 2;
1935 }
1936
1937 int send_sortrequest(char *arg, int newset)
1938 {
1939     Z_APDU *apdu = zget_APDU(out, Z_APDU_sortRequest);
1940     Z_SortRequest *req = apdu->u.sortRequest;
1941     Z_SortKeySpecList *sksl = (Z_SortKeySpecList *)
1942         odr_malloc (out, sizeof(*sksl));
1943     char setstring[32];
1944     char sort_string_buf[32], sort_flags[32];
1945     int off;
1946     int oid[OID_SIZE];
1947     oident bib1;
1948
1949     if (setnumber >= 0)
1950         sprintf (setstring, "%d", setnumber);
1951     else
1952         sprintf (setstring, "default");
1953
1954     req->referenceId = set_refid (out);
1955
1956 #ifdef ASN_COMPILED
1957     req->num_inputResultSetNames = 1;
1958     req->inputResultSetNames = (Z_InternationalString **)
1959         odr_malloc (out, sizeof(*req->inputResultSetNames));
1960     req->inputResultSetNames[0] = odr_strdup (out, setstring);
1961 #else
1962     req->inputResultSetNames =
1963         (Z_StringList *)odr_malloc (out, sizeof(*req->inputResultSetNames));
1964     req->inputResultSetNames->num_strings = 1;
1965     req->inputResultSetNames->strings =
1966         (char **)odr_malloc (out, sizeof(*req->inputResultSetNames->strings));
1967     req->inputResultSetNames->strings[0] =
1968         odr_strdup (out, setstring);
1969 #endif
1970
1971     if (newset && setnumber >= 0)
1972         sprintf (setstring, "%d", ++setnumber);
1973
1974     req->sortedResultSetName = odr_strdup (out, setstring);
1975
1976     req->sortSequence = sksl;
1977     sksl->num_specs = 0;
1978     sksl->specs = (Z_SortKeySpec **)odr_malloc (out, sizeof(sksl->specs) * 20);
1979
1980     bib1.proto = protocol;
1981     bib1.oclass = CLASS_ATTSET;
1982     bib1.value = VAL_BIB1;
1983     while ((sscanf (arg, "%31s %31s%n", sort_string_buf, sort_flags, &off)) == 2
1984            && off > 1)
1985     {
1986         int i;
1987         char *sort_string_sep;
1988         char *sort_string = sort_string_buf;
1989         Z_SortKeySpec *sks = (Z_SortKeySpec *)odr_malloc (out, sizeof(*sks));
1990         Z_SortKey *sk = (Z_SortKey *)odr_malloc (out, sizeof(*sk));
1991
1992         arg += off;
1993         sksl->specs[sksl->num_specs++] = sks;
1994         sks->sortElement = (Z_SortElement *)odr_malloc (out, sizeof(*sks->sortElement));
1995         sks->sortElement->which = Z_SortElement_generic;
1996         sks->sortElement->u.generic = sk;
1997
1998         if ((sort_string_sep = strchr (sort_string, '=')))
1999         {
2000             int i = 0;
2001             sk->which = Z_SortKey_sortAttributes;
2002             sk->u.sortAttributes =
2003                 (Z_SortAttributes *)odr_malloc (out, sizeof(*sk->u.sortAttributes));
2004             sk->u.sortAttributes->id = oid_ent_to_oid(&bib1, oid);
2005             sk->u.sortAttributes->list =
2006                 (Z_AttributeList *)odr_malloc (out, sizeof(*sk->u.sortAttributes->list));
2007             sk->u.sortAttributes->list->attributes =
2008                 (Z_AttributeElement **)
2009                 odr_malloc (out, 10 *
2010                             sizeof(*sk->u.sortAttributes->list->attributes));
2011             while (i < 10 && sort_string && sort_string_sep)
2012             {
2013                 Z_AttributeElement *el = (Z_AttributeElement *)
2014                     odr_malloc (out, sizeof(*el));
2015                 sk->u.sortAttributes->list->attributes[i] = el;
2016                 el->attributeSet = 0;
2017                 el->attributeType = (int *)odr_malloc (out, sizeof(*el->attributeType));
2018                 *el->attributeType = atoi (sort_string);
2019                 el->which = Z_AttributeValue_numeric;
2020                 el->value.numeric = (int *)odr_malloc (out, sizeof(*el->value.numeric));
2021                 *el->value.numeric = atoi (sort_string_sep + 1);
2022                 i++;
2023                 sort_string = strchr(sort_string, ',');
2024                 if (sort_string)
2025                 {
2026                     sort_string++;
2027                     sort_string_sep = strchr (sort_string, '=');
2028                 }
2029             }
2030             sk->u.sortAttributes->list->num_attributes = i;
2031         }
2032         else
2033         {
2034             sk->which = Z_SortKey_sortField;
2035             sk->u.sortField = odr_strdup (out, sort_string);
2036         }
2037         sks->sortRelation = (int *)odr_malloc (out, sizeof(*sks->sortRelation));
2038         *sks->sortRelation = Z_SortRelation_ascending;
2039         sks->caseSensitivity = (int *)odr_malloc (out, sizeof(*sks->caseSensitivity));
2040         *sks->caseSensitivity = Z_SortCase_caseSensitive;
2041
2042 #ifdef ASN_COMPILED
2043         sks->which = Z_SortKeySpec_null;
2044         sks->u.null = odr_nullval ();
2045 #else
2046         sks->missingValueAction = NULL;
2047 #endif
2048
2049         for (i = 0; sort_flags[i]; i++)
2050         {
2051             switch (sort_flags[i])
2052             {
2053             case 'a':
2054             case 'A':
2055             case '>':
2056                 *sks->sortRelation = Z_SortRelation_descending;
2057                 break;
2058             case 'd':
2059             case 'D':
2060             case '<':
2061                 *sks->sortRelation = Z_SortRelation_ascending;
2062                 break;
2063             case 'i':
2064             case 'I':
2065                 *sks->caseSensitivity = Z_SortCase_caseInsensitive;
2066                 break;
2067             case 'S':
2068             case 's':
2069                 *sks->caseSensitivity = Z_SortCase_caseSensitive;
2070                 break;
2071             }
2072         }
2073     }
2074     if (!sksl->num_specs)
2075     {
2076         printf ("Missing sort specifications\n");
2077         return -1;
2078     }
2079     send_apdu(apdu);
2080     return 2;
2081 }
2082
2083 void display_term(Z_TermInfo *t)
2084 {
2085     if (t->term->which == Z_Term_general)
2086     {
2087         printf("%.*s", t->term->u.general->len, t->term->u.general->buf);
2088         sprintf(last_scan_line, "%.*s", t->term->u.general->len,
2089             t->term->u.general->buf);
2090     }
2091     else
2092         printf("Term (not general)");
2093     if (t->globalOccurrences)
2094         printf (" (%d)\n", *t->globalOccurrences);
2095     else
2096         printf ("\n");
2097 }
2098
2099 void process_scanResponse(Z_ScanResponse *res)
2100 {
2101     int i;
2102     Z_Entry **entries = NULL;
2103     int num_entries = 0;
2104
2105     printf("Received ScanResponse\n");
2106     print_refid (res->referenceId);
2107     printf("%d entries", *res->numberOfEntriesReturned);
2108     if (res->positionOfTerm)
2109         printf (", position=%d", *res->positionOfTerm);
2110     printf ("\n");
2111     if (*res->scanStatus != Z_Scan_success)
2112         printf("Scan returned code %d\n", *res->scanStatus);
2113     if (!res->entries)
2114         return;
2115     if ((entries = res->entries->entries))
2116         num_entries = res->entries->num_entries;
2117     for (i = 0; i < num_entries; i++)
2118     {
2119         int pos_term = res->positionOfTerm ? *res->positionOfTerm : -1;
2120         if (entries[i]->which == Z_Entry_termInfo)
2121         {
2122             printf("%c ", i + 1 == pos_term ? '*' : ' ');
2123             display_term(entries[i]->u.termInfo);
2124         }
2125         else
2126             display_diagrecs(&entries[i]->u.surrogateDiagnostic, 1);
2127     }
2128     if (res->entries->nonsurrogateDiagnostics)
2129         display_diagrecs (res->entries->nonsurrogateDiagnostics,
2130                           res->entries->num_nonsurrogateDiagnostics);
2131 }
2132
2133 void process_sortResponse(Z_SortResponse *res)
2134 {
2135     printf("Received SortResponse: status=");
2136     switch (*res->sortStatus)
2137     {
2138     case Z_SortStatus_success:
2139         printf ("success"); break;
2140     case Z_SortStatus_partial_1:
2141         printf ("partial"); break;
2142     case Z_SortStatus_failure:
2143         printf ("failure"); break;
2144     default:
2145         printf ("unknown (%d)", *res->sortStatus);
2146     }
2147     printf ("\n");
2148     print_refid (res->referenceId);
2149 #ifdef ASN_COMPILED
2150     if (res->diagnostics)
2151         display_diagrecs(res->diagnostics,
2152                          res->num_diagnostics);
2153 #else
2154     if (res->diagnostics)
2155         display_diagrecs(res->diagnostics->diagRecs,
2156                          res->diagnostics->num_diagRecs);
2157 #endif
2158 }
2159
2160 void process_deleteResultSetResponse (Z_DeleteResultSetResponse *res)
2161 {
2162     printf("Got deleteResultSetResponse status=%d\n",
2163            *res->deleteOperationStatus);
2164     if (res->deleteListStatuses)
2165     {
2166         int i;
2167         for (i = 0; i < res->deleteListStatuses->num; i++)
2168         {
2169             printf ("%s status=%d\n", res->deleteListStatuses->elements[i]->id,
2170                     *res->deleteListStatuses->elements[i]->status);
2171         }
2172     }
2173 }
2174
2175 int cmd_sort_generic(char *arg, int newset)
2176 {
2177     if (!conn)
2178     {
2179         printf("Session not initialized yet\n");
2180         return 0;
2181     }
2182     if (!ODR_MASK_GET(session->options, Z_Options_sort))
2183     {
2184         printf("Target doesn't support sort\n");
2185         return 0;
2186     }
2187     if (*arg)
2188     {
2189         if (send_sortrequest(arg, newset) < 0)
2190             return 0;
2191         return 2;
2192     }
2193     return 0;
2194 }
2195
2196 int cmd_sort(char *arg)
2197 {
2198     return cmd_sort_generic (arg, 0);
2199 }
2200
2201 int cmd_sort_newset (char *arg)
2202 {
2203     return cmd_sort_generic (arg, 1);
2204 }
2205
2206 int cmd_scan(char *arg)
2207 {
2208     if (!conn)
2209     {
2210         printf("Session not initialized yet\n");
2211         return 0;
2212     }
2213     if (!ODR_MASK_GET(session->options, Z_Options_scan))
2214     {
2215         printf("Target doesn't support scan\n");
2216         return 0;
2217     }
2218     if (*arg)
2219     {
2220         strcpy (last_scan_query, arg);
2221         if (send_scanrequest(arg, 1, 20, 0) < 0)
2222             return 0;
2223     }
2224     else
2225     {
2226         if (send_scanrequest(last_scan_query, 1, 20, last_scan_line) < 0)
2227             return 0;
2228     }
2229     return 2;
2230 }
2231
2232 int cmd_schema(char *arg)
2233 {
2234     if (!arg || !*arg)
2235     {
2236         schema = VAL_NONE;
2237         return 1;
2238     }
2239     schema = oid_getvalbyname (arg);
2240     if (schema == VAL_NONE)
2241     {
2242         printf ("unknown schema\n");
2243         return 0;
2244     }
2245     return 1;
2246 }
2247
2248 int cmd_format(char *arg)
2249 {
2250     if (!arg || !*arg)
2251     {
2252         printf("Usage: format <recordsyntax>\n");
2253         return 0;
2254     }
2255     recordsyntax = oid_getvalbyname (arg);
2256     if (recordsyntax == VAL_NONE)
2257     {
2258         printf ("unknown record syntax\n");
2259         return 0;
2260     }
2261     return 1;
2262 }
2263
2264 int cmd_elements(char *arg)
2265 {
2266     static Z_ElementSetNames esn;
2267     static char what[100];
2268
2269     if (!arg || !*arg)
2270     {
2271         elementSetNames = 0;
2272         return 1;
2273     }
2274     strcpy(what, arg);
2275     esn.which = Z_ElementSetNames_generic;
2276     esn.u.generic = what;
2277     elementSetNames = &esn;
2278     return 1;
2279 }
2280
2281 int cmd_attributeset(char *arg)
2282 {
2283     char what[100];
2284
2285     if (!arg || !*arg)
2286     {
2287         printf("Usage: attributeset <setname>\n");
2288         return 0;
2289     }
2290     sscanf(arg, "%s", what);
2291     if (p_query_attset (what))
2292     {
2293         printf("Unknown attribute set name\n");
2294         return 0;
2295     }
2296     return 1;
2297 }
2298
2299 int cmd_querytype (char *arg)
2300 {
2301     if (!strcmp (arg, "ccl"))
2302         queryType = QueryType_CCL;
2303     else if (!strcmp (arg, "prefix") || !strcmp(arg, "rpn"))
2304         queryType = QueryType_Prefix;
2305 #if YAZ_MODULE_ccl
2306     else if (!strcmp (arg, "ccl2rpn") || !strcmp (arg, "cclrpn"))
2307         queryType = QueryType_CCL2RPN;
2308 #endif
2309     else
2310     {
2311         printf ("Querytype must be one of:\n");
2312         printf (" prefix         - Prefix query\n");
2313         printf (" ccl            - CCL query\n");
2314 #if YAZ_MODULE_ccl
2315         printf (" ccl2rpn        - CCL query converted to RPN\n");
2316 #endif
2317         return 0;
2318     }
2319     return 1;
2320 }
2321
2322 int cmd_refid (char *arg)
2323 {
2324     xfree (refid);
2325     refid = NULL;
2326     if (*arg)
2327     {
2328         refid = (char *) xmalloc (strlen(arg)+1);
2329         strcpy (refid, arg);
2330     }
2331     return 1;
2332 }
2333
2334 int cmd_close(char *arg)
2335 {
2336     Z_APDU *apdu;
2337     Z_Close *req;
2338     if (!conn)
2339         return 0;
2340
2341     apdu = zget_APDU(out, Z_APDU_close);
2342     req = apdu->u.close;
2343     *req->closeReason = Z_Close_finished;
2344     send_apdu(apdu);
2345     printf("Sent close request.\n");
2346     sent_close = 1;
2347     return 2;
2348 }
2349
2350 int cmd_packagename(char* arg) {
2351     xfree (esPackageName);
2352     esPackageName = NULL;
2353     if (*arg)
2354     {
2355         esPackageName = (char *) xmalloc (strlen(arg)+1);
2356         strcpy (esPackageName, arg);
2357     }
2358     return 1;
2359 };
2360
2361 static void initialize(void)
2362 {
2363 #if YAZ_MODULE_ccl
2364     FILE *inf;
2365 #endif
2366     nmem_init();
2367     if (!(out = odr_createmem(ODR_ENCODE)) ||
2368         !(in = odr_createmem(ODR_DECODE)) ||
2369         !(print = odr_createmem(ODR_PRINT)))
2370     {
2371         fprintf(stderr, "failed to allocate ODR streams\n");
2372         exit(1);
2373     }
2374     setvbuf(stdout, 0, _IONBF, 0);
2375     if (apdu_file)
2376         odr_setprint(print, apdu_file);
2377
2378 #if YAZ_MODULE_ccl
2379     bibset = ccl_qual_mk ();
2380     inf = fopen (ccl_fields, "r");
2381     if (inf)
2382     {
2383         ccl_qual_file (bibset, inf);
2384         fclose (inf);
2385     }
2386 #endif
2387     cmd_base("Default");
2388 }
2389
2390 static int client(int wait)
2391 {
2392     static struct {
2393         char *cmd;
2394         int (*fun)(char *arg);
2395         char *ad;
2396     } cmd[] = {
2397         {"open", cmd_open, "('tcp'|'osi')':'[<tsel>'/']<host>[':'<port>]"},
2398         {"quit", cmd_quit, ""},
2399         {"find", cmd_find, "<query>"},
2400         {"delete", cmd_delete, "<setname>"},
2401         {"base", cmd_base, "<base-name>"},
2402         {"show", cmd_show, "<rec#>['+'<#recs>['+'<setname>]]"},
2403         {"scan", cmd_scan, "<term>"},
2404         {"sort", cmd_sort, "<sortkey> <flag> <sortkey> <flag> ..."},
2405         {"sort+", cmd_sort_newset, "<sortkey> <flag> <sortkey> <flag> ..."},
2406         {"authentication", cmd_authentication, "<acctstring>"},
2407         {"lslb", cmd_lslb, "<largeSetLowerBound>"},
2408         {"ssub", cmd_ssub, "<smallSetUpperBound>"},
2409         {"mspn", cmd_mspn, "<mediumSetPresentNumber>"},
2410         {"status", cmd_status, ""},
2411         {"setnames", cmd_setnames, ""},
2412         {"cancel", cmd_cancel, ""},
2413         {"format", cmd_format, "<recordsyntax>"},
2414         {"schema", cmd_schema, "<schema>"},
2415         {"elements", cmd_elements, "<elementSetName>"},
2416         {"close", cmd_close, ""},
2417         {"attributeset", cmd_attributeset, "<attrset>"},
2418         {"querytype", cmd_querytype, "<type>"},
2419         {"refid", cmd_refid, "<id>"},
2420         {"itemorder", cmd_itemorder, "ill|item <itemno>"},
2421         {"update", cmd_update, "<item>"},
2422         {"packagename", cmd_packagename, "<packagename>"},
2423 #ifdef ASN_COMPILED
2424         /* Server Admin Functions */
2425         {"adm-reindex", cmd_adm_reindex, "<database-name>"},
2426         {"adm-truncate", cmd_adm_truncate, "('database'|'index')<object-name>"},
2427         {"adm-create", cmd_adm_create, ""},
2428         {"adm-drop", cmd_adm_drop, "('database'|'index')<object-name>"},
2429         {"adm-import", cmd_adm_import, "<record-type> <dir> <pattern>"},
2430         {"adm-refresh", cmd_adm_refresh, ""},
2431         {"adm-commit", cmd_adm_commit, ""},
2432         {"adm-shutdown", cmd_adm_shutdown, ""},
2433         {"adm-startup", cmd_adm_startup, ""},
2434 #endif
2435         {0,0}
2436     };
2437     char *netbuffer= 0;
2438     int netbufferlen = 0;
2439     int i;
2440     Z_APDU *apdu;
2441 #if HAVE_GETTIMEOFDAY
2442     struct timeval tv_start, tv_end;
2443     gettimeofday (&tv_start, 0);
2444 #endif
2445
2446     while (1)
2447     {
2448         int res;
2449 #ifdef USE_SELECT
2450         fd_set input;
2451 #endif
2452         char line[1024], word[1024], arg[1024];
2453
2454 #ifdef USE_SELECT
2455         FD_ZERO(&input);
2456         FD_SET(0, &input);
2457         if (conn)
2458             FD_SET(cs_fileno(conn), &input);
2459         if ((res = select(20, &input, 0, 0, 0)) < 0)
2460         {
2461             perror("select");
2462             exit(1);
2463         }
2464         if (!res)
2465             continue;
2466         if (!wait && FD_ISSET(0, &input))
2467 #else
2468         if (!wait)
2469 #endif
2470         {
2471 #if HAVE_READLINE_READLINE_H
2472             char* line_in;
2473             line_in=readline(C_PROMPT);
2474             if (!line_in)
2475                 break;
2476 #if HAVE_READLINE_HISTORY_H
2477             if (*line_in)
2478                 add_history(line_in);
2479 #endif
2480             strcpy(line,line_in);
2481             free (line_in);
2482 #else
2483             char *end_p;
2484             printf (C_PROMPT);
2485             fflush(stdout);
2486             if (!fgets(line, 1023, stdin))
2487                 break;
2488             if ((end_p = strchr (line, '\n')))
2489                 *end_p = '\0';
2490 #endif
2491 #if HAVE_GETTIMEOFDAY
2492             gettimeofday (&tv_start, 0);
2493 #endif
2494
2495             if ((res = sscanf(line, "%s %[^;]", word, arg)) <= 0)
2496             {
2497                 strcpy(word, last_cmd);
2498                 *arg = '\0';
2499             }
2500             else if (res == 1)
2501                 *arg = 0;
2502             strcpy(last_cmd, word);
2503             for (i = 0; cmd[i].cmd; i++)
2504                 if (!strncmp(cmd[i].cmd, word, strlen(word)))
2505                 {
2506                     res = (*cmd[i].fun)(arg);
2507                     break;
2508                 }
2509             if (!cmd[i].cmd) /* dump our help-screen */
2510             {
2511                 printf("Unknown command: %s.\n", word);
2512                 printf("Currently recognized commands:\n");
2513                 for (i = 0; cmd[i].cmd; i++)
2514                     printf("   %s %s\n", cmd[i].cmd, cmd[i].ad);
2515                 res = 1;
2516             }
2517             if (res < 2)
2518             {
2519                 continue;
2520             }
2521         }
2522         wait = 0;
2523         if (conn
2524 #ifdef USE_SELECT
2525             && FD_ISSET(cs_fileno(conn), &input)
2526 #endif
2527             )
2528         {
2529             do
2530             {
2531                 if ((res = cs_get(conn, &netbuffer, &netbufferlen)) < 0)
2532                 {
2533                     perror("cs_get");
2534                     exit(1);
2535                 }
2536                 if (!res)
2537                 {
2538                     printf("Target closed connection.\n");
2539                     exit(1);
2540                 }
2541                 odr_reset(in); /* release APDU from last round */
2542                 record_last = 0;
2543                 odr_setbuf(in, netbuffer, res, 0);
2544                 if (!z_APDU(in, &apdu, 0, 0))
2545                 {
2546                     odr_perror(in, "Decoding incoming APDU");
2547                     fprintf(stderr, "[Near %d]\n", odr_offset(in));
2548                     fprintf(stderr, "Packet dump:\n---------\n");
2549                     odr_dumpBER(stderr, netbuffer, res);
2550                     fprintf(stderr, "---------\n");
2551                     if (apdu_file)
2552                         z_APDU(print, &apdu, 0, 0);
2553                     exit(1);
2554                 }
2555                 if (apdu_file && !z_APDU(print, &apdu, 0, 0))
2556                 {
2557                     odr_perror(print, "Failed to print incoming APDU");
2558                     odr_reset(print);
2559                     continue;
2560                 }
2561                 switch(apdu->which)
2562                 {
2563                 case Z_APDU_initResponse:
2564                     process_initResponse(apdu->u.initResponse);
2565                     break;
2566                 case Z_APDU_searchResponse:
2567                     process_searchResponse(apdu->u.searchResponse);
2568                     break;
2569                 case Z_APDU_scanResponse:
2570                     process_scanResponse(apdu->u.scanResponse);
2571                     break;
2572                 case Z_APDU_presentResponse:
2573                     print_refid (apdu->u.presentResponse->referenceId);
2574                     setno +=
2575                         *apdu->u.presentResponse->numberOfRecordsReturned;
2576                     if (apdu->u.presentResponse->records)
2577                         display_records(apdu->u.presentResponse->records);
2578                     else
2579                         printf("No records.\n");
2580                     printf ("nextResultSetPosition = %d\n",
2581                         *apdu->u.presentResponse->nextResultSetPosition);
2582                     break;
2583                 case Z_APDU_sortResponse:
2584                     process_sortResponse(apdu->u.sortResponse);
2585                     break;
2586                 case Z_APDU_extendedServicesResponse:
2587                     printf("Got extended services response\n");
2588                     process_ESResponse(apdu->u.extendedServicesResponse);
2589                     break;
2590                 case Z_APDU_close:
2591                     printf("Target has closed the association.\n");
2592                     process_close(apdu->u.close);
2593                     break;
2594                 case Z_APDU_resourceControlRequest:
2595                     process_resourceControlRequest
2596                         (apdu->u.resourceControlRequest);
2597                     break;
2598                 case Z_APDU_deleteResultSetResponse:
2599                     process_deleteResultSetResponse(apdu->u.
2600                                                     deleteResultSetResponse);
2601                     break;
2602                 default:
2603                     printf("Received unknown APDU type (%d).\n",
2604                            apdu->which);
2605                     exit(1);
2606                 }
2607             }
2608             while (conn && cs_more(conn));
2609 #if HAVE_GETTIMEOFDAY
2610             gettimeofday (&tv_end, 0);
2611             if (1)
2612             {
2613                 printf ("Elapsed: %.6f\n", (double) tv_end.tv_usec /
2614                                                 1e6 + tv_end.tv_sec -
2615                    ((double) tv_start.tv_usec / 1e6 + tv_start.tv_sec));
2616             }
2617 #endif
2618         }
2619     }
2620     return 0;
2621 }
2622
2623 int main(int argc, char **argv)
2624 {
2625     char *prog = *argv;
2626     char *arg;
2627     int ret;
2628     int opened = 0;
2629
2630     while ((ret = options("c:a:m:v:", argv, argc, &arg)) != -2)
2631     {
2632         switch (ret)
2633         {
2634         case 0:
2635             if (!opened)
2636             {
2637                 initialize ();
2638                 if (cmd_open (arg) == 2)
2639                     opened = 1;
2640             }
2641             break;
2642         case 'm':
2643             if (!(marcdump = fopen (arg, "a")))
2644             {
2645                 perror (arg);
2646                 exit (1);
2647             }
2648             break;
2649         case 'c':
2650             strncpy (ccl_fields, arg, sizeof(ccl_fields)-1);
2651             ccl_fields[sizeof(ccl_fields)-1] = '\0';
2652             break;
2653         case 'a':
2654             if (!strcmp(arg, "-"))
2655                 apdu_file=stderr;
2656             else
2657                 apdu_file=fopen(arg, "a");
2658             break;
2659         case 'v':
2660             yaz_log_init (yaz_log_mask_str(arg), "", NULL);
2661             break;
2662         default:
2663             fprintf (stderr, "Usage: %s [-m <marclog>] [ -a <apdulog>] "
2664                              "[-c cclfields] [<server-addr>]\n",
2665                      prog);
2666             exit (1);
2667         }
2668     }
2669     if (!opened)
2670         initialize ();
2671     return client (opened);
2672 }