void ClientStream::socketReadyRead()
{
QByteArray buffer = d->socket->readAll();
#if LIBOSCAR_DEBUG
QByteArray cs(buffer.data(), buffer.size()+1);
kDebug(OSCAR_RAW_DEBUG) << "recv: " << buffer.size() << "bytes";
cs_dump( buffer );
#endif
d->client.addIncomingData( buffer );
}
void ClientStream::bs_readyRead()
{
QByteArray a;
//qDebug( "size of storage for incoming data is %i bytes.", a.size() );
a = d->bs->read();
#if LIBOSCAR_DEBUG
QCString cs(a.data(), a.size()+1);
kdDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "recv: " << a.size() << "bytes" << endl;
cs_dump( a );
#endif
d->client.addIncomingData(a);
}
static int32_t viaccess_do_emm(struct s_reader * reader, EMM_PACKET *ep)
{
def_resp;
static const unsigned char insa4[] = { 0xca,0xa4,0x04,0x00,0x03 }; // set provider id
unsigned char insf0[] = { 0xca,0xf0,0x00,0x01,0x22 }; // set adf
unsigned char insf4[] = { 0xca,0xf4,0x00,0x01,0x00 }; // set adf, encrypted
unsigned char ins18[] = { 0xca,0x18,0x01,0x01,0x00 }; // set subscription
unsigned char ins1c[] = { 0xca,0x1c,0x01,0x01,0x00 }; // set subscription, encrypted
static const unsigned char insc8[] = { 0xca,0xc8,0x00,0x00,0x02 }; // read extended status
// static const unsigned char insc8Data[] = { 0x00,0x00 }; // data for read extended status
int32_t emmdatastart=7;
if (ep->type == UNIQUE) emmdatastart++;
int32_t emmLen=SCT_LEN(ep->emm)-emmdatastart;
int32_t rc=0;
///cs_dump(ep->emm, emmLen+emmdatastart, "RECEIVED EMM VIACCESS");
int32_t emmUpToEnd;
uchar *emmParsed = ep->emm+emmdatastart;
int32_t provider_ok = 0;
uint32_t emm_provid;
uchar keynr = 0;
int32_t ins18Len = 0;
uchar ins18Data[512];
uchar insData[512];
uchar *nano81Data = 0;
uchar *nano91Data = 0;
uchar *nano92Data = 0;
uchar *nano9EData = 0;
uchar *nanoF0Data = 0;
for (emmUpToEnd=emmLen; (emmParsed[1] != 0) && (emmUpToEnd > 0); emmUpToEnd -= (2 + emmParsed[1]), emmParsed += (2 + emmParsed[1])) {
///cs_dump (emmParsed, emmParsed[1] + 2, "NANO");
if (emmParsed[0]==0x90 && emmParsed[1]==0x03) {
/* identification of the service operator */
uchar soid[3], ident[3], i;
for (i=0; i<3; i++) {
soid[i]=ident[i]=emmParsed[2+i];
}
ident[2]&=0xF0;
emm_provid=b2i(3, ident);
keynr=soid[2]&0x0F;
if (chk_prov(reader, ident, keynr)) {
provider_ok = 1;
} else {
rdr_log(reader, "EMM: provider or key not found on card (%x, %x)", emm_provid, keynr);
return ERROR;
}
// check if the provider changes. If yes, set the new one. If not, don't .. card will return an error if we do.
if( reader->last_geo.provid != emm_provid ) {
write_cmd(insa4, ident);
if( cta_res[cta_lr-2]!=0x90 || cta_res[cta_lr-1]!=0x00 ) {
cs_dump(insa4, 5, "set provider cmd:");
cs_dump(soid, 3, "set provider data:");
rdr_log(reader, "update error: %02X %02X", cta_res[cta_lr-2], cta_res[cta_lr-1]);
return ERROR;
}
}
// as we are maybe changing the used provider, clear the cache, so the next ecm will re-select the correct one
reader->last_geo.provid = 0;
reader->last_geo.geo_len = 0;
reader->last_geo.geo[0] = 0;
}
else if (emmParsed[0]==0x9e && emmParsed[1]==0x20) {
/* adf */
if (!nano91Data) {
/* adf is not crypted, so test it */
uchar custwp;
uchar *afd;
custwp=reader->sa[0][3];
afd=(uchar*)emmParsed+2;
if( afd[31-custwp/8] & (1 << (custwp & 7)) )
rdr_debug_mask(reader, D_READER, "emm for our card %08X", b2i(4, &reader->sa[0][0]));
else
return SKIPPED;
}
// memorize
nano9EData = emmParsed;
} else if (emmParsed[0]==0x81) {
nano81Data = emmParsed;
} else if (emmParsed[0]==0x91 && emmParsed[1]==0x08) {
nano91Data = emmParsed;
} else if (emmParsed[0]==0x92 && emmParsed[1]==0x08) {
nano92Data = emmParsed;
} else if (emmParsed[0]==0xF0 && emmParsed[1]==0x08) {
nanoF0Data = emmParsed;
} else {
/* other nanos */
show_subs(reader, emmParsed);
memcpy(ins18Data+ins18Len, emmParsed, emmParsed[1] + 2);
ins18Len += emmParsed [1] + 2;
}
}
if (!provider_ok) {
rdr_debug_mask(reader, D_READER, "provider not found in emm, continue anyway");
// force key to 1...
keynr = 1;
///return ERROR;
}
if (!nanoF0Data) {
cs_dump(ep->emm, ep->emmlen, "can't find 0xf0 in emm...");
return ERROR; // error
}
if (nano9EData) {
if (!nano91Data) {
// set adf
insf0[3] = keynr; // key
insf0[4] = nano9EData[1] + 2;
write_cmd(insf0, nano9EData);
if( cta_res[cta_lr-2]!=0x90 || cta_res[cta_lr-1]!=0x00 ) {
cs_dump(insf0, 5, "set adf cmd:");
cs_dump(nano9EData, insf0[4] , "set adf data:");
rdr_log(reader, "update error: %02X %02X", cta_res[cta_lr-2], cta_res[cta_lr-1]);
return ERROR;
}
} else {
// set adf crypte
insf4[3] = keynr; // key
insf4[4] = nano91Data[1] + 2 + nano9EData[1] + 2;
memcpy (insData, nano91Data, nano91Data[1] + 2);
memcpy (insData + nano91Data[1] + 2, nano9EData, nano9EData[1] + 2);
write_cmd(insf4, insData);
if(( cta_res[cta_lr-2]!=0x90 && cta_res[cta_lr-2]!=0x91) || cta_res[cta_lr-1]!=0x00 ) {
cs_dump(insf4, 5, "set adf encrypted cmd:");
cs_dump(insData, insf4[4], "set adf encrypted data:");
rdr_log(reader, "update error: %02X %02X", cta_res[cta_lr-2], cta_res[cta_lr-1]);
return ERROR;
}
}
}
if (!nano92Data) {
// send subscription
ins18[2] = nano9EData ? 0x01: 0x00; // found 9E nano ?
ins18[3] = keynr; // key
ins18[4] = ins18Len + nanoF0Data[1] + 2;
memcpy (insData, ins18Data, ins18Len);
memcpy (insData + ins18Len, nanoF0Data, nanoF0Data[1] + 2);
write_cmd(ins18, insData);
if( (cta_res[cta_lr-2]==0x90 || cta_res[cta_lr-2]==0x91) && cta_res[cta_lr-1]==0x00 ) {
rdr_debug_mask(reader, D_READER, "update successfully written");
rc=1; // written
} else {
cs_dump(ins18, 5, "set subscription cmd:");
cs_dump(insData, ins18[4], "set subscription data:");
rdr_log(reader, "update error: %02X %02X", cta_res[cta_lr-2], cta_res[cta_lr-1]);
}
} else {
// send subscription encrypted
if (!nano81Data) {
cs_dump(ep->emm, ep->emmlen, "0x92 found, but can't find 0x81 in emm...");
return ERROR; // error
}
ins1c[2] = nano9EData ? 0x01: 0x00; // found 9E nano ?
if (ep->type == UNIQUE) ins1c[2] = 0x02;
ins1c[3] = keynr; // key
ins1c[4] = nano92Data[1] + 2 + nano81Data[1] + 2 + nanoF0Data[1] + 2;
memcpy (insData, nano92Data, nano92Data[1] + 2);
memcpy (insData + nano92Data[1] + 2, nano81Data, nano81Data[1] + 2);
memcpy (insData + nano92Data[1] + 2 + nano81Data[1] + 2, nanoF0Data, nanoF0Data[1] + 2);
write_cmd(ins1c, insData);
if( (cta_res[cta_lr-2]==0x90 && cta_res[cta_lr-1]==0x00) ) {
rdr_log(reader, "update successfully written");
rc=1; // written
}
else {
if( cta_res[cta_lr-2]&0x1 )
rdr_log(reader, "update not written. Data already exists or unknown address");
//if( cta_res[cta_lr-2]&0x8 ) {
write_cmd(insc8, NULL);
if( (cta_res[cta_lr-2]==0x90 && cta_res[cta_lr-1]==0x00) ) {
rdr_log(reader, "extended status %02X %02X", cta_res[0], cta_res[1]);
}
//}
return ERROR;
}
}
/*
Sub Main()
Sc.Write("CA A4 04 00 03")
RX
Sc.Write("02 07 11")
RX
Sc.Write("CA F0 00 01 22")
RX
Sc.Write("9E 20")
Sc.Write("10 10 08 8A 80 00 04 00 10 10 26 E8 54 80 1E 80")
Sc.Write("00 01 00 00 00 00 00 50 00 00 80 02 22 00 08 50")
RX
Sc.Write("CA 18 01 01 11")
RX
Sc.Write("A9 05 34 DE 34 FF 80")
Sc.Write("F0 08 1A 3E AF B5 2B EE E3 3B")
RX
End Sub
*/
return rc;
}
int main (int argc, char *argv[])
{
NEOERR *err;
CSPARSE *parse;
HDF *hdf;
int verbose = 0;
char *hdf_file, *cs_file;
if (argc < 3)
{
ne_warn ("Usage: cstest [-v] <file.hdf> <file.cs>");
return -1;
}
if (!strcmp(argv[1], "-v"))
{
verbose = 1;
if (argc < 4)
{
ne_warn ("Usage: cstest [-v] <file.hdf> <file.cs>");
return -1;
}
hdf_file = argv[2];
cs_file = argv[3];
}
else
{
hdf_file = argv[1];
cs_file = argv[2];
}
err = hdf_init(&hdf);
if (err != STATUS_OK)
{
nerr_warn_error(err);
return -1;
}
err = hdf_read_file(hdf, hdf_file);
if (err != STATUS_OK)
{
nerr_warn_error(err);
return -1;
}
printf ("Parsing %s\n", cs_file);
err = cs_init (&parse, hdf);
if (err != STATUS_OK)
{
nerr_warn_error(err);
return -1;
}
err = cgi_register_strfuncs(parse);
if (err != STATUS_OK)
{
nerr_warn_error(err);
return -1;
}
err = cs_parse_file (parse, cs_file);
if (err != STATUS_OK)
{
err = nerr_pass(err);
nerr_warn_error(err);
return -1;
}
err = cs_render(parse, NULL, output);
if (err != STATUS_OK)
{
err = nerr_pass(err);
nerr_warn_error(err);
return -1;
}
if (verbose)
{
printf ("\n-----------------------\nCS DUMP\n");
err = cs_dump(parse, NULL, output);
}
cs_destroy (&parse);
if (verbose)
{
printf ("\n-----------------------\nHDF DUMP\n");
hdf_dump (hdf, NULL);
}
hdf_destroy(&hdf);
return 0;
}
int main (int argc, char *argv[])
{
NEOERR *err;
CSPARSE *parse;
HDF *hdf;
int verbose = 0;
char *hdf_file, *cs_file;
char c;
extern char *optarg;
err = hdf_init(&hdf);
if (err != STATUS_OK)
{
nerr_warn_error(err);
return -1;
}
err = cs_init (&parse, hdf);
if (err != STATUS_OK) {
nerr_warn_error(err);
return -1;
}
while ((c = getopt(argc, argv, "Hvh:c:")) != EOF )
switch (c) {
case 'h':
hdf_file=optarg;
err = hdf_read_file(hdf, hdf_file);
if (err != STATUS_OK) {
nerr_warn_error(err);
return -1;
}
break;
case 'c':
cs_file=optarg;
if ( verbose )
printf ("Parsing %s\n", cs_file);
err = cs_parse_file (parse, cs_file);
if (err != STATUS_OK) {
err = nerr_pass(err);
nerr_warn_error(err);
return -1;
}
break;
case 'v':
verbose=1;
break;
case 'H':
fprintf(stderr, "Usage: %s [-v] [-h <file.hdf>] [-c <file.cs>]\n", argv[0]);
fprintf(stderr, " -h <file.hdf> load hdf file file.hdf (multiple allowed)\n");
fprintf(stderr, " -c <file.cs> load cs file file.cs (multiple allowed)\n");
fprintf(stderr, " -v verbose output\n");
return -1;
break;
}
err = cs_render(parse, NULL, output);
if (err != STATUS_OK) {
err = nerr_pass(err);
nerr_warn_error(err);
return -1;
}
if (verbose) {
printf ("\n-----------------------\nCS DUMP\n");
err = cs_dump(parse, NULL, output);
}
cs_destroy (&parse);
if (verbose) {
printf ("\n-----------------------\nHDF DUMP\n");
hdf_dump (hdf, NULL);
}
return 0;
}
