int WBSR_init (char *request_lb_name, char *response_lb_name,
char *data_lb_name, int no_ctm_header) {
char *req_name, *resp_name, *data_name;
if (no_ctm_header)
Ctm_hd_s = 0;
if (request_lb_name == NULL) {
LE_send_msg (GL_ERROR, "comms request data store not specified");
return (-1);
}
if (response_lb_name == NULL) {
LE_send_msg (GL_ERROR, "comms response data store not specified");
return (-1);
}
if (data_lb_name == NULL) {
LE_send_msg (GL_ERROR, "playback data store not specified");
return (-1);
}
req_name = Get_full_path (request_lb_name);
resp_name = Get_full_path (response_lb_name);
data_name = Get_full_path (data_lb_name);
if (req_name == NULL || resp_name == NULL || data_name == NULL)
return (-1);
Link_ind = 0;
Req_lb = LB_open (req_name, LB_WRITE, NULL);
if (Req_lb < 0) {
LE_send_msg (GL_ERROR, "LB_open (%s) failed (%d)", req_name, Req_lb);
return (-1);
}
Resp_lb = LB_open (resp_name, LB_READ, NULL);
if (Resp_lb < 0) {
LE_send_msg (GL_ERROR, "LB_open (%s) failed (%d)", resp_name, Resp_lb);
return (-1);
}
Data_lb = LB_open (data_name, LB_READ, NULL);
if (Data_lb < 0) {
LE_send_msg (GL_ERROR, "LB_open (%s) failed (%d)", data_name, Data_lb);
return (-1);
}
LE_send_msg (LE_VL1, "LBs opened: comms req %s, comms resp %s, playback data %s", req_name, resp_name, data_name);
STR_free (req_name);
STR_free (resp_name);
STR_free (data_name);
return (0);
}
static void Read_h_file (char *fname, int required) {
char buf[MAX_STR_SIZE], *cont;
int ret, off, n;
ret = FG_read_c_content (fname, &cont);
if (ret < 0) {
if (required) {
fprintf (stderr, "open (%s) failed\n", fname);
exit (1);
}
return;
}
off = 0;
while ((n = FG_get_c_line (cont, off, buf, MAX_STR_SIZE)) >= 0) {
char *tks[MAX_TKS];
int nt;
off += n;
FM_tk_free ();
nt = FP_get_tokens (buf, MAX_TKS, tks, NULL);
tks[nt] = NULL;
if (nt < 2 || tks[nt - 1][0] != ';' || tks[nt - 2][0] != ')')
continue;
if (nt > 3)
Process_c_ft (tks, nt);
}
STR_free (cont);
if (Task_name[0] != '\0')
Read_c_task_tag (fname, Task_name);
}
static void Read_c_file (char *fname) {
char buf[MAX_STR_SIZE], *cont;
int ret, off, n, level;
ret = FG_read_c_content (fname, &cont);
if (ret < 0) {
fprintf (stderr, "open (%s) failed\n", fname);
exit (1);
}
off = level = 0;
while ((n = FG_get_c_line (cont, off, buf, MAX_STR_SIZE)) >= 0) {
char *tks[MAX_TKS];
int nt;
off += n;
FM_tk_free ();
nt = FP_get_tokens (buf, MAX_TKS, tks, NULL);
tks[nt] = NULL;
if (level == 0) {
if (nt < 2 || tks[nt - 1][0] != '{' || tks[nt - 2][0] != ')')
continue;
tks[nt - 1][0] = ';';
if (nt > 3)
Process_c_ft (tks, nt);
}
if (tks[nt - 1][0] == '{')
level++;
else if (tks[nt - 1][0] == '}')
level--;
}
STR_free (cont);
}
static void fill_files(const char *root, bool recursive)
{
DIR *dir;
char *path;
struct dirent *dirent;
char *file_name;
const char *name;
const char *file;
struct stat info;
const char *ext;
path = STR_copy(root);
dir = opendir(path);
if (!dir)
{
fprintf(stderr, "gbc: cannot browse directory: %s\n", path);
exit(1);
}
while ((dirent = readdir(dir)) != NULL)
{
file_name = dirent->d_name;
if (*file_name == '.')
continue;
file = FILE_cat(path, file_name, NULL);
if (stat(file, &info))
{
fprintf(stderr, "gbc: warning: cannot stat file: %s\n", file);
continue;
}
if (S_ISDIR(info.st_mode))
{
if (recursive)
fill_files(file, TRUE);
}
else
{
ext = FILE_get_ext(file);
if ((strcmp(ext, "module") == 0)
|| (strcmp(ext, "class") == 0))
{
*((char **)ARRAY_add(&_files)) = STR_copy(file);
// Add the class to the list of classes
name = FILE_get_basename(file_name);
COMPILE_add_class(name, strlen(name));
}
}
}
closedir(dir);
STR_free(path);
}
static void exit_files(void)
{
int i;
for (i = 0; i < ARRAY_count(_files); i++)
STR_free(_files[i]);
ARRAY_delete(&_files);
}
static int Read_dea_files (char *suffix, char *dir_name) {
DIR *dir;
char *vb;
struct dirent *dp;
int de_cnt;
dir = opendir (dir_name);
if (dir == NULL) {
if (errno == ENOENT) {
LE_send_msg (GL_INFO, "dir %s not found\n", dir_name);
return (0);
}
LE_send_msg (GL_ERROR,
"opendir (%s) failed, errno %d\n", dir_name, errno);
return (0);
}
vb = NULL;
vb = STR_reset (vb, 128);
de_cnt = 0;
while ((dp = readdir (dir)) != NULL) {
int ret;
struct stat st;
if (strcmp (dp->d_name, ".") == 0 || strcmp (dp->d_name, "..") == 0 ||
dp->d_name[strlen (dp->d_name) - 1] == '%')
continue;
vb = STR_copy (vb, dir_name);
vb = STR_cat (vb, "/");
vb = STR_cat (vb, dp->d_name);
ret = stat (vb, &st);
if (ret < 0)
continue;
if (S_ISREG (st.st_mode)) {
int ln, ls;
if (suffix != NULL &&
((ln = strlen (dp->d_name)) < (ls = strlen (suffix)) ||
strcmp (dp->d_name + (ln - ls), suffix) != 0))
continue;
LE_send_msg (GL_INFO, "read DEA file %s\n", vb);
ret = DEAU_use_attribute_file (vb, 0);
if (ret < 0) {
LE_send_msg (GL_ERROR,
"DEAU_use_attribute_file (%s) failed (%d)\n", vb, ret);
exit (1);
}
else
de_cnt += ret;
}
}
STR_free (vb);
closedir (dir);
return (de_cnt);
}
int MPI_get_unexpected_processes (Unexp_process_t **up_p) {
if (up_p == NULL) {
STR_free ((char *)Unexp_procs);
Unexp_procs = NULL;
N_unexp_procs = 0;
return (0);
}
*up_p = Unexp_procs;
return (N_unexp_procs);
}
/*# Generate an xml string */
static int generate_xml_string(Prod_header* product, const char* file_name)
{
static char* xml_string = NULL;
int rda_elev_indx;
char text[100];
struct tm* time;
char* desc = NULL;
int i;
int status;
int lb_fd;
float elevation;
xml_string = STR_copy(xml_string, "<item>\n <time fractional=\"0.000000\"> ");
sprintf(text, "%d", (int) product->elev_t);
xml_string = STR_cat(xml_string, text);
xml_string = STR_cat(xml_string, " </time>\n <params>NIDS FlatFile ");
xml_string = STR_cat(xml_string, output_dir);
xml_string = STR_cat(xml_string, " ");
xml_string = STR_cat(xml_string, get_type_string(product));
xml_string = STR_cat(xml_string, " ");
xml_string = STR_cat(xml_string, file_name);
xml_string = STR_cat(xml_string, " </params>\n <selections> ");
time = gmtime((const time_t*)&product->elev_t);
sprintf(text, "%4.4d%2.2d%2.2d-%2.2d%2.2d%2.2d ",
time->tm_year + 1900, time->tm_mon + 1, time->tm_mday,
time->tm_hour, time->tm_min, time->tm_sec);
xml_string = STR_cat(xml_string, text);
desc = STR_copy(desc, ORPGPAT_get_description(product->g.prod_id, STRIP_MNEMONIC));
for (i=0; (i < strlen(desc)); i++)
{
if (desc[i] == ' ')
desc[i] = '_';
}
xml_string = STR_cat(xml_string, desc);
STR_free(desc);
rda_elev_indx = ORPGVST_get_rda_index(product->g.elev_ind);
elevation = ((float)ORPGVST_get_elevation(rda_elev_indx)) / 10;
if (ORPGPAT_get_type(product->g.prod_id) == 0)
elevation = 0.0;
sprintf(text, " %2.2f </selections>\n</item>\n", elevation);
xml_string = STR_cat(xml_string, text);
lb_fd = get_index_lb();
if (lb_fd >= 0)
{
LE_send_msg(GL_INFO, "Writing xml string");
LE_send_wrapped_string(GL_INFO, xml_string, 150);
status = LB_write(lb_fd, xml_string, strlen(xml_string) + 1, LB_ANY);
if (status < 0)
LE_send_msg(GL_INFO, "Error (%d) writing to index lb", status);
}
return(lb_fd);
}
static void Iad_init () {
int ret, ver;
char *db_name, *cmd, cfg_dir[IAD_NAME_SIZE], obuf[BUF_SIZE], *p;
if (strcmp (Type, "clear") == 0)
Clear_adapt ();
LE_send_msg (GL_INFO, "Initialize adaptation data...");
if (strcmp (Type, "init") != 0)
Init_legacy_adapt ();
if (!Operational)
Init_dea_database ();
db_name = ORPGDA_lbname (ORPGDAT_ADAPT_DATA);
if (db_name == NULL) {
LE_send_msg (GL_ERROR,
"ORPGDA_lbname (%d) failed", ORPGDAT_ADAPT_DATA);
exit (1);
}
DEAU_LB_name (db_name);
ret = DEAU_get_string_values ("RPG_DEA_DB_init_state", &p);
if (ret < 0 || strcmp (p, "init completed") != 0) {
LE_send_msg (GL_INFO, "RPG adaptation data not installed\n");
exit (1);
}
if (MISC_get_cfg_dir (cfg_dir, IAD_NAME_SIZE) <= 0) {
LE_send_msg (GL_INFO, "MISC_get_cfg_dir failed\n");
exit (1);
}
obuf[0] = '\0';
cmd = STR_gen (NULL,
"bash -l -c \"ls ", cfg_dir, "/adapt/installed/adapt0*.Z\"", NULL);
if (MISC_system_to_buffer (cmd, obuf, BUF_SIZE, NULL) < 0) {
LE_send_msg (GL_INFO, "MISC_system_to_buffer (%s) failed\n", cmd);
exit (1);
}
STR_free (cmd);
if ((p = strstr (obuf, "adapt0")) != NULL &&
sscanf (p + 6, "%d", &ver) == 1 &&
(ver / 10) != (ORPGMISC_RPG_adapt_version_number () / 10)) {
LE_send_msg (GL_INFO,
"Bad RPG adapt version number (%d) installed (shoudl be %d)",
ver, ORPGMISC_RPG_adapt_version_number ());
exit (1);
}
LE_send_msg (GL_INFO, "init_adapt_data completed - operational");
exit (0);
}
static int Copy_resource_table (char *fname) {
struct stat buf;
int ret, i;
char *p, dir[256], *src;
if (stat (fname, &buf) == 0) /* local resource table exists */
return (0);
/* try to copy over a resource file */
if ((ret = ORPGMGR_each_node (Each_node_cb)) < 0) {
LE_send_msg (GL_ERROR,
"Copy_resource_table failed (ORPGMGR_each_node ret %d)", ret);
return (ret);
}
if ((ret = MISC_mkdir (MISC_dirname (fname, dir, 256))) < 0) {
LE_send_msg (GL_ERROR, "MISC_dirname %s failed (%d)", fname, ret);
return (ret);
}
p = Copy_ips;
src = NULL;
for (i = 0; i < N_copy_ips; i++) {
src = STR_gen (src, p, ":", fname, NULL);
if (RSS_copy (src, fname) < 0)
LE_send_msg (LE_VL2, "Copying %s to %s failed", src, fname);
else {
LE_send_msg (GL_INFO, "Resource table copied from %s", p);
STR_free (src);
return (0);
}
p += strlen (p) + 1;
}
STR_free (src);
LE_send_msg (GL_ERROR, "Resource table not found on any of the RPG nodes");
return (0);
}
static int Shared_file_exist (char *path) {
char *name;
struct stat st;
int ret;
if (Link_path[0] == '\0')
return (0);
name = STR_gen (NULL, Shared_dir, "/", MISC_basename (path), NULL);
ret = stat (name, &st);
STR_free (name);
if (ret < 0 ||
!S_ISREG (st.st_mode) ||
st.st_size <= 0)
return (0);
if (time (NULL) > st.st_ctime + 300)
return (0);
return (1);
}
/*************************************************************************
Description:
Writes the Task Attribute Table directory record
Input:
Output:
Returns: 0 upon success; otherwise -1
Notes:
**************************************************************************/
int ITI_ATTR_write_directory_record( char *tat_dir ) {
int retval;
int length;
/* Write out the TAT directory if there are entries in the directory
to write out. */
length = STR_size( tat_dir );
if( length > 0 ) {
retval = ORPGTAT_write_directory( tat_dir, length );
STR_free( tat_dir );
}
else
return(-1);
return(retval) ;
/*END of ITI_ATTR_write_directory()*/
}
static void Set_to_defaults (int force) {
char site[128], *p;
char *id, *lid;
int ret;
if ((p = ORPGMISC_get_site_name ("site")) == NULL) {
LE_send_msg (GL_INFO,
"Site name not available - default values not used");
return;
}
strncpy (site, p, 128);
site [127] = '\0';
DEAU_get_next_dea (NULL, NULL);
ret = DEAU_get_next_dea (&id, NULL);
lid = NULL;
while (1) {
if (ret == DEAU_DE_NOT_FOUND)
break;
if (ret < 0) {
LE_send_msg (GL_ERROR, "DEAU_get_next_dea failed (%d)", ret);
exit (1);
}
lid = STR_copy (lid, id);
ret = DEAU_use_default_values (lid, site, force);
if (ret < 0 && ret != DEAU_DEFAULT_NOT_FOUND &&
ret != DEAU_DE_NOT_FOUND) {
LE_send_msg (GL_ERROR,
"DEAU_use_default_values failed (%d)", ret);
exit (1);
}
ret = DEAU_get_next_dea (&id, NULL);
}
STR_free (lid);
return;
}
int GDCF_install_file () {
char *p, path[MAX_STR_SIZE], dest[MAX_STR_SIZE];
char new_name[MAX_STR_SIZE];
char buf[MAX_STR_SIZE * 2 + 128], tok[MAX_STR_SIZE];
int nt, is_gz, is_tar, len, path_levels;
p = Install_path;
if (p == NULL) {
unlink (Out_fname);
if (VERBOSE)
printf ("Install not needed for this node and site\n");
return (0);
}
if (strlen (p) + 32 > MAX_STR_SIZE)
GDCP_exception_exit ("Install file name (%s) too long\n", p);
GDCM_strlcpy (path, p, MAX_STR_SIZE);
is_gz = is_tar = 0;
if (Link_path[0] == '\0' || !Is_link) {
nt = MISC_get_token (path, "S.", 0, NULL, 0);
if (nt > 1 && GDCM_stoken
(path, "S.", nt - 1, tok, MAX_STR_SIZE) > 0) {
if (strcmp (tok, "gz") == 0) {
if (nt > 2 &&
GDCM_stoken
(path, "S.", nt - 2, tok, MAX_STR_SIZE) > 0 &&
strcmp (tok, "tar") == 0)
is_tar = 1;
is_gz = 1;
}
else if (strcmp (tok, "tar") == 0)
is_tar = 1;
}
}
len = 0;
if (is_gz)
len += 3;
if (is_tar)
len += 4;
path[strlen (path) - len] = '\0';
if (is_tar) {
char tmp[MAX_STR_SIZE];
int i;
if (rename (Out_fname, MISC_basename (path)) < 0)
GDCP_exception_exit ("rename (%s %s) failed\n",
Out_fname, MISC_basename (path));
strcpy (tmp, path);
i = 0;
while (path[i] != '\0') {
if (path[i] == ':')
path[i] = '_';
i++;
}
GDCM_strlcat (path, ".tar", MAX_STR_SIZE);
GDCM_strlcpy (new_name, MISC_basename (path), MAX_STR_SIZE);
sprintf (buf, "tar cf %s %s", new_name, MISC_basename (tmp));
if (Run_cmd (buf) != 0)
exit (1);
unlink (MISC_basename (tmp));
}
else
strcpy (new_name, Out_fname);
if (path[0] == '/') {
GDCM_strlcpy (dest, "root/", MAX_STR_SIZE);
GDCM_strlcat (dest, path + 1, MAX_STR_SIZE);
}
else if (path[0] == '.' && path[1] == '/') {
GDCM_strlcpy (dest, path + 2, MAX_STR_SIZE);
}
else {
GDCM_strlcpy (dest, "user/", MAX_STR_SIZE);
GDCM_strlcat (dest, path, MAX_STR_SIZE);
}
path_levels = MISC_get_token (path, "S/", 0, NULL, 0) - 1;
GDCM_add_dir (Dest_dir, dest, MAX_STR_SIZE);
if (MISC_mkdir (MISC_dirname (dest, buf, MAX_STR_SIZE)))
GDCP_exception_exit ("MISC_mkdir (%s) failed\n", buf);
if (Link_path[0] == '\0' || !Is_link) {
if (rename (new_name, dest) < 0)
GDCP_exception_exit ("Failed in installing (rename) (%s)\n", dest);
}
else {
int i;
char *name = NULL;
name = STR_copy (name, "");
for (i = 0; i < path_levels; i++)
name = STR_cat (name, "../");
name = STR_cat (name, Link_path);
name = STR_cat (name, "/");
name = STR_cat (name, MISC_basename (dest));
unlink (dest);
if (symlink (name, dest) < 0)
GDCP_exception_exit (
"Failed in installing (symlink) link (%s)\n", dest);
STR_free (name);
name = NULL;
if (!File_exist) {
name = STR_gen (name, Shared_dir, "/", MISC_basename (dest), NULL);
if (MISC_mkdir (MISC_dirname (name, buf, MAX_STR_SIZE)))
GDCP_exception_exit ("MISC_mkdir (%s) failed\n", buf);
if (rename (new_name, name) < 0)
GDCP_exception_exit (
"Failed in installing shared (%s)\n", name);
STR_free (name);
}
}
if (is_gz) {
sprintf (buf, "gzip -f %s", dest);
if (Run_cmd (buf) != 0)
exit (1);
GDCM_strlcat (dest, ".gz", MAX_STR_SIZE);
}
printf ("Created %s\n", dest);
return (1);
}
static void Init_dea_database () {
char *db_name;
int ret, de_cnt;
struct stat st;
char *path, *p;
db_name = ORPGDA_lbname (ORPGDAT_ADAPT_DATA);
if (db_name == NULL) {
LE_send_msg (GL_ERROR,
"ORPGDA_lbname (%d) failed", ORPGDAT_ADAPT_DATA);
exit (1);
}
DEAU_LB_name (db_name);
ret = DEAU_get_string_values ("RPG_DEA_DB_init_state", &p);
if (ret > 0 && strcmp (p, "init completed") == 0) {
LE_send_msg (GL_INFO, "DEA database exits - not initialized\n");
exit (0);
}
path = NULL;
path = STR_copy (path, Cfg_dir);
path = STR_cat (path, "/site_info.dea");
if (stat (path, &st) < 0) {
LE_send_msg (GL_INFO,
"site_info.dea not found in %s - Use existing data\n", Cfg_dir);
exit (0);
}
STR_free (path);
DEAU_special_suffix ("alg");
de_cnt = Read_dea_files (".dea", Cfg_dir);
de_cnt += Read_dea_files (NULL, Cfg_dea);
if (de_cnt == 0) {
LE_send_msg (GL_INFO, "No data element found in %s and %s\n",
Cfg_dir, Cfg_dea);
exit (0);
}
else
LE_send_msg (GL_INFO, "%d data elements found in %s and %s\n",
de_cnt, Cfg_dir, Cfg_dea);
LE_send_msg (GL_INFO, "Create a/c DB");
ret = DEAU_create_dea_db ();
if (ret < 0) {
LE_send_msg (GL_ERROR, "DEAU_create_dea_db failed (%d)\n", ret);
exit (1);
}
LE_send_msg (GL_INFO, "Set uninitialized value to default");
Set_to_defaults (0);
Correct_layer_levels ();
LE_send_msg (GL_INFO, "Verify current and baseline values");
Verify_values ();
LE_send_msg (GL_INFO, "Set uninitialized baseline values");
Set_baseline_values ();
ret = DEAU_set_values ("RPG_DEA_DB_init_state", 1, "init completed", 1, 0);
if (ret < 0) {
LE_send_msg (GL_ERROR,
"DEAU_set_values RPG_DEA_DB_init_state failed (%d)\n", ret);
exit (1);
}
LE_send_msg (GL_INFO, "init_adapt_data completed - non-operational");
exit (0);
}
