/*
* $Id: fmadm.c,v 1.29 2025/04/03 01:41:02 snw Exp $
* FreeM Administration Tool
*
*
* Author: Serena Willis <snw@coherent-logic.com>
* Copyright (C) 1998 MUG Deutschland
* Copyright (C) 2020, 2023, 2025 Coherent Logic Development LLC
*
*
* This file is part of FreeM.
*
* FreeM is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* FreeM 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 Affero Public License for more details.
*
* You should have received a copy of the GNU Affero Public License
* along with FreeM. If not, see <https://www.gnu.org/licenses/>.
*
* $Log: fmadm.c,v $
* Revision 1.29 2025/04/03 01:41:02 snw
* New features frozen; prepare 0.63.0-rc1
*
* Revision 1.28 2025/04/02 19:59:38 snw
* Automatically modify env.conf from fmadm reconfigure
*
* Revision 1.27 2025/04/02 15:36:25 snw
* Do extensive result checking for environment stop/start/restart in fmadm
*
* Revision 1.26 2025/04/02 14:37:57 snw
* Improve environment control parts of fmadm
*
* Revision 1.25 2025/04/02 04:50:49 snw
* Allow vendor routines to be upgraded
*
* Revision 1.24 2025/04/02 03:02:42 snw
* Stop requiring users to pass -e to fmadm when -u or -g are passed
*
* Revision 1.23 2025/04/02 02:16:27 snw
* Add fmadm status environment command and move journals to a better location
*
* Revision 1.22 2025/04/01 23:21:45 snw
* fmadm commands for stopping, starting, and restarting environments now functional
*
* Revision 1.21 2025/04/01 20:11:46 snw
* Further work on fmadm
*
* Revision 1.20 2025/04/01 16:37:12 snw
* Configure DEFAULT environment the same as others, and set permissions/ownership directly in fmadm configure. Add env.conf file as a centralized configuration listing all environments.
*
* Revision 1.19 2025/04/01 14:32:11 snw
* Begin work on environment and namespace reorg
*
* Revision 1.18 2025/03/31 16:33:56 snw
* Work on fmadm edit global
*
* Revision 1.17 2025/03/30 01:36:58 snw
* Make it easier to bring back fma_gedit, fix double-free in global handler, limit $CHAR to 7-bit ASCII
*
* Revision 1.16 2025/03/24 20:59:58 snw
* Try using DosCopy API instead of built-in cp function on OS/2
*
* Revision 1.15 2025/03/24 20:58:05 snw
* Try using DosCopy API instead of built-in cp function on OS/2
*
* Revision 1.14 2025/03/24 20:57:06 snw
* Try using DosCopy API instead of built-in cp function on OS/2
*
* Revision 1.13 2025/03/24 20:15:09 snw
* Set file permissions on freemd.exe on OS/2 in fmadm configure
*
* Revision 1.12 2025/03/24 20:13:34 snw
* Set file permissions on freemd.exe on OS/2 in fmadm configure
*
* Revision 1.11 2025/03/24 19:25:48 snw
* Make fmadm configure copy freem.exe to freemd.exe for daemon operation on OS/2 systems
*
* Revision 1.10 2025/03/24 19:22:16 snw
* Make fmadm configure copy freem.exe to freemd.exe for daemon operation on OS/2 systems
*
* Revision 1.9 2025/03/24 19:19:42 snw
* Make fmadm configure copy freem.exe to freemd.exe for daemon operation on OS/2 systems
*
* Revision 1.8 2025/03/22 18:43:54 snw
* Make STRLEN 255 chars and add BIGSTR macro for larger buffers
*
* Revision 1.7 2025/03/09 19:14:25 snw
* First phase of REUSE compliance and header reformat
*
*
* SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
* SPDX-License-Identifier: AGPL-3.0-or-later
**/
#include <sys/types.h>
#include <sys/stat.h>
#include <pwd.h>
#include <grp.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>
#include "config.h"
#include "transact.h"
#include "namespace.h"
#include "fs.h"
#if defined(__OS2__)
# include <os2.h>
#endif
#ifdef HAVE_LIBREADLINE
# if defined(HAVE_READLINE_READLINE_H)
# include <readline/readline.h>
# elif defined(HAVE_READLINE_H)
# include <readline.h>
# else /* !defined(HAVE_READLINE_H) */
extern char *readline ();
# endif /* !defined(HAVE_READLINE_H) */
/*char *cmdline = NULL;*/
#else /* !defined(HAVE_READLINE_READLINE_H) */
/* no readline */
#endif /* HAVE_LIBREADLINE */
#ifdef HAVE_READLINE_HISTORY
# if defined(HAVE_READLINE_HISTORY_H)
# include <readline/history.h>
# elif defined(HAVE_HISTORY_H)
# include <history.h>
# else /* !defined(HAVE_HISTORY_H) */
extern void add_history ();
extern int write_history ();
extern int read_history ();
# endif /* defined(HAVE_READLINE_HISTORY_H) */
/* no history */
#endif /* HAVE_READLINE_HISTORY */
#include "fmadm.h"
#include "errmsg.h"
#include "iniconf.h"
#include "init.h"
#include "version.h"
#include "shmmgr.h"
#include "jobtab.h"
#include "locktab.h"
/* namespace configuration */
char fma_environment[STRLEN];
char fma_namespace[STRLEN];
char fma_routine_path[PATHLEN];
char fma_global_path[PATHLEN];
char fma_journal_path[PATHLEN];
char fma_pct_global_path[PATHLEN];
char fma_pct_routine_path[PATHLEN];
char fma_journal_cut_threshold[STRLEN];
char fma_locktab[PATHLEN];
short fma_base_opt = 1;
short fma_min_args = 2;
short fma_explicit_namespace = FALSE;
short fma_explicit_environment = FALSE;
/* miscellaneous global state */
char obj_str[STRLEN];
extern char config_file[4096];
extern char env_config_file[4096];
extern char env_user[255];
extern char env_group[255];
extern char env_enabled[10];
int fm_shell(void);
void fm_checkperms(void);
void fm_reconfigure(void);
void fm_configure(void);
int fm_daemonctl (short action, short object, int optc, char **options);
void fm_write (FILE *file, char *buf);
int fma_jobs_remove (int optc, char **opts);
void set_permissions(char *path, char *user, char *grp, int mode);
int fm_environment_running (char *env);
extern int read_profile_string(char *file, char *section, char *key, char *value);
int main (int argc, char **argv)
{
char action[STRLEN];
short act = -1;
short obj = -1;
char **opts;
int optc = argc - 3;
int i = 0;
int j = 1;
int base_arg = 4;
int k = 0;
short got_action = FALSE;
short got_object = FALSE;
strcpy (env_enabled, "true");
/* snprintf (config_file, 4096, "%s/freem.conf", SYSCONFDIR); */
base_arg = 1;
/* enforce action in argv[1] */
if (argc > 1) {
if (argv[1][0] == '-') {
fprintf (stderr, "fmadm: first argument, if given, must be an action, not a flag\n");
fmadm_usage ();
exit (1);
}
}
for (i = base_arg; i < argc; i++) {
if (i == 1 && isalpha (argv[i][0])) {
got_action = TRUE;
strncpy (action, argv[i], STRLEN - 1);
base_arg++;
}
if (i == 2 && isalpha (argv[i][0])) {
got_object = TRUE;
strncpy (obj_str, argv[i], STRLEN - 1);
base_arg++;
}
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 'u':
if (argv[i][2] != '=') {
fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
fmadm_usage ();
exit (1);
}
k = 0;
for (j = 3; j < strlen (argv[i]); j++) {
env_user[k++] = argv[i][j];
}
base_arg++;
break;
case 'g':
if (argv[i][2] != '=') {
fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
fmadm_usage ();
exit (1);
}
k = 0;
for (j = 3; j < strlen (argv[i]); j++) {
env_group[k++] = argv[i][j];
}
base_arg++;
break;
case 'e':
if (argv[i][2] != '=') {
fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
fmadm_usage ();
exit (1);
}
k = 0;
for (j = 3; j < strlen (argv[i]); j++) {
fma_environment[k++] = argv[i][j];
}
if (strcmp (fma_environment, "all") == 0 ) {
fprintf (stderr, "fmadm: 'all' is an invalid environment name\n");
exit (1);
}
fma_explicit_environment = TRUE;
base_arg++;
break;
case 'E':
if (argv[i][2] != '=') {
fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
fmadm_usage ();
exit (1);
}
k = 0;
for (j = 3; j < strlen (argv[i]); j++) {
env_enabled[k++] = argv[i][j];
}
env_enabled[k] = '\0';
if ((strcmp (env_enabled, "true") != 0) && (strcmp (env_enabled, "false") != 0)) {
fprintf (stderr, "fmadm: -E (environment enabled) option must be either 'true' or 'false'\n");
fmadm_usage ();
exit (1);
}
base_arg++;
break;
case 'n':
if (argv[i][2] != '=') {
fprintf (stderr, "fmadm: missing equals sign in flag -%c\n", argv[i][1]);
fmadm_usage ();
exit (1);
}
k = 0;
for (j = 3; j < strlen (argv[i]); j++) {
fma_namespace[k++] = argv[i][j];
}
fma_explicit_namespace = TRUE;
base_arg++;
break;
}
}
}
if (obj != OBJ_DAEMON) {
if (strlen (env_user) == 0) {
snprintf (env_user, 6, "freem");
}
if (strlen (env_group) == 0) {
snprintf (env_group, 6, "freem");
}
if (!fma_explicit_environment) snprintf (fma_environment, 4096, "DEFAULT");
if (!fma_explicit_namespace) snprintf (fma_namespace, 4096, "SYSTEM");
snprintf (config_file, 4096, "%s/freem/%s/freem.conf", SYSCONFDIR, fma_environment);
}
snprintf (env_config_file, 4096, "%s/freem/env.conf", SYSCONFDIR);
/*
printf ("action = '%s' object = '%s' environment = '%s' namespace = '%s' config_file = '%s' base_arg = '%d' next argument = '%s'\n", action, obj_str, fma_environment, fma_namespace, config_file, base_arg, argv[base_arg]);
exit(1);
*/
/* override for fmadm configure and daemon stuff */
if (got_action) {
if (strcmp (argv[1], "configure") == 0) {
fm_configure ();
exit (0);
}
else if (strcmp (argv[1], "reconfigure") == 0) {
fm_reconfigure ();
exit (0);
}
else if (strcmp (argv[1], "start") == 0 && strcmp (argv[2], "environment") == 0) {
act = ACT_START;
obj = OBJ_DAEMON;
goto process_args;
}
else if (strcmp (argv[1], "stop") == 0 && strcmp (argv[2], "environment") == 0) {
act = ACT_STOP;
obj = OBJ_DAEMON;
goto process_args;
}
else if (strcmp (argv[1], "restart") == 0 && strcmp (argv[2], "environment") == 0) {
act = ACT_RESTART;
obj = OBJ_DAEMON;
goto process_args;
}
else if (strcmp (argv[1], "status") == 0 && strcmp (argv[2], "environment") == 0) {
act = ACT_STATUS;
obj = OBJ_DAEMON;
goto process_args;
}
}
pid = getpid ();
shm_init (16777216);
tp_init ();
jobtab_init ();
job_init (TRUE);
fm_sig_init ();
/* go to fmadm shell if no arguments passed */
if (!got_action && !got_object) return fm_shell ();
if (argc > 1 && strcmp (argv[1], "checkperms") == 0) {
fm_checkperms ();
exit (0);
}
set_namespace (fma_namespace, FALSE);
process_args:
/* allocate opts array */
/* first dimension */
if ((opts = (char **) malloc (FMA_MAXARGS * sizeof (char *))) == NULL) {
fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
return 1;
}
/* second dimension */
for (i = 0; i < FMA_MAXARGS; i++) {
if ((opts[i] = (char *) malloc (STRLEN * sizeof (char *))) == NULL) {
fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
return 1;
}
}
/* copy argv[base_arg] through argv[argc - 1] to opts[1] through opts[argc - 3] */
strncpy (opts[0], argv[0], STRLEN - 1); /* preserve argv[0] */
j = 1;
for (i = base_arg; i < argc; i++) {
if (i > FMA_MAXARGS) return fmadm_usage();
/* bail if we're going to overrun the array */
strncpy (opts[j++], argv[i], STRLEN - 1);
}
if (strncmp (action, "list", STRLEN - 1) == 0) act = ACT_LIST;
else if (strncmp (action, "examine", STRLEN - 1) == 0) act = ACT_EXAMINE;
else if (strncmp (action, "verify", STRLEN - 1) == 0) act = ACT_VERIFY;
else if (strncmp (action, "compact", STRLEN - 1) == 0) act = ACT_COMPACT;
else if (strncmp (action, "repair", STRLEN - 1) == 0) act = ACT_REPAIR;
else if (strncmp (action, "create", STRLEN - 1) == 0) act = ACT_CREATE;
else if (strncmp (action, "remove", STRLEN - 1) == 0) act = ACT_REMOVE;
else if (strncmp (action, "import", STRLEN - 1) == 0) act = ACT_IMPORT;
else if (strncmp (action, "export", STRLEN - 1) == 0) act = ACT_EXPORT;
else if (strncmp (action, "backup", STRLEN - 1) == 0) act = ACT_BACKUP;
else if (strncmp (action, "restore", STRLEN - 1) == 0) act = ACT_RESTORE;
else if (strncmp (action, "migrate", STRLEN - 1) == 0) act = ACT_MIGRATE;
else if (strncmp (action, "edit", STRLEN - 1) == 0) act = ACT_EDIT;
else if (strncmp (action, "start", STRLEN - 1) == 0) act = ACT_START;
else if (strncmp (action, "stop", STRLEN - 1) == 0) act = ACT_STOP;
else if (strncmp (action, "restart", STRLEN - 1) == 0) act = ACT_RESTART;
else if (strncmp (action, "status", STRLEN - 1) == 0) act = ACT_STATUS;
else return fmadm_usage();
if (strncmp (obj_str, "lock", STRLEN - 1) == 0) obj = OBJ_LOCK;
else if (strncmp (obj_str, "journal", STRLEN - 1) == 0) obj = OBJ_JOURNAL;
else if (strncmp (obj_str, "namespace", STRLEN - 1) == 0) obj = OBJ_NAMESPACE;
else if (strncmp (obj_str, "global", STRLEN - 1) == 0) obj = OBJ_GLOBAL;
else if (strncmp (obj_str, "routine", STRLEN - 1) == 0) obj = OBJ_ROUTINE;
else if (strncmp (obj_str, "job", STRLEN - 1) == 0) obj = OBJ_JOB;
else if (strncmp (obj_str, "environment", STRLEN - 1) == 0) obj = OBJ_DAEMON;
else return fmadm_usage();
if (act > ACT_EDIT) goto act_switch;
if (get_conf (fma_namespace, "routines_path", fma_routine_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine routine path for namespace %s\n", fma_namespace);
return 1;
}
if (get_conf (fma_namespace, "globals_path", fma_global_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine global path for namespace %s\n", fma_namespace);
return 1;
}
if (get_conf ("SYSTEM", "globals_path", fma_pct_global_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine %% global path for namespace %s\n", "SYSTEM");
return 1;
}
if (get_conf ("SYSTEM", "routines_path", fma_pct_routine_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine %% routine path for namespace %s\n", "SYSTEM");
return 1;
}
if (get_conf ("SYSTEM", "journal_file", fma_journal_path) == FALSE) {
strcpy (fma_journal_path, "");
}
if (get_conf ("SYSTEM", "journal_cut_threshold", fma_journal_cut_threshold) == FALSE) {
strcpy (fma_journal_cut_threshold, "1073741824");
}
strcpy (gloplib, fma_pct_global_path);
stcnv_c2m (gloplib);
strcpy (glopath, fma_global_path);
stcnv_c2m (glopath);
act_switch:
switch (act) {
case ACT_LIST:
fmadm_exit (fm_list (obj, optc, opts));
case ACT_EXAMINE:
fmadm_exit (fm_examine (obj, optc, opts));
case ACT_VERIFY:
fmadm_exit (fm_verify (obj, optc, opts));
case ACT_COMPACT:
fmadm_exit (fm_compact (obj, optc, opts));
case ACT_REPAIR:
fmadm_exit (fm_repair (obj, optc, opts));
case ACT_CREATE:
fmadm_exit (fm_create (obj, optc, opts));
case ACT_REMOVE:
fmadm_exit (fm_remove (obj, optc, opts));
case ACT_IMPORT:
fmadm_exit (fm_import (obj, optc, opts));
case ACT_EXPORT:
fmadm_exit (fm_export (obj, optc, opts));
case ACT_BACKUP:
fmadm_exit (fm_backup (obj, optc, opts));
case ACT_RESTORE:
fmadm_exit (fm_restore (obj, optc, opts));
case ACT_MIGRATE:
fmadm_exit (fm_migrate (obj, optc, opts));
case ACT_EDIT:
fmadm_exit (fm_edit (obj, optc, opts));
case ACT_START:
case ACT_STOP:
case ACT_RESTART:
case ACT_STATUS:
fmadm_exit (fm_daemonctl (act, obj, optc, opts));
default:
return fmadm_usage();
}
return 0; /* should never be reached */
} /* main() */
int fm_shell (void)
{
#if defined(HAVE_LIBREADLINE) && !defined(_AIX)
int cmd;
int i;
int j;
int obj;
int optc;
int argc;
char **args;
char **opts;
char *fmarl_buf;
char *fma_prompt = (char *) malloc (STRLEN * sizeof (char));
char *cmdt = (char *) malloc (65535 * sizeof (char));
char *result = (char *) malloc (65535 * sizeof (char));
/*
strcpy (fma_namespace, "SYSTEM");
set_namespace (fma_namespace, FALSE);
*/
snprintf (fma_prompt, STRLEN - 1, "fmadm [%s]> ", fma_namespace);
if (get_conf (fma_namespace, "routines_path", fma_routine_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine routine path for namespace %s\n", fma_namespace);
return 1;
}
if (get_conf (fma_namespace, "globals_path", fma_global_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine global path for namespace %s\n", fma_namespace);
return 1;
}
if (get_conf ("SYSTEM", "globals_path", fma_pct_global_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine %% global path for namespace %s\n", "SYSTEM");
return 1;
}
if (get_conf ("SYSTEM", "routines_path", fma_pct_routine_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine %% routine path for namespace %s\n", "SYSTEM");
return 1;
}
if (get_conf ("SYSTEM", "journal_file", fma_journal_path) == FALSE) {
strcpy (fma_journal_path, "");
}
if (get_conf ("SYSTEM", "journal_cut_threshold", fma_journal_cut_threshold) == FALSE) {
strcpy (fma_journal_cut_threshold, "1073741824");
}
strcpy (gloplib, fma_pct_global_path);
stcnv_c2m (gloplib);
strcpy (glopath, fma_global_path);
stcnv_c2m (glopath);
/* allocate args array */
/* first dimension */
if ((args = (char **) malloc (FMA_MAXARGS * sizeof (char *))) == NULL) {
fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
return 1;
}
/* second dimension */
for (i = 0; i < FMA_MAXARGS; i++) {
if ((args[i] = (char *) malloc (STRLEN * sizeof (char *))) == NULL) {
fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
return 1;
}
}
/* allocate opts array */
/* first dimension */
if ((opts = (char **) malloc (FMA_MAXARGS * sizeof (char *))) == NULL) {
fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
return 1;
}
/* second dimension */
for (i = 0; i < FMA_MAXARGS; i++) {
if ((opts[i] = (char *) malloc (STRLEN * sizeof (char *))) == NULL) {
fprintf (stderr, "fmadm [FATAL]: could not acquire memory\n");
return 1;
}
}
for (;;) {
fmarl_buf = readline (fma_prompt);
if (fmarl_buf == (char *) NULL) continue;
cmdt = strtok (fmarl_buf, " ");
if (cmdt == (char *) NULL) continue;
for (i = 0; i < strlen (cmdt); i++) cmdt[i] = cmdt[i] | 0140;
if (strcmp (cmdt, "exit") == 0) cmd = FMAC_EXIT;
else if (strcmp (cmdt, "quit") == 0) cmd = FMAC_EXIT;
else if (strcmp (cmdt, "select") == 0) cmd = FMAC_SELECT;
else if (strcmp (cmdt, "list") == 0) cmd = FMAC_LIST;
else if (strcmp (cmdt, "examine") == 0) cmd = FMAC_EXAMINE;
else if (strcmp (cmdt, "verify") == 0) cmd = FMAC_VERIFY;
else if (strcmp (cmdt, "compact") == 0) cmd = FMAC_COMPACT;
else if (strcmp (cmdt, "repair") == 0) cmd = FMAC_REPAIR;
else if (strcmp (cmdt, "create") == 0) cmd = FMAC_CREATE;
else if (strcmp (cmdt, "import") == 0) cmd = FMAC_IMPORT;
else if (strcmp (cmdt, "export") == 0) cmd = FMAC_EXPORT;
else if (strcmp (cmdt, "backup") == 0) cmd = FMAC_BACKUP;
else if (strcmp (cmdt, "restore") == 0) cmd = FMAC_RESTORE;
else if (strcmp (cmdt, "migrate") == 0) cmd = FMAC_MIGRATE;
else if (strcmp (cmdt, "edit") == 0) cmd = FMAC_EDIT;
else if (strcmp (cmdt, "set") == 0) cmd = FMAC_SET;
else if (strcmp (cmdt, "show") == 0) cmd = FMAC_SHOW;
else if (strcmp (cmdt, "remove") == 0) cmd = FMAC_REMOVE;
else cmd = FMAC_INVALID;
i = 0;
while ((result = strtok (NULL, " ")) != NULL) {
// printf ("%d = %s\n", i, result);
strcpy (args[i++], result);
}
argc = i;
j = 0;
for (i = 1; i < argc; i++) {
strncpy (opts[j++], args[i], STRLEN - 1);
}
optc = argc - 1;
if (i > 0) {
strcpy (obj_str, args[0]);
if (strncmp (obj_str, "lock", STRLEN - 1) == 0) obj = OBJ_LOCK;
else if (strncmp (obj_str, "journal", STRLEN - 1) == 0) obj = OBJ_JOURNAL;
else if (strncmp (obj_str, "namespace", STRLEN - 1) == 0) obj = OBJ_NAMESPACE;
else if (strncmp (obj_str, "global", STRLEN - 1) == 0) obj = OBJ_GLOBAL;
else if (strncmp (obj_str, "routine", STRLEN - 1) == 0) obj = OBJ_ROUTINE;
else if (strncmp (obj_str, "job", STRLEN - 1) == 0) obj = OBJ_JOB;
}
switch (cmd) {
case FMAC_SELECT:
break;
case FMAC_LIST:
fm_list (obj, optc, opts);
break;
case FMAC_EXAMINE:
fm_examine (obj, optc, opts);
break;
case FMAC_VERIFY:
fm_verify (obj, optc, opts);
break;
case FMAC_COMPACT:
fm_compact (obj, optc, opts);
break;
case FMAC_REPAIR:
fm_repair (obj, optc, opts);
break;
case FMAC_CREATE:
fm_create (obj, optc, opts);
break;
case FMAC_REMOVE:
fm_remove (obj, optc, opts);
break;
case FMAC_IMPORT:
fm_import (obj, optc, opts);
break;
case FMAC_EXPORT:
fm_export (obj, optc, opts);
break;
case FMAC_BACKUP:
fm_backup (obj, optc, opts);
break;
case FMAC_RESTORE:
fm_restore (obj, optc, opts);
break;
case FMAC_MIGRATE:
fm_migrate (obj, optc, opts);
break;
case FMAC_EDIT:
fm_edit (obj, optc, opts);
break;
case FMAC_SET:
if (i < 2) {
printf ("fmadm: syntax error\n");
break;
}
if (strcmp (args[0], "namespace") == 0) {
strcpy (fma_namespace, args[1]);
if (get_conf (fma_namespace, "routines_path", fma_routine_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine routine path for namespace %s\n", fma_namespace);
return 1;
}
if (get_conf (fma_namespace, "globals_path", fma_global_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine global path for namespace %s\n", fma_namespace);
return 1;
}
if (get_conf ("SYSTEM", "globals_path", fma_pct_global_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine %% global path for namespace %s\n", "SYSTEM");
return 1;
}
if (get_conf ("SYSTEM", "routines_path", fma_pct_routine_path) == FALSE) {
fprintf (stderr, "fmadm: cannot determine %% routine path for namespace %s\n", "SYSTEM");
return 1;
}
if (get_conf ("SYSTEM", "journal_file", fma_journal_path) == FALSE) {
strcpy (fma_journal_path, "");
}
if (get_conf ("SYSTEM", "journal_cut_threshold", fma_journal_cut_threshold) == FALSE) {
strcpy (fma_journal_cut_threshold, "1073741824");
}
strcpy (gloplib, fma_pct_global_path);
stcnv_c2m (gloplib);
strcpy (glopath, fma_global_path);
stcnv_c2m (glopath);
snprintf (fma_prompt, STRLEN - 1, "fmadm [%s]> ", fma_namespace);
}
else if (strcmp (args[0], "maintenance") == 0) {
if (strcmp (args[1], "on") == 0) {
shm_config->hdr->maintenance_mode = 1;
break;
}
else if (strcmp (args[1], "off") == 0) {
shm_config->hdr->maintenance_mode = 0;
break;
}
else {
printf ("fmadm: syntax error\n");
}
printf ("fmadm: syntax error\n");
}
else {
printf ("fmadm: syntax error\n");
break;
}
break;
case FMAC_SHOW:
printf ("Namespace: %s\n", fma_namespace);
printf ("Routine Path: %s\n", fma_routine_path);
printf ("%%-Routine Path: %s\n", fma_pct_routine_path);
printf ("Global Path: %s\n", fma_global_path);
printf ("%%-Global Path: %s\n", fma_pct_global_path);
printf ("Journal File: %s\n", fma_journal_path);
printf ("Journal Cut Threshold: %s bytes\n", fma_journal_cut_threshold);
break;
case FMAC_EXIT:
fmadm_exit (0);
break;
default:
printf ("fmadm: '%s' is not a valid fmadm command\n", cmdt);
break;
}
}
#endif
}
void fmadm_exit (int retval)
{
locktab_unlock_all ();
job_remove (pid);
shm_exit ();
exit (retval);
}
int fmadm_usage (void)
{
fprintf (stdout, "\nusage: fmadm <action> <object> [-e=<environment] [-n=<namespace>] [-u=<user>] [-g=<group>] [-E=true|false] [OPTIONS]\n");
fprintf (stdout, " fmadm configure\n");
fprintf (stdout, " fmadm reconfigure\n");
fprintf (stdout, " <action> can be one of:\n");
fprintf (stdout, " list, examine, verify, compact, repair, create, remove,\n");
fprintf (stdout, " import, export, backup, restore, migrate, edit, start,\n");
fprintf (stdout, " stop, restart, status\n\n");
fprintf (stdout, " <object> can be one of:\n");
fprintf (stdout, " lock, journal, namespace, global, routine, job,\n");
fprintf (stdout, " environment\n\n");
fprintf (stdout, " Not all actions are valid for all objects. Please see the FreeM manual\n");
fprintf (stdout, " for details on fmadm usage and options.\n\n");
return 1;
} /* fmadm_usage() */
int fm_list (short object, int optc, char **options)
{
switch (object) {
case OBJ_LOCK:
return fma_locks_list (optc, options);
case OBJ_ROUTINE:
return fma_routines_list (optc, options);
case OBJ_GLOBAL:
return fma_globals_list (optc, options);
case OBJ_JOB:
return fma_jobs_list (optc, options);
default:
fprintf (stderr, "fmadm: 'list' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_list() */
int fm_examine (short object, int optc, char **options)
{
switch (object) {
case OBJ_ROUTINE:
return fma_routines_examine (optc, options);
case OBJ_GLOBAL:
return fma_globals_examine (optc, options);
case OBJ_JOB:
return fma_jobs_examine (optc, options);
case OBJ_JOURNAL:
return fma_journals_examine (optc, options);
default:
fprintf (stderr, "fmadm: 'examine' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_examine() */
int fm_verify (short object, int optc, char **options)
{
switch (object) {
case OBJ_GLOBAL:
return fma_globals_verify (optc, options);
default:
fprintf (stderr, "fmadm: 'examine' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_verify() */
int fm_compact (short object, int optc, char **options)
{
switch (object) {
default:
fprintf (stderr, "fmadm: 'compact' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_compact() */
int fm_repair (short object, int optc, char **options)
{
switch (object) {
default:
fprintf (stderr, "fmadm: 'repair' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_repair() */
int fm_create (short object, int optc, char **options)
{
switch (object) {
default:
fprintf (stderr, "fmadm: 'create' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_create() */
int fm_remove (short object, int optc, char **options)
{
switch (object) {
case OBJ_JOB:
return fma_jobs_remove (optc, options);
case OBJ_LOCK:
return fma_locks_remove (optc, options);
case OBJ_ROUTINE:
return fma_routines_remove (optc, options);
case OBJ_GLOBAL:
return fma_globals_remove (optc, options);
default:
fprintf (stderr, "fmadm: 'remove' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_remove() */
int fm_import (short object, int optc, char **options)
{
switch (object) {
case OBJ_ROUTINE:
return fma_routines_import (optc, options);
default:
fprintf (stderr, "fmadm: 'import' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_import() */
int fm_export (short object, int optc, char **options)
{
switch (object) {
case OBJ_ROUTINE:
return fma_routines_export (optc, options);
default:
fprintf (stderr, "fmadm: 'export' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_export() */
int fm_backup (short object, int optc, char **options)
{
switch (object) {
case OBJ_ROUTINE:
return fma_routines_backup (optc, options);
default:
fprintf (stderr, "fmadm: 'backup' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_backup() */
int fm_restore (short object, int optc, char **options)
{
switch (object) {
case OBJ_JOURNAL:
return fma_journals_restore (optc, options);
default:
fprintf (stderr, "fmadm: 'restore' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_restore() */
int fm_migrate (short object, int optc, char **options)
{
switch (object) {
default:
fprintf (stderr, "fmadm: 'migrate' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_migrate() */
int fm_edit (short object, int optc, char **options)
{
switch (object) {
case OBJ_ROUTINE:
return fma_routines_edit (optc, options);
case OBJ_GLOBAL:
return fma_globals_edit (optc, options);
default:
fprintf (stderr, "fmadm: 'edit' is an invalid action for '%s'\n", obj_str);
return 1;
}
} /* fm_edit() */
long fm_get_pid (char *env)
{
char pid_file[4096];
char tmp_pid[255];
long res;
FILE *fp;
snprintf (pid_file, 4095, "%s/freem/run/%s.pid", LOCALSTATEDIR, env);
if ((fp = fopen (pid_file, "r")) != NULL) {
if (fgets (tmp_pid, 255, fp)) {
fclose (fp);
return atol (tmp_pid);
}
else {
fclose (fp);
return -1;
}
}
else {
return -1;
}
}
int fm_validate_environment (char *env)
{
FILE *fp;
char line[255];
char chkline[255];
snprintf (chkline, 254, "[%s]\n", env);
if ((fp = fopen (env_config_file, "r")) == NULL) {
fprintf (stderr, "fmadm: could not open %s [%s]\n", env_config_file, strerror (errno));
return FALSE;
}
while (fgets (line, 254, fp)) {
if (strncmp (line, chkline, 254) == 0) {
fclose (fp);
return TRUE;
}
}
fclose (fp);
return FALSE;
}
int fm_start_environment (char *env, char *e_user, char *e_grp)
{
char basecmd[255];
char cmd[4096];
if (fm_environment_running (env) == TRUE) {
return TRUE;
}
#if !defined(__OS2__)
snprintf (basecmd, 254, "%s/bin/freem", PREFIX);
#else
snprintf (basecmd, 254, "%s/bin/freemd.exe", PREFIX);
#endif
#if !defined(__OS2__)
snprintf (cmd, 4095, "%s -d -e %s -u %s -g %s", basecmd, env, e_user, e_grp);
#else
sprintf (cmd, 4095, "%s -d -k -e %s -u %s -g %s", basecmd, env, e_user, e_grp);
#endif
system (cmd);
sleep (1);
return (fm_environment_running (env));
}
int fm_stop_environment (char *env)
{
long epid;
epid = fm_get_pid (env);
if (epid > -1) {
kill (epid, SIGINT);
sleep (5);
if (fm_environment_running (env) == FALSE) {
return TRUE;
}
else {
kill (epid, SIGTERM);
sleep (5);
if (fm_environment_running (env) == FALSE) {
return TRUE;
}
else {
kill (epid, SIGKILL);
sleep (5);
if (fm_environment_running (env) == FALSE) {
return TRUE;
}
else {
return FALSE;
}
}
}
}
else {
return FALSE;
}
}
int fm_environment_running (char *env)
{
long epid;
int result;
epid = fm_get_pid (env);
if (epid == -1) {
return FALSE;
}
else {
result = kill (epid, 0);
return ((result == 0) ? TRUE : FALSE);
}
}
int fm_daemonctl (short action, short object, int optc, char **options)
{
FILE *ef;
char *envlist;
char env[255];
char line[255];
char tmps[255];
char *cur_env;
char verb[40];
char e_user[255];
char e_grp[255];
char e_ena[10];
char *savptr;
int result;
long epid;
switch (action) {
case ACT_START:
sprintf (verb, "starting");
break;
case ACT_STOP:
sprintf (verb, "stopping");
break;
case ACT_RESTART:
sprintf (verb, "restarting");
break;
case ACT_STATUS:
sprintf (verb, "checking status of");
break;
}
if (optc) {
/* environment list specified as command-line argument */
envlist = (char *) malloc (sizeof (char) * BIGSTR);
NULLPTRCHK(envlist,"fm_daemonctl");
strcpy (envlist, options[1]);
}
else {
/* no environment specified; do 'action' for all environments */
envlist = (char *) malloc (sizeof (char) * BIGSTR);
NULLPTRCHK(envlist,"fm_daemonctl");
ef = fopen (env_config_file, "r");
while (fgets (line, 254, ef)) {
if (line[0] == '[') {
strncpy (env, &(line[1]), 255);
env[strlen (env) - 2] = '\0';
snprintf (tmps, 255, "%s,", env);
strncat (envlist, tmps, BIGSTR - 1);
}
}
envlist[strlen (envlist) - 1] = '\0';
fclose (ef);
}
savptr = envlist;
cur_env = strtok_r (envlist, ",", &savptr);
do {
if (fm_validate_environment (cur_env) == FALSE) {
fprintf (stderr, "fmadm: %s is not a valid environment\n", cur_env);
continue;
}
result = read_profile_string (env_config_file, cur_env, "enabled", e_ena);
if (result == FALSE || strcmp (e_ena, "true") == 0) {
result = read_profile_string (env_config_file, cur_env, "user", e_user);
if (result == FALSE) {
strcpy (e_user, "freem");
}
result = read_profile_string (env_config_file, cur_env, "group", e_grp);
if (result == FALSE) {
strcpy (e_grp, "freem");
}
switch (action) {
case ACT_START:
case ACT_STOP:
case ACT_RESTART:
fprintf (stderr, "fmadm: %s environment %s... ", verb, cur_env);
break;
case ACT_STATUS:
fprintf (stderr, "fmadm: %s environment %s\n", verb, cur_env);
break;
}
switch (action) {
case ACT_START:
result = fm_start_environment (cur_env, e_user, e_grp);
if (result == TRUE) {
fprintf (stderr, "[OK]\n");
}
else {
fprintf (stderr, "[FAIL]\n");
}
break;
case ACT_STOP:
result = fm_stop_environment (cur_env);
if (result == TRUE) {
fprintf (stderr, "[OK]\n");
}
else {
fprintf (stderr, "[FAIL]\n");
}
break;
case ACT_RESTART:
if (fm_stop_environment (cur_env) == TRUE) {
result = fm_start_environment (cur_env, e_user, e_grp);
if (result == TRUE) {
fprintf (stderr, "[OK]\n");
}
else {
fprintf (stderr, "[FAIL]\n");
}
}
else {
fprintf (stderr, "[FAIL]\n");
}
break;
case ACT_STATUS:
epid = fm_get_pid (cur_env);
if (epid > -1) {
fprintf (stderr, " - %s environment daemon running as pid %d\n", cur_env, epid);
}
else {
fprintf (stderr, " - %s environment daemon does not appear to be running\n", cur_env);
}
}
}
else {
printf ("fmadm: %s environment is disabled; skipping\n", cur_env);
}
} while ((cur_env = strtok_r (NULL, ",", &savptr)) != NULL);
free (envlist);
exit (0);
} /* fm_daemonctl() */
void fm_checkperms(void)
{
} /* fm_checkperms() */
void fm_reconfigure(void)
{
char config_backup[4096];
char vers[4096];
int retval;
if (geteuid () != 0) {
fprintf (stderr, "fmadm: not superuser\n");
exit (1);
}
snprintf (config_backup, 4095, "%s.orig", config_file);
fprintf (stderr, "fmadm: reconfiguring FreeM with system defaults for %s...\n", FREEM_VERSION_CSTR);
fprintf (stderr, "fmadm: backing up %s to %s...\t", config_file, config_backup);
#if !defined(__OS2__)
retval = cp (config_backup, config_file);
#else
retval = DosCopy (config_file, config_backup);
#endif
if (retval == 0) {
fprintf (stderr, "[OK]\n");
fm_configure ();
fprintf (stderr, "\n\nYou may wish to edit %s if site-specific changes were made to the original FreeM configuration.\n", config_file);
exit (0);
}
else {
fprintf (stderr, "[FAIL (%s)]\n", strerror (errno));
exit (1);
}
} /* fm_reconfigure() */
void update_conf (char *file, char *section, char *key, char *new_value)
{
char old_value[255];
char tbuf[255];
snprintf (tbuf, 254, "%s.%s", section, key);
read_profile_string (file, section, key, old_value);
if (strcmp (old_value, new_value) != 0) {
modify_profile_string (file, section, key, new_value);
fprintf (stderr, "\t%-40s%-20s -> %s\n", tbuf, old_value, new_value);
}
else {
fprintf (stderr, "\t%-40s%-20s\n", tbuf, "no change");
}
}
void fm_configure (void)
{
char rundir[4096];
char varbase[4096];
char sysrtn[4096];
char sysgbl[4096];
char usrrtn[4096];
char usrgbl[4096];
char jnldir[4096];
char jnlfile[4096];
char jnlmode[4];
char jnlhostid[4096];
char jnlcut[4096];
char hostid[4096];
char confbase[4096];
char envbase[4096];
char nsbase[4096];
char buf[4096];
FILE *fp;
int reconfigure = FALSE;
struct stat etcstat;
int stat_result;
DIR *dir;
struct dirent *ent;
char src_dir[4096];
char dest_dir[4096];
char *username = env_user;
char *groupname = env_group;
#if !defined(__OS2__)
if (geteuid () != 0) {
fprintf (stderr, "fmadm: not superuser\n");
exit (1);
}
struct group *d_grp;
struct passwd *d_user;
gid_t d_gid;
uid_t d_uid;
if ((d_grp = getgrnam (groupname)) == NULL) {
fprintf (stderr, "fmadm: '%s' group must exist before configuring\n", groupname);
exit (1);
}
d_gid = d_grp->gr_gid;
if ((d_user = getpwnam (username)) == NULL) {
fprintf (stderr, "fmadm: '%s' user must exist before configuring\n", username);
exit (1);
}
d_uid = d_user->pw_uid;
#endif
snprintf (varbase, 4095, "%s/freem", LOCALSTATEDIR);
snprintf (rundir, 4095, "%s/freem/run", LOCALSTATEDIR);
snprintf (sysrtn, 4095, "%s/freem/%s/SYSTEM/routines", LOCALSTATEDIR, fma_environment);
snprintf (sysgbl, 4095, "%s/freem/%s/SYSTEM/globals", LOCALSTATEDIR, fma_environment);
snprintf (usrrtn, 4095, "%s/freem/%s/USER/routines", LOCALSTATEDIR, fma_environment);
snprintf (usrgbl, 4095, "%s/freem/%s/USER/globals", LOCALSTATEDIR, fma_environment);
snprintf (jnldir, 4095, "%s/freem/%s/journals", LOCALSTATEDIR, fma_environment);
snprintf (jnlfile, 4095, "%s/freem_journal_%s.dat", jnldir, fma_environment);
snprintf (jnlmode, 3, "on");
snprintf (jnlhostid, 4095, "DEFAULT");
snprintf (jnlcut, 4095, "4294967000");
if (geteuid () != 0) {
fprintf (stderr, "fmadm: not superuser\n");
exit (1);
}
if (file_exists (config_file)) {
reconfigure = TRUE;
}
gethostname (hostid, 4095);
uuid_v4 (buf);
snprintf (jnlhostid, 4095, "%s:%s", hostid, buf);
snprintf (confbase, 4095, "%s/freem", SYSCONFDIR);
snprintf (envbase, 4095, "%s/freem/%s", SYSCONFDIR, fma_environment);
snprintf (nsbase, 4095, "%s/freem/%s", LOCALSTATEDIR, fma_environment);
#if defined(__OS2__)
{
char srcfile[PATHLEN];
char dstfile[PATHLEN];
snprintf (srcfile, PATHLEN, "%s/bin/freem.exe", PREFIX);
snprintf (dstfile, PATHLEN, "%s/bin/freemd.exe", PREFIX);
unlink (dstfile);
fprintf (stderr, "fmadm: running on OS/2; will copy %s to %s\n", srcfile, dstfile);
if (DosCopy (srcfile, dstfile, 1) != 0) {
fprintf (stderr, "fmadm: fatal error copying %s to %s\n", srcfile, dstfile);
exit (1);
}
chmod (dstfile, 0755);
}
#endif
if (reconfigure == FALSE) {
printf ("\nFreeM Initial Environment Configuration\n");
printf ("---------------------------------------\n\n");
printf ("This utility will create the initial configuration files for ");
printf ("FreeM environment '%s' (owned by %s:%s) in '%s'.\n\n", fma_environment, username, groupname, config_file);
}
else {
printf ("\nFreeM Environment Upgrade/Reconfiguration\n");
printf ("-----------------------------------------\n\n");
printf ("This utility will update the configuration files for ");
printf ("FreeM environment '%s' (owned by %s:%s) in '%s'.\n\n", fma_environment, username, groupname, config_file);
}
/* check for existence of needed directories */
if (stat (SYSCONFDIR, &etcstat) == -1) {
fprintf (stderr, "fmadm: creating %s [SYSCONFDIR]\n", SYSCONFDIR);
mkdir (SYSCONFDIR, 0775);
set_permissions (SYSCONFDIR, username, groupname, 0775);
}
if (stat (confbase, &etcstat) == -1) {
fprintf (stderr, "fmadm: creating %s [confbase]\n", confbase);
mkdir (confbase, 0775);
set_permissions (confbase, username, groupname, 0775);
}
if (stat (varbase, &etcstat) == -1) {
fprintf (stderr, "fmadm: creating %s [varbase]\n", varbase);
mkdir (varbase, 0775);
set_permissions (varbase, username, groupname, 0775);
}
if (stat (envbase, &etcstat) == -1) {
fprintf (stderr, "fmadm: creating %s [envbase]\n", envbase);
mkdir (envbase, 0775);
set_permissions (envbase, username, groupname, 0775);
}
if (stat (rundir, &etcstat) == -1) {
fprintf (stderr, "fmadm: creating %s [rundir]\n", rundir);
mkdir (rundir, 0777);
chmod (rundir, 0777);
}
if (stat (nsbase, &etcstat) == -1) {
fprintf (stderr, "fmadm: creating %s [nsbase]\n", nsbase);
mkdir (nsbase, 0775);
set_permissions (nsbase, username, groupname, 0775);
}
if (stat (jnldir, &etcstat) == -1) {
fprintf (stderr, "fmadm: creating %s [jnldir]\n", jnldir);
mkdir (jnldir, 0775);
set_permissions (jnldir, username, groupname, 0775);
}
snprintf (src_dir, 4095, "%s/freem/mlib", DATADIR);
snprintf (dest_dir, 4095, "%s/freem/%s/SYSTEM/routines", LOCALSTATEDIR, fma_environment);
if (reconfigure == FALSE) {
fprintf (stderr, "fmadm: populating new environment '%s'\n", fma_environment);
}
else {
fprintf (stderr, "fmadm: upgrading environment '%s'\n", fma_environment);
}
snprintf (buf, 4095, "%s/freem/%s/SYSTEM", LOCALSTATEDIR, fma_environment);
mkdir (buf, 0775);
set_permissions (buf, username, groupname, 0775);
snprintf (buf, 4095, "%s/freem/%s/USER", LOCALSTATEDIR, fma_environment);
mkdir (buf, 0775);
set_permissions (buf, username, groupname, 0775);
snprintf (buf, 4095, "%s/freem/%s/SYSTEM/routines", LOCALSTATEDIR, fma_environment);
mkdir (buf, 0775);
set_permissions (buf, username, groupname, 0775);
snprintf (buf, 4095, "%s/freem/%s/USER/globals", LOCALSTATEDIR, fma_environment);
mkdir (buf, 0775);
set_permissions (buf, username, groupname, 0775);
snprintf (buf, 4095, "%s/freem/%s/SYSTEM/globals", LOCALSTATEDIR, fma_environment);
mkdir (buf, 0775);
set_permissions (buf, username, groupname, 0775);
snprintf (buf, 4095, "%s/freem/%s/USER/routines", LOCALSTATEDIR, fma_environment);
mkdir (buf, 0775);
set_permissions (buf, username, groupname, 0775);
fprintf (stderr, "fmadm: copying vendor routines from '%s' to '%s'...\n", src_dir, dest_dir);
if ((dir = opendir (src_dir)) == NULL) {
fprintf (stderr, "\nfmadm: could not open source directory %s\n", src_dir);
exit (1);
}
while ((ent = readdir (dir)) != NULL) {
char infile[4096];
char outfile[4096];
if ((strcmp (ent->d_name, ".") != 0) && (strcmp (ent->d_name, "..") != 0)) {
snprintf (infile, 4095, "%s/%s", src_dir, ent->d_name);
snprintf (outfile, 4095, "%s/%s", dest_dir, ent->d_name);
if (stat (outfile, &etcstat) == 0) {
unlink (outfile);
fprintf (stderr, "\tupgrade -> %s\n", ent->d_name);
}
else {
fprintf (stderr, "\tnew -> %s\n", ent->d_name);
}
#if !defined(__OS2__)
if (cp (outfile, infile) != 0) {
fprintf (stderr, "fmadm: failure copying %s to %s\n", infile, outfile);
}
set_permissions (outfile, username, groupname, 0755);
#else
if (DosCopy (infile, outfile, 1) != 0) {
fprintf (stderr, "fmadm: failure copying %s to %s\n", infile, outfile);
}
#endif
}
}
if (fm_validate_environment (fma_environment) == FALSE) {
fp = fopen (env_config_file, "a+");
fprintf (stderr, "Creating %s... ", env_config_file);
snprintf (buf, 4095, "[%s]", fma_environment);
fm_write (fp, buf);
snprintf (buf, 4095, "user=%s", env_user);
fm_write (fp, buf);
snprintf (buf, 4095, "group=%s", env_group);
fm_write (fp, buf);
snprintf (buf, 4095, "enabled=%s", env_enabled);
fm_write (fp, buf);
snprintf (buf, 4095, "env_path=%s/freem/%s", LOCALSTATEDIR, fma_environment);
fm_write (fp, buf);
fclose (fp);
fprintf (stderr, "[OK]\n");
}
else {
char modtmp[255];
fprintf (stderr, "\nUpdating %s: \n", env_config_file);
update_conf (env_config_file, fma_environment, "user", env_user);
update_conf (env_config_file, fma_environment, "group", env_group);
update_conf (env_config_file, fma_environment, "enabled", env_enabled);
}
if (reconfigure == FALSE) {
fp = fopen (config_file, "a+");
fprintf (stderr, "Creating %s... ", config_file);
snprintf (buf, 4095, "[SYSTEM]");
fm_write (fp, buf);
snprintf (buf, 4095, "root=%s/freem/%s/SYSTEM", LOCALSTATEDIR, fma_environment);
fm_write (fp, buf);
snprintf (buf, 4095, "routines_path=%s", sysrtn);
fm_write (fp, buf);
snprintf (buf, 4095, "globals_path=%s", sysgbl);
fm_write (fp, buf);
snprintf (buf, 4095, "journal_file=%s", jnlfile);
fm_write (fp, buf);
snprintf (buf, 4095, "journal_mode=%s", jnlmode);
fm_write (fp, buf);
snprintf (buf, 4095, "journal_host_id=%s", jnlhostid);
fm_write (fp, buf);
snprintf (buf, 4095, "journal_cut_threshold=%s", jnlcut);
fm_write (fp, buf);
snprintf (buf, 4095, "zdate_format=%%x");
fm_write (fp, buf);
snprintf (buf, 4095, "ztime_format=%%X");
fm_write (fp, buf);
snprintf (buf, 4095, "\n[USER]");
fm_write (fp, buf);
snprintf (buf, 4095, "root=%s/freem/%s/USER", LOCALSTATEDIR, fma_environment);
fm_write (fp, buf);
snprintf (buf, 4095, "routines_path=%s", usrrtn);
fm_write (fp, buf);
snprintf (buf, 4095, "globals_path=%s", usrgbl);
fm_write (fp, buf);
fclose (fp);
set_permissions (config_file, username, groupname, 0755);
fprintf (stderr, "[OK]\n");
printf ("FreeM initial configuration is complete.\n\n");
}
else {
char tmpsd[255];
read_profile_string (config_file, "SYSTEM", "journal_host_id", tmpsd);
/* existing configuration */
fprintf (stderr, "\nUpdating environment configuration for %s:\n", fma_environment);
snprintf (buf, 4095, "%s/freem/%s/SYSTEM", LOCALSTATEDIR, fma_environment);
update_conf (config_file, "SYSTEM", "root", buf);
update_conf (config_file, "SYSTEM", "routines_path", sysrtn);
update_conf (config_file, "SYSTEM", "globals_path", sysgbl);
update_conf (config_file, "SYSTEM", "journal_file", jnlfile);
update_conf (config_file, "SYSTEM", "journal_mode", jnlmode);
update_conf (config_file, "SYSTEM", "journal_host_id", tmpsd);
update_conf (config_file, "SYSTEM", "journal_cut_threshold", jnlcut);
snprintf (buf, 4095, "%%x");
update_conf (config_file, "SYSTEM", "zdate_format", buf);
snprintf (buf, 4095, "%%X");
update_conf (config_file, "SYSTEM", "ztime_format", buf);
/* USER */
snprintf (buf, 4095, "%s/freem/%s/USER", LOCALSTATEDIR, fma_environment);
update_conf (config_file, "USER", "root", buf);
update_conf (config_file, "USER", "routines_path", usrrtn);
update_conf (config_file, "USER", "globals_path", usrgbl);
}
printf ("\n\nUSER globals: %s\n", usrgbl);
printf ("USER routines: %s\n", usrrtn);
printf ("SYSTEM globals: %s\n", sysgbl);
printf ("SYSTEM routines: %s\n", sysrtn);
printf ("After-image journal: %s [%s]\n", jnlfile, jnlmode);
printf ("Journal cut threshold: %s bytes\n", jnlcut);
printf ("Distributed journaling host ID: %s\n", jnlhostid);
if (reconfigure == TRUE) {
fprintf (stderr, "\nIf you previously defined environments other than '%s', you should run\n'fmadm reconfigure -e=<environment-name>' on each of them to ensure they have\nthe latest vendor routines and correct, updated settings.\n\n", fma_environment);
}
} /* fm_configure */
void set_permissions(char *path, char *user, char *grp, int mode)
{
#if !defined(__OS2__)
struct group *d_grp;
struct passwd *d_user;
gid_t d_gid;
uid_t d_uid;
#endif
#if !defined(__OS2__)
if ((d_grp = getgrnam (grp)) == NULL) {
fprintf (stderr, "fmadm: '%s' group must exist before configuring\n", grp);
exit (1);
}
d_gid = d_grp->gr_gid;
if ((d_user = getpwnam (user)) == NULL) {
fprintf (stderr, "fmadm: '%s' user must exist before configuring\n", user);
exit (1);
}
d_uid = d_user->pw_uid;
if (chown (path, d_uid, d_gid) != 0) {
fprintf (stderr, "fmadm: error setting ownership on %s\n", path);
exit (1);
}
#endif
if (chmod (path, mode) != 0) {
fprintf (stderr, "fmadm: error setting permissions on %s to %d\n", path, mode);
exit (1);
}
}
void fm_write (FILE *file, char *buf)
{
fprintf (file, "%s\n", buf);
}
void fm_sig_attach (int sig, void *handler)
{
struct sigaction act;
act.sa_handler = handler;
sigaction (sig, &act, NULL);
}
void fm_sig_init (void)
{
sig_attach (SIGINT, &fm_on_sigint);
sig_attach (SIGTERM, &fm_on_sigterm);
}
void fm_on_sigint (void)
{
fprintf (stderr, "\nfmadm: caught SIGINT\n");
fmadm_exit (0);
}
void fm_on_sigterm (void)
{
fprintf (stderr, "\nfmadm: caught SIGTERM\n");
fmadm_exit (0);
}
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fmadm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src