home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 15 / CDACTUAL15.iso / cdactual / program / c / WINKERM.ZIP / KERMPROT.H < prev    next >
Encoding:
C/C++ Source or Header  |  1989-07-06  |  8.5 KB  |  234 lines
  1. /*******************************************************************************
  2. **                                                                            **
  3. **                      Kermit for Microsoft Windows                          **
  4. **                      ----------------------------                          **
  5. **                               KERMPROT.H                                   **
  6. **                                                                            **
  7. **  This include file contains the definitions, variables, and function       **
  8. **  prototypes used during a Kermit protocol.                                 **
  9. **                                                                            **
  10. *******************************************************************************/
  11.  
  12. // DEFINITIONS ----------------------------------------------------------------
  13.  
  14. #define MAXSP 1000
  15. #define MAXRP 2000
  16.  
  17. #define MAXTRY 5
  18. #define SP     32
  19.  
  20. #define KERMITSEND 's'
  21. #define KERMITRECEIVE 'v'
  22. #define KERMITSERVER 'x'
  23. #define KERMITGET 'r'
  24. #define KERMITHOST 'c'
  25. #define KERMITGENERIC 'g'
  26.  
  27. /* Macros */
  28. #define tochar(ch) ((ch) + SP)
  29. #define unchar(ch) ((ch) - SP)
  30. #define ctl(ch)    ((ch) ^ 64)
  31.  
  32. // DATA STORAGE DECLARATIONS --------------------------------------------------
  33.  
  34. CLASS char strbuf[500];
  35.  
  36. /* Kermit Protocol Negotiation */
  37. CLASS int spsiz,        /* Send Packet Size */
  38.           rpsiz,        /* Receive Packet Size */
  39.           timint,       /* Timeout Interval (Send Timeout) stimo??? */
  40.           rtimo,        /* Request Timeout (Receive Timeout) */
  41.           spadn,        /* Send Padding (Number of Characters) */
  42.           rpadn,        /* Receive Padding (Number of Characters) */
  43.           bctr,         /* Block Check Type Requested */
  44.           bctu,         /* Block Check Type Used */
  45.           ebq,          /* 8th-bit Quote Prefix */
  46.           ebqflg,       /* 8th-bit Quoting Flag */
  47.           rqf,          /* Request (8th-bit) Quoting Flag */
  48.           rq,           /* Received 8th-bit Quote Bid */
  49.           sq,           /* Sent 8th-bit Quote Bid */
  50.           rpt,          /* Repeat Count */
  51.           rptq,         /* Repeat Quote Prefix */
  52.           rptflg;       /* Repeat Quoting Flag */
  53.  
  54.  
  55. CLASS int capas,        /* Position of Capabilities Mask */
  56.           atcapb,       /* Attribute Capability */
  57.           atcapr,       /*     Requested */
  58.           atcapu,       /*     Used */
  59.           swcapb,       /* Sliding Window Capability */
  60.           swcapr,       /*     Requested */
  61.           swcapu,       /*     Used */
  62.           lpcapb,       /* Long Packet Capability */
  63.           lpcapr,       /*     Requested */
  64.           lpcapu;       /*     Used */
  65.  
  66. CLASS char spadc,       /* Send Pad Character */
  67.            rpadc,       /* Receive Pad Character */
  68.            seol,        /* Send End of Line Character */
  69.            reol,        /* Receive End of Line Character */
  70.            sctlq,       /* Send Control Quote Character */
  71.            rctlq;       /* Receive Control Quote Character */
  72.  
  73. /* Packet Control */
  74. CLASS int seq,          /* Current Packet Sequence Number */
  75.           size,         /* Size of Current Send Packet Data */
  76.           osize,        /* Size of Previous Send Packet Data */
  77.           maxsiz,       /* Maximum Size of Send Packet Data Field */
  78.           rln,          /* Length of Last Packet Received */
  79.           rsn,          /* Sequence Number of Last Packet Received */
  80.           limit,        /* Send Retry Limit */
  81.           sndpkl,       /* Length of Current Send Packet */
  82.           local,        /* TRUE if operator is at console */
  83.           delay;        /* Delay Before Send (in seconds) */
  84.  
  85. CLASS char sndpkt[MAXSP+100],   /* Send Packet */
  86.            rcvpkt[MAXRP+200],   /* Receive Packet */
  87.            *rdatap,             /* Pointer to Receive Packet Data Area */
  88.            data[MAXRP+1],       /* Packet Data Buffer */
  89.            *isp,                /* Input String Pointer */
  90.            *osp,                /* Output String Pointer */
  91.            smark,               /* Send Start of Packet Mark Character */
  92.            rmark,               /* Receive Start of Packet Mark Character */
  93.            ssc,                 /* ??? */
  94.            cmarg[80];           /* ??? */
  95.  
  96. /* File Control */
  97. CLASS char filnam[80];          /* Name of Current File */
  98. CLASS long filsiz;              /* Length of Active File */
  99.  
  100. CLASS int nfils,                /* Number of Files in Send Group */
  101.           cx,                   /* Cancel File Flag */
  102.           cz,                   /* Cancel Batch Flag */
  103.           cr,                   /* Operator Retry Request Flag */
  104.           ce,                   /* Stop Transfer Flag (w/ Error) */
  105.           cc,                   /* Abort Transfer Flag (Immediately) */
  106.           xflag,                /* Data to Screen Flag */
  107.           xpkt;                 /* Flag to Send X Packet */
  108.  
  109. CLASS FILE *ifp;                /* Input File Pointer */
  110. CLASS FILE *ofp;                /* Output File Pointer */
  111.  
  112. /* Flags */
  113. CLASS int server,               /* Server Operation Flag */
  114.           start,                /* Preset Transaction Type */
  115.           first,                /* First Input From File Flag */
  116.           clrinl,               /* Clear Input Line Flag */
  117.           parity,               /* Parity Flag (7 Bit Data) */
  118.           keep;                 /* Keep Incomplete Files Flag */
  119.  
  120. /* Status Display */
  121. typedef struct tagStatsBlk {
  122.     int  Packets;               /* Number of Packets Sent */
  123.     long Bytes;                 /* Number of Bytes Sent/Received */
  124.     int  Retries;               /* Number of Send Retries */
  125. } StatsBlk;
  126.  
  127. CLASS StatsBlk Stats;
  128.  
  129. CLASS HWND hSendList;
  130.  
  131. // MACRO DEFINITIONS ----------------------------------------------------------
  132.  
  133. #define RESUME(x) if (server) { SERVE; } else EndKermit(x)
  134. #define ERR(s) error(s); RESUME(-1)
  135. #define BEGIN(x) state=x
  136. #define SERVE tinit(); server = 1; BEGIN(sserv)
  137.  
  138. // KERMIT PROTOCOL STATES -----------------------------------------------------
  139.  
  140. #define ssfil 01
  141. #define ssdat 02
  142. #define sseot 03
  143. #define ssatr 04
  144. #define ssatx 05
  145.  
  146. #define srini 11
  147. #define srfil 12
  148. #define srdat 13
  149. #define sratt 14
  150.  
  151. #define sipkt 21
  152. #define srgen 22
  153. #define sserv 23
  154. #define ssgen 24
  155.  
  156. // FUNCTIONS PROTOTYPES -------------------------------------------------------
  157.  
  158. /* System Dependent Functions (Physical Layer) */
  159. void ttflui(void);
  160. int ttinl(char *dest, int X, char eol, int timo);
  161. short ttol(char *s, int n);
  162. void tchar(char c);
  163. void tmsg(char *s, ...);
  164. void traw(char *s, int len);
  165.  
  166. /* System Dependent Functions (Presentation Layer) */
  167. int zopeni(char *name);
  168. int zopeno(char *name);
  169. int zclosi(void);
  170. int zcloso(int x);
  171. void zrtol(char *n1, char *n2, int warn);
  172. void zltor(char *n1, char *n2);
  173. int zgetc(void);
  174. int zputc(int c);
  175.  
  176. /* Application Layer */
  177. void message(char *t, char *s);
  178. void ShowRetries(int Retries);
  179. void ShowPackets(int Packets);
  180. void ShowBytes(long Bytes);
  181. void ShowTypeIn(char TypeIn);
  182. void ShowTypeOut(char TypeOut);
  183. BOOL FAR PASCAL StatusDlgProc(HWND hDlg, unsigned message,
  184.                               WORD wParam, LONG lParam);
  185. BOOL FAR PASCAL SendDlgProc(HWND hDlg, unsigned message,
  186.                             WORD wParam, LONG lParam);
  187. BOOL FAR PASCAL ParmDlgProc(HWND hDlg, unsigned message,
  188.                             WORD wParam, LONG lParam);
  189. BOOL StartKermit(int Command);
  190. BOOL EndKermit(int Result);
  191.  
  192. /* Presentation Layer */
  193. int NEAR getpkt(int maxlen);
  194. int NEAR gnchar (void);
  195. void NEAR encode(int a, int next);
  196. int NEAR decode(void);
  197. int NEAR pnchar (int c);
  198. int NEAR encstr(char *s);
  199. void NEAR decstr(char *s);
  200. void NEAR spar(char *s);
  201. char NEAR *rpar(void);
  202. int NEAR sattr(void);
  203. int NEAR rdattr(char *s);
  204. char *NEAR setatt(char *s);
  205.  
  206. /* Session Layer */
  207.  
  208. /* Transport Layer */
  209. int NEAR input(void);
  210. void NEAR nxtpkt (void);
  211. void NEAR tinit(void);
  212. void error(char *s);
  213. int NEAR ack(void);
  214. int NEAR ackl(char *s);
  215. int NEAR nak(void);
  216. int NEAR sinit(char c);
  217. int NEAR sfile(void);
  218. int NEAR sdata(void);
  219. int NEAR seof(char *s);
  220. int NEAR seot(void);
  221. int NEAR gnfile(void);
  222. void NEAR rinit(void);
  223. int NEAR rcvfil(void);
  224. int NEAR closof(void);
  225. int NEAR scmd(char t, char *s);
  226.  
  227. /* Datalink Layer */
  228. int NEAR spack(char type, int n, int len, char *d);
  229. int NEAR resend(void);
  230. int NEAR chk3(char *s);
  231. int NEAR chk1(char *packet);
  232. long NEAR chksum(char *p);
  233. char NEAR rpack (void);
  234.