/* This is called when a new ICE connection is made. It arranges for
the ICE connection to be handled via the event loop. */
static void
new_ice_connection (IceConn connection, IcePointer client_data, Bool opening,
IcePointer *watch_data)
{
guint input_id;
if (opening)
{
/* Make sure we don't pass on these file descriptors to any
* exec'ed children
*/
GIOChannel *channel;
fcntl (IceConnectionNumber (connection), F_SETFD,
fcntl (IceConnectionNumber (connection), F_GETFD, 0) | FD_CLOEXEC);
channel = g_io_channel_unix_new (IceConnectionNumber (connection));
input_id = g_io_add_watch (channel,
G_IO_IN | G_IO_ERR,
process_ice_messages,
connection);
g_io_channel_unref (channel);
*watch_data = (IcePointer) GUINT_TO_POINTER (input_id);
}
else
{
input_id = GPOINTER_TO_UINT ((gpointer) *watch_data);
g_source_remove (input_id);
}
}
/* This is called when a new ICE connection is made. It arranges for
the ICE connection to be handled via the event loop. */
static void
iceNewConnection(IceConn connection,
IcePointer clientData,
Bool opening,
IcePointer *watchData)
{
if (opening)
{
SM_DEBUG(printf("ICE connection opening\n"));
/* Make sure we don't pass on these file descriptors to any
exec'ed children */
fcntl(IceConnectionNumber(connection), F_SETFD,
fcntl(IceConnectionNumber(connection),
F_GETFD, 0) | FD_CLOEXEC);
iceWatchFdHandle = compAddWatchFd(IceConnectionNumber(connection),
POLLIN | POLLPRI | POLLHUP | POLLERR,
iceProcessMessages, connection);
iceConnected = 1;
}
else
{
SM_DEBUG(printf("ICE connection closing\n"));
if (iceConnected)
{
compRemoveWatchFd(iceWatchFdHandle);
iceWatchFdHandle = 0;
iceConnected = 0;
}
}
}
static void IceWatch(IceConn c,IcePointer data,Bool opening,IcePointer*){
IceHook * hook = (IceHook*)data;
if (opening) {
ap::ap_set_closeonexec(IceConnectionNumber(c));
//fcntl(IceConnectionNumber(c),F_SETFD,FD_CLOEXEC);
hook->application->addInput(hook,ID_CONNECTION,IceConnectionNumber(c),INPUT_READ,c);
}
else
hook->application->removeInput(IceConnectionNumber(c),INPUT_READ);
}
void
_XtIceWatchProc (
IceConn ice_conn,
IcePointer client_data,
Bool opening,
IcePointer *watch_data)
{
#ifdef DEBUG
printf ("_XtIceWatchProc\n");
#endif /* DEBUG */
if (opening)
{
XtAppContext appContext = (XtAppContext) client_data;
*watch_data = (IcePointer) XtAppAddInput (
appContext,
IceConnectionNumber (ice_conn),
(XtPointer) XtInputReadMask,
_XtProcessIceMsgProc,
(XtPointer) ice_conn);
}
else
{
XtRemoveInput ((XtInputId) *watch_data);
}
}
static void ice_watch_callback(IceConn conn, IcePointer handle,
Bool opening, IcePointer *watch_data)
{
SessionData *sd = handle;
(void) watch_data;
if (opening)
{
int fd = IceConnectionNumber(conn);
SLOG("Opening ice watch callback on fd %d", fd);
sd->ice_conn = conn;
fcntl(fd, F_SETFD, FD_CLOEXEC);
sd->ioc = g_io_channel_unix_new(fd);
sd->tag = g_io_add_watch(sd->ioc, G_IO_IN, ioc_watch_callback, sd);
}
else
{
SLOG("Closing ice watch callback");
if (sd->tag)
{
g_source_remove(sd->tag);
sd->tag = 0;
}
if (sd->ioc)
{
g_io_channel_unref(sd->ioc);
sd->ioc = NULL;
}
}
}
KRequestShutdownHelper::KRequestShutdownHelper()
{
#if HAVE_X11
SmcCallbacks calls;
calls.save_yourself.callback = save_yourself_callback;
calls.die.callback = dummy_callback;
calls.save_complete.callback = dummy_callback;
calls.shutdown_cancelled.callback = dummy_callback;
char* id = NULL;
char err[ 11 ];
conn = SmcOpenConnection( NULL, NULL, 1, 0,
SmcSaveYourselfProcMask | SmcDieProcMask | SmcSaveCompleteProcMask
| SmcShutdownCancelledProcMask, &calls, NULL, &id, 10, err );
if( id != NULL )
free( id );
if( conn == NULL )
return; // no SM
// set the required properties, mostly dummy values
SmPropValue propvalue[ 5 ];
SmProp props[ 5 ];
propvalue[ 0 ].length = sizeof( unsigned char );
unsigned char value0 = SmRestartNever; // so that this extra SM connection doesn't interfere
propvalue[ 0 ].value = &value0;
props[ 0 ].name = const_cast< char* >( SmRestartStyleHint );
props[ 0 ].type = const_cast< char* >( SmCARD8 );
props[ 0 ].num_vals = 1;
props[ 0 ].vals = &propvalue[ 0 ];
struct passwd* entry = getpwuid( geteuid() );
propvalue[ 1 ].length = entry != NULL ? strlen( entry->pw_name ) : 0;
propvalue[ 1 ].value = (SmPointer)( entry != NULL ? entry->pw_name : "" );
props[ 1 ].name = const_cast< char* >( SmUserID );
props[ 1 ].type = const_cast< char* >( SmARRAY8 );
props[ 1 ].num_vals = 1;
props[ 1 ].vals = &propvalue[ 1 ];
propvalue[ 2 ].length = 0;
propvalue[ 2 ].value = (SmPointer)( "" );
props[ 2 ].name = const_cast< char* >( SmRestartCommand );
props[ 2 ].type = const_cast< char* >( SmLISTofARRAY8 );
props[ 2 ].num_vals = 1;
props[ 2 ].vals = &propvalue[ 2 ];
propvalue[ 3 ].length = strlen( "requestshutdownhelper" );
propvalue[ 3 ].value = (SmPointer)"requestshutdownhelper";
props[ 3 ].name = const_cast< char* >( SmProgram );
props[ 3 ].type = const_cast< char* >( SmARRAY8 );
props[ 3 ].num_vals = 1;
props[ 3 ].vals = &propvalue[ 3 ];
propvalue[ 4 ].length = 0;
propvalue[ 4 ].value = (SmPointer)( "" );
props[ 4 ].name = const_cast< char* >( SmCloneCommand );
props[ 4 ].type = const_cast< char* >( SmLISTofARRAY8 );
props[ 4 ].num_vals = 1;
props[ 4 ].vals = &propvalue[ 4 ];
SmProp* p[ 5 ] = { &props[ 0 ], &props[ 1 ], &props[ 2 ], &props[ 3 ], &props[ 4 ] };
SmcSetProperties( conn, 5, p );
notifier = new QSocketNotifier( IceConnectionNumber( SmcGetIceConnection( conn )),
QSocketNotifier::Read, this );
connect( notifier, SIGNAL(activated(int)), SLOT(processData()));
#endif
}
static void ice_connection_watch(IceConn connection, IcePointer client_data,
Bool opening, IcePointer *watch_data) {
struct ice_connection_info *conninfo = NULL;
if (opening) {
gaim_debug(GAIM_DEBUG_INFO, "Session Management",
"Handling new ICE connection... ");
/* ensure ICE connection is not passed to child processes */
fcntl(IceConnectionNumber(connection), F_SETFD, FD_CLOEXEC);
conninfo = g_new(struct ice_connection_info, 1);
conninfo->connection = connection;
/* watch the connection */
conninfo->input_id = gaim_input_add(IceConnectionNumber(connection), GAIM_INPUT_READ,
ice_process_messages, conninfo);
*watch_data = conninfo;
} else {
static void ice_connection_watch(IceConn connection, IcePointer client_data,
Bool opening, IcePointer *watch_data) {
struct ice_connection_info *conninfo = NULL;
if (opening) {
purple_debug(PURPLE_DEBUG_INFO, "Session Management",
"Handling new ICE connection... \n");
/* ensure ICE connection is not passed to child processes */
if (fcntl(IceConnectionNumber(connection), F_SETFD, FD_CLOEXEC) != 0)
purple_debug_warning("gtksession", "couldn't set FD_CLOEXEC\n");
conninfo = g_new(struct ice_connection_info, 1);
conninfo->connection = connection;
/* watch the connection */
conninfo->input_id = purple_input_add(IceConnectionNumber(connection), PURPLE_INPUT_READ,
ice_process_messages, conninfo);
*watch_data = conninfo;
} else {
static void new_ice_connection(IceConn connection, IcePointer client_data, Bool opening, IcePointer *watch_data) {
struct pa_core *c = client_data;
if (opening)
*watch_data = c->mainloop->io_new(
c->mainloop,
IceConnectionNumber(connection),
PA_IO_EVENT_INPUT,
ice_io_cb,
connection);
else
c->mainloop->io_free(*watch_data);
}
static void
ice_conn_watch_CB (IceConn iceConn, IcePointer clientData,
int opening, IcePointer *watchData)
{
if (! opening)
{
ice_connection_closed ();
return;
}
ice_fd = IceConnectionNumber (iceConn);
add_read_fd (ice_fd, x_session_check_input, NULL);
}
static void sm_ice_watch_fd(IceConn conn,
IcePointer UNUSED(client_data),
Bool opening,
IcePointer *UNUSED(watch_data))
{
if(opening){
if(sm_fd!=-1){ /* shouldn't happen */
warn(TR("Too many ICE connections."));
}
else{
sm_fd=IceConnectionNumber(conn);
cloexec_braindamage_fix(sm_fd);
mainloop_register_input_fd(sm_fd, NULL, &sm_process_messages);
}
}
else{
if (IceConnectionNumber(conn)==sm_fd){
mainloop_unregister_input_fd(sm_fd);
sm_fd=-1;
}
}
}
static Status
sm_new_client (SmsConn sms_conn,
SmPointer manager_data,
unsigned long *mask,
SmsCallbacks *callbacks,
char **failure_reason)
{
XfsmManager *manager = XFSM_MANAGER (manager_data);
XfsmClient *client;
gchar *error = NULL;
xfsm_verbose ("ICE connection fd = %d, received NEW CLIENT\n\n",
IceConnectionNumber (SmsGetIceConnection (sms_conn)));
client = xfsm_manager_new_client (manager, sms_conn, &error);
if (client == NULL)
{
xfsm_verbose ("NEW CLIENT failed: %s\n", error);
#ifdef HAVE_STRDUP
*failure_reason = strdup (error);
#else
*failure_reason = (char *) malloc (strlen (error) + 1);
if (*failure_reason != NULL)
strcpy (*failure_reason, error);
#endif
return False;
}
SET_CALLBACK (callbacks, register_client, client);
SET_CALLBACK (callbacks, interact_request, client);
SET_CALLBACK (callbacks, interact_done, client);
SET_CALLBACK (callbacks, save_yourself_request, client);
SET_CALLBACK (callbacks, save_yourself_phase2_request, client);
SET_CALLBACK (callbacks, save_yourself_done, client);
SET_CALLBACK (callbacks, close_connection, client);
SET_CALLBACK (callbacks, set_properties, client);
SET_CALLBACK (callbacks, delete_properties, client);
SET_CALLBACK (callbacks, get_properties, client);
*mask = SmsRegisterClientProcMask | SmsInteractRequestProcMask
| SmsInteractDoneProcMask | SmsSaveYourselfRequestProcMask
| SmsSaveYourselfP2RequestProcMask | SmsSaveYourselfDoneProcMask
| SmsCloseConnectionProcMask | SmsSetPropertiesProcMask
| SmsDeletePropertiesProcMask | SmsGetPropertiesProcMask;
g_object_set_data (G_OBJECT (client), "--xfsm-manager", manager);
return True;
}
static void
NewConnectionXtProc(XtPointer client_data, int *source, XtInputId *id)
{
IceConn ice_conn;
char *connstr;
IceAcceptStatus status;
if (shutdownInProgress)
{
/*
* Don't accept new connections if we are in the middle
* of a shutdown.
*/
return;
}
ice_conn = IceAcceptConnection((IceListenObj) client_data, &status);
if (! ice_conn) {
if (verbose)
printf ("IceAcceptConnection failed\n");
} else {
IceConnectStatus cstatus;
while ((cstatus = IceConnectionStatus (ice_conn))==IceConnectPending) {
XtAppProcessEvent (appContext, XtIMAll);
}
if (cstatus == IceConnectAccepted) {
if (verbose) {
printf ("ICE Connection opened by client, IceConn fd = %d, ",
IceConnectionNumber (ice_conn));
connstr = IceConnectionString (ice_conn);
printf ("Accept at networkId %s\n", connstr);
free (connstr);
printf ("\n");
}
} else {
if (verbose)
{
if (cstatus == IceConnectIOError)
printf ("IO error opening ICE Connection!\n");
else
printf ("ICE Connection rejected!\n");
}
IceCloseConnection (ice_conn);
}
}
}
static void
ice_error_handler (IceConn ice_conn)
{
/*
* The I/O error handlers does whatever is necessary to respond
* to the I/O error and then returns, but it does not call
* IceCloseConnection. The ICE connection is given a "bad IO"
* status, and all future reads and writes to the connection
* are ignored. The next time IceProcessMessages is called it
* will return a status of IceProcessMessagesIOError. At that
* time, the application should call IceCloseConnection.
*/
xfsm_verbose ("ICE connection fd = %d, ICE I/O error on connection\n",
IceConnectionNumber (ice_conn));
}
static void
_XtProcessIceMsgProc(XtPointer client_data, int *source, XtInputId *id)
{
IceConn ice_conn = (IceConn) client_data;
IceProcessMessagesStatus status;
status = IceProcessMessages (ice_conn, NULL, NULL);
if (status == IceProcessMessagesIOError)
{
List *cl;
int found = 0;
if (verbose)
{
printf ("IO error on connection (fd = %d)\n",
IceConnectionNumber (ice_conn));
printf ("\n");
}
for (cl = ListFirst (RunningList); cl; cl = ListNext (cl))
{
ClientRec *client = (ClientRec *) cl->thing;
if (client->ice_conn == ice_conn)
{
CloseDownClient (client);
found = 1;
break;
}
}
if (!found)
{
/*
* The client must have disconnected before it was added
* to the session manager's running list (i.e. before the
* NewClientProc callback was invoked).
*/
IceSetShutdownNegotiation (ice_conn, False);
IceCloseConnection (ice_conn);
}
}
}
static Status
sm_register_client (SmsConn sms_conn,
SmPointer client_data,
char *previous_id)
{
XfsmClient *client = (XfsmClient *) client_data;
Status result;
xfsm_verbose ("ICE connection fd = %d, received REGISTER CLIENT [Previous Id = %s]\n\n",
IceConnectionNumber (SmsGetIceConnection (sms_conn)),
previous_id != NULL ? previous_id : "None");
result = xfsm_manager_register_client (client, previous_id);
if (previous_id != NULL)
free (previous_id);
return result;
}
void
_XtProcessIceMsgProc (
XtPointer client_data,
int *source,
XtInputId *id)
{
IceConn ice_conn = (IceConn) client_data;
IceProcessMessagesStatus status;
#ifdef DEBUG
printf ("_XtProcessIceMsgProc\n");
#endif /* DEBUG */
status = IceProcessMessages (ice_conn, NULL, NULL);
if (status == IceProcessMessagesIOError)
{
ClientRecPtr pClientRec;
int found = 0;
#ifdef DEBUG
printf ("IO error on connection (fd = %d)\n",
IceConnectionNumber (ice_conn));
#endif /* DEBUG */
for (pClientRec = connectedList; pClientRec != NULL;
pClientRec = pClientRec->next)
{
if (pClientRec->iceConn == ice_conn)
{
CloseDownClient (pClientRec);
found = 1;
break;
}
}
if (!found) {
IceSetShutdownNegotiation (ice_conn, False);
IceCloseConnection (ice_conn);
}
}
}
static void
ice_conn_watch_CB (IceConn iceConn, IcePointer clientData, int opening, IcePointer *watchData)
{
if (! opening)
{
ice_connection_closed ();
return;
}
ice_fd = IceConnectionNumber (iceConn);
#ifdef F_SETOWN
fcntl (ice_fd, F_SETOWN, getpid ());
#endif /* ! defined (F_SETOWN) */
#ifdef SIGIO
if (interrupt_input)
init_sigio (ice_fd);
#endif /* ! defined (SIGIO) */
add_keyboard_wait_descriptor (ice_fd);
}
static void
setup_connection (GsmXSMPClient *client)
{
GIOChannel *channel;
int fd;
g_debug ("GsmXSMPClient: Setting up new connection");
fd = IceConnectionNumber (client->priv->ice_connection);
fcntl (fd, F_SETFD, fcntl (fd, F_GETFD, 0) | FD_CLOEXEC);
channel = g_io_channel_unix_new (fd);
client->priv->watch_id = g_io_add_watch (channel,
G_IO_IN | G_IO_ERR,
(GIOFunc)client_iochannel_watch,
client);
g_io_channel_unref (channel);
set_description (client);
g_debug ("GsmXSMPClient: New client '%s'", client->priv->description);
}
static void
ice_connection_watch (IceConn ice_conn,
IcePointer client_data,
Bool opening,
IcePointer *watch_data)
{
XfsmManager *manager = XFSM_MANAGER (client_data);
GIOChannel *channel;
guint watchid;
gint fd;
if (opening)
{
XfsmIceConnData *icdata = g_new(XfsmIceConnData, 1);
icdata->manager = manager;
icdata->ice_conn = ice_conn;
fd = IceConnectionNumber (ice_conn);
/* Make sure we don't pass on these file descriptors to an
* exec'd child process.
*/
fcntl (fd, F_SETFD, fcntl (fd, F_GETFD, 0) | FD_CLOEXEC);
channel = g_io_channel_unix_new (fd);
watchid = g_io_add_watch_full (channel, G_PRIORITY_DEFAULT,
G_IO_ERR | G_IO_HUP | G_IO_IN,
ice_process_messages,
icdata, (GDestroyNotify) g_free);
g_io_channel_unref (channel);
*watch_data = (IcePointer) GUINT_TO_POINTER (watchid);
}
else
{
watchid = GPOINTER_TO_UINT (*watch_data);
g_source_remove (watchid);
}
}
static void
ice_connection_watch(IceConn connection, IcePointer client_data,
Bool opening, IcePointer *watch_data)
{
guint watch_id;
if (opening) {
GIOChannel *channel;
int fd = IceConnectionNumber(connection);
fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
channel = g_io_channel_unix_new(fd);
watch_id = g_io_add_watch(channel,
static_cast<GIOCondition>(G_IO_IN | G_IO_ERR),
ice_iochannel_watch, connection);
g_io_channel_unref(channel);
*watch_data = GUINT_TO_POINTER(watch_id);
} else {
watch_id = GPOINTER_TO_UINT(*watch_data);
g_source_remove(watch_id);
}
}
void KSMServer::newConnection( int /*socket*/ )
{
IceAcceptStatus status;
IceConn iceConn = IceAcceptConnection( ((KSMListener*)sender())->listenObj, &status);
if( iceConn == NULL )
return;
IceSetShutdownNegotiation( iceConn, False );
IceConnectStatus cstatus;
while ((cstatus = IceConnectionStatus (iceConn))==IceConnectPending) {
(void) IceProcessMessages( iceConn, 0, 0 );
}
if (cstatus != IceConnectAccepted) {
if (cstatus == IceConnectIOError)
kDebug( 1218 ) << "IO error opening ICE Connection!";
else
kDebug( 1218 ) << "ICE Connection rejected!";
(void )IceCloseConnection (iceConn);
return;
}
// don't leak the fd
fcntl( IceConnectionNumber(iceConn), F_SETFD, FD_CLOEXEC );
}
static void
ice_init(void)
{
static SmPointer context;
SmcCallbacks callbacks;
char error_string_ret[4096];
char *client_id;
char style[2];
SmPropValue styleVal;
SmProp styleProp;
SmProp *props[1];
int sm_fd;
if (!getenv("SESSION_MANAGER"))
return;
IceSetIOErrorHandler(ice_io_error_handler);
callbacks.save_yourself.callback = callback_save_yourself;
callbacks.die.callback = callback_die;
callbacks.save_complete.callback = callback_save_complete;
callbacks.shutdown_cancelled.callback = callback_shutdown_cancelled;
callbacks.save_yourself.client_data = callbacks.die.client_data =
callbacks.save_complete.client_data =
callbacks.shutdown_cancelled.client_data = (SmPointer) NULL;
client_id = Estrdup(sm_client_id);
error_string_ret[0] = '\0';
sm_conn =
SmcOpenConnection(NULL, &context, SmProtoMajor, SmProtoMinor,
SmcSaveYourselfProcMask | SmcDieProcMask |
SmcSaveCompleteProcMask |
SmcShutdownCancelledProcMask, &callbacks,
client_id, &sm_client_id, 4096, error_string_ret);
Efree(client_id);
if (error_string_ret[0])
Eprintf("While connecting to session manager: %s.", error_string_ret);
if (!sm_conn)
return;
style[0] = SmRestartIfRunning;
style[1] = 0;
styleVal.length = 1;
styleVal.value = style;
styleProp.name = (char *)SmRestartStyleHint;
styleProp.type = (char *)SmCARD8;
styleProp.num_vals = 1;
styleProp.vals = &styleVal;
props[0] = &styleProp;
ice_conn = SmcGetIceConnection(sm_conn);
sm_fd = IceConnectionNumber(ice_conn);
/* Just in case we are a copy of E created by a doExit("restart") */
SmcSetProperties(sm_conn, 1, props);
fcntl(sm_fd, F_SETFD, fcntl(sm_fd, F_GETFD, 0) | FD_CLOEXEC);
sm_efd = EventFdRegister(sm_fd, ice_msgs_process);
}
static Status
RegisterClientProc(SmsConn smsConn, SmPointer managerData, char *previousId)
{
ClientRec *client = (ClientRec *) managerData;
char *id;
List *cl;
int send_save;
if (verbose)
{
printf (
"On IceConn fd = %d, received REGISTER CLIENT [Previous Id = %s]\n",
IceConnectionNumber (client->ice_conn),
previousId ? previousId : "NULL");
printf ("\n");
}
if (!previousId)
{
id = SmsGenerateClientID (smsConn);
send_save = 1;
}
else
{
int found_match = 0;
send_save = 1;
for (cl = ListFirst (PendingList); cl; cl = ListNext (cl))
{
PendingClient *pendClient = (PendingClient *) cl->thing;
if (!strcmp (pendClient->clientId, previousId))
{
SetInitialProperties (client, pendClient->props);
XtFree (pendClient->clientId);
XtFree (pendClient->clientHostname);
XtFree ((char *) pendClient);
ListFreeOne (cl);
found_match = 1;
send_save = 0;
break;
}
}
if (!found_match)
{
for (cl = ListFirst (RestartAnywayList); cl; cl = ListNext (cl))
{
ClientRec *rClient = (ClientRec *) cl->thing;
if (!strcmp (rClient->clientId, previousId))
{
SetInitialProperties (client, rClient->props);
FreeClient (rClient, False /* don't free props */);
ListFreeOne (cl);
found_match = 1;
send_save = 0;
break;
}
}
}
if (!found_match)
{
for (cl = ListFirst (RestartImmedList); cl; cl = ListNext (cl))
{
ClientRec *rClient = (ClientRec *) cl->thing;
if (!strcmp (rClient->clientId, previousId))
{
SetInitialProperties (client, rClient->props);
FreeClient (rClient, False /* don't free props */);
ListFreeOne (cl);
found_match = 1;
send_save = 0;
break;
}
}
}
if (!found_match)
{
/*
* previous-id was bogus: return bad status and the client
* should re-register with a NULL previous-id
*/
free (previousId);
return (0);
}
else
{
id = previousId;
}
}
SmsRegisterClientReply (smsConn, id);
if (verbose)
{
printf (
"On IceConn fd = %d, sent REGISTER CLIENT REPLY [Client Id = %s]\n",
IceConnectionNumber (client->ice_conn), id);
printf ("\n");
}
client->clientId = id;
client->clientHostname = SmsClientHostName (smsConn);
client->restarted = (previousId != NULL);
if (send_save)
{
SmsSaveYourself (smsConn, SmSaveLocal,
False, SmInteractStyleNone, False);
ListAddLast (InitialSaveList, (char *) client);
}
else if (client_info_visible)
{
/* We already have all required client info */
UpdateClientList ();
XawListHighlight (clientListWidget, current_client_selected);
}
return (1);
}
KSMConnection( IceConn conn )
: QSocketNotifier( IceConnectionNumber( conn ),
QSocketNotifier::Read )
{
iceConn = conn;
}
static Status
NewClientProc(SmsConn smsConn, SmPointer managerData, unsigned long *maskRet,
SmsCallbacks *callbacksRet, char **failureReasonRet)
{
ClientRec *newClient = (ClientRec *) XtMalloc (sizeof (ClientRec));
*maskRet = 0;
if (!newClient)
{
char *str = "Memory allocation failed";
if ((*failureReasonRet = (char *) XtMalloc (strlen (str) + 1)) != NULL)
strcpy (*failureReasonRet, str);
return (0);
}
newClient->smsConn = smsConn;
newClient->ice_conn = SmsGetIceConnection (smsConn);
newClient->clientId = NULL;
newClient->clientHostname = NULL;
newClient->restarted = False; /* wait till RegisterClient for true value */
newClient->userIssuedCheckpoint = False;
newClient->receivedDiscardCommand = False;
newClient->freeAfterBadSavePopup = False;
newClient->props = ListInit ();
newClient->discardCommand = NULL;
newClient->saveDiscardCommand = NULL;
newClient->restartHint = SmRestartIfRunning;
ListAddLast (RunningList, (char *) newClient);
if (verbose) {
printf("On IceConn fd = %d, client set up session mngmt protocol\n\n",
IceConnectionNumber (newClient->ice_conn));
}
/*
* Set up session manager callbacks.
*/
*maskRet |= SmsRegisterClientProcMask;
callbacksRet->register_client.callback = RegisterClientProc;
callbacksRet->register_client.manager_data = (SmPointer) newClient;
*maskRet |= SmsInteractRequestProcMask;
callbacksRet->interact_request.callback = InteractRequestProc;
callbacksRet->interact_request.manager_data = (SmPointer) newClient;
*maskRet |= SmsInteractDoneProcMask;
callbacksRet->interact_done.callback = InteractDoneProc;
callbacksRet->interact_done.manager_data = (SmPointer) newClient;
*maskRet |= SmsSaveYourselfRequestProcMask;
callbacksRet->save_yourself_request.callback = SaveYourselfReqProc;
callbacksRet->save_yourself_request.manager_data = (SmPointer) newClient;
*maskRet |= SmsSaveYourselfP2RequestProcMask;
callbacksRet->save_yourself_phase2_request.callback =
SaveYourselfPhase2ReqProc;
callbacksRet->save_yourself_phase2_request.manager_data =
(SmPointer) newClient;
*maskRet |= SmsSaveYourselfDoneProcMask;
callbacksRet->save_yourself_done.callback = SaveYourselfDoneProc;
callbacksRet->save_yourself_done.manager_data = (SmPointer) newClient;
*maskRet |= SmsCloseConnectionProcMask;
callbacksRet->close_connection.callback = CloseConnectionProc;
callbacksRet->close_connection.manager_data = (SmPointer) newClient;
*maskRet |= SmsSetPropertiesProcMask;
callbacksRet->set_properties.callback = SetPropertiesProc;
callbacksRet->set_properties.manager_data = (SmPointer) newClient;
*maskRet |= SmsDeletePropertiesProcMask;
callbacksRet->delete_properties.callback = DeletePropertiesProc;
callbacksRet->delete_properties.manager_data = (SmPointer) newClient;
*maskRet |= SmsGetPropertiesProcMask;
callbacksRet->get_properties.callback = GetPropertiesProc;
callbacksRet->get_properties.manager_data = (SmPointer) newClient;
return (1);
}
void
CloseDownClient(ClientRec *client)
{
int index_deleted = 0;
if (verbose) {
printf ("ICE Connection closed, IceConn fd = %d\n",
IceConnectionNumber (client->ice_conn));
printf ("\n");
}
SmsCleanUp (client->smsConn);
IceSetShutdownNegotiation (client->ice_conn, False);
IceCloseConnection (client->ice_conn);
client->ice_conn = NULL;
client->smsConn = NULL;
if (!shutdownInProgress && client_info_visible)
{
for (index_deleted = 0;
index_deleted < numClientListNames; index_deleted++)
{
if (clientListRecs[index_deleted] == client)
break;
}
}
ListSearchAndFreeOne (RunningList, (char *) client);
if (saveInProgress)
{
Status delStatus = ListSearchAndFreeOne (
WaitForSaveDoneList, (char *) client);
if (delStatus)
{
ListAddLast (FailedSaveList, (char *) client);
client->freeAfterBadSavePopup = True;
}
ListSearchAndFreeOne (WaitForInteractList, (char *) client);
ListSearchAndFreeOne (WaitForPhase2List, (char *) client);
if (delStatus && ListCount (WaitForSaveDoneList) == 0)
{
if (ListCount (FailedSaveList) > 0 && !checkpoint_from_signal)
PopupBadSave ();
else
FinishUpSave ();
}
else if (ListCount (WaitForInteractList) > 0 &&
OkToEnterInteractPhase ())
{
LetClientInteract (ListFirst (WaitForInteractList));
}
else if (!phase2InProgress &&
ListCount (WaitForPhase2List) > 0 && OkToEnterPhase2 ())
{
StartPhase2 ();
}
}
if (client->restartHint == SmRestartImmediately && !shutdownInProgress)
{
Clone (client, True /* use saved state */);
ListAddLast (RestartImmedList, (char *) client);
}
else if (client->restartHint == SmRestartAnyway)
{
ListAddLast (RestartAnywayList, (char *) client);
}
else if (!client->freeAfterBadSavePopup)
{
FreeClient (client, True /* free props */);
}
if (shutdownInProgress)
{
if (ListCount (RunningList) == 0)
EndSession (0);
}
else if (client_info_visible)
{
UpdateClientList ();
if (current_client_selected == index_deleted)
{
if (current_client_selected == numClientListNames)
current_client_selected--;
if (current_client_selected >= 0)
{
XawListHighlight (clientListWidget, current_client_selected);
ShowHint (clientListRecs[current_client_selected]);
if (client_prop_visible)
{
DisplayProps (clientListRecs[current_client_selected]);
}
}
}
else
{
if (index_deleted < current_client_selected)
current_client_selected--;
XawListHighlight (clientListWidget, current_client_selected);
}
}
}
static void
ProcessNewPMConnection (
int * nfds,
fd_set * rinit,
struct config * config_info,
IceListenObj ** listen_objects,
int listen_fd)
{
IceConn new_ice_conn;
IceAcceptStatus accept_status;
int temp_sock_fd;
IceListenObj * temp_obj;
struct timeval time_val;
struct timezone time_zone;
struct sockaddr_in temp_sockaddr_in;
struct sockaddr_in server_sockaddr_in;
int retval;
int addrlen = sizeof(temp_sockaddr_in);
int rule_number;
int pm_idx;
/*
* Only continue if there is room for another PM connection.
*/
for (pm_idx = 0; pm_idx < config_info->num_pm_conns; pm_idx++)
{
if (!pm_conn_array[pm_idx])
break;
}
if (pm_idx >= config_info->num_pm_conns)
{
(void) fprintf (stderr,
"Maximum number of PM connections has been reached (%d)\n",
config_info->num_pm_conns);
/*
* Must accept and then close this connection or the PM will
* continue to poll.
*/
temp_obj = *listen_objects;
new_ice_conn = IceAcceptConnection(temp_obj[listen_fd], &accept_status);
if (new_ice_conn)
IceCloseConnection(new_ice_conn);
return;
}
/*
* accept the connection if you can, use pm_listen_array
* index to index into ICE listen_object list (this is because the
* listen_objects list must correspond to the pm_listen_array)
*/
temp_obj = *listen_objects;
new_ice_conn = IceAcceptConnection(temp_obj[listen_fd], &accept_status);
if (!new_ice_conn)
{
static int been_here;
/*
* ICE initialization (bug?) makes this happen the
* first time readables is hit.
*/
if (!been_here)
been_here++;
else
(void) fprintf(stderr, "IceAcceptConnection failed (%d)\n",
accept_status);
return;
}
/*
* extract the fd from this new connection; remember, the fd of
* the listen socket is *not* the fd of the actual connection!
*/
temp_sock_fd = IceConnectionNumber(new_ice_conn);
/*
* before we get any further, do a config check on the new ICE
* connection; start by using getpeername() to get endpoint info
*/
retval = getpeername(temp_sock_fd,
(struct sockaddr*)&temp_sockaddr_in,
(void *)&addrlen);
if (retval)
{
IceCloseConnection(new_ice_conn);
(void) fprintf(stderr, "getpeername call failed\n");
return;
}
assert(temp_sockaddr_in.sin_family == AF_INET);
/*
* Do a configuration check. NOTE: we're not doing anything
* with the server_sockaddr_in argument
*/
if ((doConfigCheck(&temp_sockaddr_in,
&server_sockaddr_in,
config_info,
PMGR,
&rule_number)) == FAILURE)
{
/*
* close the PM connection
*
*/
(void) fprintf(stderr, "PM failed config check\n");
IceCloseConnection(new_ice_conn);
return;
}
/*
* you've started the connection process; allocate a buffer
* for this connection, then continue processing other fd's without
* blocking while waiting to read the coming PM data; [NOTE:
* we use the fd of the connection socket as index into the
* pm_conn_array; this saves us much troublesome linked-list
* management!]
*/
if ((pm_conn_array[pm_idx] = malloc(sizeof(struct pm_conn_buf))) == NULL)
{
(void) fprintf (stderr, "malloc - PM connection object\n");
return;
}
/*
* save the ICEconn struct for future status checks; also
* the fd (although you could extract it from the ICEconn
* each time you need it, but that's a pain)
*/
pm_conn_array[pm_idx]->fd = temp_sock_fd;
pm_conn_array[pm_idx]->ice_conn = new_ice_conn;
/*
* Set the readables select() to listen for a readable on this
* fd; remember, we're not interested in pm writables, since
* all the negotiation is handled inside this routine; adjust
* the nfds (must do that every time we get a new socket to
* select() on), and then continue processing current selections
*/
FD_SET(temp_sock_fd, rinit);
*nfds = max(*nfds, temp_sock_fd + 1);
/*
* this is where we initialize the current time and timeout on this
* pm_connection object
*/
(void) gettimeofday(&time_val, &time_zone);
pm_conn_array[pm_idx]->creation_time = time_val.tv_sec;
pm_conn_array[pm_idx]->time_to_close = config_info->pm_data_timeout;
}
