diff options
Diffstat (limited to 'src/components/transport_manager/src')
24 files changed, 725 insertions, 656 deletions
diff --git a/src/components/transport_manager/src/bluetooth/bluetooth_connection_factory.cc b/src/components/transport_manager/src/bluetooth/bluetooth_connection_factory.cc index 421104422b..02224baf4e 100644 --- a/src/components/transport_manager/src/bluetooth/bluetooth_connection_factory.cc +++ b/src/components/transport_manager/src/bluetooth/bluetooth_connection_factory.cc @@ -1,4 +1,4 @@ -/** +/* * \file bluetooth_connection_factory.cc * \brief BluetoothConnectionFactory class source file. * diff --git a/src/components/transport_manager/src/bluetooth/bluetooth_device.cc b/src/components/transport_manager/src/bluetooth/bluetooth_device.cc index 1a47f6c7ff..c8061a7ac5 100644 --- a/src/components/transport_manager/src/bluetooth/bluetooth_device.cc +++ b/src/components/transport_manager/src/bluetooth/bluetooth_device.cc @@ -33,6 +33,13 @@ #include "transport_manager/bluetooth/bluetooth_device.h" +#include <bluetooth/bluetooth.h> +#include <bluetooth/hci.h> +#include <bluetooth/hci_lib.h> +#include <bluetooth/sdp.h> +#include <bluetooth/sdp_lib.h> +#include <bluetooth/rfcomm.h> + #include <errno.h> #include <sys/types.h> #include <sys/socket.h> diff --git a/src/components/transport_manager/src/bluetooth/bluetooth_device_scanner.cc b/src/components/transport_manager/src/bluetooth/bluetooth_device_scanner.cc index 547dc463b2..29be3cd219 100644 --- a/src/components/transport_manager/src/bluetooth/bluetooth_device_scanner.cc +++ b/src/components/transport_manager/src/bluetooth/bluetooth_device_scanner.cc @@ -1,4 +1,4 @@ -/** +/* * \file bluetooth_device_scanner.cc * \brief BluetoothDeviceScanner class header file. * @@ -52,6 +52,7 @@ #include "transport_manager/bluetooth/bluetooth_device.h" #include "utils/logger.h" +#include "utils/threads/thread.h" namespace transport_manager { namespace transport_adapter { @@ -117,44 +118,45 @@ BluetoothDeviceScanner::BluetoothDeviceScanner( }; sdp_uuid128_create(&smart_device_link_service_uuid_, smart_device_link_service_uuid_data); - thread_ = threads::CreateThread("BT Device Scaner", new BluetoothDeviceScannerDelegate(this)); + thread_ = threads::CreateThread("BT Device Scaner", + new BluetoothDeviceScannerDelegate(this)); } BluetoothDeviceScanner::~BluetoothDeviceScanner() { + thread_->join(); + delete thread_->delegate(); + threads::DeleteThread(thread_); } bool BluetoothDeviceScanner::IsInitialised() const { - return thread_->is_running(); + return thread_ && thread_->is_running(); } void BluetoothDeviceScanner::UpdateTotalDeviceList() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); DeviceVector devices; devices.insert(devices.end(), paired_devices_with_sdl_.begin(), paired_devices_with_sdl_.end()); devices.insert(devices.end(), found_devices_with_sdl_.begin(), found_devices_with_sdl_.end()); controller_->SearchDeviceDone(devices); - LOG4CXX_TRACE(logger_, "exit"); } void BluetoothDeviceScanner::DoInquiry() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); const int device_id = hci_get_route(0); if (device_id < 0) { LOG4CXX_INFO(logger_, "HCI device is not available"); shutdown_requested_ = true; controller_->SearchDeviceFailed(SearchDeviceError()); - LOG4CXX_TRACE(logger_, "exit. Condition: device_id < 0"); return; } int device_handle = hci_open_dev(device_id); if (device_handle < 0) { controller_->SearchDeviceFailed(SearchDeviceError()); - LOG4CXX_TRACE(logger_, "exit. Condition: device_handle < 0"); return; } @@ -195,6 +197,7 @@ void BluetoothDeviceScanner::DoInquiry() { &found_devices_with_sdl_); } UpdateTotalDeviceList(); + controller_->FindNewApplicationsRequest(); close(device_handle); delete[] inquiry_info_list; @@ -203,8 +206,6 @@ void BluetoothDeviceScanner::DoInquiry() { LOG4CXX_DEBUG(logger_, "number_of_devices < 0"); controller_->SearchDeviceFailed(SearchDeviceError()); } - - LOG4CXX_TRACE(logger_, "exit"); } void BluetoothDeviceScanner::CheckSDLServiceOnDevices( @@ -371,7 +372,7 @@ bool BluetoothDeviceScanner::DiscoverSmartDeviceLinkRFCOMMChannels( } void BluetoothDeviceScanner::Thread() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); ready_ = true; if (auto_repeat_search_) { while (!shutdown_requested_) { @@ -394,12 +395,10 @@ void BluetoothDeviceScanner::Thread() { device_scan_requested_ = false; } } - - LOG4CXX_TRACE(logger_, "exit"); } void BluetoothDeviceScanner::TimedWaitForDeviceScanRequest() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); if (auto_repeat_pause_sec_ == 0) { LOG4CXX_TRACE(logger_, "exit. Condition: auto_repeat_pause_sec_ == 0"); @@ -417,26 +416,22 @@ void BluetoothDeviceScanner::TimedWaitForDeviceScanRequest() { } } } - - LOG4CXX_TRACE(logger_, "exit"); } TransportAdapter::Error BluetoothDeviceScanner::Init() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); if(!thread_->start()) { LOG4CXX_ERROR(logger_, "Bluetooth device scanner thread start failed"); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter:Fail"); return TransportAdapter::FAIL; } LOG4CXX_INFO(logger_, "Bluetooth device scanner thread started"); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter:OK"); return TransportAdapter::OK; } void BluetoothDeviceScanner::Terminate() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); shutdown_requested_ = true; - if (thread_->is_running()) { + if (thread_) { { sync_primitives::AutoLock auto_lock(device_scan_requested_lock_); device_scan_requested_ = false; @@ -445,36 +440,30 @@ void BluetoothDeviceScanner::Terminate() { LOG4CXX_INFO(logger_, "Waiting for bluetooth device scanner thread termination"); thread_->stop(); - LOG4CXX_INFO(logger_, "PASA Bluetooth device scanner thread joined"); + LOG4CXX_INFO(logger_, "Bluetooth device scanner thread stopped"); } - LOG4CXX_TRACE(logger_, "exit"); } TransportAdapter::Error BluetoothDeviceScanner::Scan() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); if ((!IsInitialised()) || shutdown_requested_) { - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::BAD_STATE"); + LOG4CXX_WARN(logger_, "BAD_STATE"); return TransportAdapter::BAD_STATE; } if (auto_repeat_pause_sec_ == 0) { - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::OK"); return TransportAdapter::OK; } TransportAdapter::Error ret = TransportAdapter::OK; - { - sync_primitives::AutoLock auto_lock(device_scan_requested_lock_); - if (false == device_scan_requested_) { - LOG4CXX_INFO(logger_, "Requesting device Scan"); - device_scan_requested_ = true; - device_scan_requested_cv_.NotifyOne(); - } else { - ret = TransportAdapter::BAD_STATE; - LOG4CXX_INFO(logger_, "Device Scan is currently in progress"); - } + sync_primitives::AutoLock auto_lock(device_scan_requested_lock_); + if (!device_scan_requested_) { + LOG4CXX_TRACE(logger_, "Requesting device Scan"); + device_scan_requested_ = true; + device_scan_requested_cv_.NotifyOne(); + } else { + ret = TransportAdapter::BAD_STATE; + LOG4CXX_WARN(logger_, "BAD_STATE"); } - - LOG4CXX_TRACE(logger_, "exit with Error: " << ret); return ret; } @@ -483,12 +472,10 @@ BluetoothDeviceScanner::BluetoothDeviceScannerDelegate::BluetoothDeviceScannerDe : scanner_(scanner) { } -void BluetoothDeviceScanner::BluetoothDeviceScannerDelegate::threadMain() -{ - LOG4CXX_TRACE_ENTER(logger_); +void BluetoothDeviceScanner::BluetoothDeviceScannerDelegate::threadMain() { + LOG4CXX_AUTO_TRACE(logger_); DCHECK(scanner_); scanner_->Thread(); - LOG4CXX_TRACE_EXIT(logger_); } } // namespace transport_adapter diff --git a/src/components/transport_manager/src/bluetooth/bluetooth_socket_connection.cc b/src/components/transport_manager/src/bluetooth/bluetooth_socket_connection.cc index ac1ccecfb5..d6f9f26317 100644 --- a/src/components/transport_manager/src/bluetooth/bluetooth_socket_connection.cc +++ b/src/components/transport_manager/src/bluetooth/bluetooth_socket_connection.cc @@ -1,4 +1,4 @@ -/** +/* * * Copyright (c) 2013, Ford Motor Company * All rights reserved. @@ -60,7 +60,8 @@ BluetoothSocketConnection::~BluetoothSocketConnection() { } bool BluetoothSocketConnection::Establish(ConnectError** error) { - LOG4CXX_TRACE(logger_, "enter. (#" << pthread_self() << "), error: " << error); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "error: " << error); DeviceSptr device = controller()->FindDevice(device_handle()); BluetoothDevice* bluetooth_device = diff --git a/src/components/transport_manager/src/bluetooth/bluetooth_transport_adapter.cc b/src/components/transport_manager/src/bluetooth/bluetooth_transport_adapter.cc index 7d60213b01..4d02e60896 100644 --- a/src/components/transport_manager/src/bluetooth/bluetooth_transport_adapter.cc +++ b/src/components/transport_manager/src/bluetooth/bluetooth_transport_adapter.cc @@ -1,4 +1,4 @@ -/** +/* * \file bluetooth_transport_adapter.cc * \brief BluetoothTransportAdapter class source file. * @@ -152,7 +152,7 @@ bool BluetoothTransportAdapter::Restore() { if (result) { LOG4CXX_TRACE(logger_, "exit with TRUE"); } else { - LOG4CXX_TRACE(logger_, "exit with FALSE"); + LOG4CXX_TRACE(logger_, "exit with FALSE"); } return result; } diff --git a/src/components/transport_manager/src/tcp/dnssd_service_browser.cc b/src/components/transport_manager/src/tcp/dnssd_service_browser.cc index 5580585766..3571ac8156 100644 --- a/src/components/transport_manager/src/tcp/dnssd_service_browser.cc +++ b/src/components/transport_manager/src/tcp/dnssd_service_browser.cc @@ -1,4 +1,4 @@ -/** +/* * * Copyright (c) 2013, Ford Motor Company * All rights reserved. @@ -33,37 +33,41 @@ #include <algorithm> #include <map> +#include "utils/logger.h" #include "transport_manager/transport_adapter/transport_adapter_impl.h" #include "transport_manager/tcp/tcp_device.h" #include "transport_manager/tcp/dnssd_service_browser.h" -#include "utils/logger.h" + namespace transport_manager { namespace transport_adapter { CREATE_LOGGERPTR_GLOBAL(logger_, "TransportManager") + bool operator==(const DnssdServiceRecord& a, const DnssdServiceRecord& b) { return a.name == b.name && a.type == b.type && a.interface == b.interface - && a.protocol == b.protocol && a.domain_name == b.domain_name; + && a.protocol == b.protocol && a.domain_name == b.domain_name; } void DnssdServiceBrowser::Terminate() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); if (0 != avahi_threaded_poll_) { avahi_threaded_poll_stop(avahi_threaded_poll_); } if (0 != avahi_service_browser_) { avahi_service_browser_free(avahi_service_browser_); + avahi_service_browser_ = NULL; } if (0 != avahi_client_) { avahi_client_free(avahi_client_); + avahi_client_ = NULL; } if (0 != avahi_threaded_poll_) { avahi_threaded_poll_free(avahi_threaded_poll_); + avahi_threaded_poll_ = NULL; } - LOG4CXX_TRACE(logger_, "exit"); } bool DnssdServiceBrowser::IsInitialised() const { @@ -71,18 +75,16 @@ bool DnssdServiceBrowser::IsInitialised() const { } DnssdServiceBrowser::DnssdServiceBrowser(TransportAdapterController* controller) - : controller_(controller), - avahi_service_browser_(0), - avahi_threaded_poll_(0), - avahi_client_(0), - service_records_(), - mutex_(), - initialised_(false) { - pthread_mutex_init(&mutex_, 0); + : controller_(controller), + avahi_service_browser_(0), + avahi_threaded_poll_(0), + avahi_client_(0), + service_records_(), + mutex_(), + initialised_(false) { } DnssdServiceBrowser::~DnssdServiceBrowser() { - pthread_mutex_destroy(&mutex_); } void DnssdServiceBrowser::OnClientConnected() { @@ -91,7 +93,7 @@ void DnssdServiceBrowser::OnClientConnected() { } void DnssdServiceBrowser::OnClientFailure() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); const int avahi_errno = avahi_client_errno(avahi_client_); if (avahi_errno == AVAHI_ERR_DISCONNECTED) { LOG4CXX_DEBUG(logger_, "AvahiClient disconnected"); @@ -100,16 +102,16 @@ void DnssdServiceBrowser::OnClientFailure() { LOG4CXX_ERROR(logger_, "AvahiClient failure: " << avahi_strerror(avahi_errno)); } - LOG4CXX_TRACE(logger_, "exit"); } void AvahiClientCallback(AvahiClient* avahi_client, AvahiClientState avahi_client_state, void* data) { - LOG4CXX_TRACE(logger_, - "enter. avahi_client " << avahi_client << "avahi_client_state " << - avahi_client_state << "data " << data); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG( + logger_, + "avahi_client " << avahi_client << ", avahi_client_state " << avahi_client_state << ", data " << data); DnssdServiceBrowser* dnssd_service_browser = - static_cast<DnssdServiceBrowser*>(data); + static_cast<DnssdServiceBrowser*>(data); switch (avahi_client_state) { case AVAHI_CLIENT_S_RUNNING: @@ -121,10 +123,10 @@ void AvahiClientCallback(AvahiClient* avahi_client, LOG4CXX_DEBUG(logger_, "avahi_client_state: AVAHI_CLIENT_FAILURE"); break; default: { - LOG4CXX_ERROR(logger_, "Unknown avahi_client_state: " << avahi_client_state); + LOG4CXX_ERROR(logger_, + "Unknown avahi_client_state: " << avahi_client_state); } } - LOG4CXX_TRACE(logger_, "exit"); } void AvahiServiceBrowserCallback(AvahiServiceBrowser* avahi_service_browser, @@ -132,21 +134,21 @@ void AvahiServiceBrowserCallback(AvahiServiceBrowser* avahi_service_browser, AvahiBrowserEvent event, const char* name, const char* type, const char* domain, AvahiLookupResultFlags flags, void* data) { - LOG4CXX_TRACE(logger_, "enter. avahi_service_browser " << avahi_service_browser << - " interface " << interface << " protocol " << protocol << - " event " << event << " name " << name << " type " << type << " domain " << domain << - " flags " << flags << " data " << data); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG( + logger_, + "avahi_service_browser " << avahi_service_browser << " interface " << interface << + " protocol " << protocol << " event " << event << " name " << name << + " type " << type << " domain " << domain << " flags " << flags << " data " << data); DnssdServiceBrowser* dnssd_service_browser = - static_cast<DnssdServiceBrowser*>(data); + static_cast<DnssdServiceBrowser*>(data); switch (event) { case AVAHI_BROWSER_FAILURE: LOG4CXX_ERROR( logger_, - "AvahiServiceBrowser failure: " << avahi_strerror( - avahi_client_errno( - avahi_service_browser_get_client( - avahi_service_browser)))); + "AvahiServiceBrowser failure: " << avahi_strerror(avahi_client_errno( + avahi_service_browser_get_client(avahi_service_browser)))); break; case AVAHI_BROWSER_NEW: @@ -163,6 +165,7 @@ void AvahiServiceBrowserCallback(AvahiServiceBrowser* avahi_service_browser, case AVAHI_BROWSER_ALL_FOR_NOW: LOG4CXX_DEBUG(logger_, "event: AVAHI_BROWSER_ALL_FOR_NOW"); + break; case AVAHI_BROWSER_CACHE_EXHAUSTED: LOG4CXX_DEBUG(logger_, "event: AVAHI_BROWSER_CACHE_EXHAUSTED"); break; @@ -171,33 +174,29 @@ void AvahiServiceBrowserCallback(AvahiServiceBrowser* avahi_service_browser, } void DnssdServiceBrowser::ServiceResolved( - const DnssdServiceRecord& service_record) { - LOG4CXX_TRACE(logger_, "enter"); - pthread_mutex_lock(&mutex_); + const DnssdServiceRecord& service_record) { + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock locker(mutex_); ServiceRecords::iterator service_record_it = std::find( - service_records_.begin(), service_records_.end(), service_record); + service_records_.begin(), service_records_.end(), service_record); if (service_record_it != service_records_.end()) { *service_record_it = service_record; } DeviceVector device_vector = PrepareDeviceVector(); controller_->SearchDeviceDone(device_vector); - pthread_mutex_unlock(&mutex_); - LOG4CXX_TRACE(logger_, "exit"); } void DnssdServiceBrowser::ServiceResolveFailed( - const DnssdServiceRecord& service_record) { - LOG4CXX_TRACE(logger_, "enter"); - LOG4CXX_ERROR(logger_, + const DnssdServiceRecord& service_record) { + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "AvahiServiceResolver failure for: " << service_record.name); - pthread_mutex_lock(&mutex_); + sync_primitives::AutoLock locker(mutex_); ServiceRecords::iterator service_record_it = std::find( - service_records_.begin(), service_records_.end(), service_record); + service_records_.begin(), service_records_.end(), service_record); if (service_record_it != service_records_.end()) { service_records_.erase(service_record_it); } - pthread_mutex_unlock(&mutex_); - LOG4CXX_TRACE(logger_, "exit"); } void AvahiServiceResolverCallback(AvahiServiceResolver* avahi_service_resolver, @@ -209,14 +208,16 @@ void AvahiServiceResolverCallback(AvahiServiceResolver* avahi_service_resolver, const AvahiAddress* avahi_address, uint16_t port, AvahiStringList* txt, AvahiLookupResultFlags flags, void* data) { - LOG4CXX_TRACE(logger_, "enter. avahi_service_resolver " << avahi_service_resolver << - " interface " << interface << - " protocol " << protocol << " event " << event << " name " << name << " type " << type << - " domain " << domain << " host_name " << host_name << - " avahi_address " << avahi_address << " port " << port << " txt " << txt << " flags " << - flags << " data " << data); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG( + logger_, + "avahi_service_resolver " << avahi_service_resolver << " interface " << interface << + " protocol " << protocol << " event " << event << " name " << name << + " type " << type << " domain " << domain << " host_name " << host_name << + " avahi_address " << avahi_address << " port " << port << + " txt " << txt << " flags " << flags << " data " << data); DnssdServiceBrowser* dnssd_service_browser = - static_cast<DnssdServiceBrowser*>(data); + static_cast<DnssdServiceBrowser*>(data); DnssdServiceRecord service_record; service_record.interface = interface; @@ -239,62 +240,60 @@ void AvahiServiceResolverCallback(AvahiServiceResolver* avahi_service_resolver, } avahi_service_resolver_free(avahi_service_resolver); - LOG4CXX_TRACE(logger_, "exit"); } TransportAdapter::Error DnssdServiceBrowser::CreateAvahiClientAndBrowser() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); if (0 != avahi_service_browser_) { avahi_service_browser_free(avahi_service_browser_); + avahi_service_browser_ = NULL; } if (0 != avahi_client_) { avahi_client_free(avahi_client_); + avahi_client_ = NULL; } int avahi_error; avahi_client_ = avahi_client_new( - avahi_threaded_poll_get(avahi_threaded_poll_), AVAHI_CLIENT_NO_FAIL, - AvahiClientCallback, this, &avahi_error); + avahi_threaded_poll_get(avahi_threaded_poll_), AVAHI_CLIENT_NO_FAIL, + AvahiClientCallback, this, &avahi_error); if (0 == avahi_client_) { - LOG4CXX_ERROR(logger_, "Failed to create AvahiClient: " << avahi_strerror(avahi_error)); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::FAIL"); + LOG4CXX_ERROR( + logger_, + "Failed to create AvahiClient: " << avahi_strerror(avahi_error)); return TransportAdapter::FAIL; } - pthread_mutex_lock(&mutex_); + mutex_.Acquire(); service_records_.clear(); - pthread_mutex_unlock(&mutex_); + mutex_.Release(); avahi_service_browser_ = avahi_service_browser_new( - avahi_client_, AVAHI_IF_UNSPEC, /* TODO use only required iface */ - AVAHI_PROTO_INET, DNSSD_DEFAULT_SERVICE_TYPE, NULL, /* use default domain */ - static_cast<AvahiLookupFlags>(0), AvahiServiceBrowserCallback, this); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::OK"); + avahi_client_, AVAHI_IF_UNSPEC, /* TODO use only required iface */ + AVAHI_PROTO_INET, DNSSD_DEFAULT_SERVICE_TYPE, NULL, /* use default domain */ + static_cast<AvahiLookupFlags>(0), AvahiServiceBrowserCallback, this); return TransportAdapter::OK; } TransportAdapter::Error DnssdServiceBrowser::Init() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); avahi_threaded_poll_ = avahi_threaded_poll_new(); if (0 == avahi_threaded_poll_) { LOG4CXX_ERROR(logger_, "Failed to create AvahiThreadedPoll"); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::FAIL"); return TransportAdapter::FAIL; } const TransportAdapter::Error err = CreateAvahiClientAndBrowser(); if (err != TransportAdapter::OK) { - LOG4CXX_TRACE(logger_, "exit with error " << err); + LOG4CXX_ERROR(logger_, "Error " << err); return err; } const int poll_start_status = avahi_threaded_poll_start(avahi_threaded_poll_); if (0 != poll_start_status) { LOG4CXX_ERROR(logger_, "Failed to start AvahiThreadedPoll"); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::FAIL. Condition: 0 != poll_start_status"); return TransportAdapter::FAIL; } - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::OK"); return TransportAdapter::OK; } @@ -305,8 +304,10 @@ TransportAdapter::Error DnssdServiceBrowser::Scan() { void DnssdServiceBrowser::AddService(AvahiIfIndex interface, AvahiProtocol protocol, const char* name, const char* type, const char* domain) { - LOG4CXX_TRACE(logger_, "enter: interface " << interface << " protocol " << protocol << - " name " << name << " type " << type << " domain " << domain); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG( + logger_, + "interface " << interface << " protocol " << protocol << " name " << name << " type " << type << " domain " << domain); DnssdServiceRecord record; record.interface = interface; record.protocol = protocol; @@ -314,25 +315,25 @@ void DnssdServiceBrowser::AddService(AvahiIfIndex interface, record.name = name; record.type = type; - pthread_mutex_lock(&mutex_); + sync_primitives::AutoLock locker(mutex_); if (service_records_.end() == std::find(service_records_.begin(), service_records_.end(), record)) { service_records_.push_back(record); - avahi_service_resolver_new( - avahi_client_, interface, protocol, name, type, domain, - AVAHI_PROTO_INET, static_cast<AvahiLookupFlags>(0), - AvahiServiceResolverCallback, this); + avahi_service_resolver_new(avahi_client_, interface, protocol, name, type, + domain, AVAHI_PROTO_INET, + static_cast<AvahiLookupFlags>(0), + AvahiServiceResolverCallback, this); } - pthread_mutex_unlock(&mutex_); - LOG4CXX_TRACE(logger_, "exit"); } void DnssdServiceBrowser::RemoveService(AvahiIfIndex interface, AvahiProtocol protocol, const char* name, const char* type, const char* domain) { - LOG4CXX_TRACE(logger_, "enter: interface " << interface << " protocol " << protocol << - " name " << name << " type " << type << " domain " << domain); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG( + logger_, + "interface " << interface << " protocol " << protocol << " name " << name << " type " << type << " domain " << domain); DnssdServiceRecord record; record.interface = interface; record.protocol = protocol; @@ -340,42 +341,38 @@ void DnssdServiceBrowser::RemoveService(AvahiIfIndex interface, record.type = type; record.domain_name = domain; - pthread_mutex_lock(&mutex_); + sync_primitives::AutoLock locker(mutex_); service_records_.erase( - std::remove(service_records_.begin(), service_records_.end(), record), - service_records_.end()); - pthread_mutex_unlock(&mutex_); - LOG4CXX_TRACE(logger_, "exit"); + std::remove(service_records_.begin(), service_records_.end(), record), + service_records_.end()); } DeviceVector DnssdServiceBrowser::PrepareDeviceVector() const { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); std::map<uint32_t, TcpDevice*> devices; for (ServiceRecords::const_iterator it = service_records_.begin(); - it != service_records_.end(); ++it) { + it != service_records_.end(); ++it) { const DnssdServiceRecord& service_record = *it; if (service_record.host_name.empty()) { continue; } if (devices[service_record.addr] == 0) { devices[service_record.addr] = new TcpDevice(service_record.addr, - service_record.host_name); + service_record.host_name); } if (devices[service_record.addr] != 0) { devices[service_record.addr]->AddDiscoveredApplication( - service_record.port); + service_record.port); } } DeviceVector device_vector; device_vector.reserve(devices.size()); for (std::map<uint32_t, TcpDevice*>::const_iterator it = devices.begin(); - it != devices.end(); ++it) { + it != devices.end(); ++it) { device_vector.push_back(DeviceSptr(it->second)); } - LOG4CXX_TRACE(logger_, "exit"); return device_vector; } -} // namespace -} // namespace - +} // namespace transport_adapter +} // namespace transport_manager diff --git a/src/components/transport_manager/src/tcp/tcp_client_listener.cc b/src/components/transport_manager/src/tcp/tcp_client_listener.cc index c0f39cc490..28a3c389da 100644 --- a/src/components/transport_manager/src/tcp/tcp_client_listener.cc +++ b/src/components/transport_manager/src/tcp/tcp_client_listener.cc @@ -53,7 +53,7 @@ #include <sstream> #include "utils/logger.h" - +#include "utils/threads/thread.h" #include "transport_manager/transport_adapter/transport_adapter_controller.h" #include "transport_manager/tcp/tcp_device.h" #include "transport_manager/tcp/tcp_socket_connection.h" @@ -66,35 +66,78 @@ CREATE_LOGGERPTR_GLOBAL(logger_, "TransportManager") TcpClientListener::TcpClientListener(TransportAdapterController* controller, const uint16_t port, const bool enable_keepalive) - : port_(port), - enable_keepalive_(enable_keepalive), - controller_(controller), - thread_(threads::CreateThread("TcpClientListener", this)), - socket_(-1), - thread_stop_requested_(false) { } + : port_(port), + enable_keepalive_(enable_keepalive), + controller_(controller), + thread_(0), + socket_(-1), + thread_stop_requested_(false) { + thread_ = threads::CreateThread("TcpClientListener", + new ListeningThreadDelegate(this)); +} TransportAdapter::Error TcpClientListener::Init() { + LOG4CXX_AUTO_TRACE(logger_); + thread_stop_requested_ = false; + + socket_ = socket(AF_INET, SOCK_STREAM, 0); + if (-1 == socket_) { + LOG4CXX_ERROR_WITH_ERRNO(logger_, "Failed to create socket"); + return TransportAdapter::FAIL; + } + + sockaddr_in server_address = { 0 }; + server_address.sin_family = AF_INET; + server_address.sin_port = htons(port_); + server_address.sin_addr.s_addr = INADDR_ANY; + + int optval = 1; + setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)); + + if (bind(socket_, reinterpret_cast<sockaddr*>(&server_address), + sizeof(server_address)) != 0) { + LOG4CXX_ERROR_WITH_ERRNO(logger_, "bind() failed"); + return TransportAdapter::FAIL; + } + + const int kBacklog = 128; + if (0 != listen(socket_, kBacklog)) { + LOG4CXX_ERROR_WITH_ERRNO(logger_, "listen() failed"); + return TransportAdapter::FAIL; + } return TransportAdapter::OK; } void TcpClientListener::Terminate() { - LOG4CXX_TRACE(logger_, "enter"); - if (TransportAdapter::OK != StopListening()) { - LOG4CXX_ERROR(logger_, "Cannot stop listening TCP"); + LOG4CXX_AUTO_TRACE(logger_); + if (socket_ == -1) { + LOG4CXX_WARN(logger_, "Socket has been closed"); + return; } - LOG4CXX_TRACE(logger_, "exit"); + if (shutdown(socket_, SHUT_RDWR) != 0) { + LOG4CXX_ERROR_WITH_ERRNO(logger_, "Failed to shutdown socket"); + } + if (close(socket_) != 0) { + LOG4CXX_ERROR_WITH_ERRNO(logger_, "Failed to close socket"); + } + socket_ = -1; } bool TcpClientListener::IsInitialised() const { - return true; + return thread_; } TcpClientListener::~TcpClientListener() { - LOG4CXX_INFO(logger_, "destructor"); + LOG4CXX_AUTO_TRACE(logger_); + StopListening(); + delete thread_->delegate(); + threads::DeleteThread(thread_); + Terminate(); } void SetKeepaliveOptions(const int fd) { - LOG4CXX_TRACE(logger_, "enter. fd: " << fd); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "fd: " << fd); int yes = 1; int keepidle = 3; // 3 seconds to disconnection detecting int keepcnt = 5; @@ -108,7 +151,7 @@ void SetKeepaliveOptions(const int fd) { setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &user_timeout, sizeof(user_timeout)); #elif defined(__QNX__) // __linux__ - // TODO (KKolodiy): Out of order! + // TODO(KKolodiy): Out of order! const int kMidLength = 4; int mib[kMidLength]; @@ -130,23 +173,24 @@ void SetKeepaliveOptions(const int fd) { mib[3] = TCPCTL_KEEPINTVL; sysctl(mib, kMidLength, NULL, NULL, &keepintvl, sizeof(keepintvl)); - struct timeval tval = { 0 }; + struct timeval tval = {0}; tval.tv_sec = keepidle; setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)); setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &tval, sizeof(tval)); #endif // __QNX__ - LOG4CXX_TRACE(logger_, "exit"); } -void TcpClientListener::threadMain() { - LOG4CXX_TRACE(logger_, "enter"); +void TcpClientListener::Loop() { + LOG4CXX_AUTO_TRACE(logger_); while (!thread_stop_requested_) { sockaddr_in client_address; socklen_t client_address_size = sizeof(client_address); - const int connection_fd = accept(socket_, (struct sockaddr*)&client_address, + const int connection_fd = accept(socket_, + (struct sockaddr*) &client_address, &client_address_size); if (thread_stop_requested_) { LOG4CXX_DEBUG(logger_, "thread_stop_requested_"); + close(connection_fd); break; } @@ -157,6 +201,7 @@ void TcpClientListener::threadMain() { if (AF_INET != client_address.sin_family) { LOG4CXX_DEBUG(logger_, "Address of connected client is invalid"); + close(connection_fd); continue; } @@ -169,99 +214,78 @@ void TcpClientListener::threadMain() { SetKeepaliveOptions(connection_fd); } - TcpDevice* tcp_device = new TcpDevice(client_address.sin_addr.s_addr, device_name); + TcpDevice* tcp_device = new TcpDevice(client_address.sin_addr.s_addr, + device_name); DeviceSptr device = controller_->AddDevice(tcp_device); tcp_device = static_cast<TcpDevice*>(device.get()); const ApplicationHandle app_handle = tcp_device->AddIncomingApplication( - connection_fd); + connection_fd); TcpSocketConnection* connection( - new TcpSocketConnection(device->unique_device_id(), app_handle, - controller_)); + new TcpSocketConnection(device->unique_device_id(), app_handle, + controller_)); connection->set_socket(connection_fd); const TransportAdapter::Error error = connection->Start(); if (error != TransportAdapter::OK) { delete connection; } } - LOG4CXX_TRACE(logger_, "exit"); } -TransportAdapter::Error TcpClientListener::StartListening() { - LOG4CXX_TRACE(logger_, "enter"); - if (thread_->is_running()) { - LOG4CXX_TRACE(logger_, - "exit with TransportAdapter::BAD_STATE. Condition: thread_started_"); - return TransportAdapter::BAD_STATE; - } - - socket_ = socket(AF_INET, SOCK_STREAM, 0); - - if (-1 == socket_) { - LOG4CXX_ERROR_WITH_ERRNO(logger_, "Failed to create socket"); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::FAIL. Condition: -1 == socket_"); - return TransportAdapter::FAIL; - } - +void TcpClientListener::StopLoop() { + LOG4CXX_AUTO_TRACE(logger_); + thread_stop_requested_ = true; + // We need to connect to the listening socket to unblock accept() call + int byesocket = socket(AF_INET, SOCK_STREAM, 0); sockaddr_in server_address = { 0 }; server_address.sin_family = AF_INET; server_address.sin_port = htons(port_); server_address.sin_addr.s_addr = INADDR_ANY; + connect(byesocket, reinterpret_cast<sockaddr*>(&server_address), + sizeof(server_address)); + shutdown(byesocket, SHUT_RDWR); + close(byesocket); +} - int optval = 1; - setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)); - - if (0 != bind(socket_, (sockaddr*) &server_address, sizeof(server_address))) { - LOG4CXX_ERROR_WITH_ERRNO(logger_, "bind() failed"); - LOG4CXX_TRACE(logger_, - "exit with TransportAdapter::FAIL. Condition: 0 != bind(socket_, (sockaddr*) &server_address, sizeof(server_address))"); - return TransportAdapter::FAIL; - } - - if (0 != listen(socket_, 128)) { - LOG4CXX_ERROR_WITH_ERRNO(logger_, "listen() failed"); - LOG4CXX_TRACE(logger_, - "exit with TransportAdapter::FAIL. Condition: 0 != listen(socket_, 128)"); - return TransportAdapter::FAIL; +TransportAdapter::Error TcpClientListener::StartListening() { + LOG4CXX_AUTO_TRACE(logger_); + if (thread_->is_running()) { + LOG4CXX_WARN(logger_, + "TransportAdapter::BAD_STATE. Listener has already been started"); + return TransportAdapter::BAD_STATE; } - if (thread_->start()) { - LOG4CXX_DEBUG(logger_, "Tcp client listener thread started"); - } else { + if (!thread_->start()) { LOG4CXX_ERROR(logger_, "Tcp client listener thread start failed"); return TransportAdapter::FAIL; } - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::OK"); + LOG4CXX_INFO(logger_, "Tcp client listener has started successfully"); return TransportAdapter::OK; } -bool TcpClientListener::exitThreadMain() { - StopListening(); - return true; +void TcpClientListener::ListeningThreadDelegate::exitThreadMain() { + parent_->StopLoop(); +} + +void TcpClientListener::ListeningThreadDelegate::threadMain() { + parent_->Loop(); +} + +TcpClientListener::ListeningThreadDelegate::ListeningThreadDelegate( + TcpClientListener* parent) + : parent_(parent) { } TransportAdapter::Error TcpClientListener::StopListening() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); if (!thread_->is_running()) { - LOG4CXX_TRACE(logger_, - "exit with TransportAdapter::BAD_STATE. Condition !thread_started_"); + LOG4CXX_DEBUG(logger_, "TcpClientListener is not running now"); return TransportAdapter::BAD_STATE; } - thread_stop_requested_ = true; - // We need to connect to the listening socket to unblock accept() call - int byesocket = socket(AF_INET, SOCK_STREAM, 0); - sockaddr_in server_address = { 0 }; - server_address.sin_family = AF_INET; - server_address.sin_port = htons(port_); - server_address.sin_addr.s_addr = INADDR_ANY; - connect(byesocket, (sockaddr*)&server_address, sizeof(server_address)); - shutdown(byesocket, SHUT_RDWR); - close(byesocket); - LOG4CXX_DEBUG(logger_, "Tcp client listener thread terminated"); - close(socket_); - socket_ = -1; - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::OK"); + thread_->join(); + + LOG4CXX_INFO(logger_, "Tcp client listener has stopped successfully"); return TransportAdapter::OK; } diff --git a/src/components/transport_manager/src/tcp/tcp_connection_factory.cc b/src/components/transport_manager/src/tcp/tcp_connection_factory.cc index 69173a0e06..7c6c06ddc0 100644 --- a/src/components/transport_manager/src/tcp/tcp_connection_factory.cc +++ b/src/components/transport_manager/src/tcp/tcp_connection_factory.cc @@ -1,6 +1,5 @@ -/** - * - * Copyright (c) 2013, Ford Motor Company +/* + * Copyright (c) 2015, Ford Motor Company * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -41,8 +40,9 @@ namespace transport_adapter { CREATE_LOGGERPTR_GLOBAL(logger_, "TransportManager") -TcpConnectionFactory::TcpConnectionFactory(TransportAdapterController* controller) - : controller_(controller) { +TcpConnectionFactory::TcpConnectionFactory( + TransportAdapterController* controller) + : controller_(controller) { } TransportAdapter::Error TcpConnectionFactory::Init() { @@ -50,19 +50,22 @@ TransportAdapter::Error TcpConnectionFactory::Init() { } TransportAdapter::Error TcpConnectionFactory::CreateConnection( - const DeviceUID& device_uid, const ApplicationHandle& app_handle) { - LOG4CXX_TRACE(logger_, "enter. DeviceUID: " << &device_uid << ", ApplicationHandle: " << - &app_handle); + const DeviceUID& device_uid, const ApplicationHandle& app_handle) { + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG( + logger_, + "DeviceUID: " << &device_uid << ", ApplicationHandle: " << &app_handle); TcpServerOiginatedSocketConnection* connection( - new TcpServerOiginatedSocketConnection(device_uid, app_handle, - controller_)); - TransportAdapter::Error error = connection->Start(); - if (TransportAdapter::OK != error) { - LOG4CXX_ERROR(logger_, "Transport adapter error " << error); - delete connection; + new TcpServerOiginatedSocketConnection(device_uid, app_handle, + controller_)); + controller_->ConnectionCreated(connection, device_uid, app_handle); + if (connection->Start() == TransportAdapter::OK) { + LOG4CXX_DEBUG(logger_, "TCP connection initialised"); + return TransportAdapter::OK; + } else { + LOG4CXX_ERROR(logger_, "Could not initialise TCP connection"); + return TransportAdapter::FAIL; } - LOG4CXX_TRACE(logger_, "exit with error " << error); - return error; } void TcpConnectionFactory::Terminate() { diff --git a/src/components/transport_manager/src/tcp/tcp_device.cc b/src/components/transport_manager/src/tcp/tcp_device.cc index 2540c26ed0..92848a4246 100644 --- a/src/components/transport_manager/src/tcp/tcp_device.cc +++ b/src/components/transport_manager/src/tcp/tcp_device.cc @@ -1,4 +1,4 @@ -/** +/* * * Copyright (c) 2013, Ford Motor Company * All rights reserved. @@ -30,31 +30,34 @@ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ - +#include "utils/logger.h" #include "transport_manager/tcp/tcp_device.h" -#include "utils/logger.h" namespace transport_manager { namespace transport_adapter { +//CREATE_LOGGERPTR_LOCAL(logger_, "TransportManager") CREATE_LOGGERPTR_GLOBAL(logger_, "TransportManager") + TcpDevice::TcpDevice(const in_addr_t& in_addr, const std::string& name) - : - Device(name, name), - in_addr_(in_addr), - last_handle_(0) { - pthread_mutex_init(&applications_mutex_, 0); + : Device(name, name), + applications_mutex_(), + in_addr_(in_addr), + last_handle_(0) { + LOG4CXX_AUTO_TRACE(logger_); } bool TcpDevice::IsSameAs(const Device* other) const { - LOG4CXX_TRACE(logger_, "enter. Device: " << other); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "Device: " << other); const TcpDevice* other_tcp_device = static_cast<const TcpDevice*>(other); if (other_tcp_device->in_addr_ == in_addr_) { - LOG4CXX_TRACE(logger_, - "exit with TRUE. Condition: other_tcp_device->in_addr_ == in_addr_"); + LOG4CXX_TRACE( + logger_, + "exit with TRUE. Condition: other_tcp_device->in_addr_ == in_addr_"); return true; } else { LOG4CXX_TRACE(logger_, "exit with FALSE"); @@ -63,91 +66,88 @@ bool TcpDevice::IsSameAs(const Device* other) const { } ApplicationList TcpDevice::GetApplicationList() const { - LOG4CXX_TRACE(logger_, "enter"); - pthread_mutex_lock(&applications_mutex_); + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock locker(applications_mutex_); ApplicationList app_list; for (std::map<ApplicationHandle, Application>::const_iterator it = - applications_.begin(); it != applications_.end(); ++it) { + applications_.begin(); it != applications_.end(); ++it) { app_list.push_back(it->first); } - pthread_mutex_unlock(&applications_mutex_); - LOG4CXX_TRACE(logger_, "exit with app_list. It's size = " << app_list.size()); return app_list; } ApplicationHandle TcpDevice::AddIncomingApplication(int socket_fd) { - LOG4CXX_TRACE(logger_, "enter. Socket_fd: " << socket_fd); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "Socket_fd: " << socket_fd); Application app; app.incoming = true; app.socket = socket_fd; - app.port = 0; // this line removes compiler warning - pthread_mutex_lock(&applications_mutex_); + app.port = 0; // this line removes compiler warning + sync_primitives::AutoLock locker(applications_mutex_); const ApplicationHandle app_handle = ++last_handle_; applications_[app_handle] = app; - pthread_mutex_unlock(&applications_mutex_); - LOG4CXX_TRACE(logger_, "exit with app_handle " << app_handle); + LOG4CXX_DEBUG(logger_, "App_handle " << app_handle); return app_handle; } ApplicationHandle TcpDevice::AddDiscoveredApplication(int port) { - LOG4CXX_TRACE(logger_, "enter. port " << port); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "Port " << port); Application app; app.incoming = false; app.socket = 0; // this line removes compiler warning app.port = port; - pthread_mutex_lock(&applications_mutex_); + sync_primitives::AutoLock locker(applications_mutex_); const ApplicationHandle app_handle = ++last_handle_; applications_[app_handle] = app; - pthread_mutex_unlock(&applications_mutex_); - LOG4CXX_TRACE(logger_, "exit with app_handle " << app_handle); + LOG4CXX_DEBUG(logger_, "App_handle " << app_handle); return app_handle; } - void TcpDevice::RemoveApplication(const ApplicationHandle app_handle) { - LOG4CXX_TRACE(logger_, "enter. ApplicationHandle: " << app_handle); - pthread_mutex_lock(&applications_mutex_); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "ApplicationHandle: " << app_handle); + sync_primitives::AutoLock locker(applications_mutex_); applications_.erase(app_handle); - pthread_mutex_unlock(&applications_mutex_); - LOG4CXX_TRACE(logger_, "exit"); } TcpDevice::~TcpDevice() { - pthread_mutex_destroy(&applications_mutex_); + LOG4CXX_AUTO_TRACE(logger_); } int TcpDevice::GetApplicationSocket(const ApplicationHandle app_handle) const { - LOG4CXX_TRACE(logger_, "enter. ApplicationHandle: " << app_handle); - std::map<ApplicationHandle, Application>::const_iterator it = applications_.find( - app_handle); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "ApplicationHandle: " << app_handle); + std::map<ApplicationHandle, Application>::const_iterator it = applications_ + .find(app_handle); if (applications_.end() == it) { - LOG4CXX_TRACE(logger_, "exit with -1. Condition: applications_.end() == it"); + LOG4CXX_WARN(logger_, "Application was not found"); return -1; } if (!it->second.incoming) { - LOG4CXX_TRACE(logger_, "exit with -1. Condition: !it->second.incoming"); + LOG4CXX_WARN(logger_, "Application is not incoming"); return -1; } - LOG4CXX_TRACE(logger_, "exit with socket " << it->second.socket); + LOG4CXX_DEBUG(logger_, "socket " << it->second.socket); return it->second.socket; } int TcpDevice::GetApplicationPort(const ApplicationHandle app_handle) const { - LOG4CXX_TRACE(logger_, "enter. ApplicationHandle: " << app_handle); - std::map<ApplicationHandle, Application>::const_iterator it = applications_.find( - app_handle); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "ApplicationHandle: " << app_handle); + std::map<ApplicationHandle, Application>::const_iterator it = applications_ + .find(app_handle); if (applications_.end() == it) { - LOG4CXX_TRACE(logger_, "exit with -1. Condition: applications_.end() == it"); + LOG4CXX_WARN(logger_, "Application was not found"); return -1; } if (it->second.incoming) { - LOG4CXX_TRACE(logger_, "exit with -1. Condition: it->second.incoming"); + LOG4CXX_WARN(logger_, "Application is incoming"); return -1; } - LOG4CXX_TRACE(logger_, "exit with port " << it->second.port); + LOG4CXX_DEBUG(logger_, "port " << it->second.port); return it->second.port; } - } // namespace transport_adapter } // namespace transport_manager diff --git a/src/components/transport_manager/src/tcp/tcp_socket_connection.cc b/src/components/transport_manager/src/tcp/tcp_socket_connection.cc index 3b208d8a07..c5d0e88d84 100644 --- a/src/components/transport_manager/src/tcp/tcp_socket_connection.cc +++ b/src/components/transport_manager/src/tcp/tcp_socket_connection.cc @@ -1,4 +1,4 @@ -/** +/* * * Copyright (c) 2013, Ford Motor Company * All rights reserved. @@ -31,25 +31,27 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include "transport_manager/transport_adapter/transport_adapter_controller.h" #include "transport_manager/tcp/tcp_socket_connection.h" -#include "transport_manager/tcp/tcp_device.h" -#include "utils/logger.h" #include <memory.h> #include <signal.h> #include <errno.h> +#include <unistd.h> + +#include "utils/logger.h" +#include "utils/threads/thread.h" +#include "transport_manager/tcp/tcp_device.h" +#include "transport_manager/transport_adapter/transport_adapter_controller.h" namespace transport_manager { namespace transport_adapter { CREATE_LOGGERPTR_GLOBAL(logger_, "TransportManager") - TcpSocketConnection::TcpSocketConnection(const DeviceUID& device_uid, - const ApplicationHandle& app_handle, - TransportAdapterController* controller) - : ThreadedSocketConnection(device_uid, app_handle, controller) { + const ApplicationHandle& app_handle, + TransportAdapterController* controller) + : ThreadedSocketConnection(device_uid, app_handle, controller) { } TcpSocketConnection::~TcpSocketConnection() { @@ -60,30 +62,32 @@ bool TcpSocketConnection::Establish(ConnectError** error) { } TcpServerOiginatedSocketConnection::TcpServerOiginatedSocketConnection( - const DeviceUID& device_uid, const ApplicationHandle& app_handle, - TransportAdapterController* controller) - : ThreadedSocketConnection(device_uid, app_handle, controller) { + const DeviceUID& device_uid, const ApplicationHandle& app_handle, + TransportAdapterController* controller) + : ThreadedSocketConnection(device_uid, app_handle, controller) { } TcpServerOiginatedSocketConnection::~TcpServerOiginatedSocketConnection() { } bool TcpServerOiginatedSocketConnection::Establish(ConnectError** error) { - LOG4CXX_TRACE(logger_, "enter. error " << error); + LOG4CXX_AUTO_TRACE(logger_); + DCHECK(error); + LOG4CXX_DEBUG(logger_, "error " << error); DeviceSptr device = controller()->FindDevice(device_handle()); if (!device.valid()) { LOG4CXX_ERROR(logger_, "Device " << device_handle() << " not found"); *error = new ConnectError(); - LOG4CXX_TRACE(logger_, "exit with FALSE. Condition: !device.valid()"); return false; } TcpDevice* tcp_device = static_cast<TcpDevice*>(device.get()); - int port; - if (-1 == (port = tcp_device->GetApplicationPort(application_handle()))) { - LOG4CXX_ERROR(logger_, "Application port for " << application_handle() << " not found"); + const int port = tcp_device->GetApplicationPort(application_handle()); + if (-1 == port) { + LOG4CXX_ERROR( + logger_, + "Application port for " << application_handle() << " not found"); *error = new ConnectError(); - LOG4CXX_TRACE(logger_, "exit with FALSE. Condition: port not found"); return false; } @@ -91,7 +95,6 @@ bool TcpServerOiginatedSocketConnection::Establish(ConnectError** error) { if (socket < 0) { LOG4CXX_ERROR(logger_, "Failed to create socket"); *error = new ConnectError(); - LOG4CXX_TRACE(logger_, "exit with FALSE. Condition: failed to create socket"); return false; } @@ -100,21 +103,20 @@ bool TcpServerOiginatedSocketConnection::Establish(ConnectError** error) { addr.sin_addr.s_addr = tcp_device->in_addr(); addr.sin_port = htons(port); - LOG4CXX_INFO(logger_, "Connecting " << inet_ntoa(addr.sin_addr) << ":" - << port); + LOG4CXX_DEBUG(logger_, + "Connecting " << inet_ntoa(addr.sin_addr) << ":" << port); if (::connect(socket, (struct sockaddr*) &addr, sizeof(addr)) < 0) { - LOG4CXX_ERROR(logger_, "Failed to connect for application " - << application_handle() << ", error " << errno); + LOG4CXX_ERROR( + logger_, + "Failed to connect for application " << application_handle() << ", error " << errno); *error = new ConnectError(); - LOG4CXX_TRACE(logger_, "exit with FALSE. Condition: failed to connect to application"); + ::close(socket); return false; } set_socket(socket); - LOG4CXX_TRACE(logger_, "exit with TRUE"); return true; } } // namespace transport_adapter } // namespace transport_manager - diff --git a/src/components/transport_manager/src/tcp/tcp_transport_adapter.cc b/src/components/transport_manager/src/tcp/tcp_transport_adapter.cc index 3747225a89..ade69cba69 100644 --- a/src/components/transport_manager/src/tcp/tcp_transport_adapter.cc +++ b/src/components/transport_manager/src/tcp/tcp_transport_adapter.cc @@ -1,5 +1,4 @@ -/** - * +/* * Copyright (c) 2013, Ford Motor Company * All rights reserved. * @@ -31,18 +30,19 @@ * POSSIBILITY OF SUCH DAMAGE. */ +#include "transport_manager/tcp/tcp_transport_adapter.h" + #include <memory.h> #include <signal.h> #include <errno.h> -#include <sstream> -#include <cstdlib> +#include <stdio.h> -#include "resumption/last_state.h" +#include <cstdlib> +#include <sstream> #include "utils/logger.h" #include "utils/threads/thread_delegate.h" - -#include "transport_manager/tcp/tcp_transport_adapter.h" +#include "resumption/last_state.h" #include "transport_manager/tcp/tcp_client_listener.h" #include "transport_manager/tcp/tcp_connection_factory.h" #include "transport_manager/tcp/tcp_device.h" @@ -57,14 +57,14 @@ namespace transport_adapter { CREATE_LOGGERPTR_GLOBAL(logger_, "TransportAdapterImpl") TcpTransportAdapter::TcpTransportAdapter(const uint16_t port) - : TransportAdapterImpl( + : TransportAdapterImpl( #ifdef AVAHI_SUPPORT - new DnssdServiceBrowser(this), + new DnssdServiceBrowser(this), #else - NULL, + NULL, #endif - new TcpConnectionFactory(this), - new TcpClientListener(this, port, false)) { + new TcpConnectionFactory(this), + new TcpClientListener(this, port, false)) { } TcpTransportAdapter::~TcpTransportAdapter() { @@ -75,18 +75,19 @@ DeviceType TcpTransportAdapter::GetDeviceType() const { } void TcpTransportAdapter::Store() const { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); Json::Value tcp_adapter_dictionary; Json::Value devices_dictionary; DeviceList device_ids = GetDeviceList(); - for (DeviceList::const_iterator i = device_ids.begin(); i != device_ids.end(); ++i) { + for (DeviceList::const_iterator i = device_ids.begin(); i != device_ids.end(); + ++i) { DeviceUID device_id = *i; DeviceSptr device = FindDevice(device_id); - if (!device) { // device could have been disconnected + if (!device) { // device could have been disconnected continue; } - utils::SharedPtr<TcpDevice> tcp_device = - DeviceSptr::static_pointer_cast<TcpDevice>(device); + utils::SharedPtr<TcpDevice> tcp_device = DeviceSptr::static_pointer_cast< + TcpDevice>(device); Json::Value device_dictionary; device_dictionary["name"] = tcp_device->name(); struct in_addr address; @@ -94,14 +95,16 @@ void TcpTransportAdapter::Store() const { device_dictionary["address"] = std::string(inet_ntoa(address)); Json::Value applications_dictionary; ApplicationList app_ids = tcp_device->GetApplicationList(); - for (ApplicationList::const_iterator j = app_ids.begin(); j != app_ids.end(); ++j) { + for (ApplicationList::const_iterator j = app_ids.begin(); + j != app_ids.end(); ++j) { ApplicationHandle app_handle = *j; - if (FindEstablishedConnection(tcp_device->unique_device_id(), app_handle)) { + if (FindEstablishedConnection(tcp_device->unique_device_id(), + app_handle)) { int port = tcp_device->GetApplicationPort(app_handle); - if (port != -1) { // don't want to store incoming applications + if (port != -1) { // don't want to store incoming applications Json::Value application_dictionary; char port_record[12]; - sprintf(port_record, "%d", port); + snprintf(port_record, sizeof(port_record), "%d", port); application_dictionary["port"] = std::string(port_record); applications_dictionary.append(application_dictionary); } @@ -113,19 +116,18 @@ void TcpTransportAdapter::Store() const { } } tcp_adapter_dictionary["devices"] = devices_dictionary; - resumption::LastState::instance()->dictionary["TransportManager"]["TcpAdapter"] = - tcp_adapter_dictionary; - LOG4CXX_TRACE(logger_, "exit"); + Json::Value& dictionary = resumption::LastState::instance()->dictionary; + dictionary["TransportManager"]["TcpAdapter"] = tcp_adapter_dictionary; } bool TcpTransportAdapter::Restore() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); bool errors_occurred = false; - const Json::Value tcp_adapter_dictionary = - resumption::LastState::instance()->dictionary["TransportManager"]["TcpAdapter"]; + const Json::Value tcp_adapter_dictionary = resumption::LastState::instance() + ->dictionary["TransportManager"]["TcpAdapter"]; const Json::Value devices_dictionary = tcp_adapter_dictionary["devices"]; for (Json::Value::const_iterator i = devices_dictionary.begin(); - i != devices_dictionary.end(); ++i) { + i != devices_dictionary.end(); ++i) { const Json::Value device_dictionary = *i; std::string name = device_dictionary["name"].asString(); std::string address_record = device_dictionary["address"].asString(); @@ -133,9 +135,10 @@ bool TcpTransportAdapter::Restore() { TcpDevice* tcp_device = new TcpDevice(address, name); DeviceSptr device(tcp_device); AddDevice(device); - const Json::Value applications_dictionary = device_dictionary["applications"]; + const Json::Value applications_dictionary = + device_dictionary["applications"]; for (Json::Value::const_iterator j = applications_dictionary.begin(); - j != applications_dictionary.end(); ++j) { + j != applications_dictionary.end(); ++j) { const Json::Value application_dictionary = *j; std::string port_record = application_dictionary["port"].asString(); int port = atoi(port_record.c_str()); @@ -146,11 +149,7 @@ bool TcpTransportAdapter::Restore() { } } bool result = !errors_occurred; - if (result) { - LOG4CXX_TRACE(logger_, "exit with TRUE"); - } else { - LOG4CXX_TRACE(logger_, "exit with FALSE"); - } + LOG4CXX_DEBUG(logger_, "result " << std::boolalpha << result); return result; } diff --git a/src/components/transport_manager/src/transport_adapter/threaded_socket_connection.cc b/src/components/transport_manager/src/transport_adapter/threaded_socket_connection.cc index 1e189ed101..67e41cec2b 100644 --- a/src/components/transport_manager/src/transport_adapter/threaded_socket_connection.cc +++ b/src/components/transport_manager/src/transport_adapter/threaded_socket_connection.cc @@ -1,4 +1,4 @@ -/** +/* * Copyright (c) 2013, Ford Motor Company * All rights reserved. * @@ -36,7 +36,9 @@ #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> + #include "utils/logger.h" +#include "utils/threads/thread.h" #include "transport_manager/transport_adapter/threaded_socket_connection.h" #include "transport_manager/transport_adapter/transport_adapter_controller.h" @@ -46,197 +48,173 @@ namespace transport_adapter { CREATE_LOGGERPTR_GLOBAL(logger_, "TransportManager") ThreadedSocketConnection::ThreadedSocketConnection( - const DeviceUID& device_id, const ApplicationHandle& app_handle, - TransportAdapterController* controller) - : read_fd_(-1), write_fd_(-1), controller_(controller), - frames_to_send_(), - frames_to_send_mutex_(), - socket_(-1), - terminate_flag_(false), - unexpected_disconnect_(false), - device_uid_(device_id), - app_handle_(app_handle) - { - pthread_mutex_init(&frames_to_send_mutex_, 0); + const DeviceUID& device_id, const ApplicationHandle& app_handle, + TransportAdapterController* controller) + : read_fd_(-1), + write_fd_(-1), + controller_(controller), + frames_to_send_(), + frames_to_send_mutex_(), + socket_(-1), + terminate_flag_(false), + unexpected_disconnect_(false), + device_uid_(device_id), + app_handle_(app_handle), + thread_(NULL) { + const std::string thread_name = std::string("Socket ") + device_handle(); + thread_ = threads::CreateThread(thread_name.c_str(), + new SocketConnectionDelegate(this)); } ThreadedSocketConnection::~ThreadedSocketConnection() { - terminate_flag_ = true; - Notify(); - pthread_mutex_destroy(&frames_to_send_mutex_); + LOG4CXX_AUTO_TRACE(logger_); + Disconnect(); + thread_->join(); + delete thread_->delegate(); + threads::DeleteThread(thread_); + if (-1 != read_fd_) { + close(read_fd_); + } + if (-1 != write_fd_) { + close(write_fd_); + } } void ThreadedSocketConnection::Abort() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); unexpected_disconnect_ = true; terminate_flag_ = true; - LOG4CXX_TRACE(logger_, "exit"); } TransportAdapter::Error ThreadedSocketConnection::Start() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); int fds[2]; const int pipe_ret = pipe(fds); if (0 == pipe_ret) { - LOG4CXX_DEBUG(logger_, "pipe created(#" << pthread_self() << ")"); + LOG4CXX_DEBUG(logger_, "pipe created"); read_fd_ = fds[0]; write_fd_ = fds[1]; } else { - LOG4CXX_WARN(logger_, "pipe creation failed (#" << pthread_self() << ")"); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::FAIL"); + LOG4CXX_ERROR(logger_, "pipe creation failed"); return TransportAdapter::FAIL; } const int fcntl_ret = fcntl(read_fd_, F_SETFL, fcntl(read_fd_, F_GETFL) | O_NONBLOCK); if (0 != fcntl_ret) { - LOG4CXX_WARN(logger_, "fcntl failed (#" << pthread_self() << ")"); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::FAIL"); + LOG4CXX_ERROR(logger_, "fcntl failed"); return TransportAdapter::FAIL; } - const std::string thread_name = std::string("Socket ") + device_handle(); - thread_ = threads::CreateThread(thread_name.c_str(), this); - if (!thread_->start()) { - LOG4CXX_WARN(logger_, "thread creation failed (#" << pthread_self() << ")"); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::FAIL"); + LOG4CXX_ERROR(logger_, "thread creation failed"); return TransportAdapter::FAIL; } - LOG4CXX_DEBUG(logger_, "thread created (#" << pthread_self() << ")"); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::OK"); + LOG4CXX_INFO(logger_, "thread created"); return TransportAdapter::OK; } void ThreadedSocketConnection::Finalize() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); if (unexpected_disconnect_) { - LOG4CXX_DEBUG(logger_, "unexpected_disconnect (#" << pthread_self() << ")"); + LOG4CXX_DEBUG(logger_, "unexpected_disconnect"); controller_->ConnectionAborted(device_handle(), application_handle(), CommunicationError()); } else { - LOG4CXX_DEBUG(logger_, "not unexpected_disconnect (#" << pthread_self() << ")"); + LOG4CXX_DEBUG(logger_, "not unexpected_disconnect"); controller_->ConnectionFinished(device_handle(), application_handle()); } close(socket_); - LOG4CXX_TRACE(logger_, "exit"); } TransportAdapter::Error ThreadedSocketConnection::Notify() const { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); if (-1 == write_fd_) { - LOG4CXX_ERROR_WITH_ERRNO(logger_, - "Failed to wake up connection thread for connection " << this); + LOG4CXX_ERROR_WITH_ERRNO( + logger_, "Failed to wake up connection thread for connection " << this); LOG4CXX_TRACE(logger_, "exit with TransportAdapter::BAD_STATE"); return TransportAdapter::BAD_STATE; } uint8_t c = 0; - if (1 == write(write_fd_, &c, 1)) { - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::OK"); - return TransportAdapter::OK; - } else { + if (1 != write(write_fd_, &c, 1)) { LOG4CXX_ERROR_WITH_ERRNO( - logger_, "Failed to wake up connection thread for connection " << this); - LOG4CXX_TRACE(logger_, "exit with TransportAdapter::FAIL"); + logger_, "Failed to wake up connection thread for connection " << this); return TransportAdapter::FAIL; } + return TransportAdapter::OK; } TransportAdapter::Error ThreadedSocketConnection::SendData( - ::protocol_handler::RawMessagePtr message) { - LOG4CXX_TRACE(logger_, "enter"); - pthread_mutex_lock(&frames_to_send_mutex_); + ::protocol_handler::RawMessagePtr message) { + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock auto_lock(frames_to_send_mutex_); frames_to_send_.push(message); - pthread_mutex_unlock(&frames_to_send_mutex_); - TransportAdapter::Error error = Notify(); - LOG4CXX_TRACE(logger_, "exit with error" << error); - return error; + return Notify(); } TransportAdapter::Error ThreadedSocketConnection::Disconnect() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); terminate_flag_ = true; - TransportAdapter::Error error = Notify(); - LOG4CXX_TRACE(logger_, "exit with error" << error); - return error; -} - -bool ThreadedSocketConnection::exitThreadMain() { - terminate_flag_ = true; - Notify(); - return true; + return Notify(); } void ThreadedSocketConnection::threadMain() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); controller_->ConnectionCreated(this, device_uid_, app_handle_); ConnectError* connect_error = NULL; - if (Establish(&connect_error)) { - LOG4CXX_DEBUG(logger_, "Connection established (#" << pthread_self() << ")"); - controller_->ConnectDone(device_handle(), application_handle()); - while (!terminate_flag_) { - Transmit(); - } - LOG4CXX_DEBUG(logger_, "Connection is to finalize (#" << pthread_self() << ")"); - Finalize(); - while (!frames_to_send_.empty()) { - LOG4CXX_INFO(logger_, "removing message (#" << pthread_self() << ")"); - ::protocol_handler::RawMessagePtr message = frames_to_send_.front(); - frames_to_send_.pop(); - controller_->DataSendFailed(device_handle(), application_handle(), - message, DataSendError()); - } - controller_->DisconnectDone(device_handle(), application_handle()); - } else { - LOG4CXX_ERROR(logger_, "Connection Establish failed (#" << pthread_self() << ")"); - controller_->ConnectFailed(device_handle(), application_handle(), - *connect_error); + if (!Establish(&connect_error)) { + LOG4CXX_ERROR(logger_, "Connection Establish failed"); delete connect_error; } - if (-1 != read_fd_) { - close(read_fd_); + LOG4CXX_DEBUG(logger_, "Connection established"); + controller_->ConnectDone(device_handle(), application_handle()); + while (!terminate_flag_) { + Transmit(); } - if (-1 != write_fd_) { - close(write_fd_); + LOG4CXX_DEBUG(logger_, "Connection is to finalize"); + Finalize(); + sync_primitives::AutoLock auto_lock(frames_to_send_mutex_); + while (!frames_to_send_.empty()) { + LOG4CXX_INFO(logger_, "removing message"); + ::protocol_handler::RawMessagePtr message = frames_to_send_.front(); + frames_to_send_.pop(); + controller_->DataSendFailed(device_handle(), application_handle(), + message, DataSendError()); } - LOG4CXX_TRACE(logger_, "exit"); } void ThreadedSocketConnection::Transmit() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); - const nfds_t poll_fds_size = 2; - pollfd poll_fds[poll_fds_size]; + const nfds_t kPollFdsSize = 2; + pollfd poll_fds[kPollFdsSize]; poll_fds[0].fd = socket_; - poll_fds[0].events = POLLIN | POLLPRI | (frames_to_send_.empty() ? 0 : POLLOUT); + poll_fds[0].events = POLLIN | POLLPRI + | (frames_to_send_.empty() ? 0 : POLLOUT); poll_fds[1].fd = read_fd_; poll_fds[1].events = POLLIN | POLLPRI; - LOG4CXX_DEBUG(logger_, "poll (#" << pthread_self() << ") " << this); - if (-1 == poll(poll_fds, poll_fds_size, -1)) { + LOG4CXX_DEBUG(logger_, "poll " << this); + if (-1 == poll(poll_fds, kPollFdsSize, -1)) { LOG4CXX_ERROR_WITH_ERRNO(logger_, "poll failed for connection " << this); Abort(); - LOG4CXX_TRACE(logger_, "exit. Condition: -1 == poll(poll_fds, poll_fds_size, -1)"); return; } - LOG4CXX_DEBUG(logger_, "poll is ok (#" << pthread_self() << ") " << this << " revents0:" - << - std::hex << poll_fds[0].revents << " revents1:" << std::hex << poll_fds[1].revents); + LOG4CXX_DEBUG( + logger_, + "poll is ok " << this << " revents0: " << std::hex << poll_fds[0].revents << + " revents1:" << std::hex << poll_fds[1].revents); // error check if (0 != (poll_fds[1].revents & (POLLERR | POLLHUP | POLLNVAL))) { LOG4CXX_ERROR(logger_, "Notification pipe for connection " << this << " terminated"); Abort(); - LOG4CXX_TRACE(logger_, - "exit. Condition: 0 != (poll_fds[1].revents & (POLLERR | POLLHUP | POLLNVAL))"); return; } if (poll_fds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) { LOG4CXX_WARN(logger_, "Connection " << this << " terminated"); Abort(); - LOG4CXX_TRACE(logger_, - "exit. Condition: poll_fds[0].revents & (POLLERR | POLLHUP | POLLNVAL"); return; } @@ -250,20 +228,18 @@ void ThreadedSocketConnection::Transmit() { LOG4CXX_ERROR_WITH_ERRNO(logger_, "Failed to clear notification pipe"); LOG4CXX_ERROR_WITH_ERRNO(logger_, "poll failed for connection " << this); Abort(); - LOG4CXX_TRACE(logger_, "exit. Condition: (bytes_read < 0) && (EAGAIN != errno)"); return; } // send data if possible if (!frames_to_send_.empty() && (poll_fds[0].revents | POLLOUT)) { - LOG4CXX_DEBUG(logger_, "frames_to_send_ not empty() (#" << pthread_self() << ")"); + LOG4CXX_DEBUG(logger_, "frames_to_send_ not empty() "); // send data const bool send_ok = Send(); if (!send_ok) { - LOG4CXX_ERROR(logger_, "Send() failed (#" << pthread_self() << ")"); + LOG4CXX_ERROR(logger_, "Send() failed "); Abort(); - LOG4CXX_TRACE(logger_, "exit. Condition: !send_ok"); return; } } @@ -272,17 +248,15 @@ void ThreadedSocketConnection::Transmit() { if (poll_fds[0].revents & (POLLIN | POLLPRI)) { const bool receive_ok = Receive(); if (!receive_ok) { - LOG4CXX_ERROR(logger_, "Receive() failed (#" << pthread_self() << ")"); + LOG4CXX_ERROR(logger_, "Receive() failed "); Abort(); - LOG4CXX_TRACE(logger_, "exit. Condition: !receive_ok"); return; } } - LOG4CXX_TRACE(logger_, "exit"); } bool ThreadedSocketConnection::Receive() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); uint8_t buffer[4096]; ssize_t bytes_read = -1; @@ -291,8 +265,8 @@ bool ThreadedSocketConnection::Receive() { if (bytes_read > 0) { LOG4CXX_DEBUG( - logger_, - "Received " << bytes_read << " bytes for connection " << this); + logger_, + "Received " << bytes_read << " bytes for connection " << this); ::protocol_handler::RawMessagePtr frame( new protocol_handler::RawMessage(0, 0, buffer, bytes_read)); controller_->DataReceiveDone(device_handle(), application_handle(), @@ -301,36 +275,33 @@ bool ThreadedSocketConnection::Receive() { if (EAGAIN != errno && EWOULDBLOCK != errno) { LOG4CXX_ERROR_WITH_ERRNO(logger_, "recv() failed for connection " << this); - LOG4CXX_TRACE(logger_, - "exit with FALSE. Condition: EAGAIN != errno && EWOULDBLOCK != errno"); return false; } } else { LOG4CXX_WARN(logger_, "Connection " << this << " closed by remote peer"); - LOG4CXX_TRACE(logger_, "exit with FALSE. Condition: bytes_read >= 0"); return false; } } while (bytes_read > 0); - LOG4CXX_TRACE(logger_, "exit with TRUE"); + return true; } bool ThreadedSocketConnection::Send() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); FrameQueue frames_to_send; - pthread_mutex_lock(&frames_to_send_mutex_); + frames_to_send_mutex_.Acquire(); std::swap(frames_to_send, frames_to_send_); - pthread_mutex_unlock(&frames_to_send_mutex_); + frames_to_send_mutex_.Release(); size_t offset = 0; while (!frames_to_send.empty()) { - LOG4CXX_INFO(logger_, "frames_to_send is not empty" << pthread_self() << ")"); + LOG4CXX_INFO(logger_, "frames_to_send is not empty"); ::protocol_handler::RawMessagePtr frame = frames_to_send.front(); const ssize_t bytes_sent = ::send(socket_, frame->data() + offset, frame->data_size() - offset, 0); if (bytes_sent >= 0) { - LOG4CXX_DEBUG(logger_, "bytes_sent >= 0" << pthread_self() << ")"); + LOG4CXX_DEBUG(logger_, "bytes_sent >= 0"); offset += bytes_sent; if (offset == frame->data_size()) { frames_to_send.pop(); @@ -338,7 +309,7 @@ bool ThreadedSocketConnection::Send() { controller_->DataSendDone(device_handle(), application_handle(), frame); } } else { - LOG4CXX_DEBUG(logger_, "bytes_sent < 0" << pthread_self() << ")"); + LOG4CXX_DEBUG(logger_, "bytes_sent < 0"); LOG4CXX_ERROR_WITH_ERRNO(logger_, "Send failed for connection " << this); frames_to_send.pop(); offset = 0; @@ -346,9 +317,24 @@ bool ThreadedSocketConnection::Send() { DataSendError()); } } - LOG4CXX_TRACE(logger_, "exit with TRUE"); + return true; } -} // namespace -} // namespace +ThreadedSocketConnection::SocketConnectionDelegate::SocketConnectionDelegate( + ThreadedSocketConnection* connection) + : connection_(connection) { +} + +void ThreadedSocketConnection::SocketConnectionDelegate::threadMain() { + LOG4CXX_AUTO_TRACE(logger_); + DCHECK(connection_); + connection_->threadMain(); +} + +void ThreadedSocketConnection::SocketConnectionDelegate::exitThreadMain() { + LOG4CXX_AUTO_TRACE(logger_); +} + +} // namespace transport_adapter +} // namespace transport_manager diff --git a/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc b/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc index 3330e93e31..d45143a900 100644 --- a/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc +++ b/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc @@ -53,56 +53,64 @@ TransportAdapterImpl::TransportAdapterImpl( devices_(), devices_mutex_(), connections_(), - connections_mutex_(), - device_scanner_(device_scanner), - server_connection_factory_(server_connection_factory), - client_connection_listener_(client_connection_listener) + connections_lock_(), #ifdef TIME_TESTER - , metric_observer_(NULL) + metric_observer_(NULL), #endif // TIME_TESTER -{ - pthread_mutex_init(&devices_mutex_, 0); - pthread_mutex_init(&connections_mutex_, 0); + device_scanner_(device_scanner), + server_connection_factory_(server_connection_factory), + client_connection_listener_(client_connection_listener) { } TransportAdapterImpl::~TransportAdapterImpl() { + Terminate(); + + if (device_scanner_) { + LOG4CXX_DEBUG(logger_, "Deleting device_scanner_ " << device_scanner_); + delete device_scanner_; + LOG4CXX_DEBUG(logger_, "device_scanner_ deleted."); + } + if (server_connection_factory_) { + LOG4CXX_DEBUG(logger_, "Deleting server_connection_factory " << server_connection_factory_); + delete server_connection_factory_; + LOG4CXX_DEBUG(logger_, "server_connection_factory deleted."); + } + if (client_connection_listener_) { + LOG4CXX_DEBUG(logger_, "Deleting client_connection_listener_ " << client_connection_listener_); + delete client_connection_listener_; + LOG4CXX_DEBUG(logger_, "client_connection_listener_ deleted."); + } +} + +void TransportAdapterImpl::Terminate() { if (device_scanner_) { device_scanner_->Terminate(); LOG4CXX_DEBUG(logger_, "device_scanner_ " << device_scanner_ << " terminated."); - delete device_scanner_; - LOG4CXX_DEBUG(logger_, "device_scanner_ " << device_scanner_ << " deleted."); } if (server_connection_factory_) { server_connection_factory_->Terminate(); LOG4CXX_DEBUG(logger_, "server_connection_factory " << server_connection_factory_ << " terminated."); - delete server_connection_factory_; - LOG4CXX_DEBUG(logger_, "server_connection_factory " << server_connection_factory_ << " deleted."); } if (client_connection_listener_) { client_connection_listener_->Terminate(); LOG4CXX_DEBUG(logger_, "client_connection_listener_ " << client_connection_listener_ << " terminated."); - delete client_connection_listener_; - LOG4CXX_DEBUG(logger_, "client_connection_listener_ " << client_connection_listener_ << " deleted."); } - pthread_mutex_lock(&connections_mutex_); ConnectionMap connections; + connections_lock_.AcquireForWriting(); std::swap(connections, connections_); - pthread_mutex_unlock(&connections_mutex_); + connections_lock_.Release(); connections.clear(); LOG4CXX_DEBUG(logger_, "Connections deleted"); - pthread_mutex_lock(&devices_mutex_); + devices_mutex_.Acquire(); DeviceMap devices; std::swap(devices, devices_); - pthread_mutex_unlock(&devices_mutex_); + devices_mutex_.Release(); devices.clear(); LOG4CXX_DEBUG(logger_, "Devices deleted"); - - pthread_mutex_destroy(&connections_mutex_); - pthread_mutex_destroy(&devices_mutex_); } TransportAdapter::Error TransportAdapterImpl::Init() { @@ -159,7 +167,7 @@ TransportAdapter::Error TransportAdapterImpl::Connect( return BAD_STATE; } - pthread_mutex_lock(&connections_mutex_); + connections_lock_.AcquireForWriting(); const bool already_exists = connections_.end() != connections_.find(std::make_pair(device_id, app_handle)); @@ -169,7 +177,7 @@ TransportAdapter::Error TransportAdapterImpl::Connect( info.device_id = device_id; info.state = ConnectionInfo::NEW; } - pthread_mutex_unlock(&connections_mutex_); + connections_lock_.Release(); if (already_exists) { LOG4CXX_TRACE(logger_, "exit with ALREADY_EXISTS"); return ALREADY_EXISTS; @@ -178,9 +186,9 @@ TransportAdapter::Error TransportAdapterImpl::Connect( const TransportAdapter::Error err = server_connection_factory_->CreateConnection(device_id, app_handle); if (TransportAdapter::OK != err) { - pthread_mutex_lock(&connections_mutex_); + connections_lock_.AcquireForWriting(); connections_.erase(std::make_pair(device_id, app_handle)); - pthread_mutex_unlock(&connections_mutex_); + connections_lock_.Release(); } LOG4CXX_TRACE(logger_, "exit with error: " << err); return err; @@ -208,7 +216,7 @@ TransportAdapter::Error TransportAdapterImpl::Disconnect( LOG4CXX_TRACE(logger_, "exit with BAD_STATE"); return BAD_STATE; } - Connection* connection = FindEstablishedConnection(device_id, app_handle); + ConnectionSPtr connection = FindEstablishedConnection(device_id, app_handle); if (connection) { TransportAdapter::Error err = connection->Disconnect(); LOG4CXX_TRACE(logger_, "exit with error: " << err); @@ -228,21 +236,25 @@ TransportAdapter::Error TransportAdapterImpl::DisconnectDevice( } Error error = OK; - pthread_mutex_lock(&connections_mutex_); - for (ConnectionMap::iterator it = connections_.begin(); - it != connections_.end(); ++it) { - ConnectionInfo& info = it->second; - if (info.device_id == device_id && - info.state != ConnectionInfo::FINALISING) { - if (OK != info.connection->Disconnect()) { - error = FAIL; - LOG4CXX_ERROR(logger_, "Error on disconnect" << error); - } + std::vector<ConnectionInfo> to_disconnect; + connections_lock_.AcquireForReading(); + for (ConnectionMap::const_iterator i = connections_.begin(); i != connections_.end(); ++i) { + ConnectionInfo info = i->second; + if (info.device_id == device_id && info.state != ConnectionInfo::FINALISING) { + to_disconnect.push_back(info); } } - pthread_mutex_unlock(&connections_mutex_); - LOG4CXX_TRACE(logger_, "exit with error " << error); + connections_lock_.Release(); + + for (std::vector<ConnectionInfo>::const_iterator j = to_disconnect.begin(); j != to_disconnect.end(); ++j) { + ConnectionInfo info = *j; + if (OK != info.connection->Disconnect()) { + error = FAIL; + LOG4CXX_ERROR(logger_, "Error on disconnect " << error); + } + } + return error; } @@ -256,7 +268,7 @@ TransportAdapter::Error TransportAdapterImpl::SendData( return BAD_STATE; } - Connection* connection = FindEstablishedConnection(device_id, app_handle); + ConnectionSPtr connection = FindEstablishedConnection(device_id, app_handle); if (connection) { TransportAdapter::Error err = connection->SendData(data); LOG4CXX_TRACE(logger_, "exit with error: " << err); @@ -293,19 +305,23 @@ TransportAdapter::Error TransportAdapterImpl::StopClientListening() { return BAD_STATE; } TransportAdapter::Error err = client_connection_listener_->StopListening(); + for(DeviceMap::iterator it = devices_.begin(); + it != devices_.end(); + ++it) { + it->second->Stop(); + } LOG4CXX_TRACE(logger_, "exit with error: " << err); return err; } DeviceList TransportAdapterImpl::GetDeviceList() const { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); DeviceList devices; - pthread_mutex_lock(&devices_mutex_); + sync_primitives::AutoLock locker(devices_mutex_); for (DeviceMap::const_iterator it = devices_.begin(); it != devices_.end(); ++it) { devices.push_back(it->first); } - pthread_mutex_unlock(&devices_mutex_); LOG4CXX_TRACE(logger_, "exit with DeviceList. It's' size = " << devices.size()); return devices; } @@ -314,7 +330,7 @@ DeviceSptr TransportAdapterImpl::AddDevice(DeviceSptr device) { LOG4CXX_TRACE(logger_, "enter. device: " << device); DeviceSptr existing_device; bool same_device_found = false; - pthread_mutex_lock(&devices_mutex_); + devices_mutex_.Acquire(); for (DeviceMap::const_iterator i = devices_.begin(); i != devices_.end(); ++i) { existing_device = i->second; @@ -327,7 +343,7 @@ DeviceSptr TransportAdapterImpl::AddDevice(DeviceSptr device) { if (!same_device_found) { devices_[device->unique_device_id()] = device; } - pthread_mutex_unlock(&devices_mutex_); + devices_mutex_.Release(); if (same_device_found) { LOG4CXX_TRACE(logger_, "exit with TRUE. Condition: same_device_found"); return existing_device; @@ -352,7 +368,7 @@ void TransportAdapterImpl::SearchDeviceDone(const DeviceVector& devices) { DeviceSptr device = *it; bool device_found = false; - pthread_mutex_lock(&devices_mutex_); + devices_mutex_.Acquire(); for (DeviceMap::iterator it = devices_.begin(); it != devices_.end(); ++it) { DeviceSptr existing_device = it->second; @@ -363,7 +379,7 @@ void TransportAdapterImpl::SearchDeviceDone(const DeviceVector& devices) { break; } } - pthread_mutex_unlock(&devices_mutex_); + devices_mutex_.Release(); if (!device_found) { LOG4CXX_INFO(logger_, "Adding new device " << device->unique_device_id() @@ -375,7 +391,7 @@ void TransportAdapterImpl::SearchDeviceDone(const DeviceVector& devices) { new_devices[device->unique_device_id()] = device; } - pthread_mutex_lock(&connections_mutex_); + connections_lock_.AcquireForReading(); std::set<DeviceUID> connected_devices; for (ConnectionMap::const_iterator it = connections_.begin(); it != connections_.end(); ++it) { @@ -384,10 +400,10 @@ void TransportAdapterImpl::SearchDeviceDone(const DeviceVector& devices) { connected_devices.insert(info.device_id); } } - pthread_mutex_unlock(&connections_mutex_); + connections_lock_.Release(); DeviceMap all_devices = new_devices; - pthread_mutex_lock(&devices_mutex_); + devices_mutex_.Acquire(); for (DeviceMap::iterator it = devices_.begin(); it != devices_.end(); ++it) { DeviceSptr existing_device = it->second; @@ -399,7 +415,7 @@ void TransportAdapterImpl::SearchDeviceDone(const DeviceVector& devices) { } } devices_ = all_devices; - pthread_mutex_unlock(&devices_mutex_); + devices_mutex_.Release(); for (TransportAdapterListenerList::iterator it = listeners_.begin(); it != listeners_.end(); ++it) { @@ -453,24 +469,22 @@ bool TransportAdapterImpl::IsServerOriginatedConnectSupported() const { } bool TransportAdapterImpl::IsClientOriginatedConnectSupported() const { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_TRACE(logger_, "IsClientOriginatedConnectSupported"); return client_connection_listener_ != 0; - LOG4CXX_TRACE(logger_, "exit"); } void TransportAdapterImpl::ConnectionCreated( - Connection* connection, const DeviceUID& device_id, + ConnectionSPtr connection, const DeviceUID& device_id, const ApplicationHandle& app_handle) { LOG4CXX_TRACE(logger_, "enter connection:" << connection << ", device_id: " << &device_id << ", app_handle: " << &app_handle); - pthread_mutex_lock(&connections_mutex_); + connections_lock_.AcquireForReading(); ConnectionInfo& info = connections_[std::make_pair(device_id, app_handle)]; info.app_handle = app_handle; info.device_id = device_id; info.connection = connection; info.state = ConnectionInfo::NEW; - pthread_mutex_unlock(&connections_mutex_); - LOG4CXX_TRACE(logger_, "exit"); + connections_lock_.Release(); } void TransportAdapterImpl::DeviceDisconnected( @@ -488,42 +502,55 @@ void TransportAdapterImpl::DeviceDisconnected( } } - pthread_mutex_lock(&connections_mutex_); for (TransportAdapterListenerList::iterator it = listeners_.begin(); it != listeners_.end(); ++it) { TransportAdapterListener* listener = *it; listener->OnDisconnectDeviceDone(this, device_uid); } + + connections_lock_.AcquireForWriting(); for (ApplicationList::const_iterator i = app_list.begin(); i != app_list.end(); ++i) { ApplicationHandle app_handle = *i; connections_.erase(std::make_pair(device_uid, app_handle)); } - pthread_mutex_unlock(&connections_mutex_); + connections_lock_.Release(); RemoveDevice(device_uid); LOG4CXX_TRACE(logger_, "exit"); } -void TransportAdapterImpl::DisconnectDone( - const DeviceUID& device_handle, const ApplicationHandle& app_handle) { - const DeviceUID device_uid = device_handle; - const ApplicationHandle app_uid = app_handle; - LOG4CXX_TRACE(logger_, "enter. device_id: " << &device_uid << ", app_handle: " << - &app_uid); - bool device_disconnected = true; - pthread_mutex_lock(&connections_mutex_); +bool TransportAdapterImpl::IsSingleApplication(const DeviceUID& device_uid, + const ApplicationHandle& app_uid) { + sync_primitives::AutoReadLock locker(connections_lock_); for (ConnectionMap::const_iterator it = connections_.begin(); it != connections_.end(); ++it) { const DeviceUID& current_device_id = it->first.first; const ApplicationHandle& current_app_handle = it->first.second; if (current_device_id == device_uid && current_app_handle != app_uid) { - device_disconnected = false; LOG4CXX_DEBUG(logger_, "break. Condition: current_device_id == device_id && current_app_handle != app_handle"); - break; + + return false; } } - pthread_mutex_unlock(&connections_mutex_); + return true; +} + +void TransportAdapterImpl::DisconnectDone( + const DeviceUID& device_handle, const ApplicationHandle& app_handle) { + const DeviceUID device_uid = device_handle; + const ApplicationHandle app_uid = app_handle; + LOG4CXX_TRACE(logger_, "enter. device_id: " << &device_uid << ", app_handle: " << + &app_uid); + DeviceSptr device = FindDevice(device_handle); + if (!device) { + LOG4CXX_WARN(logger_, "Device: uid " << &device_uid << " not found"); + return; + } + + bool device_disconnected = ToBeAutoDisconnected(device) && + IsSingleApplication(device_uid, app_uid); + for (TransportAdapterListenerList::iterator it = listeners_.begin(); it != listeners_.end(); ++it) { TransportAdapterListener* listener = *it; @@ -532,9 +559,9 @@ void TransportAdapterImpl::DisconnectDone( listener->OnDisconnectDeviceDone(this, device_uid); } } - pthread_mutex_lock(&connections_mutex_); + connections_lock_.AcquireForWriting(); connections_.erase(std::make_pair(device_uid, app_uid)); - pthread_mutex_unlock(&connections_mutex_); + connections_lock_.Release(); if (device_disconnected) { RemoveDevice(device_uid); @@ -600,14 +627,13 @@ DeviceSptr TransportAdapterImpl::FindDevice(const DeviceUID& device_id) const { LOG4CXX_TRACE(logger_, "enter. device_id: " << &device_id); DeviceSptr ret; LOG4CXX_DEBUG(logger_, "devices_.size() = " << devices_.size()); - pthread_mutex_lock(&devices_mutex_); + sync_primitives::AutoLock locker(devices_mutex_); DeviceMap::const_iterator it = devices_.find(device_id); if (it != devices_.end()) { ret = it->second; } else { LOG4CXX_WARN(logger_, "Device " << device_id << " not found."); } - pthread_mutex_unlock(&devices_mutex_); LOG4CXX_TRACE(logger_, "exit with DeviceSptr: " << ret); return ret; } @@ -616,14 +642,14 @@ void TransportAdapterImpl::ConnectDone(const DeviceUID& device_id, const ApplicationHandle& app_handle) { LOG4CXX_TRACE(logger_, "enter. device_id: " << &device_id << ", app_handle: " << &app_handle); - pthread_mutex_lock(&connections_mutex_); + connections_lock_.AcquireForReading(); ConnectionMap::iterator it_conn = connections_.find(std::make_pair(device_id, app_handle)); if (it_conn != connections_.end()) { ConnectionInfo& info = it_conn->second; info.state = ConnectionInfo::ESTABLISHED; } - pthread_mutex_unlock(&connections_mutex_); + connections_lock_.Release(); for (TransportAdapterListenerList::iterator it = listeners_.begin(); it != listeners_.end(); ++it) { @@ -640,9 +666,9 @@ void TransportAdapterImpl::ConnectFailed(const DeviceUID& device_handle, const ApplicationHandle app_uid = app_handle; LOG4CXX_TRACE(logger_, "enter. device_id: " << &device_uid << ", app_handle: " << &app_uid << ", error: " << &error); - pthread_mutex_lock(&connections_mutex_); + connections_lock_.AcquireForWriting(); connections_.erase(std::make_pair(device_uid, app_uid)); - pthread_mutex_unlock(&connections_mutex_); + connections_lock_.Release(); for (TransportAdapterListenerList::iterator it = listeners_.begin(); it != listeners_.end(); ++it) { (*it)->OnConnectFailed(this, device_uid, app_uid, error); @@ -674,15 +700,14 @@ void TransportAdapterImpl::ConnectionFinished( const DeviceUID& device_id, const ApplicationHandle& app_handle) { LOG4CXX_TRACE(logger_, "enter. device_id: " << &device_id << ", app_handle: " << &app_handle); - pthread_mutex_lock(&connections_mutex_); + connections_lock_.AcquireForReading(); ConnectionMap::iterator it = connections_.find(std::make_pair(device_id, app_handle)); if (it != connections_.end()) { ConnectionInfo& info = it->second; info.state = ConnectionInfo::FINALISING; } - pthread_mutex_unlock(&connections_mutex_); - LOG4CXX_TRACE(logger_, "exit"); + connections_lock_.Release(); } void TransportAdapterImpl::ConnectionAborted( @@ -763,12 +788,16 @@ bool TransportAdapterImpl::ToBeAutoConnected(DeviceSptr device) const { return false; } -Connection* TransportAdapterImpl::FindEstablishedConnection( +bool TransportAdapterImpl::ToBeAutoDisconnected(DeviceSptr device) const { + return true; +} + +ConnectionSPtr TransportAdapterImpl::FindEstablishedConnection( const DeviceUID& device_id, const ApplicationHandle& app_handle) const { LOG4CXX_TRACE(logger_, "enter. device_id: " << &device_id << ", app_handle: " << &app_handle); - Connection* connection = NULL; - pthread_mutex_lock(&connections_mutex_); + ConnectionSPtr connection; + connections_lock_.AcquireForReading(); ConnectionMap::const_iterator it = connections_.find(std::make_pair(device_id, app_handle)); if (it != connections_.end()) { @@ -777,7 +806,7 @@ Connection* TransportAdapterImpl::FindEstablishedConnection( connection = info.connection; } } - pthread_mutex_unlock(&connections_mutex_); + connections_lock_.Release(); LOG4CXX_TRACE(logger_, "exit with Connection: " << connection); return connection; } @@ -820,10 +849,10 @@ TransportAdapter::Error TransportAdapterImpl::ConnectDevice(DeviceSptr device) { } void TransportAdapterImpl::RemoveDevice(const DeviceUID& device_handle) { - LOG4CXX_TRACE(logger_, "enter. device_handle: " << &device_handle); - pthread_mutex_lock(&devices_mutex_); - DeviceMap::iterator i = devices_.find( - device_handle); //ykazakov: there is no erase for const iterator on QNX + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "Device_handle: " << &device_handle); + sync_primitives::AutoLock locker(devices_mutex_); + DeviceMap::iterator i = devices_.find(device_handle); if (i != devices_.end()) { DeviceSptr device = i->second; if (!device->keep_on_disconnect()) { @@ -835,11 +864,7 @@ void TransportAdapterImpl::RemoveDevice(const DeviceUID& device_handle) { } } } - pthread_mutex_unlock(&devices_mutex_); - LOG4CXX_TRACE(logger_, "exit"); } - } // namespace transport_adapter - } // namespace transport_manager diff --git a/src/components/transport_manager/src/transport_manager_default.cc b/src/components/transport_manager/src/transport_manager_default.cc index ffd1b3d860..835c2c17ed 100644 --- a/src/components/transport_manager/src/transport_manager_default.cc +++ b/src/components/transport_manager/src/transport_manager_default.cc @@ -43,7 +43,6 @@ #include "transport_manager/bluetooth/bluetooth_transport_adapter.h" #endif -// CUSTOMER_PASA #if defined(USB_SUPPORT) #include "transport_manager/usb/usb_aoa_adapter.h" @@ -72,6 +71,8 @@ int TransportManagerDefault::Init() { #endif // TIME_TESTER AddTransportAdapter(ta); #endif + + uint16_t port = profile::Profile::instance()->transport_manager_tcp_adapter_port(); ta = new transport_adapter::TcpTransportAdapter(port); #ifdef TIME_TESTER @@ -81,7 +82,6 @@ int TransportManagerDefault::Init() { #endif // TIME_TESTER AddTransportAdapter(ta); -// CUSTOMER_PASA #if defined(USB_SUPPORT) ta = new transport_adapter::UsbAoaAdapter(); diff --git a/src/components/transport_manager/src/transport_manager_impl.cc b/src/components/transport_manager/src/transport_manager_impl.cc index 0ee1d3304d..6c3edd7b91 100644 --- a/src/components/transport_manager/src/transport_manager_impl.cc +++ b/src/components/transport_manager/src/transport_manager_impl.cc @@ -32,7 +32,6 @@ #include "transport_manager/transport_manager_impl.h" -#include <pthread.h> #include <stdint.h> #include <cstring> #include <queue> @@ -70,22 +69,20 @@ TransportManagerImpl::Connection TransportManagerImpl::convert( } TransportManagerImpl::TransportManagerImpl() - : all_thread_active_(false), - device_listener_thread_wakeup_(), - is_initialized_(false), + : is_initialized_(false), #ifdef TIME_TESTER metric_observer_(NULL), #endif // TIME_TESTER connection_id_counter_(0), message_queue_("TM MessageQueue", this), event_queue_("TM EventQueue", this) { - LOG4CXX_INFO(logger_, "=============================================="); - pthread_cond_init(&device_listener_thread_wakeup_, NULL); - LOG4CXX_DEBUG(logger_, "TransportManager object created"); + LOG4CXX_TRACE(logger_, "TransportManager has created"); } TransportManagerImpl::~TransportManagerImpl() { LOG4CXX_DEBUG(logger_, "TransportManager object destroying"); + message_queue_.Shutdown(); + event_queue_.Shutdown(); for (std::vector<TransportAdapter*>::iterator it = transport_adapters_.begin(); @@ -99,7 +96,6 @@ TransportManagerImpl::~TransportManagerImpl() { delete it->second; } - pthread_cond_destroy(&device_listener_thread_wakeup_); LOG4CXX_INFO(logger_, "TransportManager object destroyed"); } @@ -226,18 +222,48 @@ int TransportManagerImpl::AddEventListener(TransportManagerListener* listener) { return E_SUCCESS; } +void TransportManagerImpl::DisconnectAllDevices() { + LOG4CXX_AUTO_TRACE(logger_); + for (DeviceInfoList::iterator i = device_list_.begin(); + i != device_list_.end(); ++i) { + DeviceInfo& device = i->second; + DisconnectDevice(device.device_handle()); + } +} + +void TransportManagerImpl::TerminateAllAdapters() { + LOG4CXX_AUTO_TRACE(logger_); + for (std::vector<TransportAdapter*>::iterator i = transport_adapters_.begin(); + i != transport_adapters_.end(); ++i) { + (*i)->Terminate(); + } +} + +int TransportManagerImpl::InitAllAdapters() { + LOG4CXX_AUTO_TRACE(logger_); + for (std::vector<TransportAdapter*>::iterator i = transport_adapters_.begin(); + i != transport_adapters_.end(); ++i) { + if ((*i)->Init() != TransportAdapter::OK) { + return E_ADAPTERS_FAIL; + } + } + return E_SUCCESS; +} + int TransportManagerImpl::Stop() { - LOG4CXX_TRACE(logger_, "enter"); - if (!all_thread_active_) { - LOG4CXX_TRACE(logger_, - "exit with E_TM_IS_NOT_INITIALIZED. Condition: !all_thread_active_"); + LOG4CXX_AUTO_TRACE(logger_); + if (!is_initialized_) { + LOG4CXX_WARN(logger_, "TransportManager is not initialized_"); return E_TM_IS_NOT_INITIALIZED; } - all_thread_active_ = false; - pthread_cond_signal(&device_listener_thread_wakeup_); + message_queue_.Shutdown(); + event_queue_.Shutdown(); - LOG4CXX_TRACE(logger_, "exit with E_SUCCESS"); + DisconnectAllDevices(); + TerminateAllAdapters(); + + is_initialized_ = false; return E_SUCCESS; } @@ -390,12 +416,19 @@ int TransportManagerImpl::SearchDevices() { int TransportManagerImpl::Init() { LOG4CXX_TRACE(logger_, "enter"); - all_thread_active_ = true; is_initialized_ = true; LOG4CXX_TRACE(logger_, "exit with E_SUCCESS"); return E_SUCCESS; } +int TransportManagerImpl::Reinit() { + LOG4CXX_AUTO_TRACE(logger_); + DisconnectAllDevices(); + TerminateAllAdapters(); + int ret = InitAllAdapters(); + return ret; +} + int TransportManagerImpl::Visibility(const bool& on_off) const { LOG4CXX_TRACE(logger_, "enter. On_off: " << &on_off); TransportAdapter::Error ret; @@ -478,10 +511,9 @@ void TransportManagerImpl::PostMessage(const ::protocol_handler::RawMessagePtr m } void TransportManagerImpl::PostEvent(const TransportAdapterEvent& event) { - LOG4CXX_TRACE(logger_, "enter. TransportAdapterEvent: " << &event); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "TransportAdapterEvent: " << &event); event_queue_.PostMessage(event); - pthread_cond_signal(&device_listener_thread_wakeup_); - LOG4CXX_TRACE(logger_, "exit"); } void TransportManagerImpl::AddConnection(const ConnectionInternal& c) { diff --git a/src/components/transport_manager/src/usb/libusb/platform_usb_device.cc b/src/components/transport_manager/src/usb/libusb/platform_usb_device.cc index 103e03a4f6..1ca1a54b32 100644 --- a/src/components/transport_manager/src/usb/libusb/platform_usb_device.cc +++ b/src/components/transport_manager/src/usb/libusb/platform_usb_device.cc @@ -1,4 +1,4 @@ -/** +/* * * Copyright (c) 2013, Ford Motor Company * All rights reserved. diff --git a/src/components/transport_manager/src/usb/libusb/usb_connection.cc b/src/components/transport_manager/src/usb/libusb/usb_connection.cc index 40891d3513..b8096514bc 100644 --- a/src/components/transport_manager/src/usb/libusb/usb_connection.cc +++ b/src/components/transport_manager/src/usb/libusb/usb_connection.cc @@ -30,6 +30,7 @@ * POSSIBILITY OF SUCH DAMAGE. */ +#include <pthread.h> #include <unistd.h> #include <iomanip> @@ -51,7 +52,7 @@ CREATE_LOGGERPTR_GLOBAL(logger_, "TransportManager") UsbConnection::UsbConnection(const DeviceUID& device_uid, const ApplicationHandle& app_handle, TransportAdapterController* controller, - const UsbHandlerSptr& usb_handler, + const UsbHandlerSptr usb_handler, PlatformUsbDevice* device) : device_uid_(device_uid), app_handle_(app_handle), diff --git a/src/components/transport_manager/src/usb/libusb/usb_handler.cc b/src/components/transport_manager/src/usb/libusb/usb_handler.cc index eb0ffdb4dc..776bb56c5d 100644 --- a/src/components/transport_manager/src/usb/libusb/usb_handler.cc +++ b/src/components/transport_manager/src/usb/libusb/usb_handler.cc @@ -1,4 +1,4 @@ -/** +/* * \file usb_handler.cc * \brief UsbHandler class source file. * @@ -39,7 +39,9 @@ #include "transport_manager/usb/common.h" #include "transport_manager/transport_adapter/transport_adapter_impl.h" +#include "utils/macro.h" #include "utils/logger.h" +#include "utils/threads/thread.h" namespace transport_manager { namespace transport_adapter { @@ -75,14 +77,16 @@ class UsbHandler::ControlTransferSequenceState { UsbHandler::UsbHandler() : shutdown_requested_(false), - thread_(), + thread_(NULL), usb_device_listeners_(), devices_(), transfer_sequences_(), device_handles_to_close_(), libusb_context_(NULL), arrived_callback_handle_(), - left_callback_handle_() {} + left_callback_handle_() { + thread_ = threads::CreateThread("UsbHandler", new UsbHandlerDelegate(this)); +} UsbHandler::~UsbHandler() { shutdown_requested_ = true; @@ -91,12 +95,15 @@ UsbHandler::~UsbHandler() { arrived_callback_handle_); libusb_hotplug_deregister_callback(libusb_context_, left_callback_handle_); } - pthread_join(thread_, 0); + thread_->stop(); LOG4CXX_INFO(logger_, "UsbHandler thread finished"); if (libusb_context_) { libusb_exit(libusb_context_); libusb_context_ = 0; } + thread_->join(); + delete thread_->delegate(); + threads::DeleteThread(thread_); } void UsbHandler::DeviceArrived(libusb_device* device_libusb) { @@ -209,11 +216,6 @@ void UsbHandler::CloseDeviceHandle(libusb_device_handle* device_handle) { device_handles_to_close_.push_back(device_handle); } -void* UsbHandlerThread(void* data) { - static_cast<UsbHandler*>(data)->Thread(); - return 0; -} - int ArrivedCallback(libusb_context* context, libusb_device* device, libusb_hotplug_event event, void* data) { LOG4CXX_TRACE(logger_, "enter. libusb device arrived (bus number " @@ -286,19 +288,12 @@ TransportAdapter::Error UsbHandler::Init() { return TransportAdapter::FAIL; } - const int thread_start_error = - pthread_create(&thread_, 0, &UsbHandlerThread, this); - if (0 != thread_start_error) { - LOG4CXX_ERROR(logger_, "USB device scanner thread start failed, error code " - << thread_start_error); + if (!thread_->start()) { + LOG4CXX_ERROR(logger_, "USB device scanner thread start failed, error code"); LOG4CXX_TRACE(logger_, - "exit with TransportAdapter::FAIL. Condition: 0 !== thread_start_error"); + "exit with TransportAdapter::FAIL."); return TransportAdapter::FAIL; } - LOG4CXX_INFO(logger_, "UsbHandler thread started"); - pthread_setname_np(thread_, "UsbHandler" ); - LOG4CXX_TRACE(logger_, - "exit with TransportAdapter::OK. Condition: 0 == thread_start_error"); return TransportAdapter::OK; } @@ -357,13 +352,13 @@ void UsbHandler::SubmitControlTransfer( assert(transfer->Type() == UsbControlTransfer::VENDOR); const libusb_request_type request_type = LIBUSB_REQUEST_TYPE_VENDOR; - libusb_endpoint_direction endpoint_direction; + libusb_endpoint_direction endpoint_direction = LIBUSB_ENDPOINT_IN; if (transfer->Direction() == UsbControlTransfer::IN) { endpoint_direction = LIBUSB_ENDPOINT_IN; } else if (transfer->Direction() == UsbControlTransfer::OUT) { endpoint_direction = LIBUSB_ENDPOINT_OUT; } else { - assert(0); + NOTREACHED(); } const uint8_t request = transfer->Request(); const uint16_t value = transfer->Value(); @@ -470,5 +465,16 @@ void UsbHandler::ControlTransferSequenceState::Finish() { finished_ = true; } -} // namespace -} // namespace +UsbHandler::UsbHandlerDelegate::UsbHandlerDelegate( + UsbHandler* handler) + : handler_(handler) { +} + +void UsbHandler::UsbHandlerDelegate::threadMain() { + LOG4CXX_AUTO_TRACE(logger_); + DCHECK(handler_); + handler_->Thread(); +} + +} // namespace transport_adapter +} // namespace transport_manager diff --git a/src/components/transport_manager/src/usb/qnx/platform_usb_device.cc b/src/components/transport_manager/src/usb/qnx/platform_usb_device.cc index 0f35a16ae7..132fe52cae 100644 --- a/src/components/transport_manager/src/usb/qnx/platform_usb_device.cc +++ b/src/components/transport_manager/src/usb/qnx/platform_usb_device.cc @@ -1,4 +1,4 @@ -/** +/* * \file platform_usb_device.cc * \brief QNX PlatformUsbDevice class source file. * diff --git a/src/components/transport_manager/src/usb/qnx/usb_connection.cc b/src/components/transport_manager/src/usb/qnx/usb_connection.cc index db3cac014d..a3844b2e04 100644 --- a/src/components/transport_manager/src/usb/qnx/usb_connection.cc +++ b/src/components/transport_manager/src/usb/qnx/usb_connection.cc @@ -50,7 +50,7 @@ CREATE_LOGGERPTR_GLOBAL(logger_, "TransportManager") UsbConnection::UsbConnection(const DeviceUID& device_uid, const ApplicationHandle& app_handle, TransportAdapterController* controller, - const UsbHandlerSptr& libusb_handler, + const UsbHandlerSptr libusb_handler, PlatformUsbDevice* device) : device_uid_(device_uid), app_handle_(app_handle), @@ -60,6 +60,7 @@ UsbConnection::UsbConnection(const DeviceUID& device_uid, in_pipe_(NULL), out_pipe_(NULL), in_buffer_(NULL), + out_buffer_(NULL), in_urb_(NULL), out_urb_(NULL), out_messages_(), @@ -69,7 +70,6 @@ UsbConnection::UsbConnection(const DeviceUID& device_uid, disconnecting_(false), pending_in_transfer_(false), pending_out_transfer_(false) { - pthread_mutex_init(&out_messages_mutex_, 0); } UsbConnection::~UsbConnection() { @@ -89,8 +89,6 @@ UsbConnection::~UsbConnection() { LOG4CXX_ERROR(logger_, "Failed to close pipe: " << close_pipe_rc); } } - - pthread_mutex_destroy(&out_messages_mutex_); } void InTransferCallback(usbd_urb* urb, usbd_pipe*, void* data) { @@ -212,7 +210,7 @@ void UsbConnection::OnOutTransfer(usbd_urb* urb) { } } - pthread_mutex_lock(&out_messages_mutex_); + sync_primitives::AutoLock locker(out_messages_mutex_); if (error) { LOG4CXX_ERROR(logger_, "USB out transfer failed"); @@ -234,14 +232,13 @@ void UsbConnection::OnOutTransfer(usbd_urb* urb) { } else { pending_out_transfer_ = false; } - pthread_mutex_unlock(&out_messages_mutex_); } TransportAdapter::Error UsbConnection::SendData(::protocol_handler::RawMessagePtr message) { if (disconnecting_) { return TransportAdapter::BAD_STATE; } - pthread_mutex_lock(&out_messages_mutex_); + sync_primitives::AutoLock locker(out_messages_mutex_); if (current_out_message_.valid()) { out_messages_.push_back(message); } else { @@ -251,13 +248,12 @@ TransportAdapter::Error UsbConnection::SendData(::protocol_handler::RawMessagePt DataSendError()); } } - pthread_mutex_unlock(&out_messages_mutex_); return TransportAdapter::OK; } void UsbConnection::Finalise() { LOG4CXX_INFO(logger_, "Finalising"); - pthread_mutex_lock(&out_messages_mutex_); + sync_primitives::AutoLock locker(out_messages_mutex_); disconnecting_ = true; usbd_abort_pipe(in_pipe_); usbd_abort_pipe(out_pipe_); @@ -265,7 +261,6 @@ void UsbConnection::Finalise() { it != out_messages_.end(); it = out_messages_.erase(it)) { controller_->DataSendFailed(device_uid_, app_handle_, *it, DataSendError()); } - pthread_mutex_unlock(&out_messages_mutex_); while (pending_in_transfer_ || pending_out_transfer_) sched_yield(); } diff --git a/src/components/transport_manager/src/usb/qnx/usb_handler.cc b/src/components/transport_manager/src/usb/qnx/usb_handler.cc index 7ab36169b1..d78b6c8184 100644 --- a/src/components/transport_manager/src/usb/qnx/usb_handler.cc +++ b/src/components/transport_manager/src/usb/qnx/usb_handler.cc @@ -1,4 +1,4 @@ -/** +/* * \file usb_handler.cc * \brief UsbHandler class source file. * diff --git a/src/components/transport_manager/src/usb/usb_aoa_adapter.cc b/src/components/transport_manager/src/usb/usb_aoa_adapter.cc index 464b9ea35e..b3ebb104dc 100644 --- a/src/components/transport_manager/src/usb/usb_aoa_adapter.cc +++ b/src/components/transport_manager/src/usb/usb_aoa_adapter.cc @@ -1,4 +1,4 @@ -/** +/* * \file usb_aoa_adapter.cpp * \brief UsbAoaAdapter class source file. * diff --git a/src/components/transport_manager/src/usb/usb_connection_factory.cc b/src/components/transport_manager/src/usb/usb_connection_factory.cc index d57391ebcc..4562473536 100644 --- a/src/components/transport_manager/src/usb/usb_connection_factory.cc +++ b/src/components/transport_manager/src/usb/usb_connection_factory.cc @@ -54,7 +54,7 @@ TransportAdapter::Error UsbConnectionFactory::Init() { return TransportAdapter::OK; } -void UsbConnectionFactory::SetUsbHandler(const UsbHandlerSptr& usb_handler) { +void UsbConnectionFactory::SetUsbHandler(const UsbHandlerSptr usb_handler) { usb_handler_ = usb_handler; } diff --git a/src/components/transport_manager/src/usb/usb_device_scanner.cc b/src/components/transport_manager/src/usb/usb_device_scanner.cc index bf9535941c..bddc20dd3c 100644 --- a/src/components/transport_manager/src/usb/usb_device_scanner.cc +++ b/src/components/transport_manager/src/usb/usb_device_scanner.cc @@ -47,7 +47,8 @@ CREATE_LOGGERPTR_GLOBAL(logger_, "TransportManager") class AoaInitSequence : public UsbControlTransferSequence { public: AoaInitSequence(); - virtual ~AoaInitSequence() {} + virtual ~AoaInitSequence() { + } private: class AoaGetProtocolRequest; @@ -56,7 +57,7 @@ class AoaInitSequence : public UsbControlTransferSequence { }; void UsbDeviceScanner::OnDeviceArrived(PlatformUsbDevice* device) { - LOG4CXX_TRACE(logger_, "enter. PlatformUsbDevice* " << device); + LOG4CXX_AUTO_TRACE(logger_); if (IsAppleDevice(device)) { SupportedDeviceFound(device); } else { @@ -66,13 +67,13 @@ void UsbDeviceScanner::OnDeviceArrived(PlatformUsbDevice* device) { TurnIntoAccessoryMode(device); } } - LOG4CXX_TRACE(logger_, "exit"); } void UsbDeviceScanner::OnDeviceLeft(PlatformUsbDevice* device) { - LOG4CXX_TRACE(logger_, "enter. PlatformUsbDevice " << device); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "PlatformUsbDevice " << device); bool list_changed = false; - pthread_mutex_lock(&devices_mutex_); + devices_mutex_.Acquire(); for (Devices::iterator it = devices_.begin(); it != devices_.end(); ++it) { if (device == *it) { devices_.erase(it); @@ -80,24 +81,22 @@ void UsbDeviceScanner::OnDeviceLeft(PlatformUsbDevice* device) { break; } } - pthread_mutex_unlock(&devices_mutex_); + devices_mutex_.Release(); if (list_changed) { UpdateList(); } - LOG4CXX_TRACE(logger_, "exit"); } UsbDeviceScanner::UsbDeviceScanner(TransportAdapterController* controller) - : controller_(controller) { - pthread_mutex_init(&devices_mutex_, 0); + : controller_(controller) { } UsbDeviceScanner::~UsbDeviceScanner() { - pthread_mutex_destroy(&devices_mutex_); } class AoaInitSequence::AoaGetProtocolRequest : public UsbControlInTransfer { - virtual ~AoaGetProtocolRequest() {} + virtual ~AoaGetProtocolRequest() { + } virtual RequestType Type() const { return VENDOR; } @@ -115,7 +114,7 @@ class AoaInitSequence::AoaGetProtocolRequest : public UsbControlInTransfer { } virtual bool OnCompleted(unsigned char* data) const { const int protocol_version = data[1] << 8 | data[0]; - LOG4CXX_INFO(logger_, "AOA protocol version " << protocol_version); + LOG4CXX_DEBUG(logger_, "AOA protocol version " << protocol_version); if (protocol_version == 0) { // AOA protocol not supported return false; @@ -127,10 +126,14 @@ class AoaInitSequence::AoaGetProtocolRequest : public UsbControlInTransfer { class AoaInitSequence::AoaSendIdString : public UsbControlOutTransfer { public: AoaSendIdString(uint16_t index, const char* string, uint16_t length) - : index_(index), string_(string), length_(length) {} + : index_(index), + string_(string), + length_(length) { + } private: - virtual ~AoaSendIdString() {} + virtual ~AoaSendIdString() { + } virtual RequestType Type() const { return VENDOR; } @@ -155,7 +158,8 @@ class AoaInitSequence::AoaSendIdString : public UsbControlOutTransfer { }; class AoaInitSequence::AoaTurnIntoAccessoryMode : public UsbControlOutTransfer { - virtual ~AoaTurnIntoAccessoryMode() {} + virtual ~AoaTurnIntoAccessoryMode() { + } virtual RequestType Type() const { return VENDOR; } @@ -183,7 +187,8 @@ static char version[] = "1.0"; static char uri[] = "http://www.ford.com"; static char serial_num[] = "N000000"; -AoaInitSequence::AoaInitSequence() : UsbControlTransferSequence() { +AoaInitSequence::AoaInitSequence() + : UsbControlTransferSequence() { AddTransfer(new AoaGetProtocolRequest); AddTransfer(new AoaSendIdString(0, manufacturer, sizeof(manufacturer))); AddTransfer(new AoaSendIdString(1, model_name, sizeof(model_name))); @@ -195,25 +200,26 @@ AoaInitSequence::AoaInitSequence() : UsbControlTransferSequence() { } void UsbDeviceScanner::TurnIntoAccessoryMode(PlatformUsbDevice* device) { - LOG4CXX_TRACE(logger_, "enter. PlatformUsbDevice: " << device); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_DEBUG(logger_, "PlatformUsbDevice: " << device); GetUsbHandler()->StartControlTransferSequence(new AoaInitSequence, device); - LOG4CXX_TRACE(logger_, "exit"); } void UsbDeviceScanner::SupportedDeviceFound(PlatformUsbDevice* device) { - LOG4CXX_TRACE(logger_, "enter PlatformUsbDevice: " << device); + LOG4CXX_AUTO_TRACE(logger_); + LOG4CXX_TRACE(logger_, "PlatformUsbDevice: " << device); - pthread_mutex_lock(&devices_mutex_); + devices_mutex_.Acquire(); devices_.push_back(device); - pthread_mutex_unlock(&devices_mutex_); - LOG4CXX_INFO(logger_, "USB device (bus number " - << static_cast<int>(device->bus_number()) - << ", address " - << static_cast<int>(device->address()) - << ") identified as: " << device->GetManufacturer() - << ", " << device->GetProductName()); + devices_mutex_.Release(); + LOG4CXX_DEBUG( + logger_, + "USB device (bus number " << static_cast<int>(device->bus_number()) + << ", address " << static_cast<int>(device->address()) + << ") identified as: " << device->GetManufacturer() + << ", " << device->GetProductName() + << ", serial: " << device->GetSerialNumber()); UpdateList(); - LOG4CXX_TRACE(logger_, "exit"); } TransportAdapter::Error UsbDeviceScanner::Init() { @@ -225,30 +231,28 @@ TransportAdapter::Error UsbDeviceScanner::Scan() { } void UsbDeviceScanner::UpdateList() { - LOG4CXX_TRACE(logger_, "enter"); + LOG4CXX_AUTO_TRACE(logger_); DeviceVector device_vector; - pthread_mutex_lock(&devices_mutex_); + devices_mutex_.Acquire(); for (Devices::const_iterator it = devices_.begin(); it != devices_.end(); - ++it) { - const std::string device_name = - (*it)->GetManufacturer() + " " + (*it)->GetProductName(); + ++it) { + const std::string device_name = (*it)->GetManufacturer() + " " + + (*it)->GetProductName(); std::ostringstream oss; oss << (*it)->GetManufacturer() << ":" << (*it)->GetProductName() << ":" - << (*it)->GetSerialNumber() << ":" - << static_cast<int>((*it)->bus_number()) << ":" - << static_cast<int>((*it)->address()); + << (*it)->GetSerialNumber(); const DeviceUID device_uid = oss.str(); DeviceSptr device(new UsbDevice(*it, device_name, device_uid)); device_vector.push_back(device); } - pthread_mutex_unlock(&devices_mutex_); + devices_mutex_.Release(); - LOG4CXX_INFO(logger_, "USB search done " << device_vector.size()); + LOG4CXX_DEBUG(logger_, "USB search done " << device_vector.size()); controller_->SearchDeviceDone(device_vector); - LOG4CXX_TRACE(logger_, "exit"); } -void UsbDeviceScanner::Terminate() {} +void UsbDeviceScanner::Terminate() { +} bool UsbDeviceScanner::IsInitialised() const { return true; |