src/yaz-my-client.cpp

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