int gtmsource_comm_init(void)
{
/* Initialize communication stuff */
struct linger disable_linger = {0, 0};
char error_string[1024];
int err_status;
if (FD_INVALID != gtmsource_sock_fd) /* Initialization done already */
return(0);
/* Create the socket used for communicating with secondary */
if (FD_INVALID == (gtmsource_sock_fd = socket(AF_INET, SOCK_STREAM, 0)))
{
err_status = ERRNO;
SNPRINTF(error_string, SIZEOF(error_string), "Error with source server socket create : %s", STRERROR(err_status));
rts_error(VARLSTCNT(6) ERR_REPLCOMM, 0, ERR_TEXT, 2, RTS_ERROR_STRING(error_string));
return(-1);
}
/* A connection breakage should get rid of the socket */
if (-1 == setsockopt(gtmsource_sock_fd, SOL_SOCKET, SO_LINGER, (const void *)&disable_linger, SIZEOF(disable_linger)))
{
err_status = ERRNO;
SNPRINTF(error_string, SIZEOF(error_string), "Error with source server socket disable linger : %s",
STRERROR(err_status));
rts_error(VARLSTCNT(6) ERR_REPLCOMM, 0, ERR_TEXT, 2, RTS_ERROR_STRING(error_string));
}
return(0);
}
void gtmsecshr_sock_cleanup(int caller)
{
int save_errno;
struct sockaddr_un *sock_ptr;
/* Close the secshr client socket */
if (-1 != gtmsecshr_sockfd)
{
close(gtmsecshr_sockfd);
gtmsecshr_sockfd = -1;
}
/* do the unlink */
sock_ptr = (CLIENT == caller) ? >msecshr_cli_sock_name : >msecshr_sock_name;
if (('\0' != sock_ptr->sun_path[0]) && (-1 == UNLINK(sock_ptr->sun_path))
&& (ENOENT != errno))
{
save_errno = errno;
send_msg(VARLSTCNT(12) ERR_GTMSECSHR, 1, process_id, ERR_TEXT, 2, RTS_ERROR_TEXT("unlinking socket"),
ERR_TEXT, 2, RTS_ERROR_STRING(sock_ptr->sun_path), save_errno);
}
sock_ptr->sun_path[0] = '\0'; /* Even if error unlinking since it is useless now */
gtmsecshr_sock_init_done = FALSE;
}
int create_server(void)
{
int child_pid, done_pid, status = 0;
# ifdef _BSD
union wait chld_status;
# define CSTAT chld_status
# else
# define CSTAT status
# endif
int save_errno;
FORK(child_pid);
if (0 == child_pid)
{
process_id = getpid();
/* Do exec using gtmsecshr_path, which was initialize in file check code - send_mesg2gtmsecshr */
if (WBTEST_ENABLED(WBTEST_BADEXEC_SECSHR_PROCESS))
STRCPY(gtmsecshr_path, "");
status = EXECL(gtmsecshr_path, gtmsecshr_path, 0);
if (-1 == status)
{
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(9) ERR_GTMSECSHRSTART, 3, RTS_ERROR_TEXT("Client"), process_id,
ERR_TEXT, 2, RTS_ERROR_STRING(secshrstart_error_code[UNABLETOEXECGTMSECSHR]));
UNDERSCORE_EXIT(UNABLETOEXECGTMSECSHR);
}
} else
{
if (-1 == child_pid)
{
status = GNDCHLDFORKFLD;
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(10) ERR_GTMSECSHRSTART, 3, RTS_ERROR_TEXT("Client"), process_id,
ERR_TEXT, 2, RTS_ERROR_TEXT("Failed to fork off gtmsecshr"), errno);
/* Sleep for a while and hope a subsequent fork will succeed */
hiber_start(1000);
}
for (; !status ;)
{
/* To prevent a warning message that the compiler issues */
done_pid = wait(&CSTAT);
if (done_pid == child_pid)
{
status = WEXITSTATUS(CSTAT);
break;
} else if (-1 == done_pid)
{
if (ECHILD == errno) /* Assume normal exit status */
break;
else if (EINTR != errno)
{
status = GNDCHLDFORKFLD;
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(10) ERR_GTMSECSHRSTART, 3,
RTS_ERROR_TEXT("Client"), process_id,
ERR_TEXT, 2, RTS_ERROR_TEXT("Error spawning gtmsecshr"), errno);
}
}
}
}
return status;
}
int gtmsource_comm_init(void)
{
/* Initialize communication stuff */
const int disable_keepalive = 0;
struct linger disable_linger = {0, 0};
char error_string[1024];
int err_status;
error_def(ERR_REPLCOMM);
error_def(ERR_TEXT);
if (-1 != gtmsource_sock_fd) /* Initialization done already */
return(0);
/* Create the socket used for communicating with secondary */
if (-1 == (gtmsource_sock_fd = socket(AF_INET, SOCK_STREAM, 0)))
{
err_status = ERRNO;
SNPRINTF(error_string, sizeof(error_string), "Error with source server socket create : %s", STRERROR(err_status));
rts_error(VARLSTCNT(6) ERR_REPLCOMM, 0, ERR_TEXT, 2, RTS_ERROR_STRING(error_string));
return(-1);
}
/* A connection breakage should get rid of the socket */
if (-1 == setsockopt(gtmsource_sock_fd, SOL_SOCKET, SO_LINGER, (const void *)&disable_linger, sizeof(disable_linger)))
{
err_status = ERRNO;
SNPRINTF(error_string, sizeof(error_string), "Error with source server socket disable linger : %s",
STRERROR(err_status));
rts_error(VARLSTCNT(6) ERR_REPLCOMM, 0, ERR_TEXT, 2, RTS_ERROR_STRING(error_string));
}
#ifdef REPL_DISABLE_KEEPALIVE
if (-1 == setsockopt(gtmsource_sock_fd, SOL_SOCKET, SO_KEEPALIVE, (const void *)&disable_keepalive,
sizeof(disable_keepalive)))
{ /* Till SIGPIPE is handled properly */
err_status = ERRNO;
SNPRINTF(error_string, sizeof(error_string), "Error with source server socket disable keepalive : %s",
STRERROR(err_status));
rts_error(VARLSTCNT(6) ERR_REPLCOMM, 0, ERR_TEXT, 2, RTS_ERROR_STRING(error_string));
}
#endif
return(0);
}
/*
* This will rundown a replication instance journal (and receiver) pool.
* Input Parameter:
* replpool_id of the instance. Instance file name must be null terminated in replpool_id.
* Returns :
* TRUE, if successful.
* FALSE, otherwise.
*/
boolean_t mu_rndwn_repl_instance(replpool_identifier *replpool_id, boolean_t immediate, boolean_t rndwn_both_pools)
{
boolean_t jnlpool_stat = TRUE, recvpool_stat = TRUE;
char *instfilename, shmid_buff[TMP_BUF_LEN];
gd_region *r_save;
repl_inst_hdr repl_instance;
static gd_region *reg = NULL;
struct semid_ds semstat;
struct shmid_ds shmstat;
union semun semarg;
uchar_ptr_t ret_ptr;
unix_db_info *udi;
int save_errno;
error_def(ERR_MUJPOOLRNDWNSUC);
error_def(ERR_MURPOOLRNDWNSUC);
error_def(ERR_MUJPOOLRNDWNFL);
error_def(ERR_MURPOOLRNDWNFL);
error_def(ERR_SEMREMOVED);
error_def(ERR_REPLACCSEM);
error_def(ERR_SYSCALL);
if (NULL == reg)
{
r_save = gv_cur_region;
mu_gv_cur_reg_init();
reg = gv_cur_region;
gv_cur_region = r_save;
}
jnlpool.jnlpool_dummy_reg = reg;
recvpool.recvpool_dummy_reg = reg;
instfilename = replpool_id->instfilename;
reg->dyn.addr->fname_len = strlen(instfilename);
assert(0 == instfilename[reg->dyn.addr->fname_len]);
memcpy((char *)reg->dyn.addr->fname, instfilename, reg->dyn.addr->fname_len + 1);
udi = FILE_INFO(reg);
udi->fn = (char *)reg->dyn.addr->fname;
/* Lock replication instance using ftok semaphore */
if (!ftok_sem_get(reg, TRUE, REPLPOOL_ID, immediate))
return FALSE;
repl_inst_read(instfilename, (off_t)0, (sm_uc_ptr_t)&repl_instance, SIZEOF(repl_inst_hdr));
semarg.buf = &semstat;
assert(rndwn_both_pools || JNLPOOL_SEGMENT == replpool_id->pool_type || RECVPOOL_SEGMENT == replpool_id->pool_type);
if (rndwn_both_pools || (JNLPOOL_SEGMENT == replpool_id->pool_type))
{ /* --------------------------
* First rundown Journal pool
* --------------------------
*/
if (INVALID_SEMID != repl_instance.jnlpool_semid)
if ((-1 == semctl(repl_instance.jnlpool_semid, 0, IPC_STAT, semarg)) ||
(semarg.buf->sem_ctime != repl_instance.jnlpool_semid_ctime))
repl_instance.jnlpool_semid = INVALID_SEMID;
if (INVALID_SHMID != repl_instance.jnlpool_shmid)
if ((-1 == shmctl(repl_instance.jnlpool_shmid, IPC_STAT, &shmstat)) ||
(shmstat.shm_ctime != repl_instance.jnlpool_shmid_ctime))
repl_instance.jnlpool_shmid = INVALID_SHMID;
if (INVALID_SHMID != repl_instance.jnlpool_shmid)
{
replpool_id->pool_type = JNLPOOL_SEGMENT;
jnlpool_stat = mu_rndwn_replpool(replpool_id, repl_instance.jnlpool_semid, repl_instance.jnlpool_shmid);
ret_ptr = i2asc((uchar_ptr_t)shmid_buff, repl_instance.jnlpool_shmid);
*ret_ptr = '\0';
if (rndwn_both_pools)
gtm_putmsg(VARLSTCNT(6) (jnlpool_stat ? ERR_MUJPOOLRNDWNSUC : ERR_MUJPOOLRNDWNFL),
4, LEN_AND_STR(shmid_buff), LEN_AND_STR(replpool_id->instfilename));
} else if (INVALID_SEMID != repl_instance.jnlpool_semid)
{
if (0 == sem_rmid(repl_instance.jnlpool_semid))
{ /* note that shmid_buff used here is actually a buffer to hold semid (not shmid) */
ret_ptr = i2asc((uchar_ptr_t)shmid_buff, repl_instance.jnlpool_semid);
*ret_ptr = '\0';
gtm_putmsg(VARLSTCNT(9) ERR_MUJPOOLRNDWNSUC, 4, LEN_AND_STR(shmid_buff),
LEN_AND_STR(replpool_id->instfilename), ERR_SEMREMOVED, 1, repl_instance.jnlpool_semid);
} else
{
save_errno = errno;
gtm_putmsg(VARLSTCNT(13) ERR_REPLACCSEM, 3, repl_instance.jnlpool_semid,
RTS_ERROR_STRING(instfilename), ERR_SYSCALL, 5, RTS_ERROR_LITERAL("jnlpool sem_rmid()"),
CALLFROM, save_errno);
}
/* Note that jnlpool_stat is not set to FALSE in case sem_rmid() fails above. This is because the
* journal pool is anyway not present and it is safer to reset the sem/shmids in the instance file.
* The only thing this might cause is a stranded semaphore but that is considered better than getting
* errors due to not resetting instance file.
*/
}
if (jnlpool_stat) /* Reset instance file for jnlpool info */
repl_inst_jnlpool_reset();
}
if (rndwn_both_pools || (RECVPOOL_SEGMENT == replpool_id->pool_type))
{ /* --------------------------
* Now rundown Receivpool
* --------------------------
*/
if (INVALID_SEMID != repl_instance.recvpool_semid)
if ((-1 == semctl(repl_instance.recvpool_semid, 0, IPC_STAT, semarg)) ||
(semarg.buf->sem_ctime != repl_instance.recvpool_semid_ctime))
repl_instance.recvpool_semid = INVALID_SEMID;
if (INVALID_SHMID != repl_instance.recvpool_shmid)
if ((-1 == shmctl(repl_instance.recvpool_shmid, IPC_STAT, &shmstat)) ||
(shmstat.shm_ctime != repl_instance.recvpool_shmid_ctime))
repl_instance.recvpool_shmid = INVALID_SHMID;
if (INVALID_SHMID != repl_instance.recvpool_shmid)
{
replpool_id->pool_type = RECVPOOL_SEGMENT;
recvpool_stat = mu_rndwn_replpool(replpool_id, repl_instance.recvpool_semid, repl_instance.recvpool_shmid);
ret_ptr = i2asc((uchar_ptr_t)shmid_buff, repl_instance.recvpool_shmid);
*ret_ptr = '\0';
if (rndwn_both_pools)
gtm_putmsg(VARLSTCNT(6) (recvpool_stat ? ERR_MURPOOLRNDWNSUC : ERR_MURPOOLRNDWNFL),
4, LEN_AND_STR(shmid_buff), LEN_AND_STR(replpool_id->instfilename));
} else if (INVALID_SEMID != repl_instance.recvpool_semid)
{
if (0 == sem_rmid(repl_instance.recvpool_semid))
{ /* note that shmid_buff used here is actually a buffer to hold semid (not shmid) */
ret_ptr = i2asc((uchar_ptr_t)shmid_buff, repl_instance.recvpool_semid);
*ret_ptr = '\0';
gtm_putmsg(VARLSTCNT(9) ERR_MURPOOLRNDWNSUC, 4, LEN_AND_STR(shmid_buff),
LEN_AND_STR(replpool_id->instfilename), ERR_SEMREMOVED, 1, repl_instance.recvpool_semid);
} else
{
save_errno = errno;
gtm_putmsg(VARLSTCNT(13) ERR_REPLACCSEM, 3, repl_instance.recvpool_semid,
RTS_ERROR_STRING(instfilename), ERR_SYSCALL, 5, RTS_ERROR_LITERAL("recvpool sem_rmid()"),
CALLFROM, save_errno);
}
/* Note that recvpool_stat is not set to FALSE in case sem_rmid() fails above. This is because the
* journal pool is anyway not present and it is safer to reset the sem/shmids in the instance file.
* The only thing this might cause is a stranded semaphore but that is considered better than getting
* errors due to not resetting instance file.
*/
}
if (recvpool_stat) /* Reset instance file for recvpool info */
repl_inst_recvpool_reset();
}
/* Release replication instance ftok semaphore lock */
if (!ftok_sem_release(reg, TRUE, immediate))
return FALSE;
return (jnlpool_stat && recvpool_stat);
}
void mu_getlst(char *name, int4 size)
{
char *c1, *c2, *c3, *c4, rbuff[MAX_FN_LEN + 1], fbuff[MAX_FN_LEN + 1];
unsigned short rlen, flen, i;
gd_region *reg;
tp_region *list;
boolean_t matched;
error_def(ERR_MUNODBNAME);
error_def(ERR_MUBCKNODIR);
error_def(ERR_MUNOACTION);
error_def(ERR_TEXT);
mu_star_specified = FALSE;
assert(size > 0);
rlen = sizeof(rbuff);
flen = sizeof(fbuff);
if (!cli_get_str(name, rbuff, &rlen))
mupip_exit(ERR_MUNODBNAME);
if (in_backup && ((!cli_get_str("SAVE_DIR", fbuff, &flen)) || (0 == flen)))
mupip_exit(ERR_MUBCKNODIR);
is_directory = FALSE;
for (c1 = c2 = rbuff, c3 = c4 = fbuff;;)
{
for (; *c2 && (*c2 != ','); c2++) /* locate a reg spec */
;
if (c2 - c1 > MAX_RN_LEN)
{
error_mupip = TRUE;
util_out_print("!UL exceeds maximum REGION name length of !UL characters.", TRUE, c2 - c1, MAX_RN_LEN);
} else
{ /* handle the reg spec here */
if ('*' == *c1 && (1 == c2 - c1))
mu_star_specified = TRUE;
matched = FALSE;
for (i = 0, reg = gd_header->regions; i < gd_header->n_regions; i++, reg++)
{
if (TRUE == str_match((char *)reg->rname, reg->rname_len, c1, c2 - c1))
{
matched = TRUE;
if (NULL == (list = insert_region(reg, &(grlist), NULL, size)))
{
error_mupip = TRUE;
rts_error(VARLSTCNT(4) ERR_TEXT, 2, RTS_ERROR_STRING("Region not found"));
continue;
}
if ((FALSE == in_backup) || (0 != ((backup_reg_list *)list)->backup_file.len))
continue;
if (TRUE == is_directory)
{
assert(NULL != grlist->fPtr);
mubexpfilnam(directory.addr, directory.len, (backup_reg_list *)list);
} else
{
for (; *c4 && (*c4 != ','); c4++) /* locate a file spec */
;
if (FALSE == mubgetfil((backup_reg_list *)list, c3, c4 - c3))
break;
if (*c4)
c3 = ++c4;
else if (FALSE == is_directory)
break;
}
}
}
if (!matched)
{
util_out_print("REGION !AD not found", TRUE, c2 - c1, c1);
mupip_exit(ERR_MUNOACTION);
}
}
if (!*c2)
break;
else
c1 = ++c2;
}
return;
}
int send_mesg2gtmsecshr(unsigned int code, unsigned int id, char *path, int path_len)
{
int client_sockfd, create_server_status, fcntl_res;
int req_code, wait_count = 0;
int recv_len, send_len;
ssize_t num_chars_recvd, num_chars_sent;
int save_errno, ret_code = 0, init_ret_code = 0;
int loop_count = 0;
int recv_complete, send_complete;
boolean_t retry = FALSE;
size_t server_proc_len;
int semop_res;
int selstat, status;
char *recv_ptr, *send_ptr;
struct sockaddr_un server_proc;
struct sembuf sop[4];
fd_set wait_on_fd;
gtmsecshr_mesg mesg;
TID timer_id;
int4 msec_timeout;
char *gtm_tmp_ptr;
struct stat stat_buf;
struct shmid_ds shm_info;
int len;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
DBGGSSHR((LOGFLAGS, "secshr_client: New send request\n"));
if (!gtm_dist_ok_to_use)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_GTMDISTUNVERIF, 4, STRLEN(gtm_dist), gtm_dist,
gtmImageNames[image_type].imageNameLen, gtmImageNames[image_type].imageName);
/* Create communication key (hash of release name) if it has not already been done */
if (0 == TREF(gtmsecshr_comkey))
{
STR_HASH((char *)gtm_release_name, gtm_release_name_len, TREF(gtmsecshr_comkey), 0);
}
timer_id = (TID)send_mesg2gtmsecshr;
if (!gtmsecshr_file_check_done)
{
len = STRLEN(gtm_dist);
memcpy(gtmsecshr_path, gtm_dist, len);
gtmsecshr_path[len] = '/';
memcpy(gtmsecshr_path + len + 1, GTMSECSHR_EXECUTABLE, STRLEN(GTMSECSHR_EXECUTABLE));
gtmsecshr_pathname.addr = gtmsecshr_path;
gtmsecshr_pathname.len = len + 1 + STRLEN(GTMSECSHR_EXECUTABLE);
assertpro(GTM_PATH_MAX > gtmsecshr_pathname.len);
gtmsecshr_pathname.addr[gtmsecshr_pathname.len] = '\0';
if (-1 == Stat(gtmsecshr_pathname.addr, &stat_buf))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5,
LEN_AND_LIT("stat"), CALLFROM, errno);
if ((ROOTUID != stat_buf.st_uid)
|| !(stat_buf.st_mode & S_ISUID)
|| (0 != ACCESS(gtmsecshr_pathname.addr, (X_OK))))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_GTMSECSHRPERM);
gtmsecshr_file_check_done = TRUE;
}
if (!gtmsecshr_sock_init_done && (0 < (init_ret_code = gtmsecshr_sock_init(CLIENT)))) /* Note assignment */
return init_ret_code;
DEBUG_ONLY(mesg.usesecshr = TREF(gtm_usesecshr)); /* Flag ignored in PRO build */
while (MAX_COMM_ATTEMPTS >= loop_count)
{ /* first, try the sendto */
req_code = mesg.code = code;
send_len = (int4)(GTM_MESG_HDR_SIZE);
if (REMOVE_FILE == code)
{
assert(GTM_PATH_MAX > path_len); /* Name is not user supplied so simple check */
memcpy(mesg.mesg.path, path, path_len);
send_len += path_len;
} else if (FLUSH_DB_IPCS_INFO == code)
{
assert(GTM_PATH_MAX > db_ipcs.fn_len);
memcpy(&mesg.mesg.db_ipcs, &db_ipcs, (offsetof(ipcs_mesg, fn[0]) + db_ipcs.fn_len + 1));
/* Most of the time file length is much smaller than GTM_PATH_MAX */
send_len += offsetof(ipcs_mesg, fn[0]);
send_len += mesg.mesg.db_ipcs.fn_len + 1;
} else
{
mesg.mesg.id = id;
send_len += SIZEOF(mesg.mesg.id);
}
DBGGSSHR((LOGFLAGS, "secshr_client: loop %d frm-pid: %d to-pid: %d send_len: %d code: %d\n", loop_count,
process_id, id, send_len, code));
mesg.comkey = TREF(gtmsecshr_comkey); /* Version communication key */
mesg.pid = process_id; /* Process id of client */
mesg.seqno = ++cur_seqno;
send_ptr = (char *)&mesg;
send_complete = FALSE;
SENDTO_SOCK(gtmsecshr_sockfd, send_ptr, send_len, 0, (struct sockaddr *)>msecshr_sock_name,
(GTM_SOCKLEN_TYPE)gtmsecshr_sockpath_len, num_chars_sent); /* This form handles EINTR internally */
save_errno = errno;
DBGGSSHR((LOGFLAGS, "secshr_client: sendto rc: %d errno: %d (only important if rc=-1)\n", (int)num_chars_sent,
save_errno));
if (0 >= num_chars_sent)
{ /* SENDTO_SOCK failed - start server and attempt to resend */
if ((EISCONN == save_errno) || (EBADF == save_errno))
{
gtmsecshr_sock_cleanup(CLIENT);
gtmsecshr_sock_init(CLIENT);
wcs_backoff(loop_count + 1);
DBGGSSHR((LOGFLAGS, "secshr_client: Connection error, reset socket\n"));
} else
{
if (0 < loop_count)
/* No message unless attempted server start at least once */
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(11) ERR_GTMSECSHRSRVF, 4,
RTS_ERROR_TEXT("Client"), process_id,
loop_count - 1, ERR_TEXT, 2,
RTS_ERROR_TEXT("sendto to gtmsecshr failed"), save_errno);
START_SERVER;
DBGGSSHR((LOGFLAGS, "secshr_client: sendto() failed - restarting server\n"));
}
loop_count++;
continue;
}
SETUP_FOR_RECV; /* Sets timer, recvcomplete = FALSE */
do
{ /* Note RECVFROM does not loop on EINTR return codes so must be handled. Note also we only expect
* to receive the message header back as an acknowledgement.
*/
num_chars_recvd = RECVFROM(gtmsecshr_sockfd, recv_ptr, GTM_MESG_HDR_SIZE, 0, (struct sockaddr *)0,
(GTM_SOCKLEN_TYPE *)0);
save_errno = errno;
DBGGSSHR((LOGFLAGS, "secshr_client: recvfrom rc: %d errno: %d (only important if rc=-1)\n",
(int)num_chars_recvd, save_errno));
if (0 <= num_chars_recvd)
{ /* Message received - make sure it is large enough to have set seqno before we do anything
* to rely on it.
*/
if ((GTM_MESG_HDR_SIZE <= num_chars_recvd) && (mesg.seqno == cur_seqno)
&& (TREF(gtmsecshr_comkey) == mesg.comkey))
recv_complete = TRUE;
else
{ /* Message too short or not correct sequence */
cancel_timer(timer_id);
/* Print True/False for the possibilities we failed */
DBGGSSHR((LOGFLAGS, "secshr_client: Message incorrect - chars: %d, seq: %d\n",
(GTM_MESG_HDR_SIZE <= num_chars_recvd), (mesg.seqno == cur_seqno)));
SETUP_FOR_RECV;
continue;
}
} else
{ /* Something untoward happened */
if (client_timer_popped)
break;
if (EINTR == save_errno) /* Had an irrelevant interrupt - ignore */
continue;
if (EBADF == save_errno)
break;
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(11) ERR_GTMSECSHRSRVF, 4,
RTS_ERROR_TEXT("Client"), process_id, loop_count - 1, ERR_TEXT, 2,
RTS_ERROR_TEXT("recvfrom from gtmsecshr failed"), save_errno);
if ((ECONNRESET == save_errno) || (ENOTCONN == save_errno))
{
num_chars_recvd = 0;
break;
}
gtmsecshr_sock_cleanup(CLIENT);
return save_errno;
}
} while (!recv_complete);
cancel_timer(timer_id);
if (client_timer_popped || (EBADF == save_errno) || (0 == num_chars_recvd))
{ /* Timeout, connection issues, bad descriptor block - retry */
gtmsecshr_sock_cleanup(CLIENT);
gtmsecshr_sock_init(CLIENT);
retry = TRUE;
if (client_timer_popped)
{
START_SERVER;
DBGGSSHR((LOGFLAGS, "secshr_client: Read timer popped - restarting server\n"));
} else
DBGGSSHR((LOGFLAGS, "secshr_client: Read error - socket reset, retrying\n"));
loop_count++;
continue;
}
/* Response to *our* latest message available */
assert(recv_complete);
if (ret_code = mesg.code) /* Warning - assignment */
{
DBGGSSHR((LOGFLAGS, "secshr_client: non-zero response from gtmsecshr - request: %d retcode: %d\n",
req_code, ret_code));
if (INVALID_COMKEY == ret_code)
{ /* Comkey mismatch means for a different version of GT.M - we will not handle it */
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(13) ERR_GTMSECSHRSRVFIL, 7, RTS_ERROR_TEXT("Client"),
process_id, mesg.pid, req_code, RTS_ERROR_TEXT(mesg.mesg.path),
ERR_TEXT, 2, RTS_ERROR_STRING("Communicating with wrong GT.M version"));
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(13) ERR_GTMSECSHRSRVFIL, 7, RTS_ERROR_TEXT("Client"),
process_id, mesg.pid, req_code, RTS_ERROR_TEXT(mesg.mesg.path),
ERR_TEXT, 2, RTS_ERROR_STRING("Communicating with wrong GT.M version"));
break; /* rts_error should not return */
}
switch(req_code)
{
case REMOVE_FILE:
/* Called from mutex_sock_init(). Path (and length) contain null terminator byte.
* See if file still exists (may have been deleted by earlier attempt). Caller
* handles actual error.
*/
if ((-1 != Stat(path, &stat_buf)) || (ENOENT != ret_code))
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(14) ERR_GTMSECSHRSRVFIL, 7,
RTS_ERROR_TEXT("Client"),
process_id, mesg.pid, req_code, RTS_ERROR_TEXT(mesg.mesg.path),
ERR_TEXT, 2, RTS_ERROR_STRING(secshr_fail_mesg_code[req_code]),
mesg.code);
else
ret_code = 0; /* File is gone so this or a previous try actually worked */
break;
case REMOVE_SEM:
/* See if semaphore still eixsts (may have been removed by earlier attempt that
* got a reply confused or lost). If not there, no error. Else error to op-log.
*/
if ((-1 != semctl(id, 0, GETVAL)) && !SEM_REMOVED(errno))
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(13) ERR_GTMSECSHRSRVFID, 6,
RTS_ERROR_TEXT("Client"),
process_id, mesg.pid, req_code, mesg.mesg.id, ERR_TEXT, 2,
RTS_ERROR_STRING(secshr_fail_mesg_code[req_code]),
mesg.code);
else
ret_code = 0; /* File is gone so this or a previous try actually worked */
case REMOVE_SHM:
/* See if shmem still eixsts (may have been removed by earlier attempt that
* got a reply confused or lost). If not there, no error. Else error to op-log.
* Note -
*/
if ((-1 != shmctl(id, IPC_STAT, &shm_info)) && !SEM_REMOVED(errno))
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(13) ERR_GTMSECSHRSRVFID, 6,
RTS_ERROR_TEXT("Client"),
process_id, mesg.pid, req_code, mesg.mesg.id, ERR_TEXT, 2,
RTS_ERROR_STRING(secshr_fail_mesg_code[req_code]),
mesg.code);
else
ret_code = 0; /* File is gone so this or a previous try actually worked */
break;
case FLUSH_DB_IPCS_INFO: /* Errors handled by caller */
break;
default:
if (EPERM != mesg.code && EACCES != mesg.code)
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(13) ERR_GTMSECSHRSRVFID, 6,
RTS_ERROR_TEXT("Client"),
process_id, mesg.pid, req_code, mesg.mesg.id, ERR_TEXT, 2,
RTS_ERROR_STRING(secshr_fail_mesg_code[req_code]),
mesg.code);
break;
}
}
break;
}
if (MAX_COMM_ATTEMPTS < loop_count)
{
ret_code = -1;
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(10) ERR_GTMSECSHRSRVF, 4,
RTS_ERROR_TEXT("Client"), process_id, loop_count - 1,
ERR_TEXT, 2, RTS_ERROR_TEXT("Unable to communicate with gtmsecshr"));
/* If gtm_tmp is not defined, show default path */
if (gtm_tmp_ptr = GETENV("gtm_tmp"))
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_GTMSECSHRTMPPATH, 2,
RTS_ERROR_TEXT(gtm_tmp_ptr),
ERR_TEXT, 2, RTS_ERROR_TEXT("(from $gtm_tmp)"));
else
send_msg_csa(CSA_ARG(NULL) VARLSTCNT(4)
ERR_GTMSECSHRTMPPATH, 2, RTS_ERROR_TEXT("/tmp"));
}
if (ONETIMESOCKET == init_ret_code)
gtmsecshr_sock_cleanup(CLIENT);
return ret_code;
}
