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 #if defined(KERNEL) && defined(AFS_LINUX26_ENV)
 350 #define osi_Panic(msg...) do { printk(KERN_CRIT "openafs: " msg); BUG(); } while (0)
 351 #undef osi_Assert
 352 #define osi_Assert(expr) \
 353     do { if (!(expr)) { osi_AssertFailK(#expr, __FILE__, __LINE__); BUG(); } } while (0)
 354 #else
 355 extern void osi_Panic();      /* leave without args till stdarg rewrite */
 356 #endif
 357 extern int osi_utoa(char *buf, size_t len, unsigned long val);
 358 extern void rxi_InitPeerParams(register struct rx_peer *pp);
 359 extern void shutdown_rxkernel(void);
 360 #ifdef AFS_USERSPACE_IP_ADDR
 361 extern int rxi_GetcbiInfo(void);
 362 extern afs_int32 rxi_Findcbi(afs_uint32 addr);
 363 #else
 364 extern int rxi_GetIFInfo(void);
 365 #endif
 366 #ifndef UKERNEL
 367 #if 0
 368 extern int rxk_FreeSocket(register struct socket *asocket);
 369 #endif
 370 #ifndef AFS_NT40_ENV
 371 extern osi_socket *rxk_NewSocket(short aport);
 372 #endif
 373 #endif
 374 extern int rxk_ReadPacket(osi_socket so, struct rx_packet *p,
 375                           struct sockaddr_storage *saddr, int *slen);
 376 #ifdef UKERNEL
 377 extern void rx_ServerProc(void);
 378 #endif
 379 extern void osi_AssertFailK(const char *expr, const char *file, int line);
 380 extern void rxk_ListenerProc(void);
 381 extern void rxk_Listener(void);
 382 #ifndef UKERNEL
 383 extern void afs_rxevent_daemon(void);
 384 #endif
 385 #if defined(AFS_DARWIN80_ENV) && defined(KERNEL)
 386 extern ifnet_t rxi_FindIfnet(afs_uint32 addr, afs_uint32 * maskp);
 387 #else
 388 extern struct ifnet *rxi_FindIfnet(afs_uint32 addr, afs_uint32 * maskp);
 389 #endif
 390 extern void osi_StopListener(void);
 391
 392
 393 /* ARCH/rx_kmutex.c */
 394 #if defined(KERNEL) && defined(AFS_LINUX20_ENV)
 395 extern void afs_mutex_init(afs_kmutex_t * l);
 396 extern void afs_mutex_enter(afs_kmutex_t * l);
 397 extern int afs_mutex_tryenter(afs_kmutex_t * l);
 398 extern void afs_mutex_exit(afs_kmutex_t * l);
 399 extern int afs_cv_wait(afs_kcondvar_t * cv, afs_kmutex_t * l, int sigok);
 400 extern void afs_cv_timedwait(afs_kcondvar_t * cv, afs_kmutex_t * l,
 401                              int waittime);
 402 #endif
 403
 404
 405
 406 /* ARCH/rx_knet.c */
 407 #if defined(KERNEL) && !defined(AFS_SGI_ENV)
 408 extern int osi_NetSend(osi_socket asocket, struct sockaddr_storage *addr,
 409                        int addrlen, struct iovec *dvec, int nvecs,
 410                        afs_int32 asize, int istack);
 411 #endif
 412 extern int osi_NetReceive(osi_socket so, struct sockaddr_storage *saddr,
 413                           int *slen, struct iovec *dvec, int nvecs,
 414                           int *lengthp);
 415 extern void osi_StopListener(void);
 416 extern int rxi_FindIfMTU(afs_uint32 addr);
 417 #ifndef RXK_LISTENER_ENV
 418 extern void rxk_init();
 419 #endif
 420
 421 /* UKERNEL/rx_knet.c */
 422 #ifdef UKERNEL
 423 extern void afs_rxevent_daemon(void);
 424 #endif
 425
 426
 427 /* rx_lwp.c */
 428 extern void rx_ServerProc(void);
 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, int 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                           struct sockaddr_storage *saddr, int *slen);
 499 extern struct rx_packet *rxi_SplitJumboPacket(register struct rx_packet *p,
 500                                               struct sockaddr_storage *saddr,
 501                                               int slen, int first);
 502 #ifndef KERNEL
 503 extern int osi_NetSend(osi_socket socket, void *addr, int addrlen,
 504                        struct iovec *dvec, 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                                                 struct sockaddr_storage *saddr,
 509                                                 int slen, int istack);
 510 extern struct rx_packet *rxi_ReceiveVersionPacket(register struct rx_packet
 511                                                   *ap, osi_socket asocket,
 512                                                   struct sockaddr_storage *,
 513                                                   int slen, 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
 590 #if defined(AFS_AIX32_ENV) && !defined(KERNEL)
 591 extern void *osi_Alloc(afs_int32 x);
 592 extern void osi_Free(void *x, afs_int32 size);
 593 #endif /* defined(AFS_AIX32_ENV) && !defined(KERNEL) */
 594
 595 extern void rx_GetIFInfo(void);
 596 extern void rx_SetNoJumbo(void);
 597
 598
 599 /* rx_xmit_nt.c */
 600
 601
 602 /* MISC PROTOTYPES - MOVE TO APPROPRIATE LOCATION LATER */
 603
 604 /* EXTERNAL PROTOTYPES - include here cause it causes too many issues to
 605    include the afs_prototypes.h file - just make sure they match */
 606 #ifndef afs_osi_Alloc
 607 extern void *afs_osi_Alloc(size_t x);
 608 #endif
 609 #ifndef afs_osi_Alloc_NoSleep
 610 extern void *afs_osi_Alloc_NoSleep(size_t x);
 611 #endif
 612 #ifndef afs_osi_Free
 613 extern void afs_osi_Free(void *x, size_t asize);
 614 #endif
 615 #ifndef afs_osi_Wakeup
 616 extern int afs_osi_Wakeup(void *event);
 617 #endif
 618 #ifndef afs_osi_Sleep
 619 extern void afs_osi_Sleep(void *event);
 620 #endif
 621 extern unsigned int afs_random(void);
 622 extern void osi_linux_rxkreg(void);
 623
 624 #endif /* _RX_PROTOTYPES_H */