src/gduutil.cpp

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