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 void
 245 rxi_DebugInit(void);
 246 #else
 247 void rxi_DebugInit();
 248 void rxi_DebugPrint();
 249 #endif
 250
 251 /* rx_clock.c */
 252 #if !defined(clock_Init)
 253 extern void clock_Init(void);
 254 #endif
 255 #if !defined(clock_UnInit)
 256 extern int clock_UnInit(void);
 257 #endif
 258 #if !defined(clock_UpdateTime)
 259 extern void clock_UpdateTime(void);
 260 #endif
 261
 262 /* rx_clock_nt.c */
 263
 264
 265 /* rx_conncache.c */
 266 extern void rxi_DeleteCachedConnections(void);
 267 extern struct rx_connection *rx_GetCachedConnection(unsigned int remoteAddr,
 268                                                     unsigned short port,
 269                                                     unsigned short service,
 270                                                     struct rx_securityClass
 271                                                     *securityObject,
 272                                                     int securityIndex);
 273 extern void rx_ReleaseCachedConnection(struct rx_connection *conn);
 274
 275
 276 /* rxdebug.c */
 277
 278
 279 /* rx_event.c */
 280 extern int rxevent_nFree;
 281 extern int rxevent_nPosted;
 282 #if 0
 283 extern struct rxevent *rxevent_Post(struct clock *when,
 284                                     void (*func) (struct rxevent * event,
 285                                                   struct rx_connection * conn,
 286                                                   struct rx_call * acall),
 287                                     void *arg, void *arg1);
 288 /* this func seems to be called with tons of different style routines, need to look
 289 at another time. */
 290 #else
 291 extern struct rxevent *rxevent_Post(struct clock *when, void (*func) (),
 292                                     void *arg, void *arg1);
 293 extern struct rxevent *rxevent_Post2(struct clock *when, void (*func) (),
 294                                     void *arg, void *arg1, int arg2);
 295 #endif
 296 extern void shutdown_rxevent(void);
 297 extern struct rxepoch *rxepoch_Allocate(struct clock *when);
 298 extern void rxevent_Init(int nEvents, void (*scheduler) (void));
 299 extern void rxevent_Cancel_1(register struct rxevent *ev,
 300                              register struct rx_call *call,
 301                              register int type);
 302 extern int rxevent_RaiseEvents(struct clock *next);
 303
 304
 305
 306
 307 /* rx_getaddr.c */
 308 extern void rxi_setaddr(afs_int32 x);
 309 extern afs_int32 rxi_getaddr(void);
 310
 311 /* rx_globals.c */
 312
 313
 314 /* rx_kcommon.c */
 315 struct socket;
 316 extern int (*rxk_PacketArrivalProc) (struct rx_packet * ahandle,
 317                                      struct sockaddr_in * afrom,
 318                                      struct socket *arock,
 319                                      afs_int32 asize);
 320 extern int (*rxk_GetPacketProc) (struct rx_packet **ahandle, int asize);
 321 extern afs_int32 afs_termState;
 322 extern int rxk_initDone;
 323
 324 extern int rxk_DelPort(u_short aport);
 325 extern void rxk_shutdownPorts(void);
 326 extern osi_socket rxi_GetUDPSocket(u_short port);
 327 extern osi_socket rxi_GetHostUDPSocket(u_int host, u_short port);
 328 extern void osi_Panic();
 329 extern int osi_utoa(char *buf, size_t len, unsigned long val);
 330 extern void rxi_InitPeerParams(register struct rx_peer *pp);
 331 extern void shutdown_rxkernel(void);
 332 #ifdef AFS_USERSPACE_IP_ADDR
 333 extern int rxi_GetcbiInfo(void);
 334 extern afs_int32 rxi_Findcbi(afs_uint32 addr);
 335 #else
 336 extern int rxi_GetIFInfo(void);
 337 #endif
 338 #ifndef UKERNEL
 339 #if 0
 340 extern int rxk_FreeSocket(register struct socket *asocket);
 341 #endif
 342 #ifndef AFS_NT40_ENV
 343 extern osi_socket *rxk_NewSocket(short aport);
 344 #endif
 345 #endif
 346 extern int rxk_ReadPacket(osi_socket so, struct rx_packet *p, int *host,
 347                           int *port);
 348 #ifdef UKERNEL
 349 extern void rx_ServerProc(void);
 350 #endif
 351 extern void osi_AssertFailK(const char *expr, const char *file, int line);
 352 extern void rxk_ListenerProc(void);
 353 extern void rxk_Listener(void);
 354 #ifndef UKERNEL
 355 extern void afs_rxevent_daemon(void);
 356 #endif
 357 #if defined(AFS_DARWIN80_ENV) && defined(KERNEL)
 358 extern ifnet_t rxi_FindIfnet(afs_uint32 addr, afs_uint32 * maskp);
 359 #else
 360 extern struct ifnet *rxi_FindIfnet(afs_uint32 addr, afs_uint32 * maskp);
 361 #endif
 362 extern void osi_StopListener(void);
 363
 364
 365 /* ARCH/rx_kmutex.c */
 366 #if defined(KERNEL) && defined(AFS_LINUX20_ENV)
 367 extern void afs_mutex_init(afs_kmutex_t * l);
 368 extern void afs_mutex_enter(afs_kmutex_t * l);
 369 extern int afs_mutex_tryenter(afs_kmutex_t * l);
 370 extern void afs_mutex_exit(afs_kmutex_t * l);
 371 extern int afs_cv_wait(afs_kcondvar_t * cv, afs_kmutex_t * l, int sigok);
 372 extern void afs_cv_timedwait(afs_kcondvar_t * cv, afs_kmutex_t * l,
 373                              int waittime);
 374 #endif
 375
 376
 377
 378 /* ARCH/rx_knet.c */
 379 #if defined(KERNEL) && !defined(AFS_SGI_ENV)
 380 extern int osi_NetSend(osi_socket asocket, struct sockaddr_in *addr,
 381                        struct iovec *dvec, int nvecs, afs_int32 asize,
 382                        int istack);
 383 #endif
 384 extern int osi_NetReceive(osi_socket so, struct sockaddr_in *addr,
 385                           struct iovec *dvec, int nvecs, int *lengthp);
 386 extern void osi_StopListener(void);
 387 extern int rxi_FindIfMTU(afs_uint32 addr);
 388 #ifndef RXK_LISTENER_ENV
 389 extern void rxk_init();
 390 #endif
 391
 392 /* UKERNEL/rx_knet.c */
 393 #ifdef UKERNEL
 394 extern void afs_rxevent_daemon(void);
 395 #endif
 396
 397
 398 /* rx_lwp.c */
 399 extern void rx_ServerProc(void);
 400 extern void rxi_Sleep(void *addr);
 401 extern void rxi_Delay(int seconds);
 402 extern void rxi_InitializeThreadSupport(void);
 403 extern void rxi_Wakeup(void *addr);
 404 extern void rxi_StopListener(void);
 405 #ifndef KERNEL
 406 extern void rxi_ReScheduleEvents(void);
 407 #endif
 408 extern void rxi_InitializeThreadSupport(void);
 409 extern void rxi_StartServerProc(void (*proc) (void), int stacksize);
 410 extern void rxi_StartListener(void);
 411 extern void rx_ServerProc(void);
 412 extern int rxi_Listen(osi_socket sock);
 413 extern int rxi_Recvmsg(osi_socket socket, struct msghdr *msg_p, int flags);
 414 extern int rxi_Sendmsg(osi_socket socket, struct msghdr *msg_p, int flags);
 415
 416
 417 /* rx_misc.c */
 418 #ifndef osi_alloc
 419 extern char *osi_alloc(afs_int32 x);
 420 #endif
 421 #ifndef osi_free
 422 extern int osi_free(char *x, afs_int32 size);
 423 #endif
 424 extern int hton_syserr_conv(register afs_int32 code);
 425 extern int ntoh_syserr_conv(int code);
 426
 427
 428 /* rx_multi.c */
 429 extern struct multi_handle *multi_Init(struct rx_connection **conns,
 430                                        register int nConns);
 431 extern int multi_Select(register struct multi_handle *mh);
 432 extern void multi_Ready(register struct rx_call *call,
 433                         register VOID *mh, register int index);
 434 extern void multi_Finalize(register struct multi_handle *mh);
 435 extern void multi_Finalize_Ignore(register struct multi_handle *mh);
 436
 437
 438
 439 /* rx_null.c */
 440 extern struct rx_securityClass *rxnull_NewServerSecurityObject(void);
 441 extern struct rx_securityClass *rxnull_NewClientSecurityObject(void);
 442
 443 /* rx_packet.c */
 444 extern afs_int32 rx_SlowGetInt32(struct rx_packet *packet, size_t offset);
 445 extern afs_int32 rx_SlowPutInt32(struct rx_packet *packet, size_t offset,
 446                                  afs_int32 data);
 447 extern afs_int32 rx_SlowReadPacket(struct rx_packet *packet,
 448                                    unsigned int offset, int resid, char *out);
 449 extern afs_int32 rx_SlowWritePacket(struct rx_packet *packet, int offset,
 450                                     int resid, char *in);
 451 extern int rxi_RoundUpPacket(struct rx_packet *p, unsigned int nb);
 452 extern int rxi_AllocDataBuf(struct rx_packet *p, int nb, int cla_ss);
 453 extern void rxi_MorePackets(int apackets);
 454 extern void rxi_MorePacketsNoLock(int apackets);
 455 extern void rxi_FreeAllPackets(void);
 456 extern void rx_CheckPackets(void);
 457 extern void rxi_FreePacketNoLock(struct rx_packet *p);
 458 extern int rxi_FreeDataBufsNoLock(struct rx_packet *p, int first);
 459 extern void rxi_RestoreDataBufs(struct rx_packet *p);
 460 extern int rxi_TrimDataBufs(struct rx_packet *p, int first);
 461 extern void rxi_FreePacket(struct rx_packet *p);
 462 extern struct rx_packet *rxi_AllocPacketNoLock(int cla_ss);
 463 extern struct rx_packet *rxi_AllocPacket(int cla_ss);
 464 extern int rxi_AllocPackets(int cla_ss, int num_pkts, struct rx_queue *q);
 465 extern int rxi_FreePackets(int num_pkts, struct rx_queue *q);
 466 extern struct rx_packet *rxi_AllocSendPacket(register struct rx_call *call,
 467                                              int want);
 468 extern int rxi_ReadPacket(osi_socket socket, register struct rx_packet *p,
 469                           afs_uint32 * host, u_short * port);
 470 extern struct rx_packet *rxi_SplitJumboPacket(register struct rx_packet *p,
 471                                               afs_int32 host, short port,
 472                                               int first);
 473 #ifndef KERNEL
 474 extern int osi_NetSend(osi_socket socket, void *addr, struct iovec *dvec,
 475                        int nvecs, int length, int istack);
 476 #endif
 477 extern struct rx_packet *rxi_ReceiveDebugPacket(register struct rx_packet *ap,
 478                                                 osi_socket asocket,
 479                                                 afs_int32 ahost, short aport,
 480                                                 int istack);
 481 extern struct rx_packet *rxi_ReceiveVersionPacket(register struct rx_packet
 482                                                   *ap, osi_socket asocket,
 483                                                   afs_int32 ahost,
 484                                                   short aport, int istack);
 485 extern void rxi_SendPacket(struct rx_call *call, struct rx_connection *conn,
 486                            struct rx_packet *p, int istack);
 487 extern void rxi_SendPacketList(struct rx_call *call,
 488                                struct rx_connection *conn,
 489                                struct rx_packet **list, int len, int istack);
 490 extern struct rx_packet *rxi_SendSpecial(register struct rx_call *call,
 491                                          register struct rx_connection *conn,
 492                                          struct rx_packet *optionalPacket,
 493                                          int type, char *data, int nbytes,
 494                                          int istack);
 495 extern void rxi_EncodePacketHeader(register struct rx_packet *p);
 496 extern void rxi_DecodePacketHeader(register struct rx_packet *p);
 497 extern void rxi_PrepareSendPacket(register struct rx_call *call,
 498                                   register struct rx_packet *p,
 499                                   register int last);
 500 extern int rxi_AdjustIfMTU(int mtu);
 501 extern int rxi_AdjustMaxMTU(int mtu, int peerMaxMTU);
 502 extern int rxi_AdjustDgramPackets(int frags, int mtu);
 503
 504
 505 /* rxperf.c */
 506
 507
 508 /* rx_pthread.c */
 509 extern void rxi_Delay(int sec);
 510 extern void rxi_InitializeThreadSupport(void);
 511 extern void rxi_StartServerProc(void (*proc) (void), int stacksize);
 512 #ifndef rxi_ReScheduleEvents
 513 extern void rxi_ReScheduleEvents(void);
 514 #endif
 515 extern void rx_ServerProc(void);
 516 extern void rxi_StartListener(void);
 517 extern int rxi_Listen(osi_socket sock);
 518 extern int rxi_Recvmsg(osi_socket socket, struct msghdr *msg_p, int flags);
 519 extern int rxi_Sendmsg(osi_socket socket, struct msghdr *msg_p, int flags);
 520
 521
 522 /* rx_rdwr.c */
 523 extern int rxi_ReadProc(register struct rx_call *call, register char *buf,
 524                         register int nbytes);
 525 extern int rx_ReadProc(struct rx_call *call, char *buf, int nbytes);
 526 extern int rx_ReadProc32(struct rx_call *call, afs_int32 * value);
 527 extern int rxi_FillReadVec(struct rx_call *call, afs_uint32 serial);
 528 extern int rxi_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio,
 529                          int maxio, int nbytes);
 530 extern int rx_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio,
 531                         int maxio, int nbytes);
 532 extern int rxi_WriteProc(register struct rx_call *call, register char *buf,
 533                          register int nbytes);
 534 extern int rx_WriteProc(struct rx_call *call, char *buf, int nbytes);
 535 extern int rx_WriteProc32(register struct rx_call *call,
 536                           register afs_int32 * value);
 537 extern int rxi_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio,
 538                            int maxio, int nbytes);
 539 extern int rx_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio,
 540                           int maxio, int nbytes);
 541 extern int rxi_WritevProc(struct rx_call *call, struct iovec *iov, int nio,
 542                           int nbytes);
 543 extern int rx_WritevProc(struct rx_call *call, struct iovec *iov, int nio,
 544                          int nbytes);
 545 extern void rxi_FlushWrite(register struct rx_call *call);
 546 extern void rx_FlushWrite(struct rx_call *call);
 547
 548 /* rx_trace.c */
 549
 550
 551 /* rx_user.c */
 552 #ifdef AFS_PTHREAD_ENV
 553 extern pthread_mutex_t rx_if_init_mutex;
 554 extern pthread_mutex_t rx_if_mutex;
 555 #endif
 556 extern osi_socket rxi_GetUDPSocket(u_short port);
 557 extern void osi_AssertFailU(const char *expr, const char *file, int line);
 558 extern int rx_getAllAddr(afs_int32 * buffer, int maxSize);
 559 extern void osi_Panic();        /* leave without args till stdarg rewrite */
 560 extern void rxi_InitPeerParams(struct rx_peer *pp);
 561
 562 #if defined(AFS_AIX32_ENV) && !defined(KERNEL)
 563 extern void *osi_Alloc(afs_int32 x);
 564 extern void osi_Free(void *x, afs_int32 size);
 565 #endif /* defined(AFS_AIX32_ENV) && !defined(KERNEL) */
 566
 567 extern void rx_GetIFInfo(void);
 568 extern void rx_SetNoJumbo(void);
 569
 570
 571 /* rx_xmit_nt.c */
 572
 573
 574 /* MISC PROTOTYPES - MOVE TO APPROPRIATE LOCATION LATER */
 575
 576 /* EXTERNAL PROTOTYPES - include here cause it causes too many issues to
 577    include the afs_prototypes.h file - just make sure they match */
 578 #ifndef afs_osi_Alloc
 579 extern void *afs_osi_Alloc(size_t x);
 580 #endif
 581 #ifndef afs_osi_Alloc_NoSleep
 582 extern void *afs_osi_Alloc_NoSleep(size_t x);
 583 #endif
 584 #ifndef afs_osi_Free
 585 extern void afs_osi_Free(void *x, size_t asize);
 586 #endif
 587 #ifndef afs_osi_Wakeup
 588 extern int afs_osi_Wakeup(void *event);
 589 #endif
 590 #ifndef afs_osi_Sleep
 591 extern void afs_osi_Sleep(void *event);
 592 #endif
 593 extern unsigned int afs_random(void);
 594 extern void osi_linux_rxkreg(void);
 595
 596 #endif /* _RX_PROTOTYPES_H */