src/gduutil.cpp

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