Ignore:
Timestamp:
Jan 18, 2019, 11:36:20 PM (15 months ago)
Author:
Gorgone Impertinence
Message:

big cleanup pack 4

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/reader-videoguard1.c

    r10607 r11478  
    44#include "reader-videoguard-common.h"
    55
    6 
    7 static int32_t vg1_do_cmd(struct s_reader *reader, const unsigned char *ins, const unsigned char *txbuff, unsigned char *rxbuff, unsigned char *cta_res)
     6static int32_t vg1_do_cmd(struct s_reader *reader, const uint8_t *ins, const uint8_t *txbuff, uint8_t *rxbuff, uint8_t *cta_res)
    87{
    98    uint16_t cta_lr;
    10     unsigned char ins2[5];
     9    uint8_t ins2[5];
    1110    memcpy(ins2, ins, 5);
    12     unsigned char len = 0;
     11    uint8_t len = 0;
    1312    len = ins2[4];
    1413
    15 
    16 
    1714    if(txbuff == NULL)
    1815    {
     
    2118            return -1;
    2219        }
     20
    2321        if(rxbuff != NULL)
    2422        {
     
    3028    else
    3129    {
    32         if(!write_cmd_vg(ins2, (uchar *) txbuff) || !status_ok(cta_res))
     30        if(!write_cmd_vg(ins2, (uint8_t *)txbuff) || !status_ok(cta_res))
    3331        {
    3432            return -2;
    3533        }
     34
    3635        if(rxbuff != NULL)
    3736        {
     
    4948    struct videoguard_data *csystem_data = reader->csystem_data;
    5049    def_resp;
    51     //  const unsigned char ins2a[5] = {  0x48, 0x2a, 0x00, 0x00, 0x00 };
     50    //const uint8_t ins2a[5] = { 0x48, 0x2a, 0x00, 0x00, 0x00 };
    5251    int32_t l;
    5352
    54     //  return; // Not working at present so just do nothing
    55 
    56     //  l = vg1_do_cmd(reader, ins2a, NULL, NULL, cta_res);
    57     //  if (l < 0 || !status_ok(cta_res + l))
    58     //  {
    59     //    return;
    60     //  }
    61     unsigned char ins76[5] = { 0x48, 0x76, 0x00, 0x00, 0x00 };
     53    //return; // Not working at present so just do nothing
     54
     55    //l = vg1_do_cmd(reader, ins2a, NULL, NULL, cta_res);
     56    //if (l < 0 || !status_ok(cta_res + l))
     57    //{
     58    //  return;
     59    //}
     60
     61    uint8_t ins76[5] = { 0x48, 0x76, 0x00, 0x00, 0x00 };
    6262    ins76[3] = 0x7f;
    6363    ins76[4] = 2;
     64
    6465    if(!write_cmd_vg(ins76, NULL) || !status_ok(cta_res + 2))
    6566    {
    6667        return;
    6768    }
     69
    6870    ins76[3] = 0;
    6971    ins76[4] = 0x0a;
     
    7173    int32_t i;
    7274
    73     cs_clear_entitlement(reader); //reset the entitlements
     75    cs_clear_entitlement(reader); // reset the entitlements
    7476
    7577    for(i = 0; i < num; i++)
     
    7779        ins76[2] = i;
    7880        l = vg1_do_cmd(reader, ins76, NULL, NULL, cta_res);
     81
    7982        if(l < 0 || !status_ok(cta_res + l))
    8083        {
    8184            return;
    8285        }
     86
    8387        if(cta_res[2] == 0 && cta_res[3] == 0)
    8488        {
    8589            break;
    8690        }
     91
    8792        uint16_t tier_id = (cta_res[2] << 8) | cta_res[3];
    8893        // add entitlements to list
     
    9297        char tiername[83];
    9398        cs_add_entitlement(reader, reader->caid, b2ll(4, reader->prid[0]), tier_id, 0, 0, mktime(&timeinfo), 4, 1);
    94         rdr_log(reader, "tier: %04x, expiry date: %04d/%02d/%02d-%02d:%02d:%02d %s", tier_id, timeinfo.tm_year + 1900, timeinfo.tm_mon + 1, timeinfo.tm_mday, timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec, get_tiername(tier_id, reader->caid, tiername));
     99        rdr_log(reader, "tier: %04x, expiry date: %04d/%02d/%02d-%02d:%02d:%02d %s",
     100                tier_id, timeinfo.tm_year + 1900, timeinfo.tm_mon + 1, timeinfo.tm_mday, timeinfo.tm_hour,
     101                timeinfo.tm_min, timeinfo.tm_sec, get_tiername(tier_id, reader->caid, tiername));
    95102    }
    96103}
     
    98105static int32_t videoguard1_card_init(struct s_reader *reader, ATR *newatr)
    99106{
    100 
    101107    get_hist;
    102108    /* 40 B0 09 4A 50 01 4E 5A */
     
    110116
    111117    if(!cs_malloc(&reader->csystem_data, sizeof(struct videoguard_data)))
    112         { return ERROR; }
     118    {
     119        return ERROR;
     120    }
    113121    struct videoguard_data *csystem_data = reader->csystem_data;
    114122
     
    121129           or unknown ATR and not forced to NDS1
    122130           or known NDS1 ATR and forced to another NDS version
    123            ... probably not NDS1 */
     131           ...probably not NDS1 */
    124132        return ERROR;
    125133    }
     
    138146
    139147    int32_t l = 0;
    140     unsigned char buff[256];
     148    uint8_t buff[256];
    141149    memset(buff, 0, sizeof(buff));
    142150
     
    145153       not be encrypted if it is an NDS1 card */
    146154
    147     static const unsigned char ins36[5] = { 0x48, 0x36, 0x00, 0x00, 0x90 };
    148     unsigned char boxID[4];
     155    static const uint8_t ins36[5] = { 0x48, 0x36, 0x00, 0x00, 0x90 };
     156    uint8_t boxID[4];
    149157    int32_t boxidOK = 0;
    150158    l = vg1_do_cmd(reader, ins36, NULL, buff, cta_res);
     159
    151160    if(buff[7] > 0x0F)
    152161    {
     
    161170        while(i < l)
    162171        {
    163             if(!gotUA && buff[i] < 0xF0)      /* then we guess that the next 4 bytes is the UA */
     172            if(!gotUA && buff[i] < 0xF0) /* then we guess that the next 4 bytes is the UA */
    164173            {
    165174                gotUA = 1;
     
    168177            else
    169178            {
    170                 switch(buff[i])     /* object length vary depending on type */
     179                switch(buff[i]) /* object length vary depending on type */
    171180                {
    172                 case 0x00:      /* padding */
    173                 {
    174                     i += 1;
    175                     break;
    176                 }
    177                 case 0xEF:      /* card status */
    178                 {
    179                     i += 3;
    180                     break;
    181                 }
    182                 case 0xD1:
    183                 {
    184                     i += 4;
    185                     break;
    186                 }
    187                 case 0xDF:      /* next server contact */
    188                 {
    189                     i += 5;
    190                     break;
    191                 }
    192                 case 0xF3:      /* boxID */
    193                 {
    194                     memcpy(&boxID, &buff[i + 1], sizeof(boxID));
    195                     boxidOK = 1;
    196                     i += 5;
    197                     break;
    198                 }
    199                 case 0xF6:
    200                 {
    201                     i += 6;
    202                     break;
    203                 }
    204                 case 0xFC:      /* No idea seems to with with NDS1 */
    205                 {
    206                     i += 14;
    207                     break;
    208                 }
    209                 case 0x01:      /* date & time */
    210                 {
    211                     i += 7;
    212                     break;
    213                 }
    214                 case 0xFA:
    215                 {
    216                     i += 9;
    217                     break;
    218                 }
    219                 case 0x5E:
    220                 case 0x67:      /* signature */
    221                 case 0xDE:
    222                 case 0xE2:
    223                 case 0xE9:      /* tier dates */
    224                 case 0xF8:      /* Old PPV Event Record */
    225                 case 0xFD:
    226                 {
    227                     i += buff[i + 1] + 2;   /* skip length + 2 bytes (type and length) */
    228                     break;
    229                 }
    230                 default:        /* default to assume a length byte */
    231                 {
    232                     rdr_log(reader, "class48 ins36: returned unknown type=0x%02X - parsing may fail", buff[i]);
    233                     i += buff[i + 1] + 2;
    234                 }
     181                    case 0x00: /* padding */
     182                    {
     183                        i += 1;
     184                        break;
     185                    }
     186
     187                    case 0xEF: /* card status */
     188                    {
     189                        i += 3;
     190                        break;
     191                    }
     192
     193                    case 0xD1:
     194                    {
     195                        i += 4;
     196                        break;
     197                    }
     198
     199                    case 0xDF: /* next server contact */
     200                    {
     201                        i += 5;
     202                        break;
     203                    }
     204
     205                    case 0xF3: /* boxID */
     206                    {
     207                        memcpy(&boxID, &buff[i + 1], sizeof(boxID));
     208                        boxidOK = 1;
     209                        i += 5;
     210                        break;
     211                    }
     212
     213                    case 0xF6:
     214                    {
     215                        i += 6;
     216                        break;
     217                    }
     218
     219                    case 0xFC: /* No idea seems to with with NDS1 */
     220                    {
     221                        i += 14;
     222                        break;
     223                    }
     224
     225                    case 0x01: /* date & time */
     226                    {
     227                        i += 7;
     228                        break;
     229                    }
     230
     231                    case 0xFA:
     232                    {
     233                        i += 9;
     234                        break;
     235                    }
     236
     237                    case 0x5E:
     238                    case 0x67: /* signature */
     239                    case 0xDE:
     240                    case 0xE2:
     241                    case 0xE9: /* tier dates */
     242                    case 0xF8: /* Old PPV Event Record */
     243                    case 0xFD:
     244                    {
     245                        i += buff[i + 1] + 2; /* skip length + 2 bytes (type and length) */
     246                        break;
     247                    }
     248
     249                    default: /* default to assume a length byte */
     250                    {
     251                        rdr_log(reader, "class48 ins36: returned unknown type=0x%02X - parsing may fail", buff[i]);
     252                        i += buff[i + 1] + 2;
     253                    }
    235254                }
    236255            }
     
    258277
    259278    // Send BoxID
    260     static const unsigned char ins4C[5] = { 0x48, 0x4C, 0x00, 0x00, 0x09 };
    261     unsigned char payload4C[9] = { 0, 0, 0, 0, 3, 0, 0, 0, 4 };
     279    static const uint8_t ins4C[5] = { 0x48, 0x4C, 0x00, 0x00, 0x09 };
     280    uint8_t payload4C[9] = { 0, 0, 0, 0, 3, 0, 0, 0, 4 };
    262281    memcpy(payload4C, boxID, 4);
     282
    263283    if(!write_cmd_vg(ins4C, payload4C) || !status_ok(cta_res + l))
    264284    {
     
    267287    }
    268288
    269     static const unsigned char ins58[5] = { 0x48, 0x58, 0x00, 0x00, 0x17 };
     289    static const uint8_t ins58[5] = { 0x48, 0x58, 0x00, 0x00, 0x17 };
    270290    l = vg1_do_cmd(reader, ins58, NULL, buff, cta_res);
    271291    if(l < 0)
     
    278298    memcpy(reader->hexserial + 2, cta_res + 1, 4);
    279299    memcpy(reader->sa, cta_res + 1, 3);
    280     //  reader->caid = cta_res[24] * 0x100 + cta_res[25];
     300    //reader->caid = cta_res[24] * 0x100 + cta_res[25];
    281301    /* Force caid until can figure out how to get it */
    282302    reader->caid = 0x9 * 0x100 + 0x69;
     
    296316static int32_t videoguard1_do_ecm(struct s_reader *reader, const ECM_REQUEST *er, struct s_ecm_answer *ea)
    297317{
    298     unsigned char cta_res[CTA_RES_LEN];
    299     unsigned char ins40[5] = { 0x48, 0x40, 0x00, 0x80, 0xFF };
    300     static const unsigned char ins54[5] = { 0x48, 0x54, 0x00, 0x00, 0x0D };
     318    uint8_t cta_res[CTA_RES_LEN];
     319    uint8_t ins40[5] = { 0x48, 0x40, 0x00, 0x80, 0xFF };
     320    static const uint8_t ins54[5] = { 0x48, 0x54, 0x00, 0x00, 0x0D };
    301321    int32_t posECMpart2 = er->ecm[6] + 7;
    302322    int32_t lenECMpart2 = er->ecm[posECMpart2];
    303     unsigned char tbuff[264];
    304     unsigned char rbuff[264];
     323    uint8_t tbuff[264];
     324    uint8_t rbuff[264];
    305325    memcpy(&tbuff[0], &(er->ecm[posECMpart2 + 1]), lenECMpart2);
    306326    ins40[4] = lenECMpart2;
    307327    int32_t l;
    308328    l = vg1_do_cmd(reader, ins40, tbuff, NULL, cta_res);
     329
    309330    if(l > 0 && status_ok(cta_res))
    310331    {
     
    312333        if(l > 0 && status_ok(cta_res + l))
    313334        {
    314             if(!cw_is_valid(rbuff + 5))   //sky cards report 90 00 = ok but send cw = 00 when channel not subscribed
     335            if(!cw_is_valid(rbuff + 5)) // sky cards report 90 00 = ok but send cw = 00 when channel not subscribed
    315336            {
    316337                rdr_log(reader, "class48 ins54 status 90 00 but cw=00 -> channel not subscribed");
Note: See TracChangeset for help on using the changeset viewer.