src/gduutil.cpp

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