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