LTP GCOV extension - code coverage report
Current view: directory - src/cpp/dev/spy - spy.cpp
Test: YAORB-0.2.info
Date: 2006-02-27 Instrumented lines: 176
Code covered: 77.3 % Executed lines: 136

       1                 : //=============================================================================
       2                 : // File <$/src/cpp/dev/spy/spy.cpp>
       3                 : // This file is part of YaOrb : Yet Another Object Request Broker,
       4                 : // Copyright (c) 2000-2003, Marc Alff.
       5                 : //
       6                 : // This program is free software; you can redistribute it and/or
       7                 : // modify it under the terms of the GNU General Public License
       8                 : // as published by the Free Software Foundation; either version 2
       9                 : // of the License, or (at your option) any later version.
      10                 : //
      11                 : // This program is distributed in the hope that it will be useful,
      12                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 : // GNU General Public License for more details.
      15                 : //
      16                 : // You should have received a copy of the GNU General Public License
      17                 : // along with this program; if not, write to the Free Software
      18                 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
      19                 : //
      20                 : //=============================================================================
      21                 : 
      22                 : // Portability
      23                 : #include "yaorb/config.h"
      24                 : #include "src/cpp/prod/port/port_stdc.h"
      25                 : #include "src/cpp/prod/port/port_stdlib.h"
      26                 : 
      27                 : #include <stdio.h>
      28                 : #include <fstream>
      29                 : 
      30                 : #include <yaorb/CORBA.h>
      31                 : #include <yaorb/YAORB.h>
      32                 : 
      33                 : #include "src/cpp/prod/protocol/cdr/cdr_file.h"
      34                 : #include "src/cpp/prod/protocol/giop/message_header.h"
      35                 : #include "src/cpp/prod/protocol/giop/giop.h"
      36                 : #include "src/cpp/prod/protocol/giop/request_header_12.h"
      37                 : #include "src/cpp/prod/protocol/giop/target_address.h"
      38                 : #include "src/cpp/prod/protocol/giop/reply_12.h"
      39                 : #include "src/cpp/prod/protocol/giop/reply_header_12.h"
      40                 : #include "src/cpp/prod/protocol/giop/cancel_request_12.h"
      41                 : #include "src/cpp/prod/protocol/giop/locate_request_12.h"
      42                 : #include "src/cpp/prod/protocol/giop/locate_reply_12.h"
      43                 : #include "src/cpp/prod/protocol/giop/locate_reply_header_12.h"
      44                 : 
      45               3 : void DumpOctet(CORBA::Octet o, std::ostream& str)
      46                 : {
      47                 :    char buf[80] ;
      48               3 :    sprintf(buf, "0x%x - %dd", o, o) ;
      49               3 :    str << buf ;
      50                 : }
      51                 : 
      52               7 : void DumpLong(CORBA::ULong l, std::ostream& str)
      53                 : {
      54                 :    char buf[80] ;
      55               7 :    sprintf(buf, "0x%x - %dd", l, l) ;
      56               7 :    str << buf ;
      57                 : }
      58                 : 
      59               4 : void DumpTargetAddress(const TargetAddress& target, std::ostream& str)
      60                 : {
      61               4 :    AddressingDisposition ad = target.GetAddressingDisposition() ;
      62                 : 
      63               4 :    switch (ad)
      64                 :    {
      65                 :       case KeyAddr :
      66                 :       {
      67               2 :          GIOPEncapsulation* key = target.GetObjectKey() ;
      68               2 :          str << " - (target:KeyAddr)" << std::endl ;
      69               2 :          str << "    - encapsulation, length = " << key->GetLength() << std::endl ;
      70                 :          break ;
      71                 :       }
      72                 :       case ProfileAddr :
      73                 :       {
      74               1 :          IOP::TaggedProfile* profile = target.GetProfile() ;
      75               1 :          CORBA::ULong tag = profile->_tag ;
      76                 : 
      77               1 :          str << " - (target:ProfileAddr)" << std::endl ;
      78               1 :          str << "   - tag : " << tag << std::endl ;
      79                 :          break ;
      80                 :       }
      81                 :       case ReferenceAddr :
      82                 :       {
      83               1 :          const IORAddressingInfo* ior = target.GetIOR() ;
      84               1 :          CORBA::ULong index = ior->_selected_profile_index ;
      85               1 :          const char* type_id = ior->_ior._type_id ;
      86                 : 
      87               1 :          str << " - (target:ReferenceAddr)" << std::endl ;
      88               1 :          str << "   - selected profile index :" << index << std::endl ;
      89               1 :          str << "   - ior :" << type_id << std::endl ;
      90                 :          break ;
      91                 :       }
      92                 :       default :
      93                 :       {
      94               0 :          str << " - (target:?) " << std::endl ;
      95               0 :          str << " : UNKNOWN TARGET ADDRESSING DISPOSITION" << std::endl ;
      96                 :       }
      97                 :    }
      98                 : }
      99                 : 
     100               1 : void spy_10(GIOPMessage *msg, YAORB::CDR *cdrs, std::ostream& log)
     101                 : {
     102               1 :    GIOPMessageHeader& hdr = msg->GetHeader() ;
     103               1 :    log << "GIOP 1.0, message : " << (int) hdr.GetGIOP10MessageType() << std::endl ;
     104                 : }
     105                 : 
     106               1 : void spy_11(GIOPMessage *msg, YAORB::CDR *cdrs, std::ostream& log)
     107                 : {
     108               1 :    GIOPMessageHeader& hdr = msg->GetHeader() ;
     109               1 :    log << "GIOP 1.1, message : " << (int) hdr.GetGIOP11MessageType() << std::endl ;
     110                 : }
     111                 : 
     112              12 : void spy_12(GIOPMessage *msg, YAORB::CDR *cdrs, std::ostream& log)
     113                 : {
     114              12 :    GIOPMessageHeader& hdr = msg->GetHeader() ;
     115                 : 
     116                 :    // the message header is already read throught CDR
     117              12 :    msg->cdr_body(cdrs) ;
     118                 : 
     119               9 :    switch (hdr.GetGIOP12MessageType())
     120                 :    {
     121                 :       case GIOPRequest_type :
     122                 :       {
     123               3 :          log << "Request Message" << std::endl ;
     124               3 :          const GIOP12RequestHeader* req = msg->GetRequest() ;
     125                 : 
     126               3 :          CORBA::ULong id = req->GetRequestId() ;
     127               3 :          log << " - request id = " ;
     128               3 :          DumpLong(id, log) ;
     129                 :          log  << std::endl;
     130                 : 
     131               3 :          CORBA::Octet flag = req->GetResponseFlags() ;
     132               3 :          log << " - response flags = " ;
     133               3 :          DumpOctet(flag, log) ;
     134                 :          log << std::endl ;
     135                 : 
     136               3 :          const TargetAddress & target = req->GetTarget() ;
     137               3 :          DumpTargetAddress(target, log) ;
     138                 : 
     139               3 :          const CORBA::String_var & operation = req->GetOperation() ;
     140               3 :          const char* op = operation ;
     141               3 :          log << " - operation = " << op << std::endl ;
     142                 :          break ;
     143                 :       }
     144                 :       case GIOPReply_type :
     145                 :       {
     146               1 :          log << "Reply Message" << std::endl ;
     147               1 :          GIOP12ReplyMessage *rep = msg->GetReply() ;
     148               1 :          const GIOP12ReplyHeader& repH = rep->GetHeader() ;
     149                 : 
     150               1 :          CORBA::ULong id = repH.GetRequestId() ;
     151               1 :          log << " - request id = " ;
     152               1 :          DumpLong(id, log) ;
     153                 :          log  << std::endl;
     154                 : 
     155               1 :          GIOP12ReplyHeader::ReplyStatusType status = repH.GetReplyStatus() ;
     156               1 :          log << " - reply status = " ;
     157               1 :          switch(status)
     158                 :          {
     159                 :             case GIOP12ReplyHeader::NO_EXCEPTION :
     160                 :             {
     161               1 :                log << "NO_EXCEPTION" ;
     162               1 :                break ;
     163                 :             }
     164                 :             case GIOP12ReplyHeader::USER_EXCEPTION :
     165                 :             {
     166               0 :                log << "USER_EXCEPTION" ;
     167               0 :                break ;
     168                 :             }
     169                 :             case GIOP12ReplyHeader::SYSTEM_EXCEPTION :
     170                 :             {
     171               0 :                log << "SYSTEM_EXCEPTION" ;
     172               0 :                break ;
     173                 :             }
     174                 :             case GIOP12ReplyHeader::LOCATION_FORWARD :
     175                 :             {
     176               0 :                log << "LOCATION_FORWARD" ;
     177               0 :                break ;
     178                 :             }
     179                 :             case GIOP12ReplyHeader::LOCATION_FORWARD_PERM :
     180                 :             {
     181               0 :                log << "LOCATION_FORWARD_PERM" ;
     182               0 :                break ;
     183                 :             }
     184                 :             case GIOP12ReplyHeader::NEEDS_ADDRESSING_MODE :
     185                 :             {
     186               0 :                log << "NEEDS_ADDRESSING_MODE" ;
     187                 :                break ;
     188                 :             }
     189                 :          }
     190                 :          log << std::endl ;
     191                 : 
     192                 :          // const IOP::ServiceContextList& service
     193                 :          //  = repH.GetServiceContext() ;
     194                 : 
     195                 :          break ;
     196                 :       }
     197                 :       case GIOPCancelRequest_type :
     198                 :       {
     199               1 :          log << "Cancel Request Message" << std::endl ;
     200               1 :          GIOP12CancelRequestMessage *cancel = msg->GetCancelRequest() ;
     201                 : 
     202               1 :          CORBA::ULong id = cancel->GetRequestId() ;
     203               1 :          log << " - request id = " ;
     204               1 :          DumpLong(id, log) ;
     205                 :          log  << std::endl;
     206                 : 
     207                 :          break ;
     208                 :       }
     209                 :       case GIOPLocateRequest_type :
     210                 :       {
     211               1 :          log << "Locate Request Message" << std::endl ;
     212               1 :          GIOP12LocateRequestMessage *locReq = msg->GetLocateRequest() ;
     213                 : 
     214               1 :          CORBA::ULong id = locReq->GetRequestId() ;
     215               1 :          log << " - request id = " ;
     216               1 :          DumpLong(id, log) ;
     217                 :          log  << std::endl;
     218                 : 
     219               1 :          const TargetAddress& target = locReq->GetTargetAddress() ;
     220               1 :          DumpTargetAddress(target, log) ;
     221                 : 
     222                 :          break ;
     223                 :       }
     224                 :       case GIOPLocateReply_type :
     225                 :       {
     226               1 :          log << "Locate Reply Message" << std::endl ;
     227               1 :          GIOP12LocateReplyMessage *locRep = msg->GetLocateReply() ;
     228               1 :          const GIOP12LocateReplyHeader& locRepH = locRep->GetHeader() ;
     229                 : 
     230               1 :          CORBA::ULong id = locRepH.GetRequestId() ;
     231               1 :          log << " - request id = " ;
     232               1 :          DumpLong(id, log) ;
     233                 :          log  << std::endl;
     234                 : 
     235                 :          GIOP12LocateReplyHeader::LocateStatusType status ;
     236               1 :          status = locRepH.GetLocateStatus() ;
     237                 : 
     238               1 :          log << " - locate reply status = " ;
     239               1 :          switch(status)
     240                 :          {
     241                 :             case GIOP12LocateReplyHeader::UNKNOWN_OBJECT :
     242                 :             {
     243               0 :                log << "UNKNOWN_OBJECT" ;
     244               0 :                break ;
     245                 :             }
     246                 :             case GIOP12LocateReplyHeader::OBJECT_HERE :
     247                 :             {
     248               1 :                log << "OBJECT_HERE" ;
     249               1 :                break ;
     250                 :             }
     251                 :             case GIOP12LocateReplyHeader::OBJECT_FORWARD :
     252                 :             {
     253               0 :                log << "OBJECT_FORWARD" ;
     254               0 :                break ;
     255                 :             }
     256                 :             case GIOP12LocateReplyHeader::OBJECT_FORWARD_PERM :
     257                 :             {
     258               0 :                log << "OBJECT_FORWARD_PERM" ;
     259               0 :                break ;
     260                 :             }
     261                 :             case GIOP12LocateReplyHeader::LOC_SYSTEM_EXCEPTION :
     262                 :             {
     263               0 :                log << "LOC_SYSTEM_EXCEPTION" ;
     264               0 :                break ;
     265                 :             }
     266                 :             case GIOP12LocateReplyHeader::LOC_NEEDS_ADDRESSING_MODE :
     267                 :             {
     268               0 :                log << "LOC_NEEDS_ADDRESSING_MODE" ;
     269                 :                break ;
     270                 :             }
     271                 :          }
     272                 :          log << std::endl ;
     273                 : 
     274                 :          break ;
     275                 :       }
     276                 :       case GIOPCloseConnection_type :
     277                 :       {
     278               1 :          log << "Close Connection Message" << std::endl ;
     279                 :          break ;
     280                 :       }
     281                 :       case GIOPMessageError_type :
     282                 :       {
     283               1 :          log << "Message Error Message" << std::endl ;
     284                 :          break ;
     285                 :       }
     286                 :       case GIOPFragment_type :
     287                 :       {
     288               0 :          log << "Fragment Message" << std::endl ;
     289                 :          break ;
     290                 :       }
     291                 :    }
     292                 : }
     293                 : 
     294              25 : void spy(YAORB::CDR *cdrs, std::ostream& log)
     295                 : {
     296              25 :    GIOPMessage msg ;
     297              25 :    msg.cdr_header(cdrs) ;
     298                 : 
     299              14 :    GIOPMessageHeader& hdr = msg.GetHeader() ;
     300              14 :    CORBA::Octet major = hdr.GetMajor() ;
     301              14 :    CORBA::Octet minor = hdr.GetMinor() ;
     302                 : 
     303              28 :    log << "GIOP " << (int)major << "." << (int)minor << std::endl ;
     304                 : 
     305              14 :    if ((major == 1) && (minor == 0))
     306                 :    {
     307               1 :       spy_10(& msg, cdrs, log) ;
     308              13 :    } else if ((major == 1) && (minor == 1))
     309                 :    {
     310               1 :       spy_11(& msg, cdrs, log) ;
     311              12 :    } else if ((major == 1) && (minor == 2))
     312                 :    {
     313              12 :       spy_12(& msg, cdrs, log) ;
     314                 :    } else {
     315               0 :       fprintf(stderr, "Unknown GIOP protocol\n") ;
     316                 :    }
     317                 : 
     318              11 :    int pos = cdrs->GetPosition() ;
     319              36 :    log << "final position = " << pos << std::endl ;
     320              11 : }
     321                 : 
     322              25 : void spy_file(const char* filename, std::ostream& log)
     323                 : {
     324              25 :    log << "Reading " << filename << std::endl ;
     325              25 :    CDRFile cdrs(filename, YAORB::CDR_READ) ;
     326                 : 
     327                 :    try
     328                 :    {
     329              25 :       spy( & cdrs, log) ;
     330                 :    }
     331              14 :    catch (CORBA::Exception& e)
     332                 :    {
     333              14 :       log << "Exception caught while reading stream at position " ;
     334              14 :       log << cdrs.GetPosition() << std::endl ;
     335                 : 
     336                 :       CORBA::SystemException *s = NULL ;
     337              14 :       s = CORBA::SystemException::_downcast(& e) ;
     338              14 :       if (s != NULL)
     339                 :       {
     340                 :          CORBA::MARSHAL *m = NULL ;
     341              14 :          m = CORBA::MARSHAL::_downcast(s) ;
     342              14 :          if (m != NULL)
     343                 :          {
     344              14 :             log << "CORBA::MARSHAL" << std::endl ;
     345                 :          }
     346                 : 
     347              14 :          int minor = s->minor() ;
     348                 :          char buf[80] ;
     349              14 :          sprintf(buf, "0x%x", minor) ;
     350              14 :          log << " - minor :" << buf << std::endl ;
     351              14 :          log << " - completion :" ;
     352              14 :          switch(s->completed())
     353                 :          {
     354                 :             case CORBA::COMPLETED_YES :
     355                 :             {
     356               0 :                log << "COMPLETED_YES" ;
     357                 :                break ;
     358                 :             }
     359                 :             case CORBA::COMPLETED_NO :
     360                 :             {
     361               0 :                log << "COMPLETED_NO" ;
     362                 :                break ;
     363                 :             }
     364                 :             case CORBA::COMPLETED_MAYBE :
     365                 :             {
     366              14 :                log << "COMPLETED_MAYBE" ;
     367                 :                break ;
     368                 :             }
     369                 :          }
     370                 :          log << std::endl ;
     371                 :       }
     372               0 :    }
     373                 : }
     374                 : 
     375               0 : void spy_port(int input_port, int output_port, std::ostream& log)
     376                 : {
     377                 : 
     378                 : }
     379                 : 
     380               0 : void usage(void)
     381                 : {
     382               0 :    fprintf(stderr, "usage : spy -f file_name -l log_file\n") ;
     383               0 :    fprintf(stderr, "        spy -i port_in -o port_out -l log_file\n") ;
     384               0 :    exit(-1) ;
     385                 : }
     386                 : 
     387              25 : int main(int argc, char* argv[])
     388                 : {
     389                 :    bool use_file = false ;
     390                 :    bool use_ports = false ;
     391                 :    const char *log_file = NULL ;
     392                 :    const char *input_file = NULL ;
     393                 :    int input_port = 0 ;
     394                 :    int output_port = 0 ;
     395                 : 
     396              25 :    if (   (argc != 5)
     397                 :        && (argc != 7) )
     398                 :    {
     399               0 :       usage() ;
     400                 :    }
     401                 : 
     402                 :    // consume spy
     403              25 :    argc -- ;
     404              25 :    argv ++ ;
     405                 : 
     406              75 :    while (argc>0)
     407                 :    {
     408              50 :       if (strcmp("-f", argv[0]) == 0)
     409                 :       {
     410                 :          // consume -f
     411                 :          argc -- ;
     412                 :          argv ++ ;
     413                 : 
     414              25 :          input_file = strdup(argv[0]) ;
     415                 :          use_file = true ;
     416                 : 
     417                 :          // consume input_file
     418              25 :          argc -- ;
     419              25 :          argv ++ ;
     420                 : 
     421              25 :          continue ;
     422                 :       }
     423                 : 
     424              25 :       if (strcmp("-i", argv[0]) == 0)
     425                 :       {
     426                 :          // consume -i
     427                 :          argc -- ;
     428                 :          argv ++ ;
     429                 : 
     430                 :          input_port = atoi(argv[0]) ;
     431                 :          use_ports = true ;
     432                 : 
     433                 :          // consume input_port
     434               0 :          argc -- ;
     435               0 :          argv ++ ;
     436                 : 
     437               0 :          continue ;
     438                 :       }
     439                 : 
     440              25 :       if (strcmp("-o", argv[0]) == 0)
     441                 :       {
     442                 :          // consume -o
     443                 :          argc -- ;
     444                 :          argv ++ ;
     445                 : 
     446                 :          output_port = atoi(argv[0]) ;
     447                 :          use_ports = true ;
     448                 : 
     449                 :          // consume output_port
     450               0 :          argc -- ;
     451               0 :          argv ++ ;
     452                 : 
     453               0 :          continue ;
     454                 :       }
     455                 : 
     456              25 :       if (strcmp("-l", argv[0]) == 0)
     457                 :       {
     458                 :          // consume -l
     459                 :          argc -- ;
     460                 :          argv ++ ;
     461                 : 
     462              25 :          log_file = strdup(argv[0]) ;
     463                 : 
     464                 :          // consume log_file
     465              25 :          argc -- ;
     466              25 :          argv ++ ;
     467                 : 
     468                 :          continue ;
     469                 :       }
     470                 :    }
     471                 : 
     472              25 :    if (use_file && (input_file == NULL))
     473                 :    {
     474               0 :       usage() ;
     475                 :    }
     476                 : 
     477              25 :    if (    use_ports
     478                 :        && (  (input_port == 0)
     479                 :           || (output_port == 0))
     480                 :       )
     481                 :    {
     482               0 :       usage() ;
     483                 :    }
     484                 : 
     485              25 :    if (log_file == NULL)
     486                 :    {
     487               0 :       usage() ;
     488                 :    }
     489                 : 
     490                 :    std::ofstream log ;
     491                 :    log.open(log_file) ;
     492                 : 
     493              25 :    if (use_file)
     494                 :    {
     495              25 :       spy_file(input_file, log) ;
     496                 :    }
     497                 : 
     498                 :    if (use_ports)
     499                 :    {
     500                 :       spy_port(input_port, output_port, log) ;
     501                 :    }
     502                 : 
     503                 :    log.close() ;
     504                 : 
     505                 :    return 0 ;
     506                 : }

Generated by: LTP GCOV extension version 1.4