/* BLURB lgpl Coda File System Release 5 Copyright (c) 1987-1999 Carnegie Mellon University Additional copyrights listed below This code is distributed "AS IS" without warranty of any kind under the terms of the GNU Library General Public Licence Version 2, as shown in the file LICENSE. The technical and financial contributors to Coda are listed in the file CREDITS. Additional copyrights #*/ /* IBM COPYRIGHT NOTICE Copyright (C) 1986 International Business Machines Corporation All Rights Reserved This file contains some code identical to or derived from the 1986 version of the Andrew File System ("AFS"), which is owned by the IBM Corporation. This code is provided "AS IS" and IBM does not warrant that it is free of infringement of any intellectual rights of any third party. IBM disclaims liability of any kind for any damages whatsoever resulting directly or indirectly from use of this software or of any derivative work. Carnegie Mellon University has obtained permission to modify, distribute and sublicense this code, which is based on Version 2 of AFS and does not contain the features and enhancements that are part of Version 3 of AFS. Version 3 of AFS is commercially available and supported by Transarc Corporation, Pittsburgh, PA. */ #ifndef _RPC2_PRIVATE_H_ #define _RPC2_PRIVATE_H_ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include #include #include #include #ifndef HAVE_STRUCT_SOCKADDR_STORAGE /* this should be large enough to fit 'any' socket address. */ struct sockaddr_storage { struct sockaddr __ss_sa; char _ss_padding[128 - sizeof(struct sockaddr)]; }; #endif #ifndef HAVE_STRUCT_SOCKADDR_IN6 struct in6_addr { u_int8_t u6_addr[16]; }; struct sockaddr_in6 { u_int16_t sin6_family; u_int16_t sin6_port; u_int32_t sin6_flowinfo; struct in6_addr sin6_addr; }; #endif #ifndef HAVE_SOCKLEN_T #define socklen_t unsigned int #endif /* Magic Number assignments for runtime system objects. Truly random values to allow easy detection of storage corruption. OBJ_PACKETBUFFER = 3247517 OBJ_CENTRY = 868 OBJ_MENTRY = 69743 OBJ_SLENTRY = 107 OBJ_SSENTRY = 34079 OBJ_HENTRY = 48127 */ /* Role and state determination: Top 2 bytes (0x0088 or 0x0044) determine client or server Bottom 2 bytes determine state within client or server. This allows rapid testing using bit masks. */ /* Server or Client? */ #define FREE 0x0 #define CLIENT 0x00880000 #define SERVER 0x00440000 /* Client States */ #define C_THINK 0x1 #define C_AWAITREPLY 0x2 #define C_HARDERROR 0x4 #define C_AWAITINIT2 0x8 #define C_AWAITINIT4 0x10 /* Server States */ #define S_AWAITREQUEST 0x1 #define S_REQINQUEUE 0x2 #define S_PROCESS 0x4 #define S_INSE 0x8 #define S_HARDERROR 0x10 #define S_STARTBIND 0x20 #define S_AWAITINIT3 0x40 #define S_FINISHBIND 0x80 #define S_AWAITENABLE 0x0100 #define SetRole(e, role) (e->State = role) #define SetState(e, new) (e->State = (e->State & 0xffff0000) | (new)) #define TestRole(e, role) ((e->State & 0xffff0000) == role) #define TestState(e, role, smask)\ (TestRole(e, role) && ((e->State & 0x0000ffff) & (smask))) #ifndef O_BINARY #define O_BINARY 0 #endif /* MAXRTO is used to avoid unbounded timeouts */ #define RPC2_MAXRTO 30000000 /* max rto (rtt + variance) is 30 seconds */ #define RPC2_DELACK_DELAY 100000 /* delay for server to send an ack that it received a request. This provides an upper bound on server response time. */ /* Definitions for Flags field of connections */ #define CE_OLDV 0x1 /* old version detected during bind */ /*---------------- Data Structures ----------------*/ struct LinkEntry /* form of entries in doubly-linked lists */ { struct LinkEntry *NextEntry; /* in accordance with insque(3) */ struct LinkEntry *PrevEntry; long MagicNumber; /* unique for object type; NEVER altered */ struct LinkEntry **Qname; /* head pointer of queue on which this element should be */ /* body comes here, but is irrelevant for list manipulation and object validation */ }; struct CEntry /* describes a single RPC connection */ { /* Link Entry Fields */ struct dllist_head connlist; enum {OBJ_CENTRY = 868, OBJ_FREE_CENTRY = 686} MagicNumber; struct CEntry *Qname; struct dllist_head Chain; /* State, identity and sequencing */ long State; RPC2_Handle UniqueCID; RPC2_Unsigned NextSeqNumber; RPC2_Integer SubsysId; RPC2_Integer Flags; /* CE_OLDV ? */ time_t LastRef; /* when CEntry was last looked up */ /* Security */ RPC2_Integer SecurityLevel; RPC2_EncryptionKey SessionKey; RPC2_Integer EncryptionType; /* PeerInfo */ RPC2_Handle PeerHandle; /* peer's connection ID */ RPC2_Integer PeerUnique; /* Unique integer used in Init1 bind request from peer */ struct HEntry *HostInfo; /* Link to host table and liveness information */ /* Auxiliary stuff */ struct SE_Definition *SEProcs; /* pointer to side effect routines */ long sebroken; /* flag set on hard se errors */ struct MEntry *Mgrp; /* Multicast group of this conn */ char *PrivatePtr; /* rock for pointer to user data */ char *SideEffectPtr; /* rock for per-connection side-effect data */ RPC2_Integer Color; /* Packets sent out get this color. See documentation for libfail(3). Only lowest byte is useful. */ /* Stuff for SocketListener */ struct SL_Entry *MySl; /* SL entry pertaining to this conn, or NULL */ RPC2_PacketBuffer *HeldPacket; /* NULL or pointer to packet held in readiness for retransmission (reply or last packet of Bind handshake */ unsigned long reqsize; /* size of request, for RTT calcs */ unsigned int TimeStampEcho; unsigned int RequestTime; struct timeval KeepAlive; /* Retry parameter for this connection. */ struct timeval SaveResponse; /* 2*KeepAlive, lifetime of saved response packet. */ RPC2_RequestFilter Filter; /* Set on the server during binding, filter incoming requests so that the SubsysID/Connection matches that of the handler we authenticated with */ struct security_association sa; }; struct MEntry /* describes an RPC multicast connection */ { /* Link Entry Pointers */ struct MEntry *Next; struct MEntry *Prev; enum {OBJ_MENTRY = 69743} MagicNumber; struct MEntry *Qname; /* Multicast Group Connection info */ RPC2_Integer State; /* eg {C,S}_AWAITREQUEST */ struct RPC2_addrinfo *ClientAddr; /* | */ RPC2_Handle MgroupID; /* | */ RPC2_Integer NextSeqNumber; /* for mgrp connection */ /* Auxiliary stuff */ struct SE_Definition *SEProcs; /* pointer to side effect routines */ char *SideEffectPtr; /* rock for per-mgrp side-effect data */ /* Connection entries associated with this Mgrp. Clients have an array of these, servers only one. */ union { struct { struct CEntry **mec_listeners; long mec_howmanylisteners; long mec_maxlisteners; } me_client; struct CEntry *mes_conn; } me_conns; #define listeners me_conns.me_client.mec_listeners #define howmanylisteners me_conns.me_client.mec_howmanylisteners #define maxlisteners me_conns.me_client.mec_maxlisteners #define conn me_conns.mes_conn }; /* SL entries are the data structures used for comm between user LWPs and the SocketListener. The user LWP creates an entry, sets it up, sets a timeout on it and goes to sleep. SocketListener eventually sets a return code on the entry and wakes up the LWP. SL Entries are typed: REPLY associated with a specific connection created by user LWP in SendResponse creating LWP does not wait for timeout to expire destroyed by SocketListener REQ not associated with a specific connection created and destroyed by user LWP in GetRequest DELACK delayed ack response to receiving a request created by SocketListener in HandleRequest destroyed by SocketListener on timeout destroyed by user LWP when reply is sent. DELAYED_SEND Artificially introduced a transmission delay DELAYED_RECV Artificially introduced a reception delay OTHER associated with a specific connection created and destroyed by user LWP Entries of type REQ are on a separate list to minimize list searching in SocketListener. Other types of entries can be directly accessed via the connection they are associated with. */ /* NOTE: enum definitions have to be non-anonymous: else a dbx bug is triggered */ enum SL_Type {REPLY=1421, REQ=1422, OTHER=1423, DELACK=20010911, DELAYED_SEND=20061016, DELAYED_RECV=20061017}; enum RetVal {WAITING=38358230, ARRIVED=38358231, TIMEOUT=38358232, KEPTALIVE=38358233, KILLED=38358234, NAKED=38358235}; /* data structure for communication with SocketListener */ struct SL_Entry { /* LinkEntry fields */ struct SL_Entry *NextEntry; struct SL_Entry *PrevEntry; enum {OBJ_SLENTRY = 107} MagicNumber; struct SL_Entry *Qname; enum SL_Type Type; /* Timeout-related fields */ struct TM_Elem TElem; /* element to be inserted into timer chain; The BackPointer field of TElem will point to this SL_Entry */ enum RetVal ReturnCode; /* SocketListener changes this from WAITING */ /* Other fields */ RPC2_Handle Conn; /* NULL or conn corr to this SL Entry */ void *data; /* NULL, packet buffer, or delayed xmit data */ RPC2_RequestFilter Filter; /* useful only in GetRequest */ int RetryIndex; /* useful only in MakeRPC */ struct timeval RInterval; /* current retry timeout */ }; struct SubsysEntry /* Defines a subsystem being actively serviced by a server */ { /* Created by RPC2_InitSubsys(); destroyed by RPC2_EndSubsys() */ struct SubsysEntry *Next; /* LinkEntry field */ struct SubsysEntry *Prev; /* LinkEntry field */ enum {OBJ_SSENTRY = 34079} MagicNumber; struct SubsysEntry *Qname; /* LinkEntry field */ long Id; /* using a struct is a little excessive, but it makes things uniform */ }; /* extend with other side effect types */ typedef enum {UNSET_HE = 0, RPC2_HE = 1, SMARTFTP_HE = 2} HEType; struct HEntry { /* Link Entry Pointers */ struct HEntry *Next; /* LinkEntry field */ struct HEntry *Prev; /* LinkEntry field */ enum {OBJ_HENTRY = 48127} MagicNumber; struct HEntry *Qname; /* LinkEntry field */ struct HEntry *HLink; /* for host hash */ int RefCount; /* # connections that have a reference */ struct RPC2_addrinfo *Addr; /* network address */ struct timeval LastWord; /* Most recent time we've heard from this host*/ unsigned RPC2_NumEntries; /* number of observations recorded */ RPC2_NetLogEntry RPC2_Log[RPC2_MAXLOGLENGTH]; /* circular buffer for recent observations on * round trip times and packet sizes */ unsigned SE_NumEntries; /* number of sideeffect observations recorded */ RPC2_NetLogEntry SE_Log[RPC2_MAXLOGLENGTH]; /* the RTT is shifted analogous to Jacobson's article in SIGCOMM'88 */ #define RPC2_RTT_SHIFT 3 /* Bits to right of binary point of RTT */ #define RPC2_RTTVAR_SHIFT 2 /* Bits to right of binary point of RTTvar */ unsigned long RTT; /* RTT (us<Header.Flags = htonl(p->Header.Flags)) #define ntohPktColor(p) (p->Header.Flags = ntohl(p->Header.Flags)) #define SetPktColor(p,c)\ (p->Header.Flags = (p->Header.Flags & 0xff00ffff) | ((c & 0xff) << 16)) #define GetPktColor(p) ((p->Header.Flags >> 16) & 0x000000ff) /*------------- List headers and counts -------------*/ /* NOTE: all these lists are doubly-linked and circular */ /* The multicast group abstraction */ extern struct MEntry *rpc2_MgrpFreeList; /* free mgrp blocks */ extern long rpc2_MgrpFreeCount, rpc2_MgrpCreationCount; /* Items for SocketListener */ extern struct SL_Entry *rpc2_SLFreeList, /* free entries */ *rpc2_SLReqList, /* in use, of type REQ */ *rpc2_SLList; /* in use, of types REPLY or OTHER */ extern long rpc2_SLReqCount, rpc2_SLCount; /* Packet buffers */ extern RPC2_PacketBuffer *rpc2_PBList, *rpc2_PBHoldList; extern RPC2_PacketBuffer *rpc2_PBSmallFreeList, *rpc2_PBMediumFreeList, *rpc2_PBLargeFreeList; /* Subsystem definitions */ extern struct SubsysEntry *rpc2_SSFreeList, /* free entries */ *rpc2_SSList; /* subsystems in active use */ /* Host info definitions */ extern struct HEntry *rpc2_HostFreeList, *rpc2_HostList; extern long rpc2_HostFreeCount, rpc2_HostCount, rpc2_HostCreationCount; /*------------- Miscellaneous global data ------------*/ extern int rpc2_ipv6ready; /* can userspace handle IPv6 addresses */ extern int rpc2_v4RequestSocket; /* fd of RPC socket */ extern int rpc2_v6RequestSocket; /* fd of RPC socket */ /* we may need more when we deal with many domains */ extern struct TM_Elem *rpc2_TimerQueue; extern struct CBUF_Header *rpc2_TraceBuffHeader; extern PROCESS rpc2_SocketListenerPID; /* used in IOMGR_Cancel() calls */ extern unsigned long rpc2_LamportClock; extern long Retry_N; extern struct timeval KeepAlive; /* List manipulation routines */ void rpc2_Replenish(); struct LinkEntry *rpc2_MoveEntry(); struct SL_Entry *rpc2_AllocSle(); void rpc2_FreeSle(struct SL_Entry **sl); void rpc2_ActivateSle(), rpc2_DeactivateSle(); struct SubsysEntry *rpc2_AllocSubsys(); void rpc2_FreeSubsys(); void FreeHeld(struct SL_Entry *sle); /* Socket creation */ long rpc2_CreateIPSocket(int af, int *svar, struct RPC2_addrinfo *addr, short *Port); /* Packet routines */ long rpc2_SendReliably(), rpc2_MSendPacketsReliably(); void rpc2_XmitPacket(RPC2_PacketBuffer *pb, struct RPC2_addrinfo *addr, int confirm); void rpc2_InitPacket(); int rpc2_MorePackets(void); long rpc2_RecvPacket(long whichSocket, RPC2_PacketBuffer *whichBuff); void rpc2_htonp(RPC2_PacketBuffer *p); void rpc2_ntohp(RPC2_PacketBuffer *p); long rpc2_CancelRetry(struct CEntry *Conn, struct SL_Entry *Sle); void rpc2_UpdateRTT(RPC2_PacketBuffer *pb, struct CEntry *ceaddr); void rpc2_ExpireEvents(); /* Connection manipulation routines */ int rpc2_InitConn(void); void rpc2_FreeConn(), rpc2_SetConnError(); struct CEntry *rpc2_AllocConn(); struct CEntry *rpc2_ConnFromBindInfo(struct RPC2_addrinfo *peeraddr, RPC2_Handle RemoteHandle, RPC2_Integer whichUnique); struct CEntry *__rpc2_GetConn(RPC2_Handle handle); /* doesn't bump lastref */ struct CEntry *rpc2_GetConn(RPC2_Handle handle); void rpc2_ReapDeadConns(void); void rpc2_IncrementSeqNumber(struct CEntry *); /* Host manipulation routines */ void rpc2_InitHost(void); struct HEntry *rpc2_GetHost(struct RPC2_addrinfo *addr); void rpc2_FreeHost(struct HEntry **whichHost); void rpc2_GetHostLog(struct HEntry *whichHost, RPC2_NetLog *log, NetLogEntryType type); int rpc2_AppendHostLog(struct HEntry *whichHost, RPC2_NetLogEntry *entry, NetLogEntryType type); void rpc2_ClearHostLog(struct HEntry *whichHost, NetLogEntryType type); void RPC2_UpdateEstimates(struct HEntry *whichHost, RPC2_Unsigned ElapsedTime, RPC2_Unsigned InBytes, RPC2_Unsigned OutBytes); int rpc2_RetryInterval(struct CEntry *ce, int retry, struct timeval *tv, RPC2_Unsigned OutBytes, RPC2_Unsigned InBytes); /* Multicast group manipulation routines */ void rpc2_InitMgrp(), rpc2_FreeMgrp(), rpc2_RemoveFromMgrp(), rpc2_DeleteMgrp(); struct MEntry *rpc2_AllocMgrp(struct RPC2_addrinfo *addr, RPC2_Handle handle); struct MEntry *rpc2_GetMgrp(struct RPC2_addrinfo *addr, RPC2_Handle handle, long role); /* Hold queue routines */ void rpc2_HoldPacket(), rpc2_UnholdPacket(); /* RPC2_GetRequest() filter matching function */ int rpc2_FilterMatch(); /* Autonomous LWPs */ void rpc2_SocketListener(void *); void rpc2_ClockTick(void *); /* rpc2_SocketListener packet handlers */ void SL_RegisterHandler(unsigned int proto, void (*func)(RPC2_PacketBuffer *)); void rpc2_HandlePacket(RPC2_PacketBuffer *pb); /* Packet timestamp creation */ unsigned int rpc2_TVTOTS(const struct timeval *tv); void rpc2_TSTOTV(const unsigned int ts, struct timeval *tv); unsigned int rpc2_MakeTimeStamp(); /* Debugging routines */ void rpc2_PrintTMElem(), rpc2_PrintFilter(), rpc2_PrintSLEntry(), rpc2_PrintCEntry(), rpc2_PrintTraceElem(), rpc2_PrintPacketHeader(), rpc2_PrintHostIdent(), rpc2_PrintPortIdent(), rpc2_PrintSEDesc(); extern FILE *ErrorLogFile; /* encryption */ struct security_association *rpc2_GetSA(uint32_t spi); void rpc2_ApplyD(RPC2_PacketBuffer *pb, struct CEntry *ce); void rpc2_ApplyE(RPC2_PacketBuffer *pb, struct CEntry *ce); time_t rpc2_time(); long rpc2_InitRetry(long HowManyRetries, struct timeval *Beta0); void rpc2_NoteBinding(struct RPC2_addrinfo *peeraddr, RPC2_Handle RemoteHandle, RPC2_Integer whichUnique, RPC2_Handle whichConn); int mkcall(RPC2_HandleResult_func *ClientHandler, int ArgCount, int HowMany, RPC2_Handle ConnList[], long offset, long rpcval, int *args); /*----------- Macros ---------- */ /* Test if more than one bit is set; WARNING: make sure at least one bit is set first! */ #define MORETHANONEBITSET(x) (x != (1 << (ffs((long)x)-1))) /* Macros to work with preemption package */ /* #define rpc2_Enter() (PRE_BeginCritical()) */ #define rpc2_Enter() do { } while (0) /*#define rpc2_Quit(rc) return(PRE_EndCritical(), (long)rc) */ #define rpc2_Quit(rc) return((long)rc) /* Macros to check if host and portal ident structures are equal */ /* The lengths of the names really should be #defined. */ #define rpc2_HostIdentEqual(_hi1p_,_hi2p_) \ (((_hi1p_)->Tag == RPC2_HOSTBYINETADDR && (_hi2p_)->Tag == RPC2_HOSTBYINETADDR)? \ ((_hi1p_)->Value.AddrInfo->ai_family == (_hi2p_)->Value.AddrInfo->ai_family && \ (_hi1p_)->Value.AddrInfo->ai_addrlen == (_hi2p_)->Value.AddrInfo->ai_addrlen && !memcmp((_hi1p_)->Value.AddrInfo->ai_addr,(_hi2p_)->Value.AddrInfo->ai_addr,(_hi2p_)->Value.AddrInfo->ai_addrlen)): \ (((_hi1p_)->Tag == RPC2_HOSTBYNAME && (_hi2p_)->Tag == RPC2_HOSTBYNAME)? \ (strncmp((_hi1p_)->Value.Name, (_hi2p_)->Value.Name, 64) == 0):0)) /*------ Other definitions ------*/ /* Allocation constants */ #define SMALLPACKET 350 #define MEDIUMPACKET 1500 #define LARGEPACKET RPC2_MAXPACKETSIZE /* Packets sent */ extern unsigned long rpc2_NoNaks; extern long rpc2_BindLimit, rpc2_BindsInQueue; extern long rpc2_FreeMgrps, rpc2_AllocMgrps; /* RPC2_addrinfo helper routines */ struct RPC2_addrinfo *rpc2_resolve(RPC2_HostIdent *Host, RPC2_PortIdent *Port); void rpc2_printaddrinfo(const struct RPC2_addrinfo *ai, FILE *f); void rpc2_splitaddrinfo(RPC2_HostIdent *Host, RPC2_PortIdent *Port, const struct RPC2_addrinfo *ai); void rpc2_simplifyHost(RPC2_HostIdent *Host, RPC2_PortIdent *Port); /*--------------- Useful definitions that used to be in potpourri.h or util.h ---------------*/ /* Now included here to avoid including either of those files */ /* Parameter usage */ #define IN /* Input parameter */ #define OUT /* Output parameter */ #define INOUT /* Obvious */ /* Conditional debugging output macros: no side effect in these! */ char *rpc2_timestring(); #ifdef RPC2DEBUG #define say(when, what, how...)\ do { \ if (when < what){fprintf(rpc2_logfile, "[%s]%s: \"%s\", line %d: ",\ rpc2_timestring(), LWP_Name(), __FILE__, __LINE__);\ fprintf(rpc2_logfile, ## how);(void) fflush(rpc2_logfile);}\ } while(0); #else #define say(when, what, how) #endif #ifndef TRUE #define TRUE 1 #define FALSE 0 #endif /*--------- End stuff from util.h ------------*/ /* macro to subtract one timeval from another */ #define SUBTIME(fromp, subp)\ do {\ if ((subp)->tv_usec > (fromp)->tv_usec) \ { (fromp)->tv_sec--; (fromp)->tv_usec += 1000000; }\ (fromp)->tv_sec -= (subp)->tv_sec;\ (fromp)->tv_usec -= (subp)->tv_usec;\ } while(0); /* add one timeval to another */ #define ADDTIME(top, fromp)\ do {\ (top)->tv_sec += (fromp)->tv_sec;\ (top)->tv_usec += (fromp)->tv_usec;\ if ((top)->tv_usec >= 1000000)\ { (top)->tv_sec++; (top)->tv_usec -= 1000000; }\ } while(0); #define CMPTIME(a, b, CMP)\ (((a)->tv_sec == (b)->tv_sec) ?\ ((a)->tv_usec CMP (b)->tv_usec) :\ ((a)->tv_sec CMP (b)->tv_sec)) #define CLRTIME(tm) ((tm)->tv_sec = 0, (tm)->tv_usec = 0) #define TIMERISSET(tm) ((tm)->tv_sec || (tm)->tv_usec) /* macros to convert between timeval and timestamp */ #define TVTOTS(_tvp_, _ts_)\ do {\ _ts_ = ((_tvp_)->tv_sec * 1000000 + (_tvp_)->tv_usec);\ } while(0); #define TSTOTV(_tvp_, _ts_)\ do {\ (_tvp_)->tv_sec = (_ts_) / 1000000;\ (_tvp_)->tv_usec = (_ts_) % 1000000;\ } while(0); #define TSDELTA(_ts1_, _ts2_) ((int)(_ts1_) - (int)(_ts2_)) #ifdef USE_LUA /* lua.c - include Lua interpreter for roundtrip time estimators */ void LUA_init(void); void LUA_clocktick(void); void LUA_drop_hosttable(struct HEntry *he); void LUA_rtt_update(struct HEntry *he, uint32_t rtt, uint32_t tx, uint32_t rx); int LUA_rtt_getrto(struct HEntry *he, uint32_t tx, uint32_t rx); int LUA_rtt_getbandwidth(struct HEntry *he, uint32_t *bw_tx, uint32_t *bw_rx); /* not sure if we want to allow the estimator to control number of retries * and/or overall timeout, so I might not actually use this function... */ int LUA_rtt_retryinterval(struct HEntry *he, uint32_t n, uint32_t tx, uint32_t rx); int LUA_fail_delay(struct RPC2_addrinfo *addr, RPC2_PacketBuffer *pb, int out, struct timeval *tv); #else /* do not include Lua interpreter, define empty stubs */ #define LUA_init() #define LUA_clocktick() #define LUA_drop_hosttable(a) #define LUA_rtt_update(a,b,c,d) #define LUA_rtt_getrto(a,b,c) 0 #define LUA_rtt_getbandwidth(a,b,c) 0 #define LUA_rtt_retryinterval(a,b,c,d) 0 #define LUA_fail_delay(a,b,c,d) 0 #endif int rpc2_DelayedSend(int s, struct RPC2_addrinfo *addr, RPC2_PacketBuffer *pb, struct timeval *delay); int rpc2_DelayedRecv(RPC2_PacketBuffer *pb, struct timeval *delay); void rpc2_SendDelayedPacket(struct SL_Entry *sl); RPC2_PacketBuffer *rpc2_RecvDelayedPacket(struct SL_Entry *sl); #endif /* _RPC2_PRIVATE_H_ */