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