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