static void
setup(char *argv0, bool live_check)
{
char exec_path[MAXPGPATH]; /* full path to my executable */
/*
* make sure the user has a clean environment, otherwise, we may confuse
* libpq when we connect to one (or both) of the servers.
*/
check_pghost_envvar();
verify_directories();
/* no postmasters should be running */
if (!live_check && is_server_running(old_cluster.pgdata))
pg_log(PG_FATAL, "There seems to be a postmaster servicing the old cluster.\n"
"Please shutdown that postmaster and try again.\n");
/* same goes for the new postmaster */
if (is_server_running(new_cluster.pgdata))
pg_log(PG_FATAL, "There seems to be a postmaster servicing the new cluster.\n"
"Please shutdown that postmaster and try again.\n");
/* get path to pg_upgrade executable */
if (find_my_exec(argv0, exec_path) < 0)
pg_log(PG_FATAL, "Could not get pathname to pg_upgrade: %s\n", getErrorText(errno));
/* Trim off program name and keep just path */
*last_dir_separator(exec_path) = '\0';
canonicalize_path(exec_path);
os_info.exec_path = pg_strdup(exec_path);
}
/****************************************************************
handle response (by the server) if the client has got hack or not.
*****************************************************************/
void handle_single_want_hack_reply(bool you_have_hack)
{
/* remove challenge file */
if (challenge_fullname[0] != '\0') {
if (remove(challenge_fullname) == -1) {
freelog(LOG_ERROR, "Couldn't remove temporary file: %s",
challenge_fullname);
}
challenge_fullname[0] = '\0';
}
if (you_have_hack) {
output_window_append(FTC_CLIENT_INFO, NULL,
_("Established control over the server. "
"You have command access level 'hack'."));
client_has_hack = TRUE;
} else if (is_server_running()) {
/* only output this if we started the server and we NEED hack */
output_window_append(FTC_CLIENT_INFO, NULL,
_("Failed to obtain the required access "
"level to take control of the server. "
"The server will now be shutdown."));
client_kill_server(TRUE);
}
}
void Daemon_Record::stop(void) {
if (is_server_running()) {
Block_Buffer buf;
buf.make_message(SERVER_INNER_SELF_CLOSE);
buf.finish_message();
RECORD_MONITOR->push_async_buff(buf);
}
}
/**************************************************************************
...
**************************************************************************/
static int start_new_game_callback(struct widget *pWidget)
{
if (Main.event.button.button == SDL_BUTTON_LEFT) {
popdown_start_menu();
if (is_server_running() || client_start_server()) {
/* saved settings are sent in client/options.c load_settable_options() */
}
}
return -1;
}
void
output_check_banner(bool *live_check)
{
if (user_opts.check && is_server_running(old_cluster.pgdata))
{
*live_check = true;
pg_log(PG_REPORT, "Performing Consistency Checks on Old Live Server\n");
pg_log(PG_REPORT, "------------------------------------------------\n");
}
else
{
pg_log(PG_REPORT, "Performing Consistency Checks\n");
pg_log(PG_REPORT, "-----------------------------\n");
}
}
void
output_check_banner(bool *live_check)
{
if (user_opts.check && is_server_running(old_cluster.pgdata))
{
*live_check = true;
if (old_cluster.port == new_cluster.port)
pg_log(PG_FATAL, "When checking a live server, "
"the old and new port numbers must be different.\n");
pg_log(PG_REPORT, "Performing Consistency Checks on Old Live Server\n");
pg_log(PG_REPORT, "------------------------------------------------\n");
}
else
{
pg_log(PG_REPORT, "Performing Consistency Checks\n");
pg_log(PG_REPORT, "-----------------------------\n");
}
}
/****************************************************************************
Kills the server if the client has started it.
If the 'force' parameter is unset, we just do a /quit. If it's set, then
we'll send a signal to the server to kill it (use this when the socket
is disconnected already).
****************************************************************************/
void client_kill_server(bool force)
{
if (is_server_running()) {
if (client.conn.used && client_has_hack) {
/* This does a "soft" shutdown of the server by sending a /quit.
*
* This is useful when closing the client or disconnecting because it
* doesn't kill the server prematurely. In particular, killing the
* server in the middle of a save can have disastrous results. This
* method tells the server to quit on its own. This is safer from a
* game perspective, but more dangerous because if the kill fails the
* server will be left running.
*
* Another potential problem is because this function is called atexit
* it could potentially be called when we're connected to an unowned
* server. In this case we don't want to kill it. */
send_chat("/quit");
#ifdef WIN32_NATIVE
server_process = INVALID_HANDLE_VALUE;
loghandle = INVALID_HANDLE_VALUE;
#else
server_pid = -1;
#endif
} else if (force) {
/* Either we already disconnected, or we didn't get control of the
* server. In either case, the only thing to do is a "hard" kill of
* the server. */
#ifdef WIN32_NATIVE
TerminateProcess(server_process, 0);
CloseHandle(server_process);
if (loghandle != INVALID_HANDLE_VALUE) {
CloseHandle(loghandle);
}
server_process = INVALID_HANDLE_VALUE;
loghandle = INVALID_HANDLE_VALUE;
#elif HAVE_WORKING_FORK
kill(server_pid, SIGTERM);
waitpid(server_pid, NULL, WUNTRACED);
server_pid = -1;
#endif /* WIN32_NATIVE || HAVE_WORKING_FORK */
}
}
client_has_hack = FALSE;
}
/****************************************************************
handle response (by the server) if the client has got hack or not.
*****************************************************************/
void handle_single_want_hack_reply(bool you_have_hack)
{
/* remove challenge file */
if (challenge_fullname[0] != '\0') {
if (fc_remove(challenge_fullname) == -1) {
log_error("Couldn't remove temporary file: %s", challenge_fullname);
}
challenge_fullname[0] = '\0';
}
if (you_have_hack) {
output_window_append(ftc_client,
_("Established control over the server. "
"You have command access level 'hack'."));
client_has_hack = TRUE;
} else if (is_server_running()) {
/* only output this if we started the server and we NEED hack */
output_window_append(ftc_client,
_("Failed to obtain the required access "
"level to take control of the server. "
"Attempting to shut down server."));
client_kill_server(TRUE);
}
}
smedia_handle_t
get_handle_from_fd(int32_t fd)
{
rmedia_handle_t *handle;
void *lib_handle;
int door_fd, door_server;
int ret_val;
door_arg_t door_args;
smedia_reqopen_t reqopen;
smedia_reterror_t *reterror;
door_desc_t ddesc[2];
char rbuf[sizeof (smedia_services_t) + sizeof (door_desc_t)];
struct stat stat;
DPRINTF("smedia_get_handle called\n");
handle = (rmedia_handle_t *)malloc(sizeof (rmedia_handle_t));
if (handle == NULL) {
DPRINTF("Could not allocate memory for handle\n");
return (NULL);
}
(void) memset((void *) handle, 0, sizeof (rmedia_handle_t));
handle->sm_fd = -1;
handle->sm_door = -1;
handle->sm_death_door = -1;
handle->sm_buffd = -1;
handle->sm_buf = NULL;
handle->sm_bufsize = 0;
if (ioctl(fd, DKIOCINFO, &handle->sm_dkinfo) == -1) {
free(handle);
PERROR("DKIOCINFO failed");
return (NULL);
}
lib_handle = get_dev_library_handle(fd);
if (lib_handle == NULL) {
free(handle);
DPRINTF("lib_Handle is NULL\n");
errno = ENOTSUP;
return (NULL);
}
DPRINTF("Handle initialised successfully.\n");
/* Initialise the handle elements */
handle->sm_lib_handle = lib_handle;
handle->sm_signature = LIBSMEDIA_SIGNATURE;
DPRINTF2("fd=%d signature=0x%x\n", handle->sm_fd, handle->sm_signature);
if ((handle->sm_dkinfo.dki_ctype == DKC_SCSI_CCS) ||
(handle->sm_dkinfo.dki_ctype == DKC_MD21) ||
(handle->sm_dkinfo.dki_ctype == DKC_CDROM)) {
ret_val = is_server_running(handle);
if (ret_val == 0) {
(void) dlclose(handle->sm_lib_handle);
free(handle);
return (NULL);
}
door_fd = open(smedia_service, O_RDONLY, 0644);
if (door_fd < 0) {
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
DPRINTF1("Error in opening %s\n", smedia_service);
PERROR(smedia_service);
return (NULL);
}
DPRINTF1("rbuf address=%p\n", rbuf);
ddesc[0].d_data.d_desc.d_descriptor = fd;
ddesc[0].d_attributes = DOOR_DESCRIPTOR;
reqopen.cnum = SMEDIA_CNUM_OPEN_FD;
door_args.data_ptr = (char *)&reqopen;
door_args.data_size = sizeof (smedia_services_t);
door_args.desc_ptr = &ddesc[0];
door_args.desc_num = 1;
door_args.rbuf = rbuf;
door_args.rsize = sizeof (rbuf);
ret_val = door_call(door_fd, &door_args);
(void) close(door_fd);
if (ret_val < 0) {
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
PERROR("door_call");
return (NULL);
}
DPRINTF3("rsize = %d data_size = %d data_ptr = %p \n",
door_args.rsize, door_args.data_size,
door_args.data_ptr);
reterror = (smedia_reterror_t *)((void *)door_args.data_ptr);
if (reterror->cnum != SMEDIA_CNUM_OPEN_FD) {
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
DPRINTF1(
"*** door call failed *** cnum returned = 0x%x\n", reterror->cnum);
errno = reterror->errnum;
return (NULL);
}
/*
* 2 door descriptors are returned after the above door call.
* The first door descriptor is the one that will be used
* in subsequent smedia calls. A dedicated thread is
* associated with this door to handle client calls.
* The second door descriptor is needed to signal unexpected
* death of the client to the server. This will help the server
* to do the necessary cleanup.
*/
if (door_args.desc_num != 2) {
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
DPRINTF("Num of door descriptors returned by "
"server is not 2");
if (door_args.desc_num)
(void) close(door_args.desc_ptr->\
d_data.d_desc.d_descriptor);
return (NULL);
}
door_server = door_args.desc_ptr->d_data.d_desc.d_descriptor;
/* Check if the descriptor returned is S_IFDOOR */
if (fstat(door_server, &stat) < 0) {
PERROR("fstat");
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
return (NULL);
}
if (!S_ISDOOR(stat.st_mode)) {
DPRINTF(
"Descriptor returned by door_call is not of type DOOR\n");
(void) dlclose(handle->sm_lib_handle);
free(handle);
if (handle->sm_clnt)
clnt_destroy(handle->sm_clnt);
return (NULL);
}
handle->sm_door = door_server;
handle->sm_fd = fd;
door_args.desc_ptr++;
handle->sm_death_door =
door_args.desc_ptr->d_data.d_desc.d_descriptor;
DPRINTF("door call succeeded.\n");
return ((smedia_handle_t)handle);
} else {
handle->sm_fd = fd;
return ((smedia_handle_t)handle);
}
}
