src/rx/rx_prototypes.h

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #ifndef _RX_PROTOTYPES_H
  11 #define _RX_PROTOTYPES_H
  12
  13 /* rx.c */
  14 extern void rx_SetEpoch(afs_uint32 epoch);
  15 extern int rx_Init(u_int port);
  16 extern int rx_InitHost(u_int host, u_int port);
  17 extern int rx_InitAddrs(struct sockaddr_storage *saddrs, int *types,
  18                         int *salens, int nelem);
  19 #ifdef AFS_NT40_ENV
  20 extern void rx_DebugOnOff(int on);
  21 #endif
  22 #ifndef KERNEL
  23 extern void rxi_StartServerProcs(int nExistingProcs);
  24 #endif
  25 extern void rx_StartServer(int donateMe);
  26 extern struct rx_connection *rx_NewConnection(register afs_uint32 shost,
  27                                               u_short sport, u_short sservice,
  28                                               register struct rx_securityClass
  29                                               *securityObject,
  30                                               int serviceSecurityIndex);
  31 extern struct rx_connection *rx_NewConnectionAddrs(struct sockaddr_storage *,
  32                                                    int *types, int *salens,
  33                                                    int nelem, u_short,
  34                                                    struct rx_securityClass *,
  35                                                    int);
  36 extern void rx_SetConnDeadTime(register struct rx_connection *conn,
  37                                register int seconds);
  38 extern void rxi_CleanupConnection(struct rx_connection *conn);
  39 extern void rxi_DestroyConnection(register struct rx_connection *conn);
  40 extern void rx_GetConnection(register struct rx_connection *conn);
  41 extern void rx_DestroyConnection(register struct rx_connection *conn);
  42 extern struct rx_call *rx_NewCall(register struct rx_connection *conn);
  43 extern int rxi_HasActiveCalls(register struct rx_connection *aconn);
  44 extern int rxi_GetCallNumberVector(register struct rx_connection *aconn,
  45                                    register afs_int32 * aint32s);
  46 extern int rxi_SetCallNumberVector(register struct rx_connection *aconn,
  47                                    register afs_int32 * aint32s);
  48 extern struct rx_service *rx_NewService(u_short port, u_short serviceId,
  49                                         char *serviceName,
  50                                         struct rx_securityClass
  51                                         **securityObjects,
  52                                         int nSecurityObjects,
  53                                         afs_int32(*serviceProc) (struct
  54                                                                  rx_call *
  55                                                                  acall));
  56 extern struct rx_service *rx_NewServiceHost(afs_uint32 host, u_short port,
  57                                             u_short serviceId,
  58                                             char *serviceName,
  59                                             struct rx_securityClass
  60                                             **securityObjects,
  61                                             int nSecurityObjects,
  62                                             afs_int32(*serviceProc) (struct
  63                                                                      rx_call *
  64                                                                      acall));
  65 extern void rxi_ServerProc(int threadID, struct rx_call *newcall,
  66                            osi_socket * socketp);
  67 extern void rx_WakeupServerProcs(void);
  68 extern struct rx_call *rx_GetCall(int tno, struct rx_service *cur_service,
  69                                   osi_socket * socketp);
  70 extern void rx_SetArrivalProc(register struct rx_call *call,
  71                               register void (*proc) (register struct rx_call *
  72                                                     call,
  73                                                     register VOID * mh,
  74                                                     register int index),
  75                               register VOID * handle, register int arg);
  76 extern afs_int32 rx_EndCall(register struct rx_call *call, afs_int32 rc);
  77 extern void rx_Finalize(void);
  78 extern void rxi_PacketsUnWait(void);
  79 extern struct rx_service *rxi_FindService(register osi_socket socket,
  80                                           register u_short serviceId);
  81 extern struct rx_call *rxi_NewCall(register struct rx_connection *conn,
  82                                    register int channel);
  83
  84 /* Don't like this - change source at some point to make calls identical */
  85 #ifdef RX_ENABLE_LOCKS
  86 extern void rxi_FreeCall(register struct rx_call *call, int haveCTLock);
  87 #else /* RX_ENABLE_LOCKS */
  88 extern void rxi_FreeCall(register struct rx_call *call);
  89 #endif /* RX_ENABLE_LOCKS */
  90
  91 extern char *rxi_Alloc(register size_t size);
  92 extern void rxi_Free(void *addr, register size_t size);
  93 extern struct rx_peer *rxi_FindPeer(struct sockaddr_storage *saddr, int slen,
  94                                     int stype, struct rx_peer *origPeer,
  95                                     int create);
  96 extern struct rx_connection *rxi_FindConnection(osi_socket socket,
  97                                                 struct sockaddr_storage *saddr,
  98                                                 int slen, int socktype,
  99                                                 u_short serviceId,
 100                                                 afs_uint32 cid,
 101                                                 afs_uint32 epoch, int type,
 102                                                 u_int securityIndex);
 103 extern struct rx_packet *rxi_ReceivePacket(register struct rx_packet *np,
 104                                            osi_socket socket,
 105                                            struct sockaddr_storage *saddr,
 106                                            int slen, int *tnop,
 107                                            struct rx_call **newcallp);
 108 extern int rxi_IsConnInteresting(struct rx_connection *aconn);
 109 extern struct rx_packet *rxi_ReceiveDataPacket(register struct rx_call *call,
 110                                                register struct rx_packet *np,
 111                                                int istack, osi_socket socket,
 112                                                struct sockaddr_storage *saddr,
 113                                                int slen, int *tnop,
 114                                                struct rx_call **newcallp);
 115 extern struct rx_packet *rxi_ReceiveAckPacket(register struct rx_call *call,
 116                                               struct rx_packet *np,
 117                                               int istack);
 118 extern struct rx_packet *rxi_ReceiveResponsePacket(register struct
 119                                                    rx_connection *conn, register struct rx_packet
 120                                                    *np, int istack);
 121 extern struct rx_packet *rxi_ReceiveChallengePacket(register struct
 122                                                     rx_connection *conn, register struct rx_packet
 123                                                     *np, int istack);
 124 extern void rxi_AttachServerProc(register struct rx_call *call,
 125                                  register osi_socket socket,
 126                                  register int *tnop,
 127                                  register struct rx_call **newcallp);
 128 extern void rxi_AckAll(struct rxevent *event, register struct rx_call *call,
 129                        char *dummy);
 130 extern void rxi_SendDelayedAck(struct rxevent *event,
 131                                register struct rx_call *call, char *dummy);
 132 extern void rxi_ClearTransmitQueue(register struct rx_call *call,
 133                                    register int force);
 134 extern void rxi_ClearReceiveQueue(register struct rx_call *call);
 135 extern struct rx_packet *rxi_SendCallAbort(register struct rx_call *call,
 136                                            struct rx_packet *packet,
 137                                            int istack, int force);
 138 extern struct rx_packet *rxi_SendConnectionAbort(register struct rx_connection
 139                                                  *conn,
 140                                                  struct rx_packet *packet,
 141                                                  int istack, int force);
 142 extern void rxi_ConnectionError(register struct rx_connection *conn,
 143                                 register afs_int32 error);
 144 extern void rxi_CallError(register struct rx_call *call, afs_int32 error);
 145 extern void rxi_ResetCall(register struct rx_call *call,
 146                           register int newcall);
 147 extern struct rx_packet *rxi_SendAck(register struct rx_call *call, register struct rx_packet
 148                                      *optionalPacket, int serial, int reason,
 149                                      int istack);
 150 extern void rxi_StartUnlocked(struct rxevent *event,
 151                               register struct rx_call *call,
 152                               void *arg1, int istack);
 153 extern void rxi_Start(struct rxevent *event, register struct rx_call *call,
 154                       void *arg1, int istack);
 155 extern void rxi_Send(register struct rx_call *call,
 156                      register struct rx_packet *p, int istack);
 157 #ifdef RX_ENABLE_LOCKS
 158 extern int rxi_CheckCall(register struct rx_call *call, int haveCTLock);
 159 #else /* RX_ENABLE_LOCKS */
 160 extern int rxi_CheckCall(register struct rx_call *call);
 161 #endif /* RX_ENABLE_LOCKS */
 162 extern void rxi_KeepAliveEvent(struct rxevent *event,
 163                                register struct rx_call *call, char *dummy);
 164 extern void rxi_ScheduleKeepAliveEvent(register struct rx_call *call);
 165 extern void rxi_KeepAliveOn(register struct rx_call *call);
 166 extern void rxi_SendDelayedConnAbort(struct rxevent *event,
 167                                      register struct rx_connection *conn,
 168                                      char *dummy);
 169 extern void rxi_SendDelayedCallAbort(struct rxevent *event,
 170                                      register struct rx_call *call,
 171                                      char *dummy);
 172 extern void rxi_ChallengeEvent(struct rxevent *event,
 173                                register struct rx_connection *conn,
 174                                void *arg1, int atries);
 175 extern void rxi_ChallengeOn(register struct rx_connection *conn);
 176 extern void rxi_ComputeRoundTripTime(register struct rx_packet *p,
 177                                      register struct clock *sentp,
 178                                      register struct rx_peer *peer);
 179 extern void rxi_ReapConnections(void);
 180 extern int rxs_Release(struct rx_securityClass *aobj);
 181 #ifndef KERNEL
 182 extern void rx_PrintTheseStats(FILE * file, struct rx_stats *s, int size,
 183                                afs_int32 freePackets, char version);
 184 extern void rx_PrintStats(FILE * file);
 185 extern void rx_PrintPeerStats(FILE * file, struct rx_peer *peer);
 186 #endif
 187 extern afs_int32 rx_GetServerDebug(osi_socket socket, afs_uint32 remoteAddr,
 188                                    afs_uint16 remotePort,
 189                                    struct rx_debugStats *stat,
 190                                    afs_uint32 * supportedValues);
 191 extern afs_int32 rx_GetServerStats(osi_socket socket, afs_uint32 remoteAddr,
 192                                    afs_uint16 remotePort,
 193                                    struct rx_stats *stat,
 194                                    afs_uint32 * supportedValues);
 195 extern afs_int32 rx_GetServerVersion(osi_socket socket, afs_uint32 remoteAddr,
 196                                      afs_uint16 remotePort,
 197                                      size_t version_length, char *version);
 198 extern afs_int32 rx_GetServerConnections(osi_socket socket,
 199                                          afs_uint32 remoteAddr,
 200                                          afs_uint16 remotePort,
 201                                          afs_int32 * nextConnection,
 202                                          int allConnections,
 203                                          afs_uint32 debugSupportedValues,
 204                                          struct rx_debugConn *conn,
 205                                          afs_uint32 * supportedValues);
 206 extern afs_int32 rx_GetServerPeers(osi_socket socket, afs_uint32 remoteAddr,
 207                                    afs_uint16 remotePort,
 208                                    afs_int32 * nextPeer,
 209                                    afs_uint32 debugSupportedValues,
 210                                    struct rx_debugPeer *peer,
 211                                    afs_uint32 * supportedValues);
 212 extern void shutdown_rx(void);
 213 #ifndef osirx_AssertMine
 214 extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg);
 215 #endif
 216 #ifndef KERNEL
 217 extern int rx_KeyCreate(rx_destructor_t rtn);
 218 #endif
 219 extern void rx_SetSpecific(struct rx_connection *conn, int key, void *ptr);
 220 extern void *rx_GetSpecific(struct rx_connection *conn, int key);
 221 extern void rx_IncrementTimeAndCount(struct rx_peer *peer,
 222                                      afs_uint32 rxInterface,
 223                                      afs_uint32 currentFunc,
 224                                      afs_uint32 totalFunc,
 225                                      struct clock *queueTime,
 226                                      struct clock *execTime,
 227                                      afs_hyper_t * bytesSent,
 228                                      afs_hyper_t * bytesRcvd, int isServer);
 229 extern void rx_MarshallProcessRPCStats(afs_uint32 callerVersion, int count,
 230                                        rx_function_entry_v1_t * stats,
 231                                        afs_uint32 ** ptrP);
 232 extern int rx_RetrieveProcessRPCStats(afs_uint32 callerVersion,
 233                                       afs_uint32 * myVersion,
 234                                       afs_uint32 * clock_sec,
 235                                       afs_uint32 * clock_usec,
 236                                       size_t * allocSize,
 237                                       afs_uint32 * statCount,
 238                                       afs_uint32 ** stats);
 239 extern int rx_RetrievePeerRPCStats(afs_uint32 callerVersion,
 240                                    afs_uint32 * myVersion,
 241                                    afs_uint32 * clock_sec,
 242                                    afs_uint32 * clock_usec,
 243                                    size_t * allocSize, afs_uint32 * statCount,
 244                                    afs_uint32 ** stats);
 245 extern void rx_FreeRPCStats(afs_uint32 * stats, size_t allocSize);
 246 extern int rx_queryProcessRPCStats(void);
 247 extern int rx_queryPeerRPCStats(void);
 248 extern void rx_enableProcessRPCStats(void);
 249 extern void rx_enablePeerRPCStats(void);
 250 extern void rx_disableProcessRPCStats(void);
 251 extern void rx_disablePeerRPCStats(void);
 252 extern void rx_clearProcessRPCStats(afs_uint32 clearFlag);
 253 extern void rx_clearPeerRPCStats(afs_uint32 clearFlag);
 254 extern void rx_SetRxStatUserOk(int (*proc) (struct rx_call * call));
 255 extern int rx_RxStatUserOk(struct rx_call *call);
 256
 257
 258 /* old style till varargs */
 259 #if 0
 260 void
 261 rxi_DebugPrint(char *format, int a1, int a2, int a3, int a4, int a5, int a6,
 262                int a7, int a8, int a9, int a10, int a11, int a12, int a13,
 263                int a14, int a15);
 264 void
 265 rxi_DebugInit(void);
 266 #else
 267 void rxi_DebugInit();
 268 void rxi_DebugPrint();
 269 #endif
 270
 271 /* rx_clock.c */
 272 #if !defined(clock_Init)
 273 extern void clock_Init(void);
 274 #endif
 275 #if !defined(clock_UnInit)
 276 extern int clock_UnInit(void);
 277 #endif
 278 #if !defined(clock_UpdateTime)
 279 extern void clock_UpdateTime(void);
 280 #endif
 281
 282 /* rx_clock_nt.c */
 283
 284
 285 /* rx_conncache.c */
 286 extern void rxi_DeleteCachedConnections(void);
 287 extern struct rx_connection *rx_GetCachedConnection(unsigned int remoteAddr,
 288                                                     unsigned short port,
 289                                                     unsigned short service,
 290                                                     struct rx_securityClass
 291                                                     *securityObject,
 292                                                     int securityIndex);
 293 extern void rx_ReleaseCachedConnection(struct rx_connection *conn);
 294
 295
 296 /* rxdebug.c */
 297
 298
 299 /* rx_event.c */
 300 extern int rxevent_nFree;
 301 extern int rxevent_nPosted;
 302 #if 0
 303 extern struct rxevent *rxevent_Post(struct clock *when,
 304                                     void (*func) (struct rxevent * event,
 305                                                   struct rx_connection * conn,
 306                                                   struct rx_call * acall),
 307                                     void *arg, void *arg1);
 308 /* this func seems to be called with tons of different style routines, need to look
 309 at another time. */
 310 #else
 311 extern struct rxevent *rxevent_Post(struct clock *when, void (*func) (),
 312                                     void *arg, void *arg1);
 313 extern struct rxevent *rxevent_Post2(struct clock *when, void (*func) (),
 314                                     void *arg, void *arg1, int arg2);
 315 #endif
 316 extern void shutdown_rxevent(void);
 317 extern struct rxepoch *rxepoch_Allocate(struct clock *when);
 318 extern void rxevent_Init(int nEvents, void (*scheduler) (void));
 319 extern void rxevent_Cancel_1(register struct rxevent *ev,
 320                              register struct rx_call *call,
 321                              register int type);
 322 extern int rxevent_RaiseEvents(struct clock *next);
 323
 324
 325
 326
 327 /* rx_getaddr.c */
 328 extern void rxi_setaddr(afs_int32 x);
 329 extern afs_int32 rxi_getaddr(void);
 330
 331 /* rx_globals.c */
 332
 333
 334 /* rx_kcommon.c */
 335 struct socket;
 336 extern int (*rxk_PacketArrivalProc) (struct rx_packet * ahandle,
 337                                      struct sockaddr_in * afrom,
 338                                      struct socket *arock,
 339                                      afs_int32 asize);
 340 extern int (*rxk_GetPacketProc) (struct rx_packet **ahandle, int asize);
 341 extern afs_int32 afs_termState;
 342 extern int rxk_initDone;
 343
 344 extern int rxk_DelPort(u_short aport);
 345 extern void rxk_shutdownPorts(void);
 346 extern osi_socket rxi_GetUDPSocket(u_short port);
 347 extern osi_socket rxi_GetHostUDPSocket(struct sockaddr_storage *saddr,
 348                                        int salen);
 349 extern void osi_Panic();
 350 extern int osi_utoa(char *buf, size_t len, unsigned long val);
 351 extern void rxi_InitPeerParams(register struct rx_peer *pp);
 352 extern void shutdown_rxkernel(void);
 353 #ifdef AFS_USERSPACE_IP_ADDR
 354 extern int rxi_GetcbiInfo(void);
 355 extern afs_int32 rxi_Findcbi(afs_uint32 addr);
 356 #else
 357 extern int rxi_GetIFInfo(void);
 358 #endif
 359 #ifndef UKERNEL
 360 #if 0
 361 extern int rxk_FreeSocket(register struct socket *asocket);
 362 #endif
 363 #ifndef AFS_NT40_ENV
 364 extern osi_socket *rxk_NewSocket(short aport);
 365 #endif
 366 #endif
 367 extern int rxk_ReadPacket(osi_socket so, struct rx_packet *p,
 368                           struct sockaddr_storage *saddr, int *slen);
 369 #ifdef UKERNEL
 370 extern void rx_ServerProc(void);
 371 #endif
 372 extern void osi_AssertFailK(const char *expr, const char *file, int line);
 373 extern void rxk_ListenerProc(void);
 374 extern void rxk_Listener(void);
 375 #ifndef UKERNEL
 376 extern void afs_rxevent_daemon(void);
 377 #endif
 378 #if defined(AFS_DARWIN80_ENV) && defined(KERNEL)
 379 extern ifnet_t rxi_FindIfnet(afs_uint32 addr, afs_uint32 * maskp);
 380 #else
 381 extern struct ifnet *rxi_FindIfnet(afs_uint32 addr, afs_uint32 * maskp);
 382 #endif
 383 extern void osi_StopListener(void);
 384
 385
 386 /* ARCH/rx_kmutex.c */
 387 #if defined(KERNEL) && defined(AFS_LINUX20_ENV)
 388 extern void afs_mutex_init(afs_kmutex_t * l);
 389 extern void afs_mutex_enter(afs_kmutex_t * l);
 390 extern int afs_mutex_tryenter(afs_kmutex_t * l);
 391 extern void afs_mutex_exit(afs_kmutex_t * l);
 392 extern int afs_cv_wait(afs_kcondvar_t * cv, afs_kmutex_t * l, int sigok);
 393 extern void afs_cv_timedwait(afs_kcondvar_t * cv, afs_kmutex_t * l,
 394                              int waittime);
 395 #endif
 396
 397
 398
 399 /* ARCH/rx_knet.c */
 400 #if defined(KERNEL) && !defined(AFS_SGI_ENV)
 401 extern int osi_NetSend(osi_socket asocket, struct sockaddr_storage *addr,
 402                        int addrlen, struct iovec *dvec, int nvecs,
 403                        afs_int32 asize, int istack);
 404 #endif
 405 extern int osi_NetReceive(osi_socket so, struct sockaddr_storage *saddr,
 406                           int *slen, struct iovec *dvec, int nvecs,
 407                           int *lengthp);
 408 extern void osi_StopListener(void);
 409 extern int rxi_FindIfMTU(afs_uint32 addr);
 410 #ifndef RXK_LISTENER_ENV
 411 extern void rxk_init();
 412 #endif
 413
 414 /* UKERNEL/rx_knet.c */
 415 #ifdef UKERNEL
 416 extern void afs_rxevent_daemon(void);
 417 #endif
 418
 419
 420 /* rx_lwp.c */
 421 extern void rx_ServerProc(void);
 422 extern void rxi_Sleep(void *addr);
 423 extern void rxi_Delay(int seconds);
 424 extern void rxi_InitializeThreadSupport(void);
 425 extern void rxi_Wakeup(void *addr);
 426 extern void rxi_StopListener(void);
 427 #ifndef KERNEL
 428 extern void rxi_ReScheduleEvents(void);
 429 #endif
 430 extern void rxi_InitializeThreadSupport(void);
 431 extern void rxi_StartServerProc(void (*proc) (void), int stacksize);
 432 extern void rxi_StartListener(void);
 433 extern void rx_ServerProc(void);
 434 extern int rxi_Listen(osi_socket sock);
 435 extern int rxi_Recvmsg(osi_socket socket, struct msghdr *msg_p, int flags);
 436 extern int rxi_Sendmsg(osi_socket socket, struct msghdr *msg_p, int flags);
 437
 438
 439 /* rx_misc.c */
 440 #ifndef osi_alloc
 441 extern char *osi_alloc(afs_int32 x);
 442 #endif
 443 #ifndef osi_free
 444 extern int osi_free(char *x, afs_int32 size);
 445 #endif
 446 extern int hton_syserr_conv(register afs_int32 code);
 447 extern int ntoh_syserr_conv(int code);
 448
 449
 450 /* rx_multi.c */
 451 extern struct multi_handle *multi_Init(struct rx_connection **conns,
 452                                        register int nConns);
 453 extern int multi_Select(register struct multi_handle *mh);
 454 extern void multi_Ready(register struct rx_call *call,
 455                         register VOID *mh, register int index);
 456 extern void multi_Finalize(register struct multi_handle *mh);
 457 extern void multi_Finalize_Ignore(register struct multi_handle *mh);
 458
 459
 460
 461 /* rx_null.c */
 462 extern struct rx_securityClass *rxnull_NewServerSecurityObject(void);
 463 extern struct rx_securityClass *rxnull_NewClientSecurityObject(void);
 464
 465 /* rx_packet.c */
 466 extern afs_int32 rx_SlowGetInt32(struct rx_packet *packet, size_t offset);
 467 extern afs_int32 rx_SlowPutInt32(struct rx_packet *packet, size_t offset,
 468                                  afs_int32 data);
 469 extern afs_int32 rx_SlowReadPacket(struct rx_packet *packet,
 470                                    unsigned int offset, int resid, char *out);
 471 extern afs_int32 rx_SlowWritePacket(struct rx_packet *packet, int offset,
 472                                     int resid, char *in);
 473 extern int rxi_RoundUpPacket(struct rx_packet *p, unsigned int nb);
 474 extern int rxi_AllocDataBuf(struct rx_packet *p, int nb, int cla_ss);
 475 extern void rxi_MorePackets(int apackets);
 476 extern void rxi_MorePacketsNoLock(int apackets);
 477 extern void rxi_FreeAllPackets(void);
 478 extern void rx_CheckPackets(void);
 479 extern void rxi_FreePacketNoLock(struct rx_packet *p);
 480 extern int rxi_FreeDataBufsNoLock(struct rx_packet *p, int first);
 481 extern void rxi_RestoreDataBufs(struct rx_packet *p);
 482 extern int rxi_TrimDataBufs(struct rx_packet *p, int first);
 483 extern void rxi_FreePacket(struct rx_packet *p);
 484 extern struct rx_packet *rxi_AllocPacketNoLock(int cla_ss);
 485 extern struct rx_packet *rxi_AllocPacket(int cla_ss);
 486 extern int rxi_AllocPackets(int cla_ss, int num_pkts, struct rx_queue *q);
 487 extern int rxi_FreePackets(int num_pkts, struct rx_queue *q);
 488 extern struct rx_packet *rxi_AllocSendPacket(register struct rx_call *call,
 489                                              int want);
 490 extern int rxi_ReadPacket(osi_socket socket, register struct rx_packet *p,
 491                           struct sockaddr_storage *saddr, int *slen);
 492 extern struct rx_packet *rxi_SplitJumboPacket(register struct rx_packet *p,
 493                                               struct sockaddr_storage *saddr,
 494                                               int slen, int first);
 495 #ifndef KERNEL
 496 extern int osi_NetSend(osi_socket socket, void *addr, int addrlen,
 497                        struct iovec *dvec, int nvecs, int length, int istack);
 498 #endif
 499 extern struct rx_packet *rxi_ReceiveDebugPacket(register struct rx_packet *ap,
 500                                                 osi_socket asocket,
 501                                                 struct sockaddr_storage *saddr,
 502                                                 int slen, int istack);
 503 extern struct rx_packet *rxi_ReceiveVersionPacket(register struct rx_packet
 504                                                   *ap, osi_socket asocket,
 505                                                   struct sockaddr_storage *,
 506                                                   int slen, int istack);
 507 extern void rxi_SendPacket(struct rx_call *call, struct rx_connection *conn,
 508                            struct rx_packet *p, int istack);
 509 extern void rxi_SendPacketList(struct rx_call *call,
 510                                struct rx_connection *conn,
 511                                struct rx_packet **list, int len, int istack);
 512 extern struct rx_packet *rxi_SendSpecial(register struct rx_call *call,
 513                                          register struct rx_connection *conn,
 514                                          struct rx_packet *optionalPacket,
 515                                          int type, char *data, int nbytes,
 516                                          int istack);
 517 extern void rxi_EncodePacketHeader(register struct rx_packet *p);
 518 extern void rxi_DecodePacketHeader(register struct rx_packet *p);
 519 extern void rxi_PrepareSendPacket(register struct rx_call *call,
 520                                   register struct rx_packet *p,
 521                                   register int last);
 522 extern int rxi_AdjustIfMTU(int mtu);
 523 extern int rxi_AdjustMaxMTU(int mtu, int peerMaxMTU);
 524 extern int rxi_AdjustDgramPackets(int frags, int mtu);
 525
 526
 527 /* rxperf.c */
 528
 529
 530 /* rx_pthread.c */
 531 extern void rxi_Delay(int sec);
 532 extern void rxi_InitializeThreadSupport(void);
 533 extern void rxi_StartServerProc(void (*proc) (void), int stacksize);
 534 #ifndef rxi_ReScheduleEvents
 535 extern void rxi_ReScheduleEvents(void);
 536 #endif
 537 extern void rx_ServerProc(void);
 538 extern void rxi_StartListener(void);
 539 extern int rxi_Listen(osi_socket sock);
 540 extern int rxi_Recvmsg(osi_socket socket, struct msghdr *msg_p, int flags);
 541 extern int rxi_Sendmsg(osi_socket socket, struct msghdr *msg_p, int flags);
 542
 543
 544 /* rx_rdwr.c */
 545 extern int rxi_ReadProc(register struct rx_call *call, register char *buf,
 546                         register int nbytes);
 547 extern int rx_ReadProc(struct rx_call *call, char *buf, int nbytes);
 548 extern int rx_ReadProc32(struct rx_call *call, afs_int32 * value);
 549 extern int rxi_FillReadVec(struct rx_call *call, afs_uint32 serial);
 550 extern int rxi_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio,
 551                          int maxio, int nbytes);
 552 extern int rx_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio,
 553                         int maxio, int nbytes);
 554 extern int rxi_WriteProc(register struct rx_call *call, register char *buf,
 555                          register int nbytes);
 556 extern int rx_WriteProc(struct rx_call *call, char *buf, int nbytes);
 557 extern int rx_WriteProc32(register struct rx_call *call,
 558                           register afs_int32 * value);
 559 extern int rxi_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio,
 560                            int maxio, int nbytes);
 561 extern int rx_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio,
 562                           int maxio, int nbytes);
 563 extern int rxi_WritevProc(struct rx_call *call, struct iovec *iov, int nio,
 564                           int nbytes);
 565 extern int rx_WritevProc(struct rx_call *call, struct iovec *iov, int nio,
 566                          int nbytes);
 567 extern void rxi_FlushWrite(register struct rx_call *call);
 568 extern void rx_FlushWrite(struct rx_call *call);
 569
 570 /* rx_trace.c */
 571
 572
 573 /* rx_user.c */
 574 #ifdef AFS_PTHREAD_ENV
 575 extern pthread_mutex_t rx_if_init_mutex;
 576 extern pthread_mutex_t rx_if_mutex;
 577 #endif
 578 extern osi_socket rxi_GetUDPSocket(u_short port);
 579 extern void osi_AssertFailU(const char *expr, const char *file, int line);
 580 extern int rx_getAllAddr(afs_int32 * buffer, int maxSize);
 581 extern void osi_Panic();        /* leave without args till stdarg rewrite */
 582 extern void rxi_InitPeerParams(struct rx_peer *pp);
 583
 584 #if defined(AFS_AIX32_ENV) && !defined(KERNEL)
 585 extern void *osi_Alloc(afs_int32 x);
 586 extern void osi_Free(void *x, afs_int32 size);
 587 #endif /* defined(AFS_AIX32_ENV) && !defined(KERNEL) */
 588
 589 extern void rx_GetIFInfo(void);
 590 extern void rx_SetNoJumbo(void);
 591
 592
 593 /* rx_xmit_nt.c */
 594
 595
 596 /* MISC PROTOTYPES - MOVE TO APPROPRIATE LOCATION LATER */
 597
 598 /* EXTERNAL PROTOTYPES - include here cause it causes too many issues to
 599    include the afs_prototypes.h file - just make sure they match */
 600 #ifndef afs_osi_Alloc
 601 extern void *afs_osi_Alloc(size_t x);
 602 #endif
 603 #ifndef afs_osi_Alloc_NoSleep
 604 extern void *afs_osi_Alloc_NoSleep(size_t x);
 605 #endif
 606 #ifndef afs_osi_Free
 607 extern void afs_osi_Free(void *x, size_t asize);
 608 #endif
 609 #ifndef afs_osi_Wakeup
 610 extern int afs_osi_Wakeup(void *event);
 611 #endif
 612 #ifndef afs_osi_Sleep
 613 extern void afs_osi_Sleep(void *event);
 614 #endif
 615 extern unsigned int afs_random(void);
 616 extern void osi_linux_rxkreg(void);
 617
 618 #endif /* _RX_PROTOTYPES_H */