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-2010, 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 "m_raw_channel.h"
  24 #include "semaphore.h"
  25 #include "data.h"
  26 #include "protocol.h"
  27 #include "protostructs.h"
  28 #include "packet.h"
  29 #include "endian.h"
  30 #include "error.h"
  31 #include "usbwrap.h"
  32 #include "controller.h"
  33 #include <stdexcept>
  34 #include <sstream>
  35 #include <cstring>
  36 #include <string>
  37 #include "protostructs.h"
  38
  39 #include "debug.h"
  40
  41 #define RAW_HEADER_SIZE 4
  42
  43 namespace Barry { namespace Mode {
  44
  45 ///////////////////////////////////////////////////////////////////////////////
  46 // RawChannel SocketDataHandler callback class
  47 class RawChannelSocketHandler: public SocketRoutingQueue::SocketDataHandler
  48 {
  49         RawChannel &m_raw_channel;
  50 public:
  51         RawChannelSocketHandler(RawChannel &raw_channel)
  52                 : m_raw_channel(raw_channel)
  53         {}
  54         virtual void DataReceived(Data &data)
  55         {
  56                 m_raw_channel.HandleReceivedData(data);
  57         }
  58         virtual void Error(Barry::Error &error)
  59         {
  60                 SocketDataHandler::Error(error);
  61                 m_raw_channel.HandleError(error);
  62         }
  63         virtual ~RawChannelSocketHandler()
  64         {}
  65 };
  66
  67 ///////////////////////////////////////////////////////////////////////////////
  68 // RawChannel Mode class
  69
  70 RawChannel::RawChannel(Controller &con, RawChannelDataCallback &callback)
  71         : Mode(con, Controller::RawChannel)
  72         , m_mutex_valid(false)
  73         , m_cv_valid(false)
  74         , m_semaphore(NULL)
  75         , m_callback(&callback)
  76         , m_send_buffer(NULL)
  77         , m_zero_registered(false)
  78         , m_pending_error(NULL)
  79 {
  80         CheckQueueAvailable();
  81         InitBuffer();
  82         InitSemaphore();
  83 }
  84
  85 RawChannel::RawChannel(Controller &con)
  86         : Mode(con, Controller::RawChannel)
  87         , m_mutex_valid(false)
  88         , m_cv_valid(false)
  89         , m_semaphore(NULL)
  90         , m_callback(NULL)
  91         , m_send_buffer(NULL)
  92         , m_zero_registered(false)
  93         , m_pending_error(NULL)
  94 {
  95         CheckQueueAvailable();
  96         InitBuffer();
  97         InitSemaphore();
  98 }
  99
 100 void RawChannel::CheckQueueAvailable()
 101 {
 102         if( !m_con.m_queue ) {
 103                 throw Barry::Error("RawChannel: No routing queue set in controller");
 104         }
 105 }
 106
 107 void RawChannel::InitBuffer()
 108 {
 109         m_send_buffer = new unsigned char[MAX_PACKET_SIZE];
 110 }
 111
 112 void RawChannel::InitSemaphore()
 113 {
 114         // Create the thread synchronization objects
 115         if( pthread_mutex_init(&m_mutex, NULL) ) {
 116                 throw Barry::Error("Failed to create mutex");
 117         }
 118         m_mutex_valid = true;
 119         if( pthread_cond_init(&m_cv, NULL) ) {
 120                 throw Barry::Error("Failed to create condvar");
 121         }
 122         m_cv_valid = true;
 123         m_semaphore = new semaphore(m_mutex, m_cv);
 124 }
 125
 126 RawChannel::~RawChannel()
 127 {
 128         UnregisterZeroSocketInterest();
 129
 130         delete[] m_send_buffer;
 131
 132         if( m_mutex_valid ) {
 133                 pthread_mutex_destroy(&m_mutex);
 134         }
 135         if( m_cv_valid ) {
 136                 pthread_cond_destroy(&m_cv);
 137         }
 138         delete m_semaphore;
 139         delete m_pending_error;
 140 }
 141
 142 void RawChannel::OnOpen()
 143 {
 144         // Enable sequence packets so that DataSendAck callback and close can be
 145         // implemented
 146         m_zero_registered = true;
 147         m_socket->HideSequencePacket(false);
 148         SocketRoutingQueue::SocketDataHandlerPtr callback;
 149         callback.reset(new RawChannelSocketHandler(*this));
 150         m_con.m_queue->RegisterInterest(0, callback);
 151         // Get socket data packets routed to this class as well if using callback
 152         // otherside just request interest
 153         if( !m_callback ) {
 154                 // Don't want to be called back immediately on data
 155                 callback.reset();
 156         }
 157         m_socket->RegisterInterest(callback);
 158 }
 159
 160
 161 void RawChannel::HandleReceivedData(Data &data)
 162 {
 163         // Only ever called in callback mode
 164         Protocol::CheckSize(data, MIN_PACKET_DATA_SIZE);
 165         MAKE_PACKETPTR_BUF(packet, data.GetData());
 166
 167         if( packet->socket == 0 ) {
 168                 switch( btohs(packet->command) )
 169                 {
 170                 case SB_COMMAND_SEQUENCE_HANDSHAKE:
 171                         m_semaphore->Signal();
 172                         break;
 173                 case SB_COMMAND_CLOSE_SOCKET:
 174                 case SB_COMMAND_REMOTE_CLOSE_SOCKET:
 175                         // Stop listening to socket 0 messages
 176                         // so that socket close work.
 177                         UnregisterZeroSocketInterest();
 178                         if( m_callback ) {
 179                                 m_callback->ChannelClose();
 180                         }
 181
 182                         m_semaphore->Signal();
 183                         break;
 184                 default:
 185                         UnregisterZeroSocketInterest();
 186                         if( m_callback ) {
 187                                 m_callback->ChannelError("RawChannel: Got unexpected socket zero packet");
 188                         }
 189                         else {
 190                                 SetPendingError("RawChannel: Got unexpected socket zero packet");
 191                         }
 192                         m_semaphore->Signal();
 193                         break;
 194                 }
 195         }
 196         else {
 197                 // Should be a socket packet for us, so remove packet headers
 198                 Data partial(data.GetData() + RAW_HEADER_SIZE, data.GetSize() - RAW_HEADER_SIZE);
 199                 if( m_callback ) {
 200                         m_callback->DataReceived(partial);
 201                 }
 202                 else {
 203                         SetPendingError("RawChannel: Received data to handle when in non-callback mode");
 204                 }
 205         }
 206 }
 207
 208 void RawChannel::HandleError(Barry::Error &error)
 209 {
 210         if( m_callback ) {
 211                 m_callback->ChannelError("RawChannel: Socket error received");
 212         }
 213         else {
 214                 SetPendingError("RawChannel: Socket error received");
 215         }
 216         m_semaphore->Signal();
 217 }
 218
 219 void RawChannel::UnregisterZeroSocketInterest()
 220 {
 221         if( m_zero_registered ) {
 222                 m_con.m_queue->UnregisterInterest(0);
 223                 m_socket->HideSequencePacket(true);
 224                 m_zero_registered = false;
 225         }
 226 }
 227
 228 void RawChannel::SetPendingError(const char *msg)
 229 {
 230         if( !m_pending_error ) {
 231                 m_pending_error = new std::string(msg);
 232         }
 233 }
 234
 235 ///////////////////////////////////////////////////////////////////////////////
 236 // public API
 237
 238 void RawChannel::Send(Data &data, int timeout)
 239 {
 240         size_t packetSize = RAW_HEADER_SIZE + data.GetSize();
 241
 242         if( packetSize > MAX_PACKET_SIZE ) {
 243                 throw Barry::Error("RawChannel: send data size larger than MaximumPacketSize");
 244         }
 245
 246         // setup header and copy data in
 247         MAKE_PACKETPTR_BUF(packet, m_send_buffer);
 248         packet->socket = htobs(m_socket->GetSocket());
 249         packet->size = htobs(packetSize);
 250         std::memcpy(&(m_send_buffer[RAW_HEADER_SIZE]), data.GetData(), data.GetSize());
 251
 252         Data toSend(m_send_buffer, packetSize);
 253         m_socket->Send(toSend, timeout);
 254         m_semaphore->WaitForSignal();
 255         if( m_pending_error ) {
 256                 throw Barry::Error(*m_pending_error);
 257         }
 258 }
 259
 260 void RawChannel::Receive(Data &data,int timeout)
 261 {
 262         if( m_callback ) {
 263                 throw std::logic_error("RawChannel: Receive called when channel was created with a callback");
 264         }
 265         // Receive into a buffer
 266         m_socket->Receive(m_receive_data, timeout);
 267         // Then transfer across, skipping the header
 268         Protocol::CheckSize(m_receive_data, RAW_HEADER_SIZE);
 269         size_t len = m_receive_data.GetSize() - RAW_HEADER_SIZE;
 270         memcpy(data.GetBuffer(), m_receive_data.GetData() + RAW_HEADER_SIZE, len);
 271         data.ReleaseBuffer(len);
 272
 273 }
 274
 275 size_t RawChannel::MaximumSendSize()
 276 {
 277         return MAX_PACKET_SIZE - RAW_HEADER_SIZE;
 278 }
 279
 280 }} // namespace Barry::Mode