home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / msvp98b1.lzh / MSNTCP.H < prev    next >
Text File  |  1993-05-14  |  15KB  |  460 lines
  1. /* File MSNTCP.H
  2.  * Main include file for TCP/IP, as revised and modified for MS-DOS Kermit.
  3.  *
  4.  * Copyright (C) 1991, University of Waterloo.
  5.  * Copyright (C) 1985, 1992, Trustees of Columbia University in the 
  6.  * City of New York.  Permission is granted to any individual or institution
  7.  * to use this software as long as it is not sold for profit.  This copyright
  8.  * notice must be retained.  This software may not be included in commercial
  9.  * products without written permission of Columbia University.
  10.  *
  11.  * Original version created by Erick Engelke of the University of
  12.  *  Waterloo, Waterloo, Ontario, Canada.
  13.  *       Erick Engelke                Erick@development.watstar.uwaterloo.ca
  14.  *       Faculty of Engineering
  15.  *       University of Waterloo       (519) 885-1211 Ext. 2965
  16.  *       200 University Ave.,
  17.  *       Waterloo, Ont., Canada
  18.  *       N2L 3G1
  19.  * Adapted and modified for MS-DOS Kermit by Joe R. Doupnik, 
  20.  *  Utah State University, jrd@cc.usu.edu, jrd@usu.Bitnet,
  21.  *  and by Frank da Cruz, Columbia University, fdc@watsun.cc.columbia.edu.
  22.  *
  23.  * Name resolution services were adapted from sources made available by
  24.  * the National Centre for Supercomputer Applications (NCSA) and Clarkson
  25.  * University.
  26.  *
  27.  * The C code is designed for the small memory model of Microsoft C versions
  28.  * 5.1 and 6.00A, with structures packed on one byte boundaries. No other
  29.  * options are expected.
  30.  *
  31.  * Last edit:
  32.  * 6 Sept 1991
  33.  */
  34.  
  35. /* Kernel version (major major minor minor) */
  36. #define WTCP_VER 0x0311
  37. #define KERMIT
  38.  
  39. /*
  40.  * Typedefs and constants
  41.  */
  42.  
  43. #ifndef byte
  44. typedef unsigned char byte;
  45. #endif  /* byte */
  46. #ifndef word
  47. typedef unsigned int word;
  48. #endif  /* word */
  49. #ifndef longword
  50. typedef unsigned long longword;
  51. #endif /* longword */
  52.  
  53. /*
  54. #define DEBUG
  55. */
  56.  
  57. #ifndef NULL
  58. #define NULL 0
  59. #endif
  60.  
  61. #define TRUE        1
  62. #define FALSE       0
  63.  
  64. #ifdef KERMIT
  65. #define ETH_MSS 536             /* MSS for Ethernet */
  66. #define tcp_MaxBufSize 1024    /* max bytes to buffer in a tcp socket */
  67. #define udp_MaxBufSize 534    /* max bytes to buffer in a udp socket */
  68. #define MAX_GATE_DATA 2
  69. #define MAX_NAMESERVERS 3
  70. #define MAX_COOKIES 0
  71. #else
  72. #define ETH_MSS 1500            /* MSS for Ethernet */
  73. #define tcp_MaxBufSize 2048    /* maximum bytes to buffer in a socket */
  74. #define udp_MaxBufSize 2048    /* max bytes to buffer in a udp socket */
  75. #define MAX_GATE_DATA 12
  76. #define MAX_NAMESERVERS 10
  77. #define MAX_COOKIES 10
  78. #endif
  79.  
  80. #define MAX_STRING 50    
  81. #define TICKS_SEC 18
  82. #define PD_ETHER 1
  83. #define PD_SLIP  6
  84.  
  85. /* These are Ethernet protocol numbers but are used for other things too */
  86. #define UDP_PROTO  0x11
  87. #define TCP_PROTO  0x06
  88. #define ICMP_PROTO 0x01
  89.  
  90. #define TCP_MODE_BINARY  0       /* default mode */
  91. #define TCP_MODE_ASCII   1
  92. #define TCP_MODE_NAGLE   0       /* Nagle algorithm */
  93. #define TCP_MODE_NONAGLE 4
  94. #define UDP_MODE_CHK     0       /* default to having checksums */
  95. #define UDP_MODE_NOCHK   2       /* turn off checksums */
  96.  
  97. typedef int (*procref)();
  98. typedef byte eth_address[6];
  99.  
  100. /* The Ethernet header */
  101. typedef struct {
  102.     eth_address     destination;
  103.     eth_address     source;
  104.     word            type;
  105. } eth_Header;
  106.  
  107. /* The Internet Header: */
  108. typedef struct {
  109.     byte        hdrlen_ver;        /* both in one byte */
  110.     byte        tos;
  111.     word            length;
  112.     word            identification;
  113.     word            frag;
  114.     byte        ttl;
  115.     byte        proto;
  116.     word            checksum;
  117.     longword        source;
  118.     longword        destination;
  119. } in_Header;
  120.  
  121.  
  122. #define in_GetVersion(ip) ((ip)->hdrlen_ver >> 4)
  123. #define in_GetHdrlen(ip)  ((ip)->hdrlen_ver & 0xf)  /* 32 bit word size */
  124. #define in_GetHdrlenBytes(ip)  (in_GetHdrlen(ip) << 2) /* 8 bit byte size */
  125. #define in_GetTos(ip)      ((ip)->tos)
  126. #define in_GetTTL(ip)      ((ip)->ttl)
  127. #define in_GetProtocol(ip) ((ip)->proto)
  128.  
  129. typedef struct {
  130.     word        srcPort;
  131.     word        dstPort;
  132.     word        length;
  133.     word        checksum;
  134. } udp_Header;
  135.  
  136. #define UDP_LENGTH (sizeof(udp_Header))
  137.  
  138. typedef struct {
  139.     word            srcPort;
  140.     word            dstPort;
  141.     longword        seqnum;
  142.     longword        acknum;
  143.     word            flags;
  144.     word            window;
  145.     word            checksum;
  146.     word            urgentPointer;
  147. } tcp_Header;
  148.  
  149. #define tcp_FlagFIN     0x0001
  150. #define tcp_FlagSYN     0x0002
  151. #define tcp_FlagRST     0x0004
  152. #define tcp_FlagPUSH    0x0008
  153. #define tcp_FlagACK     0x0010
  154. #define tcp_FlagURG     0x0020
  155. #define tcp_FlagDO      0xF000
  156. #define tcp_GetDataOffset(tp) (ntohs((tp)->flags) >> 12)
  157.  
  158. /* The TCP/UDP Pseudo Header */
  159. typedef struct {
  160.     longword    src;
  161.     longword    dst;
  162.     byte        mbz;
  163.     byte        protocol;
  164.     word        length;
  165.     word        checksum;
  166. } tcp_PseudoHeader;
  167.  
  168. /*
  169.  * TCP states, from tcp manual.
  170.  * Note: close-wait state is bypassed by automatically closing a connection
  171.  *       when a FIN is received.  This is easy to undo.
  172.  */
  173. #define tcp_StateLISTEN  0      /* listening for connection */
  174. #define tcp_StateSYNSENT 1      /* syn sent, active open */
  175. #define tcp_StateSYNREC  2      /* syn received, synack+syn sent. */
  176. #define tcp_StateESTAB   3      /* established */
  177. #define tcp_StateFINWT1  4      /* sent FIN */
  178. #define tcp_StateFINWT2  5      /* sent FIN, received FINACK */
  179. #define tcp_StateCLOSWT  6      /* received FIN waiting for close */
  180. #define tcp_StateCLOSING 7      /* sent FIN, recvd FIN (waiting for FINACK) */
  181. #define tcp_StateLASTACK 8      /* fin received, finack+fin sent */
  182. #define tcp_StateTIMEWT  9      /* dally after sending final FINACK */
  183. #define tcp_StateCLOSEMSL 10
  184. #define tcp_StateCLOSED  11     /* finack received */
  185.  
  186. /*
  187.  * UDP socket definition
  188.  */
  189. typedef struct udp_socket {
  190.     struct udp_socket *next;
  191.     word        ip_type;        /* always set to UDP_PROTO */
  192.     byte       *err_msg;        /* null when all is ok */
  193.     void      (*usr_yield)();
  194.     word        soc_mode;            /* a logical OR of bits */
  195.     longword        usertimer;        /* ip_timer_set, ip_timer_timeout */
  196.     procref        dataHandler;
  197.     eth_address     hisethaddr;        /* peer's ethernet address */
  198.     longword        hisaddr;        /* peer's internet address */
  199.     word        hisport;        /* peer's UDP port */
  200.     word        myport;
  201.     int             rdatalen;           /* must be signed */
  202.     byte        rdata[udp_MaxBufSize];
  203. } udp_Socket;
  204.  
  205. /*
  206.  * TCP Socket definition
  207.  */
  208.  
  209. typedef struct tcp_socket {
  210.     struct tcp_socket *next;
  211.     word        ip_type;        /* always set to TCP_PROTO */
  212.     byte        *err_msg;
  213.     void      (*usr_yield)();
  214.     word        soc_mode;        /* a logical OR of bits */
  215.  
  216.     longword        usertimer;        /* ip_timer_set, ip_timer_timeout */
  217.     procref         dataHandler;    /* called with incoming data */
  218.     eth_address     hisethaddr;     /* ethernet address of peer */
  219.     longword        hisaddr;        /* internet address of peer */
  220.     word            hisport;        /* tcp ports for this connection */
  221.     word        myport;
  222.  
  223.     int             rdatalen;       /* must be signed */
  224.     byte        rdata[tcp_MaxBufSize];    /* received data */
  225.     word        rmaxdatalen;    /* normally tcp_MaxBufSize */
  226.     word        state;          /* connection state */
  227.  
  228.     longword        acknum;
  229.     longword        seqnum;         /* data ack'd and sequence num */
  230.     long            timeout;        /* timeout, in milliseconds */
  231.     byte            unhappy;        /* flag, indicates retransmitting segt's */
  232.     word            flags;          /* tcp flags word for last packet sent */
  233.  
  234.     word        window;        /* other guy's window */
  235.     int         datalen;        /* number of bytes of data to send */
  236.                     /* must be signed */
  237.  
  238.     byte        cwindow;        /* Van Jacobson's algorithm */
  239.     byte        wwindow;
  240.  
  241.     word        vj_sa;        /* VJ's alg, standard average */
  242.     word        vj_sd;        /* VJ's alg, standard deviation */
  243.     longword        vj_last;        /* last transmit time */
  244.     word        rto;
  245.     byte        karn_count;        /* count of packets */
  246.  
  247.     /* retransmission timeout proceedure, these are in PC clock ticks */
  248.     longword        rtt_lasttran;       /* last transmission time */
  249.     longword        rtt_smooth;         /* smoothed round trip time */
  250.     longword        rtt_delay;          /* delay for next transmission */
  251.     longword        rtt_time;           /* time of next transmission */
  252.     word            mss;
  253.     byte            data[tcp_MaxBufSize];     /* data to send */
  254. } tcp_Socket;
  255.  
  256. /* sock_type used for socket io */
  257. typedef union {
  258.     udp_Socket udp;
  259.     tcp_Socket tcp;
  260. } sock_type;
  261.  
  262. /* similar to UNIX */
  263. typedef struct sockaddr {
  264.     word        s_type;
  265.     word        s_port;
  266.     longword    s_ip;
  267.     byte        s_spares[6];    /* unused in TCP realm */
  268. };
  269.  
  270. /*
  271.  * ARP definitions
  272.  */
  273. #define arp_TypeEther  0x100        /* ARP type of Ethernet address */
  274.  
  275. /* ARP style op codes */
  276. #define ARP_REQUEST 0x0100
  277. #define ARP_REPLY   0x0200
  278. #define RARP_REQUEST 0x0300        /* RARP request */
  279. #define RARP_REPLY  0x0400        /* RARP reply */
  280.  
  281. /* Arp header */
  282. typedef struct {
  283.     word            hwType;
  284.     word            protType;
  285.     word            hwProtAddrLen;  /* hw and prot addr len */
  286.     word            opcode;
  287.     eth_address     srcEthAddr;
  288.     longword        srcIPAddr;
  289.     eth_address     dstEthAddr;
  290.     longword        dstIPAddr;
  291. } arp_Header;
  292.  
  293. /*
  294.  * socket macros
  295.  */
  296.  
  297. /*
  298.  * sock_wait_established()
  299.  *    - waits then aborts if timeout on s connection
  300.  * sock_wait_input()
  301.  *    - waits for received input on s
  302.  *    - may not be valid input for sock_Gets... check returned length
  303.  * sock_tick()
  304.  *    - do tick and jump on abort
  305.  * sock_wait_closed();
  306.  *    - discards all received data
  307.  *
  308.  * jump to sock_err with contents of *statusptr set to
  309.  *     1 on closed
  310.  *    -1 on timeout
  311.  *
  312.  */
  313. #define sock_wait_established(s, seconds, fn, statusptr) \
  314.     if (ip_delay0(s, seconds, fn, statusptr)) goto sock_err;
  315. #define sock_wait_input(s, seconds, fn , statusptr) \
  316.     if (ip_delay1(s, seconds, fn, statusptr)) goto sock_err;
  317. #define sock_tick(s, statusptr) \
  318.     if (!tcp_tick(s)) { *statusptr = 1 ; goto sock_err; }
  319. #define sock_wait_closed(s, seconds, fn, statusptr)\
  320.     if (ip_delay2(s, seconds, fn, statusptr)) goto sock_err;
  321.  
  322. longword resolve();
  323. int    ping(longword host, longword countnum);
  324. longword chk_ping(longword host, longword *ptr);
  325. int    add_server(int *counter, int max, longword *array, longword value);
  326. byte *    rip(byte *s);
  327. chk_socket(tcp_Socket *s);
  328. byte *    inet_ntoa(byte *s, longword x);
  329. byte *    psocket(tcp_Socket *s);
  330. longword inet_addr(byte *s);
  331. byte *    sockerr(tcp_Socket *s);
  332. byte *    sockstate(tcp_Socket *s);
  333. byte *    getdomainname(byte *name, int length);
  334. byte *    setdomainname(byte *string);
  335.  
  336. sock_init(void);
  337. /* s is a pointer to a udp or tcp socket */
  338. sock_read(void *s, byte *dp, int len);
  339. sock_fastread(void *s, byte *dp, int len);
  340. sock_write(void *s, byte *dp, int len);
  341. sock_fastwrite(void *s, byte *dp, int len);
  342. sock_flush(void *s);
  343. sock_flushnext(void *s);
  344. sock_puts(void *s, byte *dp);
  345. word sock_gets(void *s, byte *dp, int n);
  346. sock_putc(void *s, byte c);
  347. sock_getc(void *s);
  348. word sock_dataready(void *s);
  349. sock_close(void *s);
  350. void sock_abort(void *s);
  351. sock_printf(void *s, byte *format, ...);
  352. sock_scanf(void *s, byte *format, ...);
  353. sock_mode(void *s, word mode);    /* see TCP_MODE_... */
  354. db_write(byte *msg);
  355. dbuginit();
  356.  
  357. /*
  358.  * TCP or UDP specific material, must be used for open's and listens, but
  359.  * sock calls are used for everything else.
  360.  */
  361. int    udp_open(void *s, word lport, longword ina, word port,
  362.         int (*datahandler)());
  363. int    tcp_open(void *s, word lport, longword ina, word port,
  364.         int (*datahandler)());
  365. int    tcp_listen(void *s, word lport, longword ina, word port,
  366.         int (*datahandler)(), word timeout);
  367. int    tcp_established(void *s);
  368.  
  369. /* less general functions */
  370. byte *    rip(byte *s);
  371. longword resolve(byte *name);
  372. int    isaddr(byte *text);
  373. longword intel(longword x);
  374. word    intel16(word x);
  375.  
  376. /* timers */
  377. void    ip_timer_init(void * s, int delayseconds);
  378. int    ip_timer_expired(void * s);
  379. /* tcp_init/tcp_shutdown, init/kill all tcp and lower services.
  380.    Call if sock_init is not used, else not recommended.
  381. */
  382. int    tcp_Init();
  383. void    tcp_shutdown();
  384. int    tcp_abort(tcp_Socket *s);
  385. /* tcp_tick - called periodically by user application in sock_wait.
  386.   returns 0 when our socket closes
  387. */
  388. int    tcp_tick(void *s);
  389. /* tcp_set_debug_state - set 1 or reset 0, development tool */
  390. void    tcp_set_debug_state(word x);
  391.  
  392. int    tcp_cancel(void * ip);
  393. int    udp_cancel(void * ip);
  394.  
  395. longword aton(byte * string);
  396. int    ping(longword host, longword countnum);
  397. longword chk_ping(longword host, longword *ptr);
  398. void    arp_register(longword use, longword instead_of);
  399.  
  400. int    eth_init();
  401. byte *    eth_formatpacket(void *eth_address, word eth_type);
  402. int    eth_send(word len);
  403. void    eth_free(void *buf);
  404. byte *    th_arrived(word *type_ptr);
  405. void    eth_release();
  406. void *    eth_hardware(void * p);
  407.  
  408. /* bsd-similar stuff */
  409.  
  410. int    sock_rbsize(void *s);
  411. int    sock_rbused(void *s);
  412. int    sock_rbleft(void *s);
  413. int    sock_tbsize(void *s);
  414. int    sock_tbused(void *s);
  415. int    sock_tbleft(void *s);
  416. getpeername(tcp_Socket *s, void *dest, int *len);
  417. getsockname(tcp_Socket *s, void *dest, int *len);
  418.  
  419. chk_socket(tcp_Socket *s);
  420. byte *    inet_ntoa(byte *s, longword x);
  421. byte *    psocket(tcp_Socket *s);
  422. byte *    sockerr(tcp_Socket *s);
  423. byte *    sockstate(tcp_Socket *s);
  424. byte *    getdomainname(byte *name, int length);
  425. byte *    setdomainname(byte *string);
  426. byte *    gethostname(byte *name, int length);
  427. byte *    sethostname(byte *string);
  428. longword gethostid();
  429. longword sethostid(longword ip);
  430. word     ntohs(word a);
  431. word     htons(word a);
  432. longword ntohl(longword x);
  433. longword htonl(longword x);
  434. longword realclock(void);
  435. longword inet_addr(byte *s);
  436. void *    movmem(void *, void *, int);
  437.  
  438. void    arp_register(longword use, longword instead_of);
  439. int    arp_resolve(longword ina, void *ethap);
  440. void    arp_init(void);
  441.  
  442. extern    survivebootp;
  443. extern    word pktdevclass;
  444. extern    word mss;
  445. extern    word bootptimeout;
  446. extern    longword bootphost;
  447. extern    word bootpon;
  448. extern    longword my_ip_addr;
  449. extern    eth_address eth_addr;
  450. extern    eth_address eth_brdcast;
  451. extern    longword sin_mask;
  452. extern    word sock_delay;
  453. /*extern byte *def_domain;*/
  454. extern    int last_nameserver;
  455. extern    word debug_on;
  456. extern    longword def_nameservers[MAX_NAMESERVERS];
  457. extern    byte *hostname;
  458. /* user initialization file */
  459. extern    void (*usr_init)();
  460.