client/client.c

   1 /*
   2  * Copyright (C) 1995-2007, Index Data ApS
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: client.c,v 1.341 2007-05-30 08:40:26 adam Exp $
   6  */
   7 /** \file client.c
   8  *  \brief yaz-client program
   9  */
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <assert.h>
  14 #include <time.h>
  15 #include <ctype.h>
  16 #ifndef WIN32
  17 #include <signal.h>
  18 #endif
  19 #if HAVE_SYS_TYPES_H
  20 #include <sys/types.h>
  21 #endif
  22 #if HAVE_LOCALE_H
  23 #include <locale.h>
  24 #endif
  25 #if HAVE_LANGINFO_H
  26 #include <langinfo.h>
  27 #endif
  28 #if HAVE_UNISTD_H
  29 #include <unistd.h>
  30 #endif
  31 #if HAVE_SYS_STAT_H
  32 #include <sys/stat.h>
  33 #endif
  34 #if HAVE_SYS_TIME_H
  35 #include <sys/time.h>
  36 #endif
  37
  38 #if HAVE_OPENSSL_SSL_H
  39 #include <openssl/bio.h>
  40 #include <openssl/crypto.h>
  41 #include <openssl/x509.h>
  42 #include <openssl/pem.h>
  43 #include <openssl/ssl.h>
  44 #include <openssl/err.h>
  45 #endif
  46
  47 #ifdef WIN32
  48 #include <sys/stat.h>
  49 #include <io.h>
  50 #include <windows.h>
  51 #define S_ISREG(x) (x & _S_IFREG)
  52 #define S_ISDIR(x) (x & _S_IFDIR)
  53 #endif
  54
  55 #include <yaz/yaz-util.h>
  56
  57 #include <yaz/comstack.h>
  58
  59 #include <yaz/oid_db.h>
  60 #define NO_OID 1
  61 #include <yaz/proto.h>
  62 #include <yaz/marcdisp.h>
  63 #include <yaz/diagbib1.h>
  64 #include <yaz/otherinfo.h>
  65 #include <yaz/charneg.h>
  66 #include <yaz/query-charset.h>
  67
  68 #include <yaz/pquery.h>
  69 #include <yaz/sortspec.h>
  70
  71 #include <yaz/ill.h>
  72 #include <yaz/srw.h>
  73 #include <yaz/yaz-ccl.h>
  74 #include <yaz/cql.h>
  75 #include <yaz/log.h>
  76
  77 #if HAVE_READLINE_READLINE_H
  78 #include <readline/readline.h>
  79 #endif
  80 #if HAVE_READLINE_HISTORY_H
  81 #include <readline/history.h>
  82 #endif
  83
  84
  85 #include "admin.h"
  86 #include "tabcomplete.h"
  87 #include "fhistory.h"
  88
  89 #define C_PROMPT "Z> "
  90
  91 static file_history_t file_history = 0;
  92
  93 static char *sru_method = "soap";
  94 static char *codeset = 0;               /* character set for output */
  95 static int hex_dump = 0;
  96 static char *dump_file_prefix = 0;
  97 static ODR out, in, print;              /* encoding and decoding streams */
  98 #if YAZ_HAVE_XML2
  99 static ODR srw_sr_odr_out = 0;
 100 static Z_SRW_PDU *srw_sr = 0;
 101 #endif
 102 static FILE *apdu_file = 0;
 103 static FILE *ber_file = 0;
 104 static COMSTACK conn = 0;               /* our z-association */
 105 static Z_IdAuthentication *auth = 0;    /* our current auth definition */
 106 char *databaseNames[128];
 107 int num_databaseNames = 0;
 108 static Z_External *record_last = 0;
 109 static int setnumber = -1;              /* current result set number */
 110 static int smallSetUpperBound = 0;
 111 static int largeSetLowerBound = 1;
 112 static int mediumSetPresentNumber = 0;
 113 static Z_ElementSetNames *elementSetNames = 0;
 114 static int setno = 1;                   /* current set offset */
 115 static enum oid_proto protocol = PROTO_Z3950;      /* current app protocol */
 116 #define RECORDSYNTAX_MAX 20
 117 static char *recordsyntax_list[RECORDSYNTAX_MAX];
 118 static int recordsyntax_size = 0;
 119
 120 static char *record_schema = 0;
 121 static int sent_close = 0;
 122 static NMEM session_mem = NULL;         /* memory handle for init-response */
 123 static Z_InitResponse *session_initResponse = 0;   /* session parameters */
 124 static char last_scan_line[512] = "0";
 125 static char last_scan_query[512] = "0";
 126 static char ccl_fields[512] = "default.bib";
 127 /* ### How can I set this path to use wherever YAZ is installed? */
 128 static char cql_fields[512] = "/usr/local/share/yaz/etc/pqf.properties";
 129 static char *esPackageName = 0;
 130 static char *yazProxy = 0;
 131 static int kilobytes = 1024;
 132 static char *negotiationCharset = 0;
 133 static int  negotiationCharsetRecords = 1;
 134 static int  negotiationCharsetVersion = 3;
 135 static char *outputCharset = 0;
 136 static char *marcCharset = 0;
 137 static char *queryCharset = 0;
 138 static char* yazLang = 0;
 139
 140 static char last_cmd[32] = "?";
 141 static FILE *marc_file = 0;
 142 static char *refid = NULL;
 143 static char *last_open_command = NULL;
 144 static int auto_reconnect = 0;
 145 static int auto_wait = 1;
 146 static Odr_bitmask z3950_options;
 147 static int z3950_version = 3;
 148 static int scan_stepSize = 0;
 149 static int scan_position = 1;
 150 static int scan_size = 20;
 151 static char cur_host[200];
 152 static int last_hit_count = 0;
 153
 154 typedef enum {
 155     QueryType_Prefix,
 156     QueryType_CCL,
 157     QueryType_CCL2RPN,
 158     QueryType_CQL,
 159     QueryType_CQL2RPN
 160 } QueryType;
 161
 162 static QueryType queryType = QueryType_Prefix;
 163
 164 static CCL_bibset bibset;               /* CCL bibset handle */
 165 static cql_transform_t cqltrans = 0; /* CQL context-set handle */
 166
 167 #if HAVE_READLINE_COMPLETION_OVER
 168
 169 #else
 170 /* readline doesn't have this var. Define it ourselves. */
 171 int rl_attempted_completion_over = 0;
 172 #endif
 173
 174 /* set this one to 1, to avoid decode of unknown MARCs  */
 175 #define AVOID_MARC_DECODE 1
 176
 177 #define maxOtherInfosSupported 10
 178 struct eoi {
 179     Odr_oid oid[OID_SIZE];
 180     char* value;
 181 } extraOtherInfos[maxOtherInfosSupported];
 182
 183 void process_cmd_line(char* line);
 184 #if HAVE_READLINE_READLINE_H
 185 char **readline_completer(char *text, int start, int end);
 186 #endif
 187 static char *command_generator(const char *text, int state);
 188 int cmd_register_tab(const char* arg);
 189
 190 static void close_session (void);
 191
 192 ODR getODROutputStream(void)
 193 {
 194     return out;
 195 }
 196
 197 const char* query_type_as_string(QueryType q)
 198 {
 199     switch (q) {
 200     case QueryType_Prefix: return "prefix (RPN sent to server)";
 201     case QueryType_CCL: return "CCL (CCL sent to server) ";
 202     case QueryType_CCL2RPN: return "CCL -> RPN (RPN sent to server)";
 203     case QueryType_CQL: return "CQL (CQL sent to server)";
 204     case QueryType_CQL2RPN: return "CQL -> RPN (RPN sent to server)";
 205     default:
 206         return "unknown Query type internal yaz-client error";
 207     }
 208 }
 209
 210 static void do_hex_dump(const char* buf, int len)
 211 {
 212     if (hex_dump)
 213     {
 214         int i,x;
 215         for( i=0; i<len ; i=i+16 )
 216         {
 217             printf(" %4.4d ",i);
 218             for(x=0 ; i+x<len && x<16; ++x)
 219             {
 220                 printf("%2.2X ",(unsigned int)((unsigned char)buf[i+x]));
 221             }
 222             printf("\n");
 223         }
 224     }
 225     if (dump_file_prefix)
 226     {
 227         static int no = 0;
 228         if (++no < 1000 && strlen(dump_file_prefix) < 500)
 229         {
 230             char fname[1024];
 231             FILE *of;
 232             sprintf (fname, "%s.%03d.raw", dump_file_prefix, no);
 233             of = fopen(fname, "wb");
 234
 235             fwrite (buf, 1, len, of);
 236
 237             fclose(of);
 238         }
 239     }
 240 }
 241
 242 void add_otherInfos(Z_APDU *a)
 243 {
 244     Z_OtherInformation **oi;
 245     int i;
 246
 247     yaz_oi_APDU(a, &oi);
 248     for(i=0; i<maxOtherInfosSupported; ++i)
 249     {
 250         if (oid_oidlen(extraOtherInfos[i].oid) > 0)
 251             yaz_oi_set_string_oid(oi, out, extraOtherInfos[i].oid,
 252                                      1, extraOtherInfos[i].value);
 253     }
 254 }
 255
 256 int send_apdu(Z_APDU *a)
 257 {
 258     char *buf;
 259     int len;
 260
 261     add_otherInfos(a);
 262
 263     if (apdu_file)
 264     {
 265         z_APDU(print, &a, 0, 0);
 266         odr_reset(print);
 267     }
 268     if (!z_APDU(out, &a, 0, 0))
 269     {
 270         odr_perror(out, "Encoding APDU");
 271         close_session();
 272         return 0;
 273     }
 274     buf = odr_getbuf(out, &len, 0);
 275     if (ber_file)
 276         odr_dumpBER(ber_file, buf, len);
 277     /* printf ("sending APDU of size %d\n", len); */
 278     do_hex_dump(buf, len);
 279     if (cs_put(conn, buf, len) < 0)
 280     {
 281         fprintf(stderr, "cs_put: %s", cs_errmsg(cs_errno(conn)));
 282         close_session();
 283         return 0;
 284     }
 285     odr_reset(out); /* release the APDU structure  */
 286     return 1;
 287 }
 288
 289 static void print_stringn(const unsigned char *buf, size_t len)
 290 {
 291     size_t i;
 292     for (i = 0; i<len; i++)
 293         if ((buf[i] <= 126 && buf[i] >= 32) || strchr ("\n\r\t\f", buf[i]))
 294             printf ("%c", buf[i]);
 295         else
 296             printf ("\\X%02X", buf[i]);
 297 }
 298
 299 static void print_refid (Z_ReferenceId *id)
 300 {
 301     if (id)
 302     {
 303         printf ("Reference Id: ");
 304         print_stringn (id->buf, id->len);
 305         printf ("\n");
 306     }
 307 }
 308
 309 static Z_ReferenceId *set_refid (ODR out)
 310 {
 311     Z_ReferenceId *id;
 312     if (!refid)
 313         return 0;
 314     id = (Z_ReferenceId *) odr_malloc (out, sizeof(*id));
 315     id->size = id->len = strlen(refid);
 316     id->buf = (unsigned char *) odr_malloc (out, id->len);
 317     memcpy (id->buf, refid, id->len);
 318     return id;
 319 }
 320
 321 /* INIT SERVICE ------------------------------- */
 322
 323 static void send_initRequest(const char* type_and_host)
 324 {
 325     Z_APDU *apdu = zget_APDU(out, Z_APDU_initRequest);
 326     Z_InitRequest *req = apdu->u.initRequest;
 327     int i;
 328
 329     req->options = &z3950_options;
 330
 331     ODR_MASK_ZERO(req->protocolVersion);
 332     for (i = 0; i<z3950_version; i++)
 333         ODR_MASK_SET(req->protocolVersion, i);
 334
 335     *req->maximumRecordSize = 1024*kilobytes;
 336     *req->preferredMessageSize = 1024*kilobytes;
 337
 338     req->idAuthentication = auth;
 339
 340     req->referenceId = set_refid (out);
 341
 342     if (yazProxy && type_and_host)
 343     {
 344         yaz_oi_set_string_oid(&req->otherInfo, out, yaz_oid_userinfo_proxy,
 345                               1, type_and_host);
 346     }
 347
 348     if (negotiationCharset || yazLang) {
 349         Z_OtherInformation **p;
 350         Z_OtherInformationUnit *p0;
 351
 352         yaz_oi_APDU(apdu, &p);
 353
 354         if ((p0=yaz_oi_update(p, out, NULL, 0, 0)))
 355         {
 356             ODR_MASK_SET(req->options, Z_Options_negotiationModel);
 357
 358             p0->which = Z_OtherInfo_externallyDefinedInfo;
 359             p0->information.externallyDefinedInfo =
 360                 yaz_set_proposal_charneg_list(out, ",",
 361                                               negotiationCharset,
 362                                               yazLang,
 363                                               negotiationCharsetRecords);
 364         }
 365     }
 366     if (send_apdu(apdu))
 367         printf("Sent initrequest.\n");
 368 }
 369
 370
 371 /* These two are used only from process_initResponse() */
 372 static void render_initUserInfo(Z_OtherInformation *ui1);
 373 static void render_diag(Z_DiagnosticFormat *diag);
 374
 375 static void pr_opt(const char *opt, void *clientData)
 376 {
 377     printf (" %s", opt);
 378 }
 379
 380 static int process_initResponse(Z_InitResponse *res)
 381 {
 382     int ver = 0;
 383     /* save session parameters for later use */
 384     session_mem = odr_extract_mem(in);
 385     session_initResponse = res;
 386
 387     for (ver = 0; ver < 8; ver++)
 388         if (!ODR_MASK_GET(res->protocolVersion, ver))
 389             break;
 390
 391     if (!*res->result)
 392         printf("Connection rejected by v%d target.\n", ver);
 393     else
 394         printf("Connection accepted by v%d target.\n", ver);
 395     if (res->implementationId)
 396         printf("ID     : %s\n", res->implementationId);
 397     if (res->implementationName)
 398         printf("Name   : %s\n", res->implementationName);
 399     if (res->implementationVersion)
 400         printf("Version: %s\n", res->implementationVersion);
 401     if (res->userInformationField)
 402     {
 403         Z_External *uif = res->userInformationField;
 404         if (uif->which == Z_External_userInfo1) {
 405             render_initUserInfo(uif->u.userInfo1);
 406         } else {
 407             printf("UserInformationfield:\n");
 408             if (!z_External(print, (Z_External**)&uif, 0, 0))
 409             {
 410                 odr_perror(print, "Printing userinfo\n");
 411                 odr_reset(print);
 412             }
 413             if (uif->which == Z_External_octet) {
 414                 printf("Guessing visiblestring:\n");
 415                 printf("'%.*s'\n", uif->u.octet_aligned->len,
 416                        uif->u.octet_aligned->buf);
 417             }
 418             else if (uif->which == Z_External_single)
 419             {
 420                 Odr_any *sat = uif->u.single_ASN1_type;
 421                 if (!oid_oidcmp(uif->direct_reference,
 422                                 yaz_oid_userinfo_oclc_userinfo))
 423                 {
 424                     Z_OCLC_UserInformation *oclc_ui;
 425                     ODR decode = odr_createmem(ODR_DECODE);
 426                     odr_setbuf(decode, (char *) sat->buf, sat->len, 0);
 427                     if (!z_OCLC_UserInformation(decode, &oclc_ui, 0, 0))
 428                         printf ("Bad OCLC UserInformation:\n");
 429                     else
 430                         printf ("OCLC UserInformation:\n");
 431                     if (!z_OCLC_UserInformation(print, &oclc_ui, 0, 0))
 432                         printf ("Bad OCLC UserInformation spec\n");
 433                     odr_destroy(decode);
 434                 }
 435                 else
 436                 {
 437                     /* Peek at any private Init-diagnostic APDUs */
 438                     printf("### NAUGHTY: External is '%.*s'\n",
 439                            sat->len, sat->buf);
 440                 }
 441             }
 442             odr_reset (print);
 443         }
 444     }
 445     printf ("Options:");
 446     yaz_init_opt_decode(res->options, pr_opt, 0);
 447     printf ("\n");
 448
 449     if (ODR_MASK_GET(res->options, Z_Options_namedResultSets))
 450         setnumber = 0;
 451
 452     if (ODR_MASK_GET(res->options, Z_Options_negotiationModel)) {
 453
 454         Z_CharSetandLanguageNegotiation *p =
 455                 yaz_get_charneg_record(res->otherInfo);
 456
 457         if (p) {
 458
 459             char *charset=NULL, *lang=NULL;
 460             int selected;
 461
 462             yaz_get_response_charneg(session_mem, p, &charset, &lang,
 463                                      &selected);
 464
 465             printf("Accepted character set : %s\n", charset);
 466             printf("Accepted code language : %s\n", lang ? lang : "none");
 467             printf("Accepted records in ...: %d\n", selected );
 468
 469             if (outputCharset && negotiationCharset) {
 470                 printf("Converting between %s and %s\n",
 471                        outputCharset, negotiationCharset);
 472                 odr_set_charset (out, charset, outputCharset);
 473                 odr_set_charset (in, outputCharset, charset);
 474             }
 475             else {
 476                 odr_set_charset (out, 0, 0);
 477                 odr_set_charset (in, 0, 0);
 478             }
 479         }
 480     }
 481     fflush (stdout);
 482     return 0;
 483 }
 484
 485
 486 static void render_initUserInfo(Z_OtherInformation *ui1) {
 487     int i;
 488     printf("Init response contains %d otherInfo unit%s:\n",
 489            ui1->num_elements, ui1->num_elements == 1 ? "" : "s");
 490
 491     for (i = 0; i < ui1->num_elements; i++) {
 492         Z_OtherInformationUnit *unit = ui1->list[i];
 493         printf("  %d: otherInfo unit contains ", i+1);
 494         if (unit->which == Z_OtherInfo_externallyDefinedInfo &&
 495             unit->information.externallyDefinedInfo &&
 496             unit->information.externallyDefinedInfo->which ==
 497             Z_External_diag1) {
 498             render_diag(unit->information.externallyDefinedInfo->u.diag1);
 499         }
 500         else if (unit->which != Z_OtherInfo_externallyDefinedInfo)
 501         {
 502             printf("unsupported otherInfo unit->which = %d\n", unit->which);
 503         }
 504         else
 505         {
 506             printf("unsupported otherInfo unit external %d\n",
 507                    unit->information.externallyDefinedInfo ?
 508                    unit->information.externallyDefinedInfo->which : -2);
 509         }
 510     }
 511 }
 512
 513
 514 /* ### should this share code with display_diagrecs()? */
 515 static void render_diag(Z_DiagnosticFormat *diag) {
 516     int i;
 517
 518     printf("%d diagnostic%s:\n", diag->num, diag->num == 1 ? "" : "s");
 519     for (i = 0; i < diag->num; i++) {
 520         Z_DiagnosticFormat_s *ds = diag->elements[i];
 521         printf("    %d: ", i+1);
 522         switch (ds->which) {
 523         case Z_DiagnosticFormat_s_defaultDiagRec: {
 524             Z_DefaultDiagFormat *dd = ds->u.defaultDiagRec;
 525             /* ### should check `dd->diagnosticSetId' */
 526             printf("code=%d (%s)", *dd->condition,
 527                    diagbib1_str(*dd->condition));
 528             /* Both types of addinfo are the same, so use type-pun */
 529             if (dd->u.v2Addinfo != 0)
 530                 printf(",\n\taddinfo='%s'", dd->u.v2Addinfo);
 531             break;
 532         }
 533         case Z_DiagnosticFormat_s_explicitDiagnostic:
 534             printf("Explicit diagnostic (not supported)");
 535             break;
 536         default:
 537             printf("Unrecognised diagnostic type %d", ds->which);
 538             break;
 539         }
 540
 541         if (ds->message != 0)
 542             printf(", message='%s'", ds->message);
 543         printf("\n");
 544     }
 545 }
 546
 547
 548 static int set_base(const char *arg)
 549 {
 550     int i;
 551     const char *cp;
 552
 553     for (i = 0; i<num_databaseNames; i++)
 554         xfree (databaseNames[i]);
 555     num_databaseNames = 0;
 556     while (1)
 557     {
 558         char *cp1;
 559         if (!(cp = strchr(arg, ' ')))
 560             cp = arg + strlen(arg);
 561         if (cp - arg < 1)
 562             break;
 563         databaseNames[num_databaseNames] = (char *)xmalloc (1 + cp - arg);
 564         memcpy (databaseNames[num_databaseNames], arg, cp - arg);
 565         databaseNames[num_databaseNames][cp - arg] = '\0';
 566
 567         for (cp1 = databaseNames[num_databaseNames]; *cp1 ; cp1++)
 568             if (*cp1 == '+')
 569                 *cp1 = ' ';
 570         num_databaseNames++;
 571
 572         if (!*cp)
 573             break;
 574         arg = cp+1;
 575     }
 576     if (num_databaseNames == 0)
 577     {
 578         num_databaseNames = 1;
 579         databaseNames[0] = xstrdup("");
 580     }
 581     return 1;
 582 }
 583
 584 static int parse_cmd_doc(const char **arg, ODR out, char **buf,
 585                          int *len, int opt)
 586 {
 587     const char *sep;
 588     while (**arg && strchr(" \t\n\r\f", **arg))
 589         (*arg)++;
 590     if ((*arg)[0] == '\"' && (sep=strchr(*arg+1, '"')))
 591     {
 592         (*arg)++;
 593         *len = sep - *arg;
 594         *buf = odr_strdupn(out, *arg, *len);
 595         (*arg) = sep+1;
 596         return 1;
 597     }
 598     else if ((*arg)[0] && (*arg)[0] != '\"')
 599     {
 600         long fsize;
 601         FILE *inf;
 602         const char *fname = *arg;
 603
 604         while (**arg != '\0' && **arg != ' ')
 605             (*arg)++;
 606
 607         inf = fopen(fname, "rb");
 608         if (!inf)
 609         {
 610             printf("Couldn't open %s\n", fname);
 611             return 0;
 612         }
 613         if (fseek(inf, 0L, SEEK_END) == -1)
 614         {
 615             printf("Couldn't seek in %s\n", fname);
 616             fclose(inf);
 617             return 0;
 618         }
 619         fsize = ftell(inf);
 620         if (fseek(inf, 0L, SEEK_SET) == -1)
 621         {
 622             printf("Couldn't seek in %s\n", fname);
 623             fclose(inf);
 624             return 0;
 625         }
 626         *len = fsize;
 627         *buf = (char *) odr_malloc(out, fsize);
 628         if (fread(*buf, 1, fsize, inf) != fsize)
 629         {
 630             printf("Unable to read %s\n", fname);
 631             fclose(inf);
 632             return 0;
 633         }
 634         fclose(inf);
 635         return 1;
 636     }
 637     else if (**arg == '\0')
 638     {
 639         if (opt)
 640         {
 641             *len = 0;
 642             *buf = 0;
 643             return 1;
 644         }
 645         printf("Missing doc argument\n");
 646     }
 647     else
 648         printf("Bad doc argument %s\n", *arg);
 649     return 0;
 650 }
 651
 652 static int cmd_base(const char *arg)
 653 {
 654     if (!*arg)
 655     {
 656         printf("Usage: base <database> <database> ...\n");
 657         return 0;
 658     }
 659     return set_base(arg);
 660 }
 661
 662 void cmd_open_remember_last_open_command(const char* arg, char* new_open_command)
 663 {
 664     if(last_open_command != arg)
 665     {
 666         if(last_open_command) xfree(last_open_command);
 667         last_open_command = xstrdup(new_open_command);
 668     }
 669 }
 670
 671 int session_connect(const char *arg)
 672 {
 673     void *add;
 674     char type_and_host[101];
 675     const char *basep = 0;
 676 #if HAVE_OPENSSL_SSL_H
 677     SSL *ssl;
 678 #endif
 679     if (conn)
 680     {
 681         cs_close (conn);
 682         conn = 0;
 683     }
 684     if (session_mem)
 685     {
 686         nmem_destroy (session_mem);
 687         session_mem = NULL;
 688         session_initResponse = 0;
 689     }
 690     cs_get_host_args(arg, &basep);
 691
 692     strncpy(type_and_host, arg, sizeof(type_and_host)-1);
 693     type_and_host[sizeof(type_and_host)-1] = '\0';
 694
 695     cmd_open_remember_last_open_command(arg, type_and_host);
 696
 697     if (yazProxy)
 698         conn = cs_create_host(yazProxy, 1, &add);
 699     else
 700         conn = cs_create_host(arg, 1, &add);
 701     if (!conn)
 702     {
 703         printf ("Could not resolve address %s\n", arg);
 704         return 0;
 705     }
 706 #if YAZ_HAVE_XML2
 707     if (conn->protocol == PROTO_HTTP)
 708         queryType = QueryType_CQL;
 709 #else
 710     if (conn->protocol == PROTO_HTTP)
 711     {
 712         printf ("SRW/HTTP not enabled in this YAZ\n");
 713         cs_close(conn);
 714         conn = 0;
 715         return 0;
 716     }
 717 #endif
 718     protocol = conn->protocol;
 719     if (conn->protocol == PROTO_HTTP)
 720         set_base("");
 721     else
 722         set_base("Default");
 723     printf("Connecting...");
 724     fflush(stdout);
 725     if (cs_connect(conn, add) < 0)
 726     {
 727         printf ("error = %s\n", cs_strerror(conn));
 728         cs_close(conn);
 729         conn = 0;
 730         return 0;
 731     }
 732     printf("OK.\n");
 733 #if HAVE_OPENSSL_SSL_H
 734     if ((ssl = (SSL *) cs_get_ssl(conn)))
 735     {
 736         X509 *server_cert = SSL_get_peer_certificate (ssl);
 737
 738         if (server_cert)
 739         {
 740             char *pem_buf;
 741             int pem_len;
 742             BIO *bio = BIO_new(BIO_s_mem());
 743
 744             /* get PEM buffer in memory */
 745             PEM_write_bio_X509(bio, server_cert);
 746             pem_len = BIO_get_mem_data(bio, &pem_buf);
 747             fwrite(pem_buf, pem_len, 1, stdout);
 748
 749             /* print all info on screen .. */
 750             X509_print_fp(stdout, server_cert);
 751             BIO_free(bio);
 752
 753             X509_free (server_cert);
 754         }
 755     }
 756 #endif
 757     if (basep && *basep)
 758         set_base (basep);
 759     if (protocol == PROTO_Z3950)
 760     {
 761         send_initRequest(type_and_host);
 762         return 2;
 763     }
 764     return 0;
 765 }
 766
 767 int cmd_open(const char *arg)
 768 {
 769     if (arg)
 770     {
 771         strncpy (cur_host, arg, sizeof(cur_host)-1);
 772         cur_host[sizeof(cur_host)-1] = 0;
 773     }
 774     return session_connect(cur_host);
 775 }
 776
 777 void try_reconnect(void)
 778 {
 779     char* open_command;
 780
 781     if(!( auto_reconnect && last_open_command) ) return ;
 782
 783     open_command = (char *) xmalloc (strlen(last_open_command)+6);
 784     strcpy (open_command, "open ");
 785
 786     strcat (open_command, last_open_command);
 787
 788     process_cmd_line(open_command);
 789
 790     xfree(open_command);
 791 }
 792
 793 int cmd_authentication(const char *arg)
 794 {
 795     static Z_IdAuthentication au;
 796     static char user[40], group[40], pass[40];
 797     static Z_IdPass idPass;
 798     int r;
 799
 800     if (!*arg)
 801     {
 802         printf("Auth field set to null\n");
 803         auth = 0;
 804         return 1;
 805     }
 806     r = sscanf (arg, "%39s %39s %39s", user, group, pass);
 807     if (r == 0)
 808     {
 809         printf("Authentication set to null\n");
 810         auth = 0;
 811     }
 812     if (r == 1)
 813     {
 814         auth = &au;
 815         if (!strcmp(user, "-")) {
 816             au.which = Z_IdAuthentication_anonymous;
 817             printf("Authentication set to Anonymous\n");
 818         } else {
 819             au.which = Z_IdAuthentication_open;
 820             au.u.open = user;
 821             printf("Authentication set to Open (%s)\n", user);
 822         }
 823     }
 824     if (r == 2)
 825     {
 826         auth = &au;
 827         au.which = Z_IdAuthentication_idPass;
 828         au.u.idPass = &idPass;
 829         idPass.groupId = NULL;
 830         idPass.userId = user;
 831         idPass.password = group;
 832         printf("Authentication set to User (%s), Pass (%s)\n", user, group);
 833     }
 834     if (r == 3)
 835     {
 836         auth = &au;
 837         au.which = Z_IdAuthentication_idPass;
 838         au.u.idPass = &idPass;
 839         idPass.groupId = group;
 840         idPass.userId = user;
 841         idPass.password = pass;
 842         printf("Authentication set to User (%s), Group (%s), Pass (%s)\n",
 843                user, group, pass);
 844     }
 845     return 1;
 846 }
 847
 848 /* SEARCH SERVICE ------------------------------ */
 849 static void display_record(Z_External *r);
 850
 851 static void print_record(const unsigned char *buf, size_t len)
 852 {
 853     size_t i = len;
 854     print_stringn (buf, len);
 855     /* add newline if not already added ... */
 856     if (i <= 0 || buf[i-1] != '\n')
 857         printf ("\n");
 858 }
 859
 860 static void display_record(Z_External *r)
 861 {
 862     const Odr_oid *oid = r->direct_reference;
 863
 864     record_last = r;
 865     /*
 866      * Tell the user what we got.
 867      */
 868     if (oid)
 869     {
 870         oid_class oclass;
 871         char oid_name_buf[OID_STR_MAX];
 872         const char *oid_name
 873             =  yaz_oid_to_string_buf(oid, &oclass, oid_name_buf);
 874         printf("Record type: ");
 875         if (oid_name)
 876             printf("%s\n", oid_name);
 877     }
 878     /* Check if this is a known, ASN.1 type tucked away in an octet string */
 879     if (r->which == Z_External_octet)
 880     {
 881         Z_ext_typeent *type = z_ext_getentbyref(r->direct_reference);
 882         char *rr;
 883
 884         if (type)
 885         {
 886             /*
 887              * Call the given decoder to process the record.
 888              */
 889             odr_setbuf(in, (char*)r->u.octet_aligned->buf,
 890                 r->u.octet_aligned->len, 0);
 891             if (!(*type->fun)(in, &rr, 0, 0))
 892             {
 893                 odr_perror(in, "Decoding constructed record.");
 894                 fprintf(stdout, "[Near %ld]\n", (long) odr_offset(in));
 895                 fprintf(stdout, "Packet dump:\n---------\n");
 896                 odr_dumpBER(stdout, (char*)r->u.octet_aligned->buf,
 897                             r->u.octet_aligned->len);
 898                 fprintf(stdout, "---------\n");
 899
 900                 /* note just ignores the error ant print the bytes form the octet_aligned later */
 901             } else {
 902                 /*
 903                  * Note: we throw away the original, BER-encoded record here.
 904                  * Do something else with it if you want to keep it.
 905                  */
 906                 r->u.sutrs = (Z_SUTRS *) rr; /* we don't actually check the type here. */
 907                 r->which = type->what;
 908             }
 909         }
 910     }
 911     if (oid && !oid_oidcmp(oid, yaz_oid_recsyn_soif))
 912     {
 913         print_record((const unsigned char *) r->u.octet_aligned->buf,
 914                      r->u.octet_aligned->len);
 915         if (marc_file)
 916             fwrite (r->u.octet_aligned->buf, 1, r->u.octet_aligned->len, marc_file);
 917     }
 918     else if (oid && r->which == Z_External_octet)
 919     {
 920         const char *octet_buf = (char*)r->u.octet_aligned->buf;
 921         if (oid && (!oid_oidcmp(oid, yaz_oid_recsyn_xml)
 922                     || !oid_oidcmp(oid, yaz_oid_recsyn_xml)
 923                     || !oid_oidcmp(oid, yaz_oid_recsyn_html)))
 924         {
 925             print_record((const unsigned char *) octet_buf,
 926                          r->u.octet_aligned->len);
 927         }
 928         else if (oid && !oid_oidcmp(oid, yaz_oid_recsyn_postscript))
 929         {
 930             int size = r->u.octet_aligned->len;
 931             if (size > 100)
 932                 size = 100;
 933             print_record((const unsigned char *) octet_buf, size);
 934         }
 935         else
 936         {
 937             if (oid && yaz_oid_is_iso2709(oid))
 938             {
 939                 const char *result;
 940                 size_t rlen;
 941                 yaz_iconv_t cd = 0;
 942                 yaz_marc_t mt = yaz_marc_create();
 943                 const char *from = 0;
 944
 945                 if (marcCharset && !strcmp(marcCharset, "auto"))
 946                 {
 947                     if (!oid_oidcmp(oid, yaz_oid_recsyn_usmarc))
 948                     {
 949                         if (octet_buf[9] == 'a')
 950                             from = "UTF-8";
 951                         else
 952                             from = "MARC-8";
 953                     }
 954                     else
 955                         from = "ISO-8859-1";
 956                 }
 957                 else if (marcCharset)
 958                     from = marcCharset;
 959                 if (outputCharset && from)
 960                 {
 961                     cd = yaz_iconv_open(outputCharset, from);
 962                     printf ("convert from %s to %s", from,
 963                             outputCharset);
 964                     if (!cd)
 965                         printf (" unsupported\n");
 966                     else
 967                     {
 968                         yaz_marc_iconv(mt, cd);
 969                         printf ("\n");
 970                     }
 971                 }
 972
 973                 if (yaz_marc_decode_buf(mt, octet_buf, r->u.octet_aligned->len,
 974                                         &result, &rlen)> 0)
 975                 {
 976                     fwrite (result, rlen, 1, stdout);
 977                 }
 978                 else
 979                 {
 980                     printf ("bad MARC. Dumping as it is:\n");
 981                     print_record((const unsigned char*) octet_buf,
 982                                   r->u.octet_aligned->len);
 983                 }
 984                 yaz_marc_destroy(mt);
 985                 if (cd)
 986                     yaz_iconv_close(cd);
 987             }
 988             else
 989             {
 990                 print_record((const unsigned char*) octet_buf,
 991                              r->u.octet_aligned->len);
 992             }
 993         }
 994         if (marc_file)
 995             fwrite (octet_buf, 1, r->u.octet_aligned->len, marc_file);
 996     }
 997     else if (oid && !oid_oidcmp(oid, yaz_oid_recsyn_sutrs))
 998     {
 999         if (r->which != Z_External_sutrs)
1000         {
1001             printf("Expecting single SUTRS type for SUTRS.\n");
1002             return;
1003         }
1004         print_record(r->u.sutrs->buf, r->u.sutrs->len);
1005         if (marc_file)
1006             fwrite (r->u.sutrs->buf, 1, r->u.sutrs->len, marc_file);
1007     }
1008     else if (oid && !oid_oidcmp(oid, yaz_oid_recsyn_grs_1))
1009     {
1010         WRBUF w;
1011         if (r->which != Z_External_grs1)
1012         {
1013             printf("Expecting single GRS type for GRS.\n");
1014             return;
1015         }
1016         w = wrbuf_alloc();
1017         yaz_display_grs1(w, r->u.grs1, 0);
1018         puts (wrbuf_cstr(w));
1019         wrbuf_destroy(w);
1020     }
1021     else if (oid && !oid_oidcmp(oid, yaz_oid_recsyn_opac))
1022     {
1023         int i;
1024         if (r->u.opac->bibliographicRecord)
1025             display_record(r->u.opac->bibliographicRecord);
1026         for (i = 0; i<r->u.opac->num_holdingsData; i++)
1027         {
1028             Z_HoldingsRecord *h = r->u.opac->holdingsData[i];
1029             if (h->which == Z_HoldingsRecord_marcHoldingsRecord)
1030             {
1031                 printf ("MARC holdings %d\n", i);
1032                 display_record(h->u.marcHoldingsRecord);
1033             }
1034             else if (h->which == Z_HoldingsRecord_holdingsAndCirc)
1035             {
1036                 int j;
1037
1038                 Z_HoldingsAndCircData *data = h->u.holdingsAndCirc;
1039
1040                 printf ("Data holdings %d\n", i);
1041                 if (data->typeOfRecord)
1042                     printf ("typeOfRecord: %s\n", data->typeOfRecord);
1043                 if (data->encodingLevel)
1044                     printf ("encodingLevel: %s\n", data->encodingLevel);
1045                 if (data->receiptAcqStatus)
1046                     printf ("receiptAcqStatus: %s\n", data->receiptAcqStatus);
1047                 if (data->generalRetention)
1048                     printf ("generalRetention: %s\n", data->generalRetention);
1049                 if (data->completeness)
1050                     printf ("completeness: %s\n", data->completeness);
1051                 if (data->dateOfReport)
1052                     printf ("dateOfReport: %s\n", data->dateOfReport);
1053                 if (data->nucCode)
1054                     printf ("nucCode: %s\n", data->nucCode);
1055                 if (data->localLocation)
1056                     printf ("localLocation: %s\n", data->localLocation);
1057                 if (data->shelvingLocation)
1058                     printf ("shelvingLocation: %s\n", data->shelvingLocation);
1059                 if (data->callNumber)
1060                     printf ("callNumber: %s\n", data->callNumber);
1061                 if (data->shelvingData)
1062                     printf ("shelvingData: %s\n", data->shelvingData);
1063                 if (data->copyNumber)
1064                     printf ("copyNumber: %s\n", data->copyNumber);
1065                 if (data->publicNote)
1066                     printf ("publicNote: %s\n", data->publicNote);
1067                 if (data->reproductionNote)
1068                     printf ("reproductionNote: %s\n", data->reproductionNote);
1069                 if (data->termsUseRepro)
1070                     printf ("termsUseRepro: %s\n", data->termsUseRepro);
1071                 if (data->enumAndChron)
1072                     printf ("enumAndChron: %s\n", data->enumAndChron);
1073                 for (j = 0; j<data->num_volumes; j++)
1074                 {
1075                     printf ("volume %d\n", j);
1076                     if (data->volumes[j]->enumeration)
1077                         printf (" enumeration: %s\n",
1078                                 data->volumes[j]->enumeration);
1079                     if (data->volumes[j]->chronology)
1080                         printf (" chronology: %s\n",
1081                                 data->volumes[j]->chronology);
1082                     if (data->volumes[j]->enumAndChron)
1083                         printf (" enumAndChron: %s\n",
1084                                 data->volumes[j]->enumAndChron);
1085                 }
1086                 for (j = 0; j<data->num_circulationData; j++)
1087                 {
1088                     printf ("circulation %d\n", j);
1089                     if (data->circulationData[j]->availableNow)
1090                         printf (" availableNow: %d\n",
1091                                 *data->circulationData[j]->availableNow);
1092                     if (data->circulationData[j]->availablityDate)
1093                         printf (" availabiltyDate: %s\n",
1094                                 data->circulationData[j]->availablityDate);
1095                     if (data->circulationData[j]->availableThru)
1096                         printf (" availableThru: %s\n",
1097                                 data->circulationData[j]->availableThru);
1098                     if (data->circulationData[j]->restrictions)
1099                         printf (" restrictions: %s\n",
1100                                 data->circulationData[j]->restrictions);
1101                     if (data->circulationData[j]->itemId)
1102                         printf (" itemId: %s\n",
1103                                 data->circulationData[j]->itemId);
1104                     if (data->circulationData[j]->renewable)
1105                         printf (" renewable: %d\n",
1106                                 *data->circulationData[j]->renewable);
1107                     if (data->circulationData[j]->onHold)
1108                         printf (" onHold: %d\n",
1109                                 *data->circulationData[j]->onHold);
1110                     if (data->circulationData[j]->enumAndChron)
1111                         printf (" enumAndChron: %s\n",
1112                                 data->circulationData[j]->enumAndChron);
1113                     if (data->circulationData[j]->midspine)
1114                         printf (" midspine: %s\n",
1115                                 data->circulationData[j]->midspine);
1116                     if (data->circulationData[j]->temporaryLocation)
1117                         printf (" temporaryLocation: %s\n",
1118                                 data->circulationData[j]->temporaryLocation);
1119                 }
1120             }
1121         }
1122     }
1123     else
1124     {
1125         printf("Unknown record representation.\n");
1126         if (!z_External(print, &r, 0, 0))
1127         {
1128             odr_perror(print, "Printing external");
1129             odr_reset(print);
1130         }
1131     }
1132 }
1133
1134 static void display_diagrecs(Z_DiagRec **pp, int num)
1135 {
1136     int i;
1137     Z_DefaultDiagFormat *r;
1138
1139     printf("Diagnostic message(s) from database:\n");
1140     for (i = 0; i<num; i++)
1141     {
1142         Z_DiagRec *p = pp[i];
1143         if (p->which != Z_DiagRec_defaultFormat)
1144         {
1145             printf("Diagnostic record not in default format.\n");
1146             return;
1147         }
1148         else
1149             r = p->u.defaultFormat;
1150
1151         if (!r->diagnosticSetId)
1152             printf("Missing diagset\n");
1153         else
1154         {
1155             oid_class oclass;
1156             char diag_name_buf[OID_STR_MAX];
1157             const char *diag_name = 0;
1158             diag_name = yaz_oid_to_string_buf
1159                 (r->diagnosticSetId, &oclass, diag_name_buf);
1160             if (oid_oidcmp(r->diagnosticSetId, yaz_oid_diagset_bib_1))
1161                 printf("Unknown diagset: %s\n", diag_name);
1162         }
1163         printf("    [%d] %s", *r->condition, diagbib1_str(*r->condition));
1164         switch (r->which)
1165         {
1166         case Z_DefaultDiagFormat_v2Addinfo:
1167             printf (" -- v2 addinfo '%s'\n", r->u.v2Addinfo);
1168             break;
1169         case Z_DefaultDiagFormat_v3Addinfo:
1170             printf (" -- v3 addinfo '%s'\n", r->u.v3Addinfo);
1171             break;
1172         }
1173     }
1174 }
1175
1176
1177 static void display_nameplusrecord(Z_NamePlusRecord *p)
1178 {
1179     if (p->databaseName)
1180         printf("[%s]", p->databaseName);
1181     if (p->which == Z_NamePlusRecord_surrogateDiagnostic)
1182         display_diagrecs(&p->u.surrogateDiagnostic, 1);
1183     else if (p->which == Z_NamePlusRecord_databaseRecord)
1184         display_record(p->u.databaseRecord);
1185 }
1186
1187 static void display_records(Z_Records *p)
1188 {
1189     int i;
1190
1191     if (p->which == Z_Records_NSD)
1192     {
1193         Z_DiagRec dr, *dr_p = &dr;
1194         dr.which = Z_DiagRec_defaultFormat;
1195         dr.u.defaultFormat = p->u.nonSurrogateDiagnostic;
1196         display_diagrecs (&dr_p, 1);
1197     }
1198     else if (p->which == Z_Records_multipleNSD)
1199         display_diagrecs (p->u.multipleNonSurDiagnostics->diagRecs,
1200                           p->u.multipleNonSurDiagnostics->num_diagRecs);
1201     else
1202     {
1203         printf("Records: %d\n", p->u.databaseOrSurDiagnostics->num_records);
1204         for (i = 0; i < p->u.databaseOrSurDiagnostics->num_records; i++)
1205             display_nameplusrecord(p->u.databaseOrSurDiagnostics->records[i]);
1206     }
1207 }
1208
1209 static int send_deleteResultSetRequest(const char *arg)
1210 {
1211     char names[8][32];
1212     int i;
1213
1214     Z_APDU *apdu = zget_APDU(out, Z_APDU_deleteResultSetRequest);
1215     Z_DeleteResultSetRequest *req = apdu->u.deleteResultSetRequest;
1216
1217     req->referenceId = set_refid (out);
1218
1219     req->num_resultSetList =
1220         sscanf (arg, "%30s %30s %30s %30s %30s %30s %30s %30s",
1221                 names[0], names[1], names[2], names[3],
1222                 names[4], names[5], names[6], names[7]);
1223
1224     req->deleteFunction = (int *)
1225         odr_malloc (out, sizeof(*req->deleteFunction));
1226     if (req->num_resultSetList > 0)
1227     {
1228         *req->deleteFunction = Z_DeleteResultSetRequest_list;
1229         req->resultSetList = (char **)
1230             odr_malloc (out, sizeof(*req->resultSetList)*
1231                         req->num_resultSetList);
1232         for (i = 0; i<req->num_resultSetList; i++)
1233             req->resultSetList[i] = names[i];
1234     }
1235     else
1236     {
1237         *req->deleteFunction = Z_DeleteResultSetRequest_all;
1238         req->resultSetList = 0;
1239     }
1240
1241     send_apdu(apdu);
1242     printf("Sent deleteResultSetRequest.\n");
1243     return 2;
1244 }
1245
1246 #if YAZ_HAVE_XML2
1247 static int send_srw(Z_SRW_PDU *sr)
1248 {
1249     const char *charset = negotiationCharset;
1250     const char *host_port = cur_host;
1251     Z_GDU *gdu;
1252     char *path = 0;
1253
1254     path = (char *) odr_malloc(out, 2+strlen(databaseNames[0]));
1255     *path = '/';
1256     strcpy(path+1, databaseNames[0]);
1257
1258     gdu = z_get_HTTP_Request_host_path(out, host_port, path);
1259
1260     if (!strcmp(sru_method, "get"))
1261     {
1262         yaz_sru_get_encode(gdu->u.HTTP_Request, sr, out, charset);
1263     }
1264     else if (!strcmp(sru_method, "post"))
1265     {
1266         yaz_sru_post_encode(gdu->u.HTTP_Request, sr, out, charset);
1267     }
1268     else if (!strcmp(sru_method, "soap"))
1269     {
1270         yaz_sru_soap_encode(gdu->u.HTTP_Request, sr, out, charset);
1271     }
1272
1273     if (z_GDU(out, &gdu, 0, 0))
1274     {
1275         /* encode OK */
1276         char *buf_out;
1277         int len_out;
1278         int r;
1279         if (apdu_file)
1280         {
1281             if (!z_GDU(print, &gdu, 0, 0))
1282                 printf ("Failed to print outgoing SRU package\n");
1283             odr_reset(print);
1284         }
1285         buf_out = odr_getbuf(out, &len_out, 0);
1286
1287         /* we don't odr_reset(out), since we may need the buffer again */
1288
1289         do_hex_dump(buf_out, len_out);
1290
1291         r = cs_put(conn, buf_out, len_out);
1292
1293         if (r >= 0)
1294             return 2;
1295     }
1296     return 0;
1297 }
1298 #endif
1299
1300 #if YAZ_HAVE_XML2
1301 static char *encode_SRW_term(ODR o, const char *q)
1302 {
1303     const char *in_charset = "ISO-8859-1";
1304     WRBUF w = wrbuf_alloc();
1305     yaz_iconv_t cd;
1306     char *res;
1307     if (outputCharset)
1308         in_charset = outputCharset;
1309     cd = yaz_iconv_open("UTF-8", in_charset);
1310     if (!cd)
1311     {
1312         wrbuf_destroy(w);
1313         return odr_strdup(o, q);
1314     }
1315     wrbuf_iconv_write(w, cd, q, strlen(q));
1316     if (wrbuf_len(w))
1317         res = odr_strdup(o, wrbuf_cstr(w));
1318     else
1319         res = odr_strdup(o, q);
1320     yaz_iconv_close(cd);
1321     wrbuf_destroy(w);
1322     return res;
1323 }
1324
1325
1326 static int send_SRW_scanRequest(const char *arg, int pos, int num)
1327 {
1328     Z_SRW_PDU *sr = 0;
1329
1330     /* regular requestse .. */
1331     sr = yaz_srw_get(out, Z_SRW_scan_request);
1332
1333     switch(queryType)
1334     {
1335     case QueryType_CQL:
1336         sr->u.scan_request->query_type = Z_SRW_query_type_cql;
1337         sr->u.scan_request->scanClause.cql = encode_SRW_term(out, arg);
1338         break;
1339     case QueryType_Prefix:
1340         sr->u.scan_request->query_type = Z_SRW_query_type_pqf;
1341         sr->u.scan_request->scanClause.pqf = encode_SRW_term(out, arg);
1342         break;
1343     default:
1344         printf ("Only CQL and PQF supported in SRW\n");
1345         return 0;
1346     }
1347     sr->u.scan_request->responsePosition = odr_intdup(out, pos);
1348     sr->u.scan_request->maximumTerms = odr_intdup(out, num);
1349     return send_srw(sr);
1350 }
1351
1352 static int send_SRW_searchRequest(const char *arg)
1353 {
1354     Z_SRW_PDU *sr = 0;
1355
1356     if (!srw_sr)
1357     {
1358         assert(srw_sr_odr_out == 0);
1359         srw_sr_odr_out = odr_createmem(ODR_ENCODE);
1360     }
1361     odr_reset(srw_sr_odr_out);
1362
1363     setno = 1;
1364
1365     /* save this for later .. when fetching individual records */
1366     srw_sr =  yaz_srw_get(srw_sr_odr_out, Z_SRW_searchRetrieve_request);
1367
1368     /* regular request .. */
1369     sr = yaz_srw_get(out, Z_SRW_searchRetrieve_request);
1370
1371     switch(queryType)
1372     {
1373     case QueryType_CQL:
1374         srw_sr->u.request->query_type = Z_SRW_query_type_cql;
1375         srw_sr->u.request->query.cql = encode_SRW_term(srw_sr_odr_out, arg);
1376
1377         sr->u.request->query_type = Z_SRW_query_type_cql;
1378         sr->u.request->query.cql = encode_SRW_term(srw_sr_odr_out, arg);
1379         break;
1380     case QueryType_Prefix:
1381         srw_sr->u.request->query_type = Z_SRW_query_type_pqf;
1382         srw_sr->u.request->query.pqf = encode_SRW_term(srw_sr_odr_out, arg);
1383
1384         sr->u.request->query_type = Z_SRW_query_type_pqf;
1385         sr->u.request->query.pqf = encode_SRW_term(srw_sr_odr_out, arg);
1386         break;
1387     default:
1388         printf ("Only CQL and PQF supported in SRW\n");
1389         return 0;
1390     }
1391     sr->u.request->maximumRecords = odr_intdup(out, 0);
1392
1393     if (record_schema)
1394         sr->u.request->recordSchema = record_schema;
1395     if (recordsyntax_size == 1 && !yaz_matchstr(recordsyntax_list[0], "xml"))
1396         sr->u.request->recordPacking = "xml";
1397     return send_srw(sr);
1398 }
1399 #endif
1400
1401 static void query_charset_convert(Z_RPNQuery *q)
1402 {
1403     if (queryCharset && outputCharset)
1404     {
1405         yaz_iconv_t cd = yaz_iconv_open(queryCharset, outputCharset);
1406         if (!cd)
1407         {
1408             printf("Conversion from %s to %s unsupported\n",
1409                    outputCharset, queryCharset);
1410             return;
1411         }
1412         yaz_query_charset_convert_rpnquery(q, out, cd);
1413         yaz_iconv_close(cd);
1414     }
1415 }
1416
1417 static int send_searchRequest(const char *arg)
1418 {
1419     Z_APDU *apdu = zget_APDU(out, Z_APDU_searchRequest);
1420     Z_SearchRequest *req = apdu->u.searchRequest;
1421     Z_Query query;
1422     struct ccl_rpn_node *rpn = NULL;
1423     int error, pos;
1424     char setstring[100];
1425     Z_RPNQuery *RPNquery;
1426     Odr_oct ccl_query;
1427     YAZ_PQF_Parser pqf_parser;
1428     Z_External *ext;
1429     QueryType myQueryType = queryType;
1430     char pqfbuf[512];
1431
1432     if (myQueryType == QueryType_CCL2RPN)
1433     {
1434         rpn = ccl_find_str(bibset, arg, &error, &pos);
1435         if (error)
1436         {
1437             printf("CCL ERROR: %s\n", ccl_err_msg(error));
1438             return 0;
1439         }
1440     } else if (myQueryType == QueryType_CQL2RPN) {
1441         /* ### All this code should be wrapped in a utility function */
1442         CQL_parser parser;
1443         struct cql_node *node;
1444         const char *addinfo;
1445         if (cqltrans == 0) {
1446             printf("Can't use CQL: no translation file.  Try set_cqlfile\n");
1447             return 0;
1448         }
1449         parser = cql_parser_create();
1450         if ((error = cql_parser_string(parser, arg)) != 0) {
1451             printf("Can't parse CQL: must be a syntax error\n");
1452             return 0;
1453         }
1454         node = cql_parser_result(parser);
1455         if ((error = cql_transform_buf(cqltrans, node, pqfbuf,
1456                                        sizeof pqfbuf)) != 0) {
1457             error = cql_transform_error(cqltrans, &addinfo);
1458             printf ("Can't convert CQL to PQF: %s (addinfo=%s)\n",
1459                     cql_strerror(error), addinfo);
1460             return 0;
1461         }
1462         arg = pqfbuf;
1463         myQueryType = QueryType_Prefix;
1464     }
1465
1466     req->referenceId = set_refid (out);
1467     if (!strcmp(arg, "@big")) /* strictly for troublemaking */
1468     {
1469         static unsigned char big[2100];
1470         static Odr_oct bigo;
1471
1472         /* send a very big referenceid to test transport stack etc. */
1473         memset(big, 'A', 2100);
1474         bigo.len = bigo.size = 2100;
1475         bigo.buf = big;
1476         req->referenceId = &bigo;
1477     }
1478
1479     if (setnumber >= 0)
1480     {
1481         sprintf(setstring, "%d", ++setnumber);
1482         req->resultSetName = setstring;
1483     }
1484     *req->smallSetUpperBound = smallSetUpperBound;
1485     *req->largeSetLowerBound = largeSetLowerBound;
1486     *req->mediumSetPresentNumber = mediumSetPresentNumber;
1487     if (smallSetUpperBound > 0 || (largeSetLowerBound > 1 &&
1488         mediumSetPresentNumber > 0))
1489     {
1490         if (recordsyntax_size)
1491             req->preferredRecordSyntax =
1492                 yaz_string_to_oid_odr(yaz_oid_std(),
1493                                       CLASS_RECSYN, recordsyntax_list[0], out);
1494
1495         req->smallSetElementSetNames =
1496             req->mediumSetElementSetNames = elementSetNames;
1497     }
1498     req->num_databaseNames = num_databaseNames;
1499     req->databaseNames = databaseNames;
1500
1501     req->query = &query;
1502
1503     switch (myQueryType)
1504     {
1505     case QueryType_Prefix:
1506         query.which = Z_Query_type_1;
1507         pqf_parser = yaz_pqf_create ();
1508         RPNquery = yaz_pqf_parse (pqf_parser, out, arg);
1509         if (!RPNquery)
1510         {
1511             const char *pqf_msg;
1512             size_t off;
1513             int code = yaz_pqf_error (pqf_parser, &pqf_msg, &off);
1514             int ioff = off;
1515             printf("%*s^\n", ioff+4, "");
1516             printf("Prefix query error: %s (code %d)\n", pqf_msg, code);
1517
1518             yaz_pqf_destroy (pqf_parser);
1519             return 0;
1520         }
1521         yaz_pqf_destroy (pqf_parser);
1522         query_charset_convert(RPNquery);
1523         query.u.type_1 = RPNquery;
1524         break;
1525     case QueryType_CCL:
1526         query.which = Z_Query_type_2;
1527         query.u.type_2 = &ccl_query;
1528         ccl_query.buf = (unsigned char*) arg;
1529         ccl_query.len = strlen(arg);
1530         break;
1531     case QueryType_CCL2RPN:
1532         query.which = Z_Query_type_1;
1533         RPNquery = ccl_rpn_query(out, rpn);
1534         if (!RPNquery)
1535         {
1536             printf ("Couldn't convert from CCL to RPN\n");
1537             return 0;
1538         }
1539         query_charset_convert(RPNquery);
1540         query.u.type_1 = RPNquery;
1541         ccl_rpn_delete (rpn);
1542         break;
1543     case QueryType_CQL:
1544         query.which = Z_Query_type_104;
1545         ext = (Z_External *) odr_malloc(out, sizeof(*ext));
1546         ext->direct_reference = odr_getoidbystr(out, "1.2.840.10003.16.2");
1547         ext->indirect_reference = 0;
1548         ext->descriptor = 0;
1549         ext->which = Z_External_CQL;
1550         ext->u.cql = odr_strdup(out, arg);
1551         query.u.type_104 =  ext;
1552         break;
1553     default:
1554         printf ("Unsupported query type\n");
1555         return 0;
1556     }
1557     if (send_apdu(apdu))
1558         printf("Sent searchRequest.\n");
1559     setno = 1;
1560     return 2;
1561 }
1562
1563 /* display Query Expression as part of searchResult-1 */
1564 static void display_queryExpression (const char *lead, Z_QueryExpression *qe)
1565 {
1566     if (!qe)
1567         return;
1568     printf(" %s=", lead);
1569     if (qe->which == Z_QueryExpression_term)
1570     {
1571         if (qe->u.term->queryTerm)
1572         {
1573             Z_Term *term = qe->u.term->queryTerm;
1574             switch (term->which)
1575             {
1576             case Z_Term_general:
1577                 printf ("%.*s", term->u.general->len, term->u.general->buf);
1578                 break;
1579             case Z_Term_characterString:
1580                 printf ("%s", term->u.characterString);
1581                 break;
1582             case Z_Term_numeric:
1583                 printf ("%d", *term->u.numeric);
1584                 break;
1585             case Z_Term_null:
1586                 printf ("null");
1587                 break;
1588             }
1589         }
1590     }
1591 }
1592
1593 /* see if we can find USR:SearchResult-1 */
1594 static void display_searchResult (Z_OtherInformation *o)
1595 {
1596     int i;
1597     if (!o)
1598         return ;
1599     for (i = 0; i < o->num_elements; i++)
1600     {
1601         if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
1602         {
1603             Z_External *ext = o->list[i]->information.externallyDefinedInfo;
1604
1605             if (ext->which == Z_External_searchResult1)
1606             {
1607                 int j;
1608                 Z_SearchInfoReport *sr = ext->u.searchResult1;
1609                 printf ("SearchResult-1:");
1610                 for (j = 0; j < sr->num; j++)
1611                 {
1612                     if (j)
1613                         printf(",");
1614                     if (!sr->elements[j]->subqueryExpression)
1615                         printf("%d", j);
1616                     display_queryExpression("term",
1617                         sr->elements[j]->subqueryExpression);
1618                     display_queryExpression("interpretation",
1619                         sr->elements[j]->subqueryInterpretation);
1620                     display_queryExpression("recommendation",
1621                         sr->elements[j]->subqueryRecommendation);
1622                     if (sr->elements[j]->subqueryCount)
1623                         printf(" cnt=%d", *sr->elements[j]->subqueryCount);
1624                     if (sr->elements[j]->subqueryId)
1625                         printf(" id=%s ", sr->elements[j]->subqueryId);
1626                 }
1627                 printf ("\n");
1628             }
1629         }
1630     }
1631 }
1632
1633 static int process_searchResponse(Z_SearchResponse *res)
1634 {
1635     printf ("Received SearchResponse.\n");
1636     print_refid (res->referenceId);
1637     if (*res->searchStatus)
1638         printf("Search was a success.\n");
1639     else
1640         printf("Search was a bloomin' failure.\n");
1641     printf("Number of hits: %d", *res->resultCount);
1642     last_hit_count = *res->resultCount;
1643     if (setnumber >= 0)
1644         printf (", setno %d", setnumber);
1645     putchar('\n');
1646     if (res->resultSetStatus)
1647     {
1648         printf("Result Set Status: ");
1649         switch(*res->resultSetStatus)
1650         {
1651         case Z_SearchResponse_subset:
1652             printf("subset"); break;
1653         case Z_SearchResponse_interim:
1654             printf("interim"); break;
1655         case Z_SearchResponse_none:
1656             printf("none"); break;
1657         case Z_SearchResponse_estimate:
1658             printf("estimate"); break;
1659         default:
1660             printf("%d", *res->resultSetStatus);
1661         }
1662         putchar('\n');
1663     }
1664     display_searchResult (res->additionalSearchInfo);
1665     printf("records returned: %d\n",
1666            *res->numberOfRecordsReturned);
1667     setno += *res->numberOfRecordsReturned;
1668     if (res->records)
1669         display_records(res->records);
1670     return 0;
1671 }
1672
1673 static void print_level(int iLevel)
1674 {
1675     int i;
1676     for (i = 0; i < iLevel * 4; i++)
1677         printf(" ");
1678 }
1679
1680 static void print_int(int iLevel, const char *pTag, int *pInt)
1681 {
1682     if (pInt != NULL)
1683     {
1684         print_level(iLevel);
1685         printf("%s: %d\n", pTag, *pInt);
1686     }
1687 }
1688
1689 static void print_string(int iLevel, const char *pTag, const char *pString)
1690 {
1691     if (pString != NULL)
1692     {
1693         print_level(iLevel);
1694         printf("%s: %s\n", pTag, pString);
1695     }
1696 }
1697
1698 static void print_oid(int iLevel, const char *pTag, Odr_oid *pOid)
1699 {
1700     if (pOid != NULL)
1701     {
1702         Odr_oid *pInt = pOid;
1703
1704         print_level(iLevel);
1705         printf("%s:", pTag);
1706         for (; *pInt != -1; pInt++)
1707             printf(" %d", *pInt);
1708         printf("\n");
1709     }
1710 }
1711
1712 static void print_referenceId(int iLevel, Z_ReferenceId *referenceId)
1713 {
1714     if (referenceId != NULL)
1715     {
1716         int i;
1717
1718         print_level(iLevel);
1719         printf("Ref Id (%d, %d): ", referenceId->len, referenceId->size);
1720         for (i = 0; i < referenceId->len; i++)
1721             printf("%c", referenceId->buf[i]);
1722         printf("\n");
1723     }
1724 }
1725
1726 static void print_string_or_numeric(int iLevel, const char *pTag, Z_StringOrNumeric *pStringNumeric)
1727 {
1728     if (pStringNumeric != NULL)
1729     {
1730         switch (pStringNumeric->which)
1731         {
1732         case Z_StringOrNumeric_string:
1733             print_string(iLevel, pTag, pStringNumeric->u.string);
1734             break;
1735
1736         case Z_StringOrNumeric_numeric:
1737             print_int(iLevel, pTag, pStringNumeric->u.numeric);
1738             break;
1739
1740         default:
1741             print_level(iLevel);
1742             printf("%s: valid type for Z_StringOrNumeric\n", pTag);
1743             break;
1744         }
1745     }
1746 }
1747
1748 static void print_universe_report_duplicate(
1749     int iLevel,
1750     Z_UniverseReportDuplicate *pUniverseReportDuplicate)
1751 {
1752     if (pUniverseReportDuplicate != NULL)
1753     {
1754         print_level(iLevel);
1755         printf("Universe Report Duplicate: \n");
1756         iLevel++;
1757         print_string_or_numeric(iLevel, "Hit No",
1758                                 pUniverseReportDuplicate->hitno);
1759     }
1760 }
1761
1762 static void print_universe_report_hits(
1763     int iLevel,
1764     Z_UniverseReportHits *pUniverseReportHits)
1765 {
1766     if (pUniverseReportHits != NULL)
1767     {
1768         print_level(iLevel);
1769         printf("Universe Report Hits: \n");
1770         iLevel++;
1771         print_string_or_numeric(iLevel, "Database",
1772                                 pUniverseReportHits->database);
1773         print_string_or_numeric(iLevel, "Hits", pUniverseReportHits->hits);
1774     }
1775 }
1776
1777 static void print_universe_report(int iLevel, Z_UniverseReport *pUniverseReport)
1778 {
1779     if (pUniverseReport != NULL)
1780     {
1781         print_level(iLevel);
1782         printf("Universe Report: \n");
1783         iLevel++;
1784         print_int(iLevel, "Total Hits", pUniverseReport->totalHits);
1785         switch (pUniverseReport->which)
1786         {
1787         case Z_UniverseReport_databaseHits:
1788             print_universe_report_hits(iLevel,
1789                                        pUniverseReport->u.databaseHits);
1790             break;
1791
1792         case Z_UniverseReport_duplicate:
1793             print_universe_report_duplicate(iLevel,
1794                                             pUniverseReport->u.duplicate);
1795             break;
1796
1797         default:
1798             print_level(iLevel);
1799             printf("Type: %d\n", pUniverseReport->which);
1800             break;
1801         }
1802     }
1803 }
1804
1805 static void print_external(int iLevel, Z_External *pExternal)
1806 {
1807     if (pExternal != NULL)
1808     {
1809         print_level(iLevel);
1810         printf("External: \n");
1811         iLevel++;
1812         print_oid(iLevel, "Direct Reference", pExternal->direct_reference);
1813         print_int(iLevel, "InDirect Reference", pExternal->indirect_reference);
1814         print_string(iLevel, "Descriptor", pExternal->descriptor);
1815         switch (pExternal->which)
1816         {
1817         case Z_External_universeReport:
1818             print_universe_report(iLevel, pExternal->u.universeReport);
1819             break;
1820
1821         default:
1822             print_level(iLevel);
1823             printf("Type: %d\n", pExternal->which);
1824             break;
1825         }
1826     }
1827 }
1828
1829 static int process_resourceControlRequest (Z_ResourceControlRequest *req)
1830 {
1831     printf ("Received ResourceControlRequest.\n");
1832     print_referenceId(1, req->referenceId);
1833     print_int(1, "Suspended Flag", req->suspendedFlag);
1834     print_int(1, "Partial Results Available", req->partialResultsAvailable);
1835     print_int(1, "Response Required", req->responseRequired);
1836     print_int(1, "Triggered Request Flag", req->triggeredRequestFlag);
1837     print_external(1, req->resourceReport);
1838     return 0;
1839 }
1840
1841 void process_ESResponse(Z_ExtendedServicesResponse *res)
1842 {
1843     printf("Status: ");
1844     switch (*res->operationStatus)
1845     {
1846     case Z_ExtendedServicesResponse_done:
1847         printf ("done\n");
1848         break;
1849     case Z_ExtendedServicesResponse_accepted:
1850         printf ("accepted\n");
1851         break;
1852     case Z_ExtendedServicesResponse_failure:
1853         printf ("failure\n");
1854         display_diagrecs(res->diagnostics, res->num_diagnostics);
1855         break;
1856     default:
1857         printf ("unknown\n");
1858     }
1859     if ( (*res->operationStatus != Z_ExtendedServicesResponse_failure) &&
1860         (res->num_diagnostics != 0) ) {
1861         display_diagrecs(res->diagnostics, res->num_diagnostics);
1862     }
1863     print_refid (res->referenceId);
1864     if (res->taskPackage &&
1865         res->taskPackage->which == Z_External_extendedService)
1866     {
1867         Z_TaskPackage *taskPackage = res->taskPackage->u.extendedService;
1868         Odr_oct *id = taskPackage->targetReference;
1869         Z_External *ext = taskPackage->taskSpecificParameters;
1870
1871         if (id)
1872         {
1873             printf ("Target Reference: ");
1874             print_stringn (id->buf, id->len);
1875             printf ("\n");
1876         }
1877         if (ext->which == Z_External_update)
1878         {
1879             Z_IUUpdateTaskPackage *utp = ext->u.update->u.taskPackage;
1880             if (utp && utp->targetPart)
1881             {
1882                 Z_IUTargetPart *targetPart = utp->targetPart;
1883                 int i;
1884
1885                 for (i = 0; i<targetPart->num_taskPackageRecords;  i++)
1886                 {
1887
1888                     Z_IUTaskPackageRecordStructure *tpr =
1889                         targetPart->taskPackageRecords[i];
1890                     printf ("task package record %d\n", i+1);
1891                     if (tpr->which == Z_IUTaskPackageRecordStructure_record)
1892                     {
1893                         display_record (tpr->u.record);
1894                     }
1895                     else
1896                     {
1897                         printf ("other type\n");
1898                     }
1899                 }
1900             }
1901         }
1902     }
1903     if (res->taskPackage && res->taskPackage->which == Z_External_octet)
1904     {
1905         Odr_oct *doc = res->taskPackage->u.octet_aligned;
1906         printf("%.*s\n", doc->len, doc->buf);
1907     }
1908 }
1909
1910 const char *get_ill_element (void *clientData, const char *element)
1911 {
1912     return 0;
1913 }
1914
1915 static Z_External *create_external_itemRequest(void)
1916 {
1917     struct ill_get_ctl ctl;
1918     ILL_ItemRequest *req;
1919     Z_External *r = 0;
1920     int item_request_size = 0;
1921     char *item_request_buf = 0;
1922
1923     ctl.odr = out;
1924     ctl.clientData = 0;
1925     ctl.f = get_ill_element;
1926
1927     req = ill_get_ItemRequest(&ctl, "ill", 0);
1928     if (!req)
1929         printf ("ill_get_ItemRequest failed\n");
1930
1931     if (!ill_ItemRequest (out, &req, 0, 0))
1932     {
1933         if (apdu_file)
1934         {
1935             ill_ItemRequest(print, &req, 0, 0);
1936             odr_reset(print);
1937         }
1938         item_request_buf = odr_getbuf (out, &item_request_size, 0);
1939         if (item_request_buf)
1940             odr_setbuf (out, item_request_buf, item_request_size, 1);
1941         printf ("Couldn't encode ItemRequest, size %d\n", item_request_size);
1942         return 0;
1943     }
1944     else
1945     {
1946         r = (Z_External *) odr_malloc (out, sizeof(*r));
1947         r->direct_reference = odr_oiddup(out, yaz_oid_general_isoill_1);
1948         r->indirect_reference = 0;
1949         r->descriptor = 0;
1950         r->which = Z_External_single;
1951
1952         r->u.single_ASN1_type = (Odr_oct *)
1953             odr_malloc (out, sizeof(*r->u.single_ASN1_type));
1954         r->u.single_ASN1_type->buf = (unsigned char *)
1955         odr_malloc (out, item_request_size);
1956         r->u.single_ASN1_type->len = item_request_size;
1957         r->u.single_ASN1_type->size = item_request_size;
1958         memcpy (r->u.single_ASN1_type->buf, item_request_buf,
1959                 item_request_size);
1960
1961         do_hex_dump(item_request_buf,item_request_size);
1962     }
1963     return r;
1964 }
1965
1966 static Z_External *create_external_ILL_APDU(int which)
1967 {
1968     struct ill_get_ctl ctl;
1969     ILL_APDU *ill_apdu;
1970     Z_External *r = 0;
1971     int ill_request_size = 0;
1972     char *ill_request_buf = 0;
1973
1974     ctl.odr = out;
1975     ctl.clientData = 0;
1976     ctl.f = get_ill_element;
1977
1978     ill_apdu = ill_get_APDU(&ctl, "ill", 0);
1979
1980     if (!ill_APDU (out, &ill_apdu, 0, 0))
1981     {
1982         if (apdu_file)
1983         {
1984             printf ("-------------------\n");
1985             ill_APDU(print, &ill_apdu, 0, 0);
1986             odr_reset(print);
1987             printf ("-------------------\n");
1988         }
1989         ill_request_buf = odr_getbuf (out, &ill_request_size, 0);
1990         if (ill_request_buf)
1991             odr_setbuf (out, ill_request_buf, ill_request_size, 1);
1992         printf ("Couldn't encode ILL-Request, size %d\n", ill_request_size);
1993         return 0;
1994     }
1995     else
1996     {
1997         ill_request_buf = odr_getbuf (out, &ill_request_size, 0);
1998
1999         r = (Z_External *) odr_malloc (out, sizeof(*r));
2000         r->direct_reference = odr_oiddup(out, yaz_oid_general_isoill_1);
2001         r->indirect_reference = 0;
2002         r->descriptor = 0;
2003         r->which = Z_External_single;
2004
2005         r->u.single_ASN1_type = (Odr_oct *)
2006             odr_malloc (out, sizeof(*r->u.single_ASN1_type));
2007         r->u.single_ASN1_type->buf = (unsigned char *)
2008         odr_malloc (out, ill_request_size);
2009         r->u.single_ASN1_type->len = ill_request_size;
2010         r->u.single_ASN1_type->size = ill_request_size;
2011         memcpy (r->u.single_ASN1_type->buf, ill_request_buf, ill_request_size);
2012 /*         printf ("len = %d\n", ill_request_size); */
2013 /*              do_hex_dump(ill_request_buf,ill_request_size); */
2014 /*              printf("--- end of extenal\n"); */
2015
2016     }
2017     return r;
2018 }
2019
2020
2021 static Z_External *create_ItemOrderExternal(const char *type, int itemno)
2022 {
2023     Z_External *r = (Z_External *) odr_malloc(out, sizeof(Z_External));
2024     r->direct_reference = odr_oiddup(out, yaz_oid_extserv_item_order);
2025     r->indirect_reference = 0;
2026     r->descriptor = 0;
2027
2028     r->which = Z_External_itemOrder;
2029
2030     r->u.itemOrder = (Z_ItemOrder *) odr_malloc(out,sizeof(Z_ItemOrder));
2031     memset(r->u.itemOrder, 0, sizeof(Z_ItemOrder));
2032     r->u.itemOrder->which=Z_IOItemOrder_esRequest;
2033
2034     r->u.itemOrder->u.esRequest = (Z_IORequest *)
2035         odr_malloc(out,sizeof(Z_IORequest));
2036     memset(r->u.itemOrder->u.esRequest, 0, sizeof(Z_IORequest));
2037
2038     r->u.itemOrder->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
2039         odr_malloc(out,sizeof(Z_IOOriginPartToKeep));
2040     memset(r->u.itemOrder->u.esRequest->toKeep, 0, sizeof(Z_IOOriginPartToKeep));
2041     r->u.itemOrder->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
2042         odr_malloc(out,sizeof(Z_IOOriginPartNotToKeep));
2043     memset(r->u.itemOrder->u.esRequest->notToKeep, 0, sizeof(Z_IOOriginPartNotToKeep));
2044
2045     r->u.itemOrder->u.esRequest->toKeep->supplDescription = NULL;
2046     r->u.itemOrder->u.esRequest->toKeep->contact = NULL;
2047     r->u.itemOrder->u.esRequest->toKeep->addlBilling = NULL;
2048
2049     r->u.itemOrder->u.esRequest->notToKeep->resultSetItem =
2050         (Z_IOResultSetItem *) odr_malloc(out, sizeof(Z_IOResultSetItem));
2051     memset(r->u.itemOrder->u.esRequest->notToKeep->resultSetItem, 0, sizeof(Z_IOResultSetItem));
2052     r->u.itemOrder->u.esRequest->notToKeep->resultSetItem->resultSetId = "1";
2053
2054     r->u.itemOrder->u.esRequest->notToKeep->resultSetItem->item =
2055         (int *) odr_malloc(out, sizeof(int));
2056     *r->u.itemOrder->u.esRequest->notToKeep->resultSetItem->item = itemno;
2057
2058     if (!strcmp (type, "item") || !strcmp(type, "2"))
2059     {
2060         printf ("using item-request\n");
2061         r->u.itemOrder->u.esRequest->notToKeep->itemRequest =
2062             create_external_itemRequest();
2063     }
2064     else if (!strcmp(type, "ill") || !strcmp(type, "1"))
2065     {
2066         printf ("using ILL-request\n");
2067         r->u.itemOrder->u.esRequest->notToKeep->itemRequest =
2068             create_external_ILL_APDU(ILL_APDU_ILL_Request);
2069     }
2070     else if (!strcmp(type, "xml") || !strcmp(type, "3"))
2071     {
2072         const char *xml_buf =
2073             "<itemorder>\n"
2074             "  <type>request</type>\n"
2075             "  <libraryNo>000200</libraryNo>\n"
2076             "  <borrowerTicketNo> 1212 </borrowerTicketNo>\n"
2077             "</itemorder>";
2078         r->u.itemOrder->u.esRequest->notToKeep->itemRequest =
2079             z_ext_record_oid(out, yaz_oid_recsyn_xml, xml_buf, strlen(xml_buf));
2080     }
2081     else
2082         r->u.itemOrder->u.esRequest->notToKeep->itemRequest = 0;
2083
2084     return r;
2085 }
2086
2087 static int send_itemorder(const char *type, int itemno)
2088 {
2089     Z_APDU *apdu = zget_APDU(out, Z_APDU_extendedServicesRequest);
2090     Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
2091
2092     req->referenceId = set_refid (out);
2093
2094     req->packageType = odr_oiddup(out, yaz_oid_extserv_item_order);
2095     req->packageName = esPackageName;
2096
2097     req->taskSpecificParameters = create_ItemOrderExternal(type, itemno);
2098
2099     send_apdu(apdu);
2100     return 0;
2101 }
2102
2103 static int only_z3950(void)
2104 {
2105     if (!conn)
2106     {
2107         printf ("Not connected yet\n");
2108         return 1;
2109     }
2110     if (protocol == PROTO_HTTP)
2111     {
2112         printf ("Not supported by SRW\n");
2113         return 1;
2114     }
2115     return 0;
2116 }
2117
2118 static int cmd_update_common(const char *arg, int version);
2119
2120 static int cmd_update(const char *arg)
2121 {
2122     return cmd_update_common(arg, 1);
2123 }
2124
2125 static int cmd_update0(const char *arg)
2126 {
2127     return cmd_update_common(arg, 0);
2128 }
2129
2130 static int cmd_update_Z3950(int version, int action_no, const char *recid,
2131                             char *rec_buf, int rec_len);
2132
2133 static int cmd_update_SRW(int action_no, const char *recid,
2134                           char *rec_buf, int rec_len);
2135
2136 static int cmd_update_common(const char *arg, int version)
2137 {
2138     char action[20], recid_buf[20];
2139     const char *recid = 0;
2140     char *rec_buf;
2141     int rec_len;
2142     int action_no;
2143     int noread = 0;
2144
2145     *action = 0;
2146     *recid_buf = 0;
2147     sscanf (arg, "%19s %19s%n", action, recid_buf, &noread);
2148     if (noread == 0)
2149     {
2150         printf("Use: update action recid [fname]\n");
2151         printf(" where action is one of insert,replace,delete.update\n");
2152         printf(" recid is some record ID. Use none for no ID\n");
2153         printf(" fname is file of record to be updated\n");
2154         return 0;
2155     }
2156
2157     if (!strcmp (action, "insert"))
2158         action_no = Z_IUOriginPartToKeep_recordInsert;
2159     else if (!strcmp (action, "replace"))
2160         action_no = Z_IUOriginPartToKeep_recordReplace;
2161     else if (!strcmp (action, "delete"))
2162         action_no = Z_IUOriginPartToKeep_recordDelete;
2163     else if (!strcmp (action, "update"))
2164         action_no = Z_IUOriginPartToKeep_specialUpdate;
2165     else
2166     {
2167         printf ("Bad action: %s\n", action);
2168         printf ("Possible values: insert, replace, delete, update\n");
2169         return 0;
2170     }
2171
2172     if (strcmp(recid_buf, "none")) /* none means no record ID */
2173         recid = recid_buf;
2174
2175     arg += noread;
2176     if (parse_cmd_doc(&arg, out, &rec_buf, &rec_len, 1) == 0)
2177         return 0;
2178
2179 #if YAZ_HAVE_XML2
2180     if (protocol == PROTO_HTTP)
2181         return cmd_update_SRW(action_no, recid, rec_buf, rec_len);
2182 #endif
2183     return cmd_update_Z3950(version, action_no, recid, rec_buf, rec_len);
2184 }
2185
2186 #if YAZ_HAVE_XML2
2187 static int cmd_update_SRW(int action_no, const char *recid,
2188                           char *rec_buf, int rec_len)
2189 {
2190     if (!conn)
2191         cmd_open(0);
2192     if (!conn)
2193         return 0;
2194     else
2195     {
2196         Z_SRW_PDU *srw = yaz_srw_get(out, Z_SRW_update_request);
2197         Z_SRW_updateRequest *sr = srw->u.update_request;
2198
2199         switch(action_no)
2200         {
2201         case Z_IUOriginPartToKeep_recordInsert:
2202             sr->operation = "info:srw/action/1/create";
2203             break;
2204         case Z_IUOriginPartToKeep_recordReplace:
2205             sr->operation = "info:srw/action/1/replace";
2206             break;
2207         case Z_IUOriginPartToKeep_recordDelete:
2208             sr->operation = "info:srw/action/1/delete";
2209             break;
2210         }
2211         if (rec_buf)
2212         {
2213             sr->record = yaz_srw_get_record(out);
2214             sr->record->recordData_buf = rec_buf;
2215             sr->record->recordData_len = rec_len;
2216             sr->record->recordSchema = record_schema;
2217         }
2218         if (recid)
2219             sr->recordId = odr_strdup(out, recid);
2220         return send_srw(srw);
2221     }
2222 }
2223 #endif
2224
2225 static int cmd_update_Z3950(int version, int action_no, const char *recid,
2226                             char *rec_buf, int rec_len)
2227 {
2228     Z_APDU *apdu = zget_APDU(out, Z_APDU_extendedServicesRequest );
2229     Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
2230     Z_External *r;
2231     Z_External *record_this = 0;
2232     if (rec_buf)
2233         record_this = z_ext_record_oid(out, yaz_oid_recsyn_xml,
2234                                        rec_buf, rec_len);
2235     else
2236     {
2237         if (!record_last)
2238         {
2239             printf ("No last record (update ignored)\n");
2240             return 0;
2241         }
2242         record_this = record_last;
2243     }
2244
2245     req->packageType = odr_oiddup(out, (version == 0 ?
2246        yaz_oid_extserv_database_update_first_version :
2247        yaz_oid_extserv_database_update));
2248
2249     req->packageName = esPackageName;
2250
2251     req->referenceId = set_refid (out);
2252
2253     r = req->taskSpecificParameters = (Z_External *)
2254         odr_malloc (out, sizeof(*r));
2255     r->direct_reference = req->packageType;
2256     r->indirect_reference = 0;
2257     r->descriptor = 0;
2258     if (version == 0)
2259     {
2260         Z_IU0OriginPartToKeep *toKeep;
2261         Z_IU0SuppliedRecords *notToKeep;
2262
2263         r->which = Z_External_update0;
2264         r->u.update0 = (Z_IU0Update *) odr_malloc(out, sizeof(*r->u.update0));
2265         r->u.update0->which = Z_IUUpdate_esRequest;
2266         r->u.update0->u.esRequest = (Z_IU0UpdateEsRequest *)
2267             odr_malloc(out, sizeof(*r->u.update0->u.esRequest));
2268         toKeep = r->u.update0->u.esRequest->toKeep = (Z_IU0OriginPartToKeep *)
2269             odr_malloc(out, sizeof(*r->u.update0->u.esRequest->toKeep));
2270
2271         toKeep->databaseName = databaseNames[0];
2272         toKeep->schema = 0;
2273         toKeep->elementSetName = 0;
2274
2275         toKeep->action = (int *) odr_malloc(out, sizeof(*toKeep->action));
2276         *toKeep->action = action_no;
2277
2278         notToKeep = r->u.update0->u.esRequest->notToKeep = (Z_IU0SuppliedRecords *)
2279             odr_malloc(out, sizeof(*r->u.update0->u.esRequest->notToKeep));
2280         notToKeep->num = 1;
2281         notToKeep->elements = (Z_IU0SuppliedRecords_elem **)
2282             odr_malloc(out, sizeof(*notToKeep->elements));
2283         notToKeep->elements[0] = (Z_IU0SuppliedRecords_elem *)
2284             odr_malloc(out, sizeof(**notToKeep->elements));
2285         notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
2286         if (recid)
2287         {
2288             notToKeep->elements[0]->u.opaque = (Odr_oct *)
2289                 odr_malloc (out, sizeof(Odr_oct));
2290             notToKeep->elements[0]->u.opaque->buf = (unsigned char *) recid;
2291             notToKeep->elements[0]->u.opaque->size = strlen(recid);
2292             notToKeep->elements[0]->u.opaque->len = strlen(recid);
2293         }
2294         else
2295             notToKeep->elements[0]->u.opaque = 0;
2296         notToKeep->elements[0]->supplementalId = 0;
2297         notToKeep->elements[0]->correlationInfo = 0;
2298         notToKeep->elements[0]->record = record_this;
2299     }
2300     else
2301     {
2302         Z_IUOriginPartToKeep *toKeep;
2303         Z_IUSuppliedRecords *notToKeep;
2304
2305         r->which = Z_External_update;
2306         r->u.update = (Z_IUUpdate *) odr_malloc(out, sizeof(*r->u.update));
2307         r->u.update->which = Z_IUUpdate_esRequest;
2308         r->u.update->u.esRequest = (Z_IUUpdateEsRequest *)
2309             odr_malloc(out, sizeof(*r->u.update->u.esRequest));
2310         toKeep = r->u.update->u.esRequest->toKeep = (Z_IUOriginPartToKeep *)
2311             odr_malloc(out, sizeof(*r->u.update->u.esRequest->toKeep));
2312
2313         toKeep->databaseName = databaseNames[0];
2314         toKeep->schema = 0;
2315         toKeep->elementSetName = 0;
2316         toKeep->actionQualifier = 0;
2317         toKeep->action = (int *) odr_malloc(out, sizeof(*toKeep->action));
2318         *toKeep->action = action_no;
2319
2320         notToKeep = r->u.update->u.esRequest->notToKeep = (Z_IUSuppliedRecords *)
2321             odr_malloc(out, sizeof(*r->u.update->u.esRequest->notToKeep));
2322         notToKeep->num = 1;
2323         notToKeep->elements = (Z_IUSuppliedRecords_elem **)
2324             odr_malloc(out, sizeof(*notToKeep->elements));
2325         notToKeep->elements[0] = (Z_IUSuppliedRecords_elem *)
2326             odr_malloc(out, sizeof(**notToKeep->elements));
2327         notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
2328         if (recid)
2329         {
2330             notToKeep->elements[0]->u.opaque = (Odr_oct *)
2331                 odr_malloc (out, sizeof(Odr_oct));
2332             notToKeep->elements[0]->u.opaque->buf = (unsigned char *) recid;
2333             notToKeep->elements[0]->u.opaque->size = strlen(recid);
2334             notToKeep->elements[0]->u.opaque->len = strlen(recid);
2335         }
2336         else
2337             notToKeep->elements[0]->u.opaque = 0;
2338         notToKeep->elements[0]->supplementalId = 0;
2339         notToKeep->elements[0]->correlationInfo = 0;
2340         notToKeep->elements[0]->record = record_this;
2341     }
2342
2343     send_apdu(apdu);
2344
2345     return 2;
2346 }
2347
2348 static int cmd_xmles(const char *arg)
2349 {
2350     if (only_z3950())
2351         return 1;
2352     else
2353     {
2354         char *asn_buf = 0;
2355         int noread = 0;
2356         Odr_oid *oid;
2357         char oid_str[51];
2358         Z_APDU *apdu = zget_APDU(out, Z_APDU_extendedServicesRequest);
2359         Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
2360
2361
2362         Z_External *ext = (Z_External *) odr_malloc(out, sizeof(*ext));
2363
2364         req->referenceId = set_refid (out);
2365         req->taskSpecificParameters = ext;
2366         ext->indirect_reference = 0;
2367         ext->descriptor = 0;
2368         ext->which = Z_External_octet;
2369         ext->u.single_ASN1_type = (Odr_oct *) odr_malloc (out, sizeof(Odr_oct));
2370         sscanf(arg, "%50s%n", oid_str, &noread);
2371         if (noread == 0)
2372         {
2373             printf("Missing OID for xmles\n");
2374             return 0;
2375         }
2376         arg += noread;
2377         if (parse_cmd_doc(&arg, out, &asn_buf,
2378                           &ext->u.single_ASN1_type->len, 0) == 0)
2379             return 0;
2380
2381         ext->u.single_ASN1_type->buf = (unsigned char *) asn_buf;
2382
2383         oid = yaz_string_to_oid_odr(yaz_oid_std(),
2384                                     CLASS_EXTSERV, oid_str, out);
2385         if (!oid)
2386         {
2387             printf("Bad OID: %s\n", oid_str);
2388             return 0;
2389         }
2390
2391         req->packageType = oid;
2392
2393         ext->direct_reference = oid;
2394
2395         send_apdu(apdu);
2396
2397         return 2;
2398     }
2399 }
2400
2401 static int cmd_itemorder(const char *arg)
2402 {
2403     char type[12];
2404     int itemno;
2405
2406     if (only_z3950())
2407         return 1;
2408     if (sscanf (arg, "%10s %d", type, &itemno) != 2)
2409         return 0;
2410
2411     printf("Item order request\n");
2412     fflush(stdout);
2413     send_itemorder(type, itemno);
2414     return 2;
2415 }
2416
2417 static void show_opt(const char *arg, void *clientData)
2418 {
2419     printf ("%s ", arg);
2420 }
2421
2422 static int cmd_zversion(const char *arg)
2423 {
2424     if (*arg && arg)
2425         z3950_version = atoi(arg);
2426     else
2427         printf ("version is %d\n", z3950_version);
2428     return 0;
2429 }
2430
2431 static int cmd_options(const char *arg)
2432 {
2433     if (*arg)
2434     {
2435         int r;
2436         int pos;
2437         r = yaz_init_opt_encode(&z3950_options, arg, &pos);
2438         if (r == -1)
2439             printf("Unknown option(s) near %s\n", arg+pos);
2440     }
2441     else
2442     {
2443         yaz_init_opt_decode(&z3950_options, show_opt, 0);
2444         printf ("\n");
2445     }
2446     return 0;
2447 }
2448
2449 static int cmd_explain(const char *arg)
2450 {
2451     if (protocol != PROTO_HTTP)
2452         return 0;
2453 #if YAZ_HAVE_XML2
2454     if (!conn)
2455         cmd_open(0);
2456     if (conn)
2457     {
2458         Z_SRW_PDU *sr = 0;
2459
2460         setno = 1;
2461
2462         /* save this for later .. when fetching individual records */
2463         sr = yaz_srw_get(out, Z_SRW_explain_request);
2464         if (recordsyntax_size == 1
2465             && !yaz_matchstr(recordsyntax_list[0], "xml"))
2466             sr->u.explain_request->recordPacking = "xml";
2467         send_srw(sr);
2468         return 2;
2469     }
2470 #endif
2471     return 0;
2472 }
2473
2474 static int cmd_init(const char *arg)
2475 {
2476     if (*arg)
2477     {
2478         strncpy (cur_host, arg, sizeof(cur_host)-1);
2479         cur_host[sizeof(cur_host)-1] = 0;
2480     }
2481     if (only_z3950())
2482         return 1;
2483     send_initRequest(cur_host);
2484     return 2;
2485 }
2486
2487 static int cmd_sru(const char *arg)
2488 {
2489     if (!*arg)
2490     {
2491         printf("SRU method is: %s\n", sru_method);
2492     }
2493     else
2494     {
2495         if (!yaz_matchstr(arg, "post"))
2496             sru_method = "post";
2497         else if (!yaz_matchstr(arg, "get"))
2498             sru_method = "get";
2499         else if (!yaz_matchstr(arg, "soap"))
2500             sru_method = "soap";
2501         else
2502         {
2503             printf("Unknown SRU method: %s\n", arg);
2504             printf("Specify one of POST, GET, SOAP\n");
2505         }
2506     }
2507     return 0;
2508 }
2509
2510 static int cmd_find(const char *arg)
2511 {
2512     if (!*arg)
2513     {
2514         printf("Find what?\n");
2515         return 0;
2516     }
2517     if (protocol == PROTO_HTTP)
2518     {
2519 #if YAZ_HAVE_XML2
2520         if (!conn)
2521             cmd_open(0);
2522         if (!conn)
2523             return 0;
2524         if (!send_SRW_searchRequest(arg))
2525             return 0;
2526 #else
2527         return 0;
2528 #endif
2529     }
2530     else
2531     {
2532         if (!conn)
2533         {
2534             try_reconnect();
2535
2536             if (!conn) {
2537                 printf("Not connected yet\n");
2538                 return 0;
2539             }
2540         }
2541         if (!send_searchRequest(arg))
2542             return 0;
2543     }
2544     return 2;
2545 }
2546
2547 static int cmd_delete(const char *arg)
2548 {
2549     if (only_z3950())
2550         return 0;
2551     if (!send_deleteResultSetRequest(arg))
2552         return 0;
2553     return 2;
2554 }
2555
2556 static int cmd_ssub(const char *arg)
2557 {
2558     if (!(smallSetUpperBound = atoi(arg)))
2559         return 0;
2560     return 1;
2561 }
2562
2563 static int cmd_lslb(const char *arg)
2564 {
2565     if (!(largeSetLowerBound = atoi(arg)))
2566         return 0;
2567     return 1;
2568 }
2569
2570 static int cmd_mspn(const char *arg)
2571 {
2572     if (!(mediumSetPresentNumber = atoi(arg)))
2573         return 0;
2574     return 1;
2575 }
2576
2577 static int cmd_status(const char *arg)
2578 {
2579     printf("smallSetUpperBound: %d\n", smallSetUpperBound);
2580     printf("largeSetLowerBound: %d\n", largeSetLowerBound);
2581     printf("mediumSetPresentNumber: %d\n", mediumSetPresentNumber);
2582     return 1;
2583 }
2584
2585 static int cmd_setnames(const char *arg)
2586 {
2587     if (*arg == '1')         /* enable ? */
2588         setnumber = 0;
2589     else if (*arg == '0')    /* disable ? */
2590         setnumber = -1;
2591     else if (setnumber < 0)  /* no args, toggle .. */
2592         setnumber = 0;
2593     else
2594         setnumber = -1;
2595
2596     if (setnumber >= 0)
2597         printf("Set numbering enabled.\n");
2598     else
2599         printf("Set numbering disabled.\n");
2600     return 1;
2601 }
2602
2603 /* PRESENT SERVICE ----------------------------- */
2604
2605 static void parse_show_args(const char *arg_c, char *setstring,
2606                             int *start, int *number)
2607 {
2608     char arg[40];
2609     char *p;
2610
2611     strncpy(arg, arg_c, sizeof(arg)-1);
2612     arg[sizeof(arg)-1] = '\0';
2613
2614     if ((p = strchr(arg, '+')))
2615     {
2616         *number = atoi(p + 1);
2617         *p = '\0';
2618     }
2619     if (*arg)
2620     {
2621         if (!strcmp(arg, "all"))
2622         {
2623             *number = last_hit_count;
2624             *start = 1;
2625         }
2626         else
2627             *start = atoi(arg);
2628     }
2629     if (p && (p=strchr(p+1, '+')))
2630         strcpy (setstring, p+1);
2631     else if (setnumber >= 0)
2632         sprintf(setstring, "%d", setnumber);
2633     else
2634         *setstring = '\0';
2635 }
2636
2637 static int send_presentRequest(const char *arg)
2638 {
2639     Z_APDU *apdu = zget_APDU(out, Z_APDU_presentRequest);
2640     Z_PresentRequest *req = apdu->u.presentRequest;
2641     Z_RecordComposition compo;
2642     int nos = 1;
2643     char setstring[100];
2644
2645     req->referenceId = set_refid (out);
2646
2647     parse_show_args(arg, setstring, &setno, &nos);
2648     if (*setstring)
2649         req->resultSetId = setstring;
2650
2651     req->resultSetStartPoint = &setno;
2652     req->numberOfRecordsRequested = &nos;
2653
2654     if (recordsyntax_size)
2655         req->preferredRecordSyntax =
2656             yaz_string_to_oid_odr(yaz_oid_std(),
2657                                   CLASS_RECSYN, recordsyntax_list[0], out);
2658
2659     if (record_schema || recordsyntax_size >= 2)
2660     {
2661         req->recordComposition = &compo;
2662         compo.which = Z_RecordComp_complex;
2663         compo.u.complex = (Z_CompSpec *)
2664             odr_malloc(out, sizeof(*compo.u.complex));
2665         compo.u.complex->selectAlternativeSyntax = (bool_t *)
2666             odr_malloc(out, sizeof(bool_t));
2667         *compo.u.complex->selectAlternativeSyntax = 0;
2668
2669         compo.u.complex->generic = (Z_Specification *)
2670             odr_malloc(out, sizeof(*compo.u.complex->generic));
2671
2672         compo.u.complex->generic->which = Z_Schema_oid;
2673         if (!record_schema)
2674             compo.u.complex->generic->schema.oid = 0;
2675         else
2676         {
2677             compo.u.complex->generic->schema.oid =
2678                 yaz_string_to_oid_odr(yaz_oid_std(),
2679                                       CLASS_SCHEMA, record_schema, out);
2680
2681             if (!compo.u.complex->generic->schema.oid)
2682             {
2683                 /* OID wasn't a schema! Try record syntax instead. */
2684                 compo.u.complex->generic->schema.oid = (Odr_oid *)
2685                     yaz_string_to_oid_odr(yaz_oid_std(),
2686                                           CLASS_RECSYN, record_schema, out);
2687             }
2688         }
2689         if (!elementSetNames)
2690             compo.u.complex->generic->elementSpec = 0;
2691         else
2692         {
2693             compo.u.complex->generic->elementSpec = (Z_ElementSpec *)
2694                 odr_malloc(out, sizeof(Z_ElementSpec));
2695             compo.u.complex->generic->elementSpec->which =
2696                 Z_ElementSpec_elementSetName;
2697             compo.u.complex->generic->elementSpec->u.elementSetName =
2698                 elementSetNames->u.generic;
2699         }
2700         compo.u.complex->num_dbSpecific = 0;
2701         compo.u.complex->dbSpecific = 0;
2702
2703         compo.u.complex->num_recordSyntax = 0;
2704         compo.u.complex->recordSyntax = 0;
2705         if (recordsyntax_size >= 2)
2706         {
2707             int i;
2708             compo.u.complex->num_recordSyntax = recordsyntax_size;
2709             compo.u.complex->recordSyntax = (Odr_oid **)
2710                 odr_malloc(out, recordsyntax_size * sizeof(Odr_oid*));
2711             for (i = 0; i < recordsyntax_size; i++)
2712             compo.u.complex->recordSyntax[i] =
2713                 yaz_string_to_oid_odr(yaz_oid_std(),
2714                                       CLASS_RECSYN, recordsyntax_list[i], out);
2715         }
2716     }
2717     else if (elementSetNames)
2718     {
2719         req->recordComposition = &compo;
2720         compo.which = Z_RecordComp_simple;
2721         compo.u.simple = elementSetNames;
2722     }
2723     send_apdu(apdu);
2724     printf("Sent presentRequest (%d+%d).\n", setno, nos);
2725     return 2;
2726 }
2727
2728 #if YAZ_HAVE_XML2
2729 static int send_SRW_presentRequest(const char *arg)
2730 {
2731     char setstring[100];
2732     int nos = 1;
2733     Z_SRW_PDU *sr = srw_sr;
2734
2735     if (!sr)
2736         return 0;
2737     parse_show_args(arg, setstring, &setno, &nos);
2738     sr->u.request->startRecord = odr_intdup(out, setno);
2739     sr->u.request->maximumRecords = odr_intdup(out, nos);
2740     if (record_schema)
2741         sr->u.request->recordSchema = record_schema;
2742     if (recordsyntax_size == 1 && !yaz_matchstr(recordsyntax_list[0], "xml"))
2743         sr->u.request->recordPacking = "xml";
2744     return send_srw(sr);
2745 }
2746 #endif
2747
2748 static void close_session (void)
2749 {
2750     if (conn)
2751         cs_close (conn);
2752     conn = 0;
2753     sent_close = 0;
2754     odr_reset(out);
2755     odr_reset(in);
2756     odr_reset(print);
2757     last_hit_count = 0;
2758 }
2759
2760 void process_close(Z_Close *req)
2761 {
2762     Z_APDU *apdu = zget_APDU(out, Z_APDU_close);
2763     Z_Close *res = apdu->u.close;
2764
2765     static char *reasons[] =
2766     {
2767         "finished",
2768         "shutdown",
2769         "system problem",
2770         "cost limit reached",
2771         "resources",
2772         "security violation",
2773         "protocolError",
2774         "lack of activity",
2775         "peer abort",
2776         "unspecified"
2777     };
2778
2779     printf("Reason: %s, message: %s\n", reasons[*req->closeReason],
2780         req->diagnosticInformation ? req->diagnosticInformation : "NULL");
2781     if (sent_close)
2782         close_session ();
2783     else
2784     {
2785         *res->closeReason = Z_Close_finished;
2786         send_apdu(apdu);
2787         printf("Sent response.\n");
2788         sent_close = 1;
2789     }
2790 }
2791
2792 static int cmd_show(const char *arg)
2793 {
2794     if (protocol == PROTO_HTTP)
2795     {
2796 #if YAZ_HAVE_XML2
2797         if (!conn)
2798             cmd_open(0);
2799         if (!conn)
2800             return 0;
2801         if (!send_SRW_presentRequest(arg))
2802             return 0;
2803 #else
2804         return 0;
2805 #endif
2806     }
2807     else
2808     {
2809         if (!conn)
2810         {
2811             printf("Not connected yet\n");
2812             return 0;
2813         }
2814         if (!send_presentRequest(arg))
2815             return 0;
2816     }
2817     return 2;
2818 }
2819
2820 void exit_client(int code)
2821 {
2822     file_history_save(file_history);
2823     file_history_destroy(&file_history);
2824     exit(code);
2825 }
2826
2827 int cmd_quit(const char *arg)
2828 {
2829     printf("See you later, alligator.\n");
2830     xmalloc_trav ("");
2831     exit_client(0);
2832     return 0;
2833 }
2834
2835 int cmd_cancel(const char *arg)
2836 {
2837     Z_APDU *apdu = zget_APDU(out, Z_APDU_triggerResourceControlRequest);
2838     Z_TriggerResourceControlRequest *req =
2839         apdu->u.triggerResourceControlRequest;
2840     bool_t rfalse = 0;
2841     char command[16];
2842
2843     *command = '\0';
2844     sscanf(arg, "%15s", command);
2845
2846     if (only_z3950())
2847         return 0;
2848     if (session_initResponse &&
2849         !ODR_MASK_GET(session_initResponse->options,
2850                       Z_Options_triggerResourceCtrl))
2851     {
2852         printf("Target doesn't support cancel (trigger resource ctrl)\n");
2853         return 0;
2854     }
2855     *req->requestedAction = Z_TriggerResourceControlRequest_cancel;
2856     req->resultSetWanted = &rfalse;
2857     req->referenceId = set_refid (out);
2858
2859     send_apdu(apdu);
2860     printf("Sent cancel request\n");
2861     if (!strcmp(command, "wait"))
2862          return 2;
2863     return 1;
2864 }
2865
2866
2867 int cmd_cancel_find(const char *arg) {
2868     int fres;
2869     fres=cmd_find(arg);
2870     if( fres > 0 ) {
2871         return cmd_cancel("");
2872     };
2873     return fres;
2874 }
2875
2876 int send_scanrequest(const char *set,  const char *query,
2877                      int pp, int num, const char *term)
2878 {
2879     Z_APDU *apdu = zget_APDU(out, Z_APDU_scanRequest);
2880     Z_ScanRequest *req = apdu->u.scanRequest;
2881
2882     if (only_z3950())
2883         return 0;
2884     if (queryType == QueryType_CCL2RPN)
2885     {
2886         int error, pos;
2887         struct ccl_rpn_node *rpn;
2888
2889         rpn = ccl_find_str (bibset,  query, &error, &pos);
2890         if (error)
2891         {
2892             printf("CCL ERROR: %s\n", ccl_err_msg(error));
2893             return -1;
2894         }
2895         req->attributeSet =
2896             yaz_string_to_oid_odr(yaz_oid_std(),
2897                                   CLASS_ATTSET, "Bib-1", out);
2898         if (!(req->termListAndStartPoint = ccl_scan_query (out, rpn)))
2899         {
2900             printf("Couldn't convert CCL to Scan term\n");
2901             return -1;
2902         }
2903         ccl_rpn_delete (rpn);
2904     }
2905     else
2906     {
2907         YAZ_PQF_Parser pqf_parser = yaz_pqf_create ();
2908
2909         if (!(req->termListAndStartPoint =
2910               yaz_pqf_scan(pqf_parser, out, &req->attributeSet, query)))
2911         {
2912             const char *pqf_msg;
2913             size_t off;
2914             int code = yaz_pqf_error (pqf_parser, &pqf_msg, &off);
2915             int ioff = off;
2916             printf("%*s^\n", ioff+7, "");
2917             printf("Prefix query error: %s (code %d)\n", pqf_msg, code);
2918             yaz_pqf_destroy (pqf_parser);
2919             return -1;
2920         }
2921         yaz_pqf_destroy (pqf_parser);
2922     }
2923     if (queryCharset && outputCharset)
2924     {
2925         yaz_iconv_t cd = yaz_iconv_open(queryCharset, outputCharset);
2926         if (!cd)
2927         {
2928             printf("Conversion from %s to %s unsupported\n",
2929                    outputCharset, queryCharset);
2930             return -1;
2931         }
2932         yaz_query_charset_convert_apt(req->termListAndStartPoint, out, cd);
2933         yaz_iconv_close(cd);
2934     }
2935     if (term && *term)
2936     {
2937         if (req->termListAndStartPoint->term &&
2938             req->termListAndStartPoint->term->which == Z_Term_general &&
2939             req->termListAndStartPoint->term->u.general)
2940         {
2941             req->termListAndStartPoint->term->u.general->buf =
2942                 (unsigned char *) odr_strdup(out, term);
2943             req->termListAndStartPoint->term->u.general->len =
2944                 req->termListAndStartPoint->term->u.general->size =
2945                 strlen(term);
2946         }
2947     }
2948     req->referenceId = set_refid (out);
2949     req->num_databaseNames = num_databaseNames;
2950     req->databaseNames = databaseNames;
2951     req->numberOfTermsRequested = &num;
2952     req->preferredPositionInResponse = &pp;
2953     req->stepSize = odr_intdup(out, scan_stepSize);
2954
2955     if (set)
2956         yaz_oi_set_string_oid(&req->otherInfo, out,
2957                               yaz_oid_userinfo_scan_set, 1, set);
2958
2959     send_apdu(apdu);
2960     return 2;
2961 }
2962
2963 int send_sortrequest(const char *arg, int newset)
2964 {
2965     Z_APDU *apdu = zget_APDU(out, Z_APDU_sortRequest);
2966     Z_SortRequest *req = apdu->u.sortRequest;
2967     Z_SortKeySpecList *sksl = (Z_SortKeySpecList *)
2968         odr_malloc (out, sizeof(*sksl));
2969     char setstring[32];
2970
2971     if (only_z3950())
2972         return 0;
2973     if (setnumber >= 0)
2974         sprintf (setstring, "%d", setnumber);
2975     else
2976         sprintf (setstring, "default");
2977
2978     req->referenceId = set_refid (out);
2979
2980     req->num_inputResultSetNames = 1;
2981     req->inputResultSetNames = (Z_InternationalString **)
2982         odr_malloc (out, sizeof(*req->inputResultSetNames));
2983     req->inputResultSetNames[0] = odr_strdup (out, setstring);
2984
2985     if (newset && setnumber >= 0)
2986         sprintf (setstring, "%d", ++setnumber);
2987
2988     req->sortedResultSetName = odr_strdup (out, setstring);
2989
2990     req->sortSequence = yaz_sort_spec (out, arg);
2991     if (!req->sortSequence)
2992     {
2993         printf ("Missing sort specifications\n");
2994         return -1;
2995     }
2996     send_apdu(apdu);
2997     return 2;
2998 }
2999
3000 void display_term(Z_TermInfo *t)
3001 {
3002     if (t->displayTerm)
3003         printf("%s", t->displayTerm);
3004     else if (t->term->which == Z_Term_general)
3005     {
3006         printf("%.*s", t->term->u.general->len, t->term->u.general->buf);
3007         sprintf(last_scan_line, "%.*s", t->term->u.general->len,
3008             t->term->u.general->buf);
3009     }
3010     else
3011         printf("Term (not general)");
3012     if (t->globalOccurrences)
3013         printf (" (%d)\n", *t->globalOccurrences);
3014     else
3015         printf ("\n");
3016 }
3017
3018 void process_scanResponse(Z_ScanResponse *res)
3019 {
3020     int i;
3021     Z_Entry **entries = NULL;
3022     int num_entries = 0;
3023
3024     printf("Received ScanResponse\n");
3025     print_refid (res->referenceId);
3026     printf("%d entries", *res->numberOfEntriesReturned);
3027     if (res->positionOfTerm)
3028         printf (", position=%d", *res->positionOfTerm);
3029     printf ("\n");
3030     if (*res->scanStatus != Z_Scan_success)
3031         printf("Scan returned code %d\n", *res->scanStatus);
3032     if (!res->entries)
3033         return;
3034     if ((entries = res->entries->entries))
3035         num_entries = res->entries->num_entries;
3036     for (i = 0; i < num_entries; i++)
3037     {
3038         int pos_term = res->positionOfTerm ? *res->positionOfTerm : -1;
3039         if (entries[i]->which == Z_Entry_termInfo)
3040         {
3041             printf("%c ", i + 1 == pos_term ? '*' : ' ');
3042             display_term(entries[i]->u.termInfo);
3043         }
3044         else
3045             display_diagrecs(&entries[i]->u.surrogateDiagnostic, 1);
3046     }
3047     if (res->entries->nonsurrogateDiagnostics)
3048         display_diagrecs (res->entries->nonsurrogateDiagnostics,
3049                           res->entries->num_nonsurrogateDiagnostics);
3050 }
3051
3052 void process_sortResponse(Z_SortResponse *res)
3053 {
3054     printf("Received SortResponse: status=");
3055     switch (*res->sortStatus)
3056     {
3057     case Z_SortResponse_success:
3058         printf ("success"); break;
3059     case Z_SortResponse_partial_1:
3060         printf ("partial"); break;
3061     case Z_SortResponse_failure:
3062         printf ("failure"); break;
3063     default:
3064         printf ("unknown (%d)", *res->sortStatus);
3065     }
3066     printf ("\n");
3067     print_refid (res->referenceId);
3068     if (res->diagnostics)
3069         display_diagrecs(res->diagnostics,
3070                          res->num_diagnostics);
3071 }
3072
3073 void process_deleteResultSetResponse (Z_DeleteResultSetResponse *res)
3074 {
3075     printf("Got deleteResultSetResponse status=%d\n",
3076            *res->deleteOperationStatus);
3077     if (res->deleteListStatuses)
3078     {
3079         int i;
3080         for (i = 0; i < res->deleteListStatuses->num; i++)
3081         {
3082             printf ("%s status=%d\n", res->deleteListStatuses->elements[i]->id,
3083                     *res->deleteListStatuses->elements[i]->status);
3084         }
3085     }
3086 }
3087
3088 int cmd_sort_generic(const char *arg, int newset)
3089 {
3090     if (only_z3950())
3091         return 0;
3092     if (session_initResponse &&
3093         !ODR_MASK_GET(session_initResponse->options, Z_Options_sort))
3094     {
3095         printf("Target doesn't support sort\n");
3096         return 0;
3097     }
3098     if (*arg)
3099     {
3100         if (send_sortrequest(arg, newset) < 0)
3101             return 0;
3102         return 2;
3103     }
3104     return 0;
3105 }
3106
3107 int cmd_sort(const char *arg)
3108 {
3109     return cmd_sort_generic (arg, 0);
3110 }
3111
3112 int cmd_sort_newset (const char *arg)
3113 {
3114     return cmd_sort_generic (arg, 1);
3115 }
3116
3117 int cmd_scanstep(const char *arg)
3118 {
3119     scan_stepSize = atoi(arg);
3120     return 0;
3121 }
3122
3123 int cmd_scanpos(const char *arg)
3124 {
3125     int r = sscanf(arg, "%d", &scan_position);
3126     if (r == 0)
3127         scan_position = 1;
3128     return 0;
3129 }
3130
3131 int cmd_scansize(const char *arg)
3132 {
3133     int r = sscanf(arg, "%d", &scan_size);
3134     if (r == 0)
3135         scan_size = 20;
3136     return 0;
3137 }
3138
3139 static int cmd_scan_common(const char *set, const char *arg)
3140 {
3141     if (protocol == PROTO_HTTP)
3142     {
3143 #if YAZ_HAVE_XML2
3144         if (!conn)
3145             cmd_open(0);
3146         if (!conn)
3147             return 0;
3148         if (*arg)
3149         {
3150             if (send_SRW_scanRequest(arg, scan_position, scan_size) < 0)
3151                 return 0;
3152         }
3153         else
3154         {
3155             if (send_SRW_scanRequest(last_scan_line, 1, scan_size) < 0)
3156                 return 0;
3157         }
3158         return 2;
3159 #else
3160         return 0;
3161 #endif
3162     }
3163     else
3164     {
3165         if (!conn)
3166         {
3167             try_reconnect();
3168
3169             if (!conn) {
3170                 printf("Session not initialized yet\n");
3171                 return 0;
3172             }
3173         }
3174         if (session_initResponse &&
3175             !ODR_MASK_GET(session_initResponse->options, Z_Options_scan))
3176         {
3177             printf("Target doesn't support scan\n");
3178             return 0;
3179         }
3180         if (*arg)
3181         {
3182             strcpy (last_scan_query, arg);
3183             if (send_scanrequest(set, arg,
3184                                  scan_position, scan_size, 0) < 0)
3185                 return 0;
3186         }
3187         else
3188         {
3189             if (send_scanrequest(set, last_scan_query,
3190                                  1, scan_size, last_scan_line) < 0)
3191                 return 0;
3192         }
3193         return 2;
3194     }
3195 }
3196
3197 int cmd_scan(const char *arg)
3198 {
3199     return cmd_scan_common(0, arg);
3200 }
3201
3202 int cmd_setscan(const char *arg)
3203 {
3204     char setstring[100];
3205     int nor;
3206     if (sscanf(arg, "%99s%n", setstring, &nor) < 1)
3207     {
3208         printf("missing set for setscan\n");
3209         return 0;
3210     }
3211     return cmd_scan_common(setstring, arg + nor);
3212 }
3213
3214 int cmd_schema(const char *arg)
3215 {
3216     xfree(record_schema);
3217     record_schema = 0;
3218     if (arg && *arg)
3219         record_schema = xstrdup(arg);
3220     return 1;
3221 }
3222
3223 int cmd_format(const char *arg)
3224 {
3225     const char *cp = arg;
3226     int nor;
3227     int idx = 0;
3228     int i;
3229     char form_str[41];
3230     if (!arg || !*arg)
3231     {
3232         printf("Usage: format <recordsyntax>\n");
3233         return 0;
3234     }
3235     for (i = 0; i < recordsyntax_size; i++)
3236     {
3237         xfree(recordsyntax_list[i]);
3238         recordsyntax_list[i] = 0;
3239     }
3240
3241     while (sscanf(cp, "%40s%n", form_str, &nor) >= 1 && nor > 0
3242            && idx < RECORDSYNTAX_MAX)
3243     {
3244         if (!strcmp(form_str, "none"))
3245             break;
3246         recordsyntax_list[idx] = xstrdup(form_str);
3247         cp += nor;
3248         idx++;
3249     }
3250     recordsyntax_size = idx;
3251     return 1;
3252 }
3253
3254 int cmd_elements(const char *arg)
3255 {
3256     static Z_ElementSetNames esn;
3257     static char what[100];
3258
3259     if (!arg || !*arg)
3260     {
3261         elementSetNames = 0;
3262         return 1;
3263     }
3264     strcpy(what, arg);
3265     esn.which = Z_ElementSetNames_generic;
3266     esn.u.generic = what;
3267     elementSetNames = &esn;
3268     return 1;
3269 }
3270
3271 int cmd_querytype (const char *arg)
3272 {
3273     if (!strcmp (arg, "ccl"))
3274         queryType = QueryType_CCL;
3275     else if (!strcmp (arg, "prefix") || !strcmp(arg, "rpn"))
3276         queryType = QueryType_Prefix;
3277     else if (!strcmp (arg, "ccl2rpn") || !strcmp (arg, "cclrpn"))
3278         queryType = QueryType_CCL2RPN;
3279     else if (!strcmp(arg, "cql"))
3280         queryType = QueryType_CQL;
3281     else if (!strcmp (arg, "cql2rpn") || !strcmp (arg, "cqlrpn"))
3282         queryType = QueryType_CQL2RPN;
3283     else
3284     {
3285         printf ("Querytype must be one of:\n");
3286         printf (" prefix         - Prefix query\n");
3287         printf (" ccl            - CCL query\n");
3288         printf (" ccl2rpn        - CCL query converted to RPN\n");
3289         printf (" cql            - CQL\n");
3290         printf (" cql2rpn        - CQL query converted to RPN\n");
3291         return 0;
3292     }
3293     return 1;
3294 }
3295
3296 int cmd_refid (const char *arg)
3297 {
3298     xfree (refid);
3299     refid = NULL;
3300     if (*arg)
3301         refid = xstrdup (arg);
3302     return 1;
3303 }
3304
3305 int cmd_close(const char *arg)
3306 {
3307     Z_APDU *apdu;
3308     Z_Close *req;
3309     if (only_z3950())
3310         return 0;
3311     apdu = zget_APDU(out, Z_APDU_close);
3312     req = apdu->u.close;
3313     *req->closeReason = Z_Close_finished;
3314     send_apdu(apdu);
3315     printf("Sent close request.\n");
3316     sent_close = 1;
3317     return 2;
3318 }
3319
3320 int cmd_packagename(const char* arg)
3321 {
3322     xfree (esPackageName);
3323     esPackageName = NULL;
3324     if (*arg)
3325         esPackageName = xstrdup(arg);
3326     return 1;
3327 }
3328
3329 int cmd_proxy(const char* arg)
3330 {
3331     xfree(yazProxy);
3332     yazProxy = 0;
3333     if (*arg)
3334         yazProxy = xstrdup (arg);
3335     return 1;
3336 }
3337
3338 int cmd_marccharset(const char *arg)
3339 {
3340     char l1[30];
3341
3342     *l1 = 0;
3343     if (sscanf(arg, "%29s", l1) < 1)
3344     {
3345         printf("MARC character set is `%s'\n",
3346                marcCharset ? marcCharset: "none");
3347         return 1;
3348     }
3349     xfree (marcCharset);
3350     marcCharset = 0;
3351     if (strcmp(l1, "-"))
3352         marcCharset = xstrdup(l1);
3353     return 1;
3354 }
3355
3356 int cmd_querycharset(const char *arg)
3357 {
3358     char l1[30];
3359
3360     *l1 = 0;
3361     if (sscanf(arg, "%29s", l1) < 1)
3362     {
3363         printf("Query character set is `%s'\n",
3364                queryCharset ? queryCharset: "none");
3365         return 1;
3366     }
3367     xfree (queryCharset);
3368     queryCharset = 0;
3369     if (strcmp(l1, "-"))
3370         queryCharset = xstrdup(l1);
3371     return 1;
3372 }
3373
3374 int cmd_displaycharset(const char *arg)
3375 {
3376     char l1[30];
3377
3378     *l1 = 0;
3379     if (sscanf(arg, "%29s", l1) < 1)
3380     {
3381         printf("Display character set is `%s'\n",
3382                outputCharset ? outputCharset: "none");
3383     }
3384     else
3385     {
3386         xfree (outputCharset);
3387         outputCharset = 0;
3388         if (!strcmp(l1, "auto") && codeset)
3389         {
3390             if (codeset)
3391             {
3392                 printf ("Display character set: %s\n", codeset);
3393                 outputCharset = xstrdup(codeset);
3394             }
3395             else
3396                 printf ("No codeset found on this system\n");
3397         }
3398         else if (strcmp(l1, "-") && strcmp(l1, "none"))
3399             outputCharset = xstrdup(l1);
3400     }
3401     return 1;
3402 }
3403
3404 int cmd_negcharset(const char *arg)
3405 {
3406     char l1[30];
3407
3408     *l1 = 0;
3409     if (sscanf(arg, "%29s %d %d", l1, &negotiationCharsetRecords,
3410                &negotiationCharsetVersion) < 1)
3411     {
3412         printf("Current negotiation character set is `%s'\n",
3413                negotiationCharset ? negotiationCharset: "none");
3414         printf("Records in charset %s\n", negotiationCharsetRecords ?
3415                "yes" : "no");
3416         printf("Charneg version %d\n", negotiationCharsetVersion);
3417     }
3418     else
3419     {
3420         xfree (negotiationCharset);
3421         negotiationCharset = NULL;
3422         if (*l1 && strcmp(l1, "-") && strcmp(l1, "none"))
3423         {
3424             negotiationCharset = xstrdup(l1);
3425             printf ("Character set negotiation : %s\n", negotiationCharset);
3426         }
3427     }
3428     return 1;
3429 }
3430
3431 int cmd_charset(const char* arg)
3432 {
3433     char l1[30], l2[30], l3[30];
3434
3435     *l1 = *l2 = *l3 = 0;
3436     if (sscanf(arg, "%29s %29s %29s", l1, l2, l3) < 1)
3437     {
3438         cmd_negcharset("");
3439         cmd_displaycharset("");
3440         cmd_marccharset("");
3441     }
3442     else
3443     {
3444         cmd_negcharset(l1);
3445         if (*l2)
3446             cmd_displaycharset(l2);
3447         if (*l3)
3448             cmd_marccharset(l3);
3449     }
3450     return 1;
3451 }
3452
3453 int cmd_lang(const char* arg)
3454 {
3455     if (*arg == '\0') {
3456         printf("Current language is `%s'\n", (yazLang)?yazLang:NULL);
3457         return 1;
3458     }
3459     xfree (yazLang);
3460     yazLang = NULL;
3461     if (*arg)
3462         yazLang = xstrdup(arg);
3463     return 1;
3464 }
3465
3466 int cmd_source(const char* arg, int echo )
3467 {
3468     /* first should open the file and read one line at a time.. */
3469     FILE* includeFile;
3470     char line[102400], *cp;
3471
3472     if(strlen(arg)<1) {
3473         fprintf(stderr,"Error in source command use a filename\n");
3474         return -1;
3475     }
3476
3477     includeFile = fopen (arg, "r");
3478
3479     if(!includeFile) {
3480         fprintf(stderr,"Unable to open file %s for reading\n",arg);
3481         return -1;
3482     }
3483
3484     while(!feof(includeFile)) {
3485         memset(line,0,sizeof(line));
3486         fgets(line,sizeof(line),includeFile);
3487
3488         if(strlen(line) < 2) continue;
3489         if(line[0] == '#') continue;
3490
3491         if ((cp = strrchr (line, '\n')))
3492             *cp = '\0';
3493
3494         if( echo ) {
3495             printf( "processing line: %s\n",line );
3496         };
3497         process_cmd_line(line);
3498     }
3499
3500     if(fclose(includeFile)<0) {
3501         perror("unable to close include file");
3502         exit(1);
3503     }
3504     return 1;
3505 }
3506
3507 int cmd_source_echo(const char* arg)
3508 {
3509     cmd_source(arg, 1);
3510     return 1;
3511 }
3512
3513 int cmd_source_noecho(const char* arg)
3514 {
3515     cmd_source(arg, 0);
3516     return 1;
3517 }
3518
3519
3520 int cmd_subshell(const char* args)
3521 {
3522     if(strlen(args))
3523         system(args);
3524     else
3525         system(getenv("SHELL"));
3526
3527     printf("\n");
3528     return 1;
3529 }
3530
3531 int cmd_set_berfile(const char *arg)
3532 {
3533     if (ber_file && ber_file != stdout && ber_file != stderr)
3534         fclose(ber_file);
3535     if (!strcmp(arg, ""))
3536         ber_file = 0;
3537     else if (!strcmp(arg, "-"))
3538         ber_file = stdout;
3539     else
3540         ber_file = fopen(arg, "a");
3541     return 1;
3542 }
3543
3544 int cmd_set_apdufile(const char *arg)
3545 {
3546     if(apdu_file && apdu_file != stderr && apdu_file != stderr)
3547         fclose(apdu_file);
3548     if (!strcmp(arg, ""))
3549         apdu_file = 0;
3550     else if (!strcmp(arg, "-"))
3551         apdu_file = stderr;
3552     else
3553     {
3554         apdu_file = fopen(arg, "a");
3555         if (!apdu_file)
3556             perror("unable to open apdu log file");
3557     }
3558     if (apdu_file)
3559         odr_setprint(print, apdu_file);
3560     return 1;
3561 }
3562
3563 int cmd_set_cclfile(const char* arg)
3564 {
3565     FILE *inf;
3566
3567     bibset = ccl_qual_mk ();
3568     inf = fopen (arg, "r");
3569     if (!inf)
3570         perror("unable to open CCL file");
3571     else
3572     {
3573         ccl_qual_file (bibset, inf);
3574         fclose (inf);
3575     }
3576     strcpy(ccl_fields,arg);
3577     return 0;
3578 }
3579
3580 int cmd_set_cqlfile(const char* arg)
3581 {
3582     cql_transform_t newcqltrans;
3583
3584     if ((newcqltrans = cql_transform_open_fname(arg)) == 0) {
3585         perror("unable to open CQL file");
3586         return 0;
3587     }
3588     if (cqltrans != 0)
3589         cql_transform_close(cqltrans);
3590
3591     cqltrans = newcqltrans;
3592     strcpy(cql_fields, arg);
3593     return 0;
3594 }
3595
3596 int cmd_set_auto_reconnect(const char* arg)
3597 {
3598     if(strlen(arg)==0) {
3599         auto_reconnect = ! auto_reconnect;
3600     } else if(strcmp(arg,"on")==0) {
3601         auto_reconnect = 1;
3602     } else if(strcmp(arg,"off")==0) {
3603         auto_reconnect = 0;
3604     } else {
3605         printf("Error use on or off\n");
3606         return 1;
3607     }
3608
3609     if (auto_reconnect)
3610         printf("Set auto reconnect enabled.\n");
3611     else
3612         printf("Set auto reconnect disabled.\n");
3613
3614     return 0;
3615 }
3616
3617
3618 int cmd_set_auto_wait(const char* arg)
3619 {
3620     if(strlen(arg)==0) {
3621         auto_wait = ! auto_wait;
3622     } else if(strcmp(arg,"on")==0) {
3623         auto_wait = 1;
3624     } else if(strcmp(arg,"off")==0) {
3625         auto_wait = 0;
3626     } else {
3627         printf("Error use on or off\n");
3628         return 1;
3629     }
3630
3631     if (auto_wait)
3632         printf("Set auto wait enabled.\n");
3633     else
3634         printf("Set auto wait disabled.\n");
3635
3636     return 0;
3637 }
3638
3639 int cmd_set_marcdump(const char* arg)
3640 {
3641     if(marc_file && marc_file != stderr) { /* don't close stdout*/
3642         fclose(marc_file);
3643     }
3644
3645     if (!strcmp(arg, ""))
3646         marc_file = 0;
3647     else if (!strcmp(arg, "-"))
3648         marc_file = stderr;
3649     else
3650     {
3651         marc_file = fopen(arg, "a");
3652         if (!marc_file)
3653             perror("unable to open marc log file");
3654     }
3655     return 1;
3656 }
3657
3658 /*
3659    this command takes 3 arge {name class oid}
3660 */
3661 int cmd_register_oid(const char* args) {
3662     static struct {
3663         char* className;
3664         oid_class oclass;
3665     } oid_classes[] = {
3666         {"appctx",CLASS_APPCTX},
3667         {"absyn",CLASS_ABSYN},
3668         {"attset",CLASS_ATTSET},
3669         {"transyn",CLASS_TRANSYN},
3670         {"diagset",CLASS_DIAGSET},
3671         {"recsyn",CLASS_RECSYN},
3672         {"resform",CLASS_RESFORM},
3673         {"accform",CLASS_ACCFORM},
3674         {"extserv",CLASS_EXTSERV},
3675         {"userinfo",CLASS_USERINFO},
3676         {"elemspec",CLASS_ELEMSPEC},
3677         {"varset",CLASS_VARSET},
3678         {"schema",CLASS_SCHEMA},
3679         {"tagset",CLASS_TAGSET},
3680         {"general",CLASS_GENERAL},
3681         {0,(enum oid_class) 0}
3682     };
3683     char oname_str[101], oclass_str[101], oid_str[101];
3684     int i;
3685     oid_class oidclass = CLASS_GENERAL;
3686     Odr_oid oid[OID_SIZE];
3687
3688     if (sscanf (args, "%100[^ ] %100[^ ] %100s",
3689                 oname_str,oclass_str, oid_str) < 1) {
3690         printf("Error in register command \n");
3691         return 0;
3692     }
3693
3694     for (i = 0; oid_classes[i].className; i++) {
3695         if (!strcmp(oid_classes[i].className, oclass_str))
3696         {
3697             oidclass=oid_classes[i].oclass;
3698             break;
3699         }
3700     }
3701
3702     if(!(oid_classes[i].className)) {
3703         printf("Unknown oid class %s\n",oclass_str);
3704         return 0;
3705     }
3706
3707     oid_dotstring_to_oid(oid_str, oid);
3708
3709     if (yaz_oid_add(yaz_oid_std(), oidclass, oname_str, oid))
3710     {
3711         printf("oid %s already exists, registration failed\n",
3712                oname_str);
3713     }
3714     return 1;
3715 }
3716
3717 int cmd_push_command(const char* arg)
3718 {
3719 #if HAVE_READLINE_HISTORY_H
3720     if(strlen(arg)>1)
3721         add_history(arg);
3722 #else
3723     fprintf(stderr,"Not compiled with the readline/history module\n");
3724 #endif
3725     return 1;
3726 }
3727
3728 void source_rcfile(void)
3729 {
3730     /*  Look for a $HOME/.yazclientrc and source it if it exists */
3731     struct stat statbuf;
3732     char fname[1000];
3733     char* homedir = getenv("HOME");
3734
3735     sprintf(fname, "%.500s%s%s", homedir ? homedir : "",
3736             homedir ? "/" : "",
3737             ".yazclientrc");
3738
3739     if (stat(fname,&statbuf)==0)
3740         cmd_source(fname, 0 );
3741 }
3742
3743 void add_to_readline_history(void *client_data, const char *line)
3744 {
3745 #if HAVE_READLINE_HISTORY_H
3746     if (strlen(line))
3747         add_history(line);
3748 #endif
3749 }
3750
3751 static void initialize(void)
3752 {
3753     FILE *inf;
3754     int i;
3755
3756     if (!(out = odr_createmem(ODR_ENCODE)) ||
3757         !(in = odr_createmem(ODR_DECODE)) ||
3758         !(print = odr_createmem(ODR_PRINT)))
3759     {
3760         fprintf(stderr, "failed to allocate ODR streams\n");
3761         exit(1);
3762     }
3763
3764     setvbuf(stdout, 0, _IONBF, 0);
3765     if (apdu_file)
3766         odr_setprint(print, apdu_file);
3767
3768     bibset = ccl_qual_mk ();
3769     inf = fopen (ccl_fields, "r");
3770     if (inf)
3771     {
3772         ccl_qual_file (bibset, inf);
3773         fclose (inf);
3774     }
3775
3776     cqltrans = cql_transform_open_fname(cql_fields);
3777     /* If this fails, no problem: we detect cqltrans == 0 later */
3778
3779 #if HAVE_READLINE_READLINE_H
3780     rl_attempted_completion_function =
3781         (char **(*)(const char *, int, int)) readline_completer;
3782 #endif
3783     for(i = 0; i < maxOtherInfosSupported; ++i) {
3784         extraOtherInfos[i].oid[0] = -1;
3785         extraOtherInfos[i].value = 0;
3786     }
3787
3788     cmd_format("usmarc");
3789
3790     source_rcfile();
3791
3792     file_history = file_history_new();
3793     file_history_load(file_history);
3794     file_history_trav(file_history, 0, add_to_readline_history);
3795 }
3796
3797
3798 #if HAVE_GETTIMEOFDAY
3799 struct timeval tv_start;
3800 #endif
3801
3802 #if YAZ_HAVE_XML2
3803 static void handle_srw_record(Z_SRW_record *rec)
3804 {
3805     if (rec->recordPosition)
3806     {
3807         printf ("pos=%d", *rec->recordPosition);
3808         setno = *rec->recordPosition + 1;
3809     }
3810     if (rec->recordSchema)
3811         printf (" schema=%s", rec->recordSchema);
3812     printf ("\n");
3813     if (rec->recordData_buf && rec->recordData_len)
3814     {
3815         fwrite(rec->recordData_buf, 1, rec->recordData_len, stdout);
3816         if (marc_file)
3817             fwrite (rec->recordData_buf, 1, rec->recordData_len, marc_file);
3818     }
3819     else
3820         printf ("No data!");
3821     printf("\n");
3822 }
3823
3824 static void handle_srw_explain_response(Z_SRW_explainResponse *res)
3825 {
3826     handle_srw_record(&res->record);
3827 }
3828
3829 static void handle_srw_response(Z_SRW_searchRetrieveResponse *res)
3830 {
3831     int i;
3832
3833     printf ("Received SRW SearchRetrieve Response\n");
3834
3835     for (i = 0; i<res->num_diagnostics; i++)
3836     {
3837         if (res->diagnostics[i].uri)
3838             printf ("SRW diagnostic %s\n",
3839                     res->diagnostics[i].uri);
3840         else
3841             printf ("SRW diagnostic missing or could not be decoded\n");
3842         if (res->diagnostics[i].message)
3843             printf ("Message: %s\n", res->diagnostics[i].message);
3844         if (res->diagnostics[i].details)
3845             printf ("Details: %s\n", res->diagnostics[i].details);
3846     }
3847     if (res->numberOfRecords)
3848         printf ("Number of hits: %d\n", *res->numberOfRecords);
3849     for (i = 0; i<res->num_records; i++)
3850         handle_srw_record(res->records + i);
3851 }
3852
3853 static void handle_srw_scan_term(Z_SRW_scanTerm *term)
3854 {
3855     if (term->displayTerm)
3856         printf("%s:", term->displayTerm);
3857     else if (term->value)
3858         printf("%s:", term->value);
3859     else
3860         printf("No value:");
3861     if (term->numberOfRecords)
3862         printf(" %d", *term->numberOfRecords);
3863     if (term->whereInList)
3864         printf(" %s", term->whereInList);
3865     if (term->value && term->displayTerm)
3866         printf(" %s", term->value);
3867
3868     strcpy(last_scan_line, term->value);
3869     printf("\n");
3870 }
3871
3872 static void handle_srw_scan_response(Z_SRW_scanResponse *res)
3873 {
3874     int i;
3875
3876     printf ("Received SRW Scan Response\n");
3877
3878     for (i = 0; i<res->num_diagnostics; i++)
3879     {
3880         if (res->diagnostics[i].uri)
3881             printf ("SRW diagnostic %s\n",
3882                     res->diagnostics[i].uri);
3883         else
3884             printf ("SRW diagnostic missing or could not be decoded\n");
3885         if (res->diagnostics[i].message)
3886             printf ("Message: %s\n", res->diagnostics[i].message);
3887         if (res->diagnostics[i].details)
3888             printf ("Details: %s\n", res->diagnostics[i].details);
3889     }
3890     if (res->terms)
3891         for (i = 0; i<res->num_terms; i++)
3892             handle_srw_scan_term(res->terms + i);
3893 }
3894
3895 static void http_response(Z_HTTP_Response *hres)
3896 {
3897     int ret = -1;
3898     const char *connection_head = z_HTTP_header_lookup(hres->headers,
3899                                                        "Connection");
3900     if (!yaz_srw_check_content_type(hres))
3901         printf("Content type does not appear to be XML");
3902     else
3903     {
3904         Z_SOAP *soap_package = 0;
3905         ODR o = odr_createmem(ODR_DECODE);
3906         Z_SOAP_Handler soap_handlers[3] = {
3907             {YAZ_XMLNS_SRU_v1_1, 0, (Z_SOAP_fun) yaz_srw_codec},
3908             {YAZ_XMLNS_UPDATE_v0_9, 0, (Z_SOAP_fun) yaz_ucp_codec},
3909             {0, 0, 0}
3910         };
3911         ret = z_soap_codec(o, &soap_package,
3912                            &hres->content_buf, &hres->content_len,
3913                            soap_handlers);
3914         if (!ret && soap_package->which == Z_SOAP_generic)
3915         {
3916             Z_SRW_PDU *sr = (Z_SRW_PDU *) soap_package->u.generic->p;
3917             if (sr->which == Z_SRW_searchRetrieve_response)
3918                 handle_srw_response(sr->u.response);
3919             else if (sr->which == Z_SRW_explain_response)
3920                 handle_srw_explain_response(sr->u.explain_response);
3921             else if (sr->which == Z_SRW_scan_response)
3922                 handle_srw_scan_response(sr->u.scan_response);
3923             else if (sr->which == Z_SRW_update_response)
3924                 printf("Got update response. Status: %s\n",
3925                        sr->u.update_response->operationStatus);
3926             else
3927                 ret = -1;
3928         }
3929         else if (soap_package && (soap_package->which == Z_SOAP_fault
3930                                   || soap_package->which == Z_SOAP_error))
3931         {
3932             printf ("HTTP Error Status=%d\n", hres->code);
3933             printf ("SOAP Fault code %s\n",
3934                     soap_package->u.fault->fault_code);
3935             printf ("SOAP Fault string %s\n",
3936                     soap_package->u.fault->fault_string);
3937             if (soap_package->u.fault->details)
3938                 printf ("SOAP Details %s\n",
3939                         soap_package->u.fault->details);
3940         }
3941         else
3942         {
3943             printf("z_soap_codec failed. (no SOAP error)\n");
3944             ret = -1;
3945         }
3946         odr_destroy(o);
3947     }
3948     if (ret)
3949     {
3950         if (hres->code != 200)
3951         {
3952             printf ("HTTP Error Status=%d\n", hres->code);
3953         }
3954         else
3955         {
3956             printf ("Decoding of SRW package failed\n");
3957         }
3958         close_session();
3959     }
3960     else
3961     {
3962         if (!strcmp(hres->version, "1.0"))
3963         {
3964             /* HTTP 1.0: only if Keep-Alive we stay alive.. */
3965             if (!connection_head || strcmp(connection_head, "Keep-Alive"))
3966                 close_session();
3967         }
3968         else
3969         {
3970             /* HTTP 1.1: only if no close we stay alive .. */
3971             if (connection_head && !strcmp(connection_head, "close"))
3972                 close_session();
3973         }
3974     }
3975 }
3976 #endif
3977
3978 void wait_and_handle_response(int one_response_only)
3979 {
3980     int reconnect_ok = 1;
3981     int res;
3982     char *netbuffer= 0;
3983     int netbufferlen = 0;
3984 #if HAVE_GETTIMEOFDAY
3985     int got_tv_end = 0;
3986     struct timeval tv_end;
3987 #endif
3988     Z_GDU *gdu;
3989
3990     while(conn)
3991     {
3992         res = cs_get(conn, &netbuffer, &netbufferlen);
3993         if (reconnect_ok && res <= 0 && protocol == PROTO_HTTP)
3994         {
3995             cs_close(conn);
3996             conn = 0;
3997             cmd_open(0);
3998             reconnect_ok = 0;
3999             if (conn)
4000             {
4001                 char *buf_out;
4002                 int len_out;
4003
4004                 buf_out = odr_getbuf(out, &len_out, 0);
4005
4006                 do_hex_dump(buf_out, len_out);
4007
4008                 cs_put(conn, buf_out, len_out);
4009
4010                 odr_reset(out);
4011                 continue;
4012             }
4013         }
4014         else if (res <= 0)
4015         {
4016             printf("Target closed connection\n");
4017             close_session();
4018             break;
4019         }
4020 #if HAVE_GETTIMEOFDAY
4021         if (got_tv_end == 0)
4022             gettimeofday (&tv_end, 0); /* count first one only */
4023         got_tv_end++;
4024 #endif
4025         odr_reset(out);
4026         odr_reset(in); /* release APDU from last round */
4027         record_last = 0;
4028         do_hex_dump(netbuffer, res);
4029         odr_setbuf(in, netbuffer, res, 0);
4030
4031         if (!z_GDU(in, &gdu, 0, 0))
4032         {
4033             FILE *f = ber_file ? ber_file : stdout;
4034             odr_perror(in, "Decoding incoming APDU");
4035             fprintf(f, "[Near %ld]\n", (long) odr_offset(in));
4036             fprintf(f, "Packet dump:\n---------\n");
4037             odr_dumpBER(f, netbuffer, res);
4038             fprintf(f, "---------\n");
4039             if (apdu_file)
4040             {
4041                 z_GDU(print, &gdu, 0, 0);
4042                 odr_reset(print);
4043             }
4044             if (conn && cs_more(conn))
4045                 continue;
4046             break;
4047         }
4048         if (ber_file)
4049             odr_dumpBER(ber_file, netbuffer, res);
4050         if (apdu_file && !z_GDU(print, &gdu, 0, 0))
4051         {
4052             odr_perror(print, "Failed to print incoming APDU");
4053             odr_reset(print);
4054                 continue;
4055         }
4056         if (gdu->which == Z_GDU_Z3950)
4057         {
4058             Z_APDU *apdu = gdu->u.z3950;
4059             switch(apdu->which)
4060             {
4061             case Z_APDU_initResponse:
4062                 process_initResponse(apdu->u.initResponse);
4063                 break;
4064             case Z_APDU_searchResponse:
4065                 process_searchResponse(apdu->u.searchResponse);
4066                 break;
4067             case Z_APDU_scanResponse:
4068                 process_scanResponse(apdu->u.scanResponse);
4069                 break;
4070             case Z_APDU_presentResponse:
4071                 print_refid (apdu->u.presentResponse->referenceId);
4072                 setno +=
4073                     *apdu->u.presentResponse->numberOfRecordsReturned;
4074                 if (apdu->u.presentResponse->records)
4075                     display_records(apdu->u.presentResponse->records);
4076                 else
4077                     printf("No records.\n");
4078                 printf ("nextResultSetPosition = %d\n",
4079                         *apdu->u.presentResponse->nextResultSetPosition);
4080                 break;
4081             case Z_APDU_sortResponse:
4082                 process_sortResponse(apdu->u.sortResponse);
4083                 break;
4084             case Z_APDU_extendedServicesResponse:
4085                 printf("Got extended services response\n");
4086                 process_ESResponse(apdu->u.extendedServicesResponse);
4087                 break;
4088             case Z_APDU_close:
4089                 printf("Target has closed the association.\n");
4090                 process_close(apdu->u.close);
4091                 break;
4092             case Z_APDU_resourceControlRequest:
4093                 process_resourceControlRequest
4094                     (apdu->u.resourceControlRequest);
4095                 break;
4096             case Z_APDU_deleteResultSetResponse:
4097                 process_deleteResultSetResponse(apdu->u.
4098                                                 deleteResultSetResponse);
4099                 break;
4100             default:
4101                 printf("Received unknown APDU type (%d).\n",
4102                        apdu->which);
4103                 close_session ();
4104             }
4105         }
4106 #if YAZ_HAVE_XML2
4107         else if (gdu->which == Z_GDU_HTTP_Response)
4108         {
4109             http_response(gdu->u.HTTP_Response);
4110         }
4111 #endif
4112         if (one_response_only)
4113             break;
4114         if (conn && !cs_more(conn))
4115             break;
4116     }
4117 #if HAVE_GETTIMEOFDAY
4118     if (got_tv_end)
4119     {
4120 #if 0
4121         printf ("S/U S/U=%ld/%ld %ld/%ld",
4122                 (long) tv_start.tv_sec,
4123                 (long) tv_start.tv_usec,
4124                 (long) tv_end.tv_sec,
4125                 (long) tv_end.tv_usec);
4126 #endif
4127         printf ("Elapsed: %.6f\n",
4128                 (double) tv_end.tv_usec / 1e6 + tv_end.tv_sec -
4129                 ((double) tv_start.tv_usec / 1e6 + tv_start.tv_sec));
4130     }
4131 #endif
4132     xfree (netbuffer);
4133 }
4134
4135
4136 int cmd_cclparse(const char* arg)
4137 {
4138     int error, pos;
4139     struct ccl_rpn_node *rpn=NULL;
4140
4141
4142     rpn = ccl_find_str (bibset, arg, &error, &pos);
4143
4144     if (error) {
4145         int ioff = 3+strlen(last_cmd)+1+pos;
4146         printf ("%*s^ - ", ioff, " ");
4147         printf ("%s\n", ccl_err_msg (error));
4148     }
4149     else
4150     {
4151         if (rpn)
4152         {
4153             ccl_pr_tree(rpn, stdout);
4154         }
4155     }
4156     if (rpn)
4157         ccl_rpn_delete(rpn);
4158
4159     printf ("\n");
4160
4161     return 0;
4162 }
4163
4164
4165 int cmd_set_otherinfo(const char* args)
4166 {
4167     char oidstr[101], otherinfoString[101];
4168     int otherinfoNo;
4169     int sscan_res;
4170
4171     sscan_res = sscanf (args, "%d %100[^ ] %100s",
4172                         &otherinfoNo, oidstr, otherinfoString);
4173
4174     if (sscan_res > 0 && otherinfoNo >= maxOtherInfosSupported) {
4175         printf("Error otherinfo index too large (%d>=%d)\n",
4176                otherinfoNo,maxOtherInfosSupported);
4177         return 0;
4178     }
4179
4180
4181     if (sscan_res==1)
4182     {
4183         /* reset this otherinfo */
4184         extraOtherInfos[otherinfoNo].oid[0] = -1;
4185         xfree(extraOtherInfos[otherinfoNo].value);
4186         extraOtherInfos[otherinfoNo].value = 0;
4187         return 0;
4188     }
4189     if (sscan_res != 3) {
4190         printf("Error in set_otherinfo command \n");
4191         return 0;
4192     }
4193     else
4194     {
4195         NMEM oid_tmp = nmem_create();
4196         const Odr_oid *oid =
4197             yaz_string_to_oid_nmem(yaz_oid_std(),
4198                                    CLASS_GENERAL, oidstr, oid_tmp);
4199         oid_oidcpy(extraOtherInfos[otherinfoNo].oid, oid);
4200
4201         xfree(extraOtherInfos[otherinfoNo].value);
4202         extraOtherInfos[otherinfoNo].value = xstrdup(otherinfoString);
4203
4204         nmem_destroy(oid_tmp);
4205     }
4206
4207     return 0;
4208 }
4209
4210 int cmd_sleep(const char* args )
4211 {
4212     int sec=atoi(args);
4213     if( sec > 0 ) {
4214 #ifdef WIN32
4215         Sleep(sec*1000);
4216 #else
4217         sleep(sec);
4218 #endif
4219         printf("Done sleeping %d seconds\n", sec);
4220     }
4221     return 1;
4222 }
4223
4224 int cmd_list_otherinfo(const char* args)
4225 {
4226     int i;
4227
4228     if (strlen(args)>0)
4229     {
4230         i = atoi(args);
4231         if (i >= maxOtherInfosSupported)
4232         {
4233             printf("Error otherinfo index to large (%d>%d)\n",i,maxOtherInfosSupported);
4234             return 0;
4235         }
4236         if (extraOtherInfos[i].value)
4237         {
4238             char name_oid[OID_STR_MAX];
4239             oid_class oclass;
4240             const char *name =
4241                 yaz_oid_to_string_buf(extraOtherInfos[i].oid, &oclass,
4242                                       name_oid);
4243             printf("  otherinfo %d %s %s\n",
4244                    i, name ? name : "null",
4245                    extraOtherInfos[i].value);
4246         }
4247
4248     }
4249     else
4250     {
4251         for(i = 0; i < maxOtherInfosSupported; ++i)
4252         {
4253             if (extraOtherInfos[i].value)
4254             {
4255                 char name_oid[OID_STR_MAX];
4256                 oid_class oclass;
4257                 const char *name =
4258                     yaz_oid_to_string_buf(extraOtherInfos[i].oid, &oclass,
4259                                           name_oid);
4260                 printf("  otherinfo %d %s %s\n",
4261                        i, name ? name : "null",
4262                        extraOtherInfos[i].value);
4263             }
4264         }
4265     }
4266     return 0;
4267 }
4268
4269
4270 int cmd_list_all(const char* args) {
4271     int i;
4272
4273     /* connection options */
4274     if(conn) {
4275         printf("Connected to         : %s\n",last_open_command);
4276     } else {
4277         if(last_open_command)
4278             printf("Not connected to     : %s\n",last_open_command);
4279         else
4280             printf("Not connected        : \n");
4281
4282     }
4283     if(yazProxy) printf("using proxy          : %s\n",yazProxy);
4284
4285     printf("auto_reconnect       : %s\n",auto_reconnect?"on":"off");
4286     printf("auto_wait            : %s\n",auto_wait?"on":"off");
4287
4288     if (!auth) {
4289         printf("Authentication       : none\n");
4290     } else {
4291         switch(auth->which) {
4292         case Z_IdAuthentication_idPass:
4293             printf("Authentication       : IdPass\n");
4294             printf("    Login User       : %s\n",auth->u.idPass->userId?auth->u.idPass->userId:"");
4295             printf("    Login Group      : %s\n",auth->u.idPass->groupId?auth->u.idPass->groupId:"");
4296             printf("    Password         : %s\n",auth->u.idPass->password?auth->u.idPass->password:"");
4297             break;
4298         case Z_IdAuthentication_open:
4299             printf("Authentication       : psOpen\n");
4300             printf("    Open string      : %s\n",auth->u.open);
4301             break;
4302         default:
4303             printf("Authentication       : Unknown\n");
4304         }
4305     }
4306     if (negotiationCharset)
4307         printf("Neg. Character set   : `%s'\n", negotiationCharset);
4308
4309     /* bases */
4310     printf("Bases                : ");
4311     for (i = 0; i<num_databaseNames; i++) printf("%s ",databaseNames[i]);
4312     printf("\n");
4313
4314     /* Query options */
4315     printf("CCL file             : %s\n",ccl_fields);
4316     printf("CQL file             : %s\n",cql_fields);
4317     printf("Query type           : %s\n",query_type_as_string(queryType));
4318
4319     printf("Named Result Sets    : %s\n",setnumber==-1?"off":"on");
4320
4321     /* piggy back options */
4322     printf("ssub/lslb/mspn       : %d/%d/%d\n",smallSetUpperBound,largeSetLowerBound,mediumSetPresentNumber);
4323
4324     /* print present related options */
4325     if (recordsyntax_size > 0)
4326     {
4327         printf("Format               : %s\n", recordsyntax_list[0]);
4328     }
4329     printf("Schema               : %s\n",record_schema ? record_schema : "not set");
4330     printf("Elements             : %s\n",elementSetNames?elementSetNames->u.generic:"");
4331
4332     /* loging options */
4333     printf("APDU log             : %s\n",apdu_file?"on":"off");
4334     printf("Record log           : %s\n",marc_file?"on":"off");
4335
4336     /* other infos */
4337     printf("Other Info: \n");
4338     cmd_list_otherinfo("");
4339
4340     return 0;
4341 }
4342
4343 int cmd_clear_otherinfo(const char* args)
4344 {
4345     if(strlen(args)>0) {
4346         int otherinfoNo = atoi(args);
4347         if (otherinfoNo >= maxOtherInfosSupported) {
4348             printf("Error otherinfo index too large (%d>=%d)\n",
4349                    otherinfoNo, maxOtherInfosSupported);
4350             return 0;
4351         }
4352         if (extraOtherInfos[otherinfoNo].value)
4353         {
4354             /* only clear if set. */
4355             extraOtherInfos[otherinfoNo].oid[0] = -1;
4356             xfree(extraOtherInfos[otherinfoNo].value);
4357             extraOtherInfos[otherinfoNo].value = 0;
4358         }
4359     } else {
4360         int i;
4361         for(i = 0; i < maxOtherInfosSupported; ++i)
4362         {
4363             if (extraOtherInfos[i].value)
4364             {
4365                 extraOtherInfos[i].oid[0] = -1;
4366                 xfree(extraOtherInfos[i].value);
4367                 extraOtherInfos[i].value = 0;
4368             }
4369         }
4370     }
4371     return 0;
4372 }
4373
4374 int cmd_wait_response(const char *arg)
4375 {
4376     int wait_for = atoi(arg);
4377     int i=0;
4378     if( wait_for < 1 ) {
4379         wait_for = 1;
4380     };
4381
4382     for( i=0 ; i < wait_for ; ++i ) {
4383         wait_and_handle_response(1);
4384     };
4385     return 0;
4386 }
4387
4388 static int cmd_help (const char *line);
4389
4390 typedef char *(*completerFunctionType)(const char *text, int state);
4391
4392 static struct {
4393     char *cmd;
4394     int (*fun)(const char *arg);
4395     char *ad;
4396         completerFunctionType rl_completerfunction;
4397     int complete_filenames;
4398     const char **local_tabcompletes;
4399 } cmd_array[] = {
4400     {"open", cmd_open, "('tcp'|'ssl')':<host>[':'<port>][/<db>]",NULL,0,NULL},
4401     {"quit", cmd_quit, "",NULL,0,NULL},
4402     {"find", cmd_find, "<query>",NULL,0,NULL},
4403     {"delete", cmd_delete, "<setname>",NULL,0,NULL},
4404     {"base", cmd_base, "<base-name>",NULL,0,NULL},
4405     {"show", cmd_show, "<rec#>['+'<#recs>['+'<setname>]]",NULL,0,NULL},
4406     {"setscan", cmd_setscan, "<term>",NULL,0,NULL},
4407     {"scan", cmd_scan, "<term>",NULL,0,NULL},
4408     {"scanstep", cmd_scanstep, "<size>",NULL,0,NULL},
4409     {"scanpos", cmd_scanpos, "<size>",NULL,0,NULL},
4410     {"scansize", cmd_scansize, "<size>",NULL,0,NULL},
4411     {"sort", cmd_sort, "<sortkey> <flag> <sortkey> <flag> ...",NULL,0,NULL},
4412     {"sort+", cmd_sort_newset, "<sortkey> <flag> <sortkey> <flag> ...",NULL,0,NULL},
4413     {"authentication", cmd_authentication, "<acctstring>",NULL,0,NULL},
4414     {"lslb", cmd_lslb, "<largeSetLowerBound>",NULL,0,NULL},
4415     {"ssub", cmd_ssub, "<smallSetUpperBound>",NULL,0,NULL},
4416     {"mspn", cmd_mspn, "<mediumSetPresentNumber>",NULL,0,NULL},
4417     {"status", cmd_status, "",NULL,0,NULL},
4418     {"setnames", cmd_setnames, "",NULL,0,NULL},
4419     {"cancel", cmd_cancel, "",NULL,0,NULL},
4420     {"cancel_find", cmd_cancel_find, "<query>",NULL,0,NULL},
4421     {"format", cmd_format, "<recordsyntax>",complete_format,0,NULL},
4422     {"schema", cmd_schema, "<schema>",complete_schema,0,NULL},
4423     {"elements", cmd_elements, "<elementSetName>",NULL,0,NULL},
4424     {"close", cmd_close, "",NULL,0,NULL},
4425     {"querytype", cmd_querytype, "<type>",complete_querytype,0,NULL},
4426     {"refid", cmd_refid, "<id>",NULL,0,NULL},
4427     {"itemorder", cmd_itemorder, "ill|item|xml <itemno>",NULL,0,NULL},
4428     {"update", cmd_update, "<action> <recid> [<doc>]",NULL,0,NULL},
4429     {"update0", cmd_update0, "<action> <recid> [<doc>]",NULL,0,NULL},
4430     {"xmles", cmd_xmles, "<OID> <doc>",NULL,0,NULL},
4431     {"packagename", cmd_packagename, "<packagename>",NULL,0,NULL},
4432     {"proxy", cmd_proxy, "[('tcp'|'ssl')]<host>[':'<port>]",NULL,0,NULL},
4433     {"charset", cmd_charset, "<nego_charset> <output_charset>",NULL,0,NULL},
4434     {"negcharset", cmd_negcharset, "<nego_charset>",NULL,0,NULL},
4435     {"displaycharset", cmd_displaycharset, "<output_charset>",NULL,0,NULL},
4436     {"marccharset", cmd_marccharset, "<charset_name>",NULL,0,NULL},
4437     {"querycharset", cmd_querycharset, "<charset_name>",NULL,0,NULL},
4438     {"lang", cmd_lang, "<language_code>",NULL,0,NULL},
4439     {"source", cmd_source_echo, "<filename>",NULL,1,NULL},
4440     {".", cmd_source_echo, "<filename>",NULL,1,NULL},
4441     {"!", cmd_subshell, "Subshell command",NULL,1,NULL},
4442     {"set_apdufile", cmd_set_apdufile, "<filename>",NULL,1,NULL},
4443     {"set_berfile", cmd_set_berfile, "<filename>",NULL,1,NULL},
4444     {"set_marcdump", cmd_set_marcdump," <filename>",NULL,1,NULL},
4445     {"set_cclfile", cmd_set_cclfile," <filename>",NULL,1,NULL},
4446     {"set_cqlfile", cmd_set_cqlfile," <filename>",NULL,1,NULL},
4447     {"set_auto_reconnect", cmd_set_auto_reconnect," on|off",complete_auto_reconnect,1,NULL},
4448     {"set_auto_wait", cmd_set_auto_wait," on|off",complete_auto_reconnect,1,NULL},
4449     {"set_otherinfo", cmd_set_otherinfo,"<otherinfoinddex> <oid> <string>",NULL,0,NULL},
4450     {"sleep", cmd_sleep,"<seconds>",NULL,0,NULL},
4451     {"register_oid", cmd_register_oid,"<name> <class> <oid>",NULL,0,NULL},
4452     {"push_command", cmd_push_command,"<command>",command_generator,0,NULL},
4453     {"register_tab", cmd_register_tab,"<commandname> <tab>",command_generator,0,NULL},
4454     {"cclparse", cmd_cclparse,"<ccl find command>",NULL,0,NULL},
4455     {"list_otherinfo",cmd_list_otherinfo,"[otherinfoinddex]",NULL,0,NULL},
4456     {"list_all",cmd_list_all,"",NULL,0,NULL},
4457     {"clear_otherinfo",cmd_clear_otherinfo,"",NULL,0,NULL},
4458     {"wait_response",cmd_wait_response,"<number>",NULL,0,NULL},
4459     /* Server Admin Functions */
4460     {"adm-reindex", cmd_adm_reindex, "<database-name>",NULL,0,NULL},
4461     {"adm-truncate", cmd_adm_truncate, "('database'|'index')<object-name>",NULL,0,NULL},
4462     {"adm-create", cmd_adm_create, "",NULL,0,NULL},
4463     {"adm-drop", cmd_adm_drop, "('database'|'index')<object-name>",NULL,0,NULL},
4464     {"adm-import", cmd_adm_import, "<record-type> <dir> <pattern>",NULL,0,NULL},
4465     {"adm-refresh", cmd_adm_refresh, "",NULL,0,NULL},
4466     {"adm-commit", cmd_adm_commit, "",NULL,0,NULL},
4467     {"adm-shutdown", cmd_adm_shutdown, "",NULL,0,NULL},
4468     {"adm-startup", cmd_adm_startup, "",NULL,0,NULL},
4469     {"explain", cmd_explain, "", NULL, 0, NULL},
4470     {"options", cmd_options, "", NULL, 0, NULL},
4471     {"zversion", cmd_zversion, "", NULL, 0, NULL},
4472     {"help", cmd_help, "", NULL,0,NULL},
4473     {"init", cmd_init, "", NULL,0,NULL},
4474     {"sru", cmd_sru, "", NULL,0,NULL},
4475     {"exit", cmd_quit, "",NULL,0,NULL},
4476     {0,0,0,0,0,0}
4477 };
4478
4479 static int cmd_help (const char *line)
4480 {
4481     int i;
4482     char topic[21];
4483
4484     *topic = 0;
4485     sscanf (line, "%20s", topic);
4486
4487     if (*topic == 0)
4488         printf("Commands:\n");
4489     for (i = 0; cmd_array[i].cmd; i++)
4490         if (*topic == 0 || strcmp (topic, cmd_array[i].cmd) == 0)
4491             printf("   %s %s\n", cmd_array[i].cmd, cmd_array[i].ad);
4492     if (!strcmp(topic, "find"))
4493     {
4494         printf("RPN:\n");
4495         printf(" \"term\"                        Simple Term\n");
4496         printf(" @attr [attset] type=value op  Attribute\n");
4497         printf(" @and opl opr                  And\n");
4498         printf(" @or opl opr                   Or\n");
4499         printf(" @not opl opr                  And-Not\n");
4500         printf(" @set set                      Result set\n");
4501         printf(" @prox exl dist ord rel uc ut  Proximity. Use help prox\n");
4502         printf("\n");
4503         printf("Bib-1 attribute types\n");
4504         printf("1=Use:         ");
4505         printf("4=Title 7=ISBN 8=ISSN 30=Date 62=Abstract 1003=Author 1016=Any\n");
4506         printf("2=Relation:    ");
4507         printf("1<   2<=  3=  4>=  5>  6!=  102=Relevance\n");
4508         printf("3=Position:    ");
4509         printf("1=First in Field  2=First in subfield  3=Any position\n");
4510         printf("4=Structure:   ");
4511         printf("1=Phrase  2=Word  3=Key  4=Year  5=Date  6=WordList\n");
4512         printf("5=Truncation:  ");
4513         printf("1=Right  2=Left  3=L&R  100=No  101=#  102=Re-1  103=Re-2\n");
4514         printf("6=Completeness:");
4515         printf("1=Incomplete subfield  2=Complete subfield  3=Complete field\n");
4516     }
4517     if (!strcmp(topic, "prox"))
4518     {
4519         printf("Proximity:\n");
4520         printf(" @prox exl dist ord rel uc ut\n");
4521         printf(" exl:  exclude flag . 0=include, 1=exclude.\n");
4522         printf(" dist: distance integer.\n");
4523         printf(" ord:  order flag. 0=unordered, 1=ordered.\n");
4524         printf(" rel:  relation integer. 1<  2<=  3= 4>=  5>  6!= .\n");
4525         printf(" uc:   unit class. k=known, p=private.\n");
4526         printf(" ut:   unit type. 1=character, 2=word, 3=sentence,\n");
4527         printf("        4=paragraph, 5=section, 6=chapter, 7=document,\n");
4528         printf("        8=element, 9=subelement, 10=elementType, 11=byte.\n");
4529         printf("\nExamples:\n");
4530         printf(" Search for a and b in-order at most 3 words apart:\n");
4531         printf("  @prox 0 3 1 2 k 2 a b\n");
4532         printf(" Search for any order of a and b next to each other:\n");
4533         printf("  @prox 0 1 0 3 k 2 a b\n");
4534     }
4535     return 1;
4536 }
4537
4538 int cmd_register_tab(const char* arg)
4539 {
4540 #if HAVE_READLINE_READLINE_H
4541     char command[101], tabargument[101];
4542     int i;
4543     int num_of_tabs;
4544     const char** tabslist;
4545
4546     if (sscanf (arg, "%100s %100s", command, tabargument) < 1) {
4547         return 0;
4548     }
4549
4550     /* locate the amdn in the list */
4551     for (i = 0; cmd_array[i].cmd; i++) {
4552         if (!strncmp(cmd_array[i].cmd, command, strlen(command))) {
4553             break;
4554         }
4555     }
4556
4557     if (!cmd_array[i].cmd) {
4558         fprintf(stderr,"Unknown command %s\n",command);
4559         return 1;
4560     }
4561
4562
4563     if (!cmd_array[i].local_tabcompletes)
4564         cmd_array[i].local_tabcompletes = (const char **) calloc(1,sizeof(char**));
4565
4566     num_of_tabs=0;
4567
4568     tabslist = cmd_array[i].local_tabcompletes;
4569     for(; tabslist && *tabslist; tabslist++) {
4570         num_of_tabs++;
4571     }
4572
4573     cmd_array[i].local_tabcompletes = (const char **)
4574         realloc(cmd_array[i].local_tabcompletes,
4575                 (num_of_tabs+2)*sizeof(char**));
4576     tabslist = cmd_array[i].local_tabcompletes;
4577     tabslist[num_of_tabs] = strdup(tabargument);
4578     tabslist[num_of_tabs+1] = NULL;
4579 #endif
4580     return 1;
4581 }
4582
4583
4584 void process_cmd_line(char* line)
4585 {
4586     int i, res;
4587     char word[32], arg[10240];
4588
4589 #if HAVE_GETTIMEOFDAY
4590     gettimeofday (&tv_start, 0);
4591 #endif
4592
4593     if ((res = sscanf(line, "%31s %10239[^;]", word, arg)) <= 0)
4594     {
4595         strcpy(word, last_cmd);
4596         *arg = '\0';
4597     }
4598     else if (res == 1)
4599         *arg = 0;
4600     strcpy(last_cmd, word);
4601
4602     /* removed tailing spaces from the arg command */
4603     {
4604         char* p = arg;
4605         char* lastnonspace=NULL;
4606
4607         for(;*p; ++p) {
4608             if(!isspace(*(unsigned char *) p)) {
4609                 lastnonspace = p;
4610             }
4611         }
4612         if(lastnonspace)
4613             *(++lastnonspace) = 0;
4614     }
4615
4616     for (i = 0; cmd_array[i].cmd; i++)
4617         if (!strncmp(cmd_array[i].cmd, word, strlen(word)))
4618         {
4619             res = (*cmd_array[i].fun)(arg);
4620             break;
4621         }
4622
4623     if (!cmd_array[i].cmd) /* dump our help-screen */
4624     {
4625         printf("Unknown command: %s.\n", word);
4626         printf("Type 'help' for list of commands\n");
4627         res = 1;
4628     }
4629
4630     if(apdu_file) fflush(apdu_file);
4631
4632     if (res >= 2 && auto_wait)
4633         wait_and_handle_response(0);
4634
4635     if(apdu_file)
4636         fflush(apdu_file);
4637     if(marc_file)
4638         fflush(marc_file);
4639 }
4640
4641 static char *command_generator(const char *text, int state)
4642 {
4643 #if HAVE_READLINE_READLINE_H
4644     static int idx;
4645     if (state==0) {
4646         idx = 0;
4647     }
4648     for( ; cmd_array[idx].cmd; ++idx) {
4649         if (!strncmp(cmd_array[idx].cmd, text, strlen(text))) {
4650             ++idx;  /* skip this entry on the next run */
4651             return strdup(cmd_array[idx-1].cmd);
4652         }
4653     }
4654 #endif
4655     return NULL;
4656 }
4657
4658 #if HAVE_READLINE_READLINE_H
4659 static const char** default_completer_list = NULL;
4660
4661 static char* default_completer(const char* text, int state)
4662 {
4663     return complete_from_list(default_completer_list, text, state);
4664 }
4665 #endif
4666
4667 #if HAVE_READLINE_READLINE_H
4668
4669 /*
4670    This function only known how to complete on the first word
4671 */
4672 char **readline_completer(char *text, int start, int end)
4673 {
4674     completerFunctionType completerToUse;
4675
4676     if(start == 0) {
4677 #if HAVE_READLINE_RL_COMPLETION_MATCHES
4678         char** res = rl_completion_matches(text, command_generator);
4679 #else
4680         char** res = completion_matches(text,
4681                                         (CPFunction*)command_generator);
4682 #endif
4683         rl_attempted_completion_over = 1;
4684         return res;
4685     } else {
4686         char arg[10240],word[32];
4687         int i=0 ,res;
4688         if ((res = sscanf(rl_line_buffer, "%31s %10239[^;]", word, arg)) <= 0) {
4689             rl_attempted_completion_over = 1;
4690             return NULL;
4691         }
4692
4693         for (i = 0; cmd_array[i].cmd; i++)
4694             if (!strncmp(cmd_array[i].cmd, word, strlen(word)))
4695                 break;
4696
4697         if(!cmd_array[i].cmd)
4698             return NULL;
4699
4700         default_completer_list = cmd_array[i].local_tabcompletes;
4701
4702         completerToUse = cmd_array[i].rl_completerfunction;
4703         if (!completerToUse)
4704         { /* if command completer is not defined use the default completer */
4705             completerToUse = default_completer;
4706         }
4707         if (completerToUse) {
4708 #ifdef HAVE_READLINE_RL_COMPLETION_MATCHES
4709             char** res=
4710                 rl_completion_matches(text, completerToUse);
4711 #else
4712             char** res=
4713                 completion_matches(text, (CPFunction*)completerToUse);
4714 #endif
4715             if (!cmd_array[i].complete_filenames)
4716                 rl_attempted_completion_over = 1;
4717             return res;
4718         } else {
4719             if (!cmd_array[i].complete_filenames)
4720                 rl_attempted_completion_over = 1;
4721             return 0;
4722         }
4723     }
4724 }
4725 #endif
4726
4727 #ifndef WIN32
4728 void ctrl_c_handler(int x)
4729 {
4730     exit_client(0);
4731 }
4732 #endif
4733
4734 static void client(void)
4735 {
4736     char line[10240];
4737
4738     line[10239] = '\0';
4739
4740 #ifndef WIN32
4741     signal(SIGINT, ctrl_c_handler);
4742 #endif
4743
4744 #if HAVE_GETTIMEOFDAY
4745     gettimeofday (&tv_start, 0);
4746 #endif
4747
4748     while (1)
4749     {
4750         char *line_in = NULL;
4751 #if HAVE_READLINE_READLINE_H
4752         if (isatty(0))
4753         {
4754             line_in=readline(C_PROMPT);
4755             if (!line_in)
4756                 break;
4757 #if HAVE_READLINE_HISTORY_H
4758             if (*line_in)
4759                 add_history(line_in);
4760 #endif
4761             strncpy(line, line_in, sizeof(line)-1);
4762             free(line_in);
4763         }
4764 #endif
4765         if (!line_in)
4766         {
4767             char *end_p;
4768             printf (C_PROMPT);
4769             fflush(stdout);
4770             if (!fgets(line, sizeof(line)-1, stdin))
4771                 break;
4772             if ((end_p = strchr (line, '\n')))
4773                 *end_p = '\0';
4774         }
4775         if (isatty(0))
4776             file_history_add_line(file_history, line);
4777         process_cmd_line(line);
4778     }
4779 }
4780
4781 static void show_version(void)
4782 {
4783     char vstr[20];
4784
4785     yaz_version(vstr, 0);
4786     printf ("YAZ version: %s\n", YAZ_VERSION);
4787     if (strcmp(vstr, YAZ_VERSION))
4788         printf ("YAZ DLL/SO: %s\n", vstr);
4789     exit(0);
4790 }
4791
4792 int main(int argc, char **argv)
4793 {
4794     char *prog = *argv;
4795     char *open_command = 0;
4796     char *auth_command = 0;
4797     char *arg;
4798     int ret;
4799
4800 #if HAVE_LOCALE_H
4801     if (!setlocale(LC_CTYPE, ""))
4802         fprintf (stderr, "setlocale failed\n");
4803 #endif
4804 #if HAVE_LANGINFO_H
4805 #ifdef CODESET
4806     codeset = nl_langinfo(CODESET);
4807 #endif
4808 #endif
4809     if (codeset)
4810         outputCharset = xstrdup(codeset);
4811
4812     ODR_MASK_SET(&z3950_options, Z_Options_search);
4813     ODR_MASK_SET(&z3950_options, Z_Options_present);
4814     ODR_MASK_SET(&z3950_options, Z_Options_namedResultSets);
4815     ODR_MASK_SET(&z3950_options, Z_Options_triggerResourceCtrl);
4816     ODR_MASK_SET(&z3950_options, Z_Options_scan);
4817     ODR_MASK_SET(&z3950_options, Z_Options_sort);
4818     ODR_MASK_SET(&z3950_options, Z_Options_extendedServices);
4819     ODR_MASK_SET(&z3950_options, Z_Options_delSet);
4820     ODR_MASK_SET(&z3950_options, Z_Options_negotiationModel);
4821
4822     while ((ret = options("k:c:q:a:b:m:v:p:u:t:Vxd:", argv, argc, &arg)) != -2)
4823     {
4824         switch (ret)
4825         {
4826         case 0:
4827             if (!open_command)
4828             {
4829                 open_command = (char *) xmalloc (strlen(arg)+6);
4830                 strcpy (open_command, "open ");
4831                 strcat (open_command, arg);
4832             }
4833             else
4834             {
4835                 fprintf(stderr, "%s: Specify at most one server address\n",
4836                         prog);
4837                 exit(1);
4838             }
4839             break;
4840         case 'd':
4841             dump_file_prefix = arg;
4842             break;
4843         case 'k':
4844             kilobytes = atoi(arg);
4845             break;
4846         case 'm':
4847             if (!(marc_file = fopen (arg, "a")))
4848             {
4849                 perror (arg);
4850                 exit (1);
4851             }
4852             break;
4853         case 't':
4854             outputCharset = xstrdup(arg);
4855             break;
4856         case 'c':
4857             strncpy (ccl_fields, arg, sizeof(ccl_fields)-1);
4858             ccl_fields[sizeof(ccl_fields)-1] = '\0';
4859             break;
4860         case 'q':
4861             strncpy (cql_fields, arg, sizeof(cql_fields)-1);
4862             cql_fields[sizeof(cql_fields)-1] = '\0';
4863             break;
4864         case 'b':
4865             if (!strcmp(arg, "-"))
4866                 ber_file=stderr;
4867             else
4868                 ber_file=fopen(arg, "a");
4869             break;
4870         case 'a':
4871             if (!strcmp(arg, "-"))
4872                 apdu_file=stderr;
4873             else
4874                 apdu_file=fopen(arg, "a");
4875             break;
4876         case 'x':
4877             hex_dump = 1;
4878             break;
4879         case 'p':
4880             yazProxy = xstrdup(arg);
4881             break;
4882         case 'u':
4883             if (!auth_command)
4884             {
4885                 auth_command = (char *) xmalloc (strlen(arg)+6);
4886                 strcpy (auth_command, "auth ");
4887                 strcat (auth_command, arg);
4888             }
4889             break;
4890         case 'v':
4891             yaz_log_init(yaz_log_mask_str(arg), "", 0);
4892             break;
4893         case 'V':
4894             show_version();
4895             break;
4896         default:
4897             fprintf (stderr, "Usage: %s "
4898                      " [-a <apdulog>]"
4899                      " [-b berdump]"
4900                      " [-d dump]\n"
4901                      " [-c cclfields]"
4902                      " [-k size]"
4903                      " [-m <marclog>]\n"
4904                      " [-p <proxy-addr>]"
4905                      " [-q cqlfields]"
4906                      " [-u <auth>]"
4907                      " [-V]"
4908                      " [<server-addr>]\n",
4909                      prog);
4910             exit (1);
4911         }
4912     }
4913     initialize();
4914     if (auth_command)
4915     {
4916 #ifdef HAVE_GETTIMEOFDAY
4917         gettimeofday (&tv_start, 0);
4918 #endif
4919         process_cmd_line (auth_command);
4920 #if HAVE_READLINE_HISTORY_H
4921         add_history(auth_command);
4922 #endif
4923         xfree(auth_command);
4924     }
4925     if (open_command)
4926     {
4927 #ifdef HAVE_GETTIMEOFDAY
4928         gettimeofday (&tv_start, 0);
4929 #endif
4930         process_cmd_line (open_command);
4931 #if HAVE_READLINE_HISTORY_H
4932         add_history(open_command);
4933 #endif
4934         xfree(open_command);
4935     }
4936     client();
4937     exit_client(0);
4938     return 0;
4939 }
4940 /*
4941  * Local variables:
4942  * c-basic-offset: 4
4943  * indent-tabs-mode: nil
4944  * End:
4945  * vim: shiftwidth=4 tabstop=8 expandtab
4946  */
4947