src/gduutil.cpp

   1 /* This file is part of Metaproxy.
   2    Copyright (C) 2005-2008 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 "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 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
 241                 = zapdu.u.searchResponse;
 242             if (sr->searchStatus && *(sr->searchStatus))
 243             {
 244                 os << "OK";
 245                 dump_opt_int(os, sr->resultCount);
 246                 dump_opt_int(os, sr->numberOfRecordsReturned);
 247                 dump_opt_int(os, sr->nextResultSetPosition);
 248             }
 249             else
 250                 if (sr->records)
 251                     os << "DIAG " << *(sr->records);
 252                 else
 253                     os << "ERROR";
 254         }
 255         break;
 256     case Z_APDU_presentRequest:
 257         os << " " << "presentRequest";
 258         {
 259             Z_PresentRequest *pr = zapdu.u.presentRequest;
 260             dump_opt_string(os, pr->resultSetId);
 261             dump_opt_int(os, pr->resultSetStartPoint);
 262             dump_opt_int(os, pr->numberOfRecordsRequested);
 263             if (pr->preferredRecordSyntax)
 264             {
 265                 char oid_name_str[OID_STR_MAX];
 266                 const char *oid_name = yaz_oid_to_string_buf(
 267                     pr->preferredRecordSyntax, 0, oid_name_str);
 268
 269                 os << " " << oid_name;
 270             }
 271             else
 272                 os << " -";
 273             const char * msg = 0;
 274             if (pr->recordComposition)
 275                 msg = mp_util::record_composition_to_esn(pr->recordComposition);
 276             dump_opt_string(os, msg);
 277         }
 278         break;
 279     case Z_APDU_presentResponse:
 280         os << " " << "presentResponse" << " ";
 281         {
 282             Z_PresentResponse *pr
 283                 = zapdu.u.presentResponse;
 284             if ((pr->presentStatus) && !*(pr->presentStatus))
 285             {
 286                 os << "OK";
 287                 //<< pr->referenceId << " "
 288                 if (pr->numberOfRecordsReturned)
 289                     os << " " << *(pr->numberOfRecordsReturned);
 290                 else
 291                     os << " -";
 292                 if (pr->nextResultSetPosition)
 293                     os << " " << *(pr->nextResultSetPosition);
 294                 else
 295                     os << " -";
 296             }
 297             else
 298                 if (pr->records)
 299                     os << "DIAG " << *(pr->records);
 300                 else
 301                     os << "ERROR";
 302
 303             //os << "DIAG" << " "
 304             //<< "-" << " "
 305             //<< pr->referenceId << " "
 306             //<< *(pr->numberOfRecordsReturned) << " "
 307             //<< *(pr->nextResultSetPosition);
 308         }
 309         break;
 310     case Z_APDU_deleteResultSetRequest:
 311         os << " " << "deleteResultSetRequest";
 312         break;
 313     case Z_APDU_deleteResultSetResponse:
 314         os << " " << "deleteResultSetResponse";
 315         break;
 316     case Z_APDU_accessControlRequest:
 317         os << " " << "accessControlRequest";
 318         break;
 319     case Z_APDU_accessControlResponse:
 320         os << " " << "accessControlResponse";
 321         break;
 322     case Z_APDU_resourceControlRequest:
 323         os << " " << "resourceControlRequest";
 324         break;
 325     case Z_APDU_resourceControlResponse:
 326         os << " " << "resourceControlResponse";
 327         break;
 328     case Z_APDU_triggerResourceControlRequest:
 329         os << " " << "triggerResourceControlRequest";
 330         break;
 331     case Z_APDU_resourceReportRequest:
 332         os << " " << "resourceReportRequest";
 333         break;
 334     case Z_APDU_resourceReportResponse:
 335         os << " " << "resourceReportResponse";
 336         break;
 337     case Z_APDU_scanRequest:
 338         os << " " << "scanRequest" << " ";
 339         {
 340             Z_ScanRequest *sr
 341                 = zapdu.u.scanRequest;
 342
 343             if (sr)
 344             {
 345                 for (int i = 0; i < sr->num_databaseNames; i++)
 346                 {
 347                     os << sr->databaseNames[i];
 348                     if (i+1 !=  sr->num_databaseNames)
 349                         os << "+";
 350                 }
 351                 dump_opt_int(os, sr->numberOfTermsRequested);
 352                 dump_opt_int(os, sr->preferredPositionInResponse);
 353                 dump_opt_int(os, sr->stepSize);
 354
 355                 os << " ";
 356                 if (sr->termListAndStartPoint)
 357                 {
 358                     WRBUF wr = wrbuf_alloc();
 359                     yaz_scan_to_wrbuf(wr, sr->termListAndStartPoint,
 360                                       sr->attributeSet);
 361                     os << wrbuf_cstr(wr);
 362                     wrbuf_destroy(wr);
 363                 }
 364                 else
 365                     os << "-";
 366             }
 367         }
 368         break;
 369     case Z_APDU_scanResponse:
 370         os << " " << "scanResponse" << " ";
 371         {
 372             Z_ScanResponse *sr
 373                 = zapdu.u.scanResponse;
 374             if (sr)
 375             {
 376                 if (!sr->scanStatus)
 377                 {
 378                     os << "OK";
 379                 }
 380                 else
 381                 {
 382                     switch (*(sr->scanStatus)){
 383                     case Z_Scan_success:
 384                         os << "OK";
 385                         break;
 386                     case Z_Scan_partial_1:
 387                         os << "partial_1";
 388                         break;
 389                     case Z_Scan_partial_2:
 390                         os << "partial_2";
 391                         break;
 392                     case Z_Scan_partial_3:
 393                         os << "partial_3";
 394                         break;
 395                     case Z_Scan_partial_4:
 396                         os << "partial_4";
 397                         break;
 398                     case Z_Scan_partial_5:
 399                         os << "partial_5";
 400                         break;
 401                     case Z_Scan_failure:
 402                         os << "failure";
 403                         break;
 404                     default:
 405                         os << "unknown";
 406                     }
 407                 }
 408                 dump_opt_int(os, sr->numberOfEntriesReturned);
 409                 dump_opt_int(os, sr->positionOfTerm);
 410                 dump_opt_int(os, sr->stepSize);
 411             }
 412         }
 413         break;
 414     case Z_APDU_sortRequest:
 415         os << " " << "sortRequest" << " ";
 416         break;
 417     case Z_APDU_sortResponse:
 418         os << " " << "sortResponse" << " ";
 419         break;
 420     case Z_APDU_segmentRequest:
 421         os << " " << "segmentRequest" << " ";
 422         break;
 423     case Z_APDU_extendedServicesRequest:
 424         os << " " << "extendedServicesRequest";
 425         {
 426             Z_ExtendedServicesRequest *er
 427                 = zapdu.u.extendedServicesRequest;
 428             if (er)
 429             {
 430                 if (er->function)
 431                 {
 432                     os << " ";
 433                     switch(*(er->function))
 434                     {
 435                     case Z_ExtendedServicesRequest_create:
 436                         os << "create";
 437                         break;
 438                     case Z_ExtendedServicesRequest_delete:
 439                         os << "delete";
 440                         break;
 441                     case Z_ExtendedServicesRequest_modify:
 442                         os << "modify";
 443                         break;
 444                     default:
 445                         os << "unknown";
 446                     }
 447                 }
 448                 else
 449                     os << " -";
 450
 451
 452                 if (er->userId)
 453                     os << " " << er->userId ;
 454                 else
 455                     os << " -";
 456
 457                 if (er->packageName)
 458                     os << " " << er->packageName;
 459                 else
 460                     os << " -";
 461
 462                 if (er->description)
 463                     os << " " << er->description;
 464                 else
 465                     os << " -";
 466             }
 467         }
 468         break;
 469     case Z_APDU_extendedServicesResponse:
 470         os << " " << "extendedServicesResponse";
 471          {
 472              Z_ExtendedServicesResponse *er
 473                  = zapdu.u.extendedServicesResponse;
 474              if (er)
 475              {
 476                  if (er->operationStatus)
 477                  {
 478                      os << " ";
 479                      switch (*(er->operationStatus)){
 480                      case Z_ExtendedServicesResponse_done:
 481                          os << "OK";
 482                          break;
 483                      case Z_ExtendedServicesResponse_accepted:
 484                          os << "ACCEPT";
 485                          break;
 486                      case Z_ExtendedServicesResponse_failure:
 487                          if (er->num_diagnostics)
 488                              os << "DIAG " << **(er->diagnostics);
 489                          else
 490                              os << "ERROR";
 491                          break;
 492                      default:
 493                          os << "unknown";
 494                      }
 495                  }
 496                  else
 497                      os << " -";
 498              }
 499          }
 500         break;
 501     case Z_APDU_close:
 502         os  << " " << "close" << " ";
 503         {
 504             Z_Close  *c
 505                 = zapdu.u.close;
 506             if (c)
 507             {
 508                 if (c->closeReason)
 509                 {
 510                     os << *(c->closeReason) << " ";
 511
 512                     switch (*(c->closeReason)) {
 513                     case Z_Close_finished:
 514                         os << "finished";
 515                         break;
 516                     case Z_Close_shutdown:
 517                         os << "shutdown";
 518                         break;
 519                     case Z_Close_systemProblem:
 520                         os << "systemProblem";
 521                         break;
 522                     case Z_Close_costLimit:
 523                         os << "costLimit";
 524                         break;
 525                     case Z_Close_resources:
 526                         os << "resources";
 527                         break;
 528                     case Z_Close_securityViolation:
 529                         os << "securityViolation";
 530                         break;
 531                     case Z_Close_protocolError:
 532                         os << "protocolError";
 533                         break;
 534                     case Z_Close_lackOfActivity:
 535                         os << "lackOfActivity";
 536                         break;
 537                     case Z_Close_peerAbort:
 538                         os << "peerAbort";
 539                         break;
 540                     case Z_Close_unspecified:
 541                         os << "unspecified";
 542                         break;
 543                     default:
 544                         os << "unknown";
 545                     }
 546                 }
 547
 548                 if (c->diagnosticInformation)
 549                     os << " " << c->diagnosticInformation;
 550             }
 551         }
 552         break;
 553     case Z_APDU_duplicateDetectionRequest:
 554         os << " " << "duplicateDetectionRequest";
 555         break;
 556     case Z_APDU_duplicateDetectionResponse:
 557         os << " " << "duplicateDetectionResponse";
 558         break;
 559     default:
 560         os << " " << "Z_APDU " << "UNKNOWN";
 561     }
 562
 563     return os;
 564 }
 565
 566
 567
 568
 569 /*
 570  * Local variables:
 571  * c-basic-offset: 4
 572  * c-file-style: "Stroustrup"
 573  * indent-tabs-mode: nil
 574  * End:
 575  * vim: shiftwidth=4 tabstop=8 expandtab
 576  */
 577