![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to modem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os2sdk / demos / apps / terminal|
Return to modem.c CVS log | Up to [OS/2 SDKs] / os2sdk / demos / apps / terminal |
1.1 root 1: /*** modem.c
2: *
3: * TITLE
4: *
5: * modem.c
6: * Copyright (C) Microsoft Corporation 1987
7: * March 1987
8: *
9: * DESCRIPTION
10: *
11: * This module contains routines that support Hayes compatible modem.
12: *
13: ***/
14:
15: #include <stdio.h>
16: #include <doscalls.h>
17: #include <subcalls.h>
18: #include <malloc.h>
19: #include <string.h>
20: #include <memory.h>
21: #include <conio.h>
22: #include "term.h"
23:
24: #define min(a,b) (((a)<(b)) ? (a):(b)) /* This is pulled out of the old */
25: /* v2tov3.h (c v2.0) header file */
26:
27: extern char *ErrMsg[];
28: extern unsigned FileHndl;
29:
30: make_dial_cmd(char *, int);
31: void flush_ques(int);
32: void clr_com_error(void);
33: void com_clr_flush(void);
34:
35: static char Init[] = {'A', 'T', 'V', '0', 0x0d};
36: static char Attn[] = {'A', 'T', 0x0d};
37: static char Esc[] = {'+', '+', '+'};
38: static char OnHook[] = {'A', 'T', 'H', '0', 0X0d};
39: static char OffHook[] = {'A', 'T', 'H', '1', 0x0d};
40: static char Reset[] = {'A', 'T', 'Z', 0x0d};
41:
42: struct s_Cmd{
43: char *pCmd;
44: int CmdLen;
45: } Cmds[] = {
46: {Init, sizeof(Init)}, /* Initialize modem */
47: {Attn, sizeof(Attn)}, /* Attention cmd */
48: {Esc, sizeof(Esc)}, /* Modem escape sequence*/
49: {OnHook, sizeof(OnHook)}, /* Put phone on hook */
50: {OffHook, sizeof(OffHook)}, /* Take phone off hook */
51: {Reset, sizeof(Reset)} /* Reset command */
52: };
53:
54:
55:
56: /*** make_modem_conn - make modem connection
57: *
58: * This routine tries to setup the modem connection, retrying if
59: * appropriate.
60: *
61: * make_modem_conn()
62: *
63: * ENTRY
64: *
65: * EXIT
66: * TRUE if modem connection was made
67: * FALSE if modem connection did not go through
68: *
69: * WARNING
70: *
71: * EFFECTS
72: *
73: ***/
74:
75: make_modem_conn()
76: {
77: unsigned NumBytes, /* number of bytes to be written */
78: RetCode, /* return code from system calls */
79: Result = FALSE; /* to be returned by this routine */
80: char OutBuffer,
81: ModemRetry = TRUE, /* retry for modem connection */
82: NumRetries = 0; /* no. times connection retried */
83:
84: printf("trying modem connection...\n");
85:
86: while (ModemRetry)
87: switch (setup_modem_conn()) {
88: case MS_CONNECT :
89: case MS_CONNECT1200:
90: Result = TRUE;
91: ModemRetry = FALSE;
92: OutBuffer = '\r';
93: if ((RetCode = DOSWRITE(FileHndl, &OutBuffer, 1,
94: &NumBytes)) != 0)
95: error(ERR_DOSWRITE, RetCode);
96: break;
97: case MS_NOCARRIER :
98: case MS_NODIALTONE :
99: if (++NumRetries > NUM_RETRY) {
100: printf("modem connection failed\n");
101: ModemRetry = FALSE;
102: }
103: else
104: printf("modem connection failed; retrying...\n");
105: break;
106: case MS_NOREPLY :
107: case MS_ERROR :
108: case OT_FAILURE : /* OTher failure */
109: case MS_BUSY :
110: default :
111: ModemRetry = FALSE;
112: printf("modem connection failed\n");
113: break;
114: } /* switch (setup_modem_conn()) */
115:
116: return(Result);
117:
118: }
119:
120:
121:
122:
123: /*** setup_modem_conn - setup modem connection
124: *
125: * This is the helper routine for the make_modem_conn(). It initialises
126: * the modem connection and sends out the dial command to the modem.
127: *
128: * setup_modem_conn()
129: *
130: * ENTRY
131: *
132: * EXIT
133: * returns one of the following: MS_CONNECT MS_CONNECT1200
134: * MS_NOCARRIER MS_NODIALTONE MS_NOREPLY MS_ERROR MS_BUSY
135: * OT_FAILURE
136: *
137: * WARNING
138: *
139: * EFFECTS
140: *
141: ***/
142:
143: int setup_modem_conn()
144: {
145: int Result = OT_FAILURE;
146:
147: /* initialise modem connection */
148: if (!(send_modem_cmd(MC_INIT)))
149: return(Result);
150: if (get_modem_reply() != MS_OK)
151: return(Result);
152: DOSSLEEP((long) 100);
153:
154: /* write AT string to the modem. This will cause the modem to
155: * determine the communications rate of the terminal as well
156: * as its parity setting.
157: */
158: if (!(send_modem_cmd(MC_ATTN)))
159: return(Result);
160: if (get_modem_reply() != MS_OK)
161: return(Result);
162: DOSSLEEP((long) 100);
163:
164: /* send DIAL command to the modem */
165: if (!(send_modem_cmd(MC_DIAL)))
166: return(Result);
167:
168: return(get_modem_reply());
169: };
170:
171:
172:
173:
174: /*** send_modem_cmd - send a command to modem
175: *
176: * This routine sends a command to the modem and ensures that the echo
177: * from the modem matches the input command.
178: *
179: * send_modem_cmd(CmdType)
180: *
181: * ENTRY
182: * CmdType - type of modem command: MC_INIT MC_ATTN MC_ESC
183: * MC_ONHOOK MC_OFFHOOK MC_RESET MC_DIAL
184: *
185: * EXIT
186: * TRUE if command was sent succesfully
187: * FALSE if command failed
188: *
189: * WARNING
190: *
191: * EFFECTS
192: *
193: ***/
194:
195: send_modem_cmd(CmdType)
196: int CmdType; /* The command to send */
197: {
198: int Result = TRUE,
199: ReadCnt,
200: WriteCnt,
201: CmdLen,
202: RetCode;
203: char Buf[80],
204: Cmd[80],
205: *pDst,
206: *pCmd;
207:
208:
209: /* clear COM error and flush transmit/receive queues */
210: com_clr_flush();
211:
212: if (CmdType == MC_INIT) {
213: send_modem_cmd(MC_RESET); /* modem command: ATZ */
214: /* clear COM error and flush transmit/receive queues */
215: com_clr_flush();
216: };
217:
218: /* set pCmd -> command string; CmdLen = length of command string */
219: if (CmdType == MC_DIAL) {
220: CmdLen = make_dial_cmd(Cmd, sizeof(Cmd));
221: pCmd = Cmd;
222: }
223: else {
224: pCmd = Cmds[CmdType].pCmd;
225: CmdLen = Cmds[CmdType].CmdLen;
226: };
227:
228: /* write the command out to the modem */
229: if (((RetCode = DOSWRITE(FileHndl, pCmd, CmdLen, &WriteCnt)) != 0)
230: || (WriteCnt != CmdLen))
231: return(FALSE);
232:
233: /* wait for the echo & wait for the command to clear */
234: DOSSLEEP((long) 250);
235: if (CmdType == MC_DIAL || CmdType == MC_RESET)
236: DOSSLEEP((long) 750);
237:
238: /* read back the echo from the modem & check if it matches the input */
239: RetCode =
240: DOSREAD(FileHndl, Buf, min(WriteCnt, sizeof(Buf)), &ReadCnt);
241: if ((RetCode != 0) || (ReadCnt != WriteCnt))
242: Result = FALSE;
243: else {
244: pDst = Buf;
245: while (--ReadCnt >= 0) {
246: if (*pDst++ != *pCmd++) {
247: printf("send_modem_cmd: error in echo of modem input\n");
248: Result = FALSE;
249: break;
250: }
251: } /* while (--ReadCnt >= 0) */
252: }
253:
254: return(Result);
255: }
256:
257:
258:
259:
260: /*** make_dial_cmd - create a modem command for dialing
261: *
262: * builds the dial command string and returns its length in bytes
263: *
264: * make_dial_cmd(pBuf, BufLen)
265: *
266: * ENTRY
267: * pBuf - ptr to buffer
268: * BufLen - length of buffer in bytes
269: *
270: * EXIT
271: * pBuf -> dial command string
272: * make_dial_cmd = length of dial command string in bytes
273: *
274: * WARNING
275: *
276: * EFFECTS
277: *
278: ***/
279:
280: make_dial_cmd(pBuf, BufLen)
281: char *pBuf;
282: int BufLen;
283: {
284: char *pSrc,
285: *pDst,
286: Ch,
287: Cmd[80], /* allocate a huge command buffer */
288: *bin_to_dec();
289: int Len;
290: structModemOptions sModemOptions; /* modem options */
291:
292: get_modem_options(&sModemOptions);
293: pDst = Cmd;
294: *pDst++ = 'A'; /* get Modem's attention */
295: *pDst++ = 'T';
296: *pDst++ = 'S'; /* set R6 for wait for dial tone */
297: *pDst++ = '6';
298: *pDst++ = '=';
299: pDst = bin_to_dec(pDst, sModemOptions.iWaitTone);
300: *pDst++ = B_PAUSE;
301: *pDst++ = 'S'; /* set R7 for wait for carrier time */
302: *pDst++ = '7';
303: *pDst++ = '=';
304: pDst = bin_to_dec(pDst, sModemOptions.iWaitCarrier);
305: *pDst++ = B_PAUSE;
306: *pDst++ = 'D';
307: *pDst++ = (sModemOptions.chDialType == PULSE) ? 'P' : 'T';
308: pSrc = sModemOptions.pPhoneNumber;
309: while (Ch = *pSrc++)
310: if ((Ch >= '0' && Ch <= '9') || (Ch == ','))
311: *pDst++ = Ch;
312: *pDst++ = 0x0d;
313: *pDst = 0;
314:
315: /* copy the command string into caller's buffer */
316: pSrc = Cmd;
317: pDst = pBuf;
318: for (Len = 0; Len <= BufLen; ++Len)
319: if (*pSrc==0)
320: break;
321: else
322: *pDst++ = *pSrc++;
323: return(Len);
324: }
325:
326:
327:
328:
329: /*** bin_to_dec - convert a binary number to ASCII decimal
330: *
331: * bin_to_dec(pDst, i)
332: *
333: * ENTRY
334: * pDst -> buffer to place the ASCII decimal
335: * i = integer to be converted to ASCII decimal
336: *
337: * EXIT
338: * ASCII decimal placed in the buffer pointed by pDst
339: * bin_to_dec -> byte next to ASCII decimal in the buffer
340: *
341: * WARNING
342: *
343: * EFFECTS
344: *
345: ***/
346:
347: char *bin_to_dec(pDst, i)
348: char *pDst;
349: int i;
350: {
351: if (i > 10)
352: pDst = bin_to_dec (pDst, i/10);
353: *pDst++ = '0' + (i % 10);
354: return(pDst);
355: }
356:
357:
358:
359:
360: /*** get_modem_reply - get reply from modem
361: *
362: * get_modem_reply()
363: *
364: * ENTRY
365: *
366: * EXIT
367: * get_modem_reply = MS_CONNECT MS_CONNECT1200 MS_NOCARRIER
368: * MS_NODIALTONE MS_NOREPLY MS_ERROR MS_BUSY
369: *
370: * WARNING
371: *
372: * EFFECTS
373: *
374: ***/
375:
376: int get_modem_reply()
377: {
378: char Ch;
379: int Cnt,
380: Result,
381: RetCode;
382:
383: do /* skip CR, LF and get resultcode */
384: if ((RetCode = DOSREAD(FileHndl, &Ch, 1, &Cnt)) != 0)
385: Error(ERR_DOSREAD, RetCode);
386: while ((Cnt == 1) && ((Ch == 0x0d) || (Ch == 0x0a)));
387:
388: switch(Cnt) {
389: case 0: Result = MS_NOREPLY;
390: break;
391: case 1: if ((Ch >= '0') && (Ch <= '7'))
392: Result = Ch - '0';
393: else
394: Result = MS_ERROR;
395: break;
396: default: Result = MS_ERROR;
397: break;
398: }
399:
400: return(Result);
401: }
402:
403:
404:
405:
406: /*** discon_modem - disconnect the modem
407: *
408: * discon_modem()
409: *
410: * ENTRY
411: *
412: * EXIT
413: * modem disconnected
414: *
415: * WARNING
416: *
417: * EFFECTS
418: *
419: ***/
420:
421: void discon_modem()
422: {
423: /* Wait for the last command to clear, then be quiet for 1.5 seconds */
424: DOSSLEEP((long) 1000); /* wait 1. second */
425: flush_ques(FLUSHOUTPUT); /* flush the transmit que */
426: DOSSLEEP((long) 1500); /* wait 1.5 seconds */
427:
428: send_modem_cmd(MC_ESC); /* put modem in command mode */
429: DOSSLEEP((long) 2000); /* wait 2 seconds */
430:
431: send_modem_cmd(MC_ONHOOK); /* place phone back on hook */
432: DOSSLEEP((long) 200); /* wait for command to clear*/
433: }
434:
435:
436:
437:
438: /*** com_clr_flush - clear COM error and flush transmit/receive queues
439: *
440: * com_clr_flush()
441: *
442: * ENTRY
443: *
444: * EXIT
445: * com error cleared
446: * transmit and receive queues of com port flushed out
447: *
448: * WARNING
449: *
450: * EFFECTS
451: *
452: ***/
453:
454: void com_clr_flush()
455: {
456: /* retrieve and clear the com error information */
457: clr_com_error();
458: /* flush transmit and receive queues */
459: flush_ques(FLUSHINPUT);
460: flush_ques(FLUSHOUTPUT);
461: }
462:
463:
464:
465:
466: /*** flush_ques - flush COM transmit/receive queue
467: *
468: * flush_ques(FuncId)
469: *
470: * ENTRY
471: * FuncId - set to one of: FLUSHINPUT FLUSHOUTPUT
472: *
473: * EXIT
474: * transmit or receive queue of com port flushed
475: *
476: * WARNING
477: *
478: * EFFECTS
479: *
480: ***/
481:
482: void flush_ques(FuncId)
483: int FuncId;
484: {
485: char FlushData, /* data returned by flush IOCTL function */
486: FlushParm = FLUSH_CMDINFO; /* param to flush IOCTL function */
487: int RetCode;
488:
489: /* flush transmit/receive queue */
490: if ((RetCode = DOSDEVIOCTL(&FlushData, &FlushParm,
491: FuncId, GENERIC, FileHndl)) != 0)
492: Error(ERR_IOCTLFLUSHQUE, RetCode);
493: }
494:
495:
496:
497:
498: /*** clr_com_error - retrieve and clear COM error information
499: *
500: * clr_com_error()
501: *
502: * ENTRY
503: *
504: * EXIT
505: * com error cleared
506: *
507: * WARNING
508: *
509: * EFFECTS
510: *
511: ***/
512:
513: void clr_com_error()
514:
515: {
516: int ComError,
517: RetCode;
518:
519: if ((RetCode = DOSDEVIOCTL((char *) &ComError, 0L, GETCOMERROR,
520: SERIAL, FileHndl)) != 0)
521: Error(ERR_IOCTLGETCOMERROR, RetCode);
522: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.