![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sbbsexec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / sbbs3|
Return to sbbsexec.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 ! root 1: /* sbbsexec.c */ ! 2: ! 3: /* Synchronet Windows NT/2000 VDD for FOSSIL and DOS I/O Interrupts */ ! 4: ! 5: /* $Id: sbbsexec.c,v 1.38 2006/10/28 03:56:36 rswindell Exp $ */ ! 6: ! 7: /**************************************************************************** ! 8: * @format.tab-size 4 (Plain Text/Source Code File Header) * ! 9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) * ! 10: * * ! 11: * Copyright 2006 Rob Swindell - http://www.synchro.net/copyright.html * ! 12: * * ! 13: * This program is free software; you can redistribute it and/or * ! 14: * modify it under the terms of the GNU General Public License * ! 15: * as published by the Free Software Foundation; either version 2 * ! 16: * of the License, or (at your option) any later version. * ! 17: * See the GNU General Public License for more details: gpl.txt or * ! 18: * http://www.fsf.org/copyleft/gpl.html * ! 19: * * ! 20: * Anonymous FTP access to the most recent released source is available at * ! 21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net * ! 22: * * ! 23: * Anonymous CVS access to the development source and modification history * ! 24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: * ! 25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login * ! 26: * (just hit return, no password is necessary) * ! 27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src * ! 28: * * ! 29: * For Synchronet coding style and modification guidelines, see * ! 30: * http://www.synchro.net/source.html * ! 31: * * ! 32: * You are encouraged to submit any modifications (preferably in Unix diff * ! 33: * format) via e-mail to [email protected] * ! 34: * * ! 35: * Note: If this box doesn't appear square, then you need to fix your tabs. * ! 36: ****************************************************************************/ ! 37: ! 38: #include <windows.h> ! 39: #include <stdio.h> ! 40: #include <vddsvc.h> ! 41: #include "uartdefs.h" ! 42: #include "vdd_func.h" ! 43: #include "ringbuf.h" ! 44: #include "genwrap.h" ! 45: #include "dirwrap.h" ! 46: #include "threadwrap.h" ! 47: #include "ini_file.h" ! 48: ! 49: #define INI_FILENAME "sbbsexec.ini" ! 50: #define RINGBUF_SIZE_IN 10000 ! 51: #define DEFAULT_MAX_MSG_SIZE 4000 ! 52: #define LINEAR_RX_BUFLEN 5000 ! 53: ! 54: /* UART Parameters and virtual registers */ ! 55: WORD uart_io_base = UART_COM1_IO_BASE; /* COM1 */ ! 56: BYTE uart_irq = UART_COM1_IRQ; ! 57: BYTE uart_ier_reg = 0; ! 58: BYTE uart_lcr_reg = UART_LCR_8_DATA_BITS; ! 59: BYTE uart_mcr_reg = UART_MCR_RTS | UART_MCR_DTR; ! 60: BYTE uart_lsr_reg = UART_LSR_EMPTY_DATA | UART_LSR_EMPTY_XMIT; ! 61: BYTE uart_msr_reg = UART_MSR_CTS | UART_MSR_DSR; ! 62: BYTE uart_scratch_reg = 0; ! 63: BYTE uart_divisor_latch_lsb = 0x03; /* 38400 */ ! 64: BYTE uart_divisor_latch_msb = 0x00; ! 65: ! 66: #if defined (_DEBUG) ! 67: int log_level = LOG_DEBUG; ! 68: #else ! 69: int log_level = LOG_WARNING; ! 70: #endif ! 71: ! 72: BOOL virtualize_uart=TRUE; ! 73: double yield_interval=1.0; ! 74: BOOL hangup_supported=TRUE; ! 75: HANDLE hangup_event=NULL; ! 76: HANDLE hungup_event=NULL; ! 77: HANDLE interrupt_event=NULL; ! 78: HANDLE rdslot=INVALID_HANDLE_VALUE; ! 79: HANDLE wrslot=INVALID_HANDLE_VALUE; ! 80: RingBuf rdbuf; ! 81: str_list_t ini; ! 82: char ini_fname[MAX_PATH+1]; ! 83: char revision[16]; ! 84: ! 85: void lputs(int level, char* msg) ! 86: { ! 87: char buf[1024]; ! 88: if(level > log_level) ! 89: return; ! 90: ! 91: SAFEPRINTF(buf,"SBBS: %s\r\n", msg); ! 92: OutputDebugString(buf); ! 93: } ! 94: ! 95: static void lprintf(int level, const char *fmt, ...) ! 96: { ! 97: char sbuf[1024]; ! 98: va_list argptr; ! 99: ! 100: if(level > log_level) ! 101: return; ! 102: ! 103: va_start(argptr,fmt); ! 104: _vsnprintf(sbuf,sizeof(sbuf),fmt,argptr); ! 105: sbuf[sizeof(sbuf)-1]=0; ! 106: va_end(argptr); ! 107: lputs(level,sbuf); ! 108: } ! 109: ! 110: void hangup() ! 111: { ! 112: if(hangup_supported && hangup_event!=NULL) { ! 113: lprintf(LOG_DEBUG,"Hanging-up at application request"); ! 114: SetEvent(hangup_event); ! 115: } ! 116: } ! 117: ! 118: void parse_ini(char* program) ! 119: { ! 120: char section[MAX_PATH+1]; ! 121: ! 122: if(ini==NULL) /* no initialization file */ ! 123: return; ! 124: ! 125: /* Read the root section of the sbbsexec.ini file */ ! 126: log_level=iniGetLogLevel(ini,program,"LogLevel",log_level); ! 127: if(iniGetBool(ini,program,"Debug",FALSE)) ! 128: log_level=LOG_DEBUG; ! 129: yield_interval=iniGetFloat(ini,program,"YieldInterval",yield_interval); ! 130: hangup_supported=iniGetBool(ini,program,"CanDisconnect",hangup_supported); ! 131: ! 132: lprintf(LOG_INFO,"Parsed %s section of %s" ! 133: ,program==ROOT_SECTION ? "root" : program ! 134: ,ini_fname); ! 135: ! 136: /* [UART] section */ ! 137: if(program==ROOT_SECTION) ! 138: SAFECOPY(section,"UART"); ! 139: else ! 140: SAFEPRINTF(section,"%s.UART",program); ! 141: ! 142: virtualize_uart=iniGetBool(ini,section,"Virtualize",virtualize_uart); ! 143: switch(iniGetInteger(ini,section,"ComPort",0)) { ! 144: case 1: /* COM1 */ ! 145: uart_irq =UART_COM1_IRQ; ! 146: uart_io_base =UART_COM1_IO_BASE; ! 147: break; ! 148: case 2: /* COM2 */ ! 149: uart_irq =UART_COM2_IRQ; ! 150: uart_io_base =UART_COM2_IO_BASE; ! 151: break; ! 152: case 3: /* COM3 */ ! 153: uart_irq =UART_COM3_IRQ; ! 154: uart_io_base =UART_COM3_IO_BASE; ! 155: break; ! 156: case 4: /* COM4 */ ! 157: uart_irq =UART_COM4_IRQ; ! 158: uart_io_base =UART_COM4_IO_BASE; ! 159: break; ! 160: } ! 161: uart_irq=(BYTE)iniGetShortInt(ini,section,"IRQ",uart_irq); ! 162: uart_io_base=iniGetShortInt(ini,section,"Address",uart_io_base); ! 163: ! 164: lprintf(LOG_INFO,"Parsed %s section of %s" ! 165: ,section ! 166: ,ini_fname); ! 167: } ! 168: ! 169: ! 170: /* Mutex-protected pending interrupt "queue" */ ! 171: int pending_interrupts = 0; ! 172: CRITICAL_SECTION interrupt_mutex; ! 173: ! 174: void set_interrupt_pending(BYTE intr, BOOL assert) ! 175: { ! 176: EnterCriticalSection(&interrupt_mutex); ! 177: lprintf(LOG_DEBUG,"%sasserting interrupt %02X (pending: %02X, IER: %02X)" ! 178: ,assert ? "" : "de-", intr ! 179: ,pending_interrupts ! 180: ,uart_ier_reg); ! 181: if(assert) { ! 182: if(uart_ier_reg&intr) { /* is interrupt enabled? */ ! 183: pending_interrupts |= intr; /* flag as pending */ ! 184: SetEvent(interrupt_event); ! 185: } ! 186: } else /* de-assert */ ! 187: pending_interrupts &= ~intr; /* remove as pending */ ! 188: ! 189: LeaveCriticalSection(&interrupt_mutex); ! 190: } ! 191: ! 192: #define assert_interrupt(i) set_interrupt_pending(i, TRUE) ! 193: #define deassert_interrupt(i) set_interrupt_pending(i, FALSE) ! 194: ! 195: void _cdecl interrupt_thread(void *arg) ! 196: { ! 197: while(1) { ! 198: if(WaitForSingleObject(interrupt_event,INFINITE)!=WAIT_OBJECT_0) ! 199: break; ! 200: if((uart_ier_reg&pending_interrupts) != 0) { ! 201: lprintf(LOG_DEBUG,"VDDSimulateInterrupt (pending: %02X) - IER: %02X" ! 202: ,pending_interrupts, uart_ier_reg); ! 203: VDDSimulateInterrupt(ICA_MASTER, uart_irq, /* count: */1); ! 204: } ! 205: #if 0 ! 206: /* "Real 16550s should always reassert ! 207: * this interrupt whenever the transmitter is idle and ! 208: * the interrupt is enabled." ! 209: */ ! 210: if(pending_interrupts==0 && uart_ier_reg&UART_IER_TX_EMPTY) ! 211: pending_interrupts|=UART_IER_TX_EMPTY; ! 212: #endif ! 213: } ! 214: } ! 215: ! 216: void _cdecl input_thread(void* arg) ! 217: { ! 218: char buf[LINEAR_RX_BUFLEN]; ! 219: int count; ! 220: ! 221: while(1) { ! 222: count=0; ! 223: if(!ReadFile(rdslot,buf,sizeof(buf),&count,NULL)) { ! 224: if(GetLastError()==ERROR_HANDLE_EOF) /* closed by VDD_CLOSE */ ! 225: break; ! 226: lprintf(LOG_ERR,"!input_thread: ReadFile Error %d (size=%d)" ! 227: ,GetLastError(),count); ! 228: continue; ! 229: } ! 230: if(count==0) { ! 231: lprintf(LOG_ERR,"!input_thread: ReadFile read 0"); ! 232: continue; ! 233: } ! 234: RingBufWrite(&rdbuf,buf,count); ! 235: /* Set the "Data ready" bit in the LSR */ ! 236: uart_lsr_reg |= UART_LSR_DATA_READY; ! 237: ! 238: assert_interrupt(UART_IER_RX_DATA); /* assert rx data interrupt */ ! 239: } ! 240: } ! 241: ! 242: unsigned vdd_read(BYTE* p, unsigned count) ! 243: { ! 244: sem_wait(rdbuf.sem); ! 245: count=RingBufRead(&rdbuf,p,count); ! 246: if(count==0) ! 247: lprintf(LOG_ERR,"!VDD_READ: RingBufRead read 0"); ! 248: ! 249: return(count); ! 250: } ! 251: ! 252: unsigned yields=0; ! 253: ! 254: void yield() ! 255: { ! 256: yields++; ! 257: lprintf(LOG_DEBUG,"Yielding (yields=%u)", yields); ! 258: Sleep(1); ! 259: } ! 260: ! 261: long double last_yield=0; ! 262: ! 263: void maybe_yield() ! 264: { ! 265: long double t; ! 266: ! 267: t=xp_timer(); ! 268: ! 269: if(yield_interval && (t-last_yield)*1000.0 >= yield_interval) { ! 270: yield(); ! 271: last_yield=t; ! 272: } ! 273: } ! 274: ! 275: void reset_yield() ! 276: { ! 277: last_yield=xp_timer(); ! 278: } ! 279: ! 280: /***********************/ ! 281: /* UART Virtualization */ ! 282: /***********************/ ! 283: ! 284: static char *chr(uchar ch) ! 285: { ! 286: static char str[25]; ! 287: ! 288: if(ch>=' ' && ch<='~') ! 289: sprintf(str,"'%c' (%02Xh)",ch,ch); ! 290: else if(ch<' ') ! 291: sprintf(str,"^%c (%02Xh)",'@'+ch,ch); ! 292: else ! 293: sprintf(str,"%u (%02Xh)",ch,ch); ! 294: return(str); ! 295: } ! 296: ! 297: VOID uart_wrport(WORD port, BYTE data) ! 298: { ! 299: int reg = port - uart_io_base; ! 300: int retval; ! 301: ! 302: lprintf(LOG_DEBUG,"write of port: %x (%s) <- %02X", port, uart_reg_desc[reg], data); ! 303: ! 304: switch(reg) { ! 305: case UART_BASE: ! 306: if(uart_lcr_reg&UART_LCR_DLAB) { ! 307: uart_divisor_latch_lsb = data; ! 308: lprintf(LOG_DEBUG,"set divisor latch low byte: %02X", data); ! 309: } else { ! 310: lprintf(LOG_DEBUG,"WRITE DATA: %s", chr(data)); ! 311: if(!WriteFile(wrslot,&data,sizeof(BYTE),&retval,NULL)) { ! 312: lprintf(LOG_ERR,"!VDD_WRITE: WriteFile Error %d (size=%d)" ! 313: ,GetLastError(),retval); ! 314: } else { ! 315: assert_interrupt(UART_IER_TX_EMPTY); ! 316: reset_yield(); ! 317: } ! 318: } ! 319: break; ! 320: case UART_IER: ! 321: if(uart_lcr_reg&UART_LCR_DLAB) { ! 322: uart_divisor_latch_msb = data; ! 323: lprintf(LOG_DEBUG,"set divisor latch high byte: %02X", data); ! 324: } else ! 325: uart_ier_reg = data; ! 326: assert_interrupt(UART_IER_TX_EMPTY); /* should this be re-asserted for all writes? */ ! 327: break; ! 328: case UART_IIR: /* FCR not supported */ ! 329: break; ! 330: case UART_LCR: ! 331: uart_lcr_reg = data; ! 332: break; ! 333: case UART_MCR: ! 334: uart_mcr_reg = data; ! 335: if((uart_mcr_reg&UART_MCR_DTR) == 0) /* Dropping DTR (i.e. "hangup") */ ! 336: hangup(); ! 337: break; ! 338: case UART_SCRATCH: ! 339: uart_scratch_reg = data; ! 340: break; ! 341: default: ! 342: lprintf(LOG_ERR,"UNSUPPORTED register: %u", reg); ! 343: break; ! 344: ! 345: } ! 346: } ! 347: ! 348: VOID uart_rdport(WORD port, PBYTE data) ! 349: { ! 350: int reg = port - uart_io_base; ! 351: DWORD avail; ! 352: ! 353: lprintf(LOG_DEBUG,"read of port: %x (%s)", port, uart_reg_desc[reg]); ! 354: ! 355: switch(reg) { ! 356: case UART_BASE: ! 357: if(uart_lcr_reg&UART_LCR_DLAB) { ! 358: lprintf(LOG_DEBUG,"reading divisor latch LSB"); ! 359: *data = uart_divisor_latch_lsb; ! 360: break; ! 361: } ! 362: if((avail=RingBufFull(&rdbuf))!=0) { ! 363: vdd_read(data,sizeof(BYTE)); ! 364: lprintf(LOG_DEBUG,"READ DATA: %s", chr(*data)); ! 365: avail--; ! 366: reset_yield(); ! 367: } else ! 368: *data=0; ! 369: if(avail==0) { ! 370: lprintf(LOG_DEBUG,"No more data"); ! 371: /* Clear the data ready bit in the LSR */ ! 372: uart_lsr_reg &= ~UART_LSR_DATA_READY; ! 373: ! 374: /* Clear data ready interrupt identification in IIR */ ! 375: deassert_interrupt(UART_IER_RX_DATA); ! 376: } else /* re-assert RX data (increment the semaphore) */ ! 377: assert_interrupt(UART_IER_RX_DATA); ! 378: break; ! 379: case UART_IER: ! 380: if(uart_lcr_reg&UART_LCR_DLAB) { ! 381: lprintf(LOG_DEBUG,"reading divisor latch MSB"); ! 382: *data = uart_divisor_latch_msb; ! 383: } else ! 384: *data = uart_ier_reg; ! 385: break; ! 386: case UART_IIR: ! 387: /* Report IIR based on *priority* of pending interrupts */ ! 388: if(pending_interrupts & UART_IER_LINE_STATUS) ! 389: *data = UART_IIR_LINE_STATUS; ! 390: else if(pending_interrupts & UART_IER_RX_DATA) ! 391: *data = UART_IIR_RX_DATA; ! 392: else if(pending_interrupts & UART_IER_TX_EMPTY) { ! 393: *data = UART_IIR_TX_EMPTY; ! 394: /* "Transmit Holding Register Empty" interrupt */ ! 395: /* is reset on read of IIR */ ! 396: deassert_interrupt(UART_IER_TX_EMPTY); ! 397: } ! 398: else if(pending_interrupts & UART_IER_MODEM_STATUS) ! 399: *data = UART_IIR_MODEM_STATUS; ! 400: else ! 401: *data = UART_IIR_NONE; ! 402: break; ! 403: case UART_LCR: ! 404: *data = uart_lcr_reg; ! 405: break; ! 406: case UART_MCR: ! 407: *data = uart_mcr_reg; ! 408: break; ! 409: case UART_LSR: ! 410: *data = uart_lsr_reg; ! 411: maybe_yield(); ! 412: /* Clear line status interrupt pending */ ! 413: deassert_interrupt(UART_IER_LINE_STATUS); ! 414: break; ! 415: case UART_MSR: ! 416: if(WaitForSingleObject(hungup_event,0)==WAIT_OBJECT_0) ! 417: uart_msr_reg &=~ UART_MSR_DCD; ! 418: else ! 419: uart_msr_reg |= UART_MSR_DCD; ! 420: *data = uart_msr_reg; ! 421: maybe_yield(); ! 422: /* Clear modem status interrupt pending */ ! 423: deassert_interrupt(UART_IER_MODEM_STATUS); ! 424: break; ! 425: case UART_SCRATCH: ! 426: *data = uart_scratch_reg; ! 427: break; ! 428: default: ! 429: lprintf(LOG_ERR,"UNSUPPORTED register: %u", reg); ! 430: break; ! 431: } ! 432: ! 433: if(reg!=UART_BASE) ! 434: lprintf(LOG_DEBUG, "returning 0x%02X", *data); ! 435: } ! 436: ! 437: /* VDD DOS Interface (mainly for FOSSIL driver in dosxtrn.exe) */ ! 438: ! 439: __declspec(dllexport) void __cdecl VDDDispatch(void) ! 440: { ! 441: char str[512]; ! 442: DWORD count; ! 443: DWORD msgs; ! 444: int retval; ! 445: int node_num; ! 446: BYTE* p; ! 447: vdd_status_t* status; ! 448: static DWORD writes; ! 449: static DWORD bytes_written; ! 450: static DWORD reads; ! 451: static DWORD bytes_read; ! 452: static DWORD inbuf_poll; ! 453: static DWORD online_poll; ! 454: static DWORD status_poll; ! 455: static DWORD vdd_yields; ! 456: static DWORD vdd_calls; ! 457: VDD_IO_HANDLERS IOHandlers = { NULL }; ! 458: static VDD_IO_PORTRANGE PortRange; ! 459: ! 460: retval=0; ! 461: node_num=getBH(); ! 462: ! 463: lprintf(LOG_DEBUG,"VDD_OP: (handle=%d) %d (arg=%X)", getAX(),getBL(),getCX()); ! 464: vdd_calls++; ! 465: ! 466: switch(getBL()) { ! 467: ! 468: case VDD_OPEN: ! 469: ! 470: sscanf("$Revision: 1.38 $", "%*s %s", revision); ! 471: ! 472: lprintf(LOG_INFO,"Synchronet Virtual Device Driver, rev %s %s %s" ! 473: ,revision, __DATE__, __TIME__); ! 474: #if 0 ! 475: sprintf(str,"sbbsexec%d.log",node_num); ! 476: fp=fopen(str,"wb"); ! 477: #endif ! 478: ! 479: sprintf(str,"\\\\.\\mailslot\\sbbsexec\\wr%d",node_num); ! 480: rdslot=CreateMailslot(str ! 481: ,LINEAR_RX_BUFLEN /* Max message size (0=any) */ ! 482: ,MAILSLOT_WAIT_FOREVER /* Read timeout */ ! 483: ,NULL); ! 484: if(rdslot==INVALID_HANDLE_VALUE) { ! 485: lprintf(LOG_ERR,"!VDD_OPEN: Error %d opening %s" ! 486: ,GetLastError(),str); ! 487: retval=1; ! 488: break; ! 489: } ! 490: ! 491: sprintf(str,"\\\\.\\mailslot\\sbbsexec\\rd%d",node_num); ! 492: wrslot=CreateFile(str ! 493: ,GENERIC_WRITE ! 494: ,FILE_SHARE_READ ! 495: ,NULL ! 496: ,OPEN_EXISTING ! 497: ,FILE_ATTRIBUTE_NORMAL ! 498: ,(HANDLE) NULL); ! 499: if(wrslot==INVALID_HANDLE_VALUE) { ! 500: lprintf(LOG_ERR,"!VDD_OPEN: Error %d opening %s" ! 501: ,GetLastError(),str); ! 502: retval=2; ! 503: break; ! 504: } ! 505: ! 506: if(RingBufInit(&rdbuf, RINGBUF_SIZE_IN)!=0) { ! 507: retval=3; ! 508: break; ! 509: } ! 510: ! 511: sprintf(str,"sbbsexec_hungup%d",node_num); ! 512: hungup_event=OpenEvent( ! 513: EVENT_ALL_ACCESS, /* access flag */ ! 514: FALSE, /* inherit flag */ ! 515: str); /* pointer to event-object name */ ! 516: if(hungup_event==NULL) { ! 517: lprintf(LOG_ERR,"!VDD_OPEN: Error %d opening %s" ! 518: ,GetLastError(),str); ! 519: retval=4; ! 520: break; ! 521: } ! 522: ! 523: sprintf(str,"sbbsexec_hangup%d",node_num); ! 524: hangup_event=OpenEvent( ! 525: EVENT_ALL_ACCESS, /* access flag */ ! 526: FALSE, /* inherit flag */ ! 527: str); /* pointer to event-object name */ ! 528: if(hangup_event==NULL) { ! 529: lprintf(LOG_WARNING,"!VDD_OPEN: Error %d opening %s" ! 530: ,GetLastError(),str); ! 531: } ! 532: ! 533: status_poll=0; ! 534: inbuf_poll=0; ! 535: online_poll=0; ! 536: yields=0; ! 537: ! 538: lprintf(LOG_INFO,"Yield interval: %f milliseconds", yield_interval); ! 539: ! 540: if(virtualize_uart) { ! 541: lprintf(LOG_INFO,"Virtualizing UART (0x%x, IRQ %u)" ! 542: ,uart_io_base, uart_irq); ! 543: ! 544: IOHandlers.inb_handler = uart_rdport; ! 545: IOHandlers.outb_handler = uart_wrport; ! 546: PortRange.First=uart_io_base; ! 547: PortRange.Last=uart_io_base + UART_IO_RANGE; ! 548: ! 549: VDDInstallIOHook((HANDLE)getAX(), 1, &PortRange, &IOHandlers); ! 550: ! 551: interrupt_event=CreateEvent(NULL,FALSE,FALSE,NULL); ! 552: InitializeCriticalSection(&interrupt_mutex); ! 553: ! 554: _beginthread(interrupt_thread, 0, NULL); ! 555: } ! 556: ! 557: lprintf(LOG_DEBUG,"VDD_OPEN: Opened successfully"); ! 558: ! 559: _beginthread(input_thread, 0, NULL); ! 560: ! 561: retval=0; ! 562: break; ! 563: ! 564: case VDD_CLOSE: ! 565: lprintf(LOG_INFO,"VDD_CLOSE: rdbuf=%u " ! 566: "status_poll=%u inbuf_poll=%u online_poll=%u yields=%u vdd_yields=%u vdd_calls=%u" ! 567: ,RingBufFull(&rdbuf),status_poll,inbuf_poll,online_poll ! 568: ,yields,vdd_yields,vdd_calls); ! 569: lprintf(LOG_INFO," read=%u bytes (in %u calls)",bytes_read,reads); ! 570: lprintf(LOG_INFO," wrote=%u bytes (in %u calls)",bytes_written,writes); ! 571: ! 572: if(virtualize_uart) { ! 573: lprintf(LOG_INFO,"Uninstalling Virtualizaed UART IO Hook"); ! 574: VDDDeInstallIOHook((HANDLE)getAX(), 1, &PortRange); ! 575: } ! 576: ! 577: CloseHandle(rdslot); ! 578: CloseHandle(wrslot); ! 579: if(hungup_event!=NULL) ! 580: CloseHandle(hungup_event); ! 581: if(hangup_event!=NULL) ! 582: CloseHandle(hangup_event); ! 583: ! 584: #if 0 /* This isn't strictly necessary... ! 585: and possibly the cause of a NULL dereference in the input_thread */ ! 586: RingBufDispose(&rdbuf); ! 587: #endif ! 588: status_poll=0; ! 589: retval=0; ! 590: ! 591: break; ! 592: ! 593: case VDD_READ: ! 594: count = getCX(); ! 595: if(count != 1) ! 596: lprintf(LOG_DEBUG,"VDD_READ of %d",count); ! 597: p = (BYTE*) GetVDMPointer((ULONG)((getES() << 16)|getDI()) ! 598: ,count,FALSE); ! 599: retval=vdd_read(p, count); ! 600: reads++; ! 601: bytes_read+=retval; ! 602: reset_yield(); ! 603: break; ! 604: ! 605: case VDD_PEEK: ! 606: count = getCX(); ! 607: if(count != 1) ! 608: lprintf(LOG_DEBUG,"VDD_PEEK of %d",count); ! 609: ! 610: p = (BYTE*) GetVDMPointer((ULONG)((getES() << 16)|getDI()) ! 611: ,count,FALSE); ! 612: retval=RingBufPeek(&rdbuf,p,count); ! 613: reset_yield(); ! 614: break; ! 615: ! 616: case VDD_WRITE: ! 617: count = getCX(); ! 618: if(count != 1) ! 619: lprintf(LOG_DEBUG,"VDD_WRITE of %d",count); ! 620: p = (BYTE*) GetVDMPointer((ULONG)((getES() << 16)|getDI()) ! 621: ,count,FALSE); ! 622: if(!WriteFile(wrslot,p,count,&retval,NULL)) { ! 623: lprintf(LOG_ERR,"!VDD_WRITE: WriteFile Error %d (size=%d)" ! 624: ,GetLastError(),retval); ! 625: retval=0; ! 626: } else { ! 627: writes++; ! 628: bytes_written+=retval; ! 629: reset_yield(); ! 630: } ! 631: break; ! 632: ! 633: case VDD_STATUS: ! 634: ! 635: status_poll++; ! 636: count = getCX(); ! 637: if(count != sizeof(vdd_status_t)) { ! 638: lprintf(LOG_DEBUG,"!VDD_STATUS: wrong size (%d!=%d)",count,sizeof(vdd_status_t)); ! 639: retval=sizeof(vdd_status_t); ! 640: break; ! 641: } ! 642: status = (vdd_status_t*) GetVDMPointer((ULONG)((getES() << 16)|getDI()) ! 643: ,count,FALSE); ! 644: ! 645: status->inbuf_full=RingBufFull(&rdbuf); ! 646: ! 647: /* OUTBUF FULL/SIZE */ ! 648: if(!GetMailslotInfo( ! 649: wrslot, /* mailslot handle */ ! 650: &status->outbuf_size, /* address of maximum message size */ ! 651: &status->outbuf_full, /* address of size of next message */ ! 652: &msgs, /* address of number of messages */ ! 653: NULL /* address of read time-out */ ! 654: )) { ! 655: status->outbuf_full=0; ! 656: status->outbuf_size=DEFAULT_MAX_MSG_SIZE; ! 657: } ! 658: if(status->outbuf_full==MAILSLOT_NO_MESSAGE) ! 659: status->outbuf_full=0; ! 660: status->outbuf_full*=msgs; ! 661: ! 662: /* ONLINE */ ! 663: if(WaitForSingleObject(hungup_event,0)==WAIT_OBJECT_0) ! 664: status->online=0; ! 665: else ! 666: status->online=1; ! 667: ! 668: retval=0; /* success */ ! 669: break; ! 670: ! 671: case VDD_INBUF_PURGE: ! 672: RingBufReInit(&rdbuf); ! 673: retval=0; ! 674: break; ! 675: ! 676: case VDD_OUTBUF_PURGE: ! 677: lprintf(LOG_WARNING,"!VDD_OUTBUF_PURGE: NOT IMPLEMENTED"); ! 678: retval=0; ! 679: break; ! 680: ! 681: case VDD_INBUF_FULL: ! 682: retval=RingBufFull(&rdbuf); ! 683: inbuf_poll++; ! 684: break; ! 685: ! 686: case VDD_INBUF_SIZE: ! 687: retval=RINGBUF_SIZE_IN; ! 688: break; ! 689: ! 690: case VDD_OUTBUF_FULL: ! 691: if(!GetMailslotInfo( ! 692: wrslot, /* mailslot handle */ ! 693: NULL, /* address of maximum message size */ ! 694: &retval, /* address of size of next message */ ! 695: &msgs, /* address of number of messages */ ! 696: NULL /* address of read time-out */ ! 697: )) ! 698: retval=0; ! 699: if(retval==MAILSLOT_NO_MESSAGE) ! 700: retval=0; ! 701: retval*=msgs; ! 702: break; ! 703: ! 704: case VDD_OUTBUF_SIZE: ! 705: if(!GetMailslotInfo( ! 706: wrslot, /* mailslot handle */ ! 707: &retval, /* address of maximum message size */ ! 708: NULL, /* address of size of next message */ ! 709: NULL, /* address of number of messages */ ! 710: NULL /* address of read time-out */ ! 711: )) ! 712: retval=DEFAULT_MAX_MSG_SIZE; ! 713: break; ! 714: ! 715: case VDD_ONLINE: ! 716: if(WaitForSingleObject(hungup_event,0)==WAIT_OBJECT_0) ! 717: retval=0; ! 718: else ! 719: retval=1; ! 720: online_poll++; ! 721: break; ! 722: ! 723: case VDD_YIELD: /* forced yield */ ! 724: vdd_yields++; ! 725: yield(); ! 726: break; ! 727: ! 728: case VDD_MAYBE_YIELD: /* yield if YieldInterval is enabled and expired */ ! 729: maybe_yield(); ! 730: break; ! 731: ! 732: case VDD_LOAD_INI_FILE: /* Load and parse settings file */ ! 733: { ! 734: FILE* fp; ! 735: char cwd[MAX_PATH+1]; ! 736: ! 737: /* Load exec/sbbsexec.ini first (setting default values) */ ! 738: count = getCX(); ! 739: p = (BYTE*)GetVDMPointer((ULONG)((getES() << 16)|getDI()) ! 740: ,count,FALSE); ! 741: iniFileName(ini_fname, sizeof(ini_fname), p, INI_FILENAME); ! 742: if((fp=fopen(ini_fname,"r"))!=NULL) { ! 743: ini=iniReadFile(fp); ! 744: fclose(fp); ! 745: parse_ini(ROOT_SECTION); ! 746: } ! 747: ! 748: /* Load cwd/sbbsexec.ini second (over-riding default values) */ ! 749: GetCurrentDirectory(sizeof(cwd),cwd); ! 750: iniFileName(ini_fname, sizeof(ini_fname), cwd, INI_FILENAME); ! 751: if((fp=fopen(ini_fname,"r"))!=NULL) { ! 752: ini=iniReadFile(fp); ! 753: fclose(fp); ! 754: parse_ini(ROOT_SECTION); ! 755: } ! 756: } ! 757: break; ! 758: ! 759: case VDD_LOAD_INI_SECTION: /* Parse (program-specific) sub-section of settings file */ ! 760: count = getCX(); ! 761: p = (BYTE*)GetVDMPointer((ULONG)((getES() << 16)|getDI()) ! 762: ,count,FALSE); ! 763: parse_ini(p); ! 764: break; ! 765: ! 766: case VDD_DEBUG_OUTPUT: /* Send string to debug output */ ! 767: count = getCX(); ! 768: p = (BYTE*)GetVDMPointer((ULONG)((getES() << 16)|getDI()) ! 769: ,count,FALSE); ! 770: lputs(LOG_INFO, p); ! 771: break; ! 772: ! 773: case VDD_HANGUP: ! 774: hangup(); ! 775: break; ! 776: ! 777: default: ! 778: lprintf(LOG_ERR,"!UNKNOWN VDD_OP: %d",getBL()); ! 779: break; ! 780: } ! 781: setAX((WORD)retval); ! 782: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.