#include "globals.h"

#if defined(HAVE_DVBAPI) && defined(WITH_AZBOX)

#include "extapi/openxcas/openxcas_api.h"

#include "extapi/openxcas/openxcas_message.h"

#define DVBAPI_LOG_PREFIX 1

#include "module-dvbapi.h"

#include "module-dvbapi-azbox.h"

#include "oscam-client.h"

#include "oscam-ecm.h"

#include "oscam-reader.h"

#include "oscam-string.h"

#include "oscam-time.h"

#define LOG_PREFIX "openxcas: "

#define LOG_PREFIX_MSG "openxcasmsg: "

// These variables are declared in module-dvbapi.c

extern void * dvbapi_client;

extern DEMUXTYPE demux[MAX_DEMUX];

// These are used in module-dvbapi.c

int32_t openxcas_provid;

uint16_t openxcas_sid, openxcas_caid, openxcas_ecm_pid;

static unsigned char openxcas_cw[16];

static int32_t openxcas_seq, openxcas_filter_idx, openxcas_stream_id, openxcas_cipher_idx, openxcas_busy = 0;

static uint16_t openxcas_video_pid, openxcas_audio_pid, openxcas_data_pid;

void azbox_openxcas_ecm_callback(int32_t stream_id, uint32_t UNUSED(seq), int32_t cipher_index, uint32_t UNUSED(caid), unsigned char *ecm_data, int32_t l, uint16_t pid) {

cs_debug_mask(D_DVBAPI, LOG_PREFIX "ecm callback received");

openxcas_stream_id = stream_id;

//openxcas_seq = seq;

//openxcas_caid = caid;

openxcas_ecm_pid = pid;

openxcas_busy = 1;

ECM_REQUEST *er;

if (!(er=get_ecmtask()))

return;

er->srvid = openxcas_sid;

er->caid = openxcas_caid;

er->pid = openxcas_ecm_pid;

er->prid = openxcas_provid;

er->ecmlen = l;

memcpy(er->ecm, ecm_data, er->ecmlen);

request_cw(dvbapi_client, er, 0, 0);

//openxcas_stop_filter(openxcas_stream_id, OPENXCAS_FILTER_ECM);

//openxcas_remove_filter(openxcas_stream_id, OPENXCAS_FILTER_ECM);

openxcas_cipher_idx = cipher_index;

struct timeb tp;

cs_ftime(&tp);

tp.time+=500;

}

void azbox_openxcas_ex_callback(int32_t stream_id, uint32_t seq, int32_t idx, uint32_t pid, unsigned char *ecm_data, int32_t l) {

cs_debug_mask(D_DVBAPI, LOG_PREFIX "ex callback received");

openxcas_stream_id = stream_id;

openxcas_ecm_pid = pid;

openxcas_cipher_idx = idx; // is this really cipher_idx?

ECM_REQUEST *er;

if (!(er=get_ecmtask()))

return;

er->srvid = openxcas_sid;

er->caid = openxcas_caid;

er->pid = openxcas_ecm_pid;

er->prid = openxcas_provid;

er->ecmlen = l;

memcpy(er->ecm, ecm_data, er->ecmlen);

request_cw(dvbapi_client, er, 0, 0);

if (openxcas_stop_filter_ex(stream_id, seq, openxcas_filter_idx) < 0)

cs_log(LOG_PREFIX "unable to stop ex filter");

else

cs_debug_mask(D_DVBAPI, LOG_PREFIX "ex filter stopped");

unsigned char mask[12];

unsigned char comp[12];

memset(&mask, 0x00, sizeof(mask));

memset(&comp, 0x00, sizeof(comp));

mask[0] = 0xff;

comp[0] = ecm_data[0] ^ 1;

if ((openxcas_filter_idx = openxcas_start_filter_ex(stream_id, seq, openxcas_ecm_pid, mask, comp, (void *)azbox_openxcas_ex_callback)) < 0)

cs_log(LOG_PREFIX "unable to start ex filter");

else

cs_debug_mask(D_DVBAPI, LOG_PREFIX "ex filter started, pid = %x", openxcas_ecm_pid);

}

void * azbox_main_thread(void *cli) {

struct s_client * client = (struct s_client *) cli;

client->thread=pthread_self();

pthread_setspecific(getclient, cli);

dvbapi_client=cli;

struct s_auth *account;

int32_t ok = 0;

for (account = cfg.account; account; account=account->next) {

if ((ok = streq(cfg.dvbapi_usr, account->usr)))

break;

}

cs_auth_client(client, ok ? account : (struct s_auth *)(-1), "dvbapi");

dvbapi_read_priority();

openxcas_msg_t msg;

int32_t ret;

while ((ret = openxcas_get_message(&msg, 0)) >= 0) {

cs_sleepms(10);

if (ret) {

openxcas_stream_id = msg.stream_id;

openxcas_seq = msg.sequence;

switch(msg.cmd) {

case OPENXCAS_SELECT_CHANNEL:

cs_debug_mask(D_DVBAPI, LOG_PREFIX_MSG "OPENXCAS_SELECT_CHANNEL");

// parse channel info

struct stOpenXCASChannel chan;

memcpy(&chan, msg.buf, msg.buf_len);

cs_log(LOG_PREFIX "channel change: sid = %x, vpid = %x. apid = %x", chan.service_id, chan.v_pid, chan.a_pid);

openxcas_video_pid = chan.v_pid;

openxcas_audio_pid = chan.a_pid;

openxcas_data_pid = chan.d_pid;

break;

case OPENXCAS_START_PMT_ECM:

cs_debug_mask(D_DVBAPI, LOG_PREFIX_MSG "OPENXCAS_START_PMT_ECM");

// parse pmt

uchar *dest;

if (!cs_malloc(&dest, msg.buf_len + 7 - 12 - 4))

break;

memcpy(dest, "\x00\xFF\xFF\x00\x00\x13\x00", 7);

dest[1] = msg.buf[3];

dest[2] = msg.buf[4];

dest[5] = msg.buf[11]+1;

memcpy(dest + 7, msg.buf + 12, msg.buf_len - 12 - 4);

dvbapi_parse_capmt(dest, 7 + msg.buf_len - 12 - 4, -1, NULL);

free(dest);

unsigned char mask[12];

unsigned char comp[12];

memset(&mask, 0x00, sizeof(mask));

memset(&comp, 0x00, sizeof(comp));

mask[0] = 0xfe;

comp[0] = 0x80;

if ((ret = openxcas_add_filter(msg.stream_id, OPENXCAS_FILTER_ECM, 0, 0xffff, openxcas_ecm_pid, mask, comp, (void *)azbox_openxcas_ecm_callback)) < 0)

cs_log(LOG_PREFIX "unable to add ecm filter");

else

cs_debug_mask(D_DVBAPI, LOG_PREFIX "ecm filter added, pid = %x, caid = %x", openxcas_ecm_pid, 0);

if (openxcas_start_filter(msg.stream_id, msg.sequence, OPENXCAS_FILTER_ECM) < 0)

cs_log(LOG_PREFIX "unable to start ecm filter");

else

cs_debug_mask(D_DVBAPI, LOG_PREFIX "ecm filter started");

if (!openxcas_create_cipher_ex(msg.stream_id, openxcas_seq, 0, openxcas_ecm_pid, openxcas_video_pid, 0xffff, openxcas_audio_pid, 0xffff, 0xffff, 0xffff))

cs_log(LOG_PREFIX "failed to create cipher ex");

else

cs_debug_mask(D_DVBAPI, LOG_PREFIX "cipher created");

break;

case OPENXCAS_STOP_PMT_ECM:

cs_debug_mask(D_DVBAPI, LOG_PREFIX_MSG "OPENXCAS_STOP_PMT_ECM");

openxcas_stop_filter(msg.stream_id, OPENXCAS_FILTER_ECM);

openxcas_remove_filter(msg.stream_id, OPENXCAS_FILTER_ECM);

openxcas_stop_filter_ex(msg.stream_id, msg.sequence, openxcas_filter_idx);

openxcas_destory_cipher_ex(msg.stream_id, msg.sequence);

memset(&demux, 0, sizeof(demux));

break;

case OPENXCAS_ECM_CALLBACK:

cs_debug_mask(D_DVBAPI, LOG_PREFIX_MSG "OPENXCAS_ECM_CALLBACK");

struct stOpenXCAS_Data data;

memcpy(&data, msg.buf, msg.buf_len);

if (!openxcas_busy)

openxcas_filter_callback(msg.stream_id, msg.sequence, OPENXCAS_FILTER_ECM, &data);

break;

case OPENXCAS_PID_FILTER_CALLBACK:

cs_debug_mask(D_DVBAPI, LOG_PREFIX_MSG "OPENXCAS_PID_FILTER_CALLBACK");

openxcas_filter_callback_ex(msg.stream_id, msg.sequence, (struct stOpenXCAS_Data *)msg.buf);

break;

case OPENXCAS_QUIT:

cs_debug_mask(D_DVBAPI, LOG_PREFIX_MSG "OPENXCAS_QUIT");

openxcas_close();

cs_log(LOG_PREFIX "exited");

return NULL;

break;

case OPENXCAS_UKNOWN_MSG:

default:

cs_debug_mask(D_DVBAPI, LOG_PREFIX_MSG "OPENXCAS_UKNOWN_MSG (%d)", msg.cmd);

//cs_ddump_mask(D_DVBAPI, &msg, sizeof(msg), "msg dump:");

break;

}

}

}

cs_log(LOG_PREFIX "invalid message");

return NULL;

}

void azbox_send_dcw(struct s_client *client, ECM_REQUEST *er) {

cs_debug_mask(D_DVBAPI, LOG_PREFIX "send_dcw");

FILE *ecmtxt;

if ((ecmtxt = fopen(ECMINFO_FILE, "w"))) {

char tmp[25];

if(er->rc <= E_CACHEEX) {

fprintf(ecmtxt, "caid: 0x%04X\npid: 0x%04X\nprov: 0x%06X\n", er->caid, er->pid, (uint) er->prid);

fprintf(ecmtxt, "reader: %s\n", er->selected_reader->label);

if (is_cascading_reader(er->selected_reader))

fprintf(ecmtxt, "from: %s\n", er->selected_reader->device);

else

fprintf(ecmtxt, "from: local\n");

fprintf(ecmtxt, "protocol: %s\n", reader_get_type_desc(er->selected_reader, 1));

fprintf(ecmtxt, "hops: %d\n", er->selected_reader->currenthops);

fprintf(ecmtxt, "ecm time: %.3f\n", (float) client->cwlastresptime/1000);

fprintf(ecmtxt, "cw0: %s\n", cs_hexdump(1,demux[0].lastcw[0],8, tmp, sizeof(tmp)));

fprintf(ecmtxt, "cw1: %s\n", cs_hexdump(1,demux[0].lastcw[1],8, tmp, sizeof(tmp)));

fclose(ecmtxt);

ecmtxt = NULL;

} else {

fprintf(ecmtxt, "ECM information not found\n");

fclose(ecmtxt);

}

}

openxcas_busy = 0;

int32_t i;

for (i=0; i < MAX_DEMUX; i++) {

if (er->rc >= E_NOTFOUND) {

cs_debug_mask(D_DVBAPI, "cw not found");

if (demux[i].pidindex==-1)

dvbapi_try_next_caid(i);

openxcas_stop_filter(openxcas_stream_id, OPENXCAS_FILTER_ECM);

openxcas_remove_filter(openxcas_stream_id, OPENXCAS_FILTER_ECM);

unsigned char mask[12];

unsigned char comp[12];

memset(&mask, 0x00, sizeof(mask));

memset(&comp, 0x00, sizeof(comp));

mask[0] = 0xfe;

comp[0] = 0x80;

if (openxcas_add_filter(openxcas_stream_id, OPENXCAS_FILTER_ECM, 0, 0xffff, openxcas_ecm_pid, mask, comp, (void *)azbox_openxcas_ecm_callback) < 0) {

cs_log(LOG_PREFIX "unable to add ecm filter (0)");

if (openxcas_add_filter(openxcas_stream_id, OPENXCAS_FILTER_ECM, openxcas_caid, 0xffff, openxcas_ecm_pid, mask, comp, (void *)azbox_openxcas_ecm_callback) < 0)

cs_log(LOG_PREFIX "unable to add ecm filter (%04x)", openxcas_caid);

else

cs_debug_mask(D_DVBAPI, LOG_PREFIX "ecm filter added, pid = %x, caid = %x", openxcas_ecm_pid, openxcas_caid);

} else

cs_debug_mask(D_DVBAPI, LOG_PREFIX "ecm filter added, pid = %x, caid = %x", openxcas_ecm_pid, 0);

if (openxcas_start_filter(openxcas_stream_id, openxcas_seq, OPENXCAS_FILTER_ECM) < 0)

cs_log(LOG_PREFIX "unable to start ecm filter");

else

cs_debug_mask(D_DVBAPI, LOG_PREFIX "ecm filter started");

return;

}

}

unsigned char nullcw[8];

memset(nullcw, 0, 8);

int32_t n;

for (n=0;n<2;n++) {

if (memcmp(er->cw + (n * 8), demux[0].lastcw[n], 8) && memcmp(er->cw + (n * 8), nullcw, 8)) {

memcpy(demux[0].lastcw[n], er->cw + (n * 8), 8);

memcpy(openxcas_cw + (n * 8), er->cw + (n * 8), 8);

}

}

if (openxcas_set_key(openxcas_stream_id, openxcas_seq, 0, openxcas_cipher_idx, openxcas_cw, openxcas_cw + 8) != 1)

cs_log(LOG_PREFIX "set cw failed");

else

cs_ddump_mask(D_DVBAPI, openxcas_cw, 16, LOG_PREFIX "write cws to descrambler");

}

#ifdef WITH_CARDREADER

#define __openxcas_open openxcas_open_with_smartcard

#else

#define __openxcas_open openxcas_open

#endif

void azbox_init(void) {

openxcas_debug_message_onoff(1); // debug

if (__openxcas_open("oscamCAS") < 0)

cs_log(LOG_PREFIX "could not init");

}

void azbox_close(void) {

if (openxcas_close() < 0)

cs_log(LOG_PREFIX "could not close");

}

#endif