src/yaz-my-client.cpp

   1 /*
   2  * Copyright (c) 1998-2004, Index Data.
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: yaz-my-client.cpp,v 1.18 2005-01-17 09:55:58 adam Exp $
   6  */
   7
   8 #include <stdlib.h>
   9 #include <yaz/log.h>
  10 #include <yaz/options.h>
  11 #include <yaz/diagbib1.h>
  12 #include <yaz/marcdisp.h>
  13 #include <yaz++/ir-assoc.h>
  14 #include <yaz++/pdu-assoc.h>
  15 #include <yaz++/socket-manager.h>
  16
  17 extern "C" {
  18 #if HAVE_READLINE_READLINE_H
  19 #include <readline/readline.h>
  20 #endif
  21 #if HAVE_READLINE_HISTORY_H
  22 #include <readline/history.h>
  23 #endif
  24 }
  25
  26 class YAZ_EXPORT MyClient : public Yaz_IR_Assoc {
  27 private:
  28     int m_interactive_flag;
  29     char m_thisCommand[1024];
  30     char m_lastCommand[1024];
  31     int m_setOffset;
  32     Yaz_SocketManager *m_socketManager;
  33 public:
  34     MyClient(IYaz_PDU_Observable *the_PDU_Observable,
  35              Yaz_SocketManager *the_SocketManager);
  36     IYaz_PDU_Observer *sessionNotify(
  37         IYaz_PDU_Observable *the_PDU_Observable, int fd);
  38     int args(Yaz_SocketManager *socketManager, int argc, char **argv);
  39     int interactive(Yaz_SocketManager *socketManager);
  40     int wait();
  41     void recv_initResponse(Z_InitResponse *initResponse);
  42     void recv_searchResponse(Z_SearchResponse *searchResponse);
  43     void recv_presentResponse(Z_PresentResponse *presentResponse);
  44     void recv_records (Z_Records *records);
  45     void recv_diagrecs(Z_DiagRec **pp, int num);
  46     void recv_namePlusRecord (Z_NamePlusRecord *zpr, int offset);
  47     void recv_record(Z_DatabaseRecord *record, int offset,
  48                      const char *databaseName);
  49     void recv_textRecord(int type, const char *buf, size_t len);
  50     void recv_genericRecord(Z_GenericRecord *r);
  51     void display_genericRecord(Z_GenericRecord *r, int level);
  52     void display_variant(Z_Variant *v, int level);
  53     void connectNotify();
  54     void failNotify();
  55     void timeoutNotify();
  56     char *get_cookie (Z_OtherInformation **oi);
  57     int processCommand(const char *cmd);
  58     const char *MyClient::getCommand();
  59     int cmd_open(char *host);
  60     int cmd_connect(char *host);
  61     int cmd_quit(char *args);
  62     int cmd_close(char *args);
  63     int cmd_find(char *args);
  64     int cmd_show(char *args);
  65     int cmd_cookie(char *args);
  66     int cmd_init(char *args);
  67     int cmd_format(char *args);
  68     int cmd_proxy(char *args);
  69 };
  70
  71
  72 void MyClient::connectNotify()
  73 {
  74     printf ("Connection accepted by target\n");
  75     set_lastReceived(-1);
  76 }
  77
  78 void MyClient::timeoutNotify()
  79 {
  80     printf ("Connection timeout\n");
  81     close();
  82 }
  83
  84 void MyClient::failNotify()
  85 {
  86     printf ("Connection closed by target\n");
  87     set_lastReceived(-1);
  88 }
  89
  90 IYaz_PDU_Observer *MyClient::sessionNotify(
  91     IYaz_PDU_Observable *the_PDU_Observable, int fd)
  92 {
  93     return new MyClient(the_PDU_Observable, m_socketManager);
  94 }
  95
  96 MyClient::MyClient(IYaz_PDU_Observable *the_PDU_Observable,
  97                    Yaz_SocketManager *the_socketManager) :
  98     Yaz_IR_Assoc (the_PDU_Observable)
  99 {
 100     m_setOffset = 1;
 101     m_interactive_flag = 1;
 102     m_thisCommand[0] = '\0';
 103     m_lastCommand[0] = '\0';
 104     m_socketManager = the_socketManager;
 105 }
 106
 107 void usage(char *prog)
 108 {
 109     fprintf (stderr, "%s: [-v log] [-c cookie] [-p proxy] [zurl]\n", prog);
 110     exit (1);
 111 }
 112
 113 char *MyClient::get_cookie(Z_OtherInformation **otherInfo)
 114 {
 115     int oid[OID_SIZE];
 116     Z_OtherInformationUnit *oi;
 117     struct oident ent;
 118     ent.proto = PROTO_Z3950;
 119     ent.oclass = CLASS_USERINFO;
 120     ent.value = (oid_value) VAL_COOKIE;
 121
 122     if (oid_ent_to_oid (&ent, oid) &&
 123         (oi = update_otherInformation(otherInfo, 0, oid, 1, 1)) &&
 124         oi->which == Z_OtherInfo_characterInfo)
 125         return oi->information.characterInfo;
 126     return 0;
 127 }
 128
 129 void MyClient::recv_initResponse(Z_InitResponse *initResponse)
 130 {
 131     printf ("Got InitResponse. Status ");
 132     if (*initResponse->result)
 133     {
 134         printf ("Ok\n");
 135
 136         const char *p = get_cookie (&initResponse->otherInfo);
 137         if (p)
 138         {
 139             printf ("cookie = %s\n", p);
 140             set_cookie(p);
 141         }
 142     }
 143     else
 144         printf ("Fail\n");
 145 }
 146
 147 void MyClient::recv_diagrecs(Z_DiagRec **pp, int num)
 148 {
 149     int i;
 150     oident *ent;
 151     Z_DefaultDiagFormat *r;
 152
 153     printf("Diagnostic message(s) from database:\n");
 154     for (i = 0; i<num; i++)
 155     {
 156         Z_DiagRec *p = pp[i];
 157         if (p->which != Z_DiagRec_defaultFormat)
 158         {
 159             printf("Diagnostic record not in default format.\n");
 160             return;
 161         }
 162         else
 163             r = p->u.defaultFormat;
 164         if (!(ent = oid_getentbyoid(r->diagnosticSetId)) ||
 165             ent->oclass != CLASS_DIAGSET || ent->value != VAL_BIB1)
 166             printf("Missing or unknown diagset\n");
 167         printf("    [%d] %s", *r->condition, diagbib1_str(*r->condition));
 168 #ifdef ASN_COMPILED
 169         switch (r->which)
 170         {
 171         case Z_DefaultDiagFormat_v2Addinfo:
 172             printf (" -- v2 addinfo '%s'\n", r->u.v2Addinfo);
 173             break;
 174         case Z_DefaultDiagFormat_v3Addinfo:
 175             printf (" -- v3 addinfo '%s'\n", r->u.v3Addinfo);
 176             break;
 177         }
 178 #else
 179         if (r->addinfo && *r->addinfo)
 180             printf(" -- '%s'\n", r->addinfo);
 181         else
 182             printf("\n");
 183 #endif
 184     }
 185 }
 186
 187 void MyClient::recv_textRecord(int type, const char *buf, size_t len)
 188 {
 189     fwrite (buf, 1, len, stdout);
 190     fputc ('\n', stdout);
 191 }
 192
 193 void MyClient::display_variant(Z_Variant *v, int level)
 194 {
 195     int i;
 196
 197     for (i = 0; i < v->num_triples; i++)
 198     {
 199         printf("%*sclass=%d,type=%d", level * 4, "", *v->triples[i]->zclass,
 200             *v->triples[i]->type);
 201         if (v->triples[i]->which == Z_Triple_internationalString)
 202             printf(",value=%s\n", v->triples[i]->value.internationalString);
 203         else
 204             printf("\n");
 205     }
 206 }
 207
 208 void MyClient::display_genericRecord(Z_GenericRecord *r, int level)
 209 {
 210     int i;
 211
 212     if (!r)
 213         return;
 214     for (i = 0; i < r->num_elements; i++)
 215     {
 216         Z_TaggedElement *t;
 217
 218         printf("%*s", level * 4, "");
 219         t = r->elements[i];
 220         printf("(");
 221         if (t->tagType)
 222             printf("%d,", *t->tagType);
 223         else
 224             printf("?,");
 225         if (t->tagValue->which == Z_StringOrNumeric_numeric)
 226             printf("%d) ", *t->tagValue->u.numeric);
 227         else
 228             printf("%s) ", t->tagValue->u.string);
 229         if (t->content->which == Z_ElementData_subtree)
 230         {
 231             printf("\n");
 232             display_genericRecord(t->content->u.subtree, level+1);
 233         }
 234         else if (t->content->which == Z_ElementData_string)
 235             printf("%s\n", t->content->u.string);
 236         else if (t->content->which == Z_ElementData_numeric)
 237             printf("%d\n", *t->content->u.numeric);
 238         else if (t->content->which == Z_ElementData_oid)
 239         {
 240             int *ip = t->content->u.oid;
 241             oident *oent;
 242
 243             if ((oent = oid_getentbyoid(t->content->u.oid)))
 244                 printf("OID: %s\n", oent->desc);
 245             else
 246             {
 247                 printf("{");
 248                 while (ip && *ip >= 0)
 249                     printf(" %d", *(ip++));
 250                 printf(" }\n");
 251             }
 252         }
 253         else if (t->content->which == Z_ElementData_noDataRequested)
 254             printf("[No data requested]\n");
 255         else if (t->content->which == Z_ElementData_elementEmpty)
 256             printf("[Element empty]\n");
 257         else if (t->content->which == Z_ElementData_elementNotThere)
 258             printf("[Element not there]\n");
 259         else
 260             printf("??????\n");
 261         if (t->appliedVariant)
 262             display_variant(t->appliedVariant, level+1);
 263         if (t->metaData && t->metaData->supportedVariants)
 264         {
 265             int c;
 266
 267             printf("%*s---- variant list\n", (level+1)*4, "");
 268             for (c = 0; c < t->metaData->num_supportedVariants; c++)
 269             {
 270                 printf("%*svariant #%d\n", (level+1)*4, "", c);
 271                 display_variant(t->metaData->supportedVariants[c], level + 2);
 272             }
 273         }
 274     }
 275 }
 276
 277 void MyClient::recv_genericRecord(Z_GenericRecord *r)
 278 {
 279     display_genericRecord(r, 0);
 280 }
 281
 282 void MyClient::recv_record(Z_DatabaseRecord *record, int offset,
 283                            const char *databaseName)
 284 {
 285     Z_External *r = (Z_External*) record;
 286     oident *ent = oid_getentbyoid(r->direct_reference);
 287
 288     /*
 289      * Tell the user what we got.
 290      */
 291     if (r->direct_reference)
 292     {
 293         printf("Record type: ");
 294         if (ent)
 295             printf("%s\n", ent->desc);
 296     }
 297     /* Check if this is a known, ASN.1 type tucked away in an octet string */
 298     Z_ext_typeent *etype = z_ext_getentbyref(ent->value);
 299     if (ent && (r->which == Z_External_octet || r->which == Z_External_single)
 300         && (etype = z_ext_getentbyref(ent->value)))
 301
 302     {
 303         void *rr;
 304         /*
 305          * Call the given decoder to process the record.
 306          */
 307         odr_setbuf(odr_decode(), (char*)record->u.octet_aligned->buf,
 308                    record->u.octet_aligned->len, 0);
 309         if (!(*etype->fun)(odr_decode(), (char **)&rr, 0, 0))
 310         {
 311             odr_perror(odr_decode(), "Decoding constructed record.");
 312             fprintf(stderr, "[Near %d]\n", odr_offset(odr_decode()));
 313             fprintf(stderr, "Packet dump:\n---------\n");
 314             odr_dumpBER(stderr, (char*)record->u.octet_aligned->buf,
 315                         record->u.octet_aligned->len);
 316             fprintf(stderr, "---------\n");
 317         }
 318         if (etype->what == Z_External_sutrs)
 319         {
 320             Z_SUTRS *sutrs = (Z_SUTRS *) rr;
 321             recv_textRecord ((int) VAL_SUTRS, (const char *) sutrs->buf,
 322                              (size_t) sutrs->len);
 323         }
 324         return;
 325     }
 326     if (r->which == Z_External_octet && record->u.octet_aligned->len)
 327     {
 328         switch (ent->value)
 329         {
 330         case VAL_ISO2709:
 331         case VAL_UNIMARC:
 332         case VAL_INTERMARC:
 333         case VAL_USMARC:
 334         case VAL_UKMARC:
 335         case VAL_NORMARC:
 336         case VAL_LIBRISMARC:
 337         case VAL_DANMARC:
 338         case VAL_FINMARC:
 339         case VAL_MAB:
 340         case VAL_CANMARC:
 341         case VAL_SBN:
 342         case VAL_PICAMARC:
 343         case VAL_AUSMARC:
 344         case VAL_IBERMARC:
 345         case VAL_CATMARC:
 346         case VAL_MALMARC:
 347         case VAL_JPMARC:
 348         case VAL_SWEMARC:
 349         case VAL_SIGLEMARC:
 350         case VAL_ISDSMARC:
 351         case VAL_RUSMARC:
 352             marc_display((char*) record->u.octet_aligned->buf,0);
 353             break;
 354         default:
 355             recv_textRecord((int) ent->value,
 356                             (const char *) record->u.octet_aligned->buf,
 357                             (size_t) record->u.octet_aligned->len);
 358         }
 359     }
 360     else if (ent && ent->value == VAL_SUTRS && r->which == Z_External_sutrs)
 361         recv_textRecord((int) VAL_SUTRS, (const char *) r->u.sutrs->buf,
 362                         (size_t) r->u.sutrs->len);
 363     else if (ent && ent->value == VAL_GRS1 && r->which == Z_External_grs1)
 364         recv_genericRecord(r->u.grs1);
 365     else
 366     {
 367         printf("Unknown record representation.\n");
 368         if (!z_External(odr_print(), &r, 0, 0))
 369         {
 370             odr_perror(odr_print(), "Printing external");
 371             odr_reset(odr_print());
 372         }
 373     }
 374 }
 375
 376 void MyClient::recv_namePlusRecord (Z_NamePlusRecord *zpr, int offset)
 377 {
 378     if (zpr->databaseName)
 379         printf("[%s]", zpr->databaseName);
 380     if (zpr->which == Z_NamePlusRecord_surrogateDiagnostic)
 381         recv_diagrecs(&zpr->u.surrogateDiagnostic, 1);
 382     else
 383         recv_record(zpr->u.databaseRecord, offset, zpr->databaseName);
 384 }
 385
 386 void MyClient::recv_records (Z_Records *records)
 387 {
 388 #ifdef ASN_COMPILED
 389     Z_DiagRec dr, *dr_p = &dr;
 390 #endif
 391     if (!records)
 392         return;
 393     int i;
 394     switch (records->which)
 395     {
 396     case Z_Records_DBOSD:
 397         for (i = 0; i < records->u.databaseOrSurDiagnostics->num_records; i++)
 398             recv_namePlusRecord(records->u.databaseOrSurDiagnostics->
 399                                 records[i], i + m_setOffset);
 400         m_setOffset += records->u.databaseOrSurDiagnostics->num_records;
 401         break;
 402     case Z_Records_NSD:
 403 #ifdef ASN_COMPILED
 404         dr.which = Z_DiagRec_defaultFormat;
 405         dr.u.defaultFormat = records->u.nonSurrogateDiagnostic;
 406         recv_diagrecs (&dr_p, 1);
 407 #else
 408         recv_diagrecs (&records->u.nonSurrogateDiagnostic, 1);
 409 #endif
 410         break;
 411     case Z_Records_multipleNSD:
 412         recv_diagrecs (records->u.multipleNonSurDiagnostics->diagRecs,
 413                        records->u.multipleNonSurDiagnostics->num_diagRecs);
 414         break;
 415     }
 416 }
 417
 418 void MyClient::recv_searchResponse(Z_SearchResponse *searchResponse)
 419 {
 420     printf ("Got SearchResponse. Status ");
 421     if (!*searchResponse->searchStatus)
 422     {
 423         printf ("Fail\n");
 424     }
 425     else
 426     {
 427         printf ("Ok\n");
 428         printf ("Hits: %d\n", *searchResponse->resultCount);
 429     }
 430     recv_records (searchResponse->records);
 431 }
 432
 433 void MyClient::recv_presentResponse(Z_PresentResponse *presentResponse)
 434 {
 435     printf ("Got PresentResponse\n");
 436     recv_records (presentResponse->records);
 437 }
 438
 439 int MyClient::wait()
 440 {
 441     set_lastReceived(0);
 442     while (m_socketManager->processEvent() > 0)
 443     {
 444         if (get_lastReceived())
 445             return 1;
 446     }
 447     return 0;
 448 }
 449
 450
 451 #define C_PROMPT "Z>"
 452
 453 int MyClient::cmd_connect(char *host)
 454 {
 455     client (host);
 456     timeout (10);
 457     wait ();
 458     timeout (-1);
 459     return 1;
 460 }
 461
 462 int MyClient::cmd_open(char *host)
 463 {
 464     client (host);
 465     timeout (10);
 466     wait ();
 467     timeout (-1);
 468     send_initRequest();
 469     wait ();
 470     return 1;
 471 }
 472
 473 int MyClient::cmd_init(char *args)
 474 {
 475     if (send_initRequest() >= 0)
 476         wait();
 477     else
 478         close();
 479     return 1;
 480 }
 481
 482 int MyClient::cmd_quit(char *args)
 483 {
 484     return 0;
 485 }
 486
 487 int MyClient::cmd_close(char *args)
 488 {
 489     close();
 490     return 1;
 491 }
 492
 493 int MyClient::cmd_find(char *args)
 494 {
 495     Yaz_Z_Query query;
 496
 497     if (query.set_rpn(args) <= 0)
 498     {
 499         printf ("Bad RPN query\n");
 500         return 1;
 501     }
 502     if (send_searchRequest(&query) >= 0)
 503         wait();
 504     else
 505         printf ("Not connected\n");
 506     return 1;
 507 }
 508
 509 int MyClient::cmd_show(char *args)
 510 {
 511     int start = m_setOffset, number = 1;
 512
 513     sscanf (args, "%d %d", &start, &number);
 514     m_setOffset = start;
 515     if (send_presentRequest(start, number) >= 0)
 516         wait();
 517     else
 518         printf ("Not connected\n");
 519     return 1;
 520 }
 521
 522 int MyClient::cmd_cookie(char *args)
 523 {
 524     set_cookie(*args ? args : 0);
 525     return 1;
 526 }
 527
 528 int MyClient::cmd_format(char *args)
 529 {
 530     set_preferredRecordSyntax(args);
 531     return 1;
 532 }
 533
 534 int MyClient::cmd_proxy(char *args)
 535 {
 536     set_proxy(args);
 537     return 1;
 538 }
 539
 540 int MyClient::processCommand(const char *commandLine)
 541 {
 542     char cmdStr[1024], cmdArgs[1024];
 543     cmdArgs[0] = '\0';
 544     cmdStr[0] = '\0';
 545     static struct {
 546         const char *cmd;
 547         int (MyClient::*fun)(char *arg);
 548         const char *ad;
 549     } cmd[] = {
 550         {"open", &MyClient::cmd_open, "<host>[':'<port>][/<database>]"},
 551         {"connect", &MyClient::cmd_connect, "<host>[':'<port>][/<database>]"},
 552         {"quit", &MyClient::cmd_quit, ""},
 553         {"close", &MyClient::cmd_close, ""},
 554         {"find", &MyClient::cmd_find, "<query>"},
 555         {"show", &MyClient::cmd_show, "[<start> [<number>]]"},
 556         {"cookie", &MyClient::cmd_cookie, "<cookie>"},
 557         {"init", &MyClient::cmd_init, ""},
 558         {"format", &MyClient::cmd_format, "<record-syntax>"},
 559         {"proxy", &MyClient::cmd_proxy, "<host>:[':'<port>]"},
 560         {0,0,0}
 561     };
 562
 563     if (sscanf(commandLine, "%s %[^;]", cmdStr, cmdArgs) < 1)
 564         return 1;
 565     int i;
 566     for (i = 0; cmd[i].cmd; i++)
 567         if (!strncmp(cmd[i].cmd, cmdStr, strlen(cmdStr)))
 568             break;
 569
 570     int res = 1;
 571     if (cmd[i].cmd) // Invoke command handler
 572         res = (this->*cmd[i].fun)(cmdArgs);
 573     else            // Dump help screen
 574     {
 575         printf("Unknown command: %s.\n", cmdStr);
 576         printf("Currently recognized commands:\n");
 577         for (i = 0; cmd[i].cmd; i++)
 578             printf("   %s %s\n", cmd[i].cmd, cmd[i].ad);
 579     }
 580     return res;
 581 }
 582
 583 const char *MyClient::getCommand()
 584 {
 585 #if HAVE_READLINE_READLINE_H
 586     // Read using GNU readline
 587     char *line_in;
 588     line_in=readline(C_PROMPT);
 589     if (!line_in)
 590         return 0;
 591 #if HAVE_READLINE_HISTORY_H
 592     if (*line_in)
 593         add_history(line_in);
 594 #endif
 595     strncpy(m_thisCommand,line_in, 1023);
 596     m_thisCommand[1023] = '\0';
 597     free (line_in);
 598 #else
 599     // Read using fgets(3)
 600     printf (C_PROMPT);
 601     fflush(stdout);
 602     if (!fgets(m_thisCommand, 1023, stdin))
 603         return 0;
 604 #endif
 605     // Remove trailing whitespace
 606     char *cp = m_thisCommand + strlen(m_thisCommand);
 607     while (cp != m_thisCommand && strchr("\t \n", cp[-1]))
 608         cp--;
 609     *cp = '\0';
 610     cp = m_thisCommand;
 611     // Remove leading spaces...
 612     while (*cp && strchr ("\t \n", *cp))
 613         cp++;
 614     // Save command if non-empty
 615     if (*cp != '\0')
 616         strcpy (m_lastCommand, cp);
 617     return m_lastCommand;
 618 }
 619
 620 int MyClient::interactive(Yaz_SocketManager *socketManager)
 621 {
 622     const char *cmd;
 623     if (!m_interactive_flag)
 624         return 0;
 625     while ((cmd = getCommand()))
 626     {
 627         if (!processCommand(cmd))
 628             break;
 629     }
 630     return 0;
 631 }
 632
 633 int MyClient::args(Yaz_SocketManager *socketManager, int argc, char **argv)
 634 {
 635     char *host = 0;
 636     char *proxy = 0;
 637     char *arg;
 638     char *prog = argv[0];
 639     int ret;
 640
 641     while ((ret = options("c:p:v:q", argv, argc, &arg)) != -2)
 642     {
 643         switch (ret)
 644         {
 645         case 0:
 646             if (host)
 647             {
 648                 usage(prog);
 649                 return 1;
 650             }
 651             host = arg;
 652             break;
 653         case 'p':
 654             if (proxy)
 655             {
 656                 usage(prog);
 657                 return 1;
 658             }
 659             set_proxy(arg);
 660             break;
 661         case 'c':
 662             set_cookie(arg);
 663             break;
 664         case 'v':
 665             yaz_log_init_level (yaz_log_mask_str(arg));
 666             break;
 667         case 'q':
 668             m_interactive_flag = 0;
 669             break;
 670         default:
 671             usage(prog);
 672             return 1;
 673         }
 674     }
 675     if (host)
 676     {
 677         client (host);
 678         timeout (10);
 679         wait ();
 680         timeout (-1);
 681         send_initRequest();
 682         wait ();
 683     }
 684     return 0;
 685 }
 686
 687 int main(int argc, char **argv)
 688 {
 689     Yaz_SocketManager mySocketManager;
 690     Yaz_PDU_Assoc *some = new Yaz_PDU_Assoc(&mySocketManager);
 691
 692     MyClient z(some, &mySocketManager);
 693
 694     if (z.args(&mySocketManager, argc, argv))
 695         exit (1);
 696     if (z.interactive(&mySocketManager))
 697         exit (1);
 698     return 0;
 699 }