eda_dde.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2014 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2014-2021 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include <condition_variable>
#include <mutex>
#include <thread>

#include <eda_dde.h>
#include <kiway_player.h>
#include <id.h>

#include <wx/crt.h>


static const wxString HOSTNAME( wxT( "localhost" ) );

// buffer for read and write data in socket connections
#define IPC_BUF_SIZE 4096
static char client_ipc_buffer[IPC_BUF_SIZE];


void KIWAY_PLAYER::CreateServer( int service, bool local )
{
 wxIPV4address addr;

 // Set the port number
 addr.Service( service );

 // Listen on localhost only if requested
 if( local )
 addr.Hostname( HOSTNAME );

 delete m_socketServer;
 m_socketServer = new wxSocketServer( addr );

 m_socketServer->SetNotify( wxSOCKET_CONNECTION_FLAG );
 m_socketServer->SetEventHandler( *this, ID_EDA_SOCKET_EVENT_SERV );
 m_socketServer->Notify( true );
}


void KIWAY_PLAYER::OnSockRequest( wxSocketEvent& evt )
{
 size_t len;
 wxSocketBase* sock = evt.GetSocket();

 switch( evt.GetSocketEvent() )
 {
 case wxSOCKET_INPUT:
 sock->Read( client_ipc_buffer, 1 );

 if( sock->LastCount() == 0 )
 break; // No data, occurs on opening connection

 sock->Read( client_ipc_buffer + 1, IPC_BUF_SIZE - 2 );
 len = 1 + sock->LastCount();
 client_ipc_buffer[len] = 0;
 ExecuteRemoteCommand( client_ipc_buffer );
 break;

 case wxSOCKET_LOST:
 return;
 break;

 default:
 wxPrintf( wxT( "EDA_DRAW_FRAME::OnSockRequest() error: Invalid event !" ) );
 break;
 }
}


void KIWAY_PLAYER::OnSockRequestServer( wxSocketEvent& evt )
{
 wxSocketBase* socket;
 wxSocketServer* server = (wxSocketServer*) evt.GetSocket();

 socket = server->Accept();

 if( socket == nullptr )
 return;

 m_sockets.push_back( socket );

 socket->Notify( true );
 socket->SetEventHandler( *this, ID_EDA_SOCKET_EVENT );
 socket->SetNotify( wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG );
}


class ASYNC_SOCKET_HOLDER
{
public:
 ASYNC_SOCKET_HOLDER() :
 m_messageReady( false ),
 m_shutdown( false )
 {
 // Do a dummy Connect so that wx will set up the socket stuff on the main thread, which is
 // required even if you later make socket connections on another thread.
 wxSocketClient* client = new wxSocketClient;
 wxIPV4address addr;

 addr.Hostname( HOSTNAME );
 addr.Service( KICAD_PCB_PORT_SERVICE_NUMBER );

 client->Connect( addr, false );

 client->Close();
 client->Destroy();

 m_thread = std::thread( &ASYNC_SOCKET_HOLDER::worker, this );
 }

 ~ASYNC_SOCKET_HOLDER()
 {
  {
 std::lock_guard<std::mutex> lock( m_mutex );
 m_shutdown = true;
 }

 m_cv.notify_one();

 try
 {
 if( m_thread.joinable() )
 m_thread.join();
 }
 catch( ... )
 {
 }
 }

 bool Send( int aService, const std::string& aMessage )
 {
 if( m_messageReady )
 return false;

 std::lock_guard<std::mutex> lock( m_mutex );

 m_message = std::make_pair( aService, aMessage );
 m_messageReady = true;
 m_cv.notify_one();

 return true;
 }

private:
 void worker()
 {
 int port;
 std::string message;

 std::unique_lock<std::mutex> lock( m_mutex );

 while( !m_shutdown )
 {
 m_cv.wait( lock, [&]() { return m_messageReady || m_shutdown; } );

 if( m_shutdown )
 break;

 port = m_message.first;
 message = m_message.second;

 lock.unlock();

 wxSocketClient* sock_client;
 wxIPV4address addr;

 // Create a connection
 addr.Hostname( HOSTNAME );
 addr.Service( port );

 // Mini-tutorial for Connect() :-)
 // (JP CHARRAS Note: see wxWidgets: sockets/client.cpp sample)
 // ---------------------------
 //
 // There are two ways to use Connect(): blocking and non-blocking,
 // depending on the value passed as the 'wait' (2nd) parameter.
 //
 // Connect(addr, true) will wait until the connection completes,
 // returning true on success and false on failure. This call blocks
 // the GUI (this might be changed in future releases to honor the
 // wxSOCKET_BLOCK flag).
 //
 // Connect(addr, false) will issue a nonblocking connection request
 // and return immediately. If the return value is true, then the
 // connection has been already successfully established. If it is
 // false, you must wait for the request to complete, either with
 // WaitOnConnect() or by watching wxSOCKET_CONNECTION / LOST
 // events (please read the documentation).
 //
 // WaitOnConnect() itself never blocks the GUI (this might change
 // in the future to honor the wxSOCKET_BLOCK flag). This call will
 // return false on timeout, or true if the connection request
 // completes, which in turn might mean:
 //
 // a) That the connection was successfully established
 // b) That the connection request failed (for example, because
 // it was refused by the peer.
 //
 // Use IsConnected() to distinguish between these two.
 //
 // So, in a brief, you should do one of the following things:
 //
 // For blocking Connect:
 //
 // bool success = client->Connect(addr, true);
 //
 // For nonblocking Connect:
 //
 // client->Connect(addr, false);
 //
 // bool waitmore = true;
 // while (! client->WaitOnConnect(seconds, millis) && waitmore )
 // {
 // // possibly give some feedback to the user,
 // // update waitmore if needed.
 // }
 // bool success = client->IsConnected();
 //
 // And that's all :-)

 sock_client = new wxSocketClient( wxSOCKET_BLOCK );
 sock_client->SetTimeout( 1 ); // Time out in Seconds
 sock_client->Connect( addr, false );
 sock_client->WaitOnConnect( 0, 250 );

 if( sock_client->Ok() && sock_client->IsConnected() )
 {
 sock_client->SetFlags( wxSOCKET_NOWAIT /*wxSOCKET_WAITALL*/ );
 sock_client->Write( message.c_str(), message.length() );
 }

 sock_client->Close();
 sock_client->Destroy();

 m_messageReady = false;

 lock.lock();
 }
 }

 std::thread m_thread;
 std::pair<int, std::string> m_message;
 bool m_messageReady;
 mutable std::mutex m_mutex;
 std::condition_variable m_cv;
 bool m_shutdown;
};


std::unique_ptr<ASYNC_SOCKET_HOLDER> socketHolder = nullptr;


bool SendCommand( int aService, const std::string& aMessage )
{
 if( !socketHolder )
 socketHolder.reset( new ASYNC_SOCKET_HOLDER() );

 return socketHolder->Send( aService, aMessage );
}


void SocketCleanup()
{
 if( socketHolder )
 socketHolder.reset();
}