retronetworking
/
isdn4k-utils
13
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
isdn4k-utils/isdnlog/tools/isdnconf.c

1769 lines
41 KiB
C
Raw Blame History

/* $Id: isdnconf.c,v 1.11 1997/05/25 19:41:13 luethje Exp $
*
* ISDN accounting for isdn4linux. (Utilities)
*
* Copyright 1995, 1997 by Andreas Kool (akool@Kool.f.EUnet.de)
* and Stefan Luethje (luethje@sl-gw.lake.de)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* $Log: isdnconf.c,v $
* Revision 1.11 1997/05/25 19:41:13 luethje
* isdnlog: close all files and open again after kill -HUP
* isdnrep: support vbox version 2.0
* isdnconf: changes by Roderich Schupp <roderich@syntec.m.EUnet.de>
* conffile: ignore spaces at the end of a line
*
* Revision 1.10 1997/05/15 22:21:45 luethje
* New feature: isdnrep can transmit via HTTP fax files and vbox files.
*
* Revision 1.9 1997/05/10 22:41:17 luethje
* bug in format string fixed
*
* Revision 1.8 1997/05/04 20:20:01 luethje
* README completed
* isdnrep finished
* interval-bug fixed
*
* Revision 1.7 1997/04/20 22:52:32 luethje
* isdnrep has new features:
* -variable format string
* -can create html output (option -w1 or ln -s isdnrep isdnrep.cgi)
* idea and design from Dirk Staneker (dirk.staneker@student.uni-tuebingen.de)
* bugfix of processor.c from akool
*
* Revision 1.6 1997/04/17 20:09:57 luethje
* patch of Ingo Schneider
*
*/
/****************************************************************************/
#define PUBLIC /**/
#define _ISDNCONF_C_
/****************************************************************************/
#include "tools.h"
/****************************************************************************/
static char ***Environment = NULL;
static char *OlabelPtr = NULL;
static char *IlabelPtr = NULL;
/****************************************************************************/
static char *NextItem(char *Line, int komma);
static char*NextOption(char** Options, char* Delim);
static void Append(char **Target, char*Source);
static int SetFlags(KNOWN *FlagPtr, char *flags);
static int IsVariable(char *string);
static int Set_Globals(section *SPtr);
static info_args** Set_Flags(section *SPtr, int *Flags);
static int Get_Events(char* Flags);
static int Set_Numbers(section *SPtr, char *Section, int msn);
static int Set_known_Size(int msn);
static section* writeentry(section *SPtr, int Index);
static int readconfigfile(char *_myname);
static int _readconfig(char *_myname);
static int readoldconfig(char *myname);
static section* writeinfoargs(section *SPtr, info_args *infoarg);
static void appendflag(char*str1, char*str2);
static char *writeflags(int flag);
static section* writevariables(section *SPtr);
static section* writeglobal(section *SPtr);
static int SetEnv(char ****EnvPtr, char *name, char *value);
static int GetNextEnv(char ***EnvPtr, char **name, char **value);
static int ClearEnv(char ****EnvPtr);
static int Set_ILabel(char *value);
static int Set_OLabel(char *value);
static char *Get_FmtStr(char *Ptr, char *name);
/****************************************************************************/
static char *NextItem(char *Line, int komma)
{
register char *p;
register char *Ptr = Line;
while (*Line && (*Line != ' ') && (*Line != '\t'))
Line++;
p = Line;
while ((*Line == ' ') || (*Line == '\t'))
Line++;
*p = 0;
p = Line;
while((Ptr = Check_Quote(Ptr, komma ? "\\$@;#" : S_QUOTES, QUOTE_DELETE)) != NULL);
return(Line);
} /* NextItem */
/******************************************************************************/
static char*NextOption(char** Options, char* Delim)
{
char *RetCode = NULL;
char *Ptr = *Options;
int Len;
*Delim = '\0';
if (Ptr == NULL)
return NULL;
if ((Ptr = Check_Quote(Ptr,";,",QUOTE_DELETE)) == NULL)
Ptr = "";
if (*Ptr == ',' || *Ptr == ';' || *Ptr == '\0')
{
*Delim = *Ptr;
if (Ptr != *Options)
{
Len = Ptr-(*Options);
RetCode = (char*) calloc(Len+1, sizeof(char));
strncpy(RetCode,*Options,Len);
}
if (*Ptr == ',')
{
*Options = Ptr+1;
}
else
{
while(!isalpha(*Ptr) && *Ptr != '\0')
Ptr++;
if (*Ptr == '\0')
*Options = NULL;
else
*Options = Ptr;
}
}
return RetCode;
}
/******************************************************************************/
static void Append(char **Target, char*Source)
{
if (*Target == NULL)
{
*Target = Source;
return;
}
if (Source == NULL)
return;
*Target = (char*) realloc(*Target, sizeof(char)*(strlen(*Target)+strlen(Source)+2));
strcat(*Target,",");
strcat(*Target,Source);
}
/******************************************************************************/
static int SetFlags(KNOWN *FlagPtr, char *flags)
{
auto char Delim = '\0';
auto char *Ptr;
auto int NumArgs = 0;
auto int flag = 0;
while (*flags == ' ' || *flags == '\t')
flags++;
FlagPtr->infoargs = NULL;
FlagPtr->flags = 0;
while (flags && *flags) {
flag = 0;
while(isalpha(*flags) || isspace(*flags))
{
switch (toupper(*flags++)) {
case 'I' : flag |= RING_INCOMING; break;
case 'O' : flag |= RING_OUTGOING; break;
case 'R' : flag |= RING_RING ; break;
case 'C' : flag |= RING_CONNECT ; break;
case 'B' : flag |= RING_BUSY ; break;
case 'A' : flag |= RING_AOCD ; break;
case 'E' : flag |= RING_ERROR ; break;
case 'H' : flag |= RING_HANGUP ; break;
case 'K' : flag |= RING_KILL ; break;
case 'L' : flag |= RING_LOOP ; break;
case 'S' : flag |= RING_SPEAK ; break;
case 'P' : flag |= RING_PROVIDER; break;
case 'U' : flag |= RING_UNIQUE ; break;
case ' ' : break;
case '\t': break;
default : _print_msg( "%s: WARNING: Unknown flag ``%c'' in file \"%s\" line %d, ignored\n", Myname, *(flags-1), OLDCONFFILE, ln);
break;
} /* switch */
}
if (flag != 0)
{
if(*flags == '=')
{
flags++;
FlagPtr->flags |= flag;
FlagPtr->infoargs = (info_args**) realloc(FlagPtr->infoargs, sizeof(info_args*) * (NumArgs+2));
FlagPtr->infoargs[NumArgs] = (info_args*) calloc(1, sizeof(info_args));
FlagPtr->infoargs[NumArgs]->flag = flag;
FlagPtr->infoargs[NumArgs]->infoarg = NextOption(&flags,&Delim);
if (Delim == ',')
{
if ((Ptr = NextOption(&flags,&Delim)) != NULL)
{
FlagPtr->infoargs[NumArgs]->interval= atoi(Ptr);
free(Ptr);
}
}
if (Delim == ',')
do
Append(&(FlagPtr->infoargs[NumArgs]->time),
NextOption(&flags,&Delim));
while(Delim == ',');
if (Delim != ';')
{
_print_msg( "%s: WARNING: Syntax-Error in file \"%s\" line %d, ignored (\";\" expected, but found \"%c\")\n", Myname, OLDCONFFILE, ln, Delim);
flags = NULL;
}
FlagPtr->infoargs[++NumArgs] = NULL;
}
else
{
_print_msg( "%s: WARNING: Syntax-Error in file \"%s\" line %d, ignored (\"=\" expected, but found \"%c\")\n", Myname, OLDCONFFILE, ln, *flags);
flags = NULL;
}
}
} /* while */
return 0;
}
/******************************************************************************/
static int IsVariable(char *string)
{
char s1[SHORT_STRING_SIZE] = "",
s2[LONG_STRING_SIZE] = "";
if (sscanf(string,"%[a-zA-Z0-9] = %[^\n]",s1,s2) == 2)
{
if (SetEnv(&Environment,s1,s2) == 0)
return 1;
_print_msg( "%s: WARNING: Error in file \"%s\" line %d: Can not set variable (%s)!\n", Myname, OLDCONFFILE, ln, strerror(errno));
}
return 0;
}
/****************************************************************************/
int writeconfig(char *_myname)
{
int i;
auto char s[BUFSIZ];
auto section *SPtr = NULL;
if ((SPtr = writevariables(SPtr)) == NULL)
{
free_section(SPtr);
return -1;
}
if ((SPtr = writeglobal(SPtr)) == NULL)
{
free_section(SPtr);
return -1;
}
sprintf(s, "%s%c%s", confdir(), C_SLASH, CONFFILE);
write_file(SPtr,s,_myname,VERSION);
free_section(SPtr);
SPtr = NULL;
for (i = 0; i < knowns; i++)
{
if ((SPtr = writeentry(SPtr,i)) == NULL)
{
free_section(SPtr);
return -1;
}
}
sprintf(s, "%s%c%s", confdir(), C_SLASH, CALLERIDFILE);
write_file(SPtr,s,_myname,VERSION);
free_section(SPtr);
return 0;
}
/****************************************************************************/
static void appendflag(char*str1, char*str2)
{
char delim[2];
delim[0] = C_FLAG_DELIM;
delim[1] = '\0';
if (str1[0] != '\0')
strcat(str1,delim);
strcat(str1,str2);
}
/****************************************************************************/
static char *writeflags(int flag)
{
static char string[BUFSIZ];
string[0] = '\0';
if (flag & RING_INCOMING)
appendflag(string,"I");
if (flag & RING_OUTGOING)
appendflag(string,"O");
if (flag & RING_RING)
appendflag(string,"R");
if (flag & RING_CONNECT)
appendflag(string,"C");
if (flag & RING_BUSY)
appendflag(string,"B");
if (flag & RING_AOCD)
appendflag(string,"A");
if (flag & RING_ERROR)
appendflag(string,"E");
if (flag & RING_HANGUP)
appendflag(string,"H");
if (flag & RING_KILL)
appendflag(string,"K");
if (flag & RING_LOOP)
appendflag(string,"L");
if (flag & RING_SPEAK)
appendflag(string,"S");
if (flag & RING_PROVIDER)
appendflag(string,"P");
if (flag & RING_UNIQUE)
appendflag(string,"U");
return string;
}
/****************************************************************************/
static section* writeinfoargs(section *SPtr, info_args *infoarg)
{
section *Ptr;
auto char s[BUFSIZ];
auto char s1[BUFSIZ];
strcpy(s, CONF_SEC_FLAG);
if ((Ptr = Set_Section(&SPtr,s,C_OVERWRITE | C_WARN | C_NOT_UNIQUE)) == NULL)
{
_print_msg("Can not set section `%s'!\n",CONF_SEC_FLAG);
free_section(SPtr);
return NULL;
}
sprintf(s1,"%d",infoarg->flag);
strcpy(s, CONF_ENT_FLAGS);
if (Set_Entry(Ptr,NULL,s,writeflags(infoarg->flag),C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_FLAGS);
free_section(SPtr);
return NULL;
}
strcpy(s, CONF_ENT_PROG);
if (Set_Entry(Ptr,NULL,s,infoarg->infoarg,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_PROG);
free_section(SPtr);
return NULL;
}
if (infoarg->user != NULL)
{
strcpy(s, CONF_ENT_USER);
if (Set_Entry(Ptr,NULL,s,infoarg->user,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_USER);
free_section(SPtr);
return NULL;
}
}
if (infoarg->group != NULL)
{
strcpy(s, CONF_ENT_GROUP);
if (Set_Entry(Ptr,NULL,s,infoarg->group,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_GROUP);
free_section(SPtr);
return NULL;
}
}
if (infoarg->interval != 0)
{
sprintf(s1,"%d",infoarg->interval);
strcpy(s, CONF_ENT_INTVAL);
if (Set_Entry(Ptr,NULL,s,s1,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_INTVAL);
free_section(SPtr);
return NULL;
}
}
if (infoarg->time != NULL)
{
strcpy(s, CONF_ENT_TIME);
if (Set_Entry(Ptr,NULL,s,infoarg->time,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_TIME);
free_section(SPtr);
return NULL;
}
}
return SPtr;
}
/****************************************************************************/
static section* writevariables(section *SPtr)
{
char *name;
char *value;
auto char s[BUFSIZ];
section *Ptr;
strcpy(s, CONF_SEC_VAR);
if ((Ptr = Set_Section(&SPtr,s,C_OVERWRITE | C_WARN)) == NULL)
{
_print_msg("Can not set section `%s'!\n",CONF_SEC_VAR);
free_section(SPtr);
return NULL;
}
if (GetNextEnv(Environment,&name,&value) == 0)
do
{
if (Set_Entry(Ptr,NULL,name,value,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",name);
free_section(SPtr);
return NULL;
}
}
while(GetNextEnv(NULL,&name,&value) == 0);
return SPtr;
}
/****************************************************************************/
static section* writeglobal(section *SPtr)
{
auto char s[BUFSIZ];
auto char s1[BUFSIZ];
int IIndex = 0;
section *Ptr;
section *SubPtr = NULL;
strcpy(s, CONF_SEC_GLOBAL);
if ((Ptr = Set_Section(&SPtr,s,C_OVERWRITE | C_WARN)) == NULL)
{
_print_msg("Can not set section `%s'!\n",CONF_SEC_GLOBAL);
free_section(SPtr);
return NULL;
}
if (mycountry != NULL && mycountry[0] != '\0')
{
strcpy(s, CONF_ENT_COUNTRY);
if (Set_Entry(Ptr,NULL,s,mycountry,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_COUNTRY);
free_section(SPtr);
return NULL;
}
}
if (myarea != NULL && myarea[0] != '\0')
{
strcpy(s, CONF_ENT_AREA);
if (Set_Entry(Ptr,NULL,s,myarea,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_AREA);
free_section(SPtr);
return NULL;
}
}
strcpy(s, CONF_SEC_ISDNLOG);
if ((Ptr = Set_Section(&SPtr,s,C_OVERWRITE | C_WARN)) == NULL)
{
_print_msg("Can not set section `%s'!\n",CONF_SEC_ISDNLOG);
free_section(SPtr);
return NULL;
}
if (reloadcmd != NULL)
{
strcpy(s, CONF_ENT_RELOAD);
if (Set_Entry(Ptr,NULL,s,reloadcmd,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_RELOAD);
free_section(SPtr);
return NULL;
}
}
if (stopcmd != NULL)
{
strcpy(s, CONF_ENT_STOP);
if (Set_Entry(Ptr,NULL,s,stopcmd,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_STOP);
free_section(SPtr);
return NULL;
}
}
if (rebootcmd != NULL)
{
strcpy(s, CONF_ENT_REBOOT);
if (Set_Entry(Ptr,NULL,s,rebootcmd,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_REBOOT);
free_section(SPtr);
return NULL;
}
}
if (chargemax != 0)
{
strcpy(s, CONF_ENT_CHARGE);
sprintf(s1, "%.2f",chargemax);
if (Set_Entry(Ptr,NULL,s,s1,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_CHARGE);
free_section(SPtr);
return NULL;
}
}
if (connectmax != 0)
{
strcpy(s, CONF_ENT_CONNECT);
sprintf(s1, "%.10g,%d",connectmax,connectmaxmode);
if (Set_Entry(Ptr,NULL,s,s1,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_CONNECT);
free_section(SPtr);
return NULL;
}
}
if (bytemax != 0)
{
strcpy(s, CONF_ENT_BYTE);
sprintf(s1, "%.10g,%d",bytemax,bytemaxmode);
if (Set_Entry(Ptr,NULL,s,s1,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_BYTE);
free_section(SPtr);
return NULL;
}
}
if (currency != NULL && currency_factor != 0)
{
strcpy(s, CONF_ENT_CURR);
sprintf(s1, "%.2f,%s",currency_factor,currency);
if (Set_Entry(Ptr,NULL,s,s1,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_CURR);
free_section(SPtr);
return NULL;
}
}
if (IlabelPtr != NULL)
{
strcpy(s, CONF_ENT_ILABEL);
if (Set_Entry(Ptr,NULL,s,IlabelPtr,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_ILABEL);
free_section(SPtr);
return NULL;
}
}
if (OlabelPtr != NULL)
{
strcpy(s, CONF_ENT_OLABEL);
if (Set_Entry(Ptr,NULL,s,OlabelPtr,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_OLABEL);
free_section(SPtr);
return NULL;
}
}
IIndex = 0;
if (start_procs.infoargs != NULL && start_procs.infoargs[0] != NULL)
{
while (start_procs.infoargs[IIndex] != NULL)
{
if ((SubPtr = writeinfoargs(SubPtr,start_procs.infoargs[IIndex])) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_SEC_START);
free_section(SPtr);
return NULL;
}
IIndex++;
}
strcpy(s, CONF_SEC_START);
if (Set_SubSection(Ptr,s,SubPtr,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_SEC_START);
free_section(SPtr);
return NULL;
}
}
return SPtr;
}
/****************************************************************************/
static section* writeentry(section *SPtr, int Index)
{
section *Ptr;
int IIndex = 0;
section *SubPtr = NULL;
auto char s[BUFSIZ];
auto char s1[BUFSIZ];
if (Index < mymsns)
strcpy(s,CONF_SEC_MSN);
else
strcpy(s,CONF_SEC_NUM);
if ((Ptr = Set_Section(&SPtr,s,C_OVERWRITE | C_WARN | C_NOT_UNIQUE)) == NULL)
{
_print_msg("Can not set section `%s'!\n",CONF_SEC_NUM);
free_section(SPtr);
return NULL;
}
strcpy(s, CONF_ENT_NUM);
if (Set_Entry(Ptr,NULL,s,known[Index]->num,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_NUM);
free_section(SPtr);
return NULL;
}
if (known[Index]->si != 0)
{
strcpy(s, CONF_ENT_SI);
sprintf(s1,"%d",known[Index]->si);
if (Set_Entry(Ptr,NULL,s,s1,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_SI);
free_section(SPtr);
return NULL;
}
}
strcpy(s, CONF_ENT_ALIAS);
if (Set_Entry(Ptr,NULL,s,known[Index]->who,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_ALIAS);
free_section(SPtr);
return NULL;
}
if (strcmp(known[Index]->interface,"-") != 0 && known[Index]->interface[0] != '\0')
{
strcpy(s, CONF_ENT_INTFAC);
if (Set_Entry(Ptr,NULL,s,known[Index]->interface,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_INTFAC);
free_section(SPtr);
return NULL;
}
}
strcpy(s, CONF_ENT_ZONE);
sprintf(s1,"%d",known[Index]->zone);
if (Set_Entry(Ptr,NULL,s,s1,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_ENT_ZONE);
free_section(SPtr);
return NULL;
}
IIndex = 0;
if (known[Index]->infoargs != NULL && known[Index]->infoargs[0] != NULL)
{
while (known[Index]->infoargs[IIndex] != NULL)
{
if ((SubPtr = writeinfoargs(SubPtr,known[Index]->infoargs[IIndex])) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_SEC_START);
free_section(SPtr);
return NULL;
}
IIndex++;
}
strcpy(s, CONF_SEC_START);
if (Set_SubSection(Ptr,s,SubPtr,C_OVERWRITE | C_WARN) == NULL)
{
_print_msg("Can not set entry `%s'!\n",CONF_SEC_START);
free_section(SPtr);
return NULL;
}
}
return SPtr;
}
/****************************************************************************/
void setDefaults()
{
if (currency == NULL) {
#if defined(ISDN_NL)
currency = "NLG";
#elif defined(ISDN_CH)
currency = "SFR";
#else
currency = "DM";
#endif
} /* if */
if (currency_factor == 0.0) {
#if defined(ISDN_NL)
currency_factor = 0.15;
#elif defined(ISDN_CH)
currency_factor = 0.01;
#else
currency_factor = 0.12;
#endif
} /* if */
currency_mode = AOC_UNITS;
} /* setDefaults */
/****************************************************************************/
int readconfig(char *_myname)
{
register int cc;
if (!(cc = readconfigfile(_myname)))
setDefaults();
return(cc);
} /* readconfig */
/****************************************************************************/
static int readconfigfile(char *_myname)
{
auto char file1[BUFSIZ];
auto char file2[BUFSIZ];
struct stat buf1, buf2;
int ret1, ret2;
if (use_new_config) {
sprintf(file1, "%s%c%s", confdir(), C_SLASH, CONFFILE);
ret1 = stat(file1,&buf1);
sprintf(file2, "%s%c%s", confdir(), C_SLASH, OLDCONFFILE);
ret2 = stat(file2,&buf2);
if (ret1 == 0)
{
if (access(file1,R_OK) == 0)
{
if (ret2 == 0 && access(file2,R_OK) == 0)
{
if (buf1.st_mtime >= buf2.st_mtime)
{
return _readconfig(_myname);
}
else
{
if (readoldconfig(_myname) == 0)
return writeconfig(_myname);
else
{
_print_msg("Can not read file %s!\n",file2);
return -1;
}
}
}
else
{
return _readconfig(_myname);
}
}
else
{
_print_msg("Can not read file %s!\n",file1);
return -1;
}
}
else
{
if (ret2 == 0 && access(file2,R_OK) == 0)
{
if (readoldconfig(_myname) == 0)
return writeconfig(_myname);
else
{
_print_msg("Can not read file %s!\n",file2);
return -1;
}
}
else
{
_print_msg("Can not read file %s!\n",file2);
return -1;
}
}
return 0;
}
else
return(readoldconfig(_myname));
}
/****************************************************************************/
section *read_isdnconf(section **_conf_dat)
{
read_conffiles(_conf_dat,NULL);
return *_conf_dat;
}
/****************************************************************************/
static int _readconfig(char *_myname)
{
auto section *SPtr;
auto int i;
int cur_msn = 0;
Myname = _myname;
mymsns = 0;
mycountry = "";
myarea = "";
currency = NULL;
chargemax = 0.0;
connectmax = 0;
connectmaxmode = 0;
bytemax = 0;
bytemaxmode = 0;
knowns = retnum = 0;
known = NULL;
reloadcmd = RELOADCMD;
stopcmd = STOPCMD;
rebootcmd = REBOOTCMD;
logfile = LOGFILE;
start_procs.infoargs = NULL;
start_procs.flags = 0;
conf_dat = NULL;
vboxpath = NULL;
vboxcommand1 = NULL;
vboxcommand2 = NULL;
mgettypath = NULL;
mgettycommand = NULL;
ClearEnv(&Environment);
if ((SPtr = read_isdnconf(&conf_dat)) == NULL)
return -1;
if (Replace_Variables(conf_dat) != 0)
return -1;
Set_Globals(conf_dat);
while (SPtr != NULL)
{
if (!strcmp(SPtr->name,CONF_SEC_MSN))
Set_Numbers(SPtr,SPtr->name,cur_msn++);
else
if (!strcmp(SPtr->name,CONF_SEC_NUM))
Set_Numbers(SPtr,SPtr->name,NO_MSN);
SPtr = SPtr->next;
}
for (i = 0; i < mymsns; i++)
if (known[i]->num == NULL)
{
_print_msg("Error: MSN number %d is not set!\n",i+1);
return -1;
}
return 0;
}
/****************************************************************************/
static char *Get_FmtStr(char *Ptr, char *name)
{
static char *RetCode = NULL;
char *ptr2;
if (*Ptr != '\"')
return Ptr;
free(RetCode);
ptr2 = RetCode = strdup(++Ptr);
while(*Ptr != '\"')
{
if (*Ptr == '\0')
{
_print_msg("Warning: Missing character `\"' at the end of entry `%s'!\n",name);
break;
}
if (*Ptr == '\\' && Ptr[1] == '\"')
Ptr++;
*ptr2++ = *Ptr++;
}
*ptr2 = '\0';
if (*Ptr == '\"')
Ptr++;
while(isspace(*Ptr)) Ptr++;
if (*Ptr != '\0')
_print_msg("Warning: Invalid token at the end of entry `%s'!\n",name);
return RetCode;
}
/****************************************************************************/
static int Set_Globals(section *SPtr)
{
auto int cnt = 0;
auto char ***sPtr = lineformats;
auto section *Ptr;
auto entry *CEPtr;
if (sPtr != NULL)
{
while (sPtr != NULL)
{
free(sPtr[0]);
free(sPtr[1]);
free(sPtr);
sPtr++;
}
free(lineformats);
}
if ((Ptr = Get_Section(SPtr,CONF_SEC_ISDNLOG)) != NULL)
{
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_ILABEL)) != NULL)
Set_ILabel(Get_FmtStr(CEPtr->value,CEPtr->name));
else
Set_ILabel(NULL);
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_OLABEL)) != NULL)
Set_OLabel(Get_FmtStr(CEPtr->value,CEPtr->name));
else
Set_OLabel(NULL);
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_START)) != NULL)
start_procs.infoargs = Set_Flags(CEPtr->subsection,&(start_procs.flags));
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_RELOAD)) != NULL)
reloadcmd = CEPtr->value;
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_STOP)) != NULL)
stopcmd = CEPtr->value;
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_REBOOT)) != NULL)
rebootcmd = CEPtr->value;
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_LOGFILE)) != NULL)
logfile = CEPtr->value;
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_CHARGE)) != NULL)
chargemax = strtod(CEPtr->value,NULL);
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_CONNECT)) != NULL)
{
if (sscanf(CEPtr->value,"%lg,%d", &connectmax, &connectmaxmode) != 2)
_print_msg("%s: WARNING: Syntax error in `%s' in Line %d, ignored\n", Myname, CONF_ENT_CONNECT, ln);
}
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_BYTE)) != NULL)
{
if (sscanf(CEPtr->value,"%lg,%d", &bytemax, &bytemaxmode) != 2)
_print_msg("%s: WARNING: Syntax error in `%s' in Line %d, ignored\n", Myname, CONF_ENT_CONNECT, ln);
}
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_CURR)) != NULL)
{
currency_factor = atof(CEPtr->value);
if ((currency = strchr(CEPtr->value, ',')) == NULL)
_print_msg("%s: WARNING: Syntax error in `%s' in Line %d, ignored\n", Myname, CONF_ENT_CURR, ln);
else
currency++;
}
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_VBOXPATH)) != NULL)
vboxpath = CEPtr->value;
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_VBOXCMD1)) != NULL)
vboxcommand1 = CEPtr->value;
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_VBOXCMD2)) != NULL)
vboxcommand2 = CEPtr->value;
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_MGTYPATH)) != NULL)
mgettypath = CEPtr->value;
if ((CEPtr = Get_Entry(Ptr->entries,CONF_ENT_MGTYCMD)) != NULL)
mgettycommand = CEPtr->value;
CEPtr = Ptr->entries;
cnt = 0;
while (CEPtr != NULL)
{
if (!strncmp(CEPtr->name,CONF_ENT_REPFMT,strlen(CONF_ENT_REPFMT)))
{
if ((lineformats = (char ***) realloc(lineformats,sizeof(char**)*(cnt+2))) == NULL)
{
_print_msg("%s: ERROR: Can not allocate memory!\n", Myname);
return 0;
}
if ((lineformats[cnt] = (char **) calloc(2,sizeof(char*))) == NULL)
{
_print_msg("%s: ERROR: Can not allocate memory!\n", Myname);
return 0;
}
if ((lineformats[cnt][0] = strdup(CEPtr->name+strlen(CONF_ENT_REPFMT))) == NULL)
{
_print_msg("%s: ERROR: Can not allocate memory!\n", Myname);
return 0;
}
if ((lineformats[cnt][1] = strdup(Get_FmtStr(CEPtr->value,CEPtr->name))) == NULL)
{
_print_msg("%s: ERROR: Can not allocate memory!\n", Myname);
return 0;
}
lineformats[++cnt] = NULL;
}
CEPtr = CEPtr->next;
}
}
else
_print_msg("%s: WARNING: There is no section `%s'!\n", Myname, CONF_SEC_ISDNLOG);
if (mycountry == NULL && mycountry[0] == '\0') {
_print_msg("%s: WARNING: Variable `%s' is not set!\n", Myname, CONF_ENT_COUNTRY);
mycountry = "";
}
if (myarea == NULL && myarea[0] == '\0')
{
_print_msg("%s: WARNING: Variable `%s' is not set!\n", Myname, CONF_ENT_AREA);
myarea = "";
}
if (chargemax == 0)
{
_print_msg("%s: WARNING: Variable `%s' is not set, \nperforming no action when chargemax-overflow\n", Myname, CONF_ENT_CHARGE);
}
return 0;
}
/****************************************************************************/
static info_args** Set_Flags(section *SPtr, int *Flags)
{
static int NumArgs;
info_args** RetCode = NULL;
entry* EPtr;
int Flag;
if (SPtr == NULL)
{
NumArgs = 0;
return NULL;
}
RetCode = Set_Flags(SPtr->next,Flags);
RetCode = realloc(RetCode, sizeof(info_args*) * (NumArgs+2));
RetCode[NumArgs] = (info_args*) calloc(1, sizeof(info_args));
EPtr = SPtr->entries;
while (EPtr != NULL)
{
if (!strcmp(EPtr->name,CONF_ENT_FLAGS))
{
if ((Flag = Get_Events(EPtr->value)) < 0)
_print_msg("Error: Invalid value of variable `%s'!\n",EPtr->name);
else
{
RetCode[NumArgs]->flag = Flag;
*Flags |= Flag;
}
}
else
if (!strcmp(EPtr->name,CONF_ENT_PROG))
{
RetCode[NumArgs]->infoarg = EPtr->value;
}
else
if (!strcmp(EPtr->name,CONF_ENT_USER))
{
RetCode[NumArgs]->user = EPtr->value;
}
else
if (!strcmp(EPtr->name,CONF_ENT_GROUP))
{
RetCode[NumArgs]->group = EPtr->value;
}
else
if (!strcmp(EPtr->name,CONF_ENT_INTVAL))
{
if (EPtr->value != NULL)
RetCode[NumArgs]->interval = atoi(EPtr->value);
}
else
if (!strcmp(EPtr->name,CONF_ENT_TIME))
{
RetCode[NumArgs]->time = EPtr->value;
}
else
_print_msg("Error: Invalid variable `%s'!\n",EPtr->name);
EPtr = EPtr->next;
}
RetCode[++NumArgs] = NULL;
return RetCode;
}
/****************************************************************************/
static int Get_Events(char* Flags)
{
int flag = 0, Index = 0;
while (*Flags != '\0')
{
while (isspace(*Flags) || *Flags == C_FLAG_DELIM) Flags++;
if (*Flags != '\0')
{
switch (toupper(*Flags))
{
case 'I' : flag |= RING_INCOMING; break;
case 'O' : flag |= RING_OUTGOING; break;
case 'R' : flag |= RING_RING ; break;
case 'C' : flag |= RING_CONNECT ; break;
case 'B' : flag |= RING_BUSY ; break;
case 'A' : flag |= RING_AOCD ; break;
case 'E' : flag |= RING_ERROR ; break;
case 'H' : flag |= RING_HANGUP ; break;
case 'K' : flag |= RING_KILL ; break;
case 'L' : flag |= RING_LOOP ; break;
case 'S' : flag |= RING_SPEAK ; break;
case 'P' : flag |= RING_PROVIDER; break;
case 'U' : flag |= RING_UNIQUE ; break;
default : _print_msg( "%s: WARNING: Unknown flag `%c' in file \"%s\" line %d, ignored\n", Myname, *Flags, CONFFILE, ln);
break;
} /* switch */
Flags++;
}
Index++;
}
return flag;
}
/****************************************************************************/
static int Set_Numbers(section *SPtr, char *Section, int msn)
{
auto entry *CEPtr;
auto char *num = 0, *who = 0;
auto int Index;
if ((CEPtr = Get_Entry(SPtr->entries,CONF_ENT_NUM)) != NULL)
num = CEPtr->value;
else
{
_print_msg("%s: ERROR: There is no variable `%s' in section `%s'!\n", Myname, CONF_ENT_NUM, Section);
num = S_UNKNOWN;
}
if ((CEPtr = Get_Entry(SPtr->entries,CONF_ENT_ALIAS)) != NULL)
who = CEPtr->value;
else
{
_print_msg("%s: ERROR: There is no variable `%s' in section `%s'!\n", Myname, CONF_ENT_ALIAS, Section);
who = S_UNKNOWN;
}
if (*num && *who) {
if ((Index = Set_known_Size(msn)) >= 0) {
known[Index]->num = num;
known[Index]->who = who;
known[Index]->day = -1;
known[Index]->charge = 0.0;
known[Index]->rcharge = 0.0;
known[Index]->scharge = 0.0;
known[Index]->month = -1;
known[Index]->online = 0.0;
known[Index]->sonline = 0.0;
known[Index]->bytes = 0.0;
known[Index]->sbytes = 0.0;
if ((CEPtr = Get_Entry(SPtr->entries,CONF_ENT_ZONE)) != NULL)
known[Index]->zone = atoi(CEPtr->value);
else
{
if (msn < 0)
{
_print_msg("%s: WARNING: There is no variable `%s' for number `%s'!\n", Myname, CONF_ENT_ZONE, num);
known[Index]->zone = 4;
}
else
known[Index]->zone = 1;
}
if ((CEPtr = Get_Entry(SPtr->entries,CONF_ENT_INTFAC)) != NULL)
known[Index]->interface = CEPtr->value;
else
known[Index]->interface = "-";
if ((CEPtr = Get_Entry(SPtr->entries,CONF_ENT_SI)) != NULL)
known[Index]->si = strtol(CEPtr->value, NIL, 0);
else
known[Index]->si = 0;
if ((CEPtr = Get_Entry(SPtr->entries,CONF_ENT_START)) != NULL)
known[Index]->infoargs = Set_Flags(CEPtr->subsection,&(known[Index]->flags));
else
known[Index]->infoargs = NULL;
}
else
{
_print_msg("%s: ERROR: Can not allocate memory!\n", Myname);
return -1;
}
}
return 0;
}
/****************************************************************************/
static int Set_known_Size(int msn)
{
int Index;
KNOWN **Ptr;
if (knowns == 0)
mymsns = 0;
if (msn < 0)
{
if ((known = (KNOWN **) realloc(known, sizeof(KNOWN *) * (knowns + 1))) == NULL)
return -1;
knowns++;
}
else
if (mymsns <= msn)
{
int NewKnowns = msn+knowns-mymsns+1;
if ((Ptr = (KNOWN **) calloc(NewKnowns, sizeof(KNOWN *))) == NULL)
return -1;
if (known != NULL)
{
memcpy(Ptr,known,sizeof(KNOWN*) * (mymsns));
memcpy(&(Ptr[msn+1]),&(known[mymsns]),sizeof(KNOWN*) * (knowns-mymsns));
free(known);
}
known = Ptr;
knowns= NewKnowns;
mymsns = msn+1;
}
if (msn < 0)
Index = knowns - 1;
else
Index = msn;
if ((known[Index] = (KNOWN *) calloc(1,sizeof(KNOWN))) == NULL)
return -1;
return Index;
}
/****************************************************************************/
static int readoldconfig(char *myname)
{
register char *p;
register int i;
auto int start_ln = 0;
auto FILE *f;
auto char s[BUFSIZ];
auto char *num, *who, *zone, *flags, *interface;
auto char *Ptr;
ln = 0;
mymsns = 3;
mycountry = "";
myarea = "";
currency = NULL;
chargemax = 0.0;
connectmax = 0.0;
bytemax = 0.0;
connectmaxmode = 0;
bytemaxmode = 0;
knowns = retnum = 0;
known = (KNOWN **)NULL;
start_procs.infoargs = NULL;
start_procs.flags = 0;
sprintf(s, "%s%c%s", confdir(), C_SLASH, OLDCONFFILE);
if ((f = fopen(s, "r")) != (FILE *)NULL) {
while (FGets(s, BUFSIZ, f, &ln) != NULL) {
if ((*s != '\0') && (*s != '\n')) {
if ((p = strchr(s, '\n'))) {
*p = 0;
while (*--p == ' ')
*p = 0;
} /* if */
if (!IsVariable(s))
{
num = s;
who = NextItem(num, 1);
zone = NextItem(who, 0);
interface = NextItem(zone, 0);
flags = NextItem(interface, 0);
if (*num && *who) {
known = realloc(known, sizeof(KNOWN *) * (knowns + 1));
if ((known[knowns] = (KNOWN *)malloc(sizeof(KNOWN)))) {
if ((p = strchr(num, ','))) { /* MSN,SI */
known[knowns]->si = atoi(p + 1);
*p = 0;
}
else
known[knowns]->si = 0;
known[knowns]->num = strdup(num);
known[knowns]->who = strdup(who);
known[knowns]->zone = atoi(zone);
known[knowns]->interface = strdup(interface);
known[knowns]->flags = 0;
SetFlags(known[knowns], flags);
known[knowns]->dur[CALLING] = known[knowns]->dur[CALLED] = 0.0;
known[knowns]->eh = 0;
known[knowns]->usage[DIALOUT] = known[knowns]->usage[DIALIN] = 0;
known[knowns]->dm = 0.0;
known[knowns]->day = -1;
known[knowns]->charge = 0.0;
known[knowns]->rcharge = 0.0;
known[knowns]->scharge = 0.0;
known[knowns]->month = -1;
known[knowns]->online = 0.0;
known[knowns]->sonline = 0.0;
known[knowns]->bytes = 0.0;
known[knowns]->sbytes = 0.0;
knowns++;
}
else {
_print_msg("%s: WARNING: Out of memory in Line %d\n", myname, ln);
break;
} /* else */
}
else {
_print_msg("%s: WARNING: Syntax error in Line %d, ignored\n", myname, ln);
/* break; */
} /* else */
} /* else */
else
if (start_ln == 0 && getenv(VAR_START) != NULL)
start_ln = ln;
} /* if */
} /* while */
fclose(f);
if ((Ptr = getenv(VAR_MYMSNS)) == NULL) {
_print_msg("%s: WARNING: Variable `%s' is not set, now is 3!\n", myname, VAR_MYMSNS);
mymsns = 3;
}
else
mymsns = atoi(Ptr);
if ((myarea = getenv(VAR_MYAREA)) == NULL)
_print_msg("%s: WARNING: Variable `%s' is not set!\n", myname, VAR_MYAREA);
if ((mycountry = getenv(VAR_MYCOUNTRY)) == NULL)
_print_msg("%s: WARNING: Variable `%s' is not set!\n", myname, VAR_MYCOUNTRY);
if ((Ptr = getenv(VAR_CURRENCY)) != NULL) {
currency_factor = atof(Ptr);
if ((currency = strchr(Ptr, ',')) == NULL)
_print_msg("%s: WARNING: Syntax error in `CURRENCY' in Line %d, ignored\n", myname, ln);
else
currency++;
}
if ((Ptr = getenv(VAR_CHARGEMAX)) == NULL)
_print_msg("%s: WARNING: Variable `%s' is not set, \nperforming no action when chargemax-overflow\n", myname, VAR_CHARGEMAX);
else
chargemax = strtod(Ptr, NULL);
if ((Ptr = getenv(VAR_CONNECTMAX)) == NULL)
_print_msg("%s: WARNING: Variable `%s' is not set, \nperforming no action when connectmax-overflow\n", myname, VAR_CONNECTMAX);
else {
if (sscanf(Ptr, "%lg,%d", &connectmax, &connectmaxmode) != 2)
_print_msg("%s: WARNING: Syntax error in `%s' in Line %d, ignored\n", Myname, VAR_CONNECTMAX, ln);
} /* else */
if ((Ptr = getenv(VAR_BYTEMAX)) == NULL)
_print_msg("%s: WARNING: Variable `%s' is not set, \nperforming no action when connectmax-overflow\n", myname, VAR_BYTEMAX);
else {
if (sscanf(Ptr, "%lg,%d", &bytemax, &bytemaxmode) != 2)
_print_msg("%s: WARNING: Syntax error in `%s' in Line %d, ignored\n", Myname, VAR_BYTEMAX, ln);
} /* else */
if ((Ptr = getenv(VAR_START)) != NULL) {
ln = start_ln;
SetFlags(&start_procs, Ptr);
}
Set_ILabel(getenv(VAR_ILABEL));
Set_OLabel(getenv(VAR_OLABEL));
/* Wenn eine unbekannte Varible kommt, stuerzt isdnlog einfach ab ;-) !!!!*/
if ((mycountry != NULL && mycountry[0] == '\0') &&
(myarea != NULL && myarea[0] == '\0') )
{
for (i = 0; i < mymsns; i++) {
if (known != NULL && known[i]->num != NULL) {
sprintf(s, "%s%s%s", mycountry, myarea, known[i]->num);
free(known[i]->num);
known[i]->num = strdup(s);
}
else
{
_print_msg("%s: ERROR: There are only %d MSN's, expected %d!\n",myname, i, mymsns);
return -1;
}
} /* for */
} /* if */
}
else
{
_print_msg("%s: WARNING: Can't open ``%s''\n", myname, s);
return -1;
}
return 0;
} /* readconfig */
/****************************************************************************/
void discardconfig(void)
{
register int i,j;
free_section(conf_dat);
ClearEnv(&Environment);
for (i = 0; i < knowns; i++) {
/* Unnoetig mit neuer readconfig
free(known[i]->num);
free(known[i]->who);
free(known[i]->interface);
*/
for (j = 0; known[i]->infoargs != NULL && known[i]->infoargs[j] != NULL; j++) {
/* Unnoetig mit neuer readconfig
free(known[i]->infoargs[j]->time);
free(known[i]->infoargs[j]->infoarg);
*/
free(known[i]->infoargs[j]);
}
free(known[i]->infoargs);
free(known[i]);
} /* for */
free(known);
currency = NULL;
mycountry = "";
myarea = "";
if (start_procs.infoargs != NULL)
{
int j;
for (j = 0; start_procs.infoargs != NULL && start_procs.infoargs[j] != NULL; j++) {
/* Unnoetig mit neuer readconfig
free(start_procs.infoargs[j]->time);
free(start_procs.infoargs[j]->infoarg);
*/
free(start_procs.infoargs[j]);
}
free(start_procs.infoargs);
}
} /* discardconfig */
/****************************************************************************/
static int SetEnv(char ****EnvPtr, char *name, char *value)
{
int elem = 2;
char ***CurEnvPtr = NULL;
if (setenv(name,value,1) != 0)
return -1;
if (!strcmp(name,CONF_ENT_AREA) || !strcmp(name,CONF_ENT_CURR) ||
!strcmp(name,CONF_ENT_START) || !strcmp(name,CONF_ENT_ILABEL) ||
!strcmp(name,CONF_ENT_OLABEL) || !strcmp(name,VAR_MYMSNS) ||
!strcmp(name,CONF_ENT_COUNTRY) || !strcmp(name,CONF_ENT_CHARGE) ||
!strcmp(name,CONF_ENT_RELOAD) || !strcmp(name,CONF_ENT_STOP) ||
!strcmp(name,CONF_ENT_REBOOT) || !strcmp(name,CONF_ENT_CONNECT)||
!strcmp(name,CONF_ENT_AREA) || !strcmp(name,CONF_ENT_CONNECT)||
!strcmp(name,CONF_ENT_BYTE) )
return 0;
CurEnvPtr = *EnvPtr;
if (CurEnvPtr != NULL)
while(*CurEnvPtr != NULL)
{
elem++;
CurEnvPtr++;
}
CurEnvPtr = NULL;
if ((*EnvPtr = (char***) realloc(*EnvPtr,sizeof(char**)*elem)) == NULL)
return -1;
(*EnvPtr)[elem-1] = NULL;
if (((*EnvPtr)[elem-2] = (char**) calloc(2,sizeof(char*))) == NULL)
return -1;
if (((*EnvPtr)[elem-2][0] = strdup(name)) == NULL)
return -1;
if (((*EnvPtr)[elem-2][1] = strdup(value)) == NULL)
return -1;
return 0;
}
/****************************************************************************/
static int GetNextEnv(char ***EnvPtr, char **name, char **value)
{
static char ***CurEnvPtr = NULL;
if (EnvPtr != NULL)
CurEnvPtr = EnvPtr;
else
{
if (CurEnvPtr == NULL || CurEnvPtr[0] == NULL)
return -1;
else
CurEnvPtr++;
}
if (CurEnvPtr[0] == NULL || CurEnvPtr[0][0] == NULL || CurEnvPtr[0][1] == NULL)
return -1;
*name = CurEnvPtr[0][0];
*value = CurEnvPtr[0][1];
return 0;
}
/****************************************************************************/
static int ClearEnv(char ****EnvPtr)
{
char ***CurEnvPtr = NULL;
CurEnvPtr = *EnvPtr;
if (CurEnvPtr == NULL)
return 0;
while(CurEnvPtr[0] != NULL)
{
free(CurEnvPtr[0][0]);
free(CurEnvPtr[0][1]);
free(CurEnvPtr[0]);
CurEnvPtr++;
}
free(*EnvPtr);
*EnvPtr = CurEnvPtr = NULL;
return 0;
}
/****************************************************************************/
static int Set_ILabel(char *value)
{
if ((IlabelPtr = value) == NULL)
IlabelPtr = "%b %e %T %ICall to tei %t from %N2 on %n2";
sprintf(ilabel, "%%s%s %%s%%s", IlabelPtr);
return 0;
}
/****************************************************************************/
static int Set_OLabel(char *value)
{
if ((OlabelPtr = value) == NULL)
OlabelPtr = "%b %e %T %Itei %t calling %N2 with %n2";
sprintf(olabel, "%%s%s %%s%%s", OlabelPtr);
return 0;
}
/****************************************************************************/
Reference in New Issue View Git Blame Copy Permalink