Ошибка сегментации C ++ При попытке разрешить ссылку CORBA

Question

Когда я пытаюсь разрешить ссылку CORBA, я получаю ошибку сегментации. Либо я слепой, либо я сделал что-то действительно глупо для этого не работать. Я использую ACE 5.7.9 Tao 1.7.9 для CORBA. Удивительно, если кто-нибудь может помочь мне, пожалуйста ???

Ошибка сегментации, похоже, происходит на линии «ServerRef = Corba :: orb :: getorb (). ResolveObjectReference (myior.c_str ());" Как комментировать эту строку приведет к тому, что приложение будет работать нормально.

Я скопировал весь зависимый код ниже.

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;

}

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

Решитель -objectReference Outline,

// 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

Черт, это много кода в вопросе ...

Мой следующий поиск в том случае, как это было бы разбито, что оскорбительная линия:

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

В столько частей, насколько это возможно, и попытайтесь увидеть, какая часть падает. После этого постарайтесь посмотреть, что не так с той одной частью.