/* Special packet from socketlistener: never encrypted */
static void HandleSLPacket(RPC2_PacketBuffer *pb, struct CEntry *ce)
{
rpc2_ntohp(pb);
if (pb->Header.Opcode != RPC2_NAKED) {
BOGUS(pb, "HandleSLPacket: bogus opcode\n");
return;
}
if (!TestState(ce, CLIENT, (C_AWAITREPLY | C_AWAITINIT2))) {
BOGUS(pb, "HandleSLPacket: state != AWAIT\n");
return;
}
say(1, RPC2_DebugLevel, "HandleNak()\n");
rpc2_Recvd.Naks++;
if (BogusSl(ce, pb))
return;
rpc2_SetConnError(ce);
rpc2_DeactivateSle(ce->MySl, NAKED);
LWP_NoYieldSignal((char *)ce->MySl);
RPC2_FreeBuffer(&pb);
}
static void HandleRetriedBind(RPC2_PacketBuffer *pb, struct CEntry *ce)
{
say(1, RPC2_DebugLevel, "HandleRetriedBind()\n");
if (!TestRole(ce, SERVER)) {
BOGUS(pb, "HandleRetriedBind: not server\n");
return;
}
/* The original bind request could be:
(1) in the hold queue,
(2) in RPC2_GetRequest() on some LWP,
(3) already completed.
*/
ce->TimeStampEcho = pb->Header.TimeStamp;
/* if we're modifying the TimeStampEcho, we also have
* to reset the RequestTime */
TVTOTS(&pb->Prefix.RecvStamp, ce->RequestTime);
say(15, RPC2_DebugLevel, "handleinit1 TS %u RQ %u\n", ce->TimeStampEcho,
ce->RequestTime);
if (TestState(ce, SERVER, S_STARTBIND)) {
/* Cases (1) and (2) */
say(1, RPC2_DebugLevel, "Busying Init1 on %#x\n", ce->UniqueCID);
SendBusy(ce, FALSE);
RPC2_FreeBuffer(&pb);
return;
}
if (ce->SecurityLevel == RPC2_OPENKIMONO && ce->HeldPacket) {
/* Case (3): The Init2 must have been dropped; resend it */
say(1, RPC2_DebugLevel, "Resending Init2 %#x\n", ce->UniqueCID);
ce->HeldPacket->Header.TimeStamp = htonl(ce->TimeStampEcho);
rpc2_XmitPacket(ce->HeldPacket, ce->HostInfo->Addr, 1);
RPC2_FreeBuffer(&pb);
return;
}
/* This retry is totally bogus */
BOGUS(pb, "HandleRetriedBind: anything else\n");
return;
}
static int BogusSl(struct CEntry *ce, RPC2_PacketBuffer *pb)
{
struct SL_Entry *sl;
sl = ce->MySl;
if (sl == NULL) {
BOGUS(pb, "BogusSL: sl == NULL\n");
return (-1);
}
if (sl->Conn != ce->UniqueCID) {
BOGUS(pb, "BogusSL: sl->Conn != ce->UniqueCID\n");
return (-1);
}
if (sl->ReturnCode != WAITING && sl->ReturnCode != KEPTALIVE) {
BOGUS(
pb,
"BogusSL: sl->ReturnCode != WAITING && sl->ReturnCode != KEPTALIVE\n");
return (-1);
}
return (0);
}
static void DispatchPacket(RPC2_PacketBuffer *pb)
{
unsigned int i, ProtoVersion = ntohl(pb->Header.ProtoVersion);
for (i = 0; i < nPacketHandlers; i++) {
if (ProtoVersion == PacketHandlers[i].ProtoVersion) {
PacketHandlers[i].Handler(pb);
return;
}
}
/* we don't have a ghost of a chance */
BOGUS(pb, "Wrong version\n");
}
static void rpc2_ProcessPacket(int fd)
{
RPC2_PacketBuffer *pb = NULL;
struct timeval tv;
int rc;
/* We are guaranteed that there is a packet in the socket
buffer at this point */
RPC2_AllocBuffer(RPC2_MAXPACKETSIZE - sizeof(RPC2_PacketBuffer), &pb);
assert(pb != NULL);
assert(pb->Prefix.LE.Queue == &rpc2_PBList);
if (rpc2_RecvPacket(fd, pb) < 0) {
say(9, RPC2_DebugLevel, "Recv error, ignoring.\n");
RPC2_FreeBuffer(&pb);
return;
}
#ifdef RPC2DEBUG
if (RPC2_DebugLevel > 9) {
fprintf(rpc2_tracefile, "Packet received from ");
rpc2_printaddrinfo(pb->Prefix.PeerAddr, rpc2_tracefile);
if (pb->Prefix.sa && pb->Prefix.sa->decrypt)
fprintf(rpc2_tracefile, " (secure)");
fprintf(rpc2_tracefile, "\n");
}
#endif
if (pb->Prefix.LengthOfPacket < (ssize_t)sizeof(struct RPC2_PacketHeader)) {
/* avoid memory reference errors */
BOGUS(pb, "Runt packet\n");
return;
}
rc = LUA_fail_delay(pb->Prefix.PeerAddr, pb, 0, &tv);
if (rc == -1) {
say(9, RPC2_DebugLevel, "Dropping incoming packet\n");
RPC2_FreeBuffer(&pb);
return;
}
if (rc && rpc2_DelayedRecv(pb, &tv)) {
return;
} /* delay */
DispatchPacket(pb);
}
(*message_box, XmNokCallback, MessageBox_cb, (XtPointer)MSGBOX_OK);
XtAddCallback
(*message_box, XmNmapCallback, MessageBox_cb, (XtPointer)MSGBOX_MAP);
XmStringFree (xstr_msg);
XmStringFree (xstr_btn);
XmStringFree (xstr_title);
XtManageChild (*message_box);
XtPopup (XtParent (*message_box), XtGrabNone);
}
/*
* MessageBox_cb
*/
static void MessageBox_cb (Widget w, XtPointer client, XtPointer BOGUS(1))
{
MsgBoxEvent event = (MsgBoxEvent)client;
Window root, child;
int root_x, root_y;
int win_x, win_y;
unsigned mask;
int screen;
Display *display;
XWindowAttributes xwa;
Dimension width, height;
switch (event)
{
case MSGBOX_MAP:
static void HandleInit1(RPC2_PacketBuffer *pb)
{
struct CEntry *ce;
struct SL_Entry *sl;
rpc2_ntohp(pb);
if (pb->Header.Opcode != RPC2_INIT1OPENKIMONO &&
pb->Header.Opcode != RPC2_INIT1AUTHONLY &&
pb->Header.Opcode != RPC2_INIT1HEADERSONLY &&
pb->Header.Opcode != RPC2_INIT1SECURE) {
NAKIT(pb);
return;
}
say(1, RPC2_DebugLevel, "HandleInit1()\n");
rpc2_Recvd.Requests++;
/* Have we seen this bind request before? */
ce = rpc2_ConnFromBindInfo(pb->Prefix.PeerAddr, pb->Header.LocalHandle,
pb->Header.Uniquefier);
if (ce) {
HandleRetriedBind(pb, ce);
return;
}
/* Find a willing LWP in RPC2_GetRequest() */
sl = FindRecipient(pb);
if (!sl) {
/* no threads are ready, send a busy to the other side so that it
* will back off and try again later */
say(1, RPC2_DebugLevel,
"HandleInit1: No available threads, busying peer\n");
/* SendBusy(ce, FALSE);
* -- we don't have a CEntry yet, but we can reuse most of the
* INIT1 packet we just got... */
pb->Header.RemoteHandle ^= pb->Header.LocalHandle;
pb->Header.LocalHandle ^= pb->Header.RemoteHandle;
pb->Header.RemoteHandle ^= pb->Header.LocalHandle;
pb->Header.Opcode = RPC2_BUSY;
pb->Header.Lamport = RPC2_LamportTime();
pb->Header.SeqNumber = -1;
pb->Header.BodyLength = 0;
pb->Prefix.LengthOfPacket = sizeof(struct RPC2_PacketHeader);
rpc2_htonp(pb);
rpc2_XmitPacket(pb, pb->Prefix.PeerAddr, 1);
RPC2_FreeBuffer(&pb);
return;
}
/* Create a connection entry */
ce = MakeConn(pb);
if (!ce) {
/* Packet must have been bogus in some way */
BOGUS(pb, "HandleInit1: MakeConn failed\n");
return;
}
/* Now fix packet header so that it has a real RemoteHandle */
pb->Header.RemoteHandle = ce->UniqueCID;
rpc2_DeactivateSle(sl, ARRIVED);
sl->data = pb;
ce->Filter = sl->Filter; /* struct assignment */
ce->Filter.OldOrNew = OLDORNEW;
LWP_NoYieldSignal((char *)sl);
}
static void DecodePacket(RPC2_PacketBuffer *pb, struct CEntry *ce)
{
/* either this was an INIT1 and was handled, or we found a valid connection
* entry before calling DecodePacket */
assert(ce != NULL);
switch (pb->Header.Opcode) {
case RPC2_BUSY: {
if (!TestState(ce, CLIENT, (C_AWAITINIT2 | C_AWAITREPLY))) {
BOGUS(pb, "DecodePacket(RPC2_BUSY): state != AWAIT\n");
return;
}
/*
* If the state is C_AWAITINIT2, the server is processing
* a bind request. Sequence numbers are 0 during the bind,
* but a busy during bind will have a sequence number of -1.
*/
if (TestState(ce, CLIENT, C_AWAITREPLY) &&
ce->NextSeqNumber != pb->Header.SeqNumber - 1) {
BOGUS(pb, "DecodePacket(RPC2_BUSY): bad seqno\n");
return;
}
if (TestState(ce, CLIENT, C_AWAITINIT2) && pb->Header.SeqNumber != -1) {
BOGUS(pb, "DecodePacket(RPC2_BUSY): bad bind seqno\n");
return;
}
HandleBusy(pb, ce);
return;
}
case RPC2_REPLY: {
if (!TestState(ce, CLIENT, C_AWAITREPLY)) {
BOGUS(pb, "DecodePacket(RPC2_REPLY): state != AWAIT\n");
return;
}
if (ce->NextSeqNumber != pb->Header.SeqNumber - 1) {
BOGUS(pb, "DecodePacket(RPC2_REPLY): bad seqno\n");
return;
}
HandleCurrentReply(pb, ce);
return;
}
case RPC2_INIT1OPENKIMONO:
case RPC2_INIT1AUTHONLY:
case RPC2_INIT1HEADERSONLY:
case RPC2_INIT1SECURE: {
/* INIT1 on an established connection is invalid */
NAKIT(pb);
return;
}
case RPC2_INIT2: {
if (TestState(ce, CLIENT, C_AWAITINIT2)) {
HandleInit2(pb, ce);
return;
}
/* anything else */
BOGUS(pb, "DecodePacket(RPC2_INIT2): state != AWAIT\n");
return;
}
case RPC2_INIT3: {
if (!TestRole(ce, SERVER)) {
NAKIT(pb);
return;
}
HandleInit3(pb, ce); /* This could be a retry */
return;
}
case RPC2_INIT4: {
if (TestState(ce, CLIENT, C_AWAITINIT4)) {
HandleInit4(pb, ce);
return;
}
BOGUS(pb, "DecodePacket(RPC2_INIT4): state != AWAIT\n");
return;
}
case RPC2_INITMULTICAST: {
if (TestState(ce, SERVER, S_AWAITENABLE)) {
say(1, RPC2_DebugLevel, "Connection not enabled\n");
// BOGUS(pb, "DecodePacket(INITMC): connection not enabled\n");
SendBusy(ce, TRUE);
return;
}
if (TestState(ce, SERVER, S_AWAITREQUEST) &&
ce->NextSeqNumber == pb->Header.SeqNumber) {
HandleInitMulticast(pb, ce);
return;
}
if (TestState(ce, SERVER, S_AWAITREQUEST) &&
ce->NextSeqNumber == pb->Header.SeqNumber + 2) {
HandleOldRequest(pb, ce);
return;
}
/* We can't have the "HandleCurrentRequest()" case because we don't
yield control while processing an InitMulticast request. Retries
are thus always seen as "old requests."
We don't special case the MultiRPC "packets ahead of sequence"
situation because InitMulticast requests cannot be multicasted.
*/
/* Anything else */
BOGUS(pb, "DecodePacket(INITMC): anything else\n");
return;
}
/* cannot be any negative opcode XXXXXXXXXXXXXXXX */
default: {
if (TestState(ce, SERVER, S_AWAITENABLE)) {
say(1, RPC2_DebugLevel, "Connection not enabled\n");
// BOGUS(pb, "DecodePacket: connection not enabled\n");
SendBusy(ce, TRUE);
return;
}
if (TestState(ce, SERVER, S_AWAITREQUEST) &&
ce->NextSeqNumber == pb->Header.SeqNumber) {
HandleNewRequest(pb, ce);
return;
}
if (TestState(ce, SERVER, S_AWAITREQUEST) &&
ce->NextSeqNumber == pb->Header.SeqNumber + 2) {
HandleOldRequest(pb, ce);
return;
}
if (TestState(ce, SERVER, (S_PROCESS | S_INSE | S_REQINQUEUE)) &&
ce->NextSeqNumber == pb->Header.SeqNumber + 2) {
HandleCurrentRequest(pb, ce);
return;
}
/* fix for MultiRPC; nak request packets ahead of sequence */
if ((pb->Header.SeqNumber > ce->NextSeqNumber + 2) &&
(pb->Header.SeqNumber & 1) == 0) {
NAKIT(pb);
return;
}
/* Anything else */
BOGUS(pb, "DecodePacket: anything else\n");
return;
}
}
}
/* StripHistoryInfo
*
* Contains instance data for the archive service.
*/
typedef struct _StripHistoryInfo
{
Strip strip;
}
StripHistoryInfo;
static StripHistoryInfo shi;
/* StripHistory_init
*/
StripHistory StripHistory_init (Strip BOGUS(1))
{
return (StripHistory)&shi;
}
/* StripHistory_delete
*/
void StripHistory_delete (StripHistory BOGUS(1))
{
}
/* StripHistory_fetch
*/
FetchStatus StripHistory_fetch (StripHistory BOGUS(1),
