unused/win95/comm.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14
  15
  16 #define WIN32_LEAN_AND_MEAN
  17 #define WIN95
  18 #define _WIN32
  19 #include <windows.h>
  20 #include <mmsystem.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23
  24 #include "mono.h"
  25 #include "winapp.h"
  26 #include "comm.h"
  27 #include "dxxerror.h"
  28
  29 #define ASCII_XON       0x11
  30 #define ASCII_XOFF      0x13
  31
  32 #define MODEM_REGISTRY_PATH "System\\CurrentControlSet\\Services\\Class\\Modem"
  33
  34
  35 static long comm_delay_val = 0;
  36
  37 DWORD FAR PASCAL comm_thread_proc(LPSTR lpdata);
  38 int FAR PASCAL comm_idle_function(COMM_OBJ *obj);
  39 void comm_dump_info(COMM_OBJ *obj);
  40
  41
  42 //      ---------------------------------------------------------------------
  43
  44 int comm_get_modem_info(int modem, COMM_OBJ *obj)
  45 {
  46         HKEY hKey, hSubKey;
  47         char path[256];
  48         char buf[32];
  49         DWORD len, err, type;
  50
  51         memset(obj, 0, sizeof(COMM_OBJ));
  52         obj->connect = FALSE;
  53
  54         if (modem < 0) {
  55         //      Direct Link
  56                 obj->type = 0;
  57                 obj->port = (char)(modem * -1);
  58                 return 1;
  59         }
  60         else obj->type = 1;
  61
  62         sprintf(buf, "\\%04d", modem);
  63
  64         strcpy(path, MODEM_REGISTRY_PATH);
  65         strcat(path, buf);
  66
  67         mprintf((0, "Looking for modem in HKEY_LOCAL_MACHINE\\%s\n", path));
  68
  69         err = RegOpenKeyEx(HKEY_LOCAL_MACHINE, path, 0, KEY_READ, &hKey);
  70
  71         if (err != ERROR_SUCCESS) return 0;
  72
  73 //      We have a key into the modem 000x
  74 //      Retreive all pertinant info.
  75         len = sizeof(buf);
  76         err = RegQueryValueEx(hKey, "Model", 0, &type, buf, &len);
  77         if (err != ERROR_SUCCESS) {
  78                 RegCloseKey(hKey);
  79                 return 0;
  80         }
  81
  82         strcpy(obj->name, buf);
  83
  84         len = sizeof(buf);
  85         err = RegQueryValueEx(hKey, "PortSubClass", 0, &type, buf, &len);
  86         if (err != ERROR_SUCCESS) {
  87                 RegCloseKey(hKey);
  88                 return 0;
  89         }
  90         mprintf((0, "COM:%d\n", buf[0]));
  91
  92         obj->port = buf[0];
  93
  94         len = sizeof(buf);
  95         err = RegQueryValueEx(hKey, "Reset", 0, &type, buf, &len);
  96         if (err != ERROR_SUCCESS) {
  97                 RegCloseKey(hKey);
  98                 return 0;
  99         }
 100
 101         strcpy(obj->cmd[COMM_RESET_CMD], buf);
 102
 103 //      Retreive some settings stuff
 104         err =  RegOpenKeyEx(hKey, "Answer", 0, KEY_READ, &hSubKey);
 105         if (err !=ERROR_SUCCESS) {
 106                 RegCloseKey(hKey);
 107                 return 0;
 108         }
 109         len = sizeof(buf);
 110         err = RegQueryValueEx(hSubKey, "1", 0, &type, buf, &len);
 111         if (err != ERROR_SUCCESS) {
 112                 RegCloseKey(hSubKey);
 113                 RegCloseKey(hKey);
 114                 return 0;
 115         }
 116         strcpy(obj->cmd[COMM_ANSWER_CMD], buf);
 117         RegCloseKey(hSubKey);
 118
 119         err =  RegOpenKeyEx(hKey, "Hangup", 0, KEY_READ, &hSubKey);
 120         if (err !=ERROR_SUCCESS) {
 121                 RegCloseKey(hKey);
 122                 return 0;
 123         }
 124         len = sizeof(buf);
 125         err = RegQueryValueEx(hSubKey, "1", 0, &type, buf, &len);
 126         if (err != ERROR_SUCCESS) {
 127                 RegCloseKey(hSubKey);
 128                 RegCloseKey(hKey);
 129                 return 0;
 130         }
 131         strcpy(obj->cmd[COMM_HANGUP_CMD], buf);
 132         RegCloseKey(hSubKey);
 133
 134         err =  RegOpenKeyEx(hKey, "Settings", 0, KEY_READ, &hSubKey);
 135         if (err !=ERROR_SUCCESS) {
 136                 RegCloseKey(hKey);
 137                 return 0;
 138         }
 139         len = sizeof(buf);
 140         err = RegQueryValueEx(hSubKey, "DialPrefix", 0, &type, buf, &len);
 141         if (err != ERROR_SUCCESS) {
 142                 RegCloseKey(hSubKey);
 143                 RegCloseKey(hKey);
 144                 return 0;
 145         }
 146         strcpy(obj->cmd[COMM_DIALPREF_CMD], buf);
 147
 148         len = sizeof(buf);
 149         err = RegQueryValueEx(hSubKey, "Tone", 0, &type, buf, &len);
 150         if (err != ERROR_SUCCESS) {
 151                 RegCloseKey(hSubKey);
 152                 RegCloseKey(hKey);
 153                 return 0;
 154         }
 155         strcat(obj->cmd[COMM_DIALPREF_CMD], buf);
 156
 157         len = sizeof(buf);
 158         err = RegQueryValueEx(hSubKey, "Prefix", 0, &type, buf, &len);
 159         if (err != ERROR_SUCCESS) {
 160                 RegCloseKey(hSubKey);
 161                 RegCloseKey(hKey);
 162                 return 0;
 163         }
 164         strcpy(obj->cmd[COMM_PREFIX_CMD], buf);
 165
 166         RegCloseKey(hSubKey);
 167         RegCloseKey(hKey);
 168
 169         comm_dump_info(obj);
 170
 171         return 1;
 172 }
 173
 174
 175 //      int comm_open_connection(COMM_OBJ *obj);
 176 //      ----------------------------------------------------------------------------
 177 int comm_open_connection(COMM_OBJ *obj)
 178 {
 179         char filename[16];
 180         COMMTIMEOUTS ctimeouts;
 181
 182         sprintf(filename, "COM%d", obj->port);
 183
 184         obj->handle = CreateFile(filename,
 185                                                         GENERIC_READ | GENERIC_WRITE,
 186                                                         0,
 187                                                         NULL,
 188                                                         OPEN_EXISTING,
 189                                                         FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
 190         if (obj->handle == INVALID_HANDLE_VALUE)
 191                 return 0;
 192
 193 //       Modem COMport is open.
 194         SetCommMask(obj->handle, EV_RXCHAR);
 195         SetupComm(obj->handle, 4096, 4096);
 196         PurgeComm( obj->handle,
 197                                         PURGE_TXABORT |
 198                                         PURGE_RXABORT |
 199                 PURGE_TXCLEAR | PURGE_RXCLEAR ) ;
 200
 201 //      Timeout after 10 sec.
 202         ctimeouts.ReadIntervalTimeout = 0xffffffff;
 203         ctimeouts.ReadTotalTimeoutMultiplier = 0;
 204         ctimeouts.ReadTotalTimeoutConstant = 10000;
 205         ctimeouts.WriteTotalTimeoutMultiplier = 0;
 206         ctimeouts.WriteTotalTimeoutConstant = 10000;
 207         SetCommTimeouts(obj->handle, &ctimeouts);
 208
 209         memset(&obj->rov, 0, sizeof(OVERLAPPED));
 210         memset(&obj->wov, 0, sizeof(OVERLAPPED));
 211
 212         obj->rov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 213         if (obj->rov.hEvent == NULL) {
 214                 mprintf((0, "COMM: Unable to create read event.\n"));
 215                 CloseHandle(obj->handle);
 216                 return 0;
 217         }
 218         obj->wov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 219         if (obj->wov.hEvent == NULL) {
 220                 mprintf((0, "COMM: Unable to create write event.\n"));
 221                 CloseHandle(obj->rov.hEvent);
 222                 CloseHandle(obj->handle);
 223                 return 0;
 224         }
 225
 226 //      Setup parameters for Connection
 227 //      38400 8N1
 228         obj->dcb.DCBlength = sizeof(DCB);
 229         GetCommState(obj->handle, &obj->dcb);
 230
 231         if (obj->baud)
 232                 obj->dcb.BaudRate = obj->baud;
 233         else obj->baud = obj->dcb.BaudRate;
 234
 235         mprintf((0, "COM%d (%d) is opened.\n", obj->port,  obj->baud));
 236
 237         obj->dcb.fBinary                        = 1;
 238         obj->dcb.Parity                         = NOPARITY;
 239         obj->dcb.fNull                  = 0;
 240    obj->dcb.XonChar                     = ASCII_XON;
 241    obj->dcb.XoffChar            = ASCII_XOFF;
 242    obj->dcb.XonLim                      = 1024;
 243    obj->dcb.XoffLim                     = 1024;
 244    obj->dcb.EofChar                     = 0;
 245    obj->dcb.EvtChar                     = 0;
 246         obj->dcb.fDtrControl            = DTR_CONTROL_ENABLE;// dtr=on
 247         obj->dcb.fRtsControl            = RTS_CONTROL_ENABLE;
 248
 249         obj->dcb.ByteSize               = 8;
 250         obj->dcb.StopBits               = ONESTOPBIT;
 251         obj->dcb.fParity                        = FALSE;
 252
 253         obj->dcb.fOutxDsrFlow   = FALSE;
 254         obj->dcb.fOutxCtsFlow   = FALSE;                                        // rts/cts off
 255
 256 // obj->dcb.fInX = obj->dcb.fOutX = 1;                          // Software flow control XON/XOFF
 257
 258         if (SetCommState(obj->handle, &obj->dcb) == TRUE)
 259         {
 260                 obj->hThread = NULL;
 261                 obj->threadID = (DWORD)(-1);
 262
 263         //      Send DTR
 264                 EscapeCommFunction(obj->handle, SETDTR);
 265                 obj->connect = TRUE;
 266         }
 267         else {
 268                 mprintf((1, "COMM: Unable to set CommState: (%x)\n", GetLastError()));
 269
 270                 obj->hThread = NULL;
 271                 obj->threadID = (DWORD)(-1);
 272                 obj->connect = FALSE;
 273 //              CloseHandle(obj->wov.hEvent);
 274 //              CloseHandle(obj->rov.hEvent);
 275                 CloseHandle(obj->handle);
 276
 277                 return 0;
 278         }
 279
 280         return 1;
 281 }
 282
 283
 284 //      int comm_close_connection(COMM_OBJ *obj);
 285 //      ----------------------------------------------------------------------------
 286 int comm_close_connection(COMM_OBJ *obj)
 287 {
 288         CloseHandle(obj->wov.hEvent);
 289         CloseHandle(obj->rov.hEvent);
 290
 291         SetCommMask(obj->handle, 0);
 292         EscapeCommFunction(obj->handle, CLRDTR);
 293         PurgeComm( obj->handle,
 294                                         PURGE_TXABORT |
 295                                         PURGE_RXABORT |
 296                 PURGE_TXCLEAR | PURGE_RXCLEAR ) ;
 297         CloseHandle(obj->handle);
 298
 299         obj->connect = FALSE;
 300         obj->handle = NULL;
 301         mprintf((0, "COM%d closed.\n", obj->port));
 302         return 1;
 303 }
 304
 305
 306 //      int comm_read_char(COMM_OBJ *obj);
 307 //      ----------------------------------------------------------------------------
 308
 309 #define ROTBUF_SIZE 16
 310
 311 static char rotbuf[ROTBUF_SIZE];
 312 static int rotbuf_cur=0, rotbuf_tail=0;
 313
 314 int comm_read_char(COMM_OBJ *obj)
 315 {
 316         DWORD errflags, result;
 317         COMSTAT comstat;
 318         DWORD length, length_to_read;
 319
 320         if (!obj->connect) return COMM_BUF_EMPTY;
 321
 322 //      Do read buffer stuff
 323         if (rotbuf_cur < rotbuf_tail) {
 324                 return (int)rotbuf[rotbuf_cur++];
 325         }
 326
 327 //      Now if we have a condition of cur = tail, then the buffer is empty
 328 //      and we have to refill it.
 329
 330         ClearCommError(obj->handle, &errflags, &comstat);
 331
 332         if (comstat.cbInQue > 0) {
 333                 if (comstat.cbInQue < ROTBUF_SIZE)
 334                         length_to_read = comstat.cbInQue;
 335                 else
 336                         length_to_read = ROTBUF_SIZE;
 337
 338                 result = ReadFile(obj->handle, rotbuf, length_to_read, &length, &obj->rov);
 339
 340                 if (result == 0) {
 341                         if ((errflags = GetLastError()) != ERROR_IO_PENDING) {
 342                                 mprintf((1, "CommReadChar err: %X\n", errflags));
 343                                 ClearCommError(obj->handle, &errflags, &comstat);
 344                         }
 345                         else {
 346                                 while (!GetOverlappedResult(obj->handle, &obj->rov, &length, TRUE))
 347                                 {
 348                                         errflags = GetLastError();
 349                                         if (errflags == ERROR_IO_INCOMPLETE) {
 350                                                 continue;
 351                                         }
 352                                         else {
 353                                                 mprintf((1, "GetOverlappedResult error: %d.\n", errflags));
 354                                                 rotbuf_cur = rotbuf_tail;
 355                                                 return COMM_BUF_EMPTY;
 356                                         }
 357                                 }
 358                         }
 359                 }
 360                 rotbuf_cur = 0;
 361
 362                 Assert(length <= ROTBUF_SIZE);
 363                 rotbuf_tail = length;
 364                 return (int)rotbuf[rotbuf_cur++];
 365         }
 366         else return COMM_BUF_EMPTY;
 367 }
 368
 369
 370 //      int comm_read_char_timed(COMM_OBJ *obj, int msecs);
 371 //      ----------------------------------------------------------------------------
 372 int comm_read_char_timed(COMM_OBJ *obj, int msecs)
 373 {
 374         DWORD err;
 375         COMSTAT cstat;
 376         int status;
 377         long timeout = timeGetTime() + (long)msecs;
 378
 379         ClearCommError(obj->handle, &err, &cstat);
 380         while (cstat.cbInQue == 0)
 381         {
 382                 status = comm_idle_function(obj);
 383                 if (!status) return -1;
 384                 ClearCommError(obj->handle, &err, &cstat);
 385                 if (timeout <= timeGetTime()) return -1;
 386         }
 387         return comm_read_char(obj);
 388 }
 389
 390
 391 //      int comm_write_char(COMM_OBJ *obj, int ch);
 392 //      ----------------------------------------------------------------------------
 393 int comm_write_char(COMM_OBJ *obj, int ch)
 394 {
 395         DWORD errflags;
 396         DWORD length;
 397         COMSTAT comstat;
 398         char c;
 399
 400         if (!obj->connect) return 0;
 401
 402         c = (char)ch;
 403
 404 //      mprintf((0, "%c", c));
 405
 406         if (!WriteFile(obj->handle, &c, 1, &length, &obj->wov)) {
 407                 if (GetLastError() == ERROR_IO_PENDING) {
 408                         while (!GetOverlappedResult(obj->handle, &obj->wov, &length, TRUE))
 409                         {
 410                                 errflags = GetLastError();
 411                                 if (errflags == ERROR_IO_INCOMPLETE)
 412                                         continue;
 413                                 else {
 414                                         ClearCommError(obj->handle, &errflags, &comstat);
 415                                         mprintf((1, "Comm: Write error!\n"));
 416                                         return 0;
 417                                 }
 418                         }
 419                 }
 420                 else {
 421                         ClearCommError(obj->handle, &errflags, &comstat);
 422                         mprintf((1, "Comm: Write error!\n"));
 423                         return 0;
 424                 }
 425         }
 426
 427 //mprintf((0, "[%c]", c));
 428
 429         return 1;
 430 }
 431
 432
 433 //      int comm_get_cd(COMM_OBJ *obj);
 434 //      ----------------------------------------------------------------------------
 435 int comm_get_cd(COMM_OBJ *obj)
 436 {
 437         DWORD status;
 438
 439         if (!obj->connect) return 0;
 440
 441         GetCommModemStatus(obj->handle, &status);
 442         if (status & MS_RLSD_ON) return 1;
 443         else return 0;
 444 }
 445
 446
 447 //      int comm_get_line_status(COMM_OBJ *obj);
 448 //      ----------------------------------------------------------------------------
 449 int comm_get_line_status(COMM_OBJ *obj)
 450 {
 451         COMSTAT comstat;
 452         DWORD err;
 453         int status=0;
 454
 455         if (!obj->connect) return 0;
 456
 457         ClearCommError(obj->handle, &err, &comstat);
 458
 459         if (err & CE_BREAK) status |= COMM_STATUS_BREAK;
 460         if (err & CE_FRAME) status |= COMM_STATUS_FRAME;
 461         if (err & CE_OVERRUN) status |= COMM_STATUS_OVERRUN;
 462         if (err & CE_RXPARITY) status |= COMM_STATUS_RXPARITY;
 463
 464         return status;
 465 }
 466
 467
 468 //      void comm_clear_line_status(COMM_OBJ *obj)
 469 //      ----------------------------------------------------------------------------
 470 void comm_clear_line_status(COMM_OBJ *obj)
 471 {
 472
 473 }
 474
 475
 476 //      void comm_set_dtr(COMM_OBJ *obj, int flag);
 477 //      ----------------------------------------------------------------------------
 478 void comm_set_dtr(COMM_OBJ *obj, int flag)
 479 {
 480         if (!obj->connect) return;
 481
 482         GetCommState(obj->handle, &obj->dcb);
 483
 484         if (flag == 1) obj->dcb.fDtrControl = DTR_CONTROL_ENABLE;
 485         else obj->dcb.fDtrControl = DTR_CONTROL_DISABLE;
 486
 487         SetCommState(obj->handle, &obj->dcb);
 488 }
 489
 490
 491 //      void comm_set_rtscts(COMM_OBJ *obj, int flag);
 492 //      ----------------------------------------------------------------------------
 493 void comm_set_rtscts(COMM_OBJ *obj, int flag)
 494 {
 495
 496         if (!obj->connect) return;
 497
 498         GetCommState(obj->handle, &obj->dcb);
 499
 500         if (flag) {
 501                 obj->dcb.fOutxCtsFlow   = TRUE;                         // rts/cts off
 502                 obj->dcb.fRtsControl    = RTS_CONTROL_HANDSHAKE;
 503         }
 504         else {
 505                 obj->dcb.fOutxCtsFlow   = FALSE;                                // rts/cts off
 506                 obj->dcb.fRtsControl    = RTS_CONTROL_ENABLE;
 507         }
 508
 509         SetCommState(obj->handle, &obj->dcb);
 510 }
 511
 512
 513 //      int comm_modem_input_line(COMM_OBJ *obj, int msecs, char *buffer, int chars);
 514 //      ----------------------------------------------------------------------------
 515 int comm_modem_input_line(COMM_OBJ *obj, int msecs, char *buffer, int chars)
 516 {
 517         long timeout;
 518         int ch;
 519         int retval=1;
 520         int i;
 521
 522         i = 0;
 523
 524         timeout = timeGetTime() + msecs;
 525
 526         if (chars <= 0) return 0;
 527
 528         while (1)
 529         {
 530                 ch = comm_read_char(obj);
 531                 if (ch >=0) {
 532                         if (ch == '\r') {
 533                         //      mprintf((0, "\n"));
 534                                 break;
 535                         }
 536                         if (ch == '\n') continue;
 537                         buffer[i++] = (char)ch;
 538                         chars--;
 539                         if (chars == 0) break;
 540                 }
 541                 else if (ch == COMM_BUF_EMPTY) {
 542                         retval = 0;
 543                         break;
 544                 }
 545                 else {
 546                         retval = ch;
 547                         break;
 548                 }
 549                 if (timeout <= timeGetTime()) break;
 550         }
 551
 552         buffer[i] = '\0';
 553         if (retval < 0) return retval;
 554
 555         retval = timeout - timeGetTime();
 556         if (retval < 0) retval = 0;
 557         return retval;
 558 }
 559
 560
 561 //      void comm_set_delay(COMM_OBJ *obj, int msecs)
 562 //      ----------------------------------------------------------------------------
 563 void comm_set_delay(COMM_OBJ *obj, int msecs)
 564 {
 565         comm_delay_val = (long)msecs;
 566 }
 567
 568
 569 //      void comm_wait(COMM_OBJ *obj, int msecs)
 570 //      ----------------------------------------------------------------------------
 571 int comm_wait(COMM_OBJ *obj, int msecs)
 572 {
 573         long delaytime;
 574
 575         delaytime = timeGetTime() + (long)msecs;
 576
 577         while (timeGetTime() < delaytime) {
 578                 if (!comm_idle_function(obj)) {
 579                         mprintf((1, "Comm_wait: THIS IS NOT GOOD!!\n"));
 580                         return 0;
 581                 }
 582         }
 583         return 1;
 584 }
 585
 586
 587 //      int comm_modem_send_string(COMM_OBJ *obj, char *str);
 588 //      ----------------------------------------------------------------------------
 589 int comm_modem_send_string(COMM_OBJ *obj, char *str)
 590 {
 591         int retval;
 592         long curtime;
 593         char buf[64];
 594
 595         mprintf((0, "Commodem: send %s\n", str));
 596         retval = comm_modem_send_string_nowait(obj, str, -2);
 597         if (!retval) return 0;
 598
 599         if (comm_delay_val > 0) {
 600                 if (!comm_wait(obj, comm_delay_val)) return 0;
 601         }
 602
 603 //      Checking for OK response
 604         curtime = comm_delay_val;
 605         while(1)
 606         {
 607                 curtime = comm_modem_input_line(obj, curtime, buf, 64);
 608                 if (curtime == 0) {
 609                         mprintf((1, "CommSendString: Didn't get an OK!\n"));
 610                         return 0;
 611                 }
 612                 if (strcmp("OK", buf) == 0) {
 613                         return comm_wait(obj, 500);
 614                 }
 615         }
 616
 617 }
 618
 619
 620 //      int comm_modem_send_string_nowait(COMM_OBJ *obj, char *str, int term);
 621 //      ----------------------------------------------------------------------------
 622 int comm_modem_send_string_nowait(COMM_OBJ *obj, char *str, int term)
 623 {
 624         int i;
 625
 626         if (term < -2 || term > 255) return 0;
 627
 628 //      mprintf((0, "<%s", str));
 629         for (i= 0; i < lstrlen(str); i++)
 630                 comm_write_char(obj, str[i]);
 631
 632 //@@    if (!WriteFile(obj->handle, &str, lstrlen(str), &length, &obj->wov)) {
 633 //@@            if (GetLastError() == ERROR_IO_PENDING) {
 634 //@@                    mprintf((0,"Comm: SendStringNoWait IO pending...\n"));
 635 //@@                    while (!GetOverlappedResult(obj->handle, &obj->wov, &length, TRUE))
 636 //@@                    {
 637 //@@                            errflags = GetLastError();
 638 //@@                            if (errflags == ERROR_IO_INCOMPLETE)
 639 //@@                                    continue;
 640 //@@                            else {
 641 //@@                                    ClearCommError(obj->handle, &errflags, &comstat);
 642 //@@                                    mprintf((1, "Comm: SendStringNoWait error!\n"));
 643 //@@                                    return 0;
 644 //@@                            }
 645 //@@                    }
 646 //@@            }
 647 //@@            else {
 648 //@@                    ClearCommError(obj->handle, &errflags, &comstat);
 649 //@@                    mprintf((1, "Comm: SendStringNoWait error!\n"));
 650 //@@                    return 0;
 651 //@@            }
 652 //@@    }
 653
 654         if (term >=0)
 655                 comm_write_char(obj, term);
 656         else if (term == -2) {
 657                 comm_write_char(obj, '\r');
 658                 comm_write_char(obj, '\n');
 659         }
 660
 661         return 1;
 662 }
 663
 664
 665 //      int comm_modem_reset(COMM_OBJ *obj);
 666 //      ----------------------------------------------------------------------------
 667 int comm_modem_reset(COMM_OBJ *obj)
 668 {
 669         return comm_modem_send_string(obj, obj->cmd[COMM_RESET_CMD]);
 670 }
 671
 672
 673 //      int comm_modem_dial(COMM_OBJ *obj, char *phonenum);
 674 //      ----------------------------------------------------------------------------
 675 int comm_modem_dial(COMM_OBJ *obj, char *phonenum)
 676 {
 677         char str[40];
 678
 679         strcpy(str, obj->cmd[COMM_PREFIX_CMD]);
 680         strcat(str, obj->cmd[COMM_DIALPREF_CMD]);
 681         strcat(str, phonenum);
 682         return comm_modem_send_string_nowait(obj, str, '\r');
 683 }
 684
 685
 686 //      int comm_modem_answer(COMM_OBJ *obj);
 687 //      ----------------------------------------------------------------------------
 688 int comm_modem_answer(COMM_OBJ *obj)
 689 {
 690         return comm_modem_send_string_nowait(obj, obj->cmd[COMM_ANSWER_CMD], '\r');
 691 }
 692
 693
 694
 695 //@@    DWORD FAR PASCAL comm_thread_proc (LPSTR lpData);
 696 //@@    -------------------------------------------------------------------------
 697 //@@DWORD FAR PASCAL comm_thread_proc (LPSTR lpData)
 698 //@@{
 699 //@@    DWORD event_mask;
 700 //@@    OVERLAPPED os;
 701 //@@    COMM_OBJ *obj = (COMM_OBJ *)lpData;
 702 //@@
 703 //@@    memset(&os, 0, sizeof(OVERLAPPED));
 704 //@@    os.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 705 //@@    if (os.hEvent == NULL) {
 706 //@@            mprintf((1, "CommThread: unable to create event!\n"));
 707 //@@            return FALSE;
 708 //@@    }
 709 //@@
 710 //@@    if (!SetCommMask(obj->handle, EV_RXCHAR)) return FALSE;
 711 //@@
 712 //@@    while (obj->connected)
 713 //@@    {
 714 //@@            event_mask = 0;
 715 //@@            WaitCommEvent(obj->handle, &event_mask, NULL);
 716 //@@            if ((event_mask & EV_RXCHAR) == EV_RXCHAR) {
 717 //@@            }
 718 //@@    }
 719 //@@}
 720
 721
 722 //      int FAR PASCAL comm_idle_function(COMM_OBJ *obj);
 723 //      ----------------------------------------------------------------------------
 724 int FAR PASCAL comm_idle_function(COMM_OBJ *obj)
 725 {
 726         MSG msg;
 727
 728         while (PeekMessage(&msg, 0,0,0, PM_REMOVE)) {
 729                 TranslateMessage(&msg);
 730                 DispatchMessage(&msg);
 731         }
 732
 733         return 1;
 734 }
 735
 736
 737 //      Dump Info
 738 //      ----------------------------------------------------------------------------
 739 void comm_dump_info(COMM_OBJ *obj)
 740 {
 741         int baud;
 742
 743         switch (obj->dcb.BaudRate)
 744         {
 745                 case CBR_9600:  baud = 9600; break;
 746                 case CBR_14400: baud = 14400; break;
 747                 case CBR_19200: baud = 19200; break;
 748                 case CBR_38400: baud = 38400; break;
 749                 case CBR_57600: baud = 57600; break;
 750                 default:
 751                         baud = -1;
 752         }
 753         mprintf((0, "CommObj %x:\n", obj->handle));
 754         mprintf((0, "\tConnect: %d\n\tDevice: %s\n", obj->connect, obj->name));
 755         mprintf((0,     "\tPort: COM%d\n", obj->port));
 756         mprintf((0, "\tBaud:    %d\n\tDTR:[%d]  RTS/CTS:[%d|%d]\n", baud, obj->dcb.fDtrControl,obj->dcb.fRtsControl,obj->dcb.fOutxCtsFlow));
 757         mprintf((0, "\tXON/XOFF [In|Out]:[%d|%d]  XON/OFF thresh:[%d|%d]\n", obj->dcb.fInX, obj->dcb.fOutX, obj->dcb.XonLim, obj->dcb.XoffLim));
 758 }
 759
 760
 761
 762
 763
 764
 765