src/rx/rx_prototypes.h

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