src/m_serial.cc

   1 ///
   2 /// \file       m_serial.cc
   3 ///             Mode class for serial / GPRS modem mode
   4 ///
   5
   6 /*
   7     Copyright (C) 2008-2009, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #include "m_serial.h"
  23 #include "controller.h"
  24 #include "protostructs.h"
  25 #include "endian.h"
  26 #include "debug.h"
  27 #include <stdexcept>
  28
  29 namespace Barry { namespace Mode {
  30
  31 //////////////////////////////////////////////////////////////////////////////
  32 // Mode::Serial class
  33
  34 Serial::Serial( Controller &con,
  35                 DeviceDataCallback callback,
  36                 void *callback_context)
  37         : m_con(con)
  38         , m_ModeSocket(0)
  39         , m_CtrlSocket(0)
  40         , m_callback(callback)
  41         , m_callback_context(callback_context)
  42 {
  43         if( !m_con.HasQueue() )
  44                 throw std::logic_error("A SocketRoutingQueue is required in the Controller class when using Mode::Serial.");
  45 }
  46
  47 Serial::~Serial()
  48 {
  49 }
  50
  51
  52 //////////////////////////////////////////////////////////////////////////////
  53 // protected API / static functions
  54
  55 void Serial::DataCallback(void *context, Data *data)
  56 {
  57         ddout("Serial::DataCallback called");
  58
  59         Serial *ser = (Serial*) context;
  60
  61         if( data->GetSize() <= 4 )
  62                 return; // nothing to do
  63
  64         // call callback if available
  65         if( ser->m_callback ) {
  66                 (*ser->m_callback)(ser->m_callback_context,
  67                         data->GetData() + 4,
  68                         data->GetSize() - 4);
  69         }
  70 //      else {
  71 //              // append data to readCache
  72 //              FIXME;
  73 //      }
  74 }
  75
  76 void Serial::CtrlCallback(void *context, Data *data)
  77 {
  78 //      Serial *ser = (Serial*) context;
  79
  80         // just dump to stdout, and do nothing
  81         ddout("CtrlCallback received:\n" << *data);
  82 }
  83
  84 //////////////////////////////////////////////////////////////////////////////
  85 // public API
  86
  87 void Serial::Open(const char *password)
  88 {
  89         if( m_ModeSocket ) {
  90                 m_data->Close();
  91                 m_data.reset();
  92                 m_ModeSocket = 0;
  93         }
  94
  95         if( m_CtrlSocket ) {
  96                 m_ctrl->Close();
  97                 m_ctrl.reset();
  98                 m_CtrlSocket = 0;
  99         }
 100
 101         m_ModeSocket = m_con.SelectMode(Controller::UsbSerData);
 102         m_data = m_con.m_zero.Open(m_ModeSocket, password);
 103
 104         m_CtrlSocket = m_con.SelectMode(Controller::UsbSerCtrl);
 105         m_ctrl = m_con.m_zero.Open(m_CtrlSocket, password);
 106
 107         // register callback for incoming data, for speed
 108         m_data->RegisterInterest(DataCallback, this);
 109         m_ctrl->RegisterInterest(CtrlCallback, this);
 110
 111         const unsigned char start[] =
 112                 { 0, 0, 0x0a, 0, 0x01, 0x01, 0xc2, 0x00, 0x40, 0x00 };
 113         Data block(start, sizeof(start));
 114         m_ctrl->Send(block);
 115 }
 116
 117 void Serial::Close()
 118 {
 119         ddout("Serial:: Closing connection.");
 120 }
 121
 122 /*
 123 // FIXME - if this behaviour is truly common between modes, create
 124 // a common base class for this.
 125 void Serial::RetryPassword(const char *password)
 126 {
 127         if( m_data.get() || m_ctrl.get() )
 128                 throw std::logic_error("Socket already open in Serial::RetryPassword");
 129
 130         m_data = m_con.m_zero.OpenDBSocket(m_ModeSocket, password);
 131         m_ctrl = m_con.m_zero.OpenDBSocket(m_CtrlSocket, password);
 132
 133         // register callback for incoming data, for speed
 134         m_data->RegisterInterest(DataCallback, this);
 135 }
 136 */
 137
 138 /*
 139 // can be called from separate thread
 140 void Serial::SerialRead(Data &data, int timeout)
 141 {
 142         m_socket.Receive(data, timeout);
 143 }
 144 */
 145
 146 void Serial::Write(const Data &data, int timeout)
 147 {
 148         if( data.GetSize() <= 0 )
 149                 return; // nothing to do
 150
 151         if( !m_data.get() )
 152                 throw std::logic_error("Must call Open() before Write() in Mode::Serial");
 153
 154         // filter data for PPP, and prepend 4 bytes
 155         Data &filtered = m_filter.Write(data, 4);
 156
 157         // setup header (only size needed, as socket will be set by socket class)
 158         unsigned char *buf = filtered.GetBuffer();
 159         MAKE_PACKETPTR_BUF(spack, buf);
 160         spack->size = htobs(filtered.GetSize());
 161
 162         // send via appropriate socket
 163         m_data->Send(filtered, timeout);
 164 }
 165
 166 }} // namespace Barry::Mode
 167