Changeset 70


Ignore:
Timestamp:
May 12, 2009, 5:25:27 AM (11 years ago)
Author:
rorothetroll
Message:

csctapi/io_serial.c : fix the serial port read/write wait routine to use select instead of poll

This make them compatible with Mac OS X and now oscamd works on OS X. The same code off course
still works on linux and other unix platforms. I let that code ran for 24h before commiting this code.
If you have any issue let me know and I'llr evert to poll for non compatible machines.

all the others : fix all the warning due to sign difference (mostly uchar versus char). This make the code compile

with -Werror on the more strict version of gcc (which is the case on OS X). I also noticed that in a lot of places
the code use a buffer defined as an uchar * ... and use strings functions (strnXXXX) where some memcpy/memcmp .. function
would have been preferable as we're suposedly manipulation a binary buffer. Anyway I fixed all of them and it now compile
without any warning or error on linux and OS X (and also probably on all the other unices but we will have to try before
adding -Werror on the other platform).

Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • trunk/Makefile

    r65 r70  
    8181        OS_CULI="-lncurses" \
    8282        OS_PTLI="-lpthread" \
    83         DS_OPTS="-O2 -DOS_MACOSX -DCS_NOSHM -DCS_CONFDIR=${CS_CONFDIR}" \
     83        DS_OPTS="-O2 -DOS_MACOSX -DNEED_DAEMON -DCS_NOSHM -DHAVE_PTHREAD_H -DUSE_PTHREAD -DCS_CONFDIR=${CS_CONFDIR} -Winline -Werror -finline-functions -fomit-frame-pointer" \
    8484        DS_CFLAGS="-c" \
    8585        DS_LDFLAGS="" \
  • trunk/cscrypt/md5.c

    r8 r70  
    568568    /* The password first, since that is what is most unknown */
    569569    pw_len = strlen(pw);
    570     __md5_Update(&ctx,pw,pw_len);
     570    __md5_Update(&ctx,(const unsigned char *)pw,pw_len);
    571571
    572572    /* Then our magic string */
    573     __md5_Update(&ctx,__md5__magic,__md5__magic_len);
     573    __md5_Update(&ctx,(const unsigned char *)__md5__magic,__md5__magic_len);
    574574
    575575    /* Then the raw salt */
    576     __md5_Update(&ctx,sp,sl);
     576    __md5_Update(&ctx,(const unsigned char *)sp,sl);
    577577
    578578    /* Then just as many characters of the MD5(pw,salt,pw) */
    579579    __md5_Init(&ctx1);
    580     __md5_Update(&ctx1,pw,pw_len);
    581     __md5_Update(&ctx1,sp,sl);
    582     __md5_Update(&ctx1,pw,pw_len);
     580    __md5_Update(&ctx1,(const unsigned char *)pw,pw_len);
     581    __md5_Update(&ctx1,(const unsigned char *)sp,sl);
     582    __md5_Update(&ctx1,(const unsigned char *)pw,pw_len);
    583583    __md5_Final(final,&ctx1);
    584584    for(pl = pw_len; pl > 0; pl -= 16)
    585         __md5_Update(&ctx,final,pl>16 ? 16 : pl);
     585        __md5_Update(&ctx,(const unsigned char *)final,pl>16 ? 16 : pl);
    586586
    587587    /* Don't leave anything around in vm they could use. */
     
    608608        __md5_Init(&ctx1);
    609609        if(i & 1)
    610             __md5_Update(&ctx1,pw,pw_len);
     610            __md5_Update(&ctx1,(const unsigned char *)pw,pw_len);
    611611        else
    612             __md5_Update(&ctx1,final,16);
     612            __md5_Update(&ctx1,(const unsigned char *)final,16);
    613613
    614614        if(i % 3)
    615             __md5_Update(&ctx1,sp,sl);
     615            __md5_Update(&ctx1,(const unsigned char *)sp,sl);
    616616
    617617        if(i % 7)
    618             __md5_Update(&ctx1,pw,pw_len);
     618            __md5_Update(&ctx1,(const unsigned char *)pw,pw_len);
    619619
    620620        if(i & 1)
    621             __md5_Update(&ctx1,final,16);
     621            __md5_Update(&ctx1,(const unsigned char *)final,16);
    622622        else
    623             __md5_Update(&ctx1,pw,pw_len);
     623            __md5_Update(&ctx1,(const unsigned char *)pw,pw_len);
    624624        __md5_Final(final,&ctx1);
    625625    }
  • trunk/csctapi/atr.c

    r67 r70  
    573573{
    574574    bool ret;
    575 #ifdef OS_MACOSX
    576     ret = IO_Serial_Read_MacOSX (io, timeout, 1, byte);
    577 #else   
    578575    ret = IO_Serial_Read (io, timeout, 1, byte);
    579 #endif
    580576    /* Para tarjetas inversas quiza */
    581577    if (invert)
  • trunk/csctapi/config.h

    r21 r70  
    66/* Debug CT-API */
    77/* #undef DEBUG_CTAPI */
    8 //#define DEBUG_CTAPI 1
     8// #define DEBUG_CTAPI 1
    99
    1010/* Debug Integrated Circuit Card */
    1111/* #undef DEBUG_ICC */
    12 //#define DEBUG_ICC 1
     12// #define DEBUG_ICC 1
    1313
    1414/* Debug Interface Device */
     
    2222/* Debug Input/Output */
    2323/* #undef DEBUG_IO */
    24 //#define DEBUG_IO 1
     24// #define DEBUG_IO 1
    2525
    2626/* Debug Protocol */
  • trunk/csctapi/ifd_towitoko.c

    r67 r70  
    555555        if(ioctl(ifd->io->fd, IOCTL_SET_ATR_READY)<0)
    556556            return IFD_TOWITOKO_IO_ERROR;
    557 #ifdef OS_MACOSX
    558         while(n<SCI_MAX_ATR_SIZE && IO_Serial_Read_MacOSX(ifd->io, IFD_TOWITOKO_ATR_TIMEOUT, 1, buf+n))
    559 #else           
    560557        while(n<SCI_MAX_ATR_SIZE && IO_Serial_Read(ifd->io, IFD_TOWITOKO_ATR_TIMEOUT, 1, buf+n))
    561 #endif
    562558        {
    563559            n++;
     
    760756        if ((sent == 0) && (block_delay != char_delay))
    761757        {
    762 #ifdef OS_MACOSX
    763             if (!IO_Serial_Write_MacOSX (ifd->io, block_delay, 1, buffer))
    764 #else
    765758            if (!IO_Serial_Write (ifd->io, block_delay, 1, buffer))
    766 #endif
    767759                return IFD_TOWITOKO_IO_ERROR;
    768760           
    769 #ifdef OS_MACOSX
    770             if (!IO_Serial_Write_MacOSX (ifd->io, char_delay, to_send-1, buffer+1))
    771 #else
    772761            if (!IO_Serial_Write (ifd->io, char_delay, to_send-1, buffer+1))
    773 #endif
    774762                return IFD_TOWITOKO_IO_ERROR;
    775763        }
    776764        else
    777765        {
    778 #ifdef OS_MACOSX
    779             if (!IO_Serial_Write_MacOSX (ifd->io, char_delay, to_send, buffer+sent))
    780 #else
    781766            if (!IO_Serial_Write (ifd->io, char_delay, to_send, buffer+sent))
    782 #endif
    783767                return IFD_TOWITOKO_IO_ERROR;
    784768        }
     
    806790    {
    807791        /* Read first byte using block timeout */
    808 #ifdef OS_MACOSX
    809         if (!IO_Serial_Read_MacOSX (ifd->io, block_timeout, 1, buffer))
    810 #else
    811792        if (!IO_Serial_Read (ifd->io, block_timeout, 1, buffer))
    812 #endif
    813793            return IFD_TOWITOKO_IO_ERROR;
    814794       
     
    816796        {
    817797            /* Read remaining data bytes using char timeout */
    818 #ifdef OS_MACOSX
    819             if (!IO_Serial_Read_MacOSX (ifd->io, char_timeout, size - 1, buffer + 1))
    820 #else
    821798            if (!IO_Serial_Read (ifd->io, char_timeout, size - 1, buffer + 1))
    822 #endif
    823799                return IFD_TOWITOKO_IO_ERROR;
    824800        }
     
    827803    {
    828804        /* Read all data bytes with the same timeout */
    829 #ifdef OS_MACOSX
    830         if (!IO_Serial_Read_MacOSX (ifd->io, char_timeout, size, buffer))
    831 #else
    832805        if (!IO_Serial_Read (ifd->io, char_timeout, size, buffer))
    833 #endif
    834806            return IFD_TOWITOKO_IO_ERROR;
    835807    }
  • trunk/csctapi/io_serial.c

    r69 r70  
    1 /*
     1   /*
    22    io_serial.c
    33    Serial port input/output functions
     
    2727#include <string.h>
    2828#include <stdlib.h>
     29#include <errno.h>
    2930#ifdef OS_HPUX
    3031#include <sys/modem.h>
     
    658659{
    659660    BYTE b;
    660 #ifdef OS_MACOSX
    661     while(IO_Serial_Read_MacOSX(io, 1000, 1, &b));
    662 #else
    663661    while(IO_Serial_Read(io, 1000, 1, &b));
    664 #endif
    665662}
    666663
     
    676673    return io->com;
    677674}
    678 
    679 //
    680 // read "size" Byte from the port.
    681 // return true if all data were read, false on error or timeout
    682 //
    683 
    684 bool IO_Serial_Read_MacOSX(IO_Serial * io, unsigned timeout, unsigned size, BYTE * data)
    685 
    686 {
    687    
    688    int nByte;
    689    int totalRead;
    690    int m_timeout;
    691    int length;
    692    BYTE c;
    693    
    694    totalRead=0;
    695    m_timeout=0;
    696    nByte=0;
    697    length= size * (_in_echo_read ? (1+io_serial_need_dummy_char) : 1);
    698 
    699     if((io->com!=RTYP_SCI) && (io->wr>0))
    700     {
    701         BYTE buf[256];
    702         int n = io->wr;
    703         io->wr = 0;
    704    
    705         if(!IO_Serial_Read_MacOSX (io, timeout, n, buf))
    706         {
    707             return FALSE;
    708         }
    709     }
    710 
    711 #ifdef DEBUG_IO
    712    printf ("IO: IO_Serial_Read_MacOSX\n");
    713     printf ("IO: Receiving %d byte(s): ",size);
    714     fflush (stdout);
    715 #endif
    716    while(TRUE)
    717    {
    718       nByte=read(io->fd,&c,1);
    719       if(nByte<=0)
    720       {
    721          usleep (1000L); // 1ms
    722          m_timeout++;
    723          if(m_timeout==timeout)
    724          {
    725 #ifdef DEBUG_IO
    726             printf ("TIMEOUT\n");
    727             fflush (stdout);
    728 #endif
    729             tcflush (io->fd, TCIFLUSH);
    730             return FALSE;
    731          }
    732       }
    733       else
    734       {
    735          m_timeout=0;
    736 #ifdef DEBUG_IO
    737             printf ("%02X ", c);
    738             fflush (stdout);
    739 #endif
    740          data[_in_echo_read ? totalRead/(1+io_serial_need_dummy_char) : totalRead] = c;
    741          totalRead+=nByte;
    742          if(length == totalRead)
    743             break;
    744       }
    745    }
    746    
    747    _in_echo_read = 0;
    748 
    749 #ifdef DEBUG_IO
    750    printf ("\n");
    751    fflush (stdout);
    752    printf("exiting IO_Serial_Read_MacOSX [true]\n" );
    753 #endif
    754    return TRUE;
    755 }
    756 
    757 //
    758 // Send "size" Byte data present in data
    759 // return true if data was correctly send
    760 //
    761 bool IO_Serial_Write_MacOSX (IO_Serial * io, unsigned delay, unsigned size, BYTE * data)
    762 {
    763    int nByte;
    764    int m_delay;
    765    BYTE data_w[512];
    766    int i_w;
    767    unsigned count, to_send;
    768 
    769 #ifdef DEBUG_IO
    770     unsigned i;
    771     printf ("IO: IO_Serial_Write_MacOSX\n");
    772     printf ("IO: Sending %d byte(s) : ",size);
    773     fflush (stdout);
    774 #endif
    775    
    776    m_delay=0;
    777    nByte=0;
    778    to_send = (delay? 1: size);
    779    
    780    // send the data
    781    for (count = 0; count < size; count += to_send)
    782    {
    783       for (i_w=0; i_w < to_send; i_w++)
    784       {
    785          data_w [(1+io_serial_need_dummy_char)*i_w] = data [count + i_w];
    786          if (io_serial_need_dummy_char)
    787          {
    788             data_w [2*i_w+1] = 0x00;
    789          }
    790       }
    791      
    792       nByte=write(io->fd,data_w,(1+io_serial_need_dummy_char)*to_send);
    793       _in_echo_read = 1;
    794      
    795       if(nByte<=0 || nByte!=(1+io_serial_need_dummy_char)*to_send)
    796       {
    797          tcflush (io->fd, TCIFLUSH);
    798          if(io->com!=RTYP_SCI)
    799             io->wr += nByte;
    800 
    801 #ifdef DEBUG_IO
    802          printf ("ERROR\n");
    803          printf("exiting IO_Serial_Write_MacOSX [false]\n" );
    804          fflush (stdout);
    805 #endif
    806          return FALSE;
    807       }
    808       if(delay)
    809          usleep(delay*1000L);
    810 
    811       if(io->com!=RTYP_SCI)
    812          io->wr += to_send;
    813 
    814 #ifdef DEBUG_IO
    815       for (i=0; i<(1+io_serial_need_dummy_char)*to_send; i++)
    816          printf ("%02 X ", data_w[count + i]);
    817       fflush (stdout);
    818 #endif
    819      
    820    }
    821 
    822 #ifdef DEBUG_IO
    823     printf ("\n");
    824     fflush (stdout);
    825 #endif
    826     return TRUE;
    827 }
    828 
    829675
    830676
     
    1062908static bool IO_Serial_WaitToRead (int hnd, unsigned delay_ms, unsigned timeout_ms)
    1063909{
    1064     int rval;
    1065     struct pollfd ufds;
    1066    
    1067     if (delay_ms > 0)
    1068     {
     910   fd_set rfds;
     911   fd_set erfds;
     912   struct timeval tv;
     913   int select_ret;
     914   int in_fd;
     915   
     916   if (delay_ms > 0)
     917   {
    1069918#ifdef HAVE_NANOSLEEP
    1070         struct timespec req_ts;
     919      struct timespec req_ts;
     920     
     921      req_ts.tv_sec = delay_ms / 1000;
     922      req_ts.tv_nsec = (delay_ms % 1000) * 1000000L;
     923      nanosleep (&req_ts, NULL);
     924#else
     925      usleep (delay_ms * 1000L);
     926#endif
     927   }
     928   
     929   in_fd=hnd;
     930   
     931   FD_ZERO(&rfds);
     932   FD_SET(in_fd, &rfds);
     933   
     934   FD_ZERO(&erfds);
     935   FD_SET(in_fd, &erfds);
     936   
     937   tv.tv_sec = timeout_ms/1000;
     938   tv.tv_usec = (timeout_ms % 1000) * 1000L;
     939   select_ret = select(in_fd+1, &rfds, NULL,  &erfds, &tv);
     940   if(select_ret==-1)
     941   {
     942      printf("select_ret=%i\n" , select_ret);
     943      printf("errno =%d\n", errno);
     944      fflush(stdout);
     945      return (FALSE);
     946   }
     947
     948   if (FD_ISSET(in_fd, &erfds))
     949   {
     950      printf("fd is in error fds\n");
     951      printf("errno =%d\n", errno);
     952      fflush(stdout);
     953      return (FALSE);
     954   }
     955
     956   return(FD_ISSET(in_fd,&rfds));
     957}
     958
     959static bool IO_Serial_WaitToWrite (IO_Serial *io, unsigned delay_ms, unsigned timeout_ms)
     960{
     961   fd_set wfds;
     962   fd_set ewfds;
     963   struct timeval tv;
     964   int select_ret;
     965   int out_fd;
     966   
     967#ifdef SCI_DEV
     968   if(io->com==RTYP_SCI)
     969      return TRUE;
     970#endif
    1071971       
    1072         req_ts.tv_sec = delay_ms / 1000;
    1073         req_ts.tv_nsec = (delay_ms % 1000) * 1000000L;
    1074         nanosleep (&req_ts, NULL);
     972   if (delay_ms > 0)
     973    {
     974#ifdef HAVE_NANOSLEEP
     975      struct timespec req_ts;
     976     
     977      req_ts.tv_sec = delay_ms / 1000;
     978      req_ts.tv_nsec = (delay_ms % 1000) * 1000000L;
     979      nanosleep (&req_ts, NULL);
    1075980#else
    1076         usleep (delay_ms * 1000L);
    1077 #endif
    1078     }
    1079    
    1080     ufds.fd = hnd;
    1081     ufds.events = POLLIN;
    1082     ufds.revents = 0x0000;
    1083    
    1084     rval = poll (&ufds, 1, timeout_ms);
    1085     if (rval != 1)
    1086         return (FALSE);
    1087    
    1088     return (((ufds.revents) & POLLIN) == POLLIN);
    1089 }
    1090 
    1091 static bool IO_Serial_WaitToWrite (IO_Serial *io, unsigned delay_ms, unsigned timeout_ms)
    1092 {
    1093     int rval;
    1094     struct pollfd ufds;
    1095 
    1096 #ifdef SCI_DEV
    1097     if(io->com==RTYP_SCI)
    1098         return TRUE;
    1099 #endif
    1100        
    1101     if (delay_ms > 0)
    1102     {
    1103 #ifdef HAVE_NANOSLEEP
    1104         struct timespec req_ts;
    1105        
    1106         req_ts.tv_sec = delay_ms / 1000;
    1107         req_ts.tv_nsec = (delay_ms % 1000) * 1000000L;
    1108         nanosleep (&req_ts, NULL);
    1109 #else
    1110         usleep (delay_ms * 1000L);
    1111 #endif
    1112     }
    1113    
    1114     ufds.fd = io->fd;
    1115     ufds.events = POLLOUT;
    1116     ufds.revents = 0x0000;
    1117    
    1118     rval = poll (&ufds, 1, timeout_ms);
    1119     if (rval != 1)
    1120         return (FALSE);
    1121    
    1122     return (((ufds.revents) & POLLOUT) == POLLOUT);
     981      usleep (delay_ms * 1000L);
     982#endif
     983   }
     984
     985   out_fd=io->fd;
     986   
     987   FD_ZERO(&wfds);
     988   FD_SET(out_fd, &wfds);
     989   
     990   FD_ZERO(&ewfds);
     991   FD_SET(out_fd, &ewfds);
     992   
     993   tv.tv_sec = timeout_ms/1000L;
     994   tv.tv_usec = (timeout_ms % 1000) * 1000L;
     995
     996   select_ret = select(out_fd+1, NULL, &wfds, &ewfds, &tv);
     997
     998   if(select_ret==-1)
     999   {
     1000      printf("select_ret=%d\n" , select_ret);
     1001      printf("errno =%d\n", errno);
     1002      fflush(stdout);
     1003      return (FALSE);
     1004   }
     1005
     1006   if (FD_ISSET(out_fd, &ewfds))
     1007   {
     1008      printf("fd is in ewfds\n");
     1009      printf("errno =%d\n", errno);
     1010      fflush(stdout);
     1011      return (FALSE);
     1012   }
     1013
     1014   return(FD_ISSET(out_fd,&wfds));
     1015   
    11231016}
    11241017
     
    12041097        return FALSE;
    12051098
    1206 #ifdef OS_MACOSX
    1207     while ((i < IO_SERIAL_PNPID_SIZE) && IO_Serial_Read_MacOSX (io, 200, 1, &(io->PnP_id[i])))
    1208       i++;
    1209 #else   
    12101099    while ((i < IO_SERIAL_PNPID_SIZE) && IO_Serial_Read (io, 200, 1, &(io->PnP_id[i])))
    12111100      i++;
    1212 #endif
    12131101
    12141102    io->PnP_id_size = i;
  • trunk/module-camd33.c

    r8 r70  
    6363  }
    6464  if (client[cs_idx].crypted)
    65     aes_set_key(cfg->c33_key);
     65    aes_set_key((char *) cfg->c33_key);
    6666
    6767  mbuf[0]=0;
     
    7474    {
    7575      usr=mbuf+1;
    76       pwd=usr+strlen(usr)+2;
     76      pwd=usr+strlen((char *)usr)+2;
    7777    }
    7878    else
     
    8080  }
    8181  for (rc=-1, account=cfg->account; (usr) && (account) && (rc<0); account=account->next)
    82     if ((!strcmp(usr, account->usr)) && (!strcmp(pwd, account->pwd)))
     82    if ((!strcmp((char *)usr, account->usr)) && (!strcmp((char *)pwd, account->pwd)))
    8383      rc=cs_auth_client(account, NULL);
    8484  if (!rc)
  • trunk/module-camd35.c

    r56 r70  
    4040  crc=(ucrc[0]<<24) | (ucrc[1]<<16) | (ucrc[2]<<8) | ucrc[3];
    4141  for (account=cfg->account; (account) && (!upwd[0]); account=account->next)
    42     if (crc==crc32(0L, MD5(account->usr, strlen(account->usr), NULL), 16))
     42    if (crc==crc32(0L, MD5((unsigned char *)account->usr, strlen(account->usr), NULL), 16))
    4343    {
    4444      memcpy(client[cs_idx].ucrc, ucrc, 4);
    45       strcpy(upwd, account->pwd);
    46       aes_set_key(MD5(upwd, strlen(upwd), NULL));
     45      strcpy((char *)upwd, account->pwd);
     46      aes_set_key((char *) MD5(upwd, strlen((char *)upwd), NULL));
    4747      rc=cs_auth_client(account, NULL);
    4848    }
     
    288288static void casc_set_account()
    289289{
    290   strcpy(upwd, reader[ridx].r_pwd);
    291   memcpy(client[cs_idx].ucrc, i2b(4, crc32(0L, MD5(reader[ridx].r_usr, strlen(reader[ridx].r_usr), NULL), 16)), 4);
    292   aes_set_key(MD5(upwd, strlen(upwd), NULL));
     290  strcpy((char *)upwd, reader[ridx].r_pwd);
     291  memcpy(client[cs_idx].ucrc, i2b(4, crc32(0L, MD5((unsigned char *)reader[ridx].r_usr, strlen(reader[ridx].r_usr), NULL), 16)), 4);
     292  aes_set_key((char *)MD5(upwd, strlen((char *)upwd), NULL));
    293293  client[cs_idx].crypted=1;
    294294}
     
    464464  buf[i]=0;
    465465
    466   if (!(ptr=strstr(buf, " -> "))) return(-1);
     466  if (!(ptr=(uchar *)strstr((char *)buf, " -> "))) return(-1);
    467467  ptr+=4;
    468   if (strstr(ptr, " decoded ")) return(-1); // skip "found"s
    469   if (!(ptr2=strchr(ptr, ' '))) return(-1); // corrupt
     468  if (strstr((char *)ptr, " decoded ")) return(-1); // skip "found"s
     469  if (!(ptr2=(uchar *)strchr((char *)ptr, ' '))) return(-1);    // corrupt
    470470  *ptr2=0;
    471471 
    472   for (i=0, ptr2=strtok(ptr, ":"); ptr2; i++, ptr2=strtok(NULL, ":"))
    473   {
    474     trim(ptr2);
     472  for (i=0, ptr2=(uchar *)strtok((char *)ptr, ":"); ptr2; i++, ptr2=(uchar *)strtok(NULL, ":"))
     473  {
     474    trim((char *)ptr2);
    475475    switch(i)
    476476    {
    477       case 0: *caid  =cs_atoi(ptr2, strlen(ptr2)>>1, 0); break;
    478       case 1: *provid=cs_atoi(ptr2, strlen(ptr2)>>1, 0); break;
    479       case 2: *srvid =cs_atoi(ptr2, strlen(ptr2)>>1, 0); break;
    480       case 3: idx    =cs_atoi(ptr2, strlen(ptr2)>>1, 0); break;
     477      case 0: *caid  =cs_atoi((char *)ptr2, strlen((char *)ptr2)>>1, 0); break;
     478      case 1: *provid=cs_atoi((char *)ptr2, strlen((char *)ptr2)>>1, 0); break;
     479      case 2: *srvid =cs_atoi((char *)ptr2, strlen((char *)ptr2)>>1, 0); break;
     480      case 3: idx    =cs_atoi((char *)ptr2, strlen((char *)ptr2)>>1, 0); break;
    481481    }
    482482    if (errno) return(-1);
  • trunk/module-monitor.c

    r56 r70  
    6666  for (account=cfg->account; (account) && (!auth); account=account->next)
    6767    if ((account->monlvl) &&
    68        (crc==crc32(0L, MD5(account->usr, strlen(account->usr), NULL), 16)))
     68       (crc==crc32(0L, MD5((unsigned char *)account->usr, strlen(account->usr), NULL), 16)))
    6969    {
    7070      memcpy(client[cs_idx].ucrc, ucrc, 4);
    71       aes_set_key(MD5(account->pwd, strlen(account->pwd), NULL));
     71      aes_set_key((char *)MD5((unsigned char *)account->pwd, strlen(account->pwd), NULL));
    7272      if (cs_auth_client(account, NULL))
    7373        cs_exit(0);
     
    9797  l=boundary(4, l+5)+5;
    9898  memcpy(buf+1, client[idx].ucrc, 4);
    99   strcpy(buf+10, txt);
     99  strcpy((char *)buf+10, txt);
    100100  memcpy(buf+5, i2b(4, crc32(0L, buf+10, l-10)), 4);
    101101  aes_encrypt_idx(idx, buf+5, l-5);
     
    167167    monitor_check_ip();
    168168    buf[n]='\0';
    169     if ((p=strchr(buf, 10)) && (bpos=n-(p-buf)-1))
     169    if ((p=(uchar *)strchr((char *)buf, 10)) && (bpos=n-(p-buf)-1))
    170170    {
    171171      memcpy(bbuf, p+1, bpos);
     
    175175  }
    176176  buf[n]='\0';
    177   if (n=strlen(trim(buf)))
     177  if (n=strlen(trim((char *)buf)))
    178178    client[cs_idx].last=time((time_t *) 0);
    179179  return(n);
     
    405405  char *p;
    406406  if ((r_idx=cs_idx2ridx(idx))>=0)
    407     for (p=reader[r_idx].init_history; *p; p+=strlen(p)+1)
     407    for (p=(char *)reader[r_idx].init_history; *p; p+=strlen(p)+1)
    408408      monitor_send_details(p, pid);
    409409  else
     
    537537  client[cs_idx].typ='m';
    538538  while (((n=process_input(mbuf, sizeof(mbuf), cfg->cmaxidle))>=0) &&
    539            monitor_process_request(mbuf));
     539           monitor_process_request((char *)mbuf));
    540540  cs_disconnect_client();
    541541}
  • trunk/module-newcamd.c

    r66 r70  
    337337  // 1. Connect
    338338  //
    339   handle = network_tcp_connection_open(reader[ridx].device, reader[ridx].r_port);
     339  handle = network_tcp_connection_open((uint8 *)reader[ridx].device, reader[ridx].r_port);
    340340  if(handle < 0) return -1;
    341341 
     
    356356  buf[0] = MSG_CLIENT_2_SERVER_LOGIN;
    357357  buf[1] = 0;
    358   strcpy(buf+index, reader[ridx].r_usr);
     358  strcpy((char *)buf+index, reader[ridx].r_usr);
    359359  passwdcrypt = (uint8*)__md5_crypt(reader[ridx].r_pwd, "$1$abcdefgh$");
    360360  index += strlen(reader[ridx].r_usr)+1;
    361   strcpy(buf+index, passwdcrypt);
     361  strcpy((char *)buf+index, (const char *)passwdcrypt);
    362362
    363363  //cs_debug("login to server %s:%d user=%s, pwd=%s, len=%d", reader[ridx].device,
    364364  //          reader[ridx].r_port, reader[ridx].r_usr, reader[ridx].r_pwd,
    365365  //          index+strlen(passwdcrypt)+1);
    366   network_message_send(handle, 0, buf, index+strlen(passwdcrypt)+1, key,
     366  network_message_send(handle, 0, buf, index+strlen((char *)passwdcrypt)+1, key,
    367367                       COMMTYPE_CLIENT, 0x8888);
    368368
     
    387387  // 4. Send MSG_CARD_DATE_REQ
    388388  //
    389   key = des_login_key_get(reader[ridx].ncd_key, passwdcrypt, strlen(passwdcrypt));
     389  key = des_login_key_get(reader[ridx].ncd_key, passwdcrypt, strlen((char *)passwdcrypt));
    390390
    391391  network_cmd_no_data_send(handle, &reader[ridx].ncd_msgid, MSG_CARD_DATA_REQ,
     
    666666            }
    667667        usr=mbuf+5;
    668         pwd=usr+strlen(usr)+1;
     668        pwd=usr+strlen((char *)usr)+1;
    669669        //cs_debug("usr=%s,pwd=%s", usr, pwd);
    670670        }
     
    683683        {
    684684        cs_debug("account->usr=%s", account->usr);
    685         if (strcmp(usr, account->usr) == 0)
     685        if (strcmp((char *)usr, account->usr) == 0)
    686686            {
    687687            passwdcrypt = (uint8*)__md5_crypt(account->pwd, "$1$abcdefgh$");
    688688            cs_debug("account->pwd=%s", passwdcrypt);
    689             if (strcmp(pwd, passwdcrypt) == 0)
     689            if (strcmp((char *)pwd, (const char *)passwdcrypt) == 0)
    690690                {
    691691                client[cs_idx].crypted=1;
     
    751751        FILTER *pufilt = 0;
    752752
    753         key = des_login_key_get(cfg->ncd_key, passwdcrypt, strlen(passwdcrypt));
     753        key = des_login_key_get(cfg->ncd_key, passwdcrypt, strlen((char *)passwdcrypt));
    754754        memcpy(client[cs_idx].ncd_skey, key, 16);
    755755
  • trunk/module-radegast.c

    r8 r70  
    9696      case  6:      // PROVID (ASCII)
    9797        n=(sl>6) ? 3 : (sl>>1);
    98         er->prid=cs_atoi(buf+i+2+sl-(n<<1), n, 0);
     98        er->prid=cs_atoi((char *) buf+i+2+sl-(n<<1), n, 0);
    9999        break;
    100100      case  7:      // KEYNR (ASCII), not needed
  • trunk/module-serial.c

    r56 r70  
    378378                           {
    379379                             uchar b;
    380                              if (cs_atob(&b, buf+17, 1)<0)
     380                             if (cs_atob(&b, (char *)buf+17, 1)<0)
    381381                               p=(-2);
    382382                             else {
     
    429429            if( oscam_ser_selrec(buf, 2, l, &n) )
    430430            {
    431               if( cs_atoi(buf+n-2, 1, 1)==0xFFFFFFFF )
     431              if( cs_atoi((char *)buf+n-2, 1, 1)==0xFFFFFFFF )
    432432              {
    433433                switch( (buf[n-2]<<8)|buf[n-1] )
     
    439439              }else{
    440440                if( oscam_ser_selrec(buf, 2, l, &n) )
    441                   if( cs_atoi(buf+n-2, 1, 1)==0xFFFFFFFF )
     441                  if( cs_atoi((char *)buf+n-2, 1, 1)==0xFFFFFFFF )
    442442                    dsr9500type=P_DSR_UNKNOWN;
    443443                  else
     
    746746    case P_DSR95:
    747747      buf[l]='\0';  // prepare for trim
    748       trim(buf+13); // strip spc, nl, cr ...
    749       er->l=strlen(buf+13)>>1;
    750       er->prid=cs_atoi(buf+3, 3, 0);    // ignore errors
    751       er->caid=cs_atoi(buf+9, 2, 0);    // ignore errors
    752       if (cs_atob(er->ecm, buf+13, er->l)<0)
     748      trim((char *)buf+13); // strip spc, nl, cr ...
     749      er->l=strlen((char *)buf+13)>>1;
     750      er->prid=cs_atoi((char *)buf+3, 3, 0);    // ignore errors
     751      er->caid=cs_atoi((char *)buf+9, 2, 0);    // ignore errors
     752      if (cs_atob(er->ecm, (char *)buf+13, er->l)<0)
    753753      {
    754754        cs_log("illegal characters in ecm-request");
     
    758758      {
    759759        er->l-=2;
    760         er->srvid=cs_atoi(buf+13+(er->l<<1), 2, 0);
     760        er->srvid=cs_atoi((char *)buf+13+(er->l<<1), 2, 0);
    761761      }
    762762      break;
     
    932932      if( dsr9500type==P_DSR_WITHSID )
    933933      {
    934         sprintf(buf, "%c%08lX%04X%s%04X\n\r",
     934        sprintf((char *)buf, "%c%08lX%04X%s%04X\n\r",
    935935          3, er->prid, er->caid, cs_hexdump(0, er->ecm, er->l), er->srvid);
    936936        oscam_ser_send(buf, (er->l<<1)+19); // 1 + 8 + 4 + l*2 + 4 + 2
     
    938938      else
    939939      {
    940         sprintf(buf, "%c%08lX%04X%s\n\r",
     940        sprintf((char *)buf, "%c%08lX%04X%s\n\r",
    941941          3, er->prid, er->caid, cs_hexdump(0, er->ecm, er->l));
    942942        oscam_ser_send(buf, (er->l<<1)+15); // 1 + 8 + 4 + l*2 + 2
  • trunk/oscam-config.c

    r57 r70  
    443443  if (!strcmp(token, "password")) cs_atob(cfg->gbox_pwd, value, 4);
    444444  if (!strcmp(token, "maxdist")) cfg->maxdist=atoi(value);
    445   if (!strcmp(token, "ignorelist")) strncpy(cfg->ignorefile, value, sizeof(cfg->ignorefile)-1);
    446   if (!strcmp(token, "onlineinfos")) strncpy(cfg->gbxShareOnl, value, sizeof(cfg->gbxShareOnl)-1);
    447   if (!strcmp(token, "cardinfos")) strncpy(cfg->cardfile, value, sizeof(cfg->cardfile)-1);
     445  if (!strcmp(token, "ignorelist")) strncpy((char *)cfg->ignorefile, value, sizeof(cfg->ignorefile)-1);
     446  if (!strcmp(token, "onlineinfos")) strncpy((char *)cfg->gbxShareOnl, value, sizeof(cfg->gbxShareOnl)-1);
     447  if (!strcmp(token, "cardinfos")) strncpy((char *)cfg->cardfile, value, sizeof(cfg->cardfile)-1);
    448448  if (!strcmp(token, "locals"))
    449449  {
     
    530530      if (word_atob(trim(c_caid))!=caid) continue;
    531531      if ((i=(strlen(trim(c_key))>>1))>256) continue;
    532       if (cs_atob(key, c_key, i)<0)
     532      if (cs_atob((uchar *)key, c_key, i)<0)
    533533      {
    534534        cs_log("wrong key in \"%s\"", cs_cert);
     
    635635  if (!strcmp(token, "user")) strncpy(account->usr, value, sizeof(account->usr)-1);
    636636  if (!strcmp(token, "pwd")) strncpy(account->pwd, value, sizeof(account->pwd)-1);
    637   if (!strcmp(token, "hostname")) strncpy(account->dyndns, value, sizeof(account->dyndns)-1);
     637  if (!strcmp(token, "hostname")) strncpy((char *)account->dyndns, value, sizeof(account->dyndns)-1);
    638638  if (!strcmp(token, "betatunnel")) chk_tuntab(value, &account->ttab);
    639639  if (!strcmp(token, "uniq")) account->uniq=atoi(value);
     
    939939    }
    940940  }
    941   if (!strcmp(token, "password")) strncpy(rdr->gbox_pwd, i2b(4, a2i(value, 4)), 4);
     941  if (!strcmp(token, "password")) strncpy((char *)rdr->gbox_pwd, (const char *)i2b(4, a2i(value, 4)), 4);
    942942  if (!strcmp(token, "premium")) rdr->gbox_prem=1;
    943943  if (!strcmp(token, "account"))
  • trunk/oscam-log.c

    r66 r70  
    166166*/
    167167      if ((*log_fd) && (client[cs_idx].typ!='l') && (client[cs_idx].typ!='a'))
    168         write_to_pipe(*log_fd, PIP_ID_LOG, buf+8, strlen(buf+8));
     168        write_to_pipe(*log_fd, PIP_ID_LOG, (uchar *) buf+8, strlen(buf+8));
    169169      else
    170170        cs_write_log(buf+8);
  • trunk/oscam-reader.c

    r36 r70  
    3232  val=sizeof(reader[ridx].init_history)-reader[ridx].init_history_pos-1;
    3333  if (val>0)
    34     snprintf(reader[ridx].init_history+reader[ridx].init_history_pos, val, "%s", txt);
     34    snprintf((char *) reader[ridx].init_history+reader[ridx].init_history_pos, val, "%s", txt);
    3535  reader[ridx].init_history_pos+=strlen(txt)+1;
    3636#endif
  • trunk/oscam-simples.c

    r21 r70  
    55void aes_set_key(char *key)
    66{
    7   AES_set_decrypt_key(key, 128, &aeskey);
    8   AES_set_encrypt_key(key, 128, &client[cs_idx].aeskey);
     7  AES_set_decrypt_key((const unsigned char *)key, 128, &aeskey);
     8  AES_set_encrypt_key((const unsigned char *)key, 128, &client[cs_idx].aeskey);
    99}
    1010
  • trunk/oscam.c

    r56 r70  
    153153
    154154#ifdef NEED_DAEMON
     155#ifdef OS_MACOSX
     156// this is done because daemon is being deprecated starting with 10.5 and -Werror will always trigger an error
     157static int daemon_compat(int nochdir, int noclose)
     158#else
    155159static int daemon(int nochdir, int noclose)
     160#endif
    156161{
    157162  int fd;
     
    337342
    338343      if (account &&
    339           client[i].pcrc==crc32(0L, MD5(account->pwd, strlen(account->pwd), NULL), 16))
     344          client[i].pcrc==crc32(0L, MD5((uchar *)account->pwd, strlen(account->pwd), NULL), 16))
    340345      {
    341346        client[i].grp     = account->grp;
     
    840845      if (account->dyndns[0])
    841846      {
    842         if (rht=gethostbyname(account->dyndns))
     847        if (rht=gethostbyname((const char *)account->dyndns))
    843848        {
    844849          memcpy(&udp_sa.sin_addr, rht->h_addr, sizeof(udp_sa.sin_addr));
     
    9951000static void init_service(int srv)
    9961001{
     1002#ifdef USE_PTHREAD
     1003   uchar dummy[1]={0x00};
     1004#endif
     1005
    9971006  switch(cs_fork(0, srv))
    9981007  {
     
    10081017        case 96: start_anticascader();
    10091018#endif
     1019#ifdef USE_PTHREAD
     1020        case 97: cs_logger(dummy);
     1021#else
    10101022        case 97: cs_logger();
     1023#endif
    10111024        case 98: start_resolver();
    10121025      }
     
    10861099          client[cs_idx].sidtabok= account->sidtabok;   // services
    10871100          client[cs_idx].sidtabno= account->sidtabno;   // services
    1088           client[cs_idx].pcrc  = crc32(0L, MD5(account->pwd, strlen(account->pwd), NULL), 16);
     1101          client[cs_idx].pcrc  = crc32(0L, MD5((uchar *)account->pwd, strlen(account->pwd), NULL), 16);
    10891102          memcpy(&client[cs_idx].ttab, &account->ttab, sizeof(client[cs_idx].ttab));
    10901103#ifdef CS_ANTICASC
     
    18861899
    18871900  if (cfg->nice!=99)
    1888     sprintf(buf, ", nice=%d", cfg->nice);
     1901    sprintf((char *)buf, ", nice=%d", cfg->nice);
    18891902  else
    18901903    buf[0]='\0';
    1891   cs_log("version=%s, system=%s%s", CS_VERSION_X, cs_platform(buf+64), buf);
     1904  cs_log("version=%s, system=%s%s", CS_VERSION_X, cs_platform((char *)buf+64), buf);
    18921905  cs_log("max. clients=%d, client max. idle=%d sec",
    18931906#ifdef CS_ANTICASC
     
    18971910#endif
    18981911  if( cfg->max_log_size )
    1899     sprintf(buf, "%d Kb", cfg->max_log_size);
     1912    sprintf((char *)buf, "%d Kb", cfg->max_log_size);
    19001913  else
    1901     strcpy(buf, "unlimited");
     1914    strcpy((char *)buf, "unlimited");
    19021915  cs_log("max. logsize=%s", buf);
    19031916  cs_log("client timeout=%d sec, cache delay=%d msec",
     
    19851998  gfd=mfdr+1;
    19861999
     2000#ifdef OS_MACOSX
     2001  if (bg && daemon_compat(1,0))
     2002#else
    19872003  if (bg && daemon(1,0))
     2004#endif
    19882005  {
    19892006    cs_log("Error starting in background (errno=%d)", errno);
     
    20712088            {
    20722089              cs_set_mloc(-1, "event: udp-socket");
    2073               if ((n=recvfrom(ph[i].ptab->ports[j].fd, buf+3, sizeof(buf)-3, 0, (struct sockaddr *)&cad, &scad))>0)
     2090              if ((n=recvfrom(ph[i].ptab->ports[j].fd, buf+3, sizeof(buf)-3, 0, (struct sockaddr *)&cad, (socklen_t *)&scad))>0)
    20742091              {
    20752092                int idx;
     
    21182135            {
    21192136              cs_set_mloc(-1, "event: tcp-socket");
    2120               if ((pfd=accept(ph[i].ptab->ports[j].fd, (struct sockaddr *)&cad, &scad))>0)
     2137              if ((pfd=accept(ph[i].ptab->ports[j].fd, (struct sockaddr *)&cad, (socklen_t *)&scad))>0)
    21212138              {
    21222139                switch(cs_fork(cs_inet_order(cad.sin_addr.s_addr), ntohs(cad.sin_port)))
  • trunk/reader-cryptoworks.c

    r39 r70  
    242242    uchar keybuf[256];
    243243    BIGNUM *ipk;
    244     if (search_boxkey(reader[ridx].caid[0], 0, keybuf))
     244    if (search_boxkey(reader[ridx].caid[0], 0, (char *)keybuf))
    245245    {
    246246      ipk=BN_new();
     
    271271  if (read_record(0xC0)>=16)
    272272  {
    273     strncpy(issuer, cta_res+2, sizeof(issuer)-1);
     273    strncpy(issuer, (const char *)cta_res+2, sizeof(issuer)-1);
    274274    trim(issuer);
    275275  }
     
    282282  {
    283283    cta_res[6]=0;
    284     pin=cta_res+2;
     284    pin=(char *)cta_res+2;
    285285  }
    286286  cs_ri_log("issuer: %s, id: %02X, bios: v%d, pin: %s, mfid: %04X", issuer, issuerid, atr[7], pin, mfid);
     
    578578    if (read_record(0xD6)>=16)
    579579    {
    580       strncpy(l_name+8, cta_res+2, sizeof(l_name)-9);
     580      strncpy(l_name+8, (const char *)cta_res+2, sizeof(l_name)-9);
    581581      l_name[sizeof(l_name)]=0;
    582582      trim(l_name+8);
     
    598598          chid_date(cta_res+30, de, sizeof(de)-1);
    599599          cs_ri_log("chid: %02X%02X, date: %s - %s, name: %s",
    600                     cta_res[6], cta_res[7], ds, de, trim(cta_res+10));
     600                    cta_res[6], cta_res[7], ds, de, trim((char *) cta_res+10));
    601601        }
    602602      }
     
    619619          cta_res[27]=0;
    620620          cs_ri_log("chid: %02X%02X, date: %s - %s, name: %s",
    621                     cta_res[6], cta_res[7], ds, de, trim(cta_res+10));
     621                    cta_res[6], cta_res[7], ds, de, trim((char *)cta_res+10));
    622622        }
    623623      }
  • trunk/reader-irdeto.c

    r56 r70  
    361361        reader[ridx].prid[i][4]=p++;
    362362        memcpy(&reader[ridx].prid[i][0], cta_res, 4);
    363         sprintf(buf+strlen(buf), ",%06lx", b2i(3, &reader[ridx].prid[i][1]));
     363        sprintf((char *) buf+strlen((char *)buf), ",%06lx", b2i(3, &reader[ridx].prid[i][1]));
    364364      }
    365365      else
  • trunk/reader-seca.c

    r59 r70  
    137137        return(0);
    138138      else
    139     sprintf(buf+strlen(buf), ",%04lX", b2i(2, &reader[ridx].prid[i][2]));
     139    sprintf((char *) buf+strlen((char *)buf), ",%04lX", b2i(2, &reader[ridx].prid[i][2]));
    140140    }
    141141
     
    177177
    178178//  i=get_prov_index(er->ecm[3],er->ecm[4]);
    179   i=get_prov_index(er->ecm+3);
     179  i=get_prov_index((char *) er->ecm+3);
    180180  if ((i == -1) || (reader[ridx].availkeys[i][0] == 0)) //if provider not found or expired
    181181    return (0);
     
    218218    //first find out prov id
    219219//  i=get_prov_index(ep->emm[3],ep->emm[4]);
    220     i=get_prov_index(ep->emm+3);
     220    i=get_prov_index((char *) ep->emm+3);
    221221    if (i == -1)
    222222        return(0);
     
    252252            //first find out prov id
    253253//          i=get_prov_index(ep->emm[9],ep->emm[10]);
    254             i=get_prov_index(ep->emm+9);
     254            i=get_prov_index((char *) ep->emm+9);
    255255            if (i==-1)
    256256                return(0);
Note: See TracChangeset for help on using the changeset viewer.