void rlm_liqcomp_RLMStart(void *ptr,const char *arg)
{
char address[17];
char section[256];
char errtext[256];
int i=1;
rlm_liqcomp_devs=0;
rlm_liqcomp_addresses=NULL;
rlm_liqcomp_ports=NULL;
rlm_liqcomp_masters=NULL;
rlm_liqcomp_aux1s=NULL;
rlm_liqcomp_aux2s=NULL;
sprintf(section,"System%d",i++);
strncpy(address,RLMGetStringValue(ptr,arg,section,"IpAddress",""),15);
if(strlen(address)==0) {
RLMLog(ptr,LOG_WARNING,"rlm_liqcomp: no encoder destinations specified");
return;
}
while(strlen(address)>0) {
rlm_liqcomp_addresses=
realloc(rlm_liqcomp_addresses,(rlm_liqcomp_devs+1)*(rlm_liqcomp_devs+1)*16);
strcpy(rlm_liqcomp_addresses+16*rlm_liqcomp_devs,address);
rlm_liqcomp_ports=realloc(rlm_liqcomp_ports,(rlm_liqcomp_devs+1)*sizeof(uint16_t));
rlm_liqcomp_ports[rlm_liqcomp_devs]=
RLMGetIntegerValue(ptr,arg,section,"UdpPort",0);
rlm_liqcomp_titles=realloc(rlm_liqcomp_titles,(rlm_liqcomp_devs+1)*256);
strncpy(rlm_liqcomp_titles+256*rlm_liqcomp_devs,
RLMGetStringValue(ptr,arg,section,"Title",""),256);
rlm_liqcomp_artists=realloc(rlm_liqcomp_artists,(rlm_liqcomp_devs+1)*256);
strncpy(rlm_liqcomp_artists+256*rlm_liqcomp_devs,
RLMGetStringValue(ptr,arg,section,"Artist",""),256);
rlm_liqcomp_albums=realloc(rlm_liqcomp_albums,(rlm_liqcomp_devs+1)*256);
strncpy(rlm_liqcomp_albums+256*rlm_liqcomp_devs,
RLMGetStringValue(ptr,arg,section,"Album",""),256);
rlm_liqcomp_labels=realloc(rlm_liqcomp_labels,(rlm_liqcomp_devs+1)*256);
strncpy(rlm_liqcomp_labels+256*rlm_liqcomp_devs,
RLMGetStringValue(ptr,arg,section,"Label",""),256);
rlm_liqcomp_masters=realloc(rlm_liqcomp_masters,
(rlm_liqcomp_devs+1)*sizeof(int));
rlm_liqcomp_masters[rlm_liqcomp_devs]=
rlm_liqcomp_GetLogStatus(ptr,arg,section,"MasterLog");
rlm_liqcomp_aux1s=realloc(rlm_liqcomp_aux1s,
(rlm_liqcomp_devs+1)*sizeof(int));
rlm_liqcomp_aux1s[rlm_liqcomp_devs]=
rlm_liqcomp_GetLogStatus(ptr,arg,section,"Aux1Log");
rlm_liqcomp_aux2s=realloc(rlm_liqcomp_aux2s,
(rlm_liqcomp_devs+1)*sizeof(int));
rlm_liqcomp_aux2s[rlm_liqcomp_devs]=
rlm_liqcomp_GetLogStatus(ptr,arg,section,"Aux2Log");
sprintf(errtext,"rlm_liqcomp: configured destination \"%s:%d\"",address,
rlm_liqcomp_ports[rlm_liqcomp_devs]);
rlm_liqcomp_devs++;
RLMLog(ptr,LOG_INFO,errtext);
sprintf(section,"System%d",i++);
strncpy(address,RLMGetStringValue(ptr,arg,section,"IpAddress",""),15);
}
}
void rlm_walltime_RLMStart(void *ptr,const char *arg)
{
char address[17];
char section[256];
char errtext[256];
int i=1;
rlm_walltime_devs=0;
rlm_walltime_addresses=NULL;
rlm_walltime_ports=NULL;
rlm_walltime_formats=NULL;
rlm_walltime_host_addresses=NULL;
rlm_walltime_masters=NULL;
rlm_walltime_aux1s=NULL;
rlm_walltime_aux2s=NULL;
sprintf(section,"Walltime%d",i++);
strncpy(address,RLMGetStringValue(ptr,arg,section,"IpAddress",""),15);
if(strlen(address)==0) {
RLMLog(ptr,LOG_WARNING,"rlm_walltime: no walltime destinations specified");
return;
}
while(strlen(address)>0) {
rlm_walltime_addresses=
realloc(rlm_walltime_addresses,(rlm_walltime_devs+1)*(rlm_walltime_devs+1)*16);
strcpy(rlm_walltime_addresses+16*rlm_walltime_devs,address);
rlm_walltime_ports=realloc(rlm_walltime_ports,(rlm_walltime_devs+1)*sizeof(uint16_t));
rlm_walltime_ports[rlm_walltime_devs]=
RLMGetIntegerValue(ptr,arg,section,"UdpPort",0);
rlm_walltime_formats=realloc(rlm_walltime_formats,(rlm_walltime_devs+1)*8192);
strncpy(rlm_walltime_formats+8192*rlm_walltime_devs,
RLMGetStringValue(ptr,arg,section,"FormatString",""),8192);
rlm_walltime_host_addresses=
realloc(rlm_walltime_host_addresses,(rlm_walltime_devs+1)*(rlm_walltime_devs+1)*16);
strncpy(rlm_walltime_host_addresses+16*rlm_walltime_devs,
RLMGetStringValue(ptr,arg,section,"HostAddress",""),15);
rlm_walltime_masters=realloc(rlm_walltime_masters,
(rlm_walltime_devs+1)*sizeof(int));
rlm_walltime_masters[rlm_walltime_devs]=
rlm_walltime_GetLogStatus(ptr,arg,section,"MasterLog");
rlm_walltime_aux1s=realloc(rlm_walltime_aux1s,
(rlm_walltime_devs+1)*sizeof(int));
rlm_walltime_aux1s[rlm_walltime_devs]=
rlm_walltime_GetLogStatus(ptr,arg,section,"Aux1Log");
rlm_walltime_aux2s=realloc(rlm_walltime_aux2s,
(rlm_walltime_devs+1)*sizeof(int));
rlm_walltime_aux2s[rlm_walltime_devs]=
rlm_walltime_GetLogStatus(ptr,arg,section,"Aux2Log");
sprintf(errtext,"rlm_walltime: configured destination \"%s:%d\"",address,
rlm_walltime_ports[rlm_walltime_devs]);
rlm_walltime_devs++;
RLMLog(ptr,LOG_INFO,errtext);
sprintf(section,"Walltime%d",i++);
strncpy(address,RLMGetStringValue(ptr,arg,section,"IpAddress",""),15);
}
}
void rlm_test_RLMStart(void *ptr,const char *arg)
{
char str[1024];
sprintf(str,"rlm_test: started on %s",
RLMDateTime(ptr,0,"MM/dd/yyyy at hh:mm:ss"));
RLMLog(ptr,LOG_NOTICE,str);
}
void rlm_spottrap_RLMPadDataSent(void *ptr,const struct rlm_svc *svc,
const struct rlm_log *log,
const struct rlm_pad *now,
const struct rlm_pad *next)
{
int i;
int flag=0;
char msg[1500];
for(i=0;i<rlm_spottrap_devs;i++) {
switch(log->log_mach) {
case 0:
flag=rlm_spottrap_masters[i];
break;
case 1:
flag=rlm_spottrap_aux1s[i];
break;
case 2:
flag=rlm_spottrap_aux2s[i];
break;
}
if((flag==1)||((flag==2)&&(log->log_onair!=0))) {
if((strcasecmp(now->rlm_group,rlm_spottrap_groups+16*i)==0)&&
(now->rlm_len>=rlm_spottrap_minimums[i])&&
(now->rlm_len<=rlm_spottrap_maximums[i])) {
const char *str=
RLMResolveNowNext(ptr,now,next,rlm_spottrap_formats+256*i);
RLMSendUdp(ptr,rlm_spottrap_addresses+i*16,rlm_spottrap_ports[i],
str,strlen(str));
snprintf(msg,1500,"rlm_spottrap: sending pad update: \"%s\"",
(const char *)str);
RLMLog(ptr,LOG_INFO,msg);
}
else {
const char *str=
RLMResolveNowNext(ptr,now,next,rlm_spottrap_default_formats+256*i);
RLMSendUdp(ptr,rlm_spottrap_addresses+i*16,rlm_spottrap_ports[i],
str,strlen(str));
snprintf(msg,1500,"rlm_spottrap: sending default pad update: \"%s\"",
(const char *)str);
RLMLog(ptr,LOG_INFO,msg);
}
}
}
}
void rlm_walltime_RLMPadDataSent(void *ptr,const struct rlm_svc *svc,
const struct rlm_log *log,
const struct rlm_pad *now,
const struct rlm_pad *next)
{
int i;
int flag=0;
char timer[1500];
FILE *f;
for(i=0;i<rlm_walltime_devs;i++) {
switch(log->log_mach) {
case 0:
flag=rlm_walltime_masters[i];
break;
case 1:
flag=rlm_walltime_aux1s[i];
break;
case 2:
flag=rlm_walltime_aux2s[i];
break;
}
if((flag==1)||((flag==2)&&(log->log_onair!=0))) {
f=fopen("/var/www/html/walltime/walltime.html","w");
if(now->rlm_len==0) {
snprintf(timer,1500,
"SP!RS!WU http://%s/walltime/walltime.html!",
rlm_walltime_host_addresses+16*i);
fprintf(f,"<body bgcolor=\"#000000\"> </body>");
}
else {
snprintf(timer,1500,
"SM D!PS %d!ST!WU http://%s/walltime/walltime.html!",
now->rlm_len/1000,
rlm_walltime_host_addresses+16*i);
fprintf(f,"%s\n",
RLMResolveNowNextEncoded(ptr,now,next,rlm_walltime_formats+8192*i,
RLM_ENCODE_XML));
}
fclose(f);
RLMSendUdp(ptr,rlm_walltime_addresses+i*16,rlm_walltime_ports[i],
timer,strlen(timer));
RLMLog(ptr,LOG_INFO,"rlm_walltime: sending pad update!");
}
}
}
void rlm_liqcomp_RLMPadDataSent(void *ptr,const char *svcname,int onair,
int lognum,const struct rlm_pad *now,
const struct rlm_pad *next)
{
int i;
int flag=0;
char fmt[1500];
char msg[1500];
for(i=0;i<rlm_liqcomp_devs;i++) {
switch(lognum) {
case 0:
flag=rlm_liqcomp_masters[i];
break;
case 1:
flag=rlm_liqcomp_aux1s[i];
break;
case 2:
flag=rlm_liqcomp_aux2s[i];
break;
}
if((flag==1)||((flag==2)&&(onair!=0))) {
snprintf(fmt,1500,"|%s|%s|%06u|%u|%s|%s|%s|\n",
rlm_liqcomp_titles+256*i,
rlm_liqcomp_artists+256*i,
now->rlm_cartnum,
now->rlm_len,
now->rlm_group,
rlm_liqcomp_albums+256*i,
rlm_liqcomp_labels+256*i);
const char *str=RLMResolveNowNext(ptr,now,next,fmt);
RLMSendUdp(ptr,rlm_liqcomp_addresses+i*16,rlm_liqcomp_ports[i],str,
strlen(str));
snprintf(msg,1500,"rlm_liqcomp: sending pad update: \"%s\"",
(const char *)str);
RLMLog(ptr,LOG_INFO,msg);
}
}
}
void rlm_inno713_RLMPadDataSent(void *ptr,const struct rlm_svc *svc,
const struct rlm_log *log,
const struct rlm_pad *now,
const struct rlm_pad *next)
{
int i;
int flag=0;
char msg[1500];
for(i=0;i<rlm_inno713_devs;i++) {
switch(log->log_mach) {
case 0:
flag=rlm_inno713_masters[i];
break;
case 1:
flag=rlm_inno713_aux1s[i];
break;
case 2:
flag=rlm_inno713_aux2s[i];
break;
}
if((flag==1)||((flag==2)&&(log->log_onair!=0))) {
rlm_inno713_SendString(ptr,now,next,"DPS",rlm_inno713_dynamicpss+256*i,
rlm_inno713_addresses+i*16,rlm_inno713_ports[i],
rlm_inno713_handles[i]);
rlm_inno713_SendString(ptr,now,next,"PS",rlm_inno713_pss+256*i,
rlm_inno713_addresses+i*16,rlm_inno713_ports[i],
rlm_inno713_handles[i]);
rlm_inno713_SendString(ptr,now,next,"TEXT",rlm_inno713_radiotexts+256*i,
rlm_inno713_addresses+i*16,rlm_inno713_ports[i],
rlm_inno713_handles[i]);
const char *str=RLMResolveNowNext(ptr,now,next,rlm_inno713_pss+256*i);
snprintf(msg,1500,"rlm_inno713: sending pad update: \"%s\"",str);
RLMLog(ptr,LOG_INFO,msg);
}
}
}
/*
void rlm_xmpad_RLMPadDataSent(void *ptr,const char *svcname,int onair,
int lognum,const struct rlm_pad *now,
const struct rlm_pad *next)
*/
void rlm_xmpad_RLMPadDataSent(void *ptr,const struct rlm_svc *svc,
const struct rlm_log *log,
const struct rlm_pad *now,
const struct rlm_pad *next)
{
int i;
int flag=0;
char str1[33];
char str2[33];
char msg[1500];
if(now->rlm_cartnum==0) { // Suppress null PAD frames
return;
}
for(i=0;i<rlm_xmpad_devs;i++) {
switch(log->log_mach) {
case 0:
flag=rlm_xmpad_masters[i];
break;
case 1:
flag=rlm_xmpad_aux1s[i];
break;
case 2:
flag=rlm_xmpad_aux2s[i];
break;
}
if((flag==1)||((flag==2)&&(log->log_onair!=0))) {
strncpy(str1,RLMResolveNowNext(ptr,now,next,rlm_xmpad_format1s+256*i),32);
str1[32]=0;
strncpy(str2,RLMResolveNowNext(ptr,now,next,rlm_xmpad_format2s+256*i),32);
str2[32]=0;
rlm_xmpad_SendPad(ptr,i,str1,str2,now->rlm_len);
snprintf(msg,1500,"rlm_xmpad: sending pad update: \"%s | %s\"",
(const char *)str1,(const char *)str2);
RLMLog(ptr,LOG_INFO,msg);
}
}
}
void rlm_inno713_RLMStart(void *ptr,const char *arg)
{
char address[17];
char section[256];
char errtext[256];
char device[256];
int speed;
int parity;
int wsize;
int i=1;
rlm_inno713_devs=0;
rlm_inno713_addresses=NULL;
rlm_inno713_ports=NULL;
rlm_inno713_handles=NULL;
rlm_inno713_dynamicpss=NULL;
rlm_inno713_masters=NULL;
rlm_inno713_aux1s=NULL;
rlm_inno713_aux2s=NULL;
sprintf(section,"Rds%d",i++);
strncpy(address,RLMGetStringValue(ptr,arg,section,"IpAddress",""),15);
strncpy(device,RLMGetStringValue(ptr,arg,section,"Device",""),256);
if((strlen(address)==0)&&(strlen(device)==0)) {
RLMLog(ptr,LOG_WARNING,"rlm_inno713: no RDS connections specified");
return;
}
while((strlen(address)>0)||(strlen(device)>0)) {
rlm_inno713_addresses=
realloc(rlm_inno713_addresses,
(rlm_inno713_devs+1)*(rlm_inno713_devs+1)*16);
strcpy(rlm_inno713_addresses+16*rlm_inno713_devs,address);
rlm_inno713_ports=realloc(rlm_inno713_ports,
(rlm_inno713_devs+1)*sizeof(uint16_t));
rlm_inno713_ports[rlm_inno713_devs]=
RLMGetIntegerValue(ptr,arg,section,"UdpPort",0);
speed=RLMGetIntegerValue(ptr,arg,section,"Speed",9600);
parity=RLMGetIntegerValue(ptr,arg,section,"Parity",0);
wsize=RLMGetIntegerValue(ptr,arg,section,"WordSize",8);
rlm_inno713_handles=realloc(rlm_inno713_handles,
(rlm_inno713_devs+1)*sizeof(int));
rlm_inno713_handles[rlm_inno713_devs]=
RLMOpenSerial(ptr,device,speed,parity,wsize);
rlm_inno713_dynamicpss=realloc(rlm_inno713_dynamicpss,(rlm_inno713_devs+1)*256);
strncpy(rlm_inno713_dynamicpss+256*rlm_inno713_devs,
RLMGetStringValue(ptr,arg,section,"DynamicPsString",""),256);
rlm_inno713_pss=realloc(rlm_inno713_pss,(rlm_inno713_devs+1)*256);
strncpy(rlm_inno713_pss+256*rlm_inno713_devs,
RLMGetStringValue(ptr,arg,section,"PsString",""),256);
rlm_inno713_radiotexts=realloc(rlm_inno713_radiotexts,
(rlm_inno713_devs+1)*256);
strncpy(rlm_inno713_radiotexts+256*rlm_inno713_devs,
RLMGetStringValue(ptr,arg,section,"RadiotextString",""),256);
rlm_inno713_masters=realloc(rlm_inno713_masters,
(rlm_inno713_devs+1)*sizeof(int));
rlm_inno713_masters[rlm_inno713_devs]=
rlm_inno713_GetLogStatus(ptr,arg,section,"MasterLog");
rlm_inno713_aux1s=realloc(rlm_inno713_aux1s,
(rlm_inno713_devs+1)*sizeof(int));
rlm_inno713_aux1s[rlm_inno713_devs]=
rlm_inno713_GetLogStatus(ptr,arg,section,"Aux1Log");
rlm_inno713_aux2s=realloc(rlm_inno713_aux2s,
(rlm_inno713_devs+1)*sizeof(int));
rlm_inno713_aux2s[rlm_inno713_devs]=
rlm_inno713_GetLogStatus(ptr,arg,section,"Aux2Log");
sprintf(errtext,"rlm_inno713: configured destination \"%s:%d\"",address,
rlm_inno713_ports[rlm_inno713_devs]);
RLMLog(ptr,LOG_INFO,errtext);
if(strlen(device)>0) {
if(rlm_inno713_handles[rlm_inno713_devs]<0) {
sprintf(errtext,"rlm_inno713: unable to open serial device \"%s\"",device);
}
else {
sprintf(errtext,"rlm_inno713: configured serial device \"%s\"",device);
}
RLMLog(ptr,LOG_INFO,errtext);
}
rlm_inno713_devs++;
sprintf(section,"Rds%d",i++);
strncpy(address,RLMGetStringValue(ptr,arg,section,"IpAddress",""),15);
strncpy(device,RLMGetStringValue(ptr,arg,section,"Device",""),256);
}
}
void rlm_xmpad_SendPad(void *ptr,int config,const char *line1,
const char *line2,int len)
{
char str[1024];
char sline1[17];
char sline2[17];
char flag1[1024];
char flag2[1024];
int i;
//
// Log it
//
sprintf(str,"rlm_xmpad: sending pad update: |%s|%s|%d|",line1,line2,len);
RLMLog(ptr,LOG_INFO,str);
//
// Generate Display Strings and Flags
//
strncpy(sline1,line1,16);
sline1[16]=0;
flag1[0]=0;
for(i=0;i<rlm_xmpad_display_size1s[config];i++) {
strcat(flag1,"1");
}
strncpy(sline2,line2,16);
sline2[16]=0;
flag2[0]=0;
for(i=0;i<rlm_xmpad_display_size2s[config];i++) {
strcat(flag2,"1");
}
//
// Generate PAD Data
// The B-4 packet
//
sprintf(str,"B-4%c%d%c%d%c%d%c%d%c%d%c%d%c%s%c%s%c%s%c%s%c%s%c%s%c%u\n",
RLM_XMPAD_DELIMITER,!(rlm_xmpad_recordings[config]),
RLM_XMPAD_DELIMITER,1,
RLM_XMPAD_DELIMITER,len/432,
RLM_XMPAD_DELIMITER,0,
RLM_XMPAD_DELIMITER,rlm_xmpad_display_size1s[config],
RLM_XMPAD_DELIMITER,rlm_xmpad_display_size2s[config],
RLM_XMPAD_DELIMITER,flag1,
RLM_XMPAD_DELIMITER,flag2,
RLM_XMPAD_DELIMITER,sline2,
RLM_XMPAD_DELIMITER,flag1,
RLM_XMPAD_DELIMITER,flag2,
RLM_XMPAD_DELIMITER,sline1,
RLM_XMPAD_DELIMITER,rlm_xmpad_ids[config]);
RLMSendSerial(ptr,rlm_xmpad_handles[config],str,strlen(str));
RLMSendSerial(ptr,rlm_xmpad_handles[config],str,strlen(str));
RLMSendSerial(ptr,rlm_xmpad_handles[config],str,strlen(str));
//
// The A4 Packet
//
sprintf(str,"A4%c%d%c%s\n",RLM_XMPAD_DELIMITER,1,RLM_XMPAD_DELIMITER,line1);
RLMSendSerial(ptr,rlm_xmpad_handles[config],str,strlen(str));
//
// The A5 Packet
//
sprintf(str,"A5%c%d%c%s\n",RLM_XMPAD_DELIMITER,1,RLM_XMPAD_DELIMITER,line2);
RLMSendSerial(ptr,rlm_xmpad_handles[config],str,strlen(str));
}
void rlm_xmpad_RLMStart(void *ptr,const char *arg)
{
int handle;
char device[256];
int speed;
int parity;
int wsize;
char section[256];
char errtext[256];
int i=1;
int interval;
rlm_xmpad_devs=0;
rlm_xmpad_ids=NULL;
rlm_xmpad_handles=NULL;
rlm_xmpad_recordings=NULL;
rlm_xmpad_format1s=NULL;
rlm_xmpad_format2s=NULL;
rlm_xmpad_display_size1s=NULL;
rlm_xmpad_display_size2s=NULL;
rlm_xmpad_masters=NULL;
rlm_xmpad_aux1s=NULL;
rlm_xmpad_aux2s=NULL;
sprintf(section,"Serial%d",i++);
strncpy(device,RLMGetStringValue(ptr,arg,section,"Device",""),256);
if(strlen(device)==0) {
RLMLog(ptr,LOG_WARNING,"rlm_xmpad: no serial devices specified");
return;
}
while(strlen(device)>0) {
speed=RLMGetIntegerValue(ptr,arg,section,"Speed",9600);
parity=RLMGetIntegerValue(ptr,arg,section,"Parity",0);
wsize=RLMGetIntegerValue(ptr,arg,section,"WordSize",8);
if((handle=RLMOpenSerial(ptr,device,speed,parity,wsize))>=0) {
rlm_xmpad_handles=realloc(rlm_xmpad_handles,
(rlm_xmpad_devs+1)*sizeof(int));
rlm_xmpad_handles[rlm_xmpad_devs]=handle;
rlm_xmpad_ids=realloc(rlm_xmpad_ids,(rlm_xmpad_devs+1)*sizeof(int));
rlm_xmpad_ids[rlm_xmpad_devs]=
RLMGetIntegerValue(ptr,arg,section,"ProgramID",0);
rlm_xmpad_format1s=realloc(rlm_xmpad_format1s,(rlm_xmpad_devs+1)*256);
strncpy(rlm_xmpad_format1s+256*rlm_xmpad_devs,
RLMGetStringValue(ptr,arg,section,"FormatString1",""),256);
rlm_xmpad_format2s=realloc(rlm_xmpad_format2s,(rlm_xmpad_devs+1)*256);
strncpy(rlm_xmpad_format2s+256*rlm_xmpad_devs,
RLMGetStringValue(ptr,arg,section,"FormatString2",""),256);
rlm_xmpad_display_size1s=realloc(rlm_xmpad_display_size1s,
(rlm_xmpad_devs+1)*sizeof(int));
rlm_xmpad_display_size1s[rlm_xmpad_devs]=
RLMGetIntegerValue(ptr,arg,section,"DisplaySize1",8);
rlm_xmpad_display_size2s=realloc(rlm_xmpad_display_size2s,
(rlm_xmpad_devs+1)*sizeof(int));
rlm_xmpad_display_size2s[rlm_xmpad_devs]=
RLMGetIntegerValue(ptr,arg,section,"DisplaySize2",10);
rlm_xmpad_recordings=realloc(rlm_xmpad_recordings,
(rlm_xmpad_devs+1)*sizeof(int));
rlm_xmpad_recordings[rlm_xmpad_devs]=
RLMGetBooleanValue(ptr,arg,section,"Recording",1);
rlm_xmpad_masters=realloc(rlm_xmpad_masters,
(rlm_xmpad_devs+1)*sizeof(int));
rlm_xmpad_masters[rlm_xmpad_devs]=
rlm_xmpad_GetLogStatus(ptr,arg,section,"MasterLog");
rlm_xmpad_aux1s=realloc(rlm_xmpad_aux1s,
(rlm_xmpad_devs+1)*sizeof(int));
rlm_xmpad_aux1s[rlm_xmpad_devs]=
rlm_xmpad_GetLogStatus(ptr,arg,section,"Aux1Log");
rlm_xmpad_aux2s=realloc(rlm_xmpad_aux2s,
(rlm_xmpad_devs+1)*sizeof(int));
rlm_xmpad_aux2s[rlm_xmpad_devs]=
rlm_xmpad_GetLogStatus(ptr,arg,section,"Aux2Log");
interval=RLMGetIntegerValue(ptr,arg,section,"HeartbeatInterval",30);
if(interval>0) {
RLMStartTimer(ptr,rlm_xmpad_devs,1000*interval,RLM_TIMER_REPEATING);
}
rlm_xmpad_devs++;
sprintf(errtext,"rlm_xmpad: opened device \"%s\"",device);
RLMLog(ptr,LOG_INFO,errtext);
}
else {
sprintf(errtext,"unable to open tty \"%s\"",device);
RLMLog(ptr,LOG_WARNING,errtext);
}
sprintf(section,"Serial%d",i++);
strncpy(device,RLMGetStringValue(ptr,arg,section,"Device",""),256);
}
}
void rlm_spottrap_RLMStart(void *ptr,const char *arg)
{
char address[17];
char section[256];
char errtext[256];
int i=1;
rlm_spottrap_devs=0;
rlm_spottrap_groups=NULL;
rlm_spottrap_addresses=NULL;
rlm_spottrap_minimums=NULL;
rlm_spottrap_maximums=NULL;
rlm_spottrap_ports=NULL;
rlm_spottrap_formats=NULL;
rlm_spottrap_default_formats=NULL;
rlm_spottrap_masters=NULL;
rlm_spottrap_aux1s=NULL;
rlm_spottrap_aux2s=NULL;
sprintf(section,"Rule%d",i++);
strncpy(address,RLMGetStringValue(ptr,arg,section,"IpAddress",""),15);
if(strlen(address)==0) {
RLMLog(ptr,LOG_WARNING,"rlm_spottrap: no rules specified");
return;
}
while(strlen(address)>0) {
rlm_spottrap_addresses=
realloc(rlm_spottrap_addresses,(rlm_spottrap_devs+1)*(rlm_spottrap_devs+1)*16);
strcpy(rlm_spottrap_addresses+16*rlm_spottrap_devs,address);
rlm_spottrap_groups=realloc(rlm_spottrap_groups,(rlm_spottrap_devs+1)*16);
strncpy(rlm_spottrap_groups+16*rlm_spottrap_devs,
RLMGetStringValue(ptr,arg,section,"GroupName",""),10);
rlm_spottrap_minimums=realloc(rlm_spottrap_minimums,(rlm_spottrap_devs+1)*sizeof(int));
rlm_spottrap_minimums[rlm_spottrap_devs]=
RLMGetIntegerValue(ptr,arg,section,"MinimumLength",0);
rlm_spottrap_maximums=realloc(rlm_spottrap_maximums,(rlm_spottrap_devs+1)*sizeof(int));
rlm_spottrap_maximums[rlm_spottrap_devs]=
RLMGetIntegerValue(ptr,arg,section,"MaximumLength",0);
rlm_spottrap_ports=realloc(rlm_spottrap_ports,(rlm_spottrap_devs+1)*sizeof(uint16_t));
rlm_spottrap_ports[rlm_spottrap_devs]=
RLMGetIntegerValue(ptr,arg,section,"UdpPort",0);
rlm_spottrap_formats=realloc(rlm_spottrap_formats,(rlm_spottrap_devs+1)*256);
strncpy(rlm_spottrap_formats+256*rlm_spottrap_devs,
RLMGetStringValue(ptr,arg,section,"FormatString",""),256);
rlm_spottrap_default_formats=realloc(rlm_spottrap_default_formats,
(rlm_spottrap_devs+1)*256);
strncpy(rlm_spottrap_default_formats+256*rlm_spottrap_devs,
RLMGetStringValue(ptr,arg,section,"DefaultFormatString",""),256);
rlm_spottrap_masters=realloc(rlm_spottrap_masters,
(rlm_spottrap_devs+1)*sizeof(int));
rlm_spottrap_masters[rlm_spottrap_devs]=
rlm_spottrap_GetLogStatus(ptr,arg,section,"MasterLog");
rlm_spottrap_aux1s=realloc(rlm_spottrap_aux1s,
(rlm_spottrap_devs+1)*sizeof(int));
rlm_spottrap_aux1s[rlm_spottrap_devs]=
rlm_spottrap_GetLogStatus(ptr,arg,section,"Aux1Log");
rlm_spottrap_aux2s=realloc(rlm_spottrap_aux2s,
(rlm_spottrap_devs+1)*sizeof(int));
rlm_spottrap_aux2s[rlm_spottrap_devs]=
rlm_spottrap_GetLogStatus(ptr,arg,section,"Aux2Log");
sprintf(errtext,"rlm_spottrap: configured rule for \"%s:%d\"",address,
rlm_spottrap_ports[rlm_spottrap_devs]);
rlm_spottrap_devs++;
RLMLog(ptr,LOG_INFO,errtext);
sprintf(section,"Rule%d",i++);
strncpy(address,RLMGetStringValue(ptr,arg,section,"IpAddress",""),15);
}
}
