s32 build_deps (dictionary *dict, s32 A, s32 B, char *refstr, ocrMappable_t ***all_instances, ocrParamList_t ***inst_params) {
s32 i, j, k;
s32 low, high;
s32 l, h;
for (i = 0; i < iniparser_getnsec(dict); i++) {
// Go thru the secnames looking for instances of A
if (strncasecmp(inst_str[A], iniparser_getsecname(dict, i), strlen(inst_str[A]))==0) {
// For each secname, look up corresponding instance of A through id
read_range(dict, iniparser_getsecname(dict, i), "id", &low, &high);
for (j = low; j <= high; j++) {
// Parse corresponding dependences from secname
read_range(dict, iniparser_getsecname(dict, i), refstr, &l, &h);
// Connect A with B
// Using a rough heuristic for now: if |from| == |to| then 1:1, else all:all TODO: What else makes sense here?
if (h-l == high-low) {
k = l+j-low;
add_dependence(A, B, all_instances[A][j], inst_params[A][j], all_instances[B][k], inst_params[B][k], 0, 1);
} else {
for (k = l; k <= h; k++) {
add_dependence(A, B, all_instances[A][j], inst_params[A][j], all_instances[B][k], inst_params[B][k], k-l, h-l+1);
}
}
}
}
}
return 0;
}
void Test_iniparser_getsecname(CuTest *tc)
{
unsigned i;
char sec_name[32];
dictionary *dic;
/* NULL test */
CuAssertTrue(tc, iniparser_getsecname(NULL, 0) == NULL);
/* Empty dictionary */
dic = dictionary_new(10);
CuAssertPtrEquals(tc, NULL, iniparser_getsecname(dic, 0));
dictionary_del(dic);
/* Sections without entries dictionary */
dic = generate_dictionary(100, 0);
for (i = 0; i < 100; ++i) {
sprintf(sec_name, "sec%d", i);
CuAssertStrEquals(tc, sec_name, iniparser_getsecname(dic, i));
}
dictionary_del(dic);
/* Generic dictionary */
dic = generate_dictionary(10, 100);
for (i = 0; i < 10; ++i) {
sprintf(sec_name, "sec%d", i);
CuAssertStrEquals(tc, sec_name, iniparser_getsecname(dic, i));
}
dictionary_del(dic);
}
DialogRecepti::DialogRecepti(QWidget *parent) : QDialog(parent), ui(new Ui::DialogRecepti)
{
ui->setupUi(this);
ui->listWidget->setSelectionMode(QAbstractItemView::SingleSelection);
connect(ui->btnOpenFile,SIGNAL(clicked()),this,SLOT(onOpenFile()));
connect(ui->btnExit,SIGNAL(clicked()),this,SLOT(onExit()));
char * fn = new char[40];
strcpy(fn,"/sdcard/recepti/recepti.bet");
dict = iniparser_load(fn);
if(dict == NULL)
{
QMessageBox::information(this,"iniparser library",QString("Failed to load dictionary from file:\n%1").arg(fn));
return;
}
int n = iniparser_getnsec(dict);
//QMessageBox::information(this,QString("iniparser"),QString("%1 sections found from file: %2").arg(n).arg(fn));
if(n>0)
{
for(int i =0 ; i<n ; i++)
{
QString str(iniparser_getsecname(dict,i));
ui->listWidget->addItem(str.toUpper());
}
ui->listWidget->item(0)->setSelected(true);
}
}
void parseFile()
{
char key[MAX_KEY_SIZE];
int i;
taskCount = iniparser_getnsec(file);
tasks = (iniTask*) malloc(sizeof(iniTask) * taskCount);
for(i = 0; i < taskCount; ++i) {
sprintf(tasks[i].secname, "%s", iniparser_getsecname(file, i));
sprintf(key, "%s:%s", tasks[i].secname, T_E_MAX);
tasks[i].tEMax = iniparser_getdouble(file, key, 0);
sprintf(key, "%s:%s", tasks[i].secname, T_D_MAX);
tasks[i].tDMax = iniparser_getdouble(file, key, 0);
sprintf(key, "%s:%s", tasks[i].secname, T_P_MIN);
tasks[i].tPMin = iniparser_getdouble(file, key, 0);
sprintf(key, "%s:%s", tasks[i].secname, T_B);
tasks[i].tB = iniparser_getdouble(file, key, 0);
sprintf(key, "%s:%s", tasks[i].secname, PRIORITY);
tasks[i].prio = iniparser_getint(file, key, 0);
}
}
/*--------------------------------------------------------------------------*/
void iniparser_dump_ini(const dictionary * d, FILE * f)
{
int i ;
int nsec ;
const char * secname ;
if (d==NULL || f==NULL) return ;
nsec = iniparser_getnsec(d);
if (nsec<1) {
/* No section in file: dump all keys as they are */
for (i=0 ; i<d->size ; i++) {
if (d->key[i]==NULL)
continue ;
fprintf(f, "%s = %s\n", d->key[i], d->val[i]);
}
return ;
}
for (i=0 ; i<nsec ; i++) {
secname = iniparser_getsecname(d, i) ;
iniparser_dumpsection_ini(d, secname, f);
}
fprintf(f, "\n");
return ;
}
char* DeviceFunctionCfg_GetField( int FunctionNumber, char* FieldName, char* DeviceCfgPath )
{
char* ret = NULL;
char* Section = NULL;
char* Newline;
dictionary* Dict = iniparser_load( DeviceCfgPath );
Section = iniparser_getsecname( Dict, FunctionNumber );
ret = iniparser_getsecstring( Dict, Section, FieldName, NULL ) ;
if( ret != NULL )
{
Newline = strstr(ret, "\\n");
while( Newline != NULL )
{
if( *( Newline-1 ) != '\\' )
{
*Newline = ' ';
*(Newline+1) = '\n';
}
Newline = strstr(ret, "\\n");
}
ret = strdup( ret );
}
iniparser_freedict( Dict );
return ret;
}
static int mod_init(void)
{
int ld_count = 0, i = 0;
char* section_name;
char* ldap_version;
LM_INFO("LDAP_H350 module - initializing\n");
/*
* read config file
*/
if (strlen(ldap_config.s) == 0)
{
LM_ERR("config_file is empty - this module param is mandatory\n");
return -2;
}
if ((config_vals = iniparser_new(ldap_config.s)) == NULL)
{
LM_ERR("failed to read config_file [%s]\n", ldap_config.s);
return -2;
}
if ((ld_count = iniparser_getnsec(config_vals)) < 1)
{
LM_ERR("no section found in config_file [%s]\n", ldap_config.s);
return -2;
}
/* check if mandatory settings are present */
for (i = 0; i < ld_count; i++)
{
section_name = iniparser_getsecname(config_vals, i);
if (strlen(section_name) > 255)
{
LM_ERR( "config_file section name [%s]"
" longer than allowed 255 characters",
section_name);
return -2;
}
if (!iniparser_find_entry(config_vals,
get_ini_key_name(section_name, CFG_N_LDAP_HOST)))
{
LM_ERR( "mandatory %s not defined in [%s]\n",
CFG_N_LDAP_HOST,
section_name);
return -2;
}
}
/*
* print ldap version string
*/
if (ldap_get_vendor_version(&ldap_version) != 0)
{
LM_ERR("ldap_get_vendor_version failed\n");
return -2;
}
LM_INFO("%s\n", ldap_version);
return 0;
}
/* Load layer configurations from disk */
bool buxton_init_layers(void)
{
bool ret = false;
dictionary *ini;
char *path;
int nlayers = 0;
path = DEFAULT_CONFIGURATION_FILE;
ini = iniparser_load(path);
if (ini == NULL) {
buxton_log("Failed to load buxton conf file: %s\n", path);
goto finish;
}
nlayers = iniparser_getnsec(ini);
if (nlayers <= 0) {
buxton_log("No layers defined in buxton conf file: %s\n", path);
goto end;
}
_layers = hashmap_new(string_hash_func, string_compare_func);
if (!_layers)
goto end;
for (int n = 0; n < nlayers; n++) {
BuxtonLayer *layer;
char *section_name;
layer = malloc0(sizeof(BuxtonLayer));
if (!layer)
continue;
section_name = iniparser_getsecname(ini, n);
if (!section_name) {
buxton_log("Failed to find section number: %d\n", n);
continue;
}
if (!parse_layer(ini, section_name, layer)) {
free(layer);
buxton_log("Failed to load layer: %s\n", section_name);
continue;
}
hashmap_put(_layers, layer->name, layer);
}
ret = true;
end:
iniparser_freedict(ini);
finish:
return ret;
}
static int VdecVdis_getCfgArray(dictionary *ini, VdecVdis_Config *cfg)
{
UInt32 totalChnlNum,i;
char temp[256];
char *name;
totalChnlNum = iniparser_getnsec(ini);
cfg->fileNum = totalChnlNum;
printf(" *** a new param codec is needed for ini, if you not sure about this\n");
printf(" *** please reference demo_ini/704x576_02_32CH.ini \n");
printf(" *** H264: codec = h264\n");
printf(" *** MPEG4: codec = mpeg4\n");
printf(" *** MJPEG: codec = mjpeg\n");
printf(" *** Two new params numbuf & displaydelay has been added for ini, if not defaults are set\n");
for (i = 0; i < totalChnlNum; i++)
{
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_PATH);
name = iniparser_getstring(ini,temp,NULL);
strcpy(cfg->fileInfo[i].path,name);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_WIDTH);
cfg->fileInfo[i].width = iniparser_getint(ini,temp,0);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_HEIGHT);
cfg->fileInfo[i].height = iniparser_getint(ini,temp,0);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_ENABLE);
cfg->fileInfo[i].enable = iniparser_getboolean(ini,temp,1);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_CODEC);
name = iniparser_getstring(ini,temp,NULL);
if(name != NULL )
strcpy(cfg->fileInfo[i].codec,name);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_NUMBUF);
cfg->fileInfo[i].numbuf = iniparser_getint(ini,temp,0);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_DISPLAYDELAY);
cfg->fileInfo[i].displaydelay = iniparser_getint(ini,temp,0);
}
return 0;
}
/*--------------------------------------------------------------------------*/
int _get_sections()
{
int i;
if ((section_list->count = iniparser_getnsec(ini)) == -1){
write_to_log(WARNING, "%s - %d - %s", __LINE__, __func__, "Unable to count config sections");
return -1;
}
for(i = 0; i < section_list->count; i++) {
TSection* node = malloc(sizeof(struct section));
node->section_name = iniparser_getsecname(ini, i);
_get_keys(node);
if (section_list->first == NULL) {
section_list->first = node;
} else {
TSection *tmp = section_list->first;
section_list->first = node;
section_list->first->next = tmp;
}
}
return 0;
}
/*--------------------------------------------------------------------------*/
void iniparser_dump_ini(dictionary * d, FILE * f)
{
int i, j ;
char keym[ASCIILINESZ+1];
int nsec ;
char * secname ;
int seclen ;
if (d==NULL || f==NULL) return ;
nsec = iniparser_getnsec(d);
if (nsec<1) {
/* No section in file: dump all keys as they are */
for (i=0 ; i<d->size ; i++) {
if (d->key[i]==NULL)
continue ;
fprintf(f, "%s = %s\n", d->key[i], d->val[i]);
}
return ;
}
for (i=0 ; i<nsec ; i++) {
secname = iniparser_getsecname(d, i) ;
seclen = (int)strlen(secname);
fprintf(f, "\n[%s]\n", secname);
sprintf(keym, "%s:", secname);
for (j=0 ; j<d->size ; j++) {
if (d->key[j]==NULL)
continue ;
if (!strncmp(d->key[j], keym, seclen+1)) {
fprintf(f,
"%-30s = %s\n",
d->key[j]+seclen+1,
d->val[j] ? d->val[j] : "");
}
}
}
fprintf(f, "\n");
return ;
}
static int child_init(int rank)
{
int i = 0, ld_count = 0;
char* ld_name;
/* don't do anything for non-worker process */
if (rank==PROC_MAIN || rank==PROC_TCP_MAIN) {
return 0;
}
/*
* build ld_sessions and connect all sessions
*/
ld_count = iniparser_getnsec(config_vals);
for (i = 0; i < ld_count; i++)
{
ld_name = iniparser_getsecname(config_vals, i);
if (add_ld_session(ld_name,
NULL,
config_vals)
!= 0)
{
LM_ERR("[%s]: add_ld_session failed\n", ld_name);
return -1;
}
if (ldap_connect(ld_name) != 0)
{
LM_ERR("[%s]: failed to connect to LDAP host(s)\n", ld_name);
ldap_disconnect(ld_name);
return -1;
}
}
return 0;
}
int main(int argc, char **argv)
{
int fd, i, j, k;
int c;
int foreground=0;
int active_slave=0;
int log_options;
char config_file_name[PATH_MAX] = RENDERD_CONFIG;
while (1) {
int option_index = 0;
static struct option long_options[] = {
{"config", 1, 0, 'c'},
{"foreground", 1, 0, 'f'},
{"slave", 1, 0, 's'},
{"help", 0, 0, 'h'},
{0, 0, 0, 0}
};
c = getopt_long(argc, argv, "hfc:", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'f':
foreground=1;
break;
case 'c':
strncpy(config_file_name, optarg, PATH_MAX-1);
config_file_name[PATH_MAX-1] = 0;
break;
case 's':
if (sscanf(optarg, "%i", &active_slave) != 1) {
fprintf(stderr, "--slave needs to be nummeric (%s)\n", optarg);
active_slave = 0;
}
break;
case 'h':
fprintf(stderr, "Usage: renderd [OPTION] ...\n");
fprintf(stderr, "Mapnik rendering daemon\n");
fprintf(stderr, " -f, --foreground run in foreground\n");
fprintf(stderr, " -h, --help display this help and exit\n");
fprintf(stderr, " -c, --config=CONFIG set location of config file (default /etc/renderd.conf)\n");
fprintf(stderr, " -s, --slave=CONFIG_NR set which render slave this is (default 0)\n");
exit(0);
default:
fprintf(stderr, "unknown config option '%c'\n", c);
exit(1);
}
}
log_options = LOG_PID;
#ifdef LOG_PERROR
if (foreground)
log_options |= LOG_PERROR;
#endif
openlog("renderd", log_options, LOG_DAEMON);
syslog(LOG_INFO, "Rendering daemon started");
pthread_mutex_init(&qLock, NULL);
pthread_cond_init(&qCond, NULL);
reqHead.next = reqHead.prev = &reqHead;
reqPrioHead.next = reqPrioHead.prev = &reqPrioHead;
reqBulkHead.next = reqBulkHead.prev = &reqBulkHead;
dirtyHead.next = dirtyHead.prev = &dirtyHead;
renderHead.next = renderHead.prev = &renderHead;
hashidxSize = HASHIDX_SIZE;
item_hashidx = (struct item_idx *) malloc(sizeof(struct item_idx) * hashidxSize);
bzero(item_hashidx, sizeof(struct item_idx) * hashidxSize);
stats.noDirtyRender = 0;
stats.noReqDroped = 0;
stats.noReqRender = 0;
stats.noReqPrioRender = 0;
stats.noReqBulkRender = 0;
xmlconfigitem maps[XMLCONFIGS_MAX];
bzero(maps, sizeof(xmlconfigitem) * XMLCONFIGS_MAX);
renderd_config config_slaves[MAX_SLAVES];
bzero(config_slaves, sizeof(renderd_config) * MAX_SLAVES);
bzero(&config, sizeof(renderd_config));
dictionary *ini = iniparser_load(config_file_name);
if (! ini) {
exit(1);
}
noSlaveRenders = 0;
int iconf = -1;
char buffer[PATH_MAX];
for (int section=0; section < iniparser_getnsec(ini); section++) {
char *name = iniparser_getsecname(ini, section);
syslog(LOG_INFO, "Parsing section %s\n", name);
if (strncmp(name, "renderd", 7) && strcmp(name, "mapnik")) {
if (config.tile_dir == NULL) {
fprintf(stderr, "No valid (active) renderd config section available\n");
exit(7);
}
/* this is a map section */
iconf++;
if (iconf >= XMLCONFIGS_MAX) {
fprintf(stderr, "Config: more than %d configurations found\n", XMLCONFIGS_MAX);
exit(7);
}
if (strlen(name) >= (XMLCONFIG_MAX - 1)) {
fprintf(stderr, "XML name too long: %s\n", name);
exit(7);
}
strcpy(maps[iconf].xmlname, name);
sprintf(buffer, "%s:uri", name);
char *ini_uri = iniparser_getstring(ini, buffer, (char *)"");
if (strlen(ini_uri) >= (PATH_MAX - 1)) {
fprintf(stderr, "URI too long: %s\n", ini_uri);
exit(7);
}
strcpy(maps[iconf].xmluri, ini_uri);
sprintf(buffer, "%s:xml", name);
char *ini_xmlpath = iniparser_getstring(ini, buffer, (char *)"");
if (strlen(ini_xmlpath) >= (PATH_MAX - 1)){
fprintf(stderr, "XML path too long: %s\n", ini_xmlpath);
exit(7);
}
strcpy(maps[iconf].xmlfile, ini_xmlpath);
sprintf(buffer, "%s:host", name);
char *ini_hostname = iniparser_getstring(ini, buffer, (char *) "");
if (strlen(ini_hostname) >= (PATH_MAX - 1)) {
fprintf(stderr, "Host name too long: %s\n", ini_hostname);
exit(7);
}
strcpy(maps[iconf].host, ini_hostname);
sprintf(buffer, "%s:htcphost", name);
char *ini_htcpip = iniparser_getstring(ini, buffer, (char *) "");
if (strlen(ini_htcpip) >= (PATH_MAX - 1)) {
fprintf(stderr, "HTCP host name too long: %s\n", ini_htcpip);
exit(7);
}
strcpy(maps[iconf].htcpip, ini_htcpip);
sprintf(buffer, "%s:tilesize", name);
char *ini_tilesize = iniparser_getstring(ini, buffer, (char *) "256");
maps[iconf].tile_px_size = atoi(ini_tilesize);
if (maps[iconf].tile_px_size < 1) {
fprintf(stderr, "Tile size is invalid: %s\n", ini_tilesize);
exit(7);
}
sprintf(buffer, "%s:tiledir", name);
char *ini_tiledir = iniparser_getstring(ini, buffer, (char *) config.tile_dir);
if (strlen(ini_tiledir) >= (PATH_MAX - 1)) {
fprintf(stderr, "Tiledir too long: %s\n", ini_tiledir);
exit(7);
}
strcpy(maps[iconf].tile_dir, ini_tiledir);
} else if (strncmp(name, "renderd", 7) == 0) {
int render_sec = 0;
if (sscanf(name, "renderd%i", &render_sec) != 1) {
render_sec = 0;
}
syslog(LOG_INFO, "Parsing render section %i\n", render_sec);
if (render_sec >= MAX_SLAVES) {
syslog(LOG_ERR, "Can't handle more than %i render sections\n",
MAX_SLAVES);
exit(7);
}
sprintf(buffer, "%s:socketname", name);
config_slaves[render_sec].socketname = iniparser_getstring(ini,
buffer, (char *) RENDER_SOCKET);
sprintf(buffer, "%s:iphostname", name);
config_slaves[render_sec].iphostname = iniparser_getstring(ini,
buffer, "");
sprintf(buffer, "%s:ipport", name);
config_slaves[render_sec].ipport = iniparser_getint(ini, buffer, 0);
sprintf(buffer, "%s:num_threads", name);
config_slaves[render_sec].num_threads = iniparser_getint(ini,
buffer, NUM_THREADS);
sprintf(buffer, "%s:tile_dir", name);
config_slaves[render_sec].tile_dir = iniparser_getstring(ini,
buffer, (char *) HASH_PATH);
sprintf(buffer, "%s:stats_file", name);
config_slaves[render_sec].stats_filename = iniparser_getstring(ini,
buffer, NULL);
if (render_sec == active_slave) {
config.socketname = config_slaves[render_sec].socketname;
config.iphostname = config_slaves[render_sec].iphostname;
config.ipport = config_slaves[render_sec].ipport;
config.num_threads = config_slaves[render_sec].num_threads;
config.tile_dir = config_slaves[render_sec].tile_dir;
config.stats_filename
= config_slaves[render_sec].stats_filename;
config.mapnik_plugins_dir = iniparser_getstring(ini,
"mapnik:plugins_dir", (char *) MAPNIK_PLUGINS);
config.mapnik_font_dir = iniparser_getstring(ini,
"mapnik:font_dir", (char *) FONT_DIR);
config.mapnik_font_dir_recurse = iniparser_getboolean(ini,
"mapnik:font_dir_recurse", FONT_RECURSE);
} else {
noSlaveRenders += config_slaves[render_sec].num_threads;
}
}
}
if (config.ipport > 0) {
syslog(LOG_INFO, "config renderd: ip socket=%s:%i\n", config.iphostname, config.ipport);
} else {
syslog(LOG_INFO, "config renderd: unix socketname=%s\n", config.socketname);
}
syslog(LOG_INFO, "config renderd: num_threads=%d\n", config.num_threads);
if (active_slave == 0) {
syslog(LOG_INFO, "config renderd: num_slaves=%d\n", noSlaveRenders);
}
syslog(LOG_INFO, "config renderd: tile_dir=%s\n", config.tile_dir);
syslog(LOG_INFO, "config renderd: stats_file=%s\n", config.stats_filename);
syslog(LOG_INFO, "config mapnik: plugins_dir=%s\n", config.mapnik_plugins_dir);
syslog(LOG_INFO, "config mapnik: font_dir=%s\n", config.mapnik_font_dir);
syslog(LOG_INFO, "config mapnik: font_dir_recurse=%d\n", config.mapnik_font_dir_recurse);
for (i = 0; i < MAX_SLAVES; i++) {
if (config_slaves[i].num_threads == 0) {
continue;
}
if (i == active_slave) {
syslog(LOG_INFO, "config renderd(%i): Active\n", i);
}
if (config_slaves[i].ipport > 0) {
syslog(LOG_INFO, "config renderd(%i): ip socket=%s:%i\n", i,
config_slaves[i].iphostname, config_slaves[i].ipport);
} else {
syslog(LOG_INFO, "config renderd(%i): unix socketname=%s\n", i,
config_slaves[i].socketname);
}
syslog(LOG_INFO, "config renderd(%i): num_threads=%d\n", i,
config_slaves[i].num_threads);
syslog(LOG_INFO, "config renderd(%i): tile_dir=%s\n", i,
config_slaves[i].tile_dir);
syslog(LOG_INFO, "config renderd(%i): stats_file=%s\n", i,
config_slaves[i].stats_filename);
}
for(iconf = 0; iconf < XMLCONFIGS_MAX; ++iconf) {
if (maps[iconf].xmlname[0] != 0) {
syslog(LOG_INFO, "config map %d: name(%s) file(%s) uri(%s) htcp(%s) host(%s)",
iconf, maps[iconf].xmlname, maps[iconf].xmlfile, maps[iconf].xmluri,
maps[iconf].htcpip, maps[iconf].host);
}
}
fd = server_socket_init(&config);
#if 0
if (fcntl(fd, F_SETFD, O_RDWR | O_NONBLOCK) < 0) {
fprintf(stderr, "setting socket non-block failed\n");
close(fd);
exit(5);
}
#endif
//sigPipeAction.sa_handler = pipe_handler;
sigPipeAction.sa_handler = SIG_IGN;
if (sigaction(SIGPIPE, &sigPipeAction, NULL) < 0) {
fprintf(stderr, "failed to register signal handler\n");
close(fd);
exit(6);
}
render_init(config.mapnik_plugins_dir, config.mapnik_font_dir, config.mapnik_font_dir_recurse);
/* unless the command line said to run in foreground mode, fork and detach from terminal */
if (foreground) {
fprintf(stderr, "Running in foreground mode...\n");
} else {
if (daemon(0, 0) != 0) {
fprintf(stderr, "can't daemonize: %s\n", strerror(errno));
}
/* write pid file */
FILE *pidfile = fopen(PIDFILE, "w");
if (pidfile) {
(void) fprintf(pidfile, "%d\n", getpid());
(void) fclose(pidfile);
}
}
if (config.stats_filename != NULL) {
if (pthread_create(&stats_thread, NULL, stats_writeout_thread, NULL)) {
syslog(LOG_WARNING, "Could not create stats writeout thread");
}
} else {
syslog(LOG_INFO, "No stats file specified in config. Stats reporting disabled");
}
render_threads = (pthread_t *) malloc(sizeof(pthread_t) * config.num_threads);
for(i=0; i<config.num_threads; i++) {
if (pthread_create(&render_threads[i], NULL, render_thread, (void *)maps)) {
fprintf(stderr, "error spawning render thread\n");
close(fd);
exit(7);
}
}
if (active_slave == 0) {
//Only the master renderd opens connections to its slaves
k = 0;
slave_threads
= (pthread_t *) malloc(sizeof(pthread_t) * noSlaveRenders);
for (i = 1; i < MAX_SLAVES; i++) {
for (j = 0; j < config_slaves[i].num_threads; j++) {
if (pthread_create(&slave_threads[k++], NULL, slave_thread,
(void *) &config_slaves[i])) {
fprintf(stderr, "error spawning render thread\n");
close(fd);
exit(7);
}
}
}
}
process_loop(fd);
unlink(config.socketname);
close(fd);
return 0;
}
bool cWebvideoConfig::ReadConfigFile(const char *inifile) {
dictionary *conf = iniparser_load(inifile);
if (!conf)
return false;
info("loading config file %s", inifile);
const char *templatepath = iniparser_getstring(conf, "webvi:templatepath", NULL);
if (templatepath) {
debug("templatepath = %s (from %s)", templatepath, inifile);
SetTemplatePath(templatepath);
}
const char *vfat = iniparser_getstring(conf, "webvi:vfat", NULL);
if (vfat) {
debug("vfat = %s (from %s)", vfat, inifile);
if (strcmp(vfat, "1") == 0 ||
strcmp(vfat, "true") == 0 ||
strcmp(vfat, "yes") == 0 ||
strcmp(vfat, "on") == 0)
{
vfatNames = true;
} else if (strcmp(vfat, "0") == 0 ||
strcmp(vfat, "false") == 0 ||
strcmp(vfat, "no") == 0 ||
strcmp(vfat, "off") == 0)
{
vfatNames = false;
} else {
warning("Invalid value for config option vfat: %s in %s", vfat, inifile);
}
}
for (int i=0; i<iniparser_getnsec(conf); i++) {
const char *section = iniparser_getsecname(conf, i);
if (strcmp(section, "webvi") != 0) {
const int maxsectionlen = 100;
char key[128];
char *keyname;
const char *sitename;
cString domain = parseDomain(section);
if (strlen(domain) == 0)
sitename = section;
else
sitename = domain;
strncpy(key, section, maxsectionlen);
key[maxsectionlen] = '\0';
strcat(key, ":");
keyname = key+strlen(key);
strcpy(keyname, "download-min-quality");
const char *download_min = iniparser_getstring(conf, key, NULL);
strcpy(keyname, "download-max-quality");
const char *download_max = iniparser_getstring(conf, key, NULL);
strcpy(keyname, "stream-min-quality");
const char *stream_min = iniparser_getstring(conf, key, NULL);
strcpy(keyname, "stream-max-quality");
const char *stream_max = iniparser_getstring(conf, key, NULL);
if (download_min || download_max) {
cDownloadQuality *limits = new cDownloadQuality(sitename);
limits->SetMin(download_min);
limits->SetMax(download_max);
downloadLimits.Add(limits);
debug("download priorities for %s (from %s): min = %s, max = %s",
sitename, inifile, download_min, download_max);
}
if (stream_min || stream_max) {
cDownloadQuality *limits = new cDownloadQuality(sitename);
limits->SetMin(stream_min);
limits->SetMax(stream_max);
streamLimits.Add(limits);
debug("streaming priorities for %s (from %s): min = %s, max = %s",
sitename, inifile, stream_min, stream_max);
}
}
}
iniparser_freedict(conf);
return true;
}
void populate_inverter_list(dictionary * d, struct bluetooth_inverter invs[],
int * inv_count, int inv_max) {
/* Get max sections */
int sec_count = iniparser_getnsec(d);
/* Loop through sections */
int sec_pos = 0;
char *sec_name, *inv_mac, *inv_password, *inv_protocol, *inv_type;
char key[128];
char *sec_needle = "inverter_";
for (sec_pos = 0; sec_pos < sec_count; ++sec_pos) {
/* Check if Inverter Section */
sec_name = iniparser_getsecname(d, sec_pos);
if (strstr(sec_name, sec_needle) == sec_name) {
/* inverter name to struct */
strncpy(invs[*inv_count].name, sec_name + strlen(sec_needle),
sizeof(invs[*inv_count].name) - 1);
/* type check */
snprintf(key, sizeof(key) - 1, "%s:%s", sec_name, "type");
inv_type = iniparser_getstring(d, key, "null");
snprintf(key, sizeof(key) - 1, "%s:%s", sec_name, "protocol");
inv_protocol = iniparser_getstring(d, key, "null");
if (strcasecmp(inv_type, "bluetooth") == 0) {
/* Check valid protocols */
if (strcasecmp(inv_protocol, "smadata2plus") == 0) {
/* validate password */
snprintf(key, sizeof(key) - 1, "%s:%s", sec_name,
"password");
inv_password = iniparser_getstring(d, key, "0000");
if (strlen(inv_password) < 1) {
log_error(
"[Config][%s] Passwort too short: '%s'", sec_name, inv_password);
break;
} else if (strlen(inv_password) > 12) {
log_error(
"[Config][%s] Passwort too long: '%s'", sec_name, inv_password);
break;
} else {
memcpy(invs[*inv_count].password, inv_password, 12);
}
/* validate macaddress */
snprintf(key, sizeof(key) - 1, "%s:%s", sec_name,
"bt_address");
inv_mac = iniparser_getstring(d, key, "null");
if (str_mac_validate(inv_mac) == 0) {
log_error(
"[Config][%s] Wrong Mac Address: '%s'", sec_name, iniparser_getstring(d,key,"null"));
break;
}
strcpy(invs[*inv_count].macaddr, inv_mac);
/* Log inverter found */
log_info(
"[Config][%s] Found type='%s' protocol='%s' mac='%s' password='******'", sec_name,inv_type,inv_protocol,invs[*inv_count].macaddr,invs[*inv_count].password);
} else {
log_error(
"[Config][%s] Invalid protocol '%s' for type '%s'", sec_name, inv_protocol, inv_type);
break;
}
} else {
log_error("[Config][%s] Unkown type: '%s'", sec_name, inv_type);
break;
}
}
}
}
char *flib_ini_get_sectionname(flib_ini *ini, int number) {
if(!log_badargs_if2(ini==NULL, number<0)) {
return flib_strdupnull(iniparser_getsecname(ini->inidict, number));
}
return NULL;
}
// Get name for section n.
string InitParser::get_secname(int n) const
{
if (iniparser_getsecname(dico, n)) return string(iniparser_getsecname(dico, n));
return string();
}
/*--------------------------------------------------------------------------*/
void
iniparser_dump_ini (dictionary * d, const char * file_name)
{
int i, j;
char keym[ASCIILINESZ+1];
int nsec;
char * secname;
int seclen;
FILE * f;
FileLock *lock;
if (!d)
return;
lock = ini_file_lock (file_name, TRUE);
if (!lock)
return;
f = fdopen (lock->fd, "w");
if (!f)
{
ini_file_unlock (lock);
return;
}
nsec = iniparser_getnsec (d);
if (nsec < 1)
{
/* No section in file: dump all keys as they are */
for (i = 0; i < d->size; i++)
{
if (!d->key[i])
continue;
fprintf (f, "%s = %s\n", d->key[i], d->val[i]);
}
fflush (f);
ini_file_unlock (lock);
return;
}
for (i = 0; i < nsec; i++)
{
secname = iniparser_getsecname (d, i);
seclen = (int) strlen (secname);
fprintf (f, "[%s]\n", secname);
sprintf (keym, "%s:", secname);
for (j = 0; j < d->size; j++)
{
if (!d->key[j])
continue;
if (!strncmp (d->key[j], keym, seclen + 1))
{
fprintf (f, "%s = %s\n",
d->key[j] + seclen + 1,
d->val[j] ? d->val[j] : "");
}
}
fprintf (f, "\n");
}
fflush (f);
ini_file_unlock (lock );
}
/*************************************************************************************************************
** @brief : Load all watch's in ini file
** #conf : ini file dictionary
** #watch : parser ini configure file data
** @return : how many item in conf file
*************************************************************************************************************/
int conf_init(dictionary *conf, P_WATCH_INFO watch, const unsigned int size)
{
char entry[64];
char *cp = NULL;
unsigned int i;
#define GET_INT_ENTRY(v, d) do { v = iniparser_getint(conf, entry, (d)); } while(0)
#define GET_BOOL_ENTRY(v, d) do { v = iniparser_getboolean(conf, entry, (d)); } while(0)
#define GET_STR_ENTRY(s, d) do { cp = iniparser_getstring(conf, entry, (d)); bcopy(cp, s, strlen(cp)); } while (0)
#define FORMAT_ENTRY(s, k) do { bzero(entry, sizeof(entry)); snprintf(entry, sizeof(entry), "%s:%s", (s), (k)); } while(0)
/* Debug print all conf */
if (debug){
iniparser_dump(conf, stderr);
}
/* Get section name's */
for (i = 0; i < size; i++){
cp = iniparser_getsecname(conf, i);
bcopy(cp, watch[i].name, strlen(cp));
}
/* Get each of them data */
for (i = 0; i < size; i++){
/* Ignore ? */
FORMAT_ENTRY(watch[i].name, IGNORE_KEY);
GET_BOOL_ENTRY(watch[i].ignore, 0);
/* If ignore, do not read jump to next */
if (watch[i].ignore){
continue;
}
/* Path */
FORMAT_ENTRY(watch[i].name, PATH_KEY);
GET_STR_ENTRY(watch[i].path, "");
/* Check if path is dir set is_dir mark */
watch[i].is_dir = conf_is_path_is_dir(watch[i].path);
/* Comment */
FORMAT_ENTRY(watch[i].name, COMMENT_KEY);
GET_STR_ENTRY(watch[i].comment, "");
/* Find if setting special file */
FORMAT_ENTRY(watch[i].name, SPECIAL_KEY);
/* Only dir have this option */
if (watch[i].is_dir && iniparser_find_entry(conf, entry)){
/* Read form ini file */
if ((cp = iniparser_getstring(conf, entry, ""))){
/* Get special file name */
watch[i].spc_file_cnt = conf_get_words(cp, watch[i].spc_file, MAX_SPC_FILE);
}
}
/* events */
FORMAT_ENTRY(watch[i].name, EVENTS_KEY);
GET_STR_ENTRY(watch[i].events_str, "");
/* Parser events */
watch[i].events = conf_parser_events(watch[i].events_str, watch[i].is_dir);
/* Debug */
if (debug){
conf_print_watch(&watch[i]);
}
} /* end for */
/* Arrange watching list */
return conf_arrange_watch(watch, (i == size) ? size : i);
}
//joblist_t *BuildJoblist(char *fname)
joblist_t *BuildJoblist(config_t *config, dictionary *dict, joblist_t *badjob)
{
//dictionary *dict;
char *k, **res, *section, *token, *val;
charlist_t *keys;
char entry[BUFSIZE+1];
char module[BUFSIZE+1];
int jobid=1;
int nsect;
int i=0, n=0, badjobid=-1;
joblist_t *joblist=NULL, *joblist_head=NULL;
if (badjob)
badjobid=badjob->id;
// dict = iniparser_load(fname);
/* Get all the sections */
nsect = iniparser_getnsec(dict);
for (n=0; n<nsect; n++) { // Each Section
section = iniparser_getsecname(dict, n);
if (strcmp(section, "main")==0) {
// Set global parameters
continue;
}
if (! section ) exit(-1);
if (!joblist) {
if (! (joblist = (joblist_t *) malloc( sizeof(joblist_t))) ) {
exception(MODULE_NAME, EXCEPTION_PRIORITY_FATAL, "Failed to allocate memory");
return(NULL);
}
joblist_head = joblist;
} else {
if (! (joblist->next = (joblist_t *) malloc( sizeof(joblist_t))) ) {
exception(MODULE_NAME, EXCEPTION_PRIORITY_FATAL, "Failed to allocate memory");
return(NULL);
}
joblist= joblist->next;
}
joblist->valid=TRUE;
joblist->id=0;
joblist->timestamp=0;
joblist->activecount=0;
joblist->prefix=NULL;
joblist->jobname=strdup(section);
joblist->modname=NULL;
joblist->modpath=NULL;
joblist->modhandle=NULL;
joblist->runmin=NULL;
joblist->runhr=NULL;
joblist->targetlist[0]=NULL;
joblist->next=NULL;
snprintf(entry,BUFSIZE, "%s:
%s", section, CONF_PREFIX);
val = iniparser_getstring(dict, entry, "null");
if (strncmp(val, "null", strlen("null"))==0) {
joblist->valid=FALSE;
va_exception(MODULE_NAME, EXCEPTION_PRIORITY_WARNING, "Section=%s, key not found %s",section,CONF_PREFIX);
} else {
va_exception(MODULE_NAME, EXCEPTION_PRIORITY_DEBUG, "Section=%s, Key=%s, Val=%s",section, CONF_PREFIX, val);
joblist->prefix=strdup(val);
}
snprintf(entry,BUFSIZE, "%s:
%s", section, CONF_RUNTIME);
val = iniparser_getstring(dict, entry, "null");
if (strncmp(val, "null", strlen("null"))==0) {
joblist->valid=FALSE;
va_exception(MODULE_NAME, EXCEPTION_PRIORITY_WARNING, "Section=%s, key not found %s",section,CONF_RUNTIME);
} else {
res = rematch(CONF_RUNPAT, val);
if (!res) {
va_exception(MODULE_NAME, EXCEPTION_PRIORITY_WARNING, "Section=%s, Key=%s, incorrect runtime format",section, CONF_RUNTIME);
joblist->valid=FALSE;
} else {
if (badjob && (jobid == badjob->id))
joblist->valid=FALSE;
joblist->id=jobid++;
joblist->runmin=strdup(res[1]); // group 1
joblist->runhr=strdup(res[2]); // group 2
for (i=0; res[i]!=NULL;i++)
free(res[i]);
va_exception(MODULE_NAME, EXCEPTION_PRIORITY_DEBUG, "Section=%s, min=%s hr=%s",section, joblist->runmin, joblist->runhr);
}
}
snprintf(entry,BUFSIZE, "%s:
%s", section, CONF_TARGETS);
// printf("Targets=%s\n", entry);
val = iniparser_getstring(dict, entry, "null");
if (strncmp(val, "null", strlen("null"))==0) {
va_exception(MODULE_NAME, EXCEPTION_PRIORITY_WARNING, "Section=%s, key not found %s",section,CONF_TARGETS);
joblist->valid=FALSE;
continue;
}
/* Can load targetlist by file also */
if ( strncmp(val,TARGET_FROM_FILE,strlen(TARGET_FROM_FILE))==0) {
if (joblist->targetlist[0]) free_targetlist(joblist->targetlist);
if (!( load_targets_from_file(val+strlen(TARGET_FROM_FILE), joblist->targetlist))) {
va_exception(MODULE_NAME, EXCEPTION_PRIORITY_WARNING, "Section=%s, No targets found in file:
%s",section, val+strlen(TARGET_FROM_FILE));
continue;
}
} else {
