Erreur de segmentation C++ lors de la tentative de résolution d'une référence CORBA

Question

Lorsque j'essaie de résoudre une référence CORBA, je reçois une erreur de segmentation. Soit je suis aveugle ou j'ai fait quelque chose de vraiment stupide pour que ça ne marche pas. Im en utilisant ACE 5.7.9 TAO 1.7.9 pour CORBA. Vous vous demandez si quelqu'un peut m'aider s'il vous plaît ???

L'erreur de segmentation semble se produire sur la ligne "serverRef = Corba :: Orb :: getOrb(). ResolveObjectReference (myIOR.c_str());" En commentant cette ligne, l'application fonctionnera correctement.

J'ai copié tout le code de dépendance ci-dessous.

bool ClsSend::ServerObject::resolveServerRef() 
{ 
    clssendlog << debug << "In ClsSend::ServerObject::resolveServerRef 1" << endl; 
bool referenceIsUsable = true; 
ostringstream errMsg; 

// Are we dealing with a new reference? 
if (CORBA::is_nil (serverRef.in())) 
{ 
    try { 
    Monitor crit (mutexCoreRef); 

    if (CORBA::is_nil (serverRef.in())) 
    { 
     // Step 1: Resolve the object reference 
     serverRef = Corba::Orb::getOrb().resolveObjectReference <GenericServerWithTransport> (myIOR.c_str()); 

     // Step 2: Ping to check connectivity if reference is not null 
     if (!CORBA::is_nil (serverRef.in())) 
     serverRef->ping(); 
     else 
     { 
     errMsg << "Not registered in naming server."; 
     referenceIsUsable = false; 
     } 
    } 
    } catch (const CORBA::COMM_FAILURE &exc) { 
    errMsg << "CORBA::COMM_FAILURE"; 
    referenceIsUsable = false; 
    setRefNil(); 
    } catch (const NamingException &exc) { 
    errMsg << exc; 
    referenceIsUsable = false; 
    setRefNil(); 
    } catch (...) { 
    errMsg << "Unknown exception"; 
    referenceIsUsable = false; 
    setRefNil(); 
    } 
} 
return referenceIsUsable; 

}

////////////////////////////////////// ///////////////////////////

contour resolveObjectReference,

// Resolve a reference to an object, return a nil object reference if none is bound 
// Specify the name with a delimited string 
template<class T> typename T::_var_type resolveObjectReference(const string &name, 
    char delimiter = '/') 
{ 
    return Corba::resolveObjectReference<T> (orb_.in(), name, delimiter); 
} 

// Resolve a reference to an object, return a nil object reference if none is bound 
// Specify the name with a delimited c-style string 
template<class T> 
typename T::_var_type resolveObjectReference(const CORBA::ORB_ptr & orb, const string &name, char delimiter = '/') 
{ 
    return resolveObjectReference<T> (orb, convertToCosName(name, delimiter)); 
} 

// Resolve a reference to an object, return a nil object reference if none is bound 
// Specify the name with a CosNaming::Name object 
template<class T> 
typename T::_var_type resolveObjectReference(const CORBA::ORB_ptr & orb, const CosNaming::Name &name) 
{ 
    typename T::_var_type typedObj; 
    CORBA::Object_var obj; 

    // Check it is a valid name 
    assert_throw(name.length() > 0); 

    // Try to resolve the object reference 
    try 
    { 
    obj = getNamingContext(orb)->resolve(name); 

    // If the object reference was bound to nil emit a warning but return nil, do not throw 
    if (CORBA::is_nil(obj.in())) 
    { 
     liblog << warning << "Object reference " << toString(name) 
      << " bound to nil in naming service" << endl; 
    } 
    else 
    { 
     typedObj = T::_narrow(obj.in()); 

     // If the object reference narrowed to nil this indicates the object was of the wrong type 
     if (CORBA::is_nil(typedObj.in())) 
     { 
     liblog << error << "Object reference " << toString(name) 
      << " is not of the expected type " << typeid(T).name() << endl; 
     throw NamingException("Object reference narrows to a nil"); 
     } 
    } 
    } 
    catch (const CosNaming::NamingContext::NotFound &exc) 
    { 
    // Object not bound - return nil 
    } 
    return typedObj; 
} 

/////////////////////////////////////////////////////////////////////////// 
// Local function - getNamingContext 
/////////////////////////////////////////////////////////////////////////// 
CosNaming::NamingContext_var getNamingContext(CORBA::ORB_ptr orb) 
{ 
    // Get the initial reference to the naming service 
    CORBA::Object_var nameService; 

    // Try to get a reference to the naming service 
    nameService = orb->resolve_initial_references("NameService"); 
    if (CORBA::is_nil(nameService.in())) 
    { 
    liblog << error << "Name service reference bound to nil" << endl; 
    throw NamingException("Naming service reference bound to nil"); 
    } 

    // cerr << "Name service IOR: " << getORB()->object_to_string (nameService) << endl; 

    // Narrow the reference to the root naming context 
    CosNaming::NamingContext_var rootContext = 
     CosNaming::NamingContext::_narrow(nameService.in()); 
    if (CORBA::is_nil(rootContext.in())) 
    { 
    liblog << error << "Name service reference resolved to nil" << endl; 
    throw NamingException("Naming service reference resolves to nil"); 
    } 
    return rootContext; 
} 

/////////////////////////////////////////////////////////////////////////// 
// Local function - convertToCosName 
/////////////////////////////////////////////////////////////////////////// 
CosNaming::Name convertToCosName(const string &strname, char delimiter) 
{ 
    const char *name = strname.c_str(); 

    CosNaming::Name cosName; 
    cosName.length(count(name, name + strlen(name), delimiter) + 1); 

    size_t index = 0; 
    const char *next = strchr(name, delimiter); 
    if (next == NULL) 
    { 
    next = name + strlen(name); 
    } 
    while (next != NULL) 
    { 
    cosName[index].id = string(name, next).c_str(); 
    cosName[index++].kind = CORBA::string_dup(""); 
    if (*next) 
    { 
     name = next + 1; 
     next = strchr(name, delimiter); 
     if (next == NULL) 
     { 
     next = name + strlen(name); 
     } 
    } 
    else 
    { 
     next = NULL; 
    } 
    } 
    return cosName; 
} 

Answer 1

Dang, qui est beaucoup de code dans un question ...

Mon prochain regard dans un cas comme celui-ci serait de diviser ce offendi ligne ng:

serverRef = Corba::Orb::getOrb().resolveObjectReference (myIOR.c_str());

en autant de parties que possible, et essayer de voir quelle partie se plante. Après cela, essayez de voir ce qui ne va pas avec cette partie.