src/m_raw_channel.cc

   1 ///
   2 /// \file       m_raw_channel.cc
   3 ///             Mode class for a raw channel
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2013, Net Direct Inc. (http://www.netdirect.ca/)
   8     Portions Copyright (C) 2010 RealVNC Ltd.
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18
  19     See the GNU General Public License in the COPYING file at the
  20     root directory of this project for more details.
  21 */
  22
  23 #include "i18n.h"
  24 #include "m_raw_channel.h"
  25 #include "semaphore.h"
  26 #include "data.h"
  27 #include "protocol.h"
  28 #include "protostructs.h"
  29 #include "packet.h"
  30 #include "endian.h"
  31 #include "error.h"
  32 #include "usbwrap.h"
  33 #include "controller.h"
  34 #include <stdexcept>
  35 #include <sstream>
  36 #include <cstring>
  37 #include <string>
  38 #include "protostructs.h"
  39
  40 #include "debug.h"
  41
  42 namespace Barry { namespace Mode {
  43
  44 ///////////////////////////////////////////////////////////////////////////////
  45 // RawChannel SocketDataHandler callback class for data socket
  46 class RawChannelSocketHandler: public SocketRoutingQueue::SocketDataHandler
  47 {
  48         RawChannel &m_raw_channel;
  49 public:
  50         RawChannelSocketHandler(RawChannel &raw_channel)
  51                 : m_raw_channel(raw_channel)
  52         {}
  53         virtual void DataReceived(Data &data)
  54         {
  55                 m_raw_channel.HandleReceivedData(data);
  56         }
  57         virtual void Error(Barry::Error &error)
  58         {
  59                 SocketDataHandler::Error(error);
  60                 m_raw_channel.HandleError(error);
  61         }
  62         virtual ~RawChannelSocketHandler()
  63         {}
  64 };
  65
  66 ///////////////////////////////////////////////////////////////////////////////
  67 // RawChannel SocketDataHandler callback class for zero socket
  68 class RawChannelZeroSocketHandler: public SocketRoutingQueue::SocketDataHandler
  69 {
  70         RawChannel &m_raw_channel;
  71 public:
  72         RawChannelZeroSocketHandler(RawChannel &raw_channel)
  73                 : m_raw_channel(raw_channel)
  74         {}
  75         virtual void DataReceived(Data &data)
  76         {
  77                 m_raw_channel.HandleReceivedZeroPacket(data);
  78         }
  79         virtual void Error(Barry::Error &error)
  80         {
  81                 SocketDataHandler::Error(error);
  82                 m_raw_channel.HandleError(error);
  83         }
  84         virtual ~RawChannelZeroSocketHandler()
  85         {}
  86 };
  87
  88 ///////////////////////////////////////////////////////////////////////////////
  89 // RawChannel Mode class
  90
  91 RawChannel::RawChannel(Controller &con, RawChannelDataCallback &callback)
  92         : Mode(con, Controller::RawChannel)
  93         , m_callback(&callback)
  94         , m_send_buffer(NULL)
  95         , m_zero_registered(false)
  96         , m_pending_error(NULL)
  97 {
  98         CheckQueueAvailable();
  99         InitBuffer();
 100 }
 101
 102 RawChannel::RawChannel(Controller &con)
 103         : Mode(con, Controller::RawChannel)
 104         , m_callback(NULL)
 105         , m_send_buffer(NULL)
 106         , m_zero_registered(false)
 107         , m_pending_error(NULL)
 108 {
 109         CheckQueueAvailable();
 110         InitBuffer();
 111 }
 112
 113 void RawChannel::CheckQueueAvailable()
 114 {
 115         if( !m_con.HasQueue() ) {
 116                 throw Barry::Error(_("RawChannel: No routing queue set in controller"));
 117         }
 118 }
 119
 120 void RawChannel::InitBuffer()
 121 {
 122         m_send_buffer = new unsigned char[SB_CHANNELPACKET_HEADER_SIZE + SB_CHANNELPACKET_MAX_DATA_SIZE];
 123 }
 124
 125 RawChannel::~RawChannel()
 126 {
 127         UnregisterZeroSocketInterest();
 128
 129         delete[] m_send_buffer;
 130
 131         delete m_pending_error;
 132 }
 133
 134 void RawChannel::OnOpen()
 135 {
 136         // Enable sequence packets so that DataSendAck callback and close can be
 137         // implemented
 138         m_zero_registered = true;
 139         SocketRoutingQueue::SocketDataHandlerPtr zeroCallback;
 140         zeroCallback.reset(new RawChannelZeroSocketHandler(*this));
 141         m_con.GetQueue()->RegisterInterest(0, zeroCallback);
 142         // Get socket data packets routed to this class as well if a
 143         // callback was provided, otherside just get the data packets
 144         // placed into a queue for the socket.
 145         if( m_callback ) {
 146                 SocketRoutingQueue::SocketDataHandlerPtr callback;
 147                 callback.reset(new RawChannelSocketHandler(*this));
 148                 m_socket->UnregisterInterest();
 149                 m_socket->RegisterInterest(callback);
 150         }
 151         else {
 152                 // sockets already register themselves by default,
 153                 // so no need to do anything in this case
 154         }
 155 }
 156
 157
 158 void RawChannel::HandleReceivedZeroPacket(Data &data)
 159 {
 160         Protocol::CheckSize(data, SB_PACKET_HEADER_SIZE);
 161         MAKE_PACKETPTR_BUF(packet, data.GetData());
 162
 163         if( packet->socket != 0 ) {
 164                 UnregisterZeroSocketInterest();
 165                 SetPendingError(_("RawChannel: Got packet not for socket-zero"));
 166         }
 167
 168         switch( btohs(packet->command) )
 169         {
 170         case SB_COMMAND_CLOSE_SOCKET:
 171         case SB_COMMAND_REMOTE_CLOSE_SOCKET:
 172                 // Stop listening to socket 0 messages
 173                 // so that socket close work.
 174                 UnregisterZeroSocketInterest();
 175                 if( m_callback ) {
 176                         m_callback->ChannelClose();
 177                 }
 178
 179                 break;
 180         default:
 181                 UnregisterZeroSocketInterest();
 182                 if( m_callback ) {
 183                         m_callback->ChannelError(_("RawChannel: Got unexpected socket zero packet"));
 184                 }
 185                 else {
 186                         SetPendingError(_("RawChannel: Got unexpected socket zero packet"));
 187                 }
 188                 break;
 189         }
 190
 191 }
 192
 193 void RawChannel::HandleReceivedData(Data &data)
 194 {
 195         // Only ever called in callback mode
 196         ValidateDataPacket(data);
 197         MAKE_CHANNELPACKETPTR_BUF(packet, data.GetData());
 198
 199         // Should be a socket packet for us, so remove packet headers
 200         Data partial(packet->u.data, data.GetSize() - SB_CHANNELPACKET_HEADER_SIZE);
 201         if( m_callback ) {
 202                 m_callback->DataReceived(partial);
 203         }
 204         else {
 205                 SetPendingError(_("RawChannel: Received data to handle when in non-callback mode"));
 206         }
 207 }
 208
 209 void RawChannel::HandleError(Barry::Error &error)
 210 {
 211         std::ostringstream errorOss;
 212         errorOss << _("RawChannel: Socket error received, what: ") << error.what();
 213
 214         if( m_callback ) {
 215                 m_callback->ChannelError(errorOss.str().c_str());
 216         }
 217         else {
 218                 SetPendingError(errorOss.str().c_str());
 219         }
 220 }
 221
 222 void RawChannel::UnregisterZeroSocketInterest()
 223 {
 224         if( m_zero_registered ) {
 225                 m_con.GetQueue()->UnregisterInterest(0);
 226                 m_zero_registered = false;
 227         }
 228 }
 229
 230 void RawChannel::SetPendingError(const char *msg)
 231 {
 232         if( !m_pending_error ) {
 233                 m_pending_error = new std::string(msg);
 234         }
 235 }
 236
 237 ///////////////////////////////////////////////////////////////////////////////
 238 // public API
 239
 240 void RawChannel::Send(Data &data, int timeout)
 241 {
 242         size_t packetSize = SB_CHANNELPACKET_HEADER_SIZE + data.GetSize();
 243
 244         if( packetSize > SB_CHANNELPACKET_HEADER_SIZE + SB_CHANNELPACKET_MAX_DATA_SIZE ) {
 245                 throw Barry::Error(_("RawChannel: send data size larger than MaximumPacketSize"));
 246         }
 247
 248         if( m_pending_error ) {
 249                 throw Barry::Error(*m_pending_error);
 250         }
 251
 252         // setup header and copy data in
 253         MAKE_CHANNELPACKETPTR_BUF(packet, m_send_buffer);
 254         packet->size = htobs(packetSize);
 255         std::memcpy(packet->u.data, data.GetData(), data.GetSize());
 256
 257         Data toSend(m_send_buffer, packetSize);
 258         m_socket->SyncSend(toSend, timeout);
 259
 260         if( m_pending_error ) {
 261                 throw Barry::Error(*m_pending_error);
 262         }
 263 }
 264
 265 void RawChannel::Receive(Data &data,int timeout)
 266 {
 267         if( m_callback ) {
 268                 throw std::logic_error(_("RawChannel: Receive called when channel was created with a callback"));
 269         }
 270
 271         if( m_pending_error ) {
 272                 throw Barry::Error(*m_pending_error);
 273         }
 274
 275         // Receive into a buffer
 276         m_socket->Receive(m_receive_data, timeout);
 277         // Then transfer across, skipping the header
 278         ValidateDataPacket(m_receive_data);
 279         MAKE_CHANNELPACKETPTR_BUF(packet, m_receive_data.GetData());
 280
 281         size_t len = packet->size - SB_CHANNELPACKET_HEADER_SIZE;
 282         memcpy(data.GetBuffer(), packet->u.data, len);
 283         data.ReleaseBuffer(len);
 284
 285 }
 286
 287 void RawChannel::ValidateDataPacket(Data &data)
 288 {
 289         Protocol::CheckSize(data, SB_CHANNELPACKET_HEADER_SIZE);
 290         MAKE_CHANNELPACKETPTR_BUF(packet, data.GetData());
 291         if( packet->size != data.GetSize() ) {
 292
 293                 throw std::logic_error(_("RawChannel: Data size doesn't match packet size"));
 294         }
 295 }
 296
 297 size_t RawChannel::MaximumSendSize()
 298 {
 299         return SB_CHANNELPACKET_MAX_DATA_SIZE;
 300 }
 301
 302 }} // namespace Barry::Mode