iSharkFly-Open
/
fis-gtm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
fis-gtm/sr_unix/gtmsecshr.c

876 lines
32 KiB
C
Raw Permalink Blame History

/****************************************************************
* *
* Copyright 2001, 2011 Fidelity Information Services, Inc *
* *
* This source code contains the intellectual property *
* of its copyright holder(s), and is made available *
* under a license. If you do not know the terms of *
* the license, please stop and do not read further. *
* *
****************************************************************/
#include "mdef.h"
#include "main_pragma.h"
#include <sys/time.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include "gtm_stat.h"
#include "gtm_socket.h"
#include <sys/un.h>
#include <signal.h>
#if !defined(_AIX) && !defined(__linux__) && !defined(__hpux) && !defined(__CYGWIN__) && !defined(__MVS__)
#include <siginfo.h>
#endif
#include "gtm_stdlib.h"
#include "gtm_sem.h"
#include "gtm_string.h"
#include "gtm_fcntl.h"
#include <errno.h>
#include "gtm_time.h"
#include "gtm_unistd.h"
#include "gtm_stdio.h"
#include "gtm_permissions.h"
#if defined(__MVS__)
#include "gtm_zos_io.h"
#endif
#include "cli.h"
#include "error.h"
#include "gtm_logicals.h"
#include "io.h"
#include "gtmsecshr.h"
#include "gdsroot.h"
#include "gtm_facility.h"
#include "fileinfo.h"
#include "gdsbt.h"
#include "gdsfhead.h"
#include "filestruct.h"
#include "mutex.h"
#include "iosp.h"
#include "gt_timer.h"
#include "gtm_c_stack_trace.h"
#include "eintr_wrappers.h"
#include "eintr_wrapper_semop.h"
#include "gtmimagename.h"
#include "util.h"
#include "send_msg.h"
#include "generic_signal_handler.h"
#include "gtmmsg.h"
#include "have_crit.h"
#include "trans_log_name.h"
#include "sig_init.h"
#include "gtmio.h"
#include "file_head_read.h"
#include "file_head_write.h"
#include "suspsigs_handler.h"
#include "gtm_env_init.h" /* for gtm_env_init() prototype */
#include "gtm_imagetype_init.h"
#include "gtm_threadgbl_init.h"
#include "fork_init.h"
#ifdef UNICODE_SUPPORTED
#include "gtm_icu_api.h"
#include "gtm_utf8.h"
#endif
#define TIME_FORMAT "_%Y%j%H%M%S" /* .yearjuliendayhoursminutesseconds */
GBLDEF CLI_ENTRY *cmd_ary = NULL; /* GTMSECSHR does not have any command tables so initialize command array to NULL */
GBLREF int gtmsecshr_log_file;
GBLREF int gtmsecshr_sockfd;
GBLREF struct sockaddr_un gtmsecshr_sock_name;
GBLREF int gtmsecshr_sockpath_len;
GBLREF key_t gtmsecshr_key;
GBLREF uint4 process_id;
GBLREF boolean_t need_core;
static volatile int gtmsecshr_timer_popped;
static volatile boolean_t ready_to_switch_log_file = FALSE;
static int4 times_to_switch_log_file = 0;
static int gtmsecshr_logpath_len;
static int gtmsecshr_socket_dir_len;
static char gtmsecshr_logpath[MAX_TRANS_NAME_LEN];
void clean_client_sockets(char *path);
void gtmsecshr_timer_handler(void);
void gtmsecshr_signal_handler(int sig, siginfo_t *info, void *context);
ZOS_ONLY(boolean_t gtm_tag_error(char *filename, int realtag, int desiredtag);)
error_def(ERR_ASSERT);
error_def(ERR_BADTAG);
error_def(ERR_DBFILOPERR);
error_def(ERR_DBNOTGDS);
error_def(ERR_GTMASSERT);
error_def(ERR_GTMCHECK);
error_def(ERR_GTMSECSHR);
error_def(ERR_GTMSECSHRCHDIRF);
error_def(ERR_GTMSECSHRDEFLOG);
error_def(ERR_GTMSECSHRFORKF);
error_def(ERR_GTMSECSHRLOGF);
error_def(ERR_GTMSECSHRLOGSWH);
error_def(ERR_GTMSECSHROPCMP);
error_def(ERR_GTMSECSHRRECVF);
error_def(ERR_GTMSECSHRSCKSEL);
error_def(ERR_GTMSECSHRSENDF);
error_def(ERR_GTMSECSHRSGIDF);
error_def(ERR_GTMSECSHRSOCKET);
error_def(ERR_GTMSECSHRSRVF);
error_def(ERR_GTMSECSHRSRVFID);
error_def(ERR_GTMSECSHRSRVFIL);
error_def(ERR_GTMSECSHRSSIDF);
error_def(ERR_GTMSECSHRSTART);
error_def(ERR_GTMSECSHRSUIDF);
error_def(ERR_GTMSECSHRTMOUT);
error_def(ERR_GTMSECSHRTMPPATH);
error_def(ERR_LOGTOOLONG);
error_def(ERR_MEMORY);
error_def(ERR_OUTOFSPACE);
error_def(ERR_STACKOFLOW);
error_def(ERR_TEXT);
/* Note that this condition handler is not really properly setup as a condition handler
in that it has none of the required condition handler macros in it. It's job is just
to perform shutdown logic when it is called. No further handlers are called hence
the streamlined nature.
*/
CONDITION_HANDLER(gtmsecshr_cond_hndlr)
{
gtmsecshr_exit(arg, DUMPABLE ? TRUE : FALSE);
}
/* If there was a leftover socket, the client will append a lower case letter
which we take as a flag to delete all sockets for the current client pid
*/
void clean_client_sockets(char *path)
{
char last, suffix;
int len;
len = STRLEN(path);
last = path[len - 1];
for (suffix = 'a'; last > suffix; suffix++)
{
path[len - 1] = suffix; /* OK since main loop is done with this */
UNLINK(path); /* We could care less about errors */
}
path[len - 1] = '\0'; /* The normal name for the pid */
UNLINK(path);
return;
}
/* For gtmsecshr, override this routine since crit doesn't exist here */
uint4 have_crit(uint4 crit_state)
{
return 0;
}
/* For gtmsecshr, override this routine so no fork is done */
void gtm_fork_n_core(void)
{
}
int main(void)
{
int serv_fail = 0;
int selstat;
int loop_limit = 0;
int save_errno;
int mesg_len;
int recd, sent;
int recv_len, send_len;
int recv_complete, send_complete;
int num_chars_recd, num_chars_sent;
int4 msec_timeout; /* timeout in milliseconds */
TID timer_id;
GTM_SOCKLEN_TYPE client_addr_len;
char *recv_ptr, *send_ptr;
fd_set wait_on_fd;
struct sockaddr_un client_addr;
struct timeval input_timeval;
gtmsecshr_mesg mesg;
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
gtm_imagetype_init(GTMSECSHR_IMAGE); /* Side-effect : Sets skip_dbtriggers to TRUE for trigger non-supporting platforms */
gtm_wcswidth_fnptr = NULL;
gtm_env_init(); /* read in all environment variables */
err_init(gtmsecshr_cond_hndlr);
gtmsecshr_init();
input_timeval.tv_sec = MAX_TIMEOUT_VALUE;
input_timeval.tv_usec = 0;
timer_id = (TID)main;
while (!loop_limit)
{
FD_ZERO(&wait_on_fd);
FD_SET(gtmsecshr_sockfd, &wait_on_fd);
gtmsecshr_timer_popped = FALSE;
if (times_to_switch_log_file > 0)
{
gtmsecshr_switch_log_file(0);
times_to_switch_log_file = 0;
}
ready_to_switch_log_file = TRUE;
SELECT(gtmsecshr_sockfd+1, (void *)&wait_on_fd, (void *)NULL, (void *)NULL, &input_timeval, selstat);
ready_to_switch_log_file = FALSE;
if (0 > selstat)
rts_error(VARLSTCNT(6) ERR_GTMSECSHR, 1, process_id, ERR_GTMSECSHRSCKSEL, 0, errno);
else if (0 == selstat)
{
gtm_putmsg(VARLSTCNT(1) ERR_GTMSECSHRTMOUT);
loop_limit = 1;
gtmsecshr_exit(0,0); /* doesn't return */
}
recd = 0;
mesg_len = 0;
recv_ptr = (char *)&mesg;
recv_len = SIZEOF(mesg);
recv_complete = 0;
client_addr_len = SIZEOF(struct sockaddr_un);
msec_timeout = timeout2msec(GTMSECSHR_MESG_TIMEOUT);
start_timer(timer_id, msec_timeout, gtmsecshr_timer_handler, 0, NULL);
while (!recv_complete)
{
num_chars_recd = (int)(RECVFROM(gtmsecshr_sockfd, (void *)recv_ptr, recv_len, 0,
(struct sockaddr *)&client_addr, &client_addr_len));
if ((-1 == num_chars_recd) && (gtmsecshr_timer_popped || EINTR != errno))
{
rts_error(VARLSTCNT(6) ERR_GTMSECSHR, 1, process_id, ERR_GTMSECSHRRECVF, 0, errno);
assert(FALSE); /* the above rts_error should never return */
} else if (0 == num_chars_recd)
recv_complete = 1;
else
{
recd += num_chars_recd;
if ((0 == mesg_len) && (SIZEOF(int) <= recd))
mesg_len = mesg.len;
if (recd == mesg_len)
recv_complete = 1;
else
{
recv_ptr += num_chars_recd;
recv_len -= num_chars_recd;
}
}
}
cancel_timer(timer_id);
sent = send_complete = 0;
serv_fail = service_request(&mesg);
send_len = mesg_len = mesg.len; /* We may not need to send same message size. Only return code is enough ??? */
send_ptr = (char *)&mesg;
msec_timeout = timeout2msec(GTMSECSHR_MESG_TIMEOUT);
start_timer(timer_id, msec_timeout, gtmsecshr_timer_handler, 0, NULL);
while (!send_complete)
{
num_chars_sent = (int)(SENDTO(gtmsecshr_sockfd, send_ptr, send_len, 0,
(struct sockaddr *)&client_addr, (GTM_SOCKLEN_TYPE)client_addr_len));
if ((-1 == num_chars_sent) && (gtmsecshr_timer_popped || errno != EINTR))
{
rts_error(VARLSTCNT(6) ERR_GTMSECSHR, 1, process_id, ERR_GTMSECSHRSENDF, 0, errno);
send_complete = 1;
} else
{
sent += num_chars_sent;
if (sent == mesg_len)
send_complete = 1;
else
{
send_ptr += num_chars_sent;
send_len -= num_chars_sent;
}
}
}
cancel_timer(timer_id);
/* Note :- The condition serv_fail should happen only when gtmsecshr does
* not have permission to service a request and should happen only when
* the gtmsecshr is not installed set-uid to root.
*/
if (serv_fail)
gtmsecshr_exit(serv_fail, FALSE);
assert('a' > 'F' && 'a' > '9');
if ('a' <= client_addr.sun_path[strlen(client_addr.sun_path) - 1])
clean_client_sockets(client_addr.sun_path);
}
}
void gtmsecshr_init(void)
{
int file_des, save_errno, len = 0;
int create_attempts = 0;
int secshr_sem;
int semop_res;
char *name_ptr;
now_t now; /* for GET_CUR_TIME macro */
char time_str[CTIME_BEFORE_NL + 2], *time_ptr; /* for GET_CUR_TIME macro */
pid_t pid;
struct sembuf sop[4];
gtmsecshr_mesg mesg;
struct stat stat_buf;
char *gtm_tmp_ptr;
int rc;
int lib_gid;
struct stat dist_stat_buff;
process_id = getpid();
set_blocksig();
if (-1 == setuid(ROOTUID))
{
send_msg(VARLSTCNT(10) MAKE_MSG_WARNING(ERR_GTMSECSHRSTART), 3, RTS_ERROR_LITERAL("Server"), process_id,
ERR_GTMSECSHRSUIDF, 0, ERR_GTMSECSHROPCMP, 0, errno);
gtmsecshr_exit(SETUIDROOT, FALSE);
}
pid = getsid(process_id);
if ((pid != process_id) && ((pid_t)-1 == setsid()))
{
save_errno = errno;
send_msg(VARLSTCNT(8) MAKE_MSG_WARNING(ERR_GTMSECSHRSTART), 3, RTS_ERROR_LITERAL("Server"), process_id,
ERR_GTMSECSHRSSIDF, 0, save_errno);
}
gtmsecshr_open_log_file();
DO_FORK(pid);
if (0 > pid)
{
save_errno = errno;
send_msg(VARLSTCNT(8) ERR_GTMSECSHRSTART, 3, RTS_ERROR_LITERAL("Server"), process_id,
ERR_GTMSECSHRFORKF, 0, save_errno);
gtm_putmsg(VARLSTCNT(8) ERR_GTMSECSHRSTART, 3, RTS_ERROR_LITERAL("Server"), process_id,
ERR_GTMSECSHRFORKF, 0, save_errno);
exit (GNDCHLDFORKFLD);
} else if (0 < pid)
exit(0);
process_id = getpid();
GET_CUR_TIME;
util_out_print("gtmsecshr started at !AD", TRUE, RTS_ERROR_STRING(time_ptr));
gtmsecshr_sig_init();
CLOSEFILE(0, rc);
for (file_des = (int)sysconf(_SC_OPEN_MAX)-1; file_des >= 3; file_des--)
{ /* Close the file only if we have it open. This is to avoid a CLOSEFAIL error in case of
* trying to close an invalid file descriptor.
*/
CLOSEFILE_IF_OPEN(file_des, rc);
}
if (-1 == CHDIR(P_tmpdir))
{
save_errno = errno;
send_msg(VARLSTCNT(10) ERR_GTMSECSHRSTART, 3, RTS_ERROR_LITERAL("Server"), process_id,
ERR_GTMSECSHRCHDIRF, 2, LEN_AND_STR(P_tmpdir), save_errno);
gtm_putmsg(VARLSTCNT(10) ERR_GTMSECSHRSTART, 3, RTS_ERROR_LITERAL("Server"), process_id,
ERR_GTMSECSHRCHDIRF, 2, LEN_AND_STR(P_tmpdir), save_errno);
exit (UNABLETOCHDIR);
}
umask(0);
if (gtmsecshr_pathname_init(SERVER) != 0)
{
send_msg(VARLSTCNT(5) ERR_GTMSECSHRSOCKET, 3, RTS_ERROR_LITERAL("Server path"), process_id);
rts_error(VARLSTCNT(5) ERR_GTMSECSHRSOCKET, 3, RTS_ERROR_LITERAL("Server path"), process_id);
}
if (-1 == (secshr_sem = semget(gtmsecshr_key, FTOK_SEM_PER_ID, RWDALL | IPC_NOWAIT)))
{
secshr_sem = INVALID_SEMID;
if (ENOENT != errno || /* below will fail otherwise */
-1 == (secshr_sem = semget(gtmsecshr_key, FTOK_SEM_PER_ID, RWDALL | IPC_CREAT | IPC_NOWAIT | IPC_EXCL)))
{
secshr_sem = INVALID_SEMID;
util_out_print("semget error errno = !UL", TRUE, errno);
gtmsecshr_exit(SEMGETERROR, FALSE);
}
}
sop[0].sem_num = 0;
sop[0].sem_op = 0;
sop[0].sem_flg = IPC_NOWAIT;
sop[1].sem_num = 0;
sop[1].sem_op = 1;
sop[1].sem_flg = IPC_NOWAIT | SEM_UNDO;
SEMOP(secshr_sem, sop, 2, semop_res, NO_WAIT);
if (0 > semop_res)
{
send_msg(VARLSTCNT(10) MAKE_MSG_SEVERE(ERR_GTMSECSHRSTART), 3, RTS_ERROR_LITERAL("Server"), process_id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("server already running"), errno);
/* if gtm_tmp is not defined, show default path */
if (gtm_tmp_ptr = GETENV("gtm_tmp"))
send_msg(VARLSTCNT(8) ERR_GTMSECSHRTMPPATH, 2, RTS_ERROR_TEXT(gtm_tmp_ptr),
ERR_TEXT, 2, RTS_ERROR_TEXT("(from $gtm_tmp)"));
else
send_msg(VARLSTCNT(4) ERR_GTMSECSHRTMPPATH, 2, RTS_ERROR_TEXT("/tmp"));
util_out_print("A gtmsecshr server is already running - exiting", TRUE);
gtmsecshr_exit(SEMAPHORETAKEN, FALSE);
}
if (gtmsecshr_sock_init(SERVER) != 0)
{
send_msg(VARLSTCNT(5) ERR_GTMSECSHRSOCKET, 3, RTS_ERROR_LITERAL("Server"), process_id);
rts_error(VARLSTCNT(5) ERR_GTMSECSHRSOCKET, 3, RTS_ERROR_LITERAL("Server"), process_id);
}
if (-1 == Stat(gtmsecshr_sock_name.sun_path, &stat_buf))
gtm_putmsg(VARLSTCNT(10) MAKE_MSG_WARNING(ERR_GTMSECSHRSTART), 3, RTS_ERROR_LITERAL("Server"), process_id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to get status of socket file"), errno);
/* Get the distribution group */
lib_gid = gtm_get_group_id(&dist_stat_buff);
/* if it is world accessible then make mode 666 */
if ((-1 != lib_gid) && (dist_stat_buff.st_mode & 04))
lib_gid = -1;
if (-1 == lib_gid)
stat_buf.st_mode = 0666;
else
{
/* change group if different from current user group */
if (lib_gid != GETGID() && (-1 == CHOWN(gtmsecshr_sock_name.sun_path, -1, lib_gid)))
{
gtm_putmsg(VARLSTCNT(10) MAKE_MSG_WARNING(ERR_GTMSECSHRSTART), 3,
RTS_ERROR_LITERAL("Server"), process_id, ERR_TEXT, 2,
RTS_ERROR_LITERAL("Unable to change socket file group"), errno);
}
/* change mode to 660 */
stat_buf.st_mode = 0660;
}
if (-1 == CHMOD(gtmsecshr_sock_name.sun_path, stat_buf.st_mode))
gtm_putmsg(VARLSTCNT(10) MAKE_MSG_WARNING(ERR_GTMSECSHRSTART), 3, RTS_ERROR_LITERAL("Server"), process_id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to change socket file permisions"), errno);
name_ptr = strrchr(gtmsecshr_sock_name.sun_path, '/');
while (*name_ptr == '/') /* back off in case of double-slash */
name_ptr--;
gtmsecshr_socket_dir_len = (int)(name_ptr - gtmsecshr_sock_name.sun_path + 1);
/* Preallocate some timer blocks. */
prealloc_gt_timers();
return;
}
void gtmsecshr_exit (int exit_code, boolean_t dump)
{
int gtmsecshr_sem;
now_t now; /* for GET_CUR_TIME macro */
char time_str[CTIME_BEFORE_NL + 2], *time_ptr; /* for GET_CUR_TIME macro */
if (dump)
DUMP_CORE;
gtmsecshr_sock_cleanup(SERVER);
gtmsecshr_sockfd = FD_INVALID;
if (SEMAPHORETAKEN != exit_code)
{ /* remove semaphore */
if (-1 == (gtmsecshr_sem = semget(gtmsecshr_key, FTOK_SEM_PER_ID, RWDALL | IPC_NOWAIT)))
{
gtmsecshr_sem = INVALID_SEMID;
util_out_print("error getting semaphore errno = !UL", TRUE, errno);
}
if (-1 == semctl(gtmsecshr_sem, 0, IPC_RMID, 0))
util_out_print("error removing semaphore errno = !UL", TRUE, errno);
}
util_out_print("", TRUE);
GET_CUR_TIME;
util_out_print("gtmsecshr exited on !AD", TRUE, RTS_ERROR_STRING(time_ptr));
util_out_close();
exit(exit_code);
}
int gtmsecshr_open_log_file (void)
{
struct stat buf;
int save_errno = 0, status;
char gtmsecshr_path[MAX_TRANS_NAME_LEN], *error_mesg;
mstr gtmsecshr_lognam, gtmsecshr_transnam;
# ifdef __MVS__
int create_logfile = 0, realfiletag;
# endif
gtmsecshr_lognam.addr = GTMSECSHR_LOG_DIR;
gtmsecshr_lognam.len = SIZEOF(GTMSECSHR_LOG_DIR) - 1;
status = TRANS_LOG_NAME(&gtmsecshr_lognam, &gtmsecshr_transnam, gtmsecshr_logpath, SIZEOF(gtmsecshr_logpath),
dont_sendmsg_on_log2long);
if ((SS_NORMAL != status) || !ABSOLUTE_PATH(gtmsecshr_logpath))
{ /* gtm_log not defined or not defined to absolute path, use default gtm_log
* This is not considered error, just informational
*/
if (SS_LOG2LONG == status)
send_msg(VARLSTCNT(5) ERR_LOGTOOLONG, 3, gtmsecshr_lognam.len, gtmsecshr_lognam.addr,
SIZEOF(gtmsecshr_logpath) - 1);
send_msg(VARLSTCNT(4) ERR_GTMSECSHRDEFLOG, 2, RTS_ERROR_TEXT(DEFAULT_GTMSECSHR_LOG_DIR));
strcpy(gtmsecshr_logpath, DEFAULT_GTMSECSHR_LOG_DIR);
gtmsecshr_logpath_len = SIZEOF(DEFAULT_GTMSECSHR_LOG_DIR) - 1;
} else
gtmsecshr_logpath_len = gtmsecshr_transnam.len;
if (-1 == Stat(gtmsecshr_logpath, &buf))
{
save_errno = errno;
send_msg(VARLSTCNT(14) ERR_GTMSECSHRLOGF, 3, RTS_ERROR_TEXT("Server"), process_id, ERR_TEXT, 2,
RTS_ERROR_TEXT("Unable to locate default log directory"), ERR_TEXT, 2,
RTS_ERROR_STRING(gtmsecshr_logpath), save_errno);
exit(UNABLETOOPNLOGFILEFTL);
} else if (!S_ISDIR(buf.st_mode))
{
send_msg(VARLSTCNT(13) ERR_GTMSECSHRLOGF, 3, RTS_ERROR_LITERAL("Server"), process_id, ERR_TEXT, 2,
RTS_ERROR_LITERAL("$gtm_log not a directory"), ERR_TEXT, 2,
RTS_ERROR_STRING(gtmsecshr_logpath));
exit(UNABLETOOPNLOGFILEFTL);
}
if (gtmsecshr_logpath[gtmsecshr_logpath_len - 1] != '/')
gtmsecshr_logpath[gtmsecshr_logpath_len++] = '/';
strcpy(gtmsecshr_logpath + gtmsecshr_logpath_len , GTMSECSHR_LOG_PREFIX);
# if defined(__MVS__)
if (-1 == Stat(gtmsecshr_logpath, &buf))
create_logfile = 1;
#endif
if (0 > (gtmsecshr_log_file = OPEN3(gtmsecshr_logpath, O_RDWR|O_CREAT|O_APPEND, GTMSECSHR_PERMS)))
{
send_msg(VARLSTCNT(14) ERR_GTMSECSHRLOGF, 3, RTS_ERROR_LITERAL("Server"), process_id, ERR_TEXT, 2,
RTS_ERROR_LITERAL("gtmsecshr unable to open log file"),
ERR_TEXT, 2, RTS_ERROR_STRING(gtmsecshr_logpath), errno);
exit(UNABLETOOPNLOGFILEFTL);
}
# if defined(__MVS__)
if ((1 == create_logfile) && (-1 == gtm_zos_set_tag(gtmsecshr_log_file, TAG_EBCDIC, TAG_TEXT, TAG_FORCE, &realfiletag)))
gtm_tag_error(gtmsecshr_logpath, realfiletag, TAG_EBCDIC);
else if (!gtm_zos_autocvt_enabled())
{
send_msg(VARLSTCNT(14) ERR_GTMSECSHRLOGF, 3, RTS_ERROR_LITERAL("Server"), process_id, ERR_TEXT, 2,
RTS_ERROR_LITERAL("_BPXK_AUTOCVT='ON' not set, policy tagging the log file"),
ERR_TEXT, 2, RTS_ERROR_STRING(gtmsecshr_logpath), errno);
if (-1 == gtm_zos_tag_to_policy(gtmsecshr_log_file, TAG_UNTAGGED, &realfiletag))
gtm_tag_error(gtmsecshr_logpath, realfiletag, TAG_UNTAGGED);
}
#endif
assert(0 <= gtmsecshr_log_file);
if (-1 == dup2(gtmsecshr_log_file, 1))
{
send_msg(VARLSTCNT(10) ERR_GTMSECSHRLOGF, 3, RTS_ERROR_LITERAL("Server"), process_id, ERR_TEXT, 2,
RTS_ERROR_LITERAL("Unable to dup standard out"), errno);
exit(UNABLETODUPLOG);
}
if (-1 == dup2(gtmsecshr_log_file, 2))
{
send_msg(VARLSTCNT(10) ERR_GTMSECSHRLOGF, 3, RTS_ERROR_LITERAL("Server"), process_id, ERR_TEXT, 2,
RTS_ERROR_LITERAL("Unable to dup standard error"), errno);
exit(UNABLETODUPLOG);
}
return 0;
}
void gtmsecshr_switch_log_file(int sig)
{
now_t now; /* for GET_CUR_TIME macro */
char time_str[CTIME_BEFORE_NL + 2], *time_ptr; /* for GET_CUR_TIME macro */
char newname[MAX_TRANS_NAME_LEN], *err_msg;
struct tm *tm_struct;
size_t dummy;
struct stat fs;
int newname_len, suffix, save_errno, temp_fd, rc;
ZOS_ONLY(int realfiletag;)
assert((SIGHUP == sig) || (0 == sig)); /* sig could be either SIGHUP or 0 */
assert((SIGHUP == sig) || (!ready_to_switch_log_file));
if ((SIGHUP == sig) && (!ready_to_switch_log_file))
{
times_to_switch_log_file++;
return;
}
/* --- log this switching action in the old log file --- */
GET_CUR_TIME;
util_out_print("!/gtmsecshr log was switched from this file at !AD -- process id !UL",
TRUE, RTS_ERROR_STRING(time_ptr), process_id);
/* --- construct a name for the old gtmsecshr log file --- */
strcpy(newname, gtmsecshr_logpath);
if (((time_t)-1 == (now = time(NULL))) || (!(tm_struct = localtime(&now))))
{
SPRINTF(&newname[gtmsecshr_logpath_len + SIZEOF(GTMSECSHR_LOG_PREFIX) - 1],
".timerrno%d", errno);
} else
{
STRFTIME(&newname[gtmsecshr_logpath_len + SIZEOF(GTMSECSHR_LOG_PREFIX) - 1],
MAX_TRANS_NAME_LEN - gtmsecshr_logpath_len - SIZEOF(GTMSECSHR_LOG_PREFIX),
TIME_FORMAT, tm_struct, dummy);
}
newname_len = STRLEN(newname);
suffix = 1;
while ((0 == Stat(newname, &fs)) || (ENOENT != errno)) /* This file exists */
{
SPRINTF(&newname[newname_len], ".%d", suffix);
suffix++;
}
/* --- switch to use the new log file --- */
if ((-1 == RENAME(gtmsecshr_logpath, &newname[0]))
|| (FD_INVALID == (temp_fd = OPEN3(gtmsecshr_logpath, O_RDWR | O_CREAT | O_APPEND, GTMSECSHR_PERMS)))
|| (-1 == dup2(temp_fd, gtmsecshr_log_file))
# if defined(__MVS__)
|| (-1 == gtm_zos_set_tag(temp_fd, TAG_EBCDIC, TAG_TEXT, TAG_FORCE, &realfiletag)
&& gtm_tag_error(gtmsecshr_logpath, realfiletag, TAG_EBCDIC))
|| ((!gtm_zos_autocvt_enabled()) && ((-1 == gtm_zos_tag_to_policy(gtmsecshr_log_file, TAG_UNTAGGED, &realfiletag))
&& gtm_tag_error(gtmsecshr_logpath, realfiletag, TAG_UNTAGGED)))
#endif
|| (-1 == dup2(temp_fd, 1))
|| (-1 == dup2(temp_fd, 2)))
{
save_errno = errno;
send_msg(VARLSTCNT(14) ERR_GTMSECSHRLOGSWH, 7, RTS_ERROR_STRING(gtmsecshr_logpath),
RTS_ERROR_STRING(&newname[0]), RTS_ERROR_LITERAL("rename"), process_id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Recycling gtmsecshr is suggested."), save_errno);
gtm_putmsg(VARLSTCNT(14) ERR_GTMSECSHRLOGSWH, 7, RTS_ERROR_STRING(gtmsecshr_logpath),
RTS_ERROR_STRING(&newname[0]), RTS_ERROR_LITERAL("rename"), process_id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Recycling gtmsecshr is suggested."), save_errno);
return;
}
CLOSEFILE_RESET(gtmsecshr_log_file, rc); /* resets "gtmsecshr_log_file" to FD_INVALID */
gtmsecshr_log_file = temp_fd;
/* --- log this switching action in the new log file --- */
GET_CUR_TIME;
util_out_print("!/gtmsecshr log was switched to this file at !AD -- process id !UL",
TRUE, RTS_ERROR_STRING(time_ptr), process_id);
}
void gtmsecshr_timer_handler(void)
{
gtmsecshr_timer_popped = TRUE;
}
void gtmsecshr_signal_handler(int sig, siginfo_t *info, void *context)
{
boolean_t process_signal(enum gtmImageTypes, int, siginfo_t *, void *);
/* Do standard signal handling */
(void)generic_signal_handler(sig, info, context);
/* Note that we are not letting process_signal run gtm_fork_n_core. In testing,
bad things occurred when the root process ran into trouble trying to fork
so our object is to avoid the problem entirely and core here if we need to
and if the OS will do it (Linux seems not to core if root process). */
gtmsecshr_exit(sig, need_core);
}
void gtmsecshr_sig_init(void)
{
struct sigaction act;
sig_init(gtmsecshr_signal_handler, gtmsecshr_signal_handler, suspsigs_handler);
/* Redefine handler for SIGHUP to switch log file */
memset(&act, 0, SIZEOF(act));
act.sa_handler = gtmsecshr_switch_log_file;
sigaction(SIGHUP, &act, 0);
}
int service_request(gtmsecshr_mesg *buf)
{
int ret_status = 0;
int fn_len, index, basind, save_errno, save_code;
int stat_res;
now_t now; /* for GET_CUR_TIME macro */
char time_str[CTIME_BEFORE_NL + 2], *time_ptr; /* for GET_CUR_TIME macro */
char *basnam, *fn;
struct shmid_ds temp_shmctl_buf;
struct stat statbuf;
sgmnt_data header;
GET_CUR_TIME;
save_code = buf->code;
switch(buf->code)
{
case WAKE_MESSAGE:
if (buf->code = (-1 == kill((pid_t )buf->mesg.id, SIGALRM)) ? errno : 0)
{
save_errno = errno;
send_msg(VARLSTCNT(13) ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code,
buf->mesg.id, ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to wake up process"), save_errno);
util_out_print("!AD [client pid !UL]", TRUE, CTIME_BEFORE_NL, time_ptr, buf->pid);
gtm_putmsg(VARLSTCNT(13)
ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code, buf->mesg.id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to wake up process"), save_errno);
}
DEBUG_ONLY(
else
util_out_print("!AD [client pid !UL] Process !UL was awakened", TRUE, CTIME_BEFORE_NL, time_ptr, buf->pid,
buf->mesg.id);
)
break ;
case REMOVE_SEM:
buf->code = ( -1 == semctl((int )buf->mesg.id, 0, IPC_RMID, 0)) ? errno : 0;
if (!buf->code)
util_out_print("!AD [client pid !UL] Semaphore (!UL) removed", TRUE, CTIME_BEFORE_NL, time_ptr, buf->pid,
buf->mesg.id);
else
{
send_msg(VARLSTCNT(13) ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code,
buf->mesg.id, ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to remove semaphore"), buf->code);
gtm_putmsg(VARLSTCNT(13)
ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code, buf->mesg.id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to remove semaphore"), buf->code);
}
break;
case REMOVE_SHMMEM:
buf->code = (-1 == shmctl((int )buf->mesg.id, IPC_STAT, &temp_shmctl_buf)) ? errno : 0;
if (buf->code)
{
send_msg(VARLSTCNT(13) ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code,
buf->mesg.id, ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to get shared memory statistics"), buf->code);
gtm_putmsg(VARLSTCNT(13)
ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code, buf->mesg.id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to get shared memory statistics"), buf->code);
break;
}
else if (1 < temp_shmctl_buf.shm_nattch)
{
util_out_print("More than one process attached to Shared memory segment (!UL) not removed (!UL)", TRUE,
buf->mesg.id, temp_shmctl_buf.shm_nattch);
buf->code = EBUSY;
break;
}
buf->code = (-1 == shmctl((int )buf->mesg.id, IPC_RMID, 0)) ? errno : 0;
if (!buf->code)
util_out_print("!AD [client pid !UL] Shared memory segment (!UL) removed, nattch = !UL", TRUE,
CTIME_BEFORE_NL, time_ptr, buf->pid, buf->mesg.id, temp_shmctl_buf.shm_nattch);
else
{
send_msg(VARLSTCNT(13)
ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code, buf->mesg.id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to remove shared memory segment"), buf->code);
gtm_putmsg(VARLSTCNT(13)
ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code, buf->mesg.id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to remove shared memory segment"), buf->code);
}
break;
case REMOVE_FILE :
# ifndef MUTEX_MSEM_WAKE
for (index = 0; index < SIZEOF(buf->mesg.path); index++)
{
if ('\0' == buf->mesg.path[index])
break;
}
if ((0 == index) || (index >= SIZEOF(buf->mesg.path)))
{
gtm_putmsg(VARLSTCNT(13) ERR_GTMSECSHRSRVFIL, 7, RTS_ERROR_LITERAL("Server"), process_id, buf->pid,
buf->code, index >= SIZEOF(buf->mesg.path) ? SIZEOF(buf->mesg.path) - 1 : index,
buf->mesg.path, ERR_TEXT, 2, RTS_ERROR_LITERAL("no file or length too long"));
buf->code = EINVAL;
} else
{
if ('/' == buf->mesg.path[index - 1] && 1 < index)
{ /* remove trailing slash unless only slash */
buf->mesg.path[index - 1] = '\0';
index--;
}
for (basind = index - 1; 0 <= basind; basind--)
{
if ('/' == buf->mesg.path[basind])
break;
}
if (0 < basind || (0 == basind && '/' == buf->mesg.path[basind]))
basnam = &buf->mesg.path[basind + 1];
else
basnam = &buf->mesg.path[0];
STAT_FILE(buf->mesg.path, &statbuf, stat_res);
if (-1 == stat_res)
{
buf->code = errno;
gtm_putmsg(VARLSTCNT(14) ERR_GTMSECSHRSRVFIL, 7,
RTS_ERROR_LITERAL("Server"), process_id, buf->pid, buf->code,
index >= SIZEOF(buf->mesg.path) ? SIZEOF(buf->mesg.path) - 1 : index, buf->mesg.path,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to get file status"), errno);
# ifndef __MVS__
} else if (!S_ISSOCK(statbuf.st_mode))
# else
} else if (!(S_ISSOCK(statbuf.st_mode) || S_ISCHR(statbuf.st_mode)))
# endif
{
gtm_putmsg(VARLSTCNT(13) ERR_GTMSECSHRSRVFIL, 7,
RTS_ERROR_LITERAL("Server"), process_id, buf->pid, buf->code,
index >= SIZEOF(buf->mesg.path) ? SIZEOF(buf->mesg.path) - 1 : index, buf->mesg.path,
ERR_TEXT, 2, RTS_ERROR_LITERAL("File is not a GTM mutex socket file"));
buf->code = EINVAL;
} else if (0 != MEMCMP_LIT(basnam, MUTEX_SOCK_FILE_PREFIX))
{
gtm_putmsg(VARLSTCNT(13) ERR_GTMSECSHRSRVFIL, 7,
RTS_ERROR_LITERAL("Server"), process_id, buf->pid,
buf->code, index >= SIZEOF(buf->mesg.path) ? SIZEOF(buf->mesg.path) - 1 : index,
buf->mesg.path, ERR_TEXT, 2,
RTS_ERROR_LITERAL("File name does not match the naming convention for a GT.M mutex socket file"));
buf->code = EINVAL;
} else if (0 != memcmp(gtmsecshr_sock_name.sun_path, buf->mesg.path, gtmsecshr_socket_dir_len))
{
gtm_putmsg(VARLSTCNT(13) ERR_GTMSECSHRSRVFIL, 7,
RTS_ERROR_LITERAL("Server"), process_id, buf->pid,
buf->code, index >= SIZEOF(buf->mesg.path) ? SIZEOF(buf->mesg.path) - 1 : index,
buf->mesg.path, ERR_TEXT, 2,
RTS_ERROR_LITERAL("File does not reside in the normal directory for a GT.M mutex socket file"));
buf->code = EINVAL;
} else if (buf->code = (-1 == UNLINK(buf->mesg.path)) ? errno : 0)
{
gtm_putmsg(VARLSTCNT(14) ERR_GTMSECSHRSRVFIL, 7, RTS_ERROR_LITERAL("Server"), process_id,
buf->pid, save_code, RTS_ERROR_STRING(buf->mesg.path),
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to remove file"), buf->code);
} else
{
util_out_print("!AD [client pid !UL] File (!AD) removed", TRUE, CTIME_BEFORE_NL, time_ptr, buf->pid,
RTS_ERROR_STRING(buf->mesg.path));
}
}
# else
/* For platforms that use MSEMs for mutex inter process communication, mutex socket files are not used
* by GT.M so the need to remove those (i.e. using the REMOVE_FILE command should not be necessary).
*/
assert(FALSE);
# endif
break;
case CONTINUE_PROCESS:
if (buf->code = (-1 == kill((pid_t)buf->mesg.id, SIGCONT)) ? errno : 0)
{
save_errno = errno;
send_msg(VARLSTCNT(13)
ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code, buf->mesg.id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to request process to resume processing"), save_errno);
util_out_print("!AD [client pid !UL]", TRUE, CTIME_BEFORE_NL, time_ptr, buf->pid);
gtm_putmsg(VARLSTCNT(13)
ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code, buf->mesg.id,
ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to request process to resume processing"), save_errno);
}
DEBUG_ONLY(
else
util_out_print("!AD [client pid !UL] Process !UL was requested to resume processing", TRUE, CTIME_BEFORE_NL,
time_ptr, buf->pid, buf->mesg.id);
)
break ;
case FLUSH_DB_IPCS_INFO:
fn = buf->mesg.db_ipcs.fn;
fn_len = buf->mesg.db_ipcs.fn_len;
*(fn + fn_len) = 0; /* We assumed we have one extra byte. fn must be null terminated */
if (!file_head_read(fn, &header, SIZEOF(header)))
{
buf->code = errno;
send_msg(VARLSTCNT(12) ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code,
buf->mesg.id, ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to read database file header"));
break;
}
header.semid = buf->mesg.db_ipcs.semid;
header.shmid = buf->mesg.db_ipcs.shmid;
header.gt_sem_ctime.ctime = buf->mesg.db_ipcs.gt_sem_ctime;
header.gt_shm_ctime.ctime = buf->mesg.db_ipcs.gt_shm_ctime;
if (!file_head_write(fn, &header, SIZEOF(header)))
{
buf->code = errno;
send_msg(VARLSTCNT(12) ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, save_code,
buf->mesg.id, ERR_TEXT, 2, RTS_ERROR_LITERAL("Unable to write database file header"));
}
util_out_print("!AD [client pid !UL] database fileheader (!AD) updated", TRUE, CTIME_BEFORE_NL, time_ptr, buf->pid,
fn_len, fn);
buf->code = 0;
break;
default:
buf->ack = ACK_NOT_REQUIRED;
send_msg(VARLSTCNT(12) ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, buf->code,
buf->mesg.id, ERR_TEXT, 2, RTS_ERROR_LITERAL("Invalid Service Request"));
send_msg(VARLSTCNT(12) ERR_GTMSECSHRSRVFID, 6, RTS_ERROR_LITERAL("Server"), process_id, buf->pid, buf->code,
buf->mesg.id, ERR_TEXT, 2, RTS_ERROR_LITERAL("Invalid Service Request"));
buf->code = 0;
}
return ret_status;
}
#ifdef __MVS__
boolean_t gtm_tag_error(char *filename, int realtag, int desiredtag)
{
char *errmsg = STRERROR(errno);
send_msg(VARLSTCNT(10) ERR_BADTAG, 4, LEN_AND_STR(filename), realtag,
desiredtag, ERR_TEXT, 2, RTS_ERROR_STRING(errmsg));
return 0;
}
#endif
Reference in New Issue View Git Blame Copy Permalink