/* This is called when data is available on an ICE connection. */
static gboolean
process_ice_messages (GIOChannel *channel,
GIOCondition condition,
gpointer client_data)
{
IceConn connection = (IceConn) client_data;
IceProcessMessagesStatus status;
/* This blocks infinitely sometimes. I don't know what
* to do about it. Checking "condition" just breaks
* session management.
*/
status = IceProcessMessages (connection, NULL, NULL);
if (status == IceProcessMessagesIOError)
{
#if 0
IcePointer context = IceGetConnectionContext (connection);
#endif
/* We were disconnected */
IceSetShutdownNegotiation (connection, False);
IceCloseConnection (connection);
return FALSE;
}
return TRUE;
}
static void ice_io_cb(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t flags, void *userdata) {
IceConn connection = userdata;
if (IceProcessMessages(connection, NULL, NULL) == IceProcessMessagesIOError) {
IceSetShutdownNegotiation(connection, False);
IceCloseConnection(connection);
}
}
void KSMCloseConnectionProc (
SmsConn smsConn,
SmPointer managerData,
int count,
char ** reasonMsgs
)
{
the_server->deleteClient( ( KSMClient* ) managerData );
if ( count )
SmFreeReasons( count, reasonMsgs );
IceConn iceConn = SmsGetIceConnection( smsConn );
SmsCleanUp( smsConn );
IceSetShutdownNegotiation (iceConn, False);
IceCloseConnection( iceConn );
}
static void
gsm_xsmp_client_disconnect (GsmXSMPClient *client)
{
if (client->priv->watch_id > 0) {
g_source_remove (client->priv->watch_id);
}
if (client->priv->conn != NULL) {
SmsCleanUp (client->priv->conn);
}
if (client->priv->ice_connection != NULL) {
IceSetShutdownNegotiation (client->priv->ice_connection, FALSE);
IceCloseConnection (client->priv->ice_connection);
}
}
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);
}
}
}
void KSMServer::processData( int /*socket*/ )
{
IceConn iceConn = ((KSMConnection*)sender())->iceConn;
IceProcessMessagesStatus status = IceProcessMessages( iceConn, 0, 0 );
if ( status == IceProcessMessagesIOError ) {
IceSetShutdownNegotiation( iceConn, False );
QList<KSMClient*>::iterator it = clients.begin();
QList<KSMClient*>::iterator const itEnd = clients.end();
while ( ( it != itEnd ) && *it && ( SmsGetIceConnection( ( *it )->connection() ) != iceConn ) )
++it;
if ( ( it != itEnd ) && *it ) {
SmsConn smsConn = (*it)->connection();
deleteClient( *it );
SmsCleanUp( smsConn );
}
(void) IceCloseConnection( iceConn );
}
}
/* This is called when data is available on an ICE connection. */
static bool
iceProcessMessages (IceConn connection)
{
SM_DEBUG (printf ("ICE connection process messages\n"));
IceProcessMessagesStatus status = IceProcessMessages (connection, NULL, NULL);
if (status == IceProcessMessagesIOError)
{
SM_DEBUG (printf ("ICE connection process messages"
" - error => shutting down the connection\n"));
IceSetShutdownNegotiation (connection, False);
IceCloseConnection (connection);
}
return 1;
}
static gboolean
ice_connection_accept (GIOChannel *channel,
GIOCondition condition,
gpointer watch_data)
{
IceConnectStatus cstatus;
IceAcceptStatus astatus;
IceListenObj ice_listener = (IceListenObj) watch_data;
IceConn ice_conn;
ice_conn = IceAcceptConnection (ice_listener, &astatus);
if (astatus != IceAcceptSuccess)
{
g_warning ("Failed to accept ICE connection on listener %p",
(gpointer) ice_listener);
}
else
{
/* Wait for the connection to leave pending state */
do
{
IceProcessMessages (ice_conn, NULL, NULL);
}
while ((cstatus = IceConnectionStatus (ice_conn)) == IceConnectPending);
if (cstatus != IceConnectAccepted)
{
if (cstatus == IceConnectIOError)
{
g_warning ("I/O error opening ICE connection %p", (gpointer) ice_conn);
}
else
{
g_warning ("ICE connection %p rejected", (gpointer) ice_conn);
}
IceSetShutdownNegotiation (ice_conn, False);
IceCloseConnection (ice_conn);
}
}
return TRUE;
}
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_process_messages(gpointer data, gint fd,
PurpleInputCondition condition) {
struct ice_connection_info *conninfo = (struct ice_connection_info*) data;
IceProcessMessagesStatus status;
/* please don't block... please! */
status = IceProcessMessages(conninfo->connection, NULL, NULL);
if (status == IceProcessMessagesIOError) {
purple_debug(PURPLE_DEBUG_INFO, "Session Management",
"ICE IO error, closing connection... ");
/* IO error, please disconnect */
IceSetShutdownNegotiation(conninfo->connection, False);
IceCloseConnection(conninfo->connection);
purple_debug(PURPLE_DEBUG_INFO, NULL, "done.\n");
/* cancel the handler */
purple_input_remove(conninfo->input_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 );
}
SmcCloseStatus
SmcCloseConnection(SmcConn smcConn, int count, char **reasonMsgs)
{
IceConn iceConn = smcConn->iceConn;
smCloseConnectionMsg *pMsg;
char *pData;
int extra, i;
IceCloseStatus closeStatus;
SmcCloseStatus statusRet;
extra = 8;
for (i = 0; i < count; i++)
extra += ARRAY8_BYTES (strlen (reasonMsgs[i]));
IceGetHeaderExtra (iceConn, _SmcOpcode, SM_CloseConnection,
SIZEOF (smCloseConnectionMsg), WORD64COUNT (extra),
smCloseConnectionMsg, pMsg, pData);
STORE_CARD32 (pData, count);
pData += 4;
for (i = 0; i < count; i++)
STORE_ARRAY8 (pData, strlen (reasonMsgs[i]), reasonMsgs[i]);
IceFlush (iceConn);
IceProtocolShutdown (iceConn, _SmcOpcode);
IceSetShutdownNegotiation (iceConn, False);
closeStatus = IceCloseConnection (iceConn);
if (smcConn->vendor)
free (smcConn->vendor);
if (smcConn->release)
free (smcConn->release);
if (smcConn->client_id)
free (smcConn->client_id);
if (smcConn->prop_reply_waits)
{
_SmcPropReplyWait *ptr = smcConn->prop_reply_waits;
_SmcPropReplyWait *next;
while (ptr)
{
next = ptr->next;
free ((char *) ptr);
ptr = next;
}
}
free ((char *) smcConn);
if (closeStatus == IceClosedNow)
statusRet = SmcClosedNow;
else if (closeStatus == IceClosedASAP)
statusRet = SmcClosedASAP;
else
statusRet = SmcConnectionInUse;
return (statusRet);
}
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);
}
}
}
Bool
dcop_connect()
{
size_t bytesRead = 0;
IcePointer context = 0;
FILE * f = 0L;
char * newline = 0L;
char * homeDir = 0L;
char * display = 0L;
char * dcopServer = 0L;
char errBuf[BUFFER_SIZE];
char fileName[BUFFER_SIZE];
char hostName[BUFFER_SIZE];
char displayName[BUFFER_SIZE];
char * i;
homeDir = getenv("HOME");
if (NULL == homeDir)
return False;
display = getenv("DISPLAY");
if (NULL == display)
display = "NODISPLAY";
strncpy(displayName, display, sizeof(displayName));
displayName[sizeof(displayName) - 1] = 0;
if((i = strrchr(displayName, '.')) > strrchr(displayName, ':') && i)
*i = '\0';
while((i = strchr(displayName, ':')) != NULL)
*i = '_';
dcopServer = getenv("DCOPSERVER");
if (NULL == dcopServer) {
if (-1 == chdir(homeDir)) {
fprintf(stderr, "Cannot cd ~\n");
return False;
}
hostName[0] = '\0';
if (getenv("XAUTHLOCALHOSTNAME"))
strlcpy(hostName, getenv("XAUTHLOCALHOSTNAME"),sizeof(hostName)-1);
else if (gethostname(hostName, sizeof(hostName)))
strcpy(hostName, "localhost");
else
hostName[sizeof(hostName)-1] = '\0';
snprintf(fileName, sizeof(fileName), ".DCOPserver_%s_%s", hostName, displayName);
f = fopen(fileName, "r");
if (NULL == f) {
fprintf(stderr, "Cannot open ~/%s\n", fileName);
return False;
}
dcopServer = (char *)malloc(BUFFER_SIZE);
bytesRead = fread((void *)dcopServer, sizeof(char), BUFFER_SIZE, f);
dcopServer[BUFFER_SIZE - 1] = 0;
if (0 == bytesRead)
return False;
newline = strchr(dcopServer, '\n');
if (NULL == newline) {
fprintf(stderr, "dcop server file format invalid\n");
return False;
}
*newline = '\0';
}
dcop_ice_conn =
IceOpenConnection(
dcopServer,
context,
False,
dcop_major_opcode,
sizeof(errBuf),
errBuf
);
if (NULL != dcopServer)
free(dcopServer);
if (0 == dcop_ice_conn) {
fprintf(stderr, "dcop_ice_conn is 0 :(\n");
return False;
}
IceSetShutdownNegotiation(dcop_ice_conn, False);
return True;
}
