486 lines
18 KiB
C
Executable File
486 lines
18 KiB
C
Executable File
/*
|
|
* Griffin card reader for OSCAM
|
|
* Copyright (C) 2013 Unix Solutions Ltd.
|
|
*
|
|
* Author(s): Georgi Chorbadzhiyski (gf@unixsol.org)
|
|
*
|
|
* 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* =========================================================================
|
|
* Once upon a time Bulsatcom in Bulgaria used Griffin CAS. Their cards were
|
|
* known as "strawberry cards" because they had a strawberry picture on the
|
|
* front. These cards have CAID 0x5501. You can't get EMM and ECM stream
|
|
* for these cards but if you can, then the reader would probably work.
|
|
*
|
|
* This reader is tested with working card that have CAID 0x5504. This card
|
|
* is used by KaTe Nova Gorica provider in Slovenia.
|
|
* =========================================================================
|
|
*
|
|
* Griffin reader card protocol:
|
|
* ATR from CAID 0x5501
|
|
* 3B 08 01 01 xx xx xx xx 10 00
|
|
* (01 - last two octets in caid (0x01 = CAID 0x5501)
|
|
* (xx - card hex serial number)
|
|
* (10 - command base)
|
|
*
|
|
* ATR from CAID 0x5504
|
|
* 3B 08 04 01 xx xx xx xx 20 00
|
|
* (04 - last two octets in caid (0x04 = CAID 0x5504)
|
|
* (xx - card hex serial number)
|
|
* (20 - command base)
|
|
*
|
|
* The basic card conversation looks like this:
|
|
* Send DC xx 00 00 yy zz zz zz (xx = command op, yy payload length, zz - payload if payload_len > 0)
|
|
* Recv 90 03 (90 = command ok, 03 = length of the response)
|
|
* Send DC 12 00 00 xx (Read response , xx = length of the response)
|
|
* Recv xx yy zz 90 00 (Response , xx = response code, yy - data length, zz - data, 90 00 at the end)
|
|
*
|
|
* Command ops (hex), these commands are for card with base == 20:
|
|
* 02 - read command response (for base cards with base 10)
|
|
* 12 - read command response (for base cards with base 20)
|
|
*
|
|
* The command number is (base + number, the numbers bellow are for base==20)
|
|
* 20 - card init
|
|
* 22 - get hex serial
|
|
* 24 - get ascii serial
|
|
* 26 - get caid
|
|
* 28 - get card addresses
|
|
* 30 - unknown command
|
|
* 34 - unknown command
|
|
* 36 - send_ecm
|
|
* 32 - send_emm
|
|
* 40 - get subscription info
|
|
* 42 - unknown command
|
|
* 4a - unknown command
|
|
* 50 - unknown command
|
|
*
|
|
* Perform card INIT
|
|
* DC 20 00 00 00 -- 90 03 (card init /get base/)
|
|
* DC 12 00 00 03 -- 11 01 20 90 00 (20 == cmd base)
|
|
*
|
|
* DC 22 00 00 00 -- 90 06 (get hex serial)
|
|
* DC 12 00 00 06 -- 12 04 xx xx xx xx 90 00 (xx - hex serial)
|
|
*
|
|
* DC 24 00 00 00 -- 90 0E (get ascii serial)
|
|
* DC 12 00 00 0E -- 13 0C 47 43 30 34 53 xx xx xx xx xx xx 00 90 00 (xx - ascii serial - GC04S......)
|
|
*
|
|
* DC 26 00 00 00 -- 90 04 (get caid)
|
|
* DC 12 00 00 04 -- 14 02 xx xx 90 00 (xx xx = 55 04 /the caid/)
|
|
*
|
|
* DC 28 00 00 00 -- 90 32
|
|
* DC 12 00 00 32 -- 15 30 \
|
|
* 80 00 00 00 00 00 00 00 F0 FF FF FF FF 00 00 00 \
|
|
* 80 yy yy yy yy 00 00 00 F0 FF FF FF FF 00 00 00 \ (yy = shared card address)
|
|
* 80 xx xx xx xx 00 00 00 F0 FF FF FF FF 00 00 00 90 00 (xx = card hex serial)
|
|
*
|
|
* DC 42 00 00 00 -- 90 03
|
|
* DC 12 00 00 03 -- 1C 01 00 90 00
|
|
*
|
|
* DC 34 00 00 00 -- 90 00
|
|
* DC 30 00 00 00 -- 90 00
|
|
*
|
|
* Send ECMs
|
|
* DC 36 00 00 42 -- 81 70 3F C6 71 A3 97 A3 91 36 76 C9 69 EC A8 46 CA FB 0B 31 D2 4B 2A BD 43 FF 5E A4 C0 CD 06 A9 48 1B 2B 6C 3D 28 B2 92 3A C0 C2 1C 38 35 29 D0 9D B2 16 6D 26 E3 27 A3 20 6F 8E 72 5D 0B A3 00 65 EC 90 18
|
|
* DC 36 00 00 42 -- 80 70 3F 09 D2 9B F3 03 E3 81 5A E4 44 F4 18 9E 84 18 D5 6E 81 D8 1F A2 E8 CB 1B B6 A9 3D 5D C2 CA FE 6A C2 69 1A CD 15 7F 2C A6 77 8B CF 0C 4E 4F 74 04 97 17 15 93 4F 2E 93 10 B8 6B B0 FF 1C 20 7D 90 18
|
|
*
|
|
* DC 36 00 00 41 -- 81 70 3E 09 EC 39 F4 35 CF 45 80 AB 17 56 56 64 F0 BB 39 97 BE 7F 9E D3 F7 70 6A B2 8A 52 56 BD B4 B3 77 14 22 13 70 7F 9D 03 2A BB 88 85 3E 1D AB 9D E1 C7 A1 CB B9 99 34 F6 EB 2C 15 7F 52 E5 1C 90 18
|
|
* DC 36 00 00 41 -- 80 70 3E F4 7E B1 C4 30 56 C2 61 AA 31 29 FB 09 1C 79 13 14 8E 64 43 5F 4B 97 71 A0 D3 BA A4 08 AC 8B E4 21 B7 C6 8A A5 9F 72 19 A5 51 75 9B F2 40 B2 C9 8F E8 63 98 2C 5D 84 21 88 8F F1 DA CF 32 90 18
|
|
*
|
|
* DC 36 00 00 3E -- 81 70 3B 07 76 06 C8 8D 9F 57 C8 19 30 1C 3B 93 9B A1 E1 88 E7 82 C3 E5 7A 05 44 DF 7D 90 CB F9 E1 43 C7 6F 39 75 3A A5 15 73 AA 5F 8C 1D 5B B6 52 2B 0B C2 02 88 7C C2 E8 4F D6 6A 73 A6 90 18
|
|
* DC 36 00 00 3E -- 80 70 3B CE B9 CC BC 95 D8 BB 4A C0 7B 7C 7E 9C 39 00 10 47 E1 67 A7 CD 34 9F E6 43 CB 50 2E 77 9A 54 87 54 25 49 FC 4F 6A A6 56 FD 51 74 08 37 C3 00 04 BD 72 04 CB DB D9 7C 37 76 71 A7 90 18
|
|
*
|
|
* DC 36 00 00 3D -- 81 70 3A 22 06 2B 48 2A 99 4B 82 20 C4 80 B4 55 72 CD B3 C9 FD BA 84 89 66 F4 F8 51 7F CD AC 38 4E 0E 6A 91 11 E9 E1 A4 0E 8D E7 56 43 11 56 F5 DA 78 19 42 37 B3 CA BA 33 11 69 B9 96 90 18
|
|
* DC 36 00 00 3D -- 80 70 3A FB 09 20 41 48 2D 12 4F E8 13 E3 23 AD B9 25 CE DA 95 F2 C8 ED D6 08 2E 23 6A 13 19 A8 A7 9F 9A 8B 12 F3 97 95 09 5B F6 F6 AA 64 EA 46 3C AD 62 93 DC B5 07 FB 16 81 F8 A6 D3 90 18
|
|
*
|
|
* DC 36 00 00 3A -- 81 70 37 16 21 7A 01 9A A5 BB C8 9E 93 88 79 56 C1 41 B4 37 5F 1F 3A 69 1E 4A CA DB 56 77 98 3A 02 9E 2C 8A FE 24 51 DD 5E F9 23 79 AF 4D 63 27 34 A0 28 44 11 45 BA 72 F2 92 90 18
|
|
* DC 36 00 00 3A -- 80 70 37 79 E6 26 6E 93 D8 8E F1 DC A1 70 7A 36 77 6D 68 AE 36 1B 85 E4 85 EE 35 E8 33 5A 4D 84 AC AA 87 5B 7B EF F3 DF 76 20 7B 0A 91 B3 B1 3D 97 FE 21 8C 52 E2 8F 01 5D 50 90 18
|
|
*
|
|
* Read DCWs (after sending ECM)
|
|
* DC 12 00 00 18 -- 19 04 00 00 00 00 1A 10 F9 EE 8F 76 A9 85 DC 0A E3 92 51 C6 40 B4 B0 A4 90 00
|
|
* DC 12 00 00 18 -- 19 04 00 00 00 00 1A 10 F9 EE 8F 76 A9 85 DC 0A 51 AB 96 92 7C A0 7F 9B 90 00
|
|
* DC 12 00 00 18 -- 19 04 00 00 00 00 1A 10 F6 51 8F D6 E6 F0 5E 34 AA 41 86 71 CC C0 29 B5 90 00
|
|
* DC 12 00 00 18 -- 19 04 00 00 00 00 1A 10 F6 51 8F D6 E6 F0 5E 34 51 AB 96 92 7C A0 7F 9B 90 00
|
|
*
|
|
* Send EMMs
|
|
* DC 32 00 00 B2 -- 83 70 AF -- -- -- -- 3F 38 ED 59 0B 52 7D 8B D9 43 B5 51 6F C5 1D F2 36 35 C4 90 92 83 92 3E A2 99 47 76 3A CF 81 79 5C A1 4E B3 5D 09 D0 7E 86 3F DD C8 56 30 72 B4 E0 DE 0F 76 03 6F 16 F4 1F 4E 35 DC 6F 36 E8 DB E8 F3 75 BB CF 7B FE 46 91 8F F9 1C 7D 18 27 98 27 31 5A A4 39 44 E5 62 B0 DA 81 73 65 58 08 0B 44 20 57 37 DA 20 19 6B 35 F4 07 74 BA 42 75 AD 4A C5 86 C1 E3 03 C1 A2 05 C2 A3 C2 4C 57 B8 7E 3E DE 74 FB 5D 32 4A 7F 68 2B 74 E8 84 B6 33 52 6A B8 3D FD 3F 14 C4 39 39 39 28 80 B1 AC 77 39 A0 EF 8A 3C F5 4F F6 99 67 90 A4 90 0A
|
|
* DC 12 00 00 0A -- 1F 04 51 06 B5 B5 16 02 01 00 90 00
|
|
*
|
|
* DC 32 00 00 AF -- 82 70 AC -- -- -- -- C6 94 A0 54 68 47 D0 3F FB 05 C6 A3 C5 FA 5F F0 A7 56 96 19 A5 F6 31 95 CD F1 8D 71 C3 FE 96 FD 75 2A DE 1F 12 08 8C 53 5D B6 4E FC 34 5D F0 BB 52 84 6C 71 C3 EA CE 4C 8A 08 45 22 E3 74 4A 37 48 39 75 37 0C 4A A9 8B 62 D8 F5 EE EC 28 E2 92 66 2D DA FF 8C 2B BD 97 C5 95 6B A0 6F 8B 82 79 09 79 E6 63 66 77 0A AB 8F EC 65 4F EC 05 75 2B FD DF 78 85 48 6C 2C A0 4D 4C 96 B6 08 21 A1 01 8D 74 CC F3 92 04 D2 15 49 F7 CE 74 6B 38 D9 22 66 2D 7E D6 78 BB 3D 0B 30 A7 64 A1 DC AE 0E 54 90 D0 83 BC 89 9F CA 50 90 00
|
|
*
|
|
* Get subscription info (for base 20 cards - CAID 5504)
|
|
* DC 40 00 00 00 -- 90 3C
|
|
* DC 12 00 00 3C -- 1B 02 07 FF 1B 02 07 FF 1B 02 07 FF 1B 02 07 FF 1B 02 00 0F 1B 02 00 00 \
|
|
* 1B 02 00 00 1B 02 00 00 1B 02 00 00 1B 02 00 00 1B 02 00 00 1B 02 00 00 \
|
|
* 1B 02 00 00 1B 02 00 00 1B 02 00 00 90 00
|
|
*
|
|
* Get subscription info (for base 10 cards - CAID 5501)
|
|
* DC 30 00 00 00 -- 90 2D
|
|
* DC 02 00 00 2D -- 0B 07 30 30 30 30 36 30 00 0B 07 30 30 30 30 36 30 00 \
|
|
* 0B 07 30 30 30 30 36 30 00 0B 07 30 30 30 30 36 30 00 \
|
|
* 0B 07 30 30 30 30 31 32 00 90 00
|
|
*
|
|
* Unknown commands
|
|
* DC 4A 00 00 00 -- 90 06
|
|
* DC 12 00 00 06 -- 1D 04 00 00 00 00 90 00
|
|
*
|
|
* DC 50 00 00 00 -- 90 0E
|
|
* DC 12 00 00 0E -- 1E 0C 00 0F 42 40 00 3D 09 00 00 1F 01 74 90 00
|
|
*
|
|
*/
|
|
|
|
#include "globals.h"
|
|
|
|
#ifdef READER_GRIFFIN
|
|
#include "reader-common.h"
|
|
|
|
#define DEBUG 0
|
|
|
|
#define GRIFFIN_CMD_INIT 0x00
|
|
#define GRIFFIN_CMD_GET_HEX_SERIAL 0x02
|
|
#define GRIFFIN_CMD_GET_ASCII_SERIAL 0x04
|
|
#define GRIFFIN_CMD_GET_CAID 0x06
|
|
#define GRIFFIN_CMD_GET_CARD_ADDRESS 0x08
|
|
#define GRIFFIN_CMD_SEND_EMM 0x12
|
|
#define GRIFFIN_CMD_SEND_ECM 0x16
|
|
#define GRIFFIN_CMD_SUBSCRIPTION_INFO 0x20
|
|
|
|
#define cmd_buf_len 512
|
|
|
|
struct griffin_data
|
|
{
|
|
uint8_t cmd_base; // Command base, depends on the card
|
|
};
|
|
|
|
// Sets cmd_buf and returns buf_len
|
|
static uint32_t griffin_init_cmd(struct s_reader *rdr, uint8_t *cmd_buf, uint8_t cmd_op, const uint8_t *data, uint8_t data_len)
|
|
{
|
|
#define cmd_len 5
|
|
|
|
memset(cmd_buf, 0, cmd_buf_len);
|
|
cmd_buf[0] = 0xDC; // Command start
|
|
cmd_buf[1] = cmd_op;
|
|
cmd_buf[2] = 0x00;
|
|
cmd_buf[3] = 0x00;
|
|
cmd_buf[4] = data_len; // Set payload length
|
|
|
|
if(data && data_len)
|
|
{ memcpy(cmd_buf + cmd_len, data, data_len); }
|
|
|
|
uint32_t len = cmd_len + (data ? data_len : 0);
|
|
|
|
if(DEBUG)
|
|
{
|
|
char tmp[1024];
|
|
rdr_log(rdr, "SEND[-] -> %s", cs_hexdump(1, cmd_buf, len, tmp, sizeof(tmp)));
|
|
}
|
|
return len;
|
|
}
|
|
|
|
static int32_t griffin_exec_cmd(struct s_reader *rdr, uint8_t cmd_op, const uint8_t *data, uint8_t data_len, uint8_t *response, uint16_t *response_length)
|
|
{
|
|
struct griffin_data *csystem_data = rdr->csystem_data;
|
|
uint8_t buf[cmd_buf_len];
|
|
|
|
int32_t ret = reader_cmd2icc(rdr, buf, griffin_init_cmd(rdr, buf, csystem_data->cmd_base + cmd_op,
|
|
data, data_len), response, response_length);
|
|
|
|
if(DEBUG)
|
|
{
|
|
char tmp[1024];
|
|
rdr_log(rdr, "RECV[1] <- %s (ret=%d resp_len=%d)", cs_hexdump(1, response, *response_length, tmp, sizeof(tmp)), ret, *response_length);
|
|
}
|
|
|
|
if(ret || *response_length < 2) { return ERROR; } // Response is two short
|
|
if(response[0] != 0x90) { return ERROR; } // Invalid response
|
|
if(response[1] == 0) { return OK; } // Nothing to retrieve, command OK
|
|
|
|
// Retrieve response
|
|
uint8_t cmd_read_response = 0x02;
|
|
if(csystem_data->cmd_base > 0x10)
|
|
{ cmd_read_response += csystem_data->cmd_base - 0x10; }
|
|
|
|
ret = reader_cmd2icc(rdr, buf, griffin_init_cmd(rdr, buf, cmd_read_response, NULL, response[1]), response, response_length);
|
|
|
|
if(DEBUG)
|
|
{
|
|
char tmp[1024];
|
|
rdr_log(rdr, "RECV[2] <- %s (ret=%d resp_len=%d)", cs_hexdump(1, response, *response_length, tmp, sizeof(tmp)), ret, *response_length);
|
|
}
|
|
|
|
if(ret || *response_length < 2) { return ERROR; } // Response is two short
|
|
if(response[*response_length - 2] != 0x90) { return ERROR; } // Invalid response
|
|
if(response[*response_length - 1] != 0x00) { return ERROR; } // We don't expect command_op 0x12 to return more data
|
|
return OK;
|
|
}
|
|
|
|
#define griffin_cmd(_cmd_op, _data, _data_len, _min_resp_len) \
|
|
do { \
|
|
if (!griffin_exec_cmd(rdr, _cmd_op, _data, _data_len, cta_res, &cta_lr) || cta_lr < _min_resp_len) \
|
|
return ERROR; \
|
|
} while(0)
|
|
|
|
static int32_t griffin_card_init(struct s_reader *rdr, ATR *newatr)
|
|
{
|
|
int32_t i;
|
|
get_atr
|
|
def_resp
|
|
|
|
if(atr_size < 10)
|
|
{
|
|
return ERROR;
|
|
}
|
|
|
|
// 0 1 2 3 4 5 6 7 8 9
|
|
// ATR: 3B 08 yy 01 xx xx xx xx 10 00
|
|
if(atr[0] != 0x3b || atr[1] != 0x08 || atr[3] != 0x01 || atr[9] != 0x00)
|
|
{
|
|
return ERROR;
|
|
}
|
|
|
|
if(!cs_malloc(&rdr->csystem_data, sizeof(struct griffin_data)))
|
|
{
|
|
return ERROR;
|
|
}
|
|
|
|
struct griffin_data *csystem_data = rdr->csystem_data;
|
|
|
|
rdr->nprov = 1;
|
|
memset(rdr->sa, 0, sizeof(rdr->sa));
|
|
memset(rdr->prid, 0, sizeof(rdr->prid));
|
|
memset(rdr->hexserial, 0, sizeof(rdr->hexserial));
|
|
|
|
rdr->caid = (0x55 << 8) | atr[2];
|
|
memcpy(rdr->hexserial, atr + 4, 4);
|
|
csystem_data->cmd_base = atr[8];
|
|
|
|
rdr_log_sensitive(rdr, "[griffin-reader] card detected, cmd_base: %02X caid: %04X hexserial: {%02X %02X %02X %02X}",
|
|
csystem_data->cmd_base, rdr->caid, rdr->hexserial[0], rdr->hexserial[1], rdr->hexserial[2], rdr->hexserial[3]);
|
|
|
|
griffin_cmd(GRIFFIN_CMD_INIT, NULL, 0, 2);
|
|
csystem_data->cmd_base = cta_res[2]; // already set from ATR
|
|
|
|
griffin_cmd(GRIFFIN_CMD_GET_HEX_SERIAL, NULL, 0, 6);
|
|
memcpy(rdr->hexserial, cta_res + 2, 4);
|
|
|
|
char serial[16];
|
|
memset(serial, 0, sizeof(serial));
|
|
griffin_cmd(GRIFFIN_CMD_GET_ASCII_SERIAL, NULL, 0, 14);
|
|
memcpy(serial, cta_res + 2, 12);
|
|
|
|
griffin_cmd(GRIFFIN_CMD_GET_CAID, NULL, 0, 4);
|
|
rdr->caid = (cta_res[2] << 8) | cta_res[3];
|
|
|
|
griffin_cmd(GRIFFIN_CMD_GET_CARD_ADDRESS, NULL, 0, 48);
|
|
|
|
for(i = 1 ; i < CS_MAXPROV; i++)
|
|
{
|
|
if(3 + (i * 16) + 4 > cta_lr)
|
|
{
|
|
break;
|
|
}
|
|
memcpy(rdr->sa[i - 1], cta_res + 3 + (i * 16), 4);
|
|
}
|
|
|
|
// Unknown commands
|
|
griffin_cmd(0x22, NULL, 0, 2);
|
|
griffin_cmd(0x10, NULL, 0, 2);
|
|
griffin_cmd(0x14, NULL, 0, 2);
|
|
//griffin_cmd(0x2a, NULL, 0, 2);
|
|
//griffin_cmd(0x30, NULL, 0, 2);
|
|
|
|
for(i = 0 ; i < CS_MAXPROV; i++)
|
|
{
|
|
if(array_has_nonzero_byte(rdr->sa[i], 4))
|
|
{
|
|
rdr_log_sensitive(rdr, "CAID: 0x%04X, Serial: {%s}, HexSerial: {%02X %02X %02X %02X} Addr: {%02X %02X %02X %02X}",
|
|
rdr->caid, serial, rdr->hexserial[0], rdr->hexserial[1], rdr->hexserial[2], rdr->hexserial[3],
|
|
rdr->sa[i][0], rdr->sa[i][1], rdr->sa[i][2], rdr->sa[i][3]);
|
|
}
|
|
}
|
|
|
|
rdr_log(rdr, "Ready for requests.");
|
|
return OK;
|
|
}
|
|
|
|
static int32_t griffin_do_ecm(struct s_reader *rdr, const ECM_REQUEST *er, struct s_ecm_answer *ea)
|
|
{
|
|
def_resp
|
|
griffin_cmd(GRIFFIN_CMD_SEND_ECM, er->ecm, er->ecm[2] + 3, 24);
|
|
memcpy(ea->cw, cta_res + 8, 16);
|
|
return OK;
|
|
}
|
|
|
|
static int32_t griffin_get_emm_type(EMM_PACKET *ep, struct s_reader *rdr)
|
|
{
|
|
memcpy(ep->hexserial, ep->emm + 3, 4);
|
|
switch(ep->emm[0])
|
|
{
|
|
case 0x82:
|
|
case 0x83:
|
|
if(memcmp(ep->hexserial, rdr->sa[0], 4) == 0)
|
|
{
|
|
if(DEBUG)
|
|
{
|
|
rdr_log_sensitive(rdr, "SHARED EMM TYPE:%02X SA:{%02X %02X %02X %02X}",
|
|
ep->emm[0], ep->emm[3], ep->emm[4], ep->emm[5], ep->emm[6]);
|
|
}
|
|
ep->type = SHARED;
|
|
}
|
|
if(memcmp(ep->hexserial, rdr->sa[1], 4) == 0)
|
|
{
|
|
if(DEBUG)
|
|
{
|
|
rdr_log_sensitive(rdr, "UNIQUE EMM TYPE:%02X SA:{%02X %02X %02X %02X}",
|
|
ep->emm[0], ep->emm[3], ep->emm[4], ep->emm[5], ep->emm[6]);
|
|
}
|
|
ep->type = UNIQUE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ep->type = UNKNOWN;
|
|
rdr_log_dbg(rdr, D_EMM, "UNKNOWN EMM TYPE:%02X SA:%02X %02X %02X %02X",
|
|
ep->emm[0], ep->emm[3], ep->emm[4], ep->emm[5], ep->emm[6]);
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
static int32_t griffin_do_emm(struct s_reader *rdr, EMM_PACKET *ep)
|
|
{
|
|
def_resp
|
|
griffin_cmd(GRIFFIN_CMD_SEND_EMM, ep->emm, SCT_LEN(ep->emm), 2);
|
|
return OK;
|
|
}
|
|
|
|
static int32_t griffin_get_emm_filter(struct s_reader *rdr, struct s_csystem_emm_filter **emm_filters, unsigned int *filter_count)
|
|
{
|
|
if(*emm_filters == NULL)
|
|
{
|
|
const unsigned int max_filter_count = 4;
|
|
if(!cs_malloc(emm_filters, max_filter_count * sizeof(struct s_csystem_emm_filter)))
|
|
{
|
|
return ERROR;
|
|
}
|
|
|
|
struct s_csystem_emm_filter *filters = *emm_filters;
|
|
*filter_count = 0;
|
|
|
|
int32_t idx = 0;
|
|
|
|
filters[idx].type = EMM_SHARED;
|
|
filters[idx].enabled = 1;
|
|
filters[idx].filter[0] = 0x82;
|
|
filters[idx].filter[1] = rdr->sa[0][0];
|
|
filters[idx].filter[2] = rdr->sa[0][1];
|
|
filters[idx].filter[3] = rdr->sa[0][2];
|
|
filters[idx].filter[4] = rdr->sa[0][3];
|
|
filters[idx].mask[0] = 0xFF;
|
|
filters[idx].mask[1] = 0xFF;
|
|
filters[idx].mask[2] = 0xFF;
|
|
filters[idx].mask[3] = 0xFF;
|
|
filters[idx].mask[4] = 0xFF;
|
|
idx++;
|
|
|
|
filters[idx].type = EMM_SHARED;
|
|
filters[idx].enabled = 1;
|
|
filters[idx].filter[0] = 0x82;
|
|
filters[idx].filter[1] = rdr->sa[1][0];
|
|
filters[idx].filter[2] = rdr->sa[1][1];
|
|
filters[idx].filter[3] = rdr->sa[1][2];
|
|
filters[idx].filter[4] = rdr->sa[1][3];
|
|
filters[idx].mask[0] = 0xFF;
|
|
filters[idx].mask[1] = 0xFF;
|
|
filters[idx].mask[2] = 0xFF;
|
|
filters[idx].mask[3] = 0xFF;
|
|
filters[idx].mask[4] = 0xFF;
|
|
idx++;
|
|
|
|
filters[idx].type = EMM_UNIQUE;
|
|
filters[idx].enabled = 1;
|
|
filters[idx].filter[0] = 0x83;
|
|
filters[idx].filter[1] = rdr->sa[0][0];
|
|
filters[idx].filter[2] = rdr->sa[0][1];
|
|
filters[idx].filter[3] = rdr->sa[0][2];
|
|
filters[idx].filter[4] = rdr->sa[0][3];
|
|
filters[idx].mask[0] = 0xF0;
|
|
filters[idx].mask[1] = 0xFF;
|
|
filters[idx].mask[2] = 0xFF;
|
|
filters[idx].mask[3] = 0xFF;
|
|
filters[idx].mask[4] = 0xFF;
|
|
idx++;
|
|
|
|
filters[idx].type = EMM_UNIQUE;
|
|
filters[idx].enabled = 1;
|
|
filters[idx].filter[0] = 0x83;
|
|
filters[idx].filter[1] = rdr->sa[1][0];
|
|
filters[idx].filter[2] = rdr->sa[1][1];
|
|
filters[idx].filter[3] = rdr->sa[1][2];
|
|
filters[idx].filter[4] = rdr->sa[1][3];
|
|
filters[idx].mask[0] = 0xF0;
|
|
filters[idx].mask[1] = 0xFF;
|
|
filters[idx].mask[2] = 0xFF;
|
|
filters[idx].mask[3] = 0xFF;
|
|
filters[idx].mask[4] = 0xFF;
|
|
idx++;
|
|
|
|
*filter_count = idx;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int32_t griffin_card_info(struct s_reader *rdr)
|
|
{
|
|
def_resp
|
|
int i, r = 0;
|
|
rdr_log(rdr, "Reading subscription info.");
|
|
|
|
griffin_cmd(GRIFFIN_CMD_SUBSCRIPTION_INFO, NULL, 0, 16);
|
|
|
|
if(cta_res[0] == 0x0b) // Old cards
|
|
{
|
|
for(i = 0; i < cta_lr - 8; i += 9)
|
|
{
|
|
rdr_log(rdr, " Subscription stream %d - %c%c%c%c%c%c",
|
|
r++, cta_res[i + 2], cta_res[i + 3], cta_res[i + 4],
|
|
cta_res[i + 5], cta_res[i + 6], cta_res[i + 7]);
|
|
}
|
|
}
|
|
else if(cta_res[0] == 0x1b) // Newer cards
|
|
{
|
|
for(i = 0; i < cta_lr; i += 4)
|
|
{
|
|
rdr_log(rdr, " Subscription stream #%02d - 0x%04x",
|
|
r++, b2i(2, cta_res + i + 2));
|
|
}
|
|
}
|
|
|
|
rdr_log(rdr, "End subscription info.");
|
|
return OK;
|
|
}
|
|
|
|
const struct s_cardsystem reader_griffin =
|
|
{
|
|
.desc = "griffin",
|
|
.caids = (uint16_t[]){ 0x5501, 0x5502, 0x5504, 0x5506, 0x5508, 0x5509, 0x550E, 0x5511, 0x551A, 0 },
|
|
.do_emm = griffin_do_emm,
|
|
.do_ecm = griffin_do_ecm,
|
|
.card_info = griffin_card_info,
|
|
.card_init = griffin_card_init,
|
|
.get_emm_type = griffin_get_emm_type,
|
|
.get_emm_filter = griffin_get_emm_filter,
|
|
};
|
|
|
|
#endif
|