comandos - corba java

Error de segmentación(núcleo volcado) en el lado del servidor en la aplicación CORBA C++/Java

Question

Tengo ese código:

interface Employee
{
    string getLastname();
};

#include "Employee.idl"

interface Work
{
    Employee getEmployee(in short id);
};

Archivos de servidor:

#include "Employee.hh"

class EmployeeImpl : public POA_Employee
{
    private:
        char* lastname;
        int id;

    public:
        EmployeeImpl(const char* lastname, int id);
        char* getLastname();
};

#include "EmployeeImpl.h"

EmployeeImpl::EmployeeImpl(const char* lastname, int id)
{
    this->lastname = const_cast<char*>(lastname);
    this->id = id;
}

char* EmployeeImpl::getLastname()
{
    return this->lastname;
}

#include "Work.hh"
#include <vector>
#include "EmployeeImpl.h"
using namespace std;

class WorkImpl : public POA_Work
{
    private:
        vector<EmployeeImpl> employees;

    public:
        WorkImpl();
        Employee_ptr getEmployee(::CORBA::Short id);
};

#include "WorkImpl.h"

 WorkImpl::WorkImpl()
 {
    EmployeeImpl ei1("Doe", 1);
    EmployeeImpl ei2("Smith", 2);
    EmployeeImpl ei3("Brown", 3);

    employees.push_back(ei1);
    employees.push_back(ei2);
    employees.push_back(ei3);
 }

Employee_ptr WorkImpl::getEmployee(::CORBA::Short id)
{
    return employees[id]._this();
}

Archivos de cliente:

import java.util.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import java.io.*;

public class Client
{
    public static void main(String [] args)
    {
     try
     {
        org.omg.CORBA.ORB clientORB = org.omg.CORBA.ORB.init(args, null);

        if (clientORB == null)
        {
            System.out.println("Problem while creating ORB");
            System.exit(1);
        }

        org.omg.CORBA.Object objRef = clientORB.resolve_initial_references("NameService");
        NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);

        Work work = WorkHelper.narrow(ncRef.resolve_str("WorkService"));
        Employee e = work.getEmployee((short)1);
        System.out.println(e.getLastname());
            e = work.getEmployee((short)2);
            System.out.println(e.getLastname());
            e = work.getEmployee((short)3);
            System.out.println(e.getLastname());

        }catch(Exception e){ System.out.println(e.getMessage()); }
    }
}

cuando ejecuto el Servidor, y luego el cliente, en el lado del cliente veo:

Herrero

en lugar de:

Doe
Smith
Brown

y cuando el cliente recibió el mensaje, en el lado del servidor veo:

falla de segmentación (hacer frente a dumping)

y el servidor se bloquea. ¿Qué pasa con mi código chicos? Uso omniORB e idlj en Kubuntu, y g ++ y javac para compilar mis archivos.

Aquí está todo mi proyecto: http://www44.zippyshare.com/v/60244821/file.html

Answer 1

No está siguiendo las reglas de mapeo de IDL a C ++ sobre el paso de parámetros. En particular, en el servidor:

char* EmployeeImpl::getLastname()
{
    return this->lastname;   // this is the problem
}

CORBA::string_free devolver la memoria asignada dinámicamente porque el código del esqueleto va a desasignarla (con CORBA::string_free ) después de que la CORBA::string_free por el cable al cliente.

Esto debería ser:

char* EmployeeImpl::getLastname()
{
    return CORBA::string_dup(this->lastname);
}

Todo esto se explica en el libro de Henning & Vinowski Advanced CORBA Programming with C ++ .

El otro problema que tiene es que está indexando en su vector con un índice basado en 1. Pero el vector usa un esquema de índice basado en 0. Para solucionarlo, cambie sus llamadas de cliente o cambie la implementación de su servidor a algo como esto:

Employee_ptr WorkImpl::getEmployee(::CORBA::Short id)
{
    if (id >= 1 && id <= employees.size())
    { 
       return employees[id - 1]._this();  // convert to 0-based indexing
    }
    else
    {
       // throw some type of exception
    }
}