LTP GCOV extension - code coverage report
Current view: directory - src/cpp/prod/CORBA - YASingleServerOrb.cpp
Test: YAORB-0.2.info
Date: 2006-02-27 Instrumented lines: 168
Code covered: 79.2 % Executed lines: 133

       1                 : //=============================================================================
       2                 : // File <$/src/cpp/prod/CORBA/YASingleServerOrb.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_time.h"
      25                 : #include "src/cpp/prod/port/port_stdc.h"
      26                 : #include "src/cpp/prod/port/port_socket.h"
      27                 : #include "src/cpp/prod/port/port_unistd.h"
      28                 : 
      29                 : #include <sys/types.h>
      30                 : #include <sys/select.h>
      31                 : #include <rpc/types.h>
      32                 : #include <stdio.h>
      33                 : 
      34                 : #include <yaorb/CORBA.h>
      35                 : #include <yaorb/YAORB.h>
      36                 : 
      37                 : #include "src/cpp/prod/CORBA/YASingleServerOrb.h"
      38                 : #include "src/cpp/prod/CORBA/YAConnection.h"
      39                 : #include "src/cpp/prod/boot/boot.h"
      40                 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
      41                 : #include "src/cpp/prod/tool/Assert.h"
      42                 : #include "src/cpp/prod/protocol/iop/iop.h"
      43                 : #include "src/cpp/prod/protocol/giop/message_header.h"
      44                 : #include "src/cpp/prod/protocol/giop/request_header_12.h"
      45                 : #include "src/cpp/prod/protocol/cdr/cdr_memory.h"
      46                 : #include "src/cpp/prod/poa/YaObjectKey.h"
      47                 : 
      48                 : // Max number of pending connect request on the _listning socket.
      49                 : const int NUMBER_OF_CONNECTIONS = 5 ;
      50                 : 
      51                 : //==============================================================================
      52                 : // YASingleServerORB : Server ORB, single process.
      53                 : //==============================================================================
      54                 : 
      55               1 : YASingleServerOrb::YASingleServerOrb(const String & confFileName)
      56                 :  : YAServerOrb(confFileName),
      57               1 :    _connections()
      58                 : {
      59               0 : }
      60                 : 
      61               0 : YASingleServerOrb::~YASingleServerOrb()
      62                 : {
      63               0 : }
      64                 : 
      65                 : CORBA::Boolean
      66              16 : YASingleServerOrb::workPending(void)
      67                 : {
      68                 :    int rc ;
      69                 :    fd_set readFDS ;
      70                 :    fd_set writeFDS ;
      71                 :    fd_set exceptFDS ;
      72                 :    struct timeval delay ;
      73                 :    int soc ;
      74                 :    int maxFD = 0 ;
      75                 : 
      76                 :    // See if a new connection request is pending
      77              16 :    FD_ZERO(& readFDS) ;
      78              16 :    FD_SET(_listningSocket, & readFDS) ;
      79              16 :    maxFD = _listningSocket ;
      80                 : 
      81                 :    YAConnectionLstIt it(_connections) ;
      82                 :    YAConnection *con = NULL ;
      83                 : 
      84              36 :    while (it.GetNext())
      85                 :    {
      86                 :       con = it.GetItem() ;
      87                 : 
      88                 :       // For each connection, see if a new request is pending.
      89               4 :       soc = con->GetSocket() ;
      90               4 :       FD_SET(soc, & readFDS) ;
      91                 : 
      92               4 :       if (soc > maxFD)
      93                 :       {
      94                 :          maxFD = soc ;
      95                 :       }
      96                 :    }
      97                 : 
      98              16 :    FD_ZERO(& writeFDS) ;
      99              16 :    FD_ZERO(& exceptFDS) ;
     100              16 :    delay.tv_sec = 0 ;
     101              16 :    delay.tv_usec = 0 ;
     102              16 :    maxFD ++ ;
     103                 :    
     104              16 : fprintf(stderr, "YASingleServerORB::workPending before select\n") ;
     105              16 : fflush(stderr) ;
     106                 : 
     107              16 :    rc = select(maxFD, & readFDS, & writeFDS, & exceptFDS, & delay) ;
     108                 : 
     109              16 : fprintf(stderr, "YASingleServerORB::workPending after select\n") ;
     110              16 : fflush(stderr) ;
     111                 : 
     112                 :    if (rc >0)
     113                 :    {
     114                 :       return true ;
     115                 :    }
     116                 :    else
     117                 :    {
     118                 :       return false ;
     119                 :    }
     120                 : }
     121                 : 
     122               4 : void YASingleServerOrb::performWork(void)
     123                 : {
     124                 :    int rc ;
     125                 :    fd_set readFDS ;
     126                 :    fd_set writeFDS ;
     127                 :    fd_set exceptFDS ;
     128                 :    struct timeval delay ;
     129                 :    int soc ;
     130                 :    int maxFD = 0 ;
     131                 : 
     132                 :    // See if a new connection request is pending
     133               4 :    FD_ZERO(& readFDS) ;
     134               4 :    FD_SET(_listningSocket, & readFDS) ;
     135               4 :    maxFD = _listningSocket ;
     136                 : 
     137               4 :    YAConnectionLstIt it(_connections) ;
     138                 :    YAConnection *con = NULL ;
     139                 : 
     140              12 :    while (it.GetNext())
     141                 :    {
     142                 :       con = it.GetItem() ;
     143                 : 
     144                 :       // For each connection, see if a new request is pending.
     145               4 :       soc = con->GetSocket() ;
     146               4 :       FD_SET(soc, & readFDS) ;
     147                 : 
     148               4 :       if (soc > maxFD)
     149                 :       {
     150                 :          maxFD = soc ;
     151                 :       }
     152                 :    }
     153                 : 
     154               4 :    FD_ZERO(& writeFDS) ;
     155               4 :    FD_ZERO(& exceptFDS) ;
     156               4 :    delay.tv_sec = 0 ;
     157               4 :    delay.tv_usec = 0 ;
     158               4 :    maxFD ++ ;
     159                 :    
     160               4 : fprintf(stderr, "YASingleServerORB::performWork before select\n") ;
     161               4 : fflush(stderr) ;
     162                 : 
     163               4 :    rc = select(maxFD, & readFDS, & writeFDS, & exceptFDS, & delay) ;
     164                 : 
     165               4 : fprintf(stderr, "YASingleServerORB::performWork after select\n") ;
     166               4 : fflush(stderr) ;
     167                 : 
     168               4 :    if (rc < 0)
     169                 :    {
     170               0 :       perror("select") ;
     171               0 :       NON_DEV("Error in select") ;
     172                 :    }
     173                 : 
     174               4 :    if (rc == 0)
     175                 :    {
     176                 :       return ;
     177                 :    }
     178                 : 
     179                 :    YAConnectionLstIt it2(_connections) ;
     180                 : 
     181               8 :    while (it2.GetNext())
     182                 :    {
     183                 :       con = it2.GetItem() ;
     184                 : 
     185                 :       // For each connection, process pending requests
     186               4 :       soc = con->GetSocket() ;
     187               4 :       if (FD_ISSET(soc, & readFDS))
     188                 :       {
     189               4 :          handleExistingConnection(con) ;
     190                 :       }
     191                 :    }
     192                 : 
     193                 :    // Process pending connection requests
     194               4 :    if (FD_ISSET(_listningSocket, & readFDS))
     195                 :    {
     196                 :       YAConnection *server = NULL ;
     197                 :       int connectedSoc ;
     198                 :       struct sockaddr_in con ;
     199               2 :       socklen_t len = sizeof(con) ;
     200                 : 
     201                 :       connectedSoc = accept(
     202                 :          _listningSocket,
     203                 :          (struct sockaddr*) & con,
     204               2 :          & len) ;
     205               2 :       if (connectedSoc<0)
     206                 :       {
     207               0 :          perror("accept") ;
     208               0 :          NON_DEV("accept failed") ;
     209                 :       }
     210                 : 
     211               2 :       server = new YAConnection(connectedSoc) ;
     212               2 :       handleNewConnection(server) ;
     213                 :    }
     214                 : }
     215                 : 
     216               1 : void YASingleServerOrb::shutdown(CORBA::Boolean waitForCompletion)
     217                 : {
     218               1 :    _state = OrbState_Shutdown ;
     219                 : 
     220               1 :    NON_DEV("shutdown : wait flag") ;
     221                 : }
     222                 : 
     223               1 : void YASingleServerOrb::run(void)
     224                 : {
     225              18 :    for (; _state == OrbState_Running ;)
     226                 :    {
     227              16 :       if (workPending() == true)
     228                 :       {
     229               4 :          performWork() ;
     230                 :       }
     231                 :       else
     232                 :       {
     233              12 :          sleep(10) ;
     234                 :       }
     235                 :    }
     236                 : }
     237                 : 
     238                 : void
     239               2 : YASingleServerOrb::handleNewConnection(YAConnection *con)
     240                 : {
     241                 :    _connections.addTail(con) ;
     242                 : }
     243                 : 
     244                 : void
     245               4 : YASingleServerOrb::handleExistingConnection(YAConnection *con)
     246                 : {
     247               4 :    Buffer request ;
     248               4 :    Buffer reply ;
     249                 :    bool mustDrop = false ;
     250                 :    bool mustReply = true ;
     251                 :    bool mustProcess = true ;
     252                 : 
     253               4 :    Com *com = con->GetCom() ;
     254                 : 
     255                 :    try
     256                 :    {
     257               4 :       com->ReadBuffer(request) ;
     258                 :    }
     259               0 :    catch (CORBA::MARSHAL & ex)
     260                 :    {
     261                 :       // Client sent a buggous GIOP Header
     262                 :       mustDrop = true ;
     263                 :       mustProcess = false ;
     264                 :    }
     265               2 :    catch (CORBA::COMM_FAILURE & ex)
     266                 :    {
     267                 :       mustDrop = true ;
     268                 :       mustReply = false ;
     269                 :       mustProcess = false ;
     270                 :    }
     271                 : 
     272               2 :    if (mustReply == true)
     273                 :    {
     274               2 :       if (mustProcess == true)
     275                 :       {
     276               2 :          handleRequest(request, reply) ;
     277                 :       }
     278                 :       else
     279                 :       {
     280               0 :          NON_DEV("error reply GIOP 1.2") ;
     281                 :       }
     282                 : 
     283                 :       try
     284                 :       {
     285               2 :          com->WriteBuffer(reply) ;
     286                 :       }
     287               2 :       catch (...)
     288                 :       {
     289               2 :          NON_DEV("Reply failed") ;
     290                 :       }
     291                 :    }
     292                 : 
     293               2 :    if (mustDrop == true)
     294                 :    {
     295               2 :       dropConnection(con) ;
     296               0 :    }
     297                 : }
     298                 : 
     299                 : void
     300                 : YASingleServerOrb::dropConnection(
     301               2 :    YAConnection *con)
     302                 : {
     303                 :    _connections.removeObject(con) ;
     304               2 :    con->Close() ;
     305               2 :    delete con ;
     306                 : }
     307                 : 
     308                 : void
     309                 : YASingleServerOrb::handleRequest(
     310                 :    Buffer & request,
     311               2 :    Buffer & reply)
     312                 : {
     313                 :    CORBA::Octet *data = NULL ;
     314                 :    unsigned int size = 0 ;
     315                 : 
     316               2 :    data = request.GetData() ;
     317               2 :    size = request.GetSize() ;
     318                 : 
     319               2 :    GIOPMessage giop ;
     320               2 :    CDRMemory cdrs(data, size, YAORB::CDR_READ) ;
     321               2 :    CORBA::Octet version_major = 0 ;
     322                 :    CORBA::Octet version_minor = 0 ;
     323                 : 
     324                 :    try
     325                 :    {
     326               2 :       giop.cdr_header(& cdrs) ;
     327               2 :       GIOPMessageHeader & header = giop.GetHeader() ;
     328                 : 
     329               2 :       version_major = header.GetMajor() ;
     330               2 :       version_minor = header.GetMinor() ;
     331                 :    }
     332               0 :    catch (CORBA::SystemException & ex)
     333                 :    {
     334               0 :       NON_DEV("reply with error in GIOP 1.2") ;
     335                 :    }
     336                 : 
     337                 :    try
     338                 :    {
     339               2 :       giop.cdr_body(& cdrs) ;
     340                 :    }
     341               0 :    catch (CORBA::SystemException & ex)
     342                 :    {
     343               0 :       NON_DEV("reply with error in sender GIOP version") ;
     344                 :    }
     345                 : 
     346               2 :    if (version_major != 1)
     347                 :    {
     348               0 :       NON_DEV("major") ;
     349                 :    }
     350                 : 
     351               2 :    switch(version_minor)
     352                 :    {
     353                 :       case 0 :
     354                 :       {
     355               0 :          handleRequest10(giop, & cdrs, reply) ;
     356                 :          break ;
     357                 :       }
     358                 :       case 1 :
     359                 :       {
     360               0 :          handleRequest11(giop, & cdrs, reply) ;
     361                 :          break ;
     362                 :       }
     363                 :       case 2 :
     364                 :       {
     365               2 :          handleRequest12(giop, & cdrs, reply) ;
     366                 :          break ;
     367                 :       }
     368                 :       default :
     369                 :       {
     370               0 :          handleRequest1X(giop, & cdrs, reply) ;
     371                 :          break ;
     372                 :       }
     373               0 :    }
     374                 : }
     375                 : 
     376                 : void
     377                 : YASingleServerOrb::handleRequest10(
     378                 :    GIOPMessage & giop,
     379                 :    YAORB::CDR *cdrs,
     380               0 :    Buffer & reply)
     381                 : {
     382               0 :    NON_DEV("request 1.0") ;
     383                 : }
     384                 : 
     385                 : void
     386                 : YASingleServerOrb::handleRequest11(
     387                 :    GIOPMessage & giop,
     388                 :    YAORB::CDR *cdrs,
     389               0 :    Buffer & reply)
     390                 : {
     391               0 :    NON_DEV("request 1.1") ;
     392                 : }
     393                 : 
     394                 : void
     395                 : YASingleServerOrb::handleRequest12(
     396                 :    GIOPMessage & giop,
     397                 :    YAORB::CDR *cdrs,
     398               2 :    Buffer & reply)
     399                 : {
     400               2 :    GIOPMessageHeader & header = giop.GetHeader() ;
     401               2 :    GIOP_12_MessageType_e msgType = header.GetGIOP12MessageType() ;
     402                 : 
     403               2 :    switch(msgType)
     404                 :    {
     405                 :       case GIOPRequest_type :
     406                 :       {
     407               2 :          dispatchRequest12(giop, cdrs, reply) ;
     408                 :          break ;
     409                 :       }
     410                 :       case GIOPReply_type :
     411                 :       {
     412               0 :          NON_DEV("reply 1.2") ;
     413                 :          break ;
     414                 :       }
     415                 :       case GIOPCancelRequest_type :
     416                 :       {
     417               0 :          NON_DEV("cancel request 1.2") ;
     418                 :          break ;
     419                 :       }
     420                 :       case GIOPLocateRequest_type :
     421                 :       {
     422               0 :          NON_DEV("locate request 1.2") ;
     423                 :          break ;
     424                 :       }
     425                 :       case GIOPLocateReply_type :
     426                 :       {
     427               0 :          NON_DEV("locate reply 1.2") ;
     428                 :          break ;
     429                 :       }
     430                 :       case GIOPCloseConnection_type :
     431                 :       {
     432               0 :          NON_DEV("close connection 1.2") ;
     433                 :          break ;
     434                 :       }
     435                 :       case GIOPMessageError_type :
     436                 :       {
     437               0 :          NON_DEV("message error 1.2") ;
     438                 :          break ;
     439                 :       }
     440                 :       case GIOPFragment_type :
     441                 :       {
     442               0 :          NON_DEV("fragment 1.2") ;
     443                 :          break ;
     444                 :       }
     445                 :    }
     446                 : }
     447                 : 
     448                 : void
     449                 : YASingleServerOrb::handleRequest1X(
     450                 :    GIOPMessage & giop,
     451                 :    YAORB::CDR *cdrs,
     452               0 :    Buffer & reply)
     453                 : {
     454               0 :    NON_DEV("request 1.X") ;
     455                 : }
     456                 : 
     457                 : void
     458                 : YASingleServerOrb::dispatchRequest12(
     459                 :    GIOPMessage & giop,
     460                 :    YAORB::CDR *cdrs,
     461               2 :    Buffer & reply)
     462                 : {
     463               2 :    GIOP12RequestHeader * req = giop.GetRequest() ;
     464                 : 
     465               2 :    CORBA::ULong reqId = req->GetRequestId() ;
     466               2 :    CORBA::Octet reqFlags = req->GetResponseFlags() ;
     467               2 :    const TargetAddress & reqTarget = req->GetTarget() ;
     468               2 :    const char* reqOperation = req->GetOperation() ;
     469                 : 
     470               2 : fprintf(stderr, "ReqId = %d\n", reqId) ;
     471               2 : fprintf(stderr, "ReqFlags = %d\n", reqFlags) ;
     472               2 : fprintf(stderr, "ReqOperation = %s\n", reqOperation) ;
     473                 : 
     474                 :    // PortableServer::ServantBase *servant = NULL ;
     475                 :    // const YAORB::RepositoryID *repId = NULL ;
     476                 :    YaObjectKey *objectKey = NULL ;
     477               2 :    objectKey = findObjectKey(reqTarget) ;
     478                 : 
     479               2 :    PortableServer::POA_ptr poa = PortableServer::POA::_nil() ;
     480                 : 
     481               2 :    if (objectKey != NULL)
     482                 :    {
     483               2 :       const char * poaName = objectKey->GetPoaName() ;
     484                 : 
     485               2 : fprintf(stderr, "PoaName = %s\n", poaName) ;
     486                 : 
     487               2 :       poa = findPOA(poaName) ;
     488                 :    }
     489                 : 
     490                 : 
     491               2 :    NON_DEV("request 1.2") ;
     492                 : }
     493                 : 
     494                 : PortableServer::POA_ptr
     495                 : YASingleServerOrb::findPOA(
     496               2 :    const char* poaName)
     497                 : {
     498               2 :    PortableServer::POA_ptr result = PortableServer::POA::_nil() ;
     499                 : 
     500               2 :    int len = strlen(poaName) ;
     501               4 :    char * parseBuf = new char[len+1] ;
     502               2 :    strcpy(parseBuf, poaName) ;
     503               2 :    char* tmp = NULL ;
     504                 :    char * tok = NULL ;
     505                 : 
     506               2 :    tok = strtok_r(parseBuf, "/", & tmp) ;
     507                 : 
     508               2 :    if (strcmp(tok, "RootPOA") == 0)
     509                 :    {
     510               2 :       result = _rootPOA ;
     511                 : 
     512               2 :       tok = strtok_r(NULL, "/", & tmp) ;
     513                 : 
     514               4 :       while (tok != NULL)
     515                 :       {
     516               2 :          if ( CORBA::is_nil(result) == false)
     517                 :          {
     518                 :             result = result->find_POA(
     519                 :                tok,       // find the child POA
     520               2 :                false) ;   // do not activate it
     521                 :          }
     522                 : 
     523               2 :          tok = strtok_r(NULL, "/", & tmp) ;
     524                 :       }
     525                 :    }
     526                 : 
     527               2 :    delete [] parseBuf ;
     528                 : 
     529                 :    return result ;
     530                 : }
     531                 : 
     532                 : YaObjectKey *
     533                 : YASingleServerOrb::findObjectKey(
     534               2 :    const TargetAddress & target)
     535                 : {
     536                 :    YaObjectKey * key = NULL ;
     537                 : 
     538               2 :    switch(target.GetAddressingDisposition())
     539                 :    {
     540                 :       case KeyAddr :
     541                 :       {
     542                 :          GIOPEncapsulation *encap = NULL ;
     543                 : 
     544               2 :          encap = target.GetObjectKey() ;
     545               2 :          key = new YaObjectKey() ;
     546               2 :          key->read(*encap) ;
     547               2 :          break ;
     548                 :       }
     549                 :       case ProfileAddr :
     550                 :       {
     551               0 :          NON_DEV("find key in profile") ;
     552               0 :          break ;
     553                 :       }
     554                 :       case ReferenceAddr :
     555                 :       {
     556               0 :          NON_DEV("find key in reference") ;
     557                 :          break ;
     558                 :       }
     559                 :    }
     560                 : 
     561                 :    return key ;
     562                 : }
     563                 : 

Generated by: LTP GCOV extension version 1.4