Status
SmcRequestSaveYourselfPhase2(SmcConn smcConn,
SmcSaveYourselfPhase2Proc saveYourselfPhase2Proc,
SmPointer clientData)
{
IceConn iceConn = smcConn->iceConn;
_SmcPhase2Wait *wait;
if (smcConn->phase2_wait)
wait = smcConn->phase2_wait;
else
{
if ((wait = (_SmcPhase2Wait *) malloc (
sizeof (_SmcPhase2Wait))) == NULL)
{
return (0);
}
}
wait->phase2_proc = saveYourselfPhase2Proc;
wait->client_data = clientData;
smcConn->phase2_wait = wait;
IceSimpleMessage (iceConn, _SmcOpcode, SM_SaveYourselfPhase2Request);
IceFlush (iceConn);
return (1);
}
Status
IcePing (
IceConn iceConn,
IcePingReplyProc pingReplyProc,
IcePointer clientData
)
{
_IcePingWait *newping = malloc (sizeof (_IcePingWait));
_IcePingWait *ptr = iceConn->ping_waits;
if (newping == NULL)
return (0);
newping->ping_reply_proc = pingReplyProc;
newping->client_data = clientData;
newping->next = NULL;
while (ptr && ptr->next)
ptr = ptr->next;
if (ptr == NULL)
iceConn->ping_waits = newping;
else
ptr->next = newping;
IceSimpleMessage (iceConn, 0, ICE_Ping);
IceFlush (iceConn);
return (1);
}
Status
SmcGetProperties(SmcConn smcConn, SmcPropReplyProc propReplyProc,
SmPointer clientData)
{
IceConn iceConn = smcConn->iceConn;
_SmcPropReplyWait *wait, *ptr;
if ((wait = (_SmcPropReplyWait *) malloc (
sizeof (_SmcPropReplyWait))) == NULL)
{
return (0);
}
wait->prop_reply_proc = propReplyProc;
wait->client_data = clientData;
wait->next = NULL;
ptr = smcConn->prop_reply_waits;
while (ptr && ptr->next)
ptr = ptr->next;
if (ptr == NULL)
smcConn->prop_reply_waits = wait;
else
ptr->next = wait;
IceSimpleMessage (iceConn, _SmcOpcode, SM_GetProperties);
IceFlush (iceConn);
return (1);
}
IceCloseStatus
IceCloseConnection (
IceConn iceConn
)
{
int refCountReachedZero;
IceCloseStatus status;
/*
* If this connection object was never valid, we can close
* it right now. This happens if IceAcceptConnection was
* called, but after calling IceProcessMessages several times
* the connection was rejected (because of authentication or
* some other reason).
*/
if (iceConn->listen_obj &&
iceConn->connection_status != IceConnectAccepted)
{
_IceConnectionClosed (iceConn); /* invoke watch procs */
_IceFreeConnection (iceConn);
return (IceClosedNow);
}
/*---------------------------------------------------------------
ACTIONS:
A = Invoke Watch Procedures
B = Set free-asap bit
C = Free connection
D = Initialize shutdown negotiation
N = do nothing
ACTION TABLE:
IO free- dispatch protocol shutdown
error asap bit level refcount negotiation ACTION
occured set reached 0 reached 0
0 0 0 0 0 N
0 0 0 0 1 N
0 0 0 1 0 AB
0 0 0 1 1 N
0 0 1 0 0 N
0 0 1 0 1 N
0 0 1 1 0 AC
0 0 1 1 1 D
0 1 0 0 0 N
0 1 0 0 1 N
0 1 0 1 0 N
0 1 0 1 1 N
0 1 1 0 0 C
0 1 1 0 1 D
0 1 1 1 0 C
0 1 1 1 1 D
1 0 0 0 0 AB
1 0 0 0 1 AB
1 0 0 1 0 AB
1 0 0 1 1 AB
1 0 1 0 0 AC
1 0 1 0 1 AC
1 0 1 1 0 AC
1 0 1 1 1 AC
1 1 0 0 0 N
1 1 0 0 1 N
1 1 0 1 0 N
1 1 0 1 1 N
1 1 1 0 0 C
1 1 1 0 1 C
1 1 1 1 0 C
1 1 1 1 1 C
---------------------------------------------------------------*/
if (iceConn->open_ref_count > 0)
iceConn->open_ref_count--;
refCountReachedZero = iceConn->open_ref_count == 0 &&
iceConn->proto_ref_count == 0;
status = IceConnectionInUse;
if (!iceConn->free_asap && (!iceConn->io_ok ||
(iceConn->io_ok && refCountReachedZero &&
iceConn->skip_want_to_close)))
{
/*
* Invoke the watch procedures now.
*/
_IceConnectionClosed (iceConn);
status = IceClosedNow; /* may be overwritten by IceClosedASAP */
}
if (!iceConn->free_asap && iceConn->dispatch_level != 0 &&
(!iceConn->io_ok ||
(iceConn->io_ok && refCountReachedZero &&
iceConn->skip_want_to_close)))
{
/*
* Set flag so we free the connection as soon as possible.
*/
iceConn->free_asap = True;
status = IceClosedASAP;
}
if (iceConn->io_ok && iceConn->dispatch_level == 0 &&
!iceConn->skip_want_to_close && refCountReachedZero)
{
/*
* Initiate shutdown negotiation.
*/
IceSimpleMessage (iceConn, 0, ICE_WantToClose);
IceFlush (iceConn);
iceConn->want_to_close = 1;
status = IceStartedShutdownNegotiation;
}
else if (iceConn->dispatch_level == 0 &&
(!iceConn->io_ok || (iceConn->io_ok && iceConn->skip_want_to_close &&
(iceConn->free_asap || (!iceConn->free_asap && refCountReachedZero)))))
{
/*
* Free the connection.
*/
_IceFreeConnection (iceConn);
status = IceClosedNow;
}
return (status);
}