mirror of
https://gitlab.uni-freiburg.de/opensourcevdi/spice
synced 2026-01-11 08:07:16 +00:00
8d5b738ba1
The process loop is responsible for: 1) waiting for events 2) timers 3) events queue for actions that should be performed in the context of the thread and are pushed from other threads. The benefits: 1) remove duplicity: till now, there was one implementaion of events loop for the channels and another one for the main thread. 2) timers can be executed on each thread and not only on the main thread. 3) events can be pushed to each thread and not only to the main thread. In this commit, only the main thread was modified to use the new process loop.
141 lines
4.3 KiB
C++
141 lines
4.3 KiB
C++
/*
|
|
Copyright (C) 2009 Red Hat, Inc.
|
|
|
|
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, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
Author:
|
|
yhalperi@redhat.com
|
|
*/
|
|
|
|
#ifndef _H_TUNNEL_CHANNEL
|
|
#define _H_TUNNEL_CHANNEL
|
|
|
|
#include "common.h"
|
|
#include "red_channel.h"
|
|
#include "red_client.h"
|
|
#include "client_net_socket.h"
|
|
#include "platform.h"
|
|
|
|
#define TUNNEL_CONFIG
|
|
|
|
#ifdef TUNNEL_CONFIG
|
|
class TunnelConfigConnectionIfc;
|
|
class TunnelConfigListenerIfc;
|
|
#endif
|
|
|
|
/* channel for tunneling tcp from guest to client network */
|
|
typedef struct TunnelService TunnelService;
|
|
class TunnelChannel: public RedChannel,
|
|
public ClientNetSocket::EventHandler {
|
|
public:
|
|
|
|
TunnelChannel(RedClient& client, uint32_t id);
|
|
virtual ~TunnelChannel();
|
|
|
|
virtual void on_socket_message_recv_done(ClientNetSocket& sckt,
|
|
ClientNetSocket::ReceiveBuffer& buf);
|
|
virtual void on_socket_message_send_done(ClientNetSocket& sckt);
|
|
virtual void on_socket_fin_recv(ClientNetSocket& sckt);
|
|
virtual void on_socket_disconnect(ClientNetSocket& sckt);
|
|
|
|
#ifdef TUNNEL_CONFIG
|
|
void add_service(TunnelConfigConnectionIfc& source,
|
|
uint32_t type, struct in_addr& ip, uint32_t port,
|
|
std::string& name, std::string& description);
|
|
#endif
|
|
static ChannelFactory& Factory();
|
|
|
|
protected:
|
|
class TunnelSocket;
|
|
|
|
virtual void on_disconnect();
|
|
virtual void on_connect();
|
|
|
|
private:
|
|
void handle_init(RedPeer::InMessage* message);
|
|
void handle_service_ip_map(RedPeer::InMessage* message);
|
|
|
|
void handle_socket_open(RedPeer::InMessage* message);
|
|
void handle_socket_fin(RedPeer::InMessage* message);
|
|
void handle_socket_close(RedPeer::InMessage* message);
|
|
void handle_socket_closed_ack(RedPeer::InMessage* message);
|
|
void handle_socket_data(RedPeer::InMessage* message);
|
|
void handle_socket_token(RedPeer::InMessage* message);
|
|
|
|
TunnelService* find_service(uint32_t id);
|
|
TunnelService* find_service(struct in_addr& ip);
|
|
TunnelService* find_service(struct in_addr& ip, uint32_t port);
|
|
|
|
void send_service(TunnelService& service);
|
|
void destroy_sockets();
|
|
|
|
private:
|
|
std::vector<TunnelSocket*> _sockets;
|
|
std::list<TunnelService*> _services;
|
|
uint32_t _max_socket_data_size;
|
|
uint32_t _service_id;
|
|
uint32_t _service_group;
|
|
#ifdef TUNNEL_CONFIG
|
|
TunnelConfigListenerIfc* _config_listener;
|
|
friend class TunnelConfigListenerIfc;
|
|
#endif
|
|
};
|
|
|
|
#ifdef TUNNEL_CONFIG
|
|
#ifdef _WIN32
|
|
#define TUNNEL_CONFIG_PIPE_NAME "tunnel-config.pipe"
|
|
#else
|
|
#define TUNNEL_CONFIG_PIPE_NAME "/tmp/tunnel-config.pipe"
|
|
#endif
|
|
|
|
class TunnelConfigConnectionIfc;
|
|
|
|
class TunnelConfigListenerIfc: public NamedPipe::ListenerInterface {
|
|
public:
|
|
TunnelConfigListenerIfc(TunnelChannel& tunnel);
|
|
virtual ~TunnelConfigListenerIfc();
|
|
virtual NamedPipe::ConnectionInterface& create();
|
|
virtual void destroy_connection(TunnelConfigConnectionIfc* conn);
|
|
|
|
private:
|
|
TunnelChannel& _tunnel;
|
|
NamedPipe::ListenerRef _listener_ref;
|
|
std::list<TunnelConfigConnectionIfc*> _connections;
|
|
};
|
|
|
|
#define TUNNEL_CONFIG_MAX_MSG_LEN 2048
|
|
class TunnelConfigConnectionIfc: public NamedPipe::ConnectionInterface {
|
|
public:
|
|
TunnelConfigConnectionIfc(TunnelChannel& tunnel,
|
|
TunnelConfigListenerIfc& listener);
|
|
virtual void bind(NamedPipe::ConnectionRef conn_ref);
|
|
virtual void on_data();
|
|
void send_virtual_ip(struct in_addr& ip);
|
|
NamedPipe::ConnectionRef get_ref() {return _opaque;}
|
|
void handle_msg();
|
|
|
|
private:
|
|
TunnelChannel& _tunnel;
|
|
TunnelConfigListenerIfc& _listener;
|
|
char _in_msg[TUNNEL_CONFIG_MAX_MSG_LEN]; // <service_type> <ip> <port> <name> <desc>\n
|
|
int _in_msg_len;
|
|
|
|
std::string _out_msg; // <virtual ip>\n
|
|
int _out_msg_pos;
|
|
};
|
|
#endif
|
|
|
|
#endif
|