Memory leak fixes.

[libplpbus.git] / src / plpbus / OrbServerImpl.cc

diff --git a/src/plpbus/OrbServerImpl.cc b/src/plpbus/OrbServerImpl.cc
index 3fa74a005dd95e1e05e5607617d68c8dcd4ddd2a..6e097486f5e7571effb81d332957bbed22393a3c 100644 (file)
--- a/src/plpbus/OrbServerImpl.cc
+++ b/src/plpbus/OrbServerImpl.cc
@@ -36,7 +36,7 @@ OrbServerImpl::~OrbServerImpl()
 void OrbServerImpl::send_message_and_request_response(OrbClient_ptr response_listener_param,
                                                const char* msg_req)
 {
-       char    *msg_rsp;
+       const char *msg_rsp;
 
        msg_rsp = NULL;
        if (CORBA::is_nil(response_listener_param) == false) {
@@ -56,8 +56,8 @@ void OrbServerImpl::send_message_and_request_response(OrbClient_ptr response_lis
 }
 
 char *OrbServerImpl::send_message_and_wait_response(const char* msg_req_param, ::CORBA::Long& err_flg) {
-       char    *msg_rsp;
-       char    *ret_val;
+       const char      *msg_rsp;
+       char            *ret_val;
 
        err_flg = 0;
        msg_rsp = NULL;
@@ -79,6 +79,7 @@ void OrbServerImpl::send_dataitem_message_and_request_response(OrbClient_ptr res
        BusMessage              *msg_req;
        BusMessage              *msg_rsp;
        DataItemSequence        *seq;
+       int                     err_flg;
 
        if (CORBA::is_nil(response_listener_param) == false) {
                if (_listener != NULL) {
@@ -87,11 +88,15 @@ void OrbServerImpl::send_dataitem_message_and_request_response(OrbClient_ptr res
                        log_debug("msg_req:\n");
                        msg_req->printout();
                        msg_rsp = NULL;
-                       _listener->request_received(msg_req, &msg_rsp);
+                       err_flg = 0;
+                       msg_rsp = new BusMessage(msg_req->get_type(&err_flg));
+                       _listener->request_received(msg_req, msg_rsp);
                        seq     = (DataItemSequence *)msg_rsp->_dataItemSeq;
                        log_debug("msg_rsp length: %ld\n", seq->length());
                        msg_rsp->printout();
                        response_listener_param->receive_response_dataitem_sequence(*seq);
+                       delete(msg_req);
+                       delete(msg_rsp);
                }
                else {
                        log_error("send_dataitem_message_and_request_response() error, server_callback == NULL\n");
@@ -104,11 +109,13 @@ CORBA::Long OrbServerImpl::send_dataitem_message_and_wait_response(const DataIte
        BusMessage              *msg_req;
        BusMessage              *msg_rsp;
        DataItemSequence        *seq;
+       int                     err_flg;
 
        seq     = NULL;
        msg_rsp = NULL;
        msg_req = new BusMessageInternal(req_seq_param);
-       _listener->request_received(msg_req, &msg_rsp);
+       msg_rsp = new BusMessage(msg_req->get_type(&err_flg));
+       _listener->request_received(msg_req, msg_rsp);
        if (msg_rsp != NULL) {
                seq     = (DataItemSequence *)msg_rsp->_dataItemSeq;
        }
@@ -135,7 +142,7 @@ void OrbServerImpl::add_event_listener(OrbClient_ptr client_param,
                srvr_thread->start();
        }
        else {
-               cerr << "Failed to add event listener, listener NULL.\n";
+               log_error("Failed to add event listener, listener NULL.\n");
        }
 }
 
@@ -143,15 +150,18 @@ void OrbServerImpl::shutdown()
 {
        omni_mutex_lock sync(server_thread_mutex);
        if (is_shutdown_pending() == 0) {
-               cout << "shutdown request received!" << endl;
+               log_debug("shutdown request received!\n");
                // Tell the servers to exit, and wait for them to do so.
                _shutdown_pending       = 1;
                while(_server_thread_count > 0) {
-                       server_thread_shutdown_signal.wait();
+                       server_thread_shutdown_signal.timedwait(5, 0);
+                       log_debug("signal received\n");
                }
                // Shutdown the ORB (but do not wait for completion).  This also
                // causes the main thread to unblock from CORBA::ORB::run().
+               log_debug("calling orb shutdown\n");
                _orb->shutdown(0);
+               log_debug("orb shutdown called\n");
        }
 }
 
@@ -169,7 +179,7 @@ int OrbServerImpl::init() {
                retVal  = 0;
        }
        else {
-               cout << "init() failed"  << endl;
+               log_error("init() failed\n");
        }
        return retVal;
 }
@@ -194,12 +204,12 @@ int OrbServerImpl::launch(const char *server_name)
                                                        server_name,
                                                        CONST_CONTEXT_KIND__PLPBUS);
                if (ok_flg == true) {
-                       cout << "Registered to naming service: " << server_name << endl;
+                       log_debug("Registered to naming service: %s\n", server_name);
                        _orb->run();
                        ret_val = 0;
                }
                else {
-                       cout << "Failed to register to naming service: " << server_name << endl;
+                       log_error("Failed to register to naming service: %s\n", server_name);
                }
        }
        return ret_val;
@@ -232,7 +242,7 @@ PortableServer::POA_var OrbServerImpl::create_poa(CORBA::ORB_var orb) {
                }
        }
        else {
-               cerr << "Failed to create RootPOA." << endl;
+               log_error("Failed to create RootPOA.\n");
        }
        return ret_val;
 }
@@ -334,23 +344,23 @@ bool OrbServerImpl::bind_naming_context_and_service(CosNaming::NamingContext_var
                         * service existed already for the naming context with similar description.
                         * Replace the existing one with a new one.
                         */
-                       cout << "service " << service_name_param << " existed, replacing it." << endl;
+                       log_warning("service %s exist, replacing it\n", service_name_param);
                        service_context_param->rebind(context_data, service_ref_param);
                        retVal  = true;
                }
        }
        catch (CosNaming::NamingContext::InvalidName&) {
-               cerr << "Could not register service to name server, invalid service name." << endl;
+               log_error("Could not register service to name server, invalid service name.\n");
        }
        catch (CosNaming::NamingContext::NotFound&) {
-               cerr << "Could not register service to name server, service object reference is invalid." << endl;
+               log_error("Could not register service to name server, service object reference is invalid.\n");
        }
        catch (CosNaming::NamingContext::CannotProceed&) {
                // This should not happen!
-               cerr << "Could not register service to name server, unknown error." << endl;
+               log_error("Could not register service to name server, unknown error.\n");
        }
        catch(CORBA::SystemException& ex) {
-               cerr << "Could not register service to name server, unknown error." << endl;
+               log_error("Could not register service to name server, unknown error.\n");
        }
        return retVal;
 }
@@ -360,9 +370,8 @@ int OrbServerImpl::add_server_listener(IServerListener *listener_param)
        int     retVal;
 
        retVal          = 0;
-       cout << "register_request_received_callback() started"  << endl;
+       log_debug("register_request_received_callback() started\n");
        _listener       = listener_param;
-       cout << "register_callback() done"  << endl;
        return retVal;
 }
 
@@ -371,15 +380,20 @@ int OrbServerImpl::is_shutdown_pending() {
 }
 
 void OrbServerImpl::server_thread_closed() {
-       bool send_signal = false;
+       bool    send_signal;
 
+       log_debug("server_thread_closed() started\n");
+       send_signal = false;
        server_thread_mutex.lock();
+       log_debug("server_thread_closed(), server_thread_count: %d\n", _server_thread_count);
        _server_thread_count--;
        if (_server_thread_count == 0) {
                send_signal     = true;
        }
        server_thread_mutex.unlock();
        if (send_signal == true) {
+               log_debug("server_thread_closed(), sending signal\n");
                server_thread_shutdown_signal.signal();
+               log_debug("server_thread_closed(), signal send\n");
        }
 }