getserial.c

au1200 linux2.6.11 硬件解码mae驱动和maiplayer播放器源码

      *errorCode = SERIAL_HOSTNAME_ERROR;
      return(NULL);
    }


   bcopy((char *)hp->h_addr,(char *)&server.sin_addr,hp->h_length);
   server.sin_port = htons(SEC_PORT);
   length=sizeof(struct sockaddr_in);
   
   // throw in random bits to hide command
   srand(time(NULL));
   for(i=0;i<COMMAND_SIZE;i++)
   {
        eserialNum[i] = rand() & 0xff;
   }
   
   // set the command to send to sec server
   eserialNum[COMMAND_OFFSET]=requestType;
   
   retryCount = 0;
   do
    {
      // make sure it doesn't loop forevery
      if (retryCount > RETRY_COUNT)
        {
          *errorCode = SERIAL_TOO_MANY_RETRY;
          return(NULL);
        }
        
      retryCount++;
      n=sendto(sock,eserialNum,COMMAND_SIZE,0,(const struct sockaddr *)&server,length);
      if (n < 0) 
        {
          *errorCode = SERIAL_SOCKET_ERROR;
           close(sock);
           return(NULL);
        }
      usleep(10000);  // sleep for 0.1 secs
      fds.fd=sock;
      fds.events |= POLLIN;
   
      pollrc=poll(&fds,1,1000);
    } while (!(fds.revents & POLLIN));

   if (pollrc < 0)
    {
      *errorCode = SERIAL_SOCKET_ERROR;
      return(NULL);
    }
      
   n = recvfrom(sock,retStr,STRING_MAX_LEN,0,(struct sockaddr *)&from, &length);
   if (n < 0) 
    {
      *errorCode = SERIAL_SOCKET_ERROR;
      close(sock);
      return(NULL);
    }

    found=1;
    close(sock);    
    return(retStr);
    
}
char *getModelStr(int *error_code)
{
  return(getDeviceStr(GET_MODEL_STRING,error_code));

}
char *getManufStr(int *error_code)
{
  return(getDeviceStr(GET_MANUF_STRING,error_code));

}

int getHwSecret(unsigned char **key, int *errorCode)
{
  
   static   unsigned char        hwSecret[HARDWARE_SECRET_SIZE];
   int                    sock, length, n;
   struct                 sockaddr_in server, from;
   struct                 hostent *hp;
   int                    i;
   static   int           found=0;
   char                   eserialNum[COMMAND_SIZE];

   char  localhost[] = "ybpnyubfg"; 
   struct pollfd   fds;
   int pollrc;  
   int     retryCount; 
 
   *errorCode = SERIAL_STATUS_OK;   
   (*key) = hwSecret;
   
   if (found)
    return(0);

   sock= socket(AF_INET, SOCK_DGRAM, 0);
   if (sock < 0) 
    {
      *errorCode = SERIAL_SOCKET_ERROR;
      return(-1);
    }

   server.sin_family = AF_INET;
   rot13(localhost);
   hp = gethostbyname(localhost);

   if (hp==0) 
    {
      *errorCode = SERIAL_HOSTNAME_ERROR;
      return(-1);
    }


   bcopy((char *)hp->h_addr,(char *)&server.sin_addr,hp->h_length);
   server.sin_port = htons(SEC_PORT);
   length=sizeof(struct sockaddr_in);
   
   bzero(hwSecret,sizeof(hwSecret));

   // throw in random bits to hide command
   srand(time(NULL));
   for(i=0;i<COMMAND_SIZE;i++)
   {
        eserialNum[i] = rand() & 0xff;
   }
   
   // set the command to send to sec server
   eserialNum[COMMAND_OFFSET]=GET_HARDWARE_SECRET;
   
   retryCount = 0;
   do
    {
      // make sure it doesn't loop forevery
      if (retryCount > RETRY_COUNT)
        {
          *errorCode = SERIAL_TOO_MANY_RETRY;
          return(-1);
        }
        
      retryCount++;
      n=sendto(sock,eserialNum,COMMAND_SIZE,0,(const struct sockaddr *)&server,length);
      if (n < 0) 
        {
          *errorCode = SERIAL_SOCKET_ERROR;
           close(sock);
           return(-1);
        }
      usleep(10000);  // sleep for 0.1 secs
      fds.fd=sock;
      fds.events |= POLLIN;
   
      pollrc=poll(&fds,1,1000);
    } while (!(fds.revents & POLLIN));

   if (pollrc < 0)
    {
      *errorCode = SERIAL_SOCKET_ERROR;
      return(-1);
    }
      
   n = recvfrom(sock,hwSecret,sizeof(hwSecret),0,(struct sockaddr *)&from, &length);
   if (n < 0) 
    {
      *errorCode = SERIAL_SOCKET_ERROR;
      close(sock);
      return(-1);
    }

    found=1;
    close(sock);    
    return(0);
    
}

//----------------------------
int loadDivxStore(unsigned char *data)
{
  
  int                    sock, length, n;
   
  struct                 sockaddr_in server, from;
  struct                 hostent *hp;
  int                    i;

  char  localhost[] = "ybpnyubfg";
  unsigned char eserialNum[COMMAND_SIZE];
  unsigned char newData[DIVX_STORE_SIZE+1];
   
   
  struct pollfd   fds;
  int pollrc;  
  int     retryCount; 
 
  sock = socket(AF_INET, SOCK_DGRAM, 0);
  if (sock < 0) 
  {
    return(SERIAL_SOCKET_ERROR);
  }

  server.sin_family = AF_INET;
  rot13(localhost);
  hp = gethostbyname(localhost);

  if (hp==0) 
  {
    return(SERIAL_HOSTNAME_ERROR);
  }


  bcopy((char *)hp->h_addr,(char *)&server.sin_addr,hp->h_length);
  server.sin_port = htons(SEC_PORT);
  length=sizeof(struct sockaddr_in);
   
  // throw in random bits to hide command
  srand(time(NULL));
  for(i=0;i<COMMAND_SIZE;i++)
  {
    eserialNum[i] = rand() & 0xff;
  }
   
  // set the command to send to sec server
  eserialNum[COMMAND_OFFSET]=GET_DIVX_DATA;
   
  retryCount = 0;
  do
  {
    // make sure it doesn't loop forevery
    if (retryCount > RETRY_COUNT)
    {
      return(SERIAL_TOO_MANY_RETRY);
    }
        
    retryCount++;
    n=sendto(sock,eserialNum,COMMAND_SIZE,0,(const struct sockaddr *)&server,length);
    if (n < 0) 
    {
      close(sock);
      return(SERIAL_SOCKET_ERROR);
    }
    usleep(10000);  // sleep for 0.1 secs
    fds.fd=sock;
    fds.events |= POLLIN;
   
    pollrc=poll(&fds,1,1000);
  } while (!(fds.revents & POLLIN));

  if (pollrc < 0)
  {
    return(SERIAL_SOCKET_ERROR);
  }
      
  n = recvfrom(sock,newData,DIVX_STORE_SIZE+1,0,(struct sockaddr *)&from, &length);
  if (n < 0) 
  {
    close(sock);
    return(SERIAL_SOCKET_ERROR);
  }
  if (newData[0] != SERIAL_STATUS_OK)
    return(newData[0]);

  memcpy(data,&newData[1],DIVX_STORE_SIZE);

  close(sock);    
  return(SERIAL_STATUS_OK);
    
}

//====
//----------------------------
int saveDivxStore(unsigned char *data)
{
  
   int                    sock, length, n;
   
   struct                 sockaddr_in server, from;
   struct                 hostent *hp;

   char  localhost[] = "ybpnyubfg";
   unsigned char divxStore[DIVX_STORE_SIZE+1];
   unsigned char ret[COMMAND_SIZE];
   
   struct pollfd   fds;
   int pollrc;  
   int     retryCount; 

   memcpy(&divxStore[1],data,DIVX_STORE_SIZE);
   divxStore[0] = SET_DIVX_DATA;
   sock = socket(AF_INET, SOCK_DGRAM, 0);
   if (sock < 0) 
    {
      return(SERIAL_SOCKET_ERROR);
    }

   server.sin_family = AF_INET;
   rot13(localhost);
   hp = gethostbyname(localhost);

   if (hp==0) 
    {
      return(SERIAL_HOSTNAME_ERROR);
    }


   bcopy((char *)hp->h_addr,(char *)&server.sin_addr,hp->h_length);
   server.sin_port = htons(SEC_PORT);
   length=sizeof(struct sockaddr_in);
   

   
   retryCount = 0;
   do
    {
      // make sure it doesn't loop forevery
      if (retryCount > RETRY_COUNT)
        {
          return(SERIAL_TOO_MANY_RETRY);
        }
        
      retryCount++;
      n=sendto(sock,divxStore,sizeof(divxStore),0,(const struct sockaddr *)&server,length);
      if (n < 0) 
        {
           close(sock);
           return(SERIAL_SOCKET_ERROR);
        }
      usleep(10000);  // sleep for 0.1 secs
      fds.fd=sock;
      fds.events |= POLLIN;
   
      pollrc=poll(&fds,1,1000);
    } while (!(fds.revents & POLLIN));

   if (pollrc < 0)
    {
      return(SERIAL_SOCKET_ERROR);
    }
      
   n = recvfrom(sock,ret,5,0,(struct sockaddr *)&from, &length);
   if (n < 0) 
    {
      close(sock);
      return(SERIAL_SOCKET_ERROR);
    }

    close(sock);

    return(ret[0]);
    
}