fnsproto.h

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

/*
*            Copyright (c) 1998-2001 by NETsilicon Inc.
*
*  This software is copyrighted by and is the sole property of
*  NETsilicon.  All rights, title, ownership, or other interests
*  in the software remain the property of NETsilicon.  This
*  software may only be used in accordance with the corresponding
*  license agreement.  Any unauthorized use, duplication, transmission,
*  distribution, or disclosure of this software is expressly forbidden.
*
*  This Copyright notice may not be removed or modified without prior
*  written consent of NETsilicon.
*
*  NETsilicon, reserves the right to modify this software
*  without notice.
*
*  NETsilicon
*  411 Waverley Oaks Road                  USA 781.647.1234
*  Suite 227                               http://www.netsilicon.com
*  Waltham, MA 02452                       [e-mail]
*
*************************************************************************
*  $Name: Fusion 6.52 Fusion 6.51 $
*  $Date: 2002/01/18 17:20:42 $
*  $Source: M:/psisrc/stack/incl/rcs/fnsproto.h $
*  $Revision: 1.79 $
**************************************************************************
*  File Description:   FNS Function Prototype header file
*
**************************************************************************/

#ifndef _FNSPROTO_
#define _FNSPROTO_

#include "config.h"
#include "ccdep.h"
#include "osdeps.h"
#include "socket.h"
#include "std.h"
#include "dsu.h"
#include "q.h"
#include "timer.h"
#include "netdev.h"
#include "m.h"
#include "psu.h"
#include "so.h"
#include "son.h"
#include "select.h"
#include "nsel.h"
#include "fr.h"
#include "pr.h"
#include "arp.h"
#include "ip.h"
#include "tcp.h"
#include "panic.h"
#include "twq.h"
#include "fpublic.h"

#define so_close(sd)    so_uclose((u16)sd)


#ifdef FUSION_SCHEDULER
#define tcpip_exit()    os_idle()
#else
#define tcpip_exit()
#endif


#ifdef  LLC_PROTOCOL
import  int llc_connect(), llc_inaddr();
#ifdef USE_PM
import  int llc_bind(), llc_attach();
#endif
#endif  /* LLC_PROTOCOL */

#ifdef  TRN_PROTOCOL
import  int tr_attach(), tr_bind(), tr_connect(), tr_inaddr();
#endif

#ifdef IM_DEVICE
import  st  im_send();
#else
#define im_send sterr
#endif

import  char *  a48_2_str(a48 * ap);
import  char	* af2str(int af, char * buf);
import  u32     af_2_type(ufast af, ufast llaf);
import  u16     af_code(char * name);
import  void    af_db_load(void);
import  void    af_db_unload(void);
import  char *  af_name(u16 af);
import  int     arp_init(void);
import  int 	arp_multi_add (netdev *ndp, char *ip);
import  int 	arp_multi_del (netdev *ndp, char *ip);
import  void    arp_pcache(void);
import  st      _arp_resolve(m * mp);
import  st      arp_up(m * mp);




import	int	cabort(int sd);
import  void    char_dump(char * charp,  int bcnt);

#ifdef REAL_SKEPTIC
import  int check_heap(char * cp);
#endif
import  void    clr_pending_notify(so_t * sop);

#ifdef SNMP
import  u32 countTcpCurrEstab(void);
#endif

#ifdef TELNET_PROTOCOL
import void do_telnetd(void);
import void do_telnetp(void);
#endif

import  void    do_tx_udp_test(void *dptr);
import  void    do_tx_tcp_test(void *dptr);
import  void    do_telsingle (void *dptr);
import  void    do_httpd (void *dptr);
import  void    fatal(char * fmt, ...);
import  nsel_t  * find_nsel(nsel_t * nselp, u16 flags, u32 ukey);


import void     FNS_Console (void *dptr);    /* console.c */
import  int     fns_demo(int task);
import  void    FNS_Timer_Task(void);

import  int fr_ddown(netdev * ndp);
import  int fr_dup(netdev * ndp,  sa_u * saup, char * options);
import  int fr_in(u16 flags,  qtb * qtbp);
import  void    fr_linit(void);
import  int fr_multi(void);
import  st  fr_qin(st (*fn)(m * mp),  m * mp,  qtb * qtbp);
import  st  fr_send(m  * mp);
import  st  fr_tq(m * mp);
import  int fr_unsafe(void);
import  st  fr_up(m * mp);
import  void    fusion_init(void);
import	int     get_my_ip_address(netdev * ndp, char * address);

import  int gq_chk(gq * gqp, m * qmp);
import  q * gq_hdlock(gq * gqp, int * errp, boolean canblock);
import  q * gq_head(gq * gqp, int * errp, boolean canblock);
import  int gq_in(gq * gqp, m * mp);
import  void    gq_init(gq * gqp);
import  void    gq_max_set(gq * gqp, int new_max);
import  void    gq_out(gq * gqp, int cnt);
import  void    gq_out_wake(gq * gqp);
import  int _gq_poll(gq * gqp, boolean canblock);
import  int _gq_sleep(gq * gqp);
import  int gq_sleep(gq * gqp);
import  void    gq_smoke(gq * gqp);
import  void    gq_unlock(gq * gqp);
import  void    _gq_wakeup(gq * gqp, int status);
import  void    gq_wakeup(gq * gqp, int status);

import  void    hex_cat(char * dst,  char * src, int len);
import  char *  hex2str(u8 * u8p,  int bcnt);

import  char *  i_2_str(i32 i);
import  int ia_attach(so_t * sop);
import  int ia_close(so_t * sop);
import  void ia_endrecv(so_t * sop, m * mp);
import  st  ia_dispose(m * mp);
import  st  ia_echo(m * mp);
import  int ia_ioctl(so_t * sop, int cmnd, u32 * addr, int len);
import  int ia_init(pr_t * prp);
import  void ia_kwarf(so_t * sop, st (*fn)(m *));
import  int ia_listen(so_t * sop, int backlog);
import  int ia_pair(so_t * sop,  so_t * nsop);
import  int icmp_attach(so_t * sop);
import  int icmp_dink(m * mp);
import  st  icmp_msg(m * mp);
import  int icmp_rtrdiscovery_req(netdev * ndp);
import  st  icmp_up(m * mp);
import  int icmpinit(pr_t * prp);
import  st  icmp_user_up(m * mp);

import void ip_purge_fragments();

/**  IGMP functions */
import int igmpinit(pr_t * prp);
import st  igmp_up(struct m *mp);
import int igmp_attach(struct so_t * sop);
#ifndef is_D_class
import int is_D_class(u8 *);
#endif
import int igmp_start(netdev * ndp);
import int ip_add_multi_route (char *devname, char *ip_address, int is_localmc );
import int ip_del_multi_route(char * devname, char *ip_address);
import int igmp_find(u32 ip, netdev * ndp);
import netdev * igmpFindNdp(a32 * a32p);
import  int     igmp_send_query (void);
/** END of IGMP functions */

import	void init_dbg_params(void);
import  int _inselect(void * nselp, void * unusedp);
import  char *  ipa2str(ipa * ipap, char * dst);
import  st  ip_ascend(m * mp);
import  void    ip_at_comm(so_t * sop, u32 sq_max, u32 rq_max);
import  u16 ip_bc_type(u32 ndestaddr, u32 nmyipaddress, u32 nsubnetmask);
import  u32 ip_class_mask(u8 msb);
import  int is_loopback(u32 ip_address);
import  st  ip_collect(m * mp);
import  void    ip_fragment(m * mp);
import	st	ip_frsend(m * mp);
import  int ip_getopt(so_t * sop,  int optname,  char * optval,  int * optlen);

import  boolean ip_hmatch(u32, u8 *);
import  boolean ip_host_is_sane(a32 * a32p);
import  st  ip_icmp(m * mp);
import  st  ip_net_deliver(m * mp);
import  boolean ip_net_is_sane(a32 * a32p);
import  boolean ip_net0(a32 * addrp);
import  st  ip_resolve(m * mp);
import  st  ip_route(m * mp);
import  st  ip_send(m * mp);
import  int ip_setopt(so_t *sop, int level, int optname, u8 * optval, int optlen);
import  void    ip_stop(m * mp);
import  st  ip_up(m * mp);
import  st  ip_xmit(m * mp);
import  st  ip_xmt2(m * mp);
import  st  ip_xmt3(m * mp);
import  st  ip_xmtlocal(m * mp);
import  st  ip_xopt(m * mp);
import  int ipinit(void);
#ifdef IP_RFC_1191
import  int ip_get_path_mtu(u32 hostaddr);
import void ip_path_mtu_init();
import void ip_pmtu_icmp(u32 hostaddr,u16 nhmtu);
#endif /* IP_RFC_1191 */
import  char *  ipnh2str(u32, char *);
#ifndef isbroadcast
import  boolean isbroadcast(a48 * a48p);
#endif
import  boolean is_secure(secure * secp);



import int ll_set_addr( netdev *ndp, u8 *addr, u8 len );
import  netdev * ll_dev_2_ndp(char * devname);
import  netdev * ll_ipaddr_2_ndp (u32 ipaddr);  

#ifndef md_cheql
import  boolean md_cheql(char * cp1,  char * cp2,  int len);
#endif

/* Multibus Ethernet 3com entry points */
#ifdef  META_DEVICE
import  int     meta_init(netdev * ndp);
import  int     meta_updown(netdev * ndp, u16 flags, char * options);
import  int     meta_ioctl(netdev * ndp, int cmnd, char * addr);
import  int     meta_start(m * mp);
#endif  /* META_DEVICE */

import  void    mgq_out(m * mp);
import  void    nc_hinit(void);
import  int     nc_init(void);
import  void    ncdev_init(void);
import  void    ncpr_init(void);
import  netdev * nd_match(u16 devid, int (*init_pfi)(netdev *));
import  void    ndv_init(void);
import  int     noent_init(struct netdev * ndp);
import  void    np_init(void);
import  void    nr_init(void);
import  void    ndq_restart(netdev * ndp);
import  void    ndq_smoke(netdev * ndp);
import  st      ndq_start(m * mp);
import  netdev  * nd_lookup(char * name);
import  int     noent(void);
import  int     no_shutdown(so_t * sop, int direction);
import  u16     oc_sum(a16 * a16p,  int cnt);
import  int     opnotsupp(void);

#ifdef FUSION_SCHEDULER
import  void    os_maint(void);
import	void	os_idle(void);
import	void	init_os_area(void);
import  void    os_wait(unsigned int duration);
import  void    proc_init(void);
#else
#define os_idle()	return
#endif

import  void    os_clock_init(void);
import  int     os_critical(void);

import  void    os_normal(int savpri);
import  void    os_notify(nsel_t * nselp);

#ifndef os_printf
import  void    os_printf(char * msg,...);
#endif

import  int     spl7(void);   /* jp - 01.2000 */
import  int     os_pid(void); /* */

import  int     os_spl0(void);
import  boolean os_priv_user(void);
import  int     os_sleep(char * event);
import  int     os_timeout(void);
import  void    os_wakeup(char * event);

import  void    os_yield(void);

import  char *  parseitem(char ** curcpp, char ** endcpp, char ** valcpp);

#ifdef PACK_DEVICE /* PC PACKET DRIVER INTERFACE */
import  void    pack_pack(void);
import  int     pack_init(netdev * ndp);
import  int     pack_updown(netdev * ndp, u16 flags, char * options);
import  int     pack_ioctl(netdev * ndp, int cmnd, char * addr);
import  int     pack_start(m * mp);
import	void	pack_maint(void);
import	void	pack_bringdown(void);
import	void	packrecv(void * dparam);
#endif

#ifdef PPP_PROTOCOL
import  int     ppp_init(netdev * ndp);
import  int     ppp_updown(netdev * ndp, u16 flags, char * options);
import  st      ppp_scomm(m * mp);
import  int     ppp_linkup( char *devname );
import  int     ppp_linkdown( char *devname );
import  void    ppp_transmit_complete( netdev *ndp );
import  int		ppp_start (m *mp);
#endif

#ifdef DNS_RESOLVER
import void dns_rslv_set_search_list(char **p_parameters);
import int dns_rslv_set_name_servers(char **p_parameters);
import void dns_rslv_sort_list(void);
import int dns_rslv_add_name_server(u32 name_server_ip, int timeout);
import int dns_rslv_delete_name_server(u32 name_server_ip);
u32 *dns_rslv_get_name_servers(void);
/* Used by PPP to set name server addresses */
import void dns_rslv_set_ppp_name_servers(u32 primary, u32 secondary);
#endif

import	int	ping(a32 * host, int datalen, int npackets);
import  pr_t *  pr_lookup(u16 af,  u16 protocol,  u16 type);
import  void    pr_name_cat(char * str);
import  void    prt_cache_entry(RC_EL * p);

/* 3COM Etherlink III 3C509 card */
#ifdef PET9_DEVICE
import int pet9_init(struct netdev * ndp);  /* initialize the board */
import int pet9_updown(struct netdev * ndp, u16 fl, char * opt); /* on line*/
import int pet9_ioctl(struct netdev * ndp, int cmnd, char * addr);
#ifdef USE_TRANSMIT_TASK
import int pet9_xmit_packet(char * hp, int len);
#else
import int pet9_start(m * mp); /* send the packet out over the wire */