src/gduutil.cpp

   1 /* $Id: gduutil.cpp,v 1.20 2007-04-13 09:57:51 adam Exp $
   2    Copyright (c) 2005-2007, Index Data.
   3
   4    See the LICENSE file for details
   5 */
   6
   7 #include "gduutil.hpp"
   8 #include "util.hpp"
   9
  10 #include <yaz/wrbuf.h>
  11 #include <yaz/oid_db.h>
  12 #include <yaz/querytowrbuf.h>
  13
  14 #include <iostream>
  15 #include <list>
  16
  17 namespace mp = metaproxy_1;
  18
  19 // Doxygen doesn't like mp::gdu, so we use this instead
  20 namespace mp_util = metaproxy_1::util;
  21
  22
  23
  24
  25 std::ostream& std::operator<<(std::ostream& os,  Z_GDU& zgdu)
  26 {
  27     if (zgdu.which == Z_GDU_Z3950)
  28     {
  29         os << "Z3950";
  30         if (zgdu.u.z3950)
  31             os << *(zgdu.u.z3950);
  32     }
  33     else if (zgdu.which == Z_GDU_HTTP_Request)
  34     {
  35         os << "HTTP_Request";
  36         if (zgdu.u.HTTP_Request)
  37             os << " " << *(zgdu.u.HTTP_Request);
  38     }
  39     else if (zgdu.which == Z_GDU_HTTP_Response)
  40     {
  41         os << "HTTP_Response";
  42         if (zgdu.u.HTTP_Response)
  43             os << " " << *(zgdu.u.HTTP_Response);
  44     }
  45     else
  46         os << "Z_GDU";
  47     return os;
  48 }
  49
  50 std::ostream& std::operator<<(std::ostream& os, Z_HTTP_Request& httpreq)
  51 {
  52     os << httpreq.method << " ";
  53     os << httpreq.path;
  54     return os;
  55 }
  56
  57
  58 std::ostream& std::operator<<(std::ostream& os, Z_HTTP_Response& httpres)
  59 {
  60     os << httpres.code << " ";
  61     os << httpres.content_len;
  62     return os;
  63 }
  64
  65 std::ostream& std::operator<<(std::ostream& os, Z_Records & rs)
  66 {
  67     switch(rs.which) {
  68     case Z_Records_DBOSD :
  69         break;
  70     case Z_Records_NSD:
  71         if (rs.u.nonSurrogateDiagnostic)
  72             os << *(rs.u.nonSurrogateDiagnostic);
  73         break;
  74     case Z_Records_multipleNSD:
  75         os << "Z_Records_multipleNSD";
  76         //os << *(rs.u.multipleNonSurDiagnostics);
  77         break;
  78     default:
  79         os << "Z_Records" ;
  80     }
  81
  82     return os;
  83 }
  84
  85 std::ostream& std::operator<<(std::ostream& os, Z_DiagRec& dr)
  86 {
  87     switch(dr.which) {
  88     case Z_DiagRec_defaultFormat:
  89         if (dr.u.defaultFormat)
  90             os << *(dr.u.defaultFormat);
  91         break;
  92     case Z_DiagRec_externallyDefined :
  93         os << "Z_DiagRec_externallyDefined";
  94         break;
  95     default:
  96         os << "Z_DiagRec" ;
  97     }
  98
  99     return os;
 100 }
 101
 102 std::ostream& std::operator<<(std::ostream& os, Z_DefaultDiagFormat& ddf)
 103 {
 104     if (ddf.condition)
 105         os << *(ddf.condition) << " ";
 106
 107     switch(ddf.which) {
 108     case Z_DefaultDiagFormat_v2Addinfo:
 109         os << ddf.u.v2Addinfo;
 110         break;
 111     case Z_DefaultDiagFormat_v3Addinfo:
 112         os << ddf.u.v3Addinfo;
 113         break;
 114     default:
 115         os << "Z_DefaultDiagFormat" ;
 116     }
 117
 118     return os;
 119 }
 120
 121 std::ostream& std::operator<<(std::ostream& os,  Z_APDU& zapdu)
 122 {
 123     switch(zapdu.which) {
 124
 125     case Z_APDU_initRequest:
 126         os << " " << "initRequest" << " ";
 127
 128         {
 129             Z_InitRequest *ir
 130                 = zapdu.u.initRequest;
 131
 132             Z_IdAuthentication *a = ir->idAuthentication;
 133             if (a && a->which == Z_IdAuthentication_idPass
 134                 &&  a->u.idPass->userId)
 135                 os << a->u.idPass->userId << " ";
 136             //<< ":" << a->u.idPass->groupId << " ";
 137             else
 138                 os << "-" << " ";
 139
 140             std::list<std::string> vhosts;
 141             mp::util::get_vhost_otherinfo(ir->otherInfo, vhosts);
 142             if (vhosts.size()){
 143                 copy(vhosts.begin(), vhosts.end(),
 144                      ostream_iterator<string>(os, " "));
 145             }
 146                 else
 147                     os << "-" << " " ;
 148
 149             if (ir->implementationId)
 150                 os << (ir->implementationId) << " ";
 151             //<< ir->referenceId << " "
 152             if (ir->implementationName)
 153                 os<< (ir->implementationName) << " ";
 154             if (ir->implementationVersion)
 155                 os << (ir->implementationVersion) << " ";
 156         }
 157         break;
 158     case Z_APDU_initResponse:
 159         os << " " << "initResponse" << " ";
 160         {
 161             Z_InitResponse *ir
 162                 = zapdu.u.initResponse;
 163             if (ir->result && *(ir->result)){
 164                 os << "OK" << " ";
 165                 if (ir->implementationId)
 166                      os << (ir->implementationId) << " ";
 167                     //<< ir->referenceId << " "
 168                 if (ir->implementationName)
 169                       os<< (ir->implementationName) << " ";
 170                 if (ir->implementationVersion)
 171                      os << (ir->implementationVersion) << " ";
 172             }
 173             else
 174                 os << "DIAG";
 175         }
 176         break;
 177     case Z_APDU_searchRequest:
 178         os << " " << "searchRequest" << " ";
 179         {
 180             Z_SearchRequest *sr
 181                 = zapdu.u.searchRequest;
 182
 183             for (int i = 0; i < sr->num_databaseNames; i++)
 184             {
 185                 os << sr->databaseNames[i];
 186                 if (i+1 ==  sr->num_databaseNames)
 187                     os << " ";
 188                 else
 189                     os << "+";
 190             }
 191
 192             WRBUF wr = wrbuf_alloc();
 193             yaz_query_to_wrbuf(wr, sr->query);
 194             os << wrbuf_cstr(wr);
 195             wrbuf_destroy(wr);
 196         }
 197         break;
 198     case Z_APDU_searchResponse:
 199         os << " " << "searchResponse" << " ";
 200         {
 201             Z_SearchResponse *sr
 202                 = zapdu.u.searchResponse;
 203             if (sr->searchStatus && *(sr->searchStatus))
 204             {
 205                 os << "OK";
 206                 if (sr->resultCount)
 207                     os << " " << *(sr->resultCount);
 208                 else
 209                     os << " -";
 210                 //<< sr->referenceId << " "
 211                 if (sr->numberOfRecordsReturned)
 212                     os << " " << *(sr->numberOfRecordsReturned);
 213                 else
 214                     os << " -";
 215                 if (sr->nextResultSetPosition)
 216                     os << " " << *(sr->nextResultSetPosition);
 217                 else
 218                     os << " -";
 219             }
 220             else
 221                 if (sr->records)
 222                     os << "DIAG " << *(sr->records);
 223                 else
 224                     os << "ERROR";
 225         }
 226         break;
 227     case Z_APDU_presentRequest:
 228         os << " " << "presentRequest";
 229         {
 230             Z_PresentRequest *pr = zapdu.u.presentRequest;
 231             if (pr->resultSetId)
 232                 os << " " << (pr->resultSetId);
 233             else
 234                 os << " -";
 235             //<< pr->referenceId << " "
 236             if (pr->resultSetStartPoint)
 237                 os << " " << *(pr->resultSetStartPoint);
 238             else
 239                 os << " -";
 240             if (pr->numberOfRecordsRequested)
 241                 os << " " << *(pr->numberOfRecordsRequested);
 242             else
 243                 os << " -";
 244             if (pr->preferredRecordSyntax)
 245             {
 246                 char oid_name_str[OID_STR_MAX];
 247                 const char *oid_name = yaz_oid_to_string_buf(
 248                     pr->preferredRecordSyntax, 0, oid_name_str);
 249
 250                 os << " " << oid_name;
 251             }
 252             else
 253                 os << " -";
 254             const char * msg = 0;
 255             if (pr->recordComposition
 256                 && (msg = mp_util::record_composition_to_esn(pr->recordComposition)))
 257                 os << " " << msg;
 258             else
 259                 os << " -";
 260         }
 261         break;
 262     case Z_APDU_presentResponse:
 263         os << " " << "presentResponse" << " ";
 264         {
 265             Z_PresentResponse *pr
 266                 = zapdu.u.presentResponse;
 267             if ((pr->presentStatus) && !*(pr->presentStatus))
 268             {
 269                 os << "OK";
 270                 //<< pr->referenceId << " "
 271                 if (pr->numberOfRecordsReturned)
 272                     os << " " << *(pr->numberOfRecordsReturned);
 273                 else
 274                     os << " -";
 275                 if (pr->nextResultSetPosition)
 276                     os << " " << *(pr->nextResultSetPosition);
 277                 else
 278                     os << " -";
 279             }
 280             else
 281                 if (pr->records)
 282                     os << "DIAG " << *(pr->records);
 283                 else
 284                     os << "ERROR";
 285
 286             //os << "DIAG" << " "
 287             //<< "-" << " "
 288             //<< pr->referenceId << " "
 289             //<< *(pr->numberOfRecordsReturned) << " "
 290             //<< *(pr->nextResultSetPosition);
 291         }
 292         break;
 293     case Z_APDU_deleteResultSetRequest:
 294         os << " " << "deleteResultSetRequest";
 295         break;
 296     case Z_APDU_deleteResultSetResponse:
 297         os << " " << "deleteResultSetResponse";
 298         break;
 299     case Z_APDU_accessControlRequest:
 300         os << " " << "accessControlRequest";
 301         break;
 302     case Z_APDU_accessControlResponse:
 303         os << " " << "accessControlResponse";
 304         break;
 305     case Z_APDU_resourceControlRequest:
 306         os << " " << "resourceControlRequest";
 307         break;
 308     case Z_APDU_resourceControlResponse:
 309         os << " " << "resourceControlResponse";
 310         break;
 311     case Z_APDU_triggerResourceControlRequest:
 312         os << " " << "triggerResourceControlRequest";
 313         break;
 314     case Z_APDU_resourceReportRequest:
 315         os << " " << "resourceReportRequest";
 316         break;
 317     case Z_APDU_resourceReportResponse:
 318         os << " " << "resourceReportResponse";
 319         break;
 320     case Z_APDU_scanRequest:
 321         os << " " << "scanRequest" << " ";
 322         {
 323             Z_ScanRequest *sr
 324                 = zapdu.u.scanRequest;
 325
 326             if (sr)
 327             {
 328                 for (int i = 0; i < sr->num_databaseNames; i++)
 329                 {
 330                     os << sr->databaseNames[i];
 331                     if (i+1 ==  sr->num_databaseNames)
 332                         os << " ";
 333                     else
 334                     os << "+";
 335                 }
 336                 if (sr->numberOfTermsRequested)
 337                     os << " " << *(sr->numberOfTermsRequested);
 338                 else
 339                      os << " -";
 340                 if (sr->preferredPositionInResponse)
 341                     os << " " << *(sr->preferredPositionInResponse);
 342                 else
 343                     os << " -";
 344                 if (sr->stepSize)
 345                     os << " " << *(sr->stepSize);
 346                 else
 347                     os << " -";
 348
 349                 if (sr->termListAndStartPoint)
 350                 {
 351                     WRBUF wr = wrbuf_alloc();
 352                     yaz_scan_to_wrbuf(wr, sr->termListAndStartPoint,
 353                                       sr->attributeSet);
 354                     os << wrbuf_cstr(wr);
 355                     wrbuf_destroy(wr);
 356                 }
 357                 else
 358                     os << " -";
 359             }
 360         }
 361         break;
 362     case Z_APDU_scanResponse:
 363         os << " " << "scanResponse" << " ";
 364         {
 365             Z_ScanResponse *sr
 366                 = zapdu.u.scanResponse;
 367             if (sr)
 368             {
 369                 if ((sr->scanStatus) && !*(sr->scanStatus))
 370                 {
 371                     os << "OK";
 372                     //<< *(sr->scanStatus) << " "
 373                     if (sr->numberOfEntriesReturned)
 374                         os << " " << *(sr->numberOfEntriesReturned);
 375                     else
 376                         os << " -";
 377                     //<< sr->referenceId << " "
 378                     if (sr->positionOfTerm)
 379                         os << " " << *(sr->positionOfTerm);
 380                     else
 381                         os << " -";
 382                     if (sr->stepSize)
 383                         os << " " << *(sr->stepSize);
 384                      else
 385                         os << " -";
 386                 }
 387                 else {
 388                     os << "ERROR";
 389                     if (sr->scanStatus)
 390                     {
 391                         os << " " << *(sr->scanStatus) << " ";
 392
 393                         switch (*(sr->scanStatus)){
 394                         case Z_Scan_success:
 395                             os << "success ";
 396                             break;
 397                         case Z_Scan_partial_1:
 398                             os << "partial_1";
 399                             break;
 400                         case Z_Scan_partial_2:
 401                             os << "partial_2";
 402                             break;
 403                         case Z_Scan_partial_3:
 404                             os << "partial_3";
 405                             break;
 406                         case Z_Scan_partial_4:
 407                             os << "partial_4";
 408                             break;
 409                         case Z_Scan_partial_5:
 410                             os << "partial_5";
 411                             break;
 412                         case Z_Scan_failure:
 413                             os << "failure";
 414                             break;
 415                         default:
 416                             os << "unknown";
 417                         }
 418                     }
 419                     if (sr->numberOfEntriesReturned)
 420                         os << " " << *(sr->numberOfEntriesReturned);
 421                     else
 422                         os << " -";
 423                 }
 424             }
 425         }
 426         break;
 427     case Z_APDU_sortRequest:
 428         os << " " << "sortRequest" << " ";
 429         break;
 430     case Z_APDU_sortResponse:
 431         os << " " << "sortResponse" << " ";
 432         break;
 433     case Z_APDU_segmentRequest:
 434         os << " " << "segmentRequest" << " ";
 435         break;
 436     case Z_APDU_extendedServicesRequest:
 437         os << " " << "extendedServicesRequest";
 438         {
 439             Z_ExtendedServicesRequest *er
 440                 = zapdu.u.extendedServicesRequest;
 441             if (er)
 442             {
 443                 if (er->function)
 444                 {
 445                     os << " ";
 446                     switch(*(er->function))
 447                     {
 448                     case Z_ExtendedServicesRequest_create:
 449                         os << "create";
 450                         break;
 451                     case Z_ExtendedServicesRequest_delete:
 452                         os << "delete";
 453                         break;
 454                     case Z_ExtendedServicesRequest_modify:
 455                         os << "modify";
 456                         break;
 457                     default:
 458                         os << "unknown";
 459                     }
 460                 }
 461                 else
 462                     os << " -";
 463
 464
 465                 if (er->userId)
 466                     os << " " << er->userId ;
 467                 else
 468                     os << " -";
 469
 470                 if (er->packageName)
 471                     os << " " << er->packageName;
 472                 else
 473                     os << " -";
 474
 475                 if (er->description)
 476                     os << " " << er->description;
 477                 else
 478                     os << " -";
 479             }
 480         }
 481         break;
 482     case Z_APDU_extendedServicesResponse:
 483         os << " " << "extendedServicesResponse";
 484          {
 485              Z_ExtendedServicesResponse *er
 486                  = zapdu.u.extendedServicesResponse;
 487              if (er)
 488              {
 489                  if (er->operationStatus)
 490                  {
 491                      os << " ";
 492                      switch (*(er->operationStatus)){
 493                      case Z_ExtendedServicesResponse_done:
 494                          os << "OK";
 495                          break;
 496                      case Z_ExtendedServicesResponse_accepted:
 497                          os << "ACCEPT";
 498                          break;
 499                      case Z_ExtendedServicesResponse_failure:
 500                          if (er->num_diagnostics)
 501                              os << "DIAG " << **(er->diagnostics);
 502                          else
 503                              os << "ERROR";
 504                          break;
 505                      default:
 506                          os << "unknown";
 507                      }
 508                  }
 509                  else
 510                      os << " -";
 511              }
 512          }
 513         break;
 514     case Z_APDU_close:
 515         os  << " " << "close" << " ";
 516         {
 517             Z_Close  *c
 518                 = zapdu.u.close;
 519             if (c)
 520             {
 521                 if (c->closeReason)
 522                 {
 523                     os << *(c->closeReason) << " ";
 524
 525                     switch (*(c->closeReason)) {
 526                     case Z_Close_finished:
 527                         os << "finished";
 528                         break;
 529                     case Z_Close_shutdown:
 530                         os << "shutdown";
 531                         break;
 532                     case Z_Close_systemProblem:
 533                         os << "systemProblem";
 534                         break;
 535                     case Z_Close_costLimit:
 536                         os << "costLimit";
 537                         break;
 538                     case Z_Close_resources:
 539                         os << "resources";
 540                         break;
 541                     case Z_Close_securityViolation:
 542                         os << "securityViolation";
 543                         break;
 544                     case Z_Close_protocolError:
 545                         os << "protocolError";
 546                         break;
 547                     case Z_Close_lackOfActivity:
 548                         os << "lackOfActivity";
 549                         break;
 550                     case Z_Close_peerAbort:
 551                         os << "peerAbort";
 552                         break;
 553                     case Z_Close_unspecified:
 554                         os << "unspecified";
 555                         break;
 556                     default:
 557                         os << "unknown";
 558                     }
 559                 }
 560
 561                 if (c->diagnosticInformation)
 562                     os << " " << c->diagnosticInformation;
 563             }
 564         }
 565         break;
 566     case Z_APDU_duplicateDetectionRequest:
 567         os << " " << "duplicateDetectionRequest";
 568         break;
 569     case Z_APDU_duplicateDetectionResponse:
 570         os << " " << "duplicateDetectionResponse";
 571         break;
 572     default:
 573         os << " " << "Z_APDU " << "UNKNOWN";
 574     }
 575
 576     return os;
 577 }
 578
 579
 580
 581
 582 /*
 583  * Local variables:
 584  * c-basic-offset: 4
 585  * indent-tabs-mode: nil
 586  * c-file-style: "stroustrup"
 587  * End:
 588  * vim: shiftwidth=4 tabstop=8 expandtab
 589  */