Changeset 1795


Ignore:
Timestamp:
Mar 6, 2010, 12:34:56 AM (10 years ago)
Author:
_network
Message:

modular: fix au in dvbapi testversion

Location:
branches/modular
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • branches/modular/Distribution/doc/example/oscam.srvid

    r1241 r1795  
    3573571830:EF10|Astra HD+|RTL HD|TV|
    3583581830:EF11|Astra HD+|VOX HD|TV|
    359 1830:277E|Astra HD+|. (SD)|TV|
     3591830:EF74|Astra HD+|SAT.1 HD|TV|
     3601830:EF75|Astra HD+|ProSieben HD|TV|
     3611830:EF76|Astra HD+|kabel eins HD|TV|
    360362
    361363#
  • branches/modular/globals.h

    r1776 r1795  
    548548  DWORD dwActiveProtocol;
    549549#endif
    550 #ifdef LIBUSB 
    551   SR_CONFIG *sr_config; 
    552 #endif 
     550#ifdef LIBUSB
     551  SR_CONFIG *sr_config;
     552#endif
    553553};
    554554
  • branches/modular/module-dvbapi.c

    r1776 r1795  
    3232
    3333static int listenfd = -1;
     34int global_support_pip = 0;
     35int global_merged_capmt = 0;
    3436
    3537typedef struct ECMPIDS
     
    245247    close(dmx_fd);
    246248
     249    if (ret < 0) return 0;
     250
    247251    selected_box=devnum;
    248252    selected_api=apinum;
     
    423427    demux[demux_index].provider_id=provider_id;
    424428
    425     int camfd=dvbapi_open_device(demux_index,1);
    426     if (camfd<=0) {
     429    demux[demux_index].ca_fd = dvbapi_open_device(demux_index,1);
     430    if (demux[demux_index].ca_fd<=0)
    427431        return;
    428     }
    429 
    430     demux[demux_index].ca_fd=camfd;
    431432
    432433    for (i=0;i<demux[demux_index].STREAMpidcount;i++) {
     
    435436        ca_pid2.pid = demux[demux_index].STREAMpids[i];
    436437        ca_pid2.index = demux_index;
    437         if (ioctl(camfd, CA_SET_PID, &ca_pid2)==-1)
     438        if (ioctl(demux[demux_index].ca_fd, CA_SET_PID, &ca_pid2)==-1)
    438439            cs_debug("dvbapi: Error Stream SET_PID");
    439440    }
     
    567568    unsigned int program_number = (buffer[1] << 8) | buffer[2];
    568569    int program_info_length = ((buffer[4] & 0x0F) << 8) | buffer[5];
    569 
     570/*
    570571    switch (ca_pmt_list_management)
    571572    {
     
    583584            break;
    584585    }
    585 
     586*/
    586587    if (buffer[17]==0x82 && buffer[18]==0x02) {
    587588        //enigma2
     
    595596    for (i=0;i<MAX_DEMUX;i++) {
    596597        if (demux[i].demux_index==demux_index2 && demux[i].program_number==((buffer[1] << 8) | buffer[2])) { // already descrambling prog on this device
     598            global_support_pip=1;
    597599            if (demux[i].active==1) {
    598600                //remove any inactive program
     
    693695            return;
    694696        }
     697
     698        global_merged_capmt=0;
     699        if (k>0) global_merged_capmt=1;
    695700
    696701        if (buffer[3+k] & 0x80) {
     
    937942                            dvbapi_stop_filter(demux_index, TYPE_EMM);
    938943                            if (cfg->dvbapi_au==1) {
    939                                 if (demux[demux_index].ECMpids[n].EMM_PID>0)
    940                                     dvbapi_start_filter(demux_index, demux[demux_index].ECMpids[n].CA_System_ID, demux[demux_index].ECMpids[n].EMM_PID, 0x80, 0xf0, TYPE_EMM);
     944                                for (g=0;g<demux[demux_index].ECMpidcount;g++) {
     945                                    if (demux[demux_index].demux_fd[n].caid == demux[demux_index].ECMpids[g].CA_System_ID && demux[demux_index].ECMpids[g].EMM_PID>0)
     946                                        dvbapi_start_filter(demux_index, demux[demux_index].ECMpids[g].CA_System_ID, demux[demux_index].ECMpids[g].EMM_PID, 0x80, 0xF0, TYPE_EMM);
     947                                }
    941948                            }
    942949                            continue;
     
    956963    int i;
    957964    unsigned char nullcw[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
     965    ca_descr_t ca_descr;
    958966
    959967    cs_debug("dvbapi: ECM rc: %d", er->rc);
     
    9951003            }
    9961004
    997             ca_descr_t ca_descr;
    9981005            memset(&ca_descr,0,sizeof(ca_descr));
    9991006
    10001007            if (demux[i].ca_fd<=0) {
    10011008                cs_log("dvbapi: could not write cw.");
    1002                 return;
     1009                demux[i].ca_fd = dvbapi_open_device(i,1);
     1010                if (demux[i].ca_fd<=0)
     1011                    return;
    10031012            }
    10041013
  • branches/modular/oscam-log.c

    r1776 r1795  
    144144    //  memcpy(txt, sbuf, 11);
    145145
    146 //Fixme: remove below if all works ok
    147 /*
    148     time(&t);
    149     lt=localtime(&t);
    150     sprintf(buf, "[LOG000]%4d/%02d/%02d %2d:%02d:%02d %s\n",
    151             lt->tm_year+1900, lt->tm_mon+1, lt->tm_mday,
    152             lt->tm_hour, lt->tm_min, lt->tm_sec, txt);
    153 */
    154146    if (use_syslog && !use_ac_log)      // system-logfile
    155147        syslog(LOG_INFO, "%s", txt);
     
    277269
    278270    if( fmt )
    279         cs_log(fmt);
     271    {
     272        get_log_header(1, txt);
     273        va_list params;
     274        va_start(params, fmt);
     275        vsprintf(txt+11, fmt, params);
     276        va_end(params);
     277        write_to_log(-1, txt);
     278        //printf("LOG: %s\n", txt); fflush(stdout);
     279    }
    280280
    281281    for( i=0; i<n; i+=16 )
  • branches/modular/oscam-reader.c

    r1769 r1795  
    421421  int i, no, rc, ecs;
    422422  char *rtxt[] = { "error", "written", "skipped", "blocked" };
     423  //char *typedesc[]= { "unknown", "unique", "shared", "global" };
    423424  struct timeb tps, tpe;
    424425
     
    455456  {
    456457    cs_ftime(&tpe);
    457 //    cs_log("%s type=%02x, len=%d, idx=%d, cnt=%d: %s (%d ms)",
    458 //           cs_inet_ntoa(client[ep->cidx].ip), emmcache[i].type, ep->emm[2],
    459 //           i, no, rtxt[rc], 1000*(tpe.time-tps.time)+tpe.millitm-tps.millitm);
     458
     459    /*
     460    cs_log("%s emm: type=%s, len=%d, idx=%d, cnt=%d: %s (%d ms)",
     461           username(ep->cidx), typedesc[emmcache[i].type], ep->emm[2],
     462           i, no, rtxt[rc], 1000*(tpe.time-tps.time)+tpe.millitm-tps.millitm);
     463    */
    460464    cs_log("%s type=%02x, len=%d, idx=%d, cnt=%d: %s (%d ms)",
    461465           username(ep->cidx), emmcache[i].type, ep->emm[2],
  • branches/modular/oscam.c

    r1776 r1795  
    21082108void do_emm(EMM_PACKET *ep)
    21092109{
    2110   int au;//, ephs;
    2111   au=client[cs_idx].au;
     2110    int au;
     2111    au = client[cs_idx].au;
     2112
    21122113    cs_ddump_mask(D_ATR, ep->emm, ep->l, "emm:");
    21132114
    2114   if ((au<0) || (au>=CS_MAXREADER))
    2115     return;
     2115    if ((au < 0) || (au >= CS_MAXREADER))
     2116        return;
     2117
    21162118    if (!reader_get_emm_type(ep, &reader[au])) //decodes ep->type and ep->hexserial from the EMM
    21172119        return;
    2118   cs_debug_mask(D_EMM, "Emmtype = %i. reader %s has serial %s.", ep->type, reader[au].label, cs_hexdump(0, reader[au].hexserial, 8));
    2119   cs_ddump_mask(D_EMM, ep->hexserial, 8, "emm UA/SA:");
     2120
     2121    cs_ddump_mask(D_EMM, ep->hexserial, 8, "emm UA/SA:");
     2122
    21202123    switch (ep->type) {
    21212124        case UNKNOWN:
     2125            cs_debug_mask(D_EMM, "emmtype UNKNOWN. Reader %s has serial %s.", reader[au].label, cs_hexdump(0, reader[au].hexserial, 8));
    21222126            if (reader[au].blockemm_unknown) return;
     2127            break;
     2128
    21232129        case UNIQUE:
     2130            cs_debug_mask(D_EMM, "emmtype UNIQUE. Reader %s has serial %s.", reader[au].label, cs_hexdump(0, reader[au].hexserial, 8));
    21242131            if (reader[au].blockemm_u) return;
     2132            break;
     2133
    21252134        case SHARED:
     2135            cs_debug_mask(D_EMM, "emmtype SHARED. Reader %s has serial %s.", reader[au].label, cs_hexdump(0, reader[au].hexserial, 8));
    21262136            if (reader[au].blockemm_s) return;
    2127 //FIXME only camd33 delivers hexserial from the net, newcamd, camd35 copy cardreader hexserial in; reader_get_emm_type overwrites this with real SA value if known!
     2137            break;
     2138
     2139        // FIXME only camd33 delivers hexserial from the net, newcamd, camd35 copy
     2140        // cardreader hexserial in; reader_get_emm_type overwrites this with real SA value if known!
    21282141        case GLOBAL:
     2142            cs_debug_mask(D_EMM, "emmtype GLOBAL. Reader %s has serial %s.", reader[au].label, cs_hexdump(0, reader[au].hexserial, 8));
    21292143            if (reader[au].blockemm_g) return;
     2144            break;
    21302145    }
    2131   client[cs_idx].lastemm=time((time_t)0);
    2132   cs_ddump_mask(D_EMM, ep->emm, ep->l, "emm:");
    2133 //  if ((!reader[au].fd) || (reader[au].b_nano[ep->emm[3]])) // blocknano is obsolete
    2134   if ((!reader[au].fd) ||       // reader has no fd
    2135       (reader[au].caid[0]!=b2i(2,ep->caid))) {   // wrong caid
     2146
     2147    client[cs_idx].lastemm = time((time_t)0);
     2148    cs_ddump_mask(D_EMM, ep->emm, ep->l, "emm:");
     2149
     2150    if ((!reader[au].fd) ||       // reader has no fd
     2151    (reader[au].caid[0] != b2i(2,ep->caid))) {   // wrong caid
    21362152#ifdef WEBIF
    21372153      client[cs_idx].emmnok++;
    21382154#endif
    21392155      return;
    2140   }
     2156    }
    21412157#ifdef WEBIF
    2142   client[cs_idx].emmok++;
    2143 #endif
    2144   ep->cidx=cs_idx;
    2145   cs_debug_mask(D_EMM, "EMM is being sent to reader %s.", reader[au].label);
    2146   write_to_pipe(reader[au].fd, PIP_ID_EMM, (uchar *) ep, sizeof(EMM_PACKET));
     2158    client[cs_idx].emmok++;
     2159#endif
     2160    ep->cidx = cs_idx;
     2161    cs_debug_mask(D_EMM, "emm is being sent to reader %s.", reader[au].label);
     2162    write_to_pipe(reader[au].fd, PIP_ID_EMM, (uchar *) ep, sizeof(EMM_PACKET));
    21472163}
    21482164
  • branches/modular/reader-conax.c

    r1776 r1795  
    206206int conax_get_emm_type(EMM_PACKET *ep, struct s_reader * rdr) //returns TRUE if shared emm matches SA, unique emm matches serial, or global or unknown
    207207{
    208     ep->type=ep->emm[2]+3; //FIXME not sure how this maps onto global, unique and shared!
    209     return TRUE; //FIXME let it all pass without checking serial or SA, without filling ep->hexserial
     208    int i, ok = 0;
     209
     210    cs_debug_mask(D_EMM, "Entered conax_get_emm_type ep->emm[2]=%02x",ep->emm[2]);
     211
     212    for (i = 0; i < rdr->nprov; i++) {
     213        ok = (!memcmp(&ep->emm[6], rdr->sa[i], 4));
     214        if (ok) break;
     215    }
     216
     217    if (ok) {
     218        ep->type = SHARED;
     219        memset(ep->hexserial, 0, 8);
     220        memcpy(ep->hexserial, &ep->emm[6], 4);
     221        cs_debug_mask(D_EMM, "CONAX EMM: SHARED, ep->hexserial = %s", cs_hexdump(1, ep->hexserial, 8));
     222        return TRUE;
     223    }
     224    else {
     225        if (!memcmp(&ep->emm[4], rdr->hexserial, 6)) {
     226            ep->type = UNIQUE;
     227            memset(ep->hexserial, 0, 8);
     228            memcpy(ep->hexserial, &ep->emm[4], 6);
     229            cs_debug_mask(D_EMM, "CONAX EMM: UNIQUE, ep->hexserial = %s", cs_hexdump(1, ep->hexserial, 8));
     230            return TRUE;
     231        }
     232        else {
     233            ep->type = GLOBAL;
     234            cs_debug_mask(D_EMM, "CONAX EMM: GLOBAL");
     235            memset(ep->hexserial, 0, 8);
     236            return TRUE;
     237        }
     238    }
     239
    210240}
    211241   
  • branches/modular/reader-irdeto.c

    r1776 r1795  
    366366}
    367367
    368 int irdeto_get_emm_type(EMM_PACKET *ep, struct s_reader * rdr) //returns TRUE if shared emm matches SA, unique emm matches serial, or global or unknown
    369 {
    370     int i, l = (ep->emm[3]&0x07), ok=0;
     368int irdeto_get_emm_type(EMM_PACKET *ep, struct s_reader * rdr) {
     369
     370    int l = (ep->emm[3]&0x07);
    371371    int mode = (ep->emm[3]>>3);
    372     if (mode&0x10) {
    373         // Hex addressed
    374         ep->type = UNIQUE;
    375         memset(ep->hexserial,0,8);
    376         memcpy(ep->hexserial, ep->emm + 4, l);
    377         return (mode == rdr->hexserial[3] && (!l || !memcmp(ep->emm+4, rdr->hexserial, l)));
     372
     373    cs_debug_mask(D_EMM, "Entered irdeto_get_emm_type ep->emm[3]=%02x",ep->emm[3]);
     374
     375    switch (ep->emm[3]) {
     376
     377        case 0xd0:
     378            // 0xd0 means global emm
     379            ep->type = GLOBAL;
     380            cs_debug_mask(D_EMM, "IRDETO EMM: GLOBAL");
     381            return TRUE;
     382        case 0xd2:
     383            // 0xd2 means shared emm, first 2 bytes of hexserial are transmitted in emm, seems to be the shared adr
     384            ep->type = SHARED;
     385            memset(ep->hexserial, 0, 8);
     386            memcpy(ep->hexserial, ep->emm + 4, l);
     387            cs_debug_mask(D_EMM, "IRDETO EMM: SHARED, ep = %s, rdr = %s", cs_hexdump(1, ep->hexserial, l),
     388                     cs_hexdump(1, rdr->hexserial, l));
     389            return (!l || !memcmp(ep->emm + 4, rdr->hexserial, l));
     390           
     391        case 0xd3:
     392            // 0xd3 means uniqe emm
     393            ep->type = UNIQUE;
     394            memset(ep->hexserial, 0, 8);
     395            memcpy(ep->hexserial, ep->emm + 4, l);
     396            cs_debug_mask(D_EMM, "IRDETO EMM: UNIQUE, ep = %s, rdr = %s", cs_hexdump(1, ep->hexserial, l),
     397                     cs_hexdump(1, rdr->hexserial, l));
     398            return (mode == rdr->hexserial[3] && (!l || !memcmp(ep->emm + 4, rdr->hexserial, l)));
     399        default:
     400            ep->type = UNKNOWN;
     401            cs_debug_mask(D_EMM, "IRDETO EMM: UNKNOWN");
     402            return TRUE;
    378403    }
    379     else {
    380         // Provider addressed
    381         for(i = 0; i < rdr->nprov; i++) {
    382             ok = (mode == rdr->prid[i][0] && (!l || !memcmp(ep->emm+4, &rdr->prid[i][1], l)));
    383             if (ok) break;
    384         }
    385        
    386         ep->type = SHARED;
    387         memset(ep->hexserial,0,8);
    388         //prid in hexserial instead of SA
    389         memcpy(ep->hexserial, ep->emm+4, l);
    390         return ok;
    391     }
     404
    392405}
    393406
  • branches/modular/reader-nagra.c

    r1776 r1795  
    727727            ep->hexserial[1] = ep->emm[4];
    728728            ep->hexserial[2] = ep->emm[3];
    729             ep->hexserial[3] = ep->emm[6];
    730             if (ep->emm[7] == 0x10)
     729            if (ep->emm[7] == 0x10) {
    731730                ep->type = SHARED;
    732             else
     731                return (!memcmp (rdr->hexserial+2, ep->hexserial, 3));
     732            }
     733            else {
     734                ep->hexserial[3] = ep->emm[6];
    733735                ep->type = UNIQUE;
    734             return (!memcmp (rdr->hexserial, ep->hexserial, 4));
     736                return (!memcmp (rdr->hexserial+2, ep->hexserial, 4));
     737            }
    735738        case 0x82:
    736739            ep->type = GLOBAL;
Note: See TracChangeset for help on using the changeset viewer.