| """ Copyright (C) 2010-2011 ST-Ericsson SA """ |
| |
| """ Author: Szymon Janc <szymon.janc@tieto.com> for ST-Ericsson. """ |
| |
| """ 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, write to the Free Software """ |
| """ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA """ |
| |
| from array import array |
| from bluetooth import * |
| import time |
| import re |
| |
| class SAPParam: |
| """ SAP Parameter Class """ |
| |
| MaxMsgSize = 0x00 |
| ConnectionStatus = 0x01 |
| ResultCode = 0x02 |
| DisconnectionType = 0x03 |
| CommandAPDU = 0x04 |
| ResponseAPDU = 0x05 |
| ATR = 0x06 |
| CardReaderStatus = 0x07 |
| StatusChange = 0x08 |
| TransportProtocol = 0x09 |
| CommandAPDU7816 = 0x10 |
| |
| def __init__(self, name, id, value = None): |
| self.name = name |
| self.id = id |
| self.value = value |
| |
| def _padding(self, buf): |
| pad = array('B') |
| while ( (len(buf) + len(pad)) % 4 ) != 0: |
| pad.append(0) |
| return pad |
| |
| def _basicCheck(self, buf): |
| if len(buf) < 4 or (len(buf) % 4) != 0 or buf[1] != 0: |
| return (-1, -1) |
| if buf[0] != self.id: |
| return (-1, -1) |
| plen = buf[2] * 256 + buf[3] + 4 |
| if plen > len(buf): |
| return (-1, -1) |
| pad = plen |
| while (pad % 4) != 0: |
| if buf[pad] != 0: |
| return (-1, -1) |
| pad+=1 |
| return (plen, pad) |
| |
| def getID(self): |
| return self.id |
| |
| def getValue(self): |
| return self.value |
| |
| def getContent(self): |
| return "%s(id=0x%.2X), value=%s \n" % (self.name, self.id, self.value) |
| |
| def serialize(self): |
| a = array('B', '\00\00\00\00') |
| a[0] = self.id |
| a[1] = 0 # reserved |
| a[2] = 0 # length |
| a[3] = 1 # length |
| a.append(self.value) |
| a.extend(self._padding(a)) |
| return a |
| |
| def deserialize(self, buf): |
| p = self._basicCheck(buf) |
| if p[0] == -1: |
| return -1 |
| self.id = buf[0] |
| self.value = buf[4] |
| return p[1] |
| |
| |
| class SAPParam_MaxMsgSize(SAPParam): |
| """MaxMsgSize Param """ |
| |
| def __init__(self, value = None): |
| SAPParam.__init__(self,"MaxMsgSize", SAPParam.MaxMsgSize, value) |
| self.__validate() |
| |
| def __validate(self): |
| if self.value > 0xFFFF: |
| self.value = 0xFFFF |
| |
| def serialize(self): |
| a = array('B', '\00\00\00\00') |
| a[0] = self.id |
| a[3] = 2 |
| a.append(self.value / 256) |
| a.append(self.value % 256) |
| a.extend(self._padding(a)) |
| return a |
| |
| def deserialize(self, buf): |
| p = self._basicCheck(buf) |
| if p[0] == -1 : |
| return -1 |
| self.value = buf[4] * 256 + buf[5] |
| return p[1] |
| |
| class SAPParam_CommandAPDU(SAPParam): |
| def __init__(self, value = None): |
| if value is None: |
| SAPParam.__init__(self, "CommandAPDU", SAPParam.CommandAPDU, array('B')) |
| else: |
| SAPParam.__init__(self, "CommandAPDU", SAPParam.CommandAPDU, array('B', value)) |
| |
| def serialize(self): |
| a = array('B', '\00\00\00\00') |
| a[0] = self.id |
| plen = len(self.value) |
| a[2] = plen / 256 |
| a[3] = plen % 256 |
| a.extend(self.value) |
| a.extend(self._padding(a)) |
| return a |
| |
| def deserialize(self, buf): |
| p = self._basicCheck(buf) |
| if p[0] == -1: |
| return -1 |
| self.value = buf[4:p[0]] |
| return p[1] |
| |
| class SAPParam_ResponseAPDU(SAPParam_CommandAPDU): |
| """ResponseAPDU Param """ |
| |
| def __init__(self, value = None): |
| if value is None: |
| SAPParam.__init__(self, "ResponseAPDU", SAPParam.ResponseAPDU, array('B')) |
| else: |
| SAPParam.__init__(self, "ResponseAPDU", SAPParam.ResponseAPDU, array('B', value)) |
| |
| class SAPParam_ATR(SAPParam_CommandAPDU): |
| """ATR Param """ |
| |
| def __init__(self, value = None): |
| if value is None: |
| SAPParam.__init__(self, "ATR", SAPParam.ATR, array('B')) |
| else: |
| SAPParam.__init__(self, "ATR", SAPParam.ATR, array('B', value)) |
| |
| class SAPParam_CommandAPDU7816(SAPParam_CommandAPDU): |
| """Command APDU7816 Param.""" |
| |
| def __init__(self, value = None): |
| if value is None: |
| SAPParam.__init__(self, "CommandAPDU7816", SAPParam.CommandAPDU7816, array('B')) |
| else: |
| SAPParam.__init__(self, "CommandAPDU7816", SAPParam.CommandAPDU7816, array('B', value)) |
| |
| |
| class SAPParam_ConnectionStatus(SAPParam): |
| """Connection status Param.""" |
| |
| def __init__(self, value = None): |
| SAPParam.__init__(self,"ConnectionStatus", SAPParam.ConnectionStatus, value) |
| self.__validate() |
| |
| def __validate(self): |
| if self.value is not None and self.value not in (0x00, 0x01, 0x02, 0x03, 0x04): |
| print "Warning. ConnectionStatus value in reserved range (0x%x)" % self.value |
| |
| def deserialize(self, buf): |
| ret = SAPParam.deserialize(self, buf) |
| if ret == -1: |
| return -1 |
| self.__validate() |
| return ret |
| |
| class SAPParam_ResultCode(SAPParam): |
| """ Result Code Param """ |
| |
| def __init__(self, value = None): |
| SAPParam.__init__(self,"ResultCode", SAPParam.ResultCode, value) |
| self.__validate() |
| |
| def __validate(self): |
| if self.value is not None and self.value not in (0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07): |
| print "Warning. ResultCode value in reserved range (0x%x)" % self.value |
| |
| def deserialize(self, buf): |
| ret = SAPParam.deserialize(self, buf) |
| if ret == -1: |
| return -1 |
| self.__validate() |
| return ret |
| |
| class SAPParam_DisconnectionType(SAPParam): |
| """Disconnection Type Param.""" |
| |
| def __init__(self, value = None): |
| SAPParam.__init__(self,"DisconnectionType", SAPParam.DisconnectionType, value) |
| self.__validate() |
| |
| def __validate(self): |
| if self.value is not None and self.value not in (0x00, 0x01): |
| print "Warning. DisconnectionType value in reserved range (0x%x)" % self.value |
| |
| def deserialize(self, buf): |
| ret = SAPParam.deserialize(self, buf) |
| if ret == -1: |
| return -1 |
| self.__validate() |
| return ret |
| |
| class SAPParam_CardReaderStatus(SAPParam_CommandAPDU): |
| """Card reader Status Param.""" |
| |
| def __init__(self, value = None): |
| if value is None: |
| SAPParam.__init__(self, "CardReaderStatus", SAPParam.CardReaderStatus, array('B')) |
| else: |
| SAPParam.__init__(self, "CardReaderStatus", SAPParam.CardReaderStatus, array('B', value)) |
| |
| class SAPParam_StatusChange(SAPParam): |
| """Status Change Param """ |
| |
| def __init__(self, value = None): |
| SAPParam.__init__(self,"StatusChange", SAPParam.StatusChange, value) |
| |
| def __validate(self): |
| if self.value is not None and self.value not in (0x00, 0x01, 0x02, 0x03, 0x04, 0x05): |
| print "Warning. StatusChange value in reserved range (0x%x)" % self.value |
| |
| def deserialize(self, buf): |
| ret = SAPParam.deserialize(self, buf) |
| if ret == -1: |
| return -1 |
| self.__validate() |
| return ret |
| |
| class SAPParam_TransportProtocol(SAPParam): |
| """Transport Protocol Param """ |
| |
| def __init__(self, value = None): |
| SAPParam.__init__(self,"TransportProtocol", SAPParam.TransportProtocol, value) |
| self.__validate() |
| |
| def __validate(self): |
| if self.value is not None and self.value not in (0x00, 0x01): |
| print "Warning. TransportProtoco value in reserved range (0x%x)" % self.value |
| |
| def deserialize(self, buf): |
| ret = SAPParam.deserialize(self, buf) |
| if ret == -1: |
| return -1 |
| self.__validate() |
| return ret |
| |
| class SAPMessage: |
| |
| CONNECT_REQ = 0x00 |
| CONNECT_RESP = 0x01 |
| DISCONNECT_REQ = 0x02 |
| DISCONNECT_RESP =0x03 |
| DISCONNECT_IND = 0x04 |
| TRANSFER_APDU_REQ = 0x05 |
| TRANSFER_APDU_RESP = 0x06 |
| TRANSFER_ATR_REQ = 0x07 |
| TRANSFER_ATR_RESP = 0x08 |
| POWER_SIM_OFF_REQ = 0x09 |
| POWER_SIM_OFF_RESP = 0x0A |
| POWER_SIM_ON_REQ = 0x0B |
| POWER_SIM_ON_RESP = 0x0C |
| RESET_SIM_REQ = 0x0D |
| RESET_SIM_RESP = 0x0E |
| TRANSFER_CARD_READER_STATUS_REQ = 0x0F |
| TRANSFER_CARD_READER_STATUS_RESP = 0x10 |
| STATUS_IND = 0x11 |
| ERROR_RESP = 0x12 |
| SET_TRANSPORT_PROTOCOL_REQ = 0x13 |
| SET_TRANSPORT_PROTOCOL_RESP = 0x14 |
| |
| def __init__(self, name, id): |
| self.name = name |
| self.id = id |
| self.params = [] |
| self.buf = array('B') |
| |
| def _basicCheck(self, buf): |
| if len(buf) < 4 or (len(buf) % 4) != 0 : |
| return False |
| |
| if buf[0] != self.id: |
| return False |
| |
| return True |
| |
| def getID(self): |
| return self.id |
| |
| def getContent(self): |
| s = "%s(id=0x%.2X) " % (self.name, self.id) |
| if len( self.buf): s = s + "[%s]" % re.sub("(.{2})", "0x\\1 " , self.buf.tostring().encode("hex").upper(), re.DOTALL) |
| s = s + "\n\t" |
| for p in self.params: |
| s = s + "\t" + p.getContent() |
| return s |
| |
| def getParams(self): |
| return self.params |
| |
| def addParam(self, param): |
| self.params.append(param) |
| |
| def serialize(self): |
| ret = array('B', '\00\00\00\00') |
| ret[0] = self.id |
| ret[1] = len(self.params) |
| ret[2] = 0 # reserved |
| ret[3] = 0 # reserved |
| for p in self.params: |
| ret.extend(p.serialize()) |
| |
| self.buf = ret |
| return ret |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| return len(buf) == 4 and buf[1] == 0 and self._basicCheck(buf) |
| |
| |
| class SAPMessage_CONNECT_REQ(SAPMessage): |
| def __init__(self, MaxMsgSize = None): |
| SAPMessage.__init__(self,"CONNECT_REQ", SAPMessage.CONNECT_REQ) |
| if MaxMsgSize is not None: |
| self.addParam(SAPParam_MaxMsgSize(MaxMsgSize)) |
| |
| def _validate(self): |
| if len(self.params) == 1: |
| if self.params[0].getID() == SAPParam.MaxMsgSize: |
| return True |
| return False |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| self.params[:] = [] |
| if SAPMessage._basicCheck(self, buf): |
| p = SAPParam_MaxMsgSize() |
| if p.deserialize(buf[4:]) == len(buf[4:]): |
| self.addParam(p) |
| return self._validate() |
| |
| return False |
| |
| class SAPMessage_CONNECT_RESP(SAPMessage): |
| def __init__(self, ConnectionStatus = None, MaxMsgSize = None): |
| SAPMessage.__init__(self,"CONNECT_RESP", SAPMessage.CONNECT_RESP) |
| if ConnectionStatus is not None: |
| self.addParam(SAPParam_ConnectionStatus(ConnectionStatus)) |
| if MaxMsgSize is not None: |
| self.addParam(SAPParam_MaxMsgSize(MaxMsgSize)) |
| |
| def _validate(self): |
| if len(self.params) > 0: |
| if self.params[0] .getID() == SAPParam.ConnectionStatus: |
| if self.params[0].getValue() == 0x02: |
| if len(self.params) == 2: |
| return True |
| else: |
| if len(self.params) == 1: |
| return True |
| return False |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| self.params[:] = [] |
| |
| if SAPMessage._basicCheck(self, buf): |
| p = SAPParam_ConnectionStatus() |
| r = p.deserialize(buf[4:]) |
| if r != -1: |
| self.addParam(p) |
| if buf[1] == 2: |
| p = SAPParam_MaxMsgSize() |
| r = p.deserialize(buf[4+r:]) |
| if r != -1: |
| self.addParam(p) |
| |
| return self._validate() |
| |
| return False |
| |
| class SAPMessage_DISCONNECT_REQ(SAPMessage): |
| def __init__(self): |
| SAPMessage.__init__(self,"DISCONNECT_REQ", SAPMessage.DISCONNECT_REQ) |
| |
| class SAPMessage_DISCONNECT_RESP(SAPMessage): |
| def __init__(self): |
| SAPMessage.__init__(self,"DISCONNECT_RESP", SAPMessage.DISCONNECT_RESP) |
| |
| class SAPMessage_DISCONNECT_IND(SAPMessage): |
| def __init__(self, Type = None): |
| SAPMessage.__init__(self,"DISCONNECT_IND", SAPMessage.DISCONNECT_IND) |
| if Type is not None: |
| self.addParam(SAPParam_DisconnectionType(Type)) |
| |
| def _validate(self): |
| if len(self.params) == 1: |
| if self.params[0].getID() == SAPParam.DisconnectionType: |
| return True |
| return False |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| self.params[:] = [] |
| if SAPMessage._basicCheck(self, buf): |
| p = SAPParam_DisconnectionType() |
| if p.deserialize(buf[4:]) == len(buf[4:]): |
| self.addParam(p) |
| return self._validate() |
| |
| return False |
| |
| |
| class SAPMessage_TRANSFER_APDU_REQ(SAPMessage): |
| def __init__(self, APDU = None, T = False): |
| SAPMessage.__init__(self,"TRANSFER_APDU_REQ", SAPMessage.TRANSFER_APDU_REQ) |
| if APDU is not None: |
| if T : |
| self.addParam(SAPParam_CommandAPDU(APDU)) |
| else: |
| self.addParam(SAPParam_CommandAPDU7816(APDU)) |
| |
| def _validate(self): |
| if len(self.params) == 1: |
| if self.params[0].getID() == SAPParam.CommandAPDU or self.params[0].getID() == SAPParam.CommandAPDU7816: |
| return True |
| return False |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| self.params[:] = [] |
| if SAPMessage._basicCheck(self, buf): |
| |
| p = SAPParam_CommandAPDU() |
| p2 = SAPParam_CommandAPDU7816() |
| if p.deserialize(buf[4:]) == len(buf[4:]): |
| self.addParam(p) |
| return self._validate() |
| elif p2.deserialize(buf[4:]) == len(buf[4:]): |
| self.addParam(p2) |
| return self._validate() |
| |
| return False |
| |
| class SAPMessage_TRANSFER_APDU_RESP(SAPMessage): |
| def __init__(self, ResultCode = None, Response = None): |
| SAPMessage.__init__(self,"TRANSFER_APDU_RESP", SAPMessage.TRANSFER_APDU_RESP) |
| if ResultCode is not None: |
| self.addParam(SAPParam_ResultCode(ResultCode)) |
| if Response is not None: |
| self.addParam(SAPParam_ResponseAPDU(Response)) |
| |
| def _validate(self): |
| if len(self.params) > 0: |
| if self.params[0] .getID() == SAPParam.ResultCode: |
| if self.params[0].getValue() == 0x00: |
| if len(self.params) == 2: |
| return True |
| else: |
| if len(self.params) == 1: |
| return True |
| return False |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| self.params[:] = [] |
| |
| if SAPMessage._basicCheck(self, buf): |
| p = SAPParam_ResultCode() |
| r = p.deserialize(buf[4:]) |
| if r != -1: |
| self.addParam(p) |
| if buf[1] == 2: |
| p = SAPParam_ResponseAPDU() |
| r = p.deserialize(buf[4+r:]) |
| if r != -1: |
| self.addParam(p) |
| |
| return self._validate() |
| |
| return False |
| |
| class SAPMessage_TRANSFER_ATR_REQ(SAPMessage): |
| def __init__(self): |
| SAPMessage.__init__(self,"TRANSFER_ATR_REQ", SAPMessage.TRANSFER_ATR_REQ) |
| |
| class SAPMessage_TRANSFER_ATR_RESP(SAPMessage): |
| def __init__(self, ResultCode = None, ATR = None): |
| SAPMessage.__init__(self,"TRANSFER_ATR_RESP", SAPMessage.TRANSFER_ATR_RESP) |
| if ResultCode is not None: |
| self.addParam(SAPParam_ResultCode(ResultCode)) |
| if ATR is not None: |
| self.addParam(SAPParam_ATR(ATR)) |
| |
| def _validate(self): |
| if len(self.params) > 0: |
| if self.params[0] .getID() == SAPParam.ResultCode: |
| if self.params[0].getValue() == 0x00: |
| if len(self.params) == 2: |
| return True |
| else: |
| if len(self.params) == 1: |
| return True |
| return False |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| self.params[:] = [] |
| |
| if SAPMessage._basicCheck(self, buf): |
| |
| p = SAPParam_ResultCode() |
| r = p.deserialize(buf[4:]) |
| |
| if r != -1: |
| |
| self.addParam(p) |
| if buf[1] == 2: |
| |
| p = SAPParam_ATR() |
| r = p.deserialize(buf[4+r:]) |
| if r != -1: |
| self.addParam(p) |
| |
| return self._validate() |
| |
| return False |
| |
| class SAPMessage_POWER_SIM_OFF_REQ(SAPMessage): |
| def __init__(self): |
| SAPMessage.__init__(self,"POWER_SIM_OFF_REQ", SAPMessage.POWER_SIM_OFF_REQ) |
| |
| class SAPMessage_POWER_SIM_OFF_RESP(SAPMessage): |
| def __init__(self, ResultCode = None): |
| SAPMessage.__init__(self,"POWER_SIM_OFF_RESP", SAPMessage.POWER_SIM_OFF_RESP) |
| if ResultCode is not None: |
| self.addParam(SAPParam_ResultCode(ResultCode)) |
| |
| def _validate(self): |
| if len(self.params) == 1: |
| if self.params[0].getID() == SAPParam.ResultCode: |
| return True |
| return False |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| self.params[:] = [] |
| if SAPMessage._basicCheck(self, buf): |
| p = SAPParam_ResultCode() |
| if p.deserialize(buf[4:]) == len(buf[4:]): |
| self.addParam(p) |
| return self._validate() |
| |
| return False |
| |
| class SAPMessage_POWER_SIM_ON_REQ(SAPMessage): |
| def __init__(self): |
| SAPMessage.__init__(self,"POWER_SIM_ON_REQ", SAPMessage.POWER_SIM_ON_REQ) |
| |
| class SAPMessage_POWER_SIM_ON_RESP(SAPMessage_POWER_SIM_OFF_RESP): |
| def __init__(self, ResultCode = None): |
| SAPMessage.__init__(self,"POWER_SIM_ON_RESP", SAPMessage.POWER_SIM_ON_RESP) |
| if ResultCode is not None: |
| self.addParam(SAPParam_ResultCode(ResultCode)) |
| |
| class SAPMessage_RESET_SIM_REQ(SAPMessage): |
| def __init__(self): |
| SAPMessage.__init__(self,"RESET_SIM_REQ", SAPMessage.RESET_SIM_REQ) |
| |
| class SAPMessage_RESET_SIM_RESP(SAPMessage_POWER_SIM_OFF_RESP): |
| def __init__(self, ResultCode = None): |
| SAPMessage.__init__(self,"RESET_SIM_RESP", SAPMessage.RESET_SIM_RESP) |
| if ResultCode is not None: |
| self.addParam(SAPParam_ResultCode(ResultCode)) |
| |
| class SAPMessage_STATUS_IND(SAPMessage): |
| def __init__(self, StatusChange = None): |
| SAPMessage.__init__(self,"STATUS_IND", SAPMessage.STATUS_IND) |
| if StatusChange is not None: |
| self.addParam(SAPParam_StatusChange(StatusChange)) |
| |
| def _validate(self): |
| if len(self.params) == 1: |
| if self.params[0].getID() == SAPParam.StatusChange: |
| return True |
| return False |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| self.params[:] = [] |
| if SAPMessage._basicCheck(self, buf): |
| p = SAPParam_StatusChange() |
| if p.deserialize(buf[4:]) == len(buf[4:]): |
| self.addParam(p) |
| return self._validate() |
| |
| return False |
| |
| class SAPMessage_TRANSFER_CARD_READER_STATUS_REQ(SAPMessage): |
| def __init__(self): |
| SAPMessage.__init__(self,"TRANSFER_CARD_READER_STATUS_REQ", SAPMessage.TRANSFER_CARD_READER_STATUS_REQ) |
| |
| class SAPMessage_TRANSFER_CARD_READER_STATUS_RESP(SAPMessage): |
| def __init__(self, ResultCode = None, Status = None): |
| SAPMessage.__init__(self,"TRANSFER_CARD_READER_STATUS_RESP", SAPMessage.TRANSFER_CARD_READER_STATUS_RESP) |
| if ResultCode is not None: |
| self.addParam(SAPParam_ResultCode(ResultCode)) |
| if Status is not None: |
| self.addParam(SAPParam_CardReaderStatus(Status)) |
| |
| def _validate(self): |
| if len(self.params) > 0: |
| if self.params[0] .getID() == SAPParam.ResultCode: |
| if self.params[0].getValue() == 0x00: |
| if len(self.params) == 2: |
| return True |
| else: |
| if len(self.params) == 1: |
| return True |
| return False |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| self.params[:] = [] |
| |
| if SAPMessage._basicCheck(self, buf): |
| p = SAPParam_ResultCode() |
| r = p.deserialize(buf[4:]) |
| if r != -1: |
| self.addParam(p) |
| if buf[1] == 2: |
| p = SAPParam_CardReaderStatus() |
| r = p.deserialize(buf[4+r:]) |
| if r != -1: |
| self.addParam(p) |
| |
| return self._validate() |
| |
| return False |
| |
| class SAPMessage_ERROR_RESP(SAPMessage): |
| def __init__(self): |
| SAPMessage.__init__(self,"ERROR_RESP", SAPMessage.ERROR_RESP) |
| |
| |
| class SAPMessage_SET_TRANSPORT_PROTOCOL_REQ(SAPMessage): |
| def __init__(self, protocol = None): |
| SAPMessage.__init__(self,"SET_TRANSPORT_PROTOCOL_REQ", SAPMessage.SET_TRANSPORT_PROTOCOL_REQ) |
| if protocol is not None: |
| self.addParam(SAPParam_TransportProtocol(protocol)) |
| |
| def _validate(self): |
| if len(self.params) == 1: |
| if self.params[0].getID() == SAPParam.TransportProtocol: |
| return True |
| return False |
| |
| def deserialize(self, buf): |
| self.buf = buf |
| self.params[:] = [] |
| if SAPMessage._basicCheck(self, buf): |
| p = SAPParam_TransportProtocol() |
| if p.deserialize(buf[4:]) == len(buf[4:]): |
| self.addParam(p) |
| return self._validate() |
| |
| return False |
| |
| class SAPMessage_SET_TRANSPORT_PROTOCOL_RESP(SAPMessage_POWER_SIM_OFF_RESP): |
| def __init__(self, ResultCode = None): |
| SAPMessage.__init__(self,"SET_TRANSPORT_PROTOCOL_RESP", SAPMessage.SET_TRANSPORT_PROTOCOL_RESP) |
| if ResultCode is not None: |
| self.addParam(SAPParam_ResultCode(ResultCode)) |
| |
| |
| class SAPClient: |
| |
| CONNECTED = 1 |
| DISCONNECTED = 0 |
| |
| uuid = "0000112D-0000-1000-8000-00805F9B34FB" |
| bufsize = 1024 |
| timeout = 20 |
| state = DISCONNECTED |
| |
| def __init__(self, host = None, port = None): |
| self.sock = None |
| |
| if host is None or is_valid_address(host): |
| self.host = host |
| else: |
| raise BluetoothError ("%s is not a valid BT address." % host) |
| self.host = None |
| return |
| |
| if port is None: |
| self.__discover() |
| else: |
| self.port = port |
| |
| self.__connectRFCOMM() |
| |
| def __del__(self): |
| self.__disconnectRFCOMM() |
| |
| def __disconnectRFCOMM(self): |
| if self.sock is not None: |
| self.sock.close() |
| self.state = self.DISCONNECTED |
| |
| def __discover(self): |
| service_matches = find_service(self.uuid, self.host) |
| |
| if len(service_matches) == 0: |
| raise BluetoothError ("No SAP service found") |
| return |
| |
| first_match = service_matches[0] |
| self.port = first_match["port"] |
| self.host = first_match["host"] |
| |
| print "SAP Service found on %s(%s)" % first_match["name"] % self.host |
| |
| def __connectRFCOMM(self): |
| self.sock=BluetoothSocket( RFCOMM ) |
| self.sock.connect((self.host, self.port)) |
| self.sock.settimeout(self.timeout) |
| self.state = self.CONNECTED |
| |
| def __sendMsg(self, msg): |
| if isinstance(msg, SAPMessage): |
| s = msg.serialize() |
| print "\tTX: " + msg.getContent() |
| return self.sock.send(s.tostring()) |
| |
| def __rcvMsg(self, msg): |
| if isinstance(msg, SAPMessage): |
| print "\tRX Wait: %s(id = 0x%.2x)" % (msg.name, msg.id) |
| data = self.sock.recv(self.bufsize) |
| if data: |
| if msg.deserialize(array('B',data)): |
| print "\tRX: len(%d) %s" % (len(data), msg.getContent()) |
| return msg |
| else: |
| print "msg: %s" % array('B',data) |
| raise BluetoothError ("Message deserialization failed.") |
| else: |
| raise BluetoothError ("Timeout. No data received.") |
| |
| def connect(self): |
| self.__connectRFCOMM() |
| |
| def disconnect(self): |
| self.__disconnectRFCOMM() |
| |
| def isConnected(self): |
| return self.state |
| |
| def proc_connect(self): |
| try: |
| self.__sendMsg(SAPMessage_CONNECT_REQ(self.bufsize)) |
| params = self.__rcvMsg(SAPMessage_CONNECT_RESP()).getParams() |
| |
| if params[0].getValue() in (0x00, 0x04): |
| pass |
| elif params[0].getValue() == 0x02: |
| self.bufsize = params[1].getValue() |
| |
| self.__sendMsg(SAPMessage_CONNECT_REQ(self.bufsize)) |
| params = self.__rcvMsg(SAPMessage_CONNECT_RESP()).getParams() |
| |
| if params[0].getValue() not in (0x00, 0x04): |
| return False |
| else: |
| return False |
| |
| params = self.__rcvMsg(SAPMessage_STATUS_IND()).getParams() |
| if params[0].getValue() == 0x00: |
| return False |
| elif params[0].getValue() == 0x01: |
| """OK, Card reset""" |
| return self.proc_transferATR() |
| elif params[0].getValue() == 0x02: |
| """T0 not supported""" |
| if self.proc_transferATR(): |
| return self.proc_setTransportProtocol(1) |
| else: |
| return False |
| else: |
| return False |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_disconnectByClient(self, timeout=0): |
| try: |
| self.__sendMsg(SAPMessage_DISCONNECT_REQ()) |
| self.__rcvMsg(SAPMessage_DISCONNECT_RESP()) |
| time.sleep(timeout) # let srv to close rfcomm |
| self.__disconnectRFCOMM() |
| return True |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_disconnectByServer(self, timeout=0): |
| try: |
| params = self.__rcvMsg(SAPMessage_DISCONNECT_IND()).getParams() |
| |
| """graceful""" |
| if params[0].getValue() == 0x00: |
| if not self.proc_transferAPDU(): |
| return False |
| |
| return self.proc_disconnectByClient(timeout) |
| |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_transferAPDU(self, apdu = "Sample APDU command"): |
| try: |
| self.__sendMsg(SAPMessage_TRANSFER_APDU_REQ(apdu)) |
| params = self.__rcvMsg(SAPMessage_TRANSFER_APDU_RESP()).getParams() |
| return True |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_transferATR(self): |
| try: |
| self.__sendMsg(SAPMessage_TRANSFER_ATR_REQ()) |
| params = self.__rcvMsg(SAPMessage_TRANSFER_ATR_RESP()).getParams() |
| return True |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_powerSimOff(self): |
| try: |
| self.__sendMsg(SAPMessage_POWER_SIM_OFF_REQ()) |
| params = self.__rcvMsg(SAPMessage_POWER_SIM_OFF_RESP()).getParams() |
| return True |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_powerSimOn(self): |
| try: |
| self.__sendMsg(SAPMessage_POWER_SIM_ON_REQ()) |
| params = self.__rcvMsg(SAPMessage_POWER_SIM_ON_RESP()).getParams() |
| if params[0].getValue() == 0x00: |
| return self.proc_transferATR() |
| |
| return True |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_resetSim(self): |
| try: |
| self.__sendMsg(SAPMessage_RESET_SIM_REQ()) |
| params = self.__rcvMsg(SAPMessage_RESET_SIM_RESP()).getParams() |
| if params[0].getValue() == 0x00: |
| return self.proc_transferATR() |
| |
| return True |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_reportStatus(self): |
| try: |
| params = self.__rcvMsg(SAPMessage_STATUS_IND()).getParams() |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_transferCardReaderStatus(self): |
| try: |
| self.__sendMsg(SAPMessage_TRANSFER_CARD_READER_STATUS_REQ()) |
| params = self.__rcvMsg(SAPMessage_TRANSFER_CARD_READER_STATUS_RESP()).getParams() |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_errorResponse(self): |
| try: |
| """ send malformed message, no mandatory maxmsgsize parameter""" |
| self.__sendMsg(SAPMessage_CONNECT_REQ()) |
| |
| params = self.__rcvMsg(SAPMessage_ERROR_RESP()).getParams() |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| def proc_setTransportProtocol(self, protocol = 0): |
| try: |
| self.__sendMsg(SAPMessage_SET_TRANSPORT_PROTOCOL_REQ(protocol)) |
| params = self.__rcvMsg(SAPMessage_SET_TRANSPORT_PROTOCOL_RESP()).getParams() |
| |
| if params[0].getValue() == 0x00: |
| params = self.__rcvMsg(SAPMessage_STATUS_IND()).getParams() |
| if params[0].getValue() in (0x01, 0x02): |
| return self.proc_transferATR() |
| else: |
| return True |
| """return False ???""" |
| elif params[0].getValue == 0x07: |
| """not supported""" |
| return True |
| """return False ???""" |
| else: |
| return False |
| |
| except BluetoothError , e: |
| print "Error. " +str(e) |
| return False |
| |
| if __name__ == "__main__": |
| pass |
