config_file.c

很少见的linux下的红外口的工具

/*      $Id: config_file.c,v 5.11 2002/07/01 18:54:01 lirc Exp $      */

/****************************************************************************
 ** config_file.c ***********************************************************
 ****************************************************************************
 *
 * config_file.c - parses the config file of lircd
 *
 * Copyright (C) 1998 Pablo d'Angelo <[e-mail]>
 *
 */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <errno.h>
#include <limits.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

#include "lircd.h"
#include "ir_remote.h"
#include "config_file.h"

#define LINE_LEN 1024

int line;
int parse_error;

void **init_void_array(struct void_array *ar,size_t chunk_size, size_t item_size)
{
        ar->chunk_size=chunk_size;
        ar->item_size=item_size;
	ar->nr_items=0;
        if(!(ar->ptr=calloc(chunk_size, ar->item_size))){
                logprintf(LOG_ERR,"out of memory");
                parse_error=1;
                return(NULL);
        }
	return(ar->ptr);
}

int add_void_array (struct void_array *ar, void * dataptr)
{
	void *ptr;

        if ((ar->nr_items%ar->chunk_size)==(ar->chunk_size)-1){
                /* I hope this works with the right alignment,
		   if not we're screwed */
                if (!(ptr=realloc(ar->ptr,ar->item_size*((ar->nr_items)+(ar->chunk_size+1))))){
                        logprintf(LOG_ERR,"out of memory");
                        parse_error=1;
                        return(0);
                }
		ar->ptr=ptr;
        }
        memcpy((ar->ptr)+(ar->item_size*ar->nr_items), dataptr, ar->item_size);
        ar->nr_items=(ar->nr_items)+1;
        memset((ar->ptr)+(ar->item_size*ar->nr_items), 0, ar->item_size);
        return(1);
}

inline void *get_void_array(struct void_array *ar)
{
        return(ar->ptr);
}

void *s_malloc(size_t size)
{
        void *ptr;
        if((ptr=malloc(size))==NULL){
                logprintf(LOG_ERR,"out of memory");
                parse_error=1;
                return(NULL);
        }
        memset(ptr, 0, size);
        return (ptr);
}

inline char *s_strdup(char * string)
{
        char *ptr;
        if(!(ptr=strdup(string))){
                logprintf(LOG_ERR,"out of memory");
                parse_error=1;
                return(NULL);
        }
        return (ptr);
}

inline ir_code s_strtocode(char *val)
{
	ir_code code=0;
	char *endptr;

	errno=0;
#       ifdef LONG_IR_CODE
	code=strtouq(val,&endptr,0);
	if((code==(unsigned long long) -1 && errno==ERANGE) ||
	    strlen(endptr)!=0 || strlen(val)==0)
	{
		logprintf(LOG_ERR,"error in configfile line %d:",line);
		logprintf(LOG_ERR,"\"%s\": must be a valid (unsigned long "
			  "long) number",val);
		parse_error=1;
		return(0);
	}
#       else
	code=strtoul(val,&endptr,0);
	if(code==ULONG_MAX && errno==ERANGE)
	{
		logprintf(LOG_ERR,"error in configfile line %d:",line);
		logprintf(LOG_ERR,"code is out of range");
		logprintf(LOG_ERR,"try compiling lircd with the LONG_IR_CODE "
			  "option");
		parse_error=1;
		return(0);
	}
	else if(strlen(endptr)!=0 || strlen(val)==0)
	{
		logprintf(LOG_ERR,"error in configfile line %d:",line);
		logprintf(LOG_ERR,"\"%s\": must be a valid (unsigned long) "
			  "number",val);
		parse_error=1;
		return(0);
	}
#       endif
	return(code);
}

unsigned long s_strtoul(char *val)
{
	unsigned long n;
	char *endptr;

	n=strtoul(val,&endptr,0);
	if(!*val || *endptr)
	{
		logprintf(LOG_ERR,"error in configfile line %d:",line);
		logprintf(LOG_ERR,"\"%s\": must be a valid (unsigned long) "
			  "number",val);
		parse_error=1;
		return(0);
	}
	return(n);
}

int s_strtoi(char *val)
{
	char *endptr;
	long n;
	int h;
	
	n=strtol(val,&endptr,0);
	h=(int) n;
	if(!*val || *endptr || n!=((long) h))
	{
		logprintf(LOG_ERR,"error in configfile line %d:",line);
		logprintf(LOG_ERR,"\"%s\": must be a valid (int) number",
			  val);
		parse_error=1;
		return(0);
	}
	return(h);
}

unsigned int s_strtoui(char *val)
{
	char *endptr;
	unsigned long n;
	unsigned int h;
	
	n=strtoul(val,&endptr,0);
	h=(unsigned int) n;
	if(!*val || *endptr || n!=((unsigned long) h))
	{
		logprintf(LOG_ERR,"error in configfile line %d:",line);
		logprintf(LOG_ERR,"\"%s\": must be a valid (unsigned int) "
			  "number",val);
		parse_error=1;
		return(0);
	}
	return(h);
}

lirc_t s_strtolirc_t(char *val)
{
	unsigned long n;
	lirc_t h;
	char *endptr;
	
	n=strtoul(val,&endptr,0);
	h=(lirc_t) n;
	if(!*val || *endptr || n!=((unsigned long) h))
	{
		logprintf(LOG_ERR,"error in configfile line %d:",line);
		logprintf(LOG_ERR,"\"%s\": must be a valid (lirc_t) "
			  "number",val);
		parse_error=1;
		return(0);
	}
	return(h);
}

int checkMode(int is_mode, int c_mode, char *error)
{
        if (is_mode!=c_mode)
	{
		logprintf(LOG_ERR,"fatal error in configfile line %d:",
			  line);
		logprintf(LOG_ERR,"\"%s\" isn't valid at this position",
			  error);
		parse_error=1;
		return(0);
	}
        return(1);
}

int addSignal(struct void_array *signals, char *val)
{
	lirc_t t;
	
	t=s_strtolirc_t(val);
	if(parse_error) return(0);
	if(!add_void_array(signals, &t)){
		return(0);
	}
        return(1);
}
	      
struct ir_ncode *defineCode(char *key, char *val, struct ir_ncode *code)
{
        code->name=s_strdup(key);
        code->code=s_strtocode(val);
#       ifdef LONG_IR_CODE
        LOGPRINTF(3,"      %-20s 0x%016llX",code->name, code->code);
#       else
        LOGPRINTF(3,"      %-20s 0x%016lX",code->name, code->code);
#       endif
        return(code);
}

int parseFlags(char *val)
{
        struct flaglist *flaglptr;
	int flags=0;
	char *flag,*help;

	flag=help=val;
	while(flag!=NULL)
	{
		while(*help!='|' && *help!=0) help++;
		if(*help=='|')
		{
			*help=0;help++;
		}
		else
		{
			help=NULL;
		}
	
		flaglptr=all_flags;
		while(flaglptr->name!=NULL){
			if(strcasecmp(flaglptr->name,flag)==0){
				flags=flags|flaglptr->flag;
				LOGPRINTF(3,"flag %s recognized",
					  flaglptr->name);
				break;
			}
			flaglptr++;
		}
		if(flaglptr->name==NULL)
		{
			logprintf(LOG_ERR,"error in configfile line %d:",
				  line);
			logprintf(LOG_ERR,"unknown flag: \"%s\"",flag);
			parse_error=1;
			return(0);
		}
		flag=help;
	}
	LOGPRINTF(2,"flags value: %d",flags);

        return(flags);
}

int defineRemote(char * key, char * val, char *val2, struct ir_remote *rem)
{
	if ((strcasecmp("name",key))==0){
		if(rem->name!=NULL) free(rem->name);
		rem->name=s_strdup(val);
		LOGPRINTF(1,"parsing %s remote",val);
		return(1);
	}
	else if ((strcasecmp("bits",key))==0){
		rem->bits=s_strtoi(val);
		return(1);
	}
	else if (strcasecmp("flags",key)==0){
		rem->flags|=parseFlags(val);
		return(1);
	}
	else if (strcasecmp("eps",key)==0){
		rem->eps=s_strtoi(val);
		return(1);
	}
	else if (strcasecmp("aeps",key)==0){
		rem->aeps=s_strtoi(val);
		return(1);
	}
	else if (strcasecmp("plead",key)==0){
		rem->plead=s_strtolirc_t(val);
		return(1);
	}
	else if (strcasecmp("ptrail",key)==0){
		rem->ptrail=s_strtolirc_t(val);
		return(1);
	}
	else if (strcasecmp("pre_data_bits",key)==0){
		rem->pre_data_bits=s_strtoi(val);
		return(1);
	}
	else if (strcasecmp("pre_data",key)==0){
		rem->pre_data=s_strtocode(val);
		return(1);
	}
	else if (strcasecmp("post_data_bits",key)==0){
		rem->post_data_bits=s_strtoi(val);
		return(1);
	}
	else if (strcasecmp("post_data",key)==0){
		rem->post_data=s_strtocode(val);
		return(1);
	}
	else if (strcasecmp("gap",key)==0){
		rem->gap=s_strtoul(val);
		return(1);
	}
	else if (strcasecmp("repeat_gap",key)==0){
		rem->repeat_gap=s_strtoul(val);
		return(1);
	}
	else if (strcasecmp("toggle_bit",key)==0){
		rem->toggle_bit=s_strtoi(val);
		return(1);
	}
	else if (strcasecmp("toggle_mask",key)==0){
		rem->toggle_mask=s_strtocode(val);
		return(1);
	}
	/* obsolete name */
	else if (strcasecmp("repeat_bit",key)==0){
		rem->toggle_bit=s_strtoi(val);
		return(1);
	}
	else if (strcasecmp("min_repeat",key)==0){
		rem->min_repeat=s_strtoi(val);
		return(1);
	}
	else if (strcasecmp("frequency",key)==0){
		rem->freq=s_strtoui(val);
		return(1);
	}
	else if (strcasecmp("duty_cycle",key)==0){
		rem->duty_cycle=s_strtoui(val);
		return(1);
	}
	else if (val2!=NULL)
	{
		if (strcasecmp("header",key)==0){
			rem->phead=s_strtolirc_t(val);
			rem->shead=s_strtolirc_t(val2);
			return(2);
		}
		else if (strcasecmp("three",key)==0){
			rem->pthree=s_strtolirc_t(val);
			rem->sthree=s_strtolirc_t(val2);
			return(2);
		}
		else if (strcasecmp("two",key)==0){
			rem->ptwo=s_strtolirc_t(val);
			rem->stwo=s_strtolirc_t(val2);
			return(2);
		}
		else if (strcasecmp("one",key)==0){
			rem->pone=s_strtolirc_t(val);
			rem->sone=s_strtolirc_t(val2);
			return(2);
		}
		else if (strcasecmp("zero",key)==0){