eibd/libserver/tpdu.cpp

   1 /*
   2     EIBD eib bus access and management daemon
   3     Copyright (C) 2005-2011 Martin Koegler <mkoegler@auto.tuwien.ac.at>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "tpdu.h"
  21 #include "apdu.h"
  22
  23 TPDU *
  24 TPDU::fromPacket (const CArray & c)
  25 {
  26   TPDU *t = 0;
  27   if (c () >= 1)
  28     {
  29       if ((c[0] & 0xfc) == 0)
  30         t = new T_DATA_XXX_REQ_PDU ();
  31       if (c[0] == 0x80)
  32         t = new T_CONNECT_REQ_PDU ();
  33       if (c[0] == 0x81)
  34         t = new T_DISCONNECT_REQ_PDU ();
  35       if ((c[0] & 0xC3) == 0xC2)
  36         t = new T_ACK_PDU ();
  37       if ((c[0] & 0xC3) == 0xC3)
  38         t = new T_NACK_PDU ();
  39       if ((c[0] & 0xC0) == 0x40)
  40         t = new T_DATA_CONNECTED_REQ_PDU ();
  41     }
  42   if (t && t->init (c))
  43     return t;
  44   if (t)
  45     delete t;
  46
  47   t = new T_UNKNOWN_PDU ();
  48   t->init (c);
  49   return t;
  50 }
  51
  52
  53 /* T_UNKNOWN  */
  54
  55 T_UNKNOWN_PDU::T_UNKNOWN_PDU ()
  56 {
  57 }
  58
  59 bool
  60 T_UNKNOWN_PDU::init (const CArray & c)
  61 {
  62   pdu = c;
  63   return true;
  64 }
  65
  66 CArray T_UNKNOWN_PDU::ToPacket ()
  67 {
  68   return pdu;
  69 }
  70
  71 String T_UNKNOWN_PDU::Decode ()
  72 {
  73   String
  74   s ("Unknown TPDU: ");
  75   unsigned
  76     i;
  77
  78   if (pdu () == 0)
  79     return "empty TPDU";
  80
  81   for (i = 0; i < pdu (); i++)
  82     addHex (s, pdu[i]);
  83
  84   return s;
  85 }
  86
  87 /* T_DATA_XXX_REQ  */
  88
  89 T_DATA_XXX_REQ_PDU::T_DATA_XXX_REQ_PDU ()
  90 {
  91 }
  92
  93 bool
  94 T_DATA_XXX_REQ_PDU::init (const CArray & c)
  95 {
  96   if (c () < 1)
  97     return false;
  98   data = c;
  99   return true;
 100 }
 101
 102 CArray T_DATA_XXX_REQ_PDU::ToPacket ()
 103 {
 104   assert (data () > 0);
 105   CArray
 106   pdu (data);
 107   pdu[0] = (pdu[0] & 0x3);
 108   return pdu;
 109 }
 110
 111 String T_DATA_XXX_REQ_PDU::Decode ()
 112 {
 113   APDU *
 114     a = APDU::fromPacket (data);
 115   String
 116   s ("T_DATA_XXX_REQ ");
 117   s += a->Decode ();
 118   delete
 119     a;
 120   return s;
 121 }
 122
 123 /* T_DATA_CONNECTED_REQ  */
 124
 125 T_DATA_CONNECTED_REQ_PDU::T_DATA_CONNECTED_REQ_PDU ()
 126 {
 127   serno = 0;
 128 }
 129
 130 bool
 131 T_DATA_CONNECTED_REQ_PDU::init (const CArray & c)
 132 {
 133   if (c () < 1)
 134     return false;
 135   data = c;
 136   serno = (c[0] >> 2) & 0x0f;
 137   return true;
 138 }
 139
 140 CArray T_DATA_CONNECTED_REQ_PDU::ToPacket ()
 141 {
 142   assert (data () > 0);
 143   assert ((serno & 0xf0) == 0);
 144   CArray
 145   pdu (data);
 146   pdu[0] = (pdu[0] & 0x3) | 0x40 | ((serno & 0x0f) << 2);
 147   return pdu;
 148 }
 149
 150 String T_DATA_CONNECTED_REQ_PDU::Decode ()
 151 {
 152   assert ((serno & 0xf0) == 0);
 153   APDU *
 154     a = APDU::fromPacket (data);
 155   String
 156   s ("T_DATA_CONNECTED_REQ serno:");
 157   addHex (s, serno);
 158   s += a->Decode ();
 159   delete
 160     a;
 161   return s;
 162 }
 163
 164 /* T_CONNECT_REQ  */
 165
 166 T_CONNECT_REQ_PDU::T_CONNECT_REQ_PDU ()
 167 {
 168 }
 169
 170 bool
 171 T_CONNECT_REQ_PDU::init (const CArray & c)
 172 {
 173   if (c () != 1)
 174     return false;
 175   return true;
 176 }
 177
 178 CArray T_CONNECT_REQ_PDU::ToPacket ()
 179 {
 180   uchar
 181     c = 0x80;
 182   return CArray (&c, 1);
 183 }
 184
 185 String T_CONNECT_REQ_PDU::Decode ()
 186 {
 187   return "T_CONNECT_REQ";
 188 }
 189
 190 /* T_DISCONNECT_REQ  */
 191
 192 T_DISCONNECT_REQ_PDU::T_DISCONNECT_REQ_PDU ()
 193 {
 194 }
 195
 196 bool
 197 T_DISCONNECT_REQ_PDU::init (const CArray & c)
 198 {
 199   if (c () != 1)
 200     return false;
 201   return true;
 202 }
 203
 204 CArray T_DISCONNECT_REQ_PDU::ToPacket ()
 205 {
 206   uchar
 207     c = 0x81;
 208   return CArray (&c, 1);
 209 }
 210
 211 String T_DISCONNECT_REQ_PDU::Decode ()
 212 {
 213   return "T_DISCONNECT_REQ";
 214 }
 215
 216 /* T_ACK */
 217
 218 T_ACK_PDU::T_ACK_PDU ()
 219 {
 220   serno = 0;
 221 }
 222
 223 bool
 224 T_ACK_PDU::init (const CArray & c)
 225 {
 226   if (c () != 1)
 227     return false;
 228   serno = (c[0] >> 2) & 0x0f;
 229   return true;
 230 }
 231
 232 CArray T_ACK_PDU::ToPacket ()
 233 {
 234   assert ((serno & 0xf0) == 0);
 235   uchar
 236     c = 0xC2 | ((serno & 0x0f) << 2);
 237   return CArray (&c, 1);
 238 }
 239
 240 String T_ACK_PDU::Decode ()
 241 {
 242   assert ((serno & 0xf0) == 0);
 243   String
 244   s ("T_ACK Serno:");
 245   addHex (s, serno);
 246   return s;
 247 }
 248
 249 /* T_NACK  */
 250
 251 T_NACK_PDU::T_NACK_PDU ()
 252 {
 253   serno = 0;
 254 }
 255
 256 bool T_NACK_PDU::init (const CArray & c)
 257 {
 258   if (c () != 1)
 259     return false;
 260   serno = (c[0] >> 2) & 0x0f;
 261   return true;
 262 }
 263
 264 CArray T_NACK_PDU::ToPacket ()
 265 {
 266   assert ((serno & 0xf0) == 0);
 267   uchar
 268     c = 0xC3 | ((serno & 0x0f) << 2);
 269   return CArray (&c, 1);
 270 }
 271
 272 String T_NACK_PDU::Decode ()
 273 {
 274   assert ((serno & 0xf0) == 0);
 275   String
 276   s ("T_NACK Serno:");
 277   addHex (s, serno);
 278   return s;
 279 }