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