fnsproto.h

用于嵌入式系统的TCP/IP协议栈及若干服务

#endif /* USE_TRANSMIT_TASK */
#endif  /* PET9_DEVICE*/

import  int     q_chk(q * qp,  q * iqp);
import  q *     q_in(q * a,  q * b);
#ifndef q_init
import  void    q_init(q * qp, u16 flags);
#endif
#ifndef q_initparent
import  void    q_initparent(q * qp, u16 flags, char * pp);
#endif
import  q *     q_intail(q * a,  q * b);
import  int     q_len(q * qp);
import  q * q_nxt(q * qp);
import  q * q_out(q * qp);
import  char *  q_outhead(q * qp);
import  char *  q_outparent(q * qp);
import  char *  q_parent(q * qp);
import  char *  q_scan(q * qp,  void * arg,  boolean (*match)(void * arg, m* mp));

#ifdef  QUICC_DEVICE
import  int     quicc_init(netdev * ndp);
import  int     quicc_updown(netdev * ndp, u16 flags, char * options);
import  int     quicc_ioctl(netdev * ndp, int cmnd, char * addr);
import  int     quicc_start(m * mp);
import	void	quicc_maint(void);
import	void    smc1_write (char *ch, int num_bytes);
import void 	smc_initproc (void);
import	void	quicc_quicc(void);
#endif

#ifdef  MACE_DEVICE		/*RLS 12/96 rev. 3.7*/
import  int     mace_init(netdev * ndp);
import  int     mace_updown(netdev * ndp, u16 flags, char * options);
import  int     mace_ioctl(netdev * ndp, int cmnd, char * addr);
import  int     mace_start(m * mp);
#endif

#ifdef RARP_CLIENT
int rarp_ask(char * address, netdev * ndp);
#endif

import  void    rarp_pcache(void);
import  void    rip_notify(so_t * sop);

/* Router interface routines */
import void fns_router(void * param);
import void router_start(void);
import void router_router(void);
import int router_init(void);
import int router_circ_init(netdev * ndp);
import int ip_add_local_route(netdev *ndp, u32 ip_address, u32 subnet);
import int ip_del_local_route(netdev * ndp, u32 ip_address, u32 ip_mask);
import int ipGetNextHop(u8 * ipap, int * cidp, rripa * nexthopp );
import void rrIcmpTxRtrDiscAdv(netdev * ndp);
import st rip_up(m * mp);
import st ospf_up(m * mp);
/* End of router interface routine */
import  char *  rte2str(rte * rtp, char * its_buf);


#ifdef SV_SKEPTIC
import  void    _sv_bind(tcpsv_t * svp,  u32 * ref, boolean m_ok);
import  tcpsv_t * _sv_detach(tcpsv_t * svp,  u32 * ref, boolean m_ok);
#else
import  void    _sv_bind(tcpsv_t * svp);
import  tcpsv_t * _sv_detach(tcpsv_t * svp);
#endif

import  void    s_dp(u32 value,  int field);
import  void    s_heap(void);
import  void    s_hp(u32 value,  int field);
import  void    s_mp(m * mp, char * msg);
import  char *  s2str(int s, char * buf);
import  char *  sec2str(u16 af, char * its_buf);
import  u16     sel_anotify(so_t * sop, son_t * sonp,  u16 news);
import  u16     sel_notify(so_t * sop, son_t * sonp,  u16 news);
import  void    sel_rip(nsel_t * nselp);
import  void    send_notify(so_t * sop);
import  char *  skipbl(char * s);

/* Generic SLIP entry points */
#ifdef SLIP_PROTOCOL
import  int     sl_init(netdev * ndp);
import  int     sl_updown(netdev * ndp, u16 flags, char * options);
#ifdef RAW_SOCKET
import  int     sl_attach(so_t * sop);
import  int     sl_bind(so_t * sop, el * elp);
import  int     sl_connect(so_t * sop, el * elp);
import  int     sl_inaddr(el * elp,  so_addr * addrp);
#endif
import  st      sl_scomm(m * mp);
#endif

/* Loop back interface */
st loopback_driver_send (struct m * mp);

/* Standard Microsystems Corp. SMC Elite16 Series EtherCard Plus */
#ifdef SMC16_DEVICE
import int      smc16_init(struct netdev * ndp);  /* initialize the board */
import int      smc16_updown(struct netdev * ndp, u16 fl, char * opt); /* on line*/
import int      smc16_ioctl(struct netdev * ndp, int cmnd, char * addr);
import int      smc16_start(m * mp); /* send the packet out over the wire */
#endif

import  int     so_dclose(so_t * sop);
import  int     so_pclose(so_t * sop);
import  int     so_ditchsop(void * sop);
import  int     so_debug(void);
import  int     so_inextsocket(int * errp);
import  int     so_initialize(void);
import  int     so_iopen(int six);
import  int     so_ishutdown(so_t * sop, int direction);
import  int     so_iclose(so_t * sop);
import  void    so_notify(so_t * sop,  u16 news);
import  int     so_open(short dev);
import  int     so_return(int err, short dev, panic_t * panicarg);
import  void    so_smoke(so_t * sop);
import	int	so_timeoutclose(void *  uarg);
import  int     so_uclose(short dev);
import  void    sop_init(so_t * sop);

import	int	so_nwrite(int fd, u32 * bytep);
import	int	so_nread(int fd, u32 * bytep);
import	int	so_sq_max(int fd, u32 new_sq_max);
import	int	so_rq_max(int fd, u32 new_rq_max);

import  st  sterr(m * mp);

import  a32   * str2ipnh(char * str, char ** newstrpp,  a32 * nhp);
import  ipa   * str2ipa(char * str,  ipa * ipap);
import  char  * strecpy(char * dest,  char * src);
#ifndef streql
import  boolean streql(char * cp1,  char * cp2);
#endif
import  boolean strfneql(char * s1,  char * s2,  int n);
import  boolean sv_check(u32 * ref);
import  void    sv_m_bind (tcpsv_t * svp, m * mp,int (*termfn)(struct m *)  );
import  int    sv_m_detach(m * mp);
import  void    sv_nstate(char * msg,  tcpsv_t * svp,  u16 new_state);
import  void    sv_so_bind(tcpsv_t * svp,  so_t * sop);
import  void    sv_so_detach(tcpsv_t * svp);
import  void    t_clock(void);
import  void    fns_t_delete(tcb * tcbp);
import  tcb *   t_new(tcb * tcbp, int (*pfi)(void *), 
                      void * uarg,  u32 ms,  u16 flags);
import  u32     fns_t_start(tcb * tcbp,  u32 ms);
import  u32     t_stop(tcb * tcbp);
import  void    tcpabort(tcpsv_t * svp, int err);
import  int     tcpattach(so_t * sop);
import  int     tcp_acktimer(void * uarg);
#ifdef NEED_ADJUST_ACK_DELAY
import  void    tcp_adjust_ack_delay(tcpsv_t * svp, u32 value);
#endif
import  int     tcpclose(so_t * sop);
import	int	    tcp_c_echo(void);
import  int     tcp_cabort(so_t * sop);
import  void    tcp_clr_ack(tcpsv_t * svp);
import  int     tcp_dink(m * mp);
import  int     tcp_dl(m * mp);
import  void    tcp_finpkt(m * mp,  tcpsv_t * svp);
import  st      tcp_icmp(m * mp);
#ifdef IP_RFC_1191
import int      tcp_pmtu_change_notif(u32 host,u16 new_pmtu);
#endif /* IP_RFC_1191 */
#ifdef TCP_SELACK_ENHANCEMENTS
import void tcp_add_out_sack_block(tcpsv_t *svp, u32 seqno,int length);
import void tcp_adjust_out_sack_blocks_for_rnxt(tcpsv_t *svp);
import void tcp_selective_ack_needed(tcpsv_t *svp,int *optsize,u16 *which_options);
import void tcp_in_sack_processing(tcpsv_t *svp, TCPO_T *tcphp);
import void tcp_in_sack_proc_suna(tcpsv_t *svp);
#endif /* TCP_SELACK_ENHANCEMENTS */

#ifdef TCP_TRACE
import void tcp_trace_segment (m *mp, int rx);
#endif

#ifdef TCP_TRANSACTION_TCP
import void t_tcp_initialize();
import t_tcp_cache_entry_ *t_tcp_init_connection_vars(tcpsv_t *svp, 
													  u32 hostaddr,boolean active);
import t_tcp_cache_entry_ *t_tcp_find_cache_entry(u32 hostaddr);
import int tcp_do_implied_connect(so_t *sop,tcpsv_t *svp,char *buf, 
								             int *buf_lenp, int flags);
#endif /* TCP_TRANSACTION_TCP */

import boolean tcp_retransmit_fsm(tcpsv_t * svp, int retr_event);
/* defines for retr_event */
#define TCP_RETR_TIMEOUT           1
#define TCP_RETR_NEW_ACK           2
#ifdef TCP_RETRANSMIT_ENHANCEMENTS
#define TCP_RETR_DUP_ACK           3
#define TCP_RETR_SEG_RETRANSMITTED 4 
#endif

import int tcp_connect_inner(so_t *sop, saddr *to, int tolen, tcpsv_t **svpp);
import int tcp_west (tcpsv_t * svp);


#ifdef TCP_WND_SCALE
import u16 tcp_rcv_wscale_value(tcpsv_t *svp);
#endif
import TCPO_T *tcp_find_option(TCPH_T *tcphp, u8 kind);
import int tcp_seg_optsize(tcpsv_t *svp, int synseg, u16 *which_options);
import void tcp_construct_seg_options(tcpsv_t *svp, char *optr, int olen, 
									  u16 which_options);

import  void    tcp_set_send_mss(tcpsv_t * svp,  u16 mss, int source);
#define TCP_MSS_SOURCE_PEER     1 /* source is MSS option in an incoming SYN */
#define TCP_MSS_SOURCE_IF_MTU   2 /* source is local interface MTU */
#define TCP_MSS_SOURCE_SOCKOPT  3 /* source is the TCP_MAXSEG socket option */
#define TCP_MSS_SOURCE_DEFAULT  4 /* source is the default we assume if we don't get*/
#ifdef IP_RFC_1191
#define TCP_MSS_SOURCE_PATH_MTU 5 /* source is path MTU */
#endif /* IP_RFC_1191 */
#ifdef TCP_TRANSACTION_TCP
#define TCP_MSS_SOURCE_FHCACHE  6 /* source is the t/tcp foreign host cache */
#endif /* TCP_TRANSACTION_TCP */

import  st      tcp_net_deliver(m * mp);
import  void    tcp_no_more_data_in(tcpsv_t * svp);
import  int     tcp_perftimer(void * uarg);
import  char    * tcp_pf(u16 flags);

import  void    tcp_schedule_delayed_ack(tcpsv_t * svp,  u16 ackflags);
#ifdef TCP_TRANSACTION_TCP
import  void    tcp_gsyn(tcpsv_t * svp, boolean xmit_now);
#else
import  void    tcp_gsyn(tcpsv_t * svp);
#endif
import  int     tcp_getopt(so_t * sop, int level, int optname, char * optval, int * optlen);
import  int     lk_close(so_t * sop);
import  int     ndev_ioctl(so_t * sop, int cmnd, u32 * addr, int len);
import  int     tcp_ioctl(so_t * sop, int cmnd, u32 * addr, int len);
import  int     tcp_listen(so_t * sop, int backlog);
import  int     tcp_setopt(so_t * sop, int level, int optname, u8 * optval, int optlen);
import  int     tcp_shutdown(so_t * sop, int direction);
import  int     udp_check_ocsum(m * mp);
import	int	    udp_c_echo(void);
import  int     udp_getopt(so_t * sop, int level, int optname, 
                           char * optval, int * optlen);
import  int     udp_setopt(so_t * sop, int level, int optname, 
                           u8 * optval, int optlen);
import int udp_memory_recovery_pending;
import void udp_schedule_recover_memory();
import void udp_recover_memory();

import  int     addr_out(so_addr * addrp, saddr * to, int * tolen);
#ifdef RAW_SOCKET
import  int     en_attach(so_t * sop);
import  int     en_bind(so_t * sop, saddr * to, int to_len);
import  int     en_connect(so_t * sop, saddr * to, int to_len);
import  int     en_inaddr(saddr * to, int to_len, so_addr * dest);
#endif
import  so_t    * fd_2_sock(int fd, int * errp);
import  so_t    * fd_2_sock_ignore_err(int fd, int * errp);
import  int     so_add_mcast_group(so_t *sop, struct netdev *ndp, u32 maddr);
import  int     so_drop_mcast_group(so_t *sop, struct netdev *ndp, u32 maddr);
import  so_mcast_t *so_in_mcast_group(so_t *sop, struct netdev *ndp, u32 maddr);
import  void	so_free_all_mcast(so_t *sop);
import  int     icmp_bind(so_t * sop, saddr * to, int to_len);
import  int     icmp_connect(so_t * sop, saddr * to, int to_len);
import  int     icmp_user_send(so_t * sop, char * buf, int * blnp, int flags);
import  int     ia_accept(so_t * sop, int * nfdp, int flags, 
                          saddr * addrname, int * addrlenp);
import  int     ia_bind(so_t * sop, saddr * to, int to_len);
import  int     ia_connect(so_t * sop, saddr * to, int to_len);
import  int     ia_inaddr(saddr * to, int to_len, so_addr * dest);
import  int     ia_recv(so_t * sop, char * buf, int * buf_lenp, int flags);
import  int     ia_send(so_t * sop, char * buf, int * buf_lenp, int flags);
import  int     ip_inaddr(saddr * to, int to_len, so_addr * dest);
import  int     lk_bind(so_t * sop, saddr * to, int to_len);
import  int     lk_recv(so_t * sop, char * buf, int * buf_lenp, int flags);
import  int     lk_send(so_t * sop, char * buf, int * buf_lenp, int flags);
import  int     os_nselect(nsel_t * nselp,  int cnt, void * ukey);
import  int     so_nselect(so_t * sop, usel_t * up, int flags);
import  int     so_outaddr(so_t * sop, saddr * name, int * namelen, int type);
import  int     so_rbcomm(so_t * sop, char * bufp, int * buf_lenp, int flags);
import  m       * so_rpcomm(so_t * sop, char * buf, int * buf_lenp, 
                            int flags, int * errp);
import  void	so_sbcomm(so_t * sop, char * buf, int * buf_lenp, 
                            int flags, int * errp);
import  m       * so_spcomm(so_t * sop, char * buf, int * buf_lenp, 
                            int flags, int * errp);
import  int     tcp_accept(so_t *sop, int *nfdp, int flags, 
                           saddr *addrname, int * addrlenp);
import  int     tcp_bind(so_t * sop, saddr * to, int to_len);
import  int     tcp_connect(so_t * sop, saddr * to, int to_len);
import  int     tcp_outaddr(so_t * sop, saddr * name, int * namelen, int type);
import  int     tcp_recv(so_t * sop, char * buf, int * buf_lenp, int flags);
import  int     tcp_send(so_t * sop, char * buf, int * buf_lenp, int flags);
import  int     udp_accept(so_t * sop, int * nfdp, int flags, 
                           saddr * addrname, int * addrlenp);
import  int     udp_bind(so_t * sop, saddr * to, int to_len);
import  int     udp_connect(so_t * sop, saddr * to, int to_len);
import  int     udp_send(so_t * sop, char * buf, int * buf_lenp, int flags);

#ifdef TCP_KEEP_ALIVE
import  void    tcp_end_ka(tcpsv_t * svp);
import  int     tcp_init_ka(tcpsv_t * svp);
import  int     tcp_ka_timer(void * svp);
import  void    tcp_ska(m * dmp, tcpsv_t * svp , boolean garbage);
#endif

import  int     tcp_reject(so_t * sop, boolean can_wait);
import  st      tcp_reset(m * mp);
import  int     tcp_rextimer(void * uarg);
import  void    tcp_rmax_set(tcpsv_t * svp);
import  void    tcp_rshrinkwindow(tcpsv_t * svp, u16 length);
import  void    tcp_rsinit(tcpsv_t * svp);
import  void    tcp_rslf(tcpsv_t * svp, int err);
import  void    tcp_rsyn(m * mp);
import  void    tcp_rwdefaults(tcpsv_t * svp);
import  void    tcp_sndack(m * dmp,  tcpsv_t * svp);
import  char    * tcp_st(u16 state);
import  void     tcp_sqxmit(tcpsv_t * svp);
import  st      tcp_target(m * mp);
import  st      tcp_up(m * mp);
import  st      tcp_xmit(m * mp);
import  int     tcpinit(pr_t * prp);


import  int     _tmq_block(tmq * tmqp, m * mp,
				boolean (*match)(void * arg, m* mp));
import  void    tmq_continue(tmq * tmqp, void * arg,
			boolean (*match)(void * arg, m * mp), int err);
import  m     * tmq_in(tmq * tmqp, u32 delay,  m * mp, st (*fn)(m *));
import  void    tmq_init(tmq * tmqp, u32 ms, int timeouterr);
import  void    tmq_wakeup(m * mp, int err);
import  char *  tokenize(char * line,  char * delim);
import  char *  trimbl(char * s);
import  st      tr_scomm(m * mp);
import  boolean true_sub(void);
import  void    twq_in(int (*pfi)(void *, void *), void * arg1, void * arg2);
import  void    twq_init();
import  void    twq_promise(void);
import  void    twq_run(void);
import  u16     type_2_af(u32 type, ufast llaf);
import  char  * u_2_str(u32 u);
import  void    u8_dump(u8 * u8p,  int bcnt);
import  void    u16_dump(u16 * u16p,  int bcnt);
import  int     udp_attach(so_t * sop);
import  int     udp_dink(m * mp);
import  st      udp_icmp(m * mp);
import  int     udp_reject(so_t * sop, boolean waitok);
import  st      udp_up(m * mp);
import  st      udp_xmit(m * mp);
import  int     udpinit(pr_t * prp);
import  int     uselect(usel_t * uselp);
import  void    void_sub(void);
import  int     zero_sub(void);

void show_gq(gq * gqp);
int gq_chk_nom(gq * gqp);

#endif /* _FNSPROTO_ */