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 << "\"";
 120         os << ddf.u.v2Addinfo;
 121         os << "\"";
 122         break;
 123     case Z_DefaultDiagFormat_v3Addinfo:
 124         os << "\"";
 125         os << ddf.u.v3Addinfo;
 126         os << "\"";
 127         break;
 128     default:
 129         os << "-";
 130     }
 131
 132     return os;
 133 }
 134
 135 static void dump_opt_string(std::ostream& os, const char *s)
 136 {
 137     os << " ";
 138     if (s)
 139         os << s;
 140     else
 141         os << "-";
 142 }
 143
 144 static void dump_opt_int_l(std::ostream& os, const Odr_int *i, const char *lead)
 145 {
 146     os << lead;
 147     if (i)
 148         os << *i;
 149     else
 150         os << "-";
 151 }
 152
 153 static void dump_opt_int(std::ostream& os, const Odr_int *i)
 154 {
 155     dump_opt_int_l(os, i, " ");
 156 }
 157
 158 std::ostream& std::operator<<(std::ostream& os,  Z_APDU& zapdu)
 159 {
 160     switch(zapdu.which) {
 161
 162     case Z_APDU_initRequest:
 163         os << " " << "initRequest";
 164
 165         {
 166             Z_InitRequest *ir
 167                 = zapdu.u.initRequest;
 168
 169             Z_IdAuthentication *a = ir->idAuthentication;
 170             if (a && a->which == Z_IdAuthentication_idPass)
 171                 dump_opt_string(os, a->u.idPass->userId);
 172             else if (a && a->which == Z_IdAuthentication_open)
 173                 dump_opt_string(os, a->u.open);
 174             else
 175                 dump_opt_string(os, 0);
 176
 177             os << " ";
 178             std::list<std::string> vhosts;
 179             mp::util::get_vhost_otherinfo(ir->otherInfo, vhosts);
 180             if (vhosts.size()){
 181                 copy(vhosts.begin(), vhosts.end(),
 182                      ostream_iterator<string>(os, " "));
 183             }
 184             else
 185                 os << "-" ;
 186
 187             dump_opt_string(os, ir->implementationId);
 188             dump_opt_string(os, ir->implementationName);
 189             dump_opt_string(os, ir->implementationVersion);
 190         }
 191         break;
 192     case Z_APDU_initResponse:
 193         os << " " << "initResponse ";
 194         {
 195             Z_InitResponse *ir
 196                 = zapdu.u.initResponse;
 197             if (ir->result && *(ir->result))
 198             {
 199                 os << "OK";
 200             }
 201             else
 202             {
 203                 os << "FAIL";
 204             }
 205             dump_opt_string(os, ir->implementationId);
 206             dump_opt_string(os, ir->implementationName);
 207             dump_opt_string(os, ir->implementationVersion);
 208         }
 209         break;
 210     case Z_APDU_searchRequest:
 211         os << " " << "searchRequest" << " ";
 212         {
 213             Z_SearchRequest *sr
 214                 = zapdu.u.searchRequest;
 215
 216             for (int i = 0; i < sr->num_databaseNames; i++)
 217             {
 218                 os << sr->databaseNames[i];
 219                 if (i+1 !=  sr->num_databaseNames)
 220                     os << "+";
 221             }
 222
 223             dump_opt_string(os, sr->resultSetName);
 224
 225             os << " ";
 226             if (sr->preferredRecordSyntax)
 227             {
 228                 char oid_name_str[OID_STR_MAX];
 229                 os << yaz_oid_to_string_buf(
 230                     sr->preferredRecordSyntax, 0, oid_name_str);
 231             }
 232             else
 233                 os << "-";
 234
 235             os << " ";
 236             mp::wrbuf wr;
 237             yaz_query_to_wrbuf(wr, sr->query);
 238             os << wrbuf_cstr(wr);
 239         }
 240         break;
 241     case Z_APDU_searchResponse:
 242         os << " " << "searchResponse ";
 243         {
 244             Z_SearchResponse *sr = zapdu.u.searchResponse;
 245             if (!sr->searchStatus)
 246                 os << "Unknown";
 247             else if (*sr->searchStatus)
 248                 os << "OK";
 249             else
 250                 os << "Failure";
 251             if (sr->records && sr->records->which != Z_Records_DBOSD)
 252             {
 253                 os << " DIAG " << *sr->records;
 254             }
 255             else
 256             {
 257                 dump_opt_int(os, sr->resultCount);
 258                 dump_opt_int_l(os, sr->numberOfRecordsReturned, " 1+");
 259                 dump_opt_int(os, sr->nextResultSetPosition);
 260             }
 261         }
 262         break;
 263     case Z_APDU_presentRequest:
 264         os << " " << "presentRequest";
 265         {
 266             Z_PresentRequest *pr = zapdu.u.presentRequest;
 267             dump_opt_string(os, pr->resultSetId);
 268             dump_opt_int(os, pr->resultSetStartPoint);
 269             dump_opt_int_l(os, pr->numberOfRecordsRequested, "+");
 270             if (pr->preferredRecordSyntax)
 271             {
 272                 char oid_name_str[OID_STR_MAX];
 273                 const char *oid_name = yaz_oid_to_string_buf(
 274                     pr->preferredRecordSyntax, 0, oid_name_str);
 275
 276                 os << " " << oid_name;
 277             }
 278             else
 279                 os << " -";
 280             const char * msg = 0;
 281             if (pr->recordComposition)
 282                 msg = mp_util::record_composition_to_esn(pr->recordComposition);
 283             dump_opt_string(os, msg);
 284         }
 285         break;
 286     case Z_APDU_presentResponse:
 287         os << " " << "presentResponse" << " ";
 288         {
 289             Z_PresentResponse *pr
 290                 = zapdu.u.presentResponse;
 291             if (!pr->presentStatus)
 292                 os << "Unknown";
 293             else
 294             {
 295                 switch (*pr->presentStatus)
 296                 {
 297                 case Z_PresentStatus_success:
 298                     os << "OK"; break;
 299                 case Z_PresentStatus_partial_1:
 300                     os << "Partial-1"; break;
 301                 case Z_PresentStatus_partial_2:
 302                     os << "Partial-2"; break;
 303                 case Z_PresentStatus_partial_3:
 304                     os << "Partial-3"; break;
 305                 case Z_PresentStatus_partial_4:
 306                     os << "Partial-4"; break;
 307                 case Z_PresentStatus_failure:
 308                     os << "Failure"; break;
 309                 default:
 310                     os << "Unknown"; break;
 311                 }
 312             }
 313             if (pr->records && pr->records->which != Z_Records_DBOSD)
 314                 os << " DIAG " << *pr->records;
 315             else
 316             {
 317                 dump_opt_int(os, pr->numberOfRecordsReturned);
 318                 dump_opt_int(os, pr->nextResultSetPosition);
 319             }
 320         }
 321         break;
 322     case Z_APDU_deleteResultSetRequest:
 323         os << " " << "deleteResultSetRequest";
 324         break;
 325     case Z_APDU_deleteResultSetResponse:
 326         os << " " << "deleteResultSetResponse";
 327         break;
 328     case Z_APDU_accessControlRequest:
 329         os << " " << "accessControlRequest";
 330         break;
 331     case Z_APDU_accessControlResponse:
 332         os << " " << "accessControlResponse";
 333         break;
 334     case Z_APDU_resourceControlRequest:
 335         os << " " << "resourceControlRequest";
 336         break;
 337     case Z_APDU_resourceControlResponse:
 338         os << " " << "resourceControlResponse";
 339         break;
 340     case Z_APDU_triggerResourceControlRequest:
 341         os << " " << "triggerResourceControlRequest";
 342         break;
 343     case Z_APDU_resourceReportRequest:
 344         os << " " << "resourceReportRequest";
 345         break;
 346     case Z_APDU_resourceReportResponse:
 347         os << " " << "resourceReportResponse";
 348         break;
 349     case Z_APDU_scanRequest:
 350         os << " " << "scanRequest" << " ";
 351         {
 352             Z_ScanRequest *sr = zapdu.u.scanRequest;
 353
 354             if (sr)
 355             {
 356                 for (int i = 0; i < sr->num_databaseNames; i++)
 357                 {
 358                     os << sr->databaseNames[i];
 359                     if (i+1 !=  sr->num_databaseNames)
 360                         os << "+";
 361                 }
 362                 dump_opt_int(os, sr->numberOfTermsRequested);
 363                 dump_opt_int(os, sr->preferredPositionInResponse);
 364                 dump_opt_int(os, sr->stepSize);
 365
 366                 os << " ";
 367                 if (sr->termListAndStartPoint)
 368                 {
 369                     mp::wrbuf wr;
 370                     yaz_scan_to_wrbuf(wr, sr->termListAndStartPoint,
 371                                       sr->attributeSet);
 372                     os << wrbuf_cstr(wr);
 373                 }
 374                 else
 375                     os << "-";
 376             }
 377         }
 378         break;
 379     case Z_APDU_scanResponse:
 380         os << " " << "scanResponse" << " ";
 381         {
 382             Z_ScanResponse *sr = zapdu.u.scanResponse;
 383             if (sr)
 384             {
 385                 if (!sr->scanStatus)
 386                     os << "OK";
 387                 else
 388                 {
 389                     switch (*sr->scanStatus)
 390                     {
 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                     {
 489                     case Z_ExtendedServicesResponse_done:
 490                         os << "OK";
 491                         break;
 492                     case Z_ExtendedServicesResponse_accepted:
 493                         os << "ACCEPT";
 494                         break;
 495                     case Z_ExtendedServicesResponse_failure:
 496                         if (er->num_diagnostics)
 497                             os << "DIAG " << **(er->diagnostics);
 498                         else
 499                             os << "ERROR";
 500                         break;
 501                     default:
 502                         os << "unknown";
 503                     }
 504                 }
 505                 else
 506                     os << " -";
 507             }
 508         }
 509         break;
 510     case Z_APDU_close:
 511         os  << " " << "close" << " ";
 512         {
 513             Z_Close *c = zapdu.u.close;
 514             if (c)
 515             {
 516                 if (c->closeReason)
 517                 {
 518                     os << *(c->closeReason) << " ";
 519
 520                     switch (*c->closeReason)
 521                     {
 522                     case Z_Close_finished:
 523                         os << "finished";
 524                         break;
 525                     case Z_Close_shutdown:
 526                         os << "shutdown";
 527                         break;
 528                     case Z_Close_systemProblem:
 529                         os << "systemProblem";
 530                         break;
 531                     case Z_Close_costLimit:
 532                         os << "costLimit";
 533                         break;
 534                     case Z_Close_resources:
 535                         os << "resources";
 536                         break;
 537                     case Z_Close_securityViolation:
 538                         os << "securityViolation";
 539                         break;
 540                     case Z_Close_protocolError:
 541                         os << "protocolError";
 542                         break;
 543                     case Z_Close_lackOfActivity:
 544                         os << "lackOfActivity";
 545                         break;
 546                     case Z_Close_peerAbort:
 547                         os << "peerAbort";
 548                         break;
 549                     case Z_Close_unspecified:
 550                         os << "unspecified";
 551                         break;
 552                     default:
 553                         os << "unknown";
 554                     }
 555                 }
 556
 557                 if (c->diagnosticInformation)
 558                     os << " " << c->diagnosticInformation;
 559             }
 560         }
 561         break;
 562     case Z_APDU_duplicateDetectionRequest:
 563         os << " " << "duplicateDetectionRequest";
 564         break;
 565     case Z_APDU_duplicateDetectionResponse:
 566         os << " " << "duplicateDetectionResponse";
 567         break;
 568     default:
 569         os << " " << "Z_APDU " << "UNKNOWN";
 570     }
 571
 572     return os;
 573 }
 574
 575
 576
 577
 578 /*
 579  * Local variables:
 580  * c-basic-offset: 4
 581  * c-file-style: "Stroustrup"
 582  * indent-tabs-mode: nil
 583  * End:
 584  * vim: shiftwidth=4 tabstop=8 expandtab
 585  */
 586