client/client.c

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