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