WATTCP.H
上传用户:sunrenlu
上传日期:2022-06-13
资源大小:1419k
文件大小:21k
源码类别:

操作系统开发

开发平台:

DOS

  1. #ifndef _wattcp_wattcp_h
  2. #define _wattcp_wattcp_h
  3. /*
  4.  * Are we compiling the kernel?
  5.  *    or an application using the kernel?
  6.  */
  7. #if !defined(__WATTCP_USER__)
  8. #define __WATTCP_KERNEL__
  9. #endif
  10. /*
  11.  * Note that some stuff is not available to user applications.
  12.  *   This is generally detail you shouldn't need to worry about,
  13.  *   and best stay away from to preserve the kernel integrity.
  14.  * Note also that there is a lot of other stuff that should probably
  15.  *   be protected but isn't.
  16.  */
  17. #define WATTCPH
  18. /* these are visible for select.c routine return values */
  19. #define SOCKESTABLISHED 1
  20. #define SOCKDATAREADY   2
  21. #define SOCKCLOSED      4
  22. #if defined(__WATTCP_KERNEL__)
  23. #define IP_TYPE     0x0008
  24. /*
  25. #define DEBUG
  26. */
  27. #include <stdio.h>
  28. #include <elib.h>
  29. #define MAX_GATE_DATA 12
  30. #define MAX_STRING 50 /* most strings are limited */
  31. #endif  /* defined(__WATTCP_KERNEL__) */
  32. #define MAX_NAMESERVERS 10
  33. #define MAX_COOKIES 10
  34. #if defined(__WATTCP_KERNEL__)
  35. #define MAXVJSA     1440 /* 10 s */
  36. #define MAXVJSD     360  /* 10 s */
  37. #define SAFETYTCP  0x538f25a3L
  38. #define SAFETYUDP  0x3e45e154L
  39. #define TRUE        1
  40. #define true        TRUE
  41. #define FALSE       0
  42. #define false       FALSE
  43. #define EL_INUSE        0x0001
  44. #define EL_DELAY        0x0002
  45. #define EL_TCP          0x0004
  46. #define EL_SERVER       0x0008
  47. #define EL_ASCII        0x0010
  48. #define EL_NEVER        0x0020
  49. /* These are Ethernet protocol numbers but I use them for other things too */
  50. #define UDP_PROTO  0x11
  51. #define TCP_PROTO  0x06
  52. #define ICMP_PROTO 0x01
  53. #endif /* defined(__WATTCP_KERNEL__) */
  54. #define TCP_MODE_BINARY  0       /* default mode */
  55. #define TCP_MODE_ASCII   1
  56. #define UDP_MODE_CHK     0       /* default to having checksums */
  57. #define UDP_MODE_NOCHK   2       /* turn off checksums */
  58. #define TCP_MODE_NAGLE   0       /* Nagle algorithm */
  59. #define TCP_MODE_NONAGLE 4
  60. typedef unsigned long longword;     /* 32 bits */
  61. typedef unsigned short word;        /* 16 bits */
  62. typedef unsigned char byte;         /*  8 bits */
  63. typedef struct { byte eaddr[6]; } eth_address;    // 94.11.19 -- made an array
  64. #if defined(__WATTCP_KERNEL__)
  65. /* undesirable */
  66. extern longword MsecClock();
  67. #define clock_ValueRough() MsecClock()
  68. #define TICKS_SEC 18
  69. #define checksum( p, len) inchksum( p, len )
  70. #define PD_ETHER 1
  71. #define PD_SLIP  6
  72. extern word sock_inactive;      /* in pcbootp.c */
  73. extern word _pktdevclass;
  74. extern word _mss;
  75. extern word _bootptimeout; /* in pcbootp.c */
  76. extern longword _bootphost; /* in pcbootp.c */
  77. extern word _bootpon;
  78. /* The Ethernet header */
  79. typedef struct {
  80.     eth_address     destination;
  81.     eth_address     source;
  82.     word            type;
  83. } eth_Header;
  84. /* The Internet Header: */
  85. typedef struct {
  86.     unsigned     hdrlen  : 4;
  87.     unsigned     ver     : 4;
  88.     byte     tos;
  89.     word            length;
  90.     word            identification;
  91.     word            frags;
  92.     byte     ttl;
  93.     byte     proto;
  94.     word            checksum;
  95.     longword        source;
  96.     longword        destination;
  97. } in_Header;
  98. #define in_GetVersion(ip) ( (ip)->ver )
  99. #define in_GetHdrlen(ip)  ( (ip)->hdrlen )  /* 32 bit word size */
  100. #define in_GetHdrlenBytes(ip)  ( in_GetHdrlen(ip) << 2 ) /* 8 bit byte size */
  101. #define in_GetTos(ip)      ( (ip)->tos)
  102. #define in_GetTTL(ip)      ((ip)->ttl)
  103. #define in_GetProtocol(ip) ((ip)->proto )
  104. typedef struct {
  105.     word     srcPort;
  106.     word     dstPort;
  107.     word     length;
  108.     word     checksum;
  109. } udp_Header;
  110. #define UDP_LENGTH ( sizeof( udp_Header ))
  111. typedef struct {
  112.     word            srcPort;
  113.     word            dstPort;
  114.     longword        seqnum;
  115.     longword        acknum;
  116.     word            flags;
  117.     word            window;
  118.     word            checksum;
  119.     word            urgentPointer;
  120. } tcp_Header;
  121. #define tcp_FlagFIN     0x0001
  122. #define tcp_FlagSYN     0x0002
  123. #define tcp_FlagRST     0x0004
  124. #define tcp_FlagPUSH    0x0008
  125. #define tcp_FlagACK     0x0010
  126. #define tcp_FlagURG     0x0020
  127. #define tcp_FlagDO      0xF000
  128. #define tcp_GetDataOffset(tp) (intel16((tp)->flags) >> 12)
  129. #endif /* defined(__WATTCP_KERNEL__) */
  130. /* The TCP/UDP Pseudo Header */
  131. typedef struct {
  132.     longword    src;
  133.     longword    dst;
  134.     byte        mbz;
  135.     byte        protocol;
  136.     word        length;
  137.     word        checksum;
  138. } tcp_PseudoHeader;
  139. /* A datahandler for tcp or udp sockets */
  140. typedef int (*dataHandler_t)( void *s, byte *data, int len, tcp_PseudoHeader *pseudohdr, void *protohdr );
  141. /* A socket function for delay routines */
  142. typedef int (*sockfunct_t)( void *s );
  143. #if defined(__WATTCP_KERNEL__)
  144. /*
  145.  * TCP states, from tcp manual.
  146.  * Note: close-wait state is bypassed by automatically closing a connection
  147.  *       when a FIN is received.  This is easy to undo.
  148.  */
  149. #define tcp_StateLISTEN  0      /* listening for connection */
  150. #define tcp_StateSYNSENT 1      /* syn sent, active open */
  151. #define tcp_StateSYNREC  2      /* syn received, synack+syn sent. */
  152. #define tcp_StateESTAB   3      /* established */
  153. #define tcp_StateESTCL   4      /* established, but will FIN */
  154. #define tcp_StateFINWT1  5      /* sent FIN */
  155. #define tcp_StateFINWT2  6      /* sent FIN, received FINACK */
  156. #define tcp_StateCLOSWT  7      /* received FIN waiting for close */
  157. #define tcp_StateCLOSING 8      /* sent FIN, received FIN (waiting for FINACK) */
  158. #define tcp_StateLASTACK 9      /* fin received, finack+fin sent */
  159. #define tcp_StateTIMEWT  10     /* dally after sending final FINACK */
  160. #define tcp_StateCLOSEMSL 11
  161. #define tcp_StateCLOSED  12     /* finack received */
  162. #define tcp_MaxBufSize 2048         /* maximum bytes to buffer on input */
  163. #endif
  164. #if defined(__WATTCP_KERNEL__)
  165. /*
  166.  * UDP socket definition
  167.  */
  168. typedef struct _udp_socket {
  169.     struct _udp_socket *next;
  170.     word     ip_type; /* always set to UDP_PROTO */
  171.     char    *err_msg; /* null when all is ok */
  172.     char           *usr_name;
  173.     void   (*usr_yield)( void );
  174.     byte            rigid;
  175.     byte            stress;
  176.     word     sock_mode;         /* a logical OR of bits */
  177.     longword     usertimer; /* ip_timer_set, ip_timer_timeout */
  178.     dataHandler_t  dataHandler;
  179.     eth_address     hisethaddr; /* peer's ethernet address */
  180.     longword        hisaddr; /* peer's internet address */
  181.     word     hisport; /* peer's UDP port */
  182.     longword        myaddr;
  183.     word     myport;
  184.     word            locflags;
  185.     int             queuelen;
  186.     byte           *queue;
  187.     int             rdatalen;           /* must be signed */
  188.     word            maxrdatalen;
  189.     byte           *rdata;
  190.     byte            rddata[ tcp_MaxBufSize + 1];         /* if dataHandler = 0, len == 512 */
  191.     longword        safetysig;
  192. } udp_Socket;
  193. #else /* __WATTCP_USER */
  194. /*
  195.  * Don't give users access to the fields.
  196.  */
  197. typedef struct {
  198.     byte undoc[ 2200 ];
  199. } udp_Socket;
  200. #endif /* __WATTCP_USER__ */
  201. #if defined(__WATTCP_KERNEL__)
  202. /*
  203.  * TCP Socket definition
  204.  */
  205. typedef struct _tcp_socket {
  206.     struct _tcp_socket *next;
  207.     word     ip_type;     /* always set to TCP_PROTO */
  208.     char     *err_msg;
  209.     char           *usr_name;
  210.     void          (*usr_yield)(void);
  211.     byte            rigid;
  212.     byte            stress;
  213.     word     sock_mode;     /* a logical OR of bits */
  214.     longword     usertimer;     /* ip_timer_set, ip_timer_timeout */
  215.     dataHandler_t   dataHandler;    /* called with incoming data */
  216.     eth_address     hisethaddr;     /* ethernet address of peer */
  217.     longword        hisaddr;        /* internet address of peer */
  218.     word            hisport;     /* tcp ports for this connection */
  219.     longword        myaddr;
  220.     word     myport;
  221.     word            locflags;
  222.     int             queuelen;
  223.     byte           *queue;
  224.     int             rdatalen;       /* must be signed */
  225.     word            maxrdatalen;
  226.     byte           *rdata;
  227.     byte            rddata[tcp_MaxBufSize+1];    /* received data */
  228.     longword        safetysig;
  229.     word     state;          /* connection state */
  230.     longword        acknum;
  231.     longword     seqnum;      /* data ack'd and sequence num */
  232.     long            timeout;        /* timeout, in milliseconds */
  233.     byte            unhappy;        /* flag, indicates retransmitting segt's */
  234.     byte            recent;         /* 1 if recently transmitted */
  235.     word            flags;          /* tcp flags word for last packet sent */
  236.     word     window;     /* other guy's window */
  237.     int      datalen;        /* number of bytes of data to send */
  238.     /* must be signed */
  239.     int             unacked;        /* unacked data */
  240.     byte     cwindow;     /* Van Jacobson's algorithm */
  241.     byte     wwindow;
  242.     word     vj_sa;     /* VJ's alg, standard average */
  243.     word     vj_sd;     /* VJ's alg, standard deviation */
  244.     longword     vj_last;     /* last transmit time */
  245.     word     rto;
  246.     byte     karn_count;     /* count of packets */
  247.     byte            tos;            /* priority */
  248.     /* retransmission timeout proceedure */
  249.     /* these are in clock ticks */
  250.     longword        rtt_lasttran;       /* last transmission time */
  251.     longword        rtt_smooth;         /* smoothed round trip time */
  252.     longword        rtt_delay;          /* delay for next transmission */
  253.     longword        rtt_time;           /* time of next transmission */
  254.     word            mss;
  255.     longword        inactive_to;           /* for the inactive flag */
  256.     int             sock_delay;
  257.     byte            gotflush;              /* received Flush on last packet */
  258.     byte            data[tcp_MaxBufSize+1]; /* data to send */
  259.     longword        datatimer;          /* EE 99.08.23 note broken connections */
  260.     longword     frag[2]; /* S. Lawson - handle one dropped segment */
  261. } tcp_Socket;
  262. #else /* __WATTCP_USER */
  263. /*
  264.  * Don't give users access to the fields.
  265.  */
  266. typedef struct {
  267.     byte undoc[ 4300 ];
  268. } tcp_Socket;
  269. #endif /* __WATTCP_USER__ */
  270. #if defined(__WATTCP_KERNEL__)
  271. /* sock_type used for socket io */
  272. typedef union {
  273.     udp_Socket udp;
  274.     tcp_Socket tcp;
  275. } sock_type;
  276. #else /* __WATTCP_USER__ */
  277. typedef void sock_type;
  278. #endif /* __WATTCP_USER__ */
  279. /* similar to UNIX */
  280. typedef struct sockaddr {
  281.     word        s_type;
  282.     word        s_port;
  283.     longword    s_ip;
  284.     byte        s_spares[6];    /* unused in TCP realm */
  285. } sockaddr;
  286. #define sockaddr_in sockaddr
  287.         /*
  288.          * TCP/IP system variables - do not change these since they
  289.          *      are not necessarily the source variables, instead use
  290.          *      ip_Init function
  291.          */
  292. extern longword my_ip_addr;
  293. extern longword sin_mask;       /* eg.  0xfffffe00L */
  294. extern word sock_delay;
  295. extern word sock_data_timeout;  /* EE 99.08.23 */
  296. #if defined(__WATTCP_KERNEL__)
  297. extern eth_address _eth_addr;
  298. extern eth_address _eth_brdcast;
  299. #endif
  300. #if defined(__WATTCP_KERNEL__)
  301. /*
  302.  * ARP definitions
  303.  */
  304. #define arp_TypeEther  0x100 /* ARP type of Ethernet address */
  305. /* arp op codes */
  306. #define ARP_REQUEST 0x0100
  307. #define ARP_REPLY   0x0200
  308. /*
  309.  * Arp header
  310.  */
  311. typedef struct {
  312.     word            hwType;
  313.     word            protType;
  314.     word            hwProtAddrLen;  // hw and prot addr len
  315.     word            opcode;
  316.     eth_address     srcEthAddr;
  317.     longword        srcIPAddr;
  318.     eth_address     dstEthAddr;
  319.     longword        dstIPAddr;
  320. } arp_Header;
  321. #if !defined(ETH_MSS)   // S. Lawson - allow setting in makefile
  322. #define ETH_MSS 1500  // MSS for Ethernet
  323. #endif                  // S. Lawson
  324. byte *fragment( in_Header * ip );
  325. void timeout_frags( void );
  326. #endif
  327. /*
  328.  * Ethernet interface -- pcsed.c
  329.  */
  330. int  _eth_init( void ); // S. Lawson
  331. byte *_eth_formatpacket( eth_address *eth_dest, word eth_type );
  332. int   _eth_send( word len );
  333. void  _eth_free( void *buf );
  334. byte *_eth_arrived( word *type_ptr );
  335. void  _eth_release( void );
  336. #if defined(__WATTCP_KERNEL__)
  337. extern void *_eth_hardware( byte *p );
  338. #endif
  339. /*
  340.  * timers -- pctcp.c
  341.  */
  342. void ip_timer_init( sock_type *s, int delayseconds );
  343. int ip_timer_expired( sock_type *s );
  344. longword MsecClock( void );
  345. /*
  346.  * sock_init()  -- initialize wattcp libraries -- sock_ini.c
  347.  */
  348. void sock_init(void);
  349. int sock_init_noexit(void);     // S. Lawson
  350. void sock_exit( void );   /* normally called via atexit() in sock_init() */
  351.         /*
  352.          * tcp_init/tcp_shutdown -- pctcp.c
  353.          *      - init/kill all tcp and lower services
  354.          *      - only call if you do not use sock_init
  355.          * (NOT RECOMMENDED)
  356.          */
  357. void tcp_shutdown(void);
  358. int tcp_init_noexit(void);      // S. Lawson
  359. void tcp_init(void);
  360. void tcp_set_ports(word tcp_base, word udp_base); // S. Lawson
  361. void tcp_get_ports(word *tcp_base, word *udp_base); // S. Lawson
  362. /*
  363.  * things you probably won't need to know about
  364.  */
  365. /*
  366.  * sock_debugdump -- sock_dbu.c
  367.  * - dump some socket control block parameters
  368.  * used for testing the kernal, not recommended
  369.  */
  370. void sock_debugdump( sock_type *s );
  371.         /*
  372.          * tcp_config - read a configuration file
  373.          *            - if special path desired, call after sock_init()
  374.          *            - null reads path from executable
  375.          * see sock_init();
  376.          */
  377. int tcp_config( char *path );
  378. /* S. Lawson
  379.  * tcp_config_file - sets the configuration filename
  380.  *                 - null silently skips config file processing
  381.  */
  382. void tcp_config_file( const char *fname );
  383. /*
  384.          * tcp_tick - called periodically by user application in sock_wait_...
  385.          *          - returns 1 when our socket closes
  386.          */
  387. int tcp_tick( sock_type *s );
  388.         /*
  389.          * Retransmitter - called periodically to perform tcp retransmissions
  390.          *          - normally called from tcp_tick, you have to be pretty
  391.          *            low down to use this one
  392.          */
  393. void tcp_Retransmitter(void);
  394.         /*
  395.          * tcp_set_debug_state - set 1 or reset 0 - depends on what I have done
  396.          */
  397. void tcp_set_debug_state( int x );
  398. /*
  399.  * check for bugs -- pctcp.c
  400.  */
  401. int tcp_checkfor( sock_type *t );
  402. /*
  403.  * Timeout routines.
  404.  */
  405. unsigned long set_timeout( unsigned int seconds );
  406. unsigned long set_ttimeout( unsigned int ticks );
  407. int chk_timeout( unsigned long timeout );
  408. /*
  409.  * socket macros
  410.  */
  411. /*
  412.  * sock_wait_established()
  413.  * - waits then aborts if timeout on s connection
  414.  * sock_wait_input()
  415.  * - waits for received input on s
  416.  * - may not be valid input for sock_gets... check returned length
  417.  * sock_tick()
  418.  * - do tick and jump on abort
  419.  * sock_wait_closed();
  420.  * - discards all received data
  421.  *
  422.  * jump to sock_err with contents of *statusptr set to
  423.  *  1 on closed
  424.  * -1 on timeout
  425.  *
  426.  */
  427. int _ip_delay0( sock_type *s, int timeoutseconds, sockfunct_t fn, int *statusptr );
  428. int _ip_delay1( sock_type *s, int timeoutseconds, sockfunct_t fn, int *statusptr);
  429. int _ip_delay2( sock_type *s, int timeoutseconds, sockfunct_t fn, int *statusptr);
  430. #if defined(__WATTCP_KERNEL__)
  431. #define set_mstimeout( x ) (set_timeout(0)+ (x / 55))
  432. #endif  /* defined(__WATTCP_KERNEL__) */
  433. #define sock_wait_established( s, seconds, fn, statusptr ) 
  434.     if (_ip_delay0( s, seconds, fn, statusptr )) goto sock_err;
  435. #define sock_wait_input( s, seconds, fn , statusptr ) 
  436.     if (_ip_delay1( s, seconds, fn, statusptr )) goto sock_err;
  437. #define sock_tick( s, statusptr ) 
  438.     if ( !tcp_tick(s)) { *statusptr = 1 ; goto sock_err; }
  439. #define sock_wait_closed(s, seconds, fn, statusptr )
  440.     if (_ip_delay2( s, seconds, fn, statusptr )) goto sock_err;
  441. /*
  442.  * TCP or UDP specific stuff, must be used for open's and listens, but
  443.  * sock stuff is used for everything else -- pctcp.c
  444.  */
  445. int tcp_open( tcp_Socket *s, word lport, longword ina, word port, dataHandler_t datahandler );
  446. int udp_open( udp_Socket *s, word lport, longword ina, word port, dataHandler_t datahandler );
  447. int tcp_listen( tcp_Socket *s, word lport, longword ina, word port, dataHandler_t datahandler, word timeout );
  448. int tcp_established( tcp_Socket *s );
  449. /*
  450.  * Clean up a string -- pctcp.c
  451.  */
  452. char *rip( char *s);
  453. /*
  454.  * Name service / name lookup routines -- udp_dom.c
  455.  */
  456. longword resolve( char *name );
  457. longword resolve_fn( char *name, sockfunct_t fn );     // S. Lawson
  458. int reverse_addr_lookup( longword ipaddr, char *name );
  459. int reverse_addr_lookup_fn( longword ipaddr, char *name, sockfunct_t fn );  // S. Lawson
  460. /*
  461.  * less general functions
  462.  */
  463. longword intel( longword x );
  464. word intel16( word x );
  465. longword MsecClock( void );
  466. /*
  467.  * Ctrl-break handling -- pc_cbrk.c
  468.  */
  469. void tcp_cbrk( int mode );
  470. void outs( char far * string );
  471. #if defined(__WATTCP_KERNEL__)
  472. /* icmp handler -- pcicmp.c */
  473. int icmp_handler( in_Header *ip );
  474. void icmp_Unreach( in_Header *ip); // S. Lawson
  475. #endif
  476. /*
  477.  * ARP -- pcarp.c
  478.  */
  479. #if defined(__WATTCP_KERNEL__)
  480. void _arp_add_gateway( char *data, longword ip );
  481. int _arp_handler( arp_Header *in );
  482. #endif
  483. void _arp_register( longword use, longword instead_of );
  484. void _arp_tick( longword ip );      /* kernel only? */
  485. int _arp_resolve( longword ina, eth_address *ethap, int nowait );
  486. /*
  487.  * Packet -- pcpkt.c
  488.  *
  489.  * These probably shouldn't be visible to user app code.
  490.  */
  491. eth_address *_pkt_eth_init( void );
  492. int pkt_send( char *buffer, int length );
  493. void pkt_buf_wipe( void );
  494. void pkt_buf_release( char *ptr );
  495. void * pkt_received( void );
  496. void pkt_release( void );
  497. #if defined(__WATTCP_KERNEL__)
  498. void _add_server( int *counter, int max, longword *array, longword value );
  499. extern word debug_on;
  500. #endif
  501. /*
  502.  * pcbsd.c
  503.  */
  504. int _chk_socket( sock_type *s );
  505. char *inet_ntoa( char *s, longword x );
  506. longword inet_addr( char *s );
  507. char *sockerr( sock_type *s );
  508. char *sockstate( sock_type *s );
  509. longword gethostid( void );
  510. longword sethostid( longword ip );
  511. word ntohs( word a );
  512. word htons( word a );
  513. longword ntohl( longword x );
  514. longword htonl( longword x );
  515. #if defined(__WATTCP_KERNEL__)
  516. void *_tcp_lookup( longword hisip, word hisport, word myport );
  517. void _tcp_cancel( in_Header *ip, int code, char *msg, longword dummyip );
  518. void _udp_cancel( in_Header *ip );
  519. int _dobootp(void);
  520. #endif
  521. /*
  522.  * General socket I/O -- pctcp.c
  523.  */
  524. word sock_mode( sock_type *, word);        /* see TCP_MODE_... */
  525. void sock_abort( sock_type *);
  526. void tcp_sendsoon( tcp_Socket *s );
  527. int sock_fastwrite( sock_type *, byte *, int );
  528. int sock_write( sock_type *, byte *, int );
  529. int sock_read( sock_type *, byte *, int );
  530. int sock_fastread( sock_type *, byte *, int );
  531. int sock_gets( sock_type *, byte *, int );
  532. void sock_close( sock_type *s );
  533. byte sock_putc( sock_type  *s, byte c );
  534. int sock_getc( sock_type  *s );
  535. int sock_puts( sock_type  *s, byte *dp );
  536. int sock_gets(sock_type *, byte *, int );
  537. int sock_setbuf( sock_type *s, byte *dp, int len );
  538. int sock_yield( tcp_Socket *s, void (*fn)( void ) );
  539. /*
  540.  *   s is the pointer to a udp or tcp socket
  541.  */
  542. /*
  543.  * Socket text output/input routines -- sock_prn.c
  544.  */
  545. int sock_printf( sock_type  *s, char *format, ... );
  546. int sock_scanf( sock_type  *s, char *format, ... );
  547. /*
  548.  * Misc. socket I/O -- pctcp.c
  549.  */
  550. int sock_setbuf( sock_type *s, byte *dp, int len );
  551. int sock_enqueue( sock_type  *s, byte *dp, int len );
  552. void sock_noflush( sock_type *s );
  553. void sock_flush( sock_type  *s );
  554. void sock_flushnext( sock_type  *s);
  555. int sock_dataready( sock_type  *s );
  556. int sock_established( sock_type *s );
  557. void sock_sturdy( sock_type *s, int level );
  558. /*
  559.  * Debug output -- pcdbug.c
  560.  */
  561. void db_write( char *msg );
  562. void db_open( void );
  563. void db_close( void );
  564. void dbug_printf( char *, ... );
  565. void dbug_init( void );
  566. void dbug_init( void );
  567. /*
  568.  * Socket Select -- select.c
  569.  */
  570. int sock_sselect( sock_type *s, int waitstate );
  571. /*
  572.  * recv routines -- pcrecv.c
  573.  */
  574. int sock_recv_init( sock_type *s, void *space, word len );
  575. int sock_recv_from( sock_type *s, long *hisip, word *hisport, char *buffer, int len, word flags );
  576. int sock_recv( sock_type *s, char *buffer, int len, word flags );
  577. /*
  578.  * bsd-similar stuff -- pcbuf.c
  579.  */
  580. int sock_rbsize( sock_type *s );
  581. int sock_rbused( sock_type *s );
  582. int sock_rbleft( sock_type *s );
  583. int sock_tbsize( sock_type *s );
  584. int sock_tbused( sock_type *s );
  585. int sock_tbleft( sock_type *s );
  586. int sock_preread( sock_type *s, byte *dp, int len );
  587. /*
  588.  * Name conversion stuff -- udp_nds.c
  589.  */
  590. longword aton( char *text );
  591. int isaddr( char *text );
  592. /*
  593.  * Configuration -- pcconfig.c
  594.  */
  595. char *_inet_atoeth( char *src, byte *eth );
  596. void _add_server( int *counter, int max, longword *array, longword value );
  597. int tcp_config( char *path );
  598.         /*
  599.          * name domain constants
  600.          */
  601. extern char *def_domain;
  602. extern longword def_nameservers[ MAX_NAMESERVERS ];
  603. extern word wathndlcbrk;
  604. extern word watcbroke;
  605. /* user initialization file */
  606. extern void (*usr_init)(char *name, char *value);
  607. extern void (*usr_post_init)();
  608. extern int _survivebootp;
  609. extern int _last_cookie;
  610. extern longword _cookie[MAX_COOKIES];
  611. extern int _last_nameserver;
  612. extern char *_hostname;
  613. /*
  614.  * Elib stuff
  615.  */
  616. int isstring( char *string, unsigned stringlen );     /* isstring.c */
  617.  
  618. #endif /* ndef _wattcp_wattcp_h */