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