channel_buffer.c

// Copyright 2011 Google Inc. All Rights Reserved.
// Author: qianzhang@google.com (Qiann Zhang)

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <netdb.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <limits.h>
#include <assert.h>
#include <signal.h>
#include <sys/errno.h>
#include <features.h>
#include <sys/time.h>
#include <math.h>
#include <time.h>
#include <sys/timeb.h>
#include <sys/un.h>
#include <poll.h>
#include <pthread.h>
#include <dirent.h>
#include <dlfcn.h>
#include <stdarg.h>
#include <inttypes.h>
#include "channel_buffer.h"

#define sage_log(x)  _sagelog x
void _sagelog( int type, int level, const char* cstr, ... );

static const char* delimiter = " \t,;\r\n:=|'\"#";

static int is_delimiter( char ch )
{
  int i;
  if ( ch == 0 ) return 1;
  for ( i = 0; delimiter[i]; i++ )
    if ( ch == delimiter[i] ) return 1;
  return 0;
}

//format name:zzz (or name=zzzz)
int get_string( char*p, const char* name, char* string, int max_len, char **next )
{
  char *s, *e;
  e = p;

  while ( e != NULL && *e ) {
    s = strstr( e, name );
    if ( s == NULL )
      return 0;
    //is a token name
   if ( ((s > p && is_delimiter(*(s-1))) || s == p ) && is_delimiter( *(s+strlen(name)) )  ) {
      s += (int)strlen(name);
      while( *s && ( *s == ' ' || *s == '\t' ) )
        s++; //skip white space
      if ( *s == '=' || *s == ':' ) {
        s++;
        while( *s && ( *s == ' ' || *s == '\t' ) )
          s++; //skip white space
          if ( *s ) {
        int i=0;
            while ( i++<max_len && *s && *s != ' ' && *s != '\t' && *s != '\n' && *s != '\r')
            *string++ = *s++;

          *string = 0x0; //terminator
          if ( next != NULL ) {
            while (  *s && *s != ' ' && *s != '\t' && *s != '\n' && *s != '\r')
              s++;
            *next = s;
          }
          return 1;
        }
      }
    }
    e = ++s;
  }
  return 0;
}

//format name:"zzz" (or name="zzzz")
int get_string_with_quote( char*p, const char* name, char* string, int max_len, char **next )
{
  char *s, *e;
  e = p;

  while ( e != NULL && *e ) {
    s = strstr( e, name );
    if ( s == NULL ) return 0;
    //is a token name
    if ( ((s > p && is_delimiter(*(s-1))) || s == p ) && is_delimiter( *(s+strlen(name)) )  )  {
       s += (int)strlen(name);
    while( *s && ( *s == ' ' || *s == '\t' ) )
      s++; //skip white space
    if ( *s == '=' || *s == ':' ) {
      s++;
      while( *s && ( *s == ' ' || *s == '\t' ) )
        s++; //skip white space
        if ( *s == '\"' ) {
          int i=0;
          s++;
          while ( i++<max_len && *s && *s != '\"' )
            *string++ = *s++;

          *string = 0x0; //terminator

          if ( next != NULL) {
            while ( *s && *s != '\"' )
              s++;
            *next = s+1;
          }
          return 1;
        } else
          return 0;
      }
    }
    e = ++s;
  }
  return 0;
}

int get_string_token( char*p, int num, char* string, int max_len, char **next )
{
  int count = 0;
  char *s;
  s = p;
  if ( s == NULL )
    return 0;
  while ( *s )  {
    while( *s && ( *s == ' ' || *s == '\t' || *s == '\r' || *s == '\n' )  )
      s++; //skip white space
    if ( *s == 0 )
      break;

    if ( count++ != num ) {
      while( *s && !( *s == ' ' || *s == '\t' || *s == ';' || *s == ',' || *s == '\r' || *s == '\n' ) )
        s++; //skip a token
    } else {
      if ( *s )  {
        int i=0;
        while ( i++<max_len && *s && !( *s == ' ' || *s == '\t' || *s == ';' || *s == ',' || *s == '\r' || *s == '\n' ) )
          *string++ = *s++;

        *string = 0x0; //terminator
        if ( next != NULL ) {
          while (  *s && !( *s == ' ' || *s == '\t' || *s == '\r' || *s == '\n' ) )
            s++;
          *next = s;
        }
        return 1;
      }
    }
    if ( *s )
      s++;
  }
  return 0;
}

int get_int_val( char*p, const char* name, int* val, char** next )
{
  char *s, *e;
  e = p;
  while( e != NULL && *e ) {
    s = strstr( e, name );
    if ( s == NULL )
      return 0;
    //is a token name
    if ( ( (s > p && is_delimiter(*(s-1)) ) || s == p ) && is_delimiter( *(s+strlen(name)) )  ) {
      s += strlen(name);
      while( *s && ( *s == ' ' || *s == '\t' ) )
        s++; //skip white space
      if ( *s == '=' || *s == ':' ) {
        s++;
        while( *s && ( *s == ' ' || *s == '\t' ) )
          s++; //skip white space
        if ( *s ) {
          *val = atoi( s );
          if (*val < 0 && *s == '-' )
            s++;
          while( *s >= '0' && *s <= '9')
            s++;
          if ( next != NULL )
            *next = s;
          return 1;
        }
      }
    }
    e = ++s;
  }
  return 0;
}

//format: name val; ext
int get_cfg_val( char* string, char* name, int max_name_lenn, int* Val, char* ext, int max_ext_len )
{
  const char* delima = " \t,;\r\n";
  char *token, *saved_ptr;
  if ( name == NULL || ext == NULL || max_name_lenn == 0 || max_ext_len == 0 )
    return 0;

  name[0] = 0;
  *Val = 0;
  ext[0] = 0;;
  token = (char*)strtok_r( string, delima, &saved_ptr );
  if ( token != NULL )
    strncpy( name, token, max_name_lenn );
  token = (char*)strtok_r( saved_ptr, delima, &saved_ptr );
  if ( token != NULL ) {
    *Val = atoi( token); strncpy( ext, token, max_ext_len ); }
  token = (char*)strtok_r( saved_ptr, delima, &saved_ptr );
  if ( token != NULL )
    strncpy( ext, token, max_ext_len );
  return 1;
}

int make_channel_entry_buffer( struct channel_entry_t *ce, char *buf, int size )
{
  int pos = 0;
   pos += snprintf( buf+pos, size-pos, "ch:%03d state:%d ", ce->ch, ce->state );
  if ( ce->ctrl_bits )
    pos += snprintf( buf+pos, size-pos, "ctrl:%d ", ce->ctrl_bits );
  if ( ce->ch_name[0] )
    pos += snprintf( buf+pos, size-pos, "name:%s ", ce->ch_name );
  if ( ce->src_ip[0] )
    pos += snprintf( buf+pos, size-pos, "ip:%s port:%d ", ce->src_ip, ce->src_port);
  if ( ce->epg_id[0] )
    pos += snprintf( buf+pos, size-pos, "epg:%s ", ce->epg_id );
  if ( ce->dev_name[0] )
   pos += snprintf( buf+pos, size-pos, "dev:%s ", ce->dev_name );
  if ( ce->dev_tuning[0] )
    pos += snprintf( buf+pos, size-pos, "tune:%s ", ce->dev_tuning );
  if ( ce->av_inf[0] )
    pos += snprintf( buf+pos, size-pos, "av:\"%s\" ", ce->av_inf );
  if ( ce->ch_desc[0] )
    pos += snprintf( buf+pos, size-pos, "desc:%s ", ce->ch_desc );
  pos += snprintf( buf+pos, size-pos, "\n" );
  return pos;
}

int parse_channel_entry_t_buffer( struct channel_entry_t *ce, char* buf )
{
  int item = 0;
  char *p = buf;
  if ( !get_int_val( p, "ch", &ce->ch, NULL ) )
    ce->ch = -1;
  else
  if ( !get_int_val( p, "state", &ce->state, NULL ) )
    ce->ch = 1;
  else
    item++;
  if ( !get_int_val( p, "ctrl", &ce->ctrl_bits, NULL ) )
    ce->ctrl_bits = 0;
  else
    item++;
  if ( !get_string( p, "name", ce->ch_name, sizeof(ce->ch_name)-1, NULL ) )
    ce->ch_name[0] = 0x0;
  else
    item++;
  if ( !get_string( p, "desc", ce->ch_desc, sizeof(ce->ch_desc)-1, NULL ) )
    ce->ch_desc[0] = 0x0;
  else
   item++;
  if ( !get_string( p, "ip", ce->src_ip, sizeof(ce->src_ip)-1, NULL ) )
    ce->src_ip[0] = 0x0;
  else
    item++;
  if ( !get_int_val( p, "port", &ce->src_port, NULL ) )
    ce->src_port = -1;
  else
    item++;
  if ( !get_string( p, "epg", ce->epg_id, sizeof(ce->epg_id)-1, NULL ) )
    ce->epg_id[0] = 0x0;
  else
    item++;
  if ( !get_string( p, "dev", ce->dev_name, sizeof(ce->dev_name)-1, NULL ) )
    ce->dev_name[0] = 0x0;
  else
    item++;
  if ( !get_string( p, "tuning", ce->dev_tuning, sizeof(ce->dev_tuning)-1, NULL ) )
    ce->dev_tuning[0] = 0x0;
  else
    item++;
  if ( !get_string_with_quote( p, "av", ce->av_inf, sizeof(ce->av_inf)-1, NULL ) )
    ce->av_inf[0] = 0x0;
  else
    item++;
  if ( !get_string_with_quote( p, "desc", ce->ch_desc, sizeof(ce->ch_desc)-1, NULL ) )
    ce->ch_desc[0] = 0x0;
  else
    item++;

  return item;
}

struct channel_list_t* create_channel_list( int num )
{
  if ( num <= 0 )
    return NULL;
  struct channel_list_t *cl = malloc( sizeof( struct channel_list_t));
  if ( cl == NULL )
    return NULL;
  cl->num = num;
  cl->channel_num = 0;
  cl->ce = malloc( sizeof(struct channel_entry_t)*num );
  if ( cl->ce == NULL ) {
    free( cl );
    return NULL;
  }
  memset( cl->ce, 0x0, sizeof(struct channel_entry_t)*num );
  return cl;
}

void release_channel_list( struct channel_list_t *cl )
{
  if ( cl ) {
    if ( cl->ce )
      free( cl->ce );
    free( cl );
  }
}

struct channel_list_t* join_channel_list( struct channel_list_t* cl1, struct channel_list_t* cl2 )
{
  int i, n, channel_num;
  if ( cl1 == NULL )
    return cl2;
  if ( cl2 == NULL )
    return cl1;

  channel_num = cl1->channel_num + cl2->channel_num;
  if ( channel_num < cl1->num ) {
    n = 0;
    for ( i = cl1->channel_num; i<channel_num; i++ ) {
      cl1->ce[i] = cl2->ce[n++];
      cl1->ce[i].ch = i;
    }
    cl2->channel_num = channel_num;
    release_channel_list( cl2 );
    return cl1;
  } else if ( channel_num < cl2->num ) {
    n = 0;
    for ( i = cl2->channel_num; i<channel_num; i++ ) {
      cl2->ce[i] = cl1->ce[n++];
      cl2->ce[i].ch = i;
    }
    cl2->channel_num = channel_num;
    release_channel_list( cl1 );
    return cl2;
  } else {
    struct channel_list_t* cl = create_channel_list( channel_num );
    for ( i = 0; i<cl1->channel_num; i++ ) {
      cl->ce[i] = cl1->ce[i];
      cl->ce[i].ch = i;
    }
    for ( n = 0; n<cl2->channel_num; n++, i++ ) {
      cl->ce[i] = cl2->ce[n];
      cl->ce[i].ch = i;
    }
    release_channel_list( cl1 );
    release_channel_list( cl2 );
    cl->channel_num = channel_num;
    return cl;
  }
  return NULL;
}


struct channel_list_t* load_channel_entry( char* file_name )
{
  int item;
  int count = 0;
  char buf[2048]={0};
  struct channel_list_t *cl;
  FILE *fp;
  fp = fopen( file_name, "r" );
  if ( fp == NULL ) {
    //printf( "Can't open file %s to load channel table, errno:%d\n", file_name, errno );
   return NULL;
  }
  //count entry number
   while ( !feof(fp) ) {
     char* p = fgets( buf, sizeof(buf)-1, fp );
     if ( p == NULL )
       break;
     if ( buf[0] != '#' && strlen(buf) > 4 )
       count++;
    }
  fseek( fp, 0, SEEK_SET );
  cl = create_channel_list( count );
  while ( !feof(fp) && cl->channel_num < cl->num ) {
    char *p = fgets( buf, sizeof(buf)-1, fp );
    if ( p == NULL )
      break;

    //skip comments
    if ( buf[0] == '#' )
      continue;

    item = parse_channel_entry_t_buffer( &cl->ce[cl->channel_num], buf );
    if ( item > 0 ) {
      cl->channel_num++;
    }
  }
  fclose( fp );
  return cl;
}

int save_channel_entry( char* file_name, struct channel_list_t *cl )
{
  int i;
  char buf[2048];
  FILE *fp;
  if ( cl == NULL || cl->channel_num == 0 )
    return 0;

  fp = fopen( file_name, "w" );
  if ( fp == NULL ) {
    //printf( "Can't open file %s to save channel table, errno:%d\n", file_name, errno );
    return -1;
  }
  fputs( "#Google sagetv channel table ver 1.0., maxium 2048 bytes per line\n", fp );
  fprintf( fp, "total_channel:%d\n", cl->channel_num );
  for ( i = 0; i<cl->channel_num; i++ ) {
    make_channel_entry_buffer( &cl->ce[i], buf, sizeof(buf) );
   fputs( buf, fp );
  }
  fclose( fp );
  return 1;
}

char* join_alloc_string( char* str1, char* str2 )
{
  int len, len1, len2;
  char* str;
  if ( str1 == NULL )
    return str2;
  if ( str2 == NULL )
    return str1;
  len1 = strlen( str1 );
  len2 = strlen( str2 );
  len = len1 + len2;
  str = (char*)malloc( len+1 );
  strncpy( str, str1, len1 );
  strncpy( str+len1, str2, len2 );
  str[len] = 0x0;
  free( str1 );
  free( str2 );
  return str;
}