![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dosxtrn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / sbbs3 / dosxtrn|
Return to dosxtrn.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 / dosxtrn |
1.1 ! root 1: /* dosxtrn.c */ ! 2: ! 3: /* Synchronet External DOS Program Launcher (16-bit MSVC 1.52c project) */ ! 4: ! 5: /* $Id: dosxtrn.c,v 1.23 2006/10/28 03:54:09 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 <stdio.h> ! 39: #include <stdlib.h> ! 40: #include <string.h> ! 41: #include <process.h> ! 42: #include <dos.h> /* _dos_set/getvect() */ ! 43: #include <windows.h> /* BOOL, etc. */ ! 44: #include "vdd_func.h" ! 45: #include "execvxd.h" ! 46: #include "isvbop.h" /* ddk\inc */ ! 47: #include "fossdefs.h" ! 48: ! 49: #define VDD_FILENAME "sbbsexec.dll" ! 50: ! 51: /****************************************************************************/ ! 52: /* Truncates white-space chars off end of 'str' and terminates at first tab */ ! 53: /****************************************************************************/ ! 54: static void truncsp(char *str) ! 55: { ! 56: size_t c; ! 57: ! 58: str[strcspn(str,"\t")]=0; ! 59: c=strlen(str); ! 60: while(c && (unsigned char)str[c-1]<=' ') c--; ! 61: str[c]=0; ! 62: } ! 63: short vdd=0; ! 64: BYTE node_num=0; ! 65: int mode=0; ! 66: int revision; ! 67: char id_string[128]; ! 68: #ifdef DEBUG_INT_CALLS ! 69: ulong int14calls=0; ! 70: ulong int16calls=0; ! 71: ulong int21calls=0; ! 72: ulong int29calls=0; ! 73: #endif ! 74: ! 75: void (interrupt *oldint14)(); ! 76: void (interrupt *oldint16)(); ! 77: void (interrupt *oldint21)(); ! 78: void (interrupt *oldint29)(); ! 79: ! 80: ! 81: static int vdd_buf(BYTE op, int count, WORD buf_seg, WORD buf_off) ! 82: { ! 83: int retval; ! 84: ! 85: _asm { ! 86: push bx ! 87: push cx ! 88: push es ! 89: push di ! 90: mov ax, vdd ! 91: mov bh, node_num ! 92: mov bl, op ! 93: mov cx, count ! 94: mov es, buf_seg ! 95: mov di, buf_off ! 96: } ! 97: DispatchCall(); ! 98: _asm { ! 99: mov retval, ax ! 100: pop di ! 101: pop es ! 102: pop cx ! 103: pop bx ! 104: } ! 105: return(retval); ! 106: } ! 107: ! 108: static int vdd_str(BYTE op, char* str) ! 109: { ! 110: WORD buf_seg; ! 111: ! 112: _asm mov buf_seg, ss; ! 113: return vdd_buf(op, strlen(str), buf_seg, (WORD)str); ! 114: } ! 115: ! 116: static int vdd_op(BYTE op) ! 117: { ! 118: int retval; ! 119: ! 120: #if FALSE /* disable yield? */ ! 121: if(op==VDD_YIELD) ! 122: return(0); ! 123: #endif ! 124: _asm { ! 125: push bx ! 126: mov ax, vdd ! 127: mov bh, node_num ! 128: mov bl, op ! 129: } ! 130: DispatchCall(); ! 131: _asm { ! 132: mov retval, ax ! 133: pop bx ! 134: } ! 135: return(retval); ! 136: } ! 137: ! 138: union REGS inregs; ! 139: struct SREGS sregs; ! 140: BOOL inside_int14=FALSE; ! 141: ! 142: /* This function is only necessary for naughty programs that call the vector ! 143: directly instead of issuing an interrupt ! 144: */ ! 145: void interrupt win95int14( ! 146: unsigned _es, unsigned _ds, ! 147: unsigned _di, unsigned _si, ! 148: unsigned _bp, unsigned _sp, ! 149: unsigned _bx, unsigned _dx, ! 150: unsigned _cx, unsigned _ax, ! 151: unsigned flags ) ! 152: { ! 153: union REGS outregs; ! 154: ! 155: /* prevent recursion, just incase the VXD isn't handling int14h */ ! 156: if(inside_int14) ! 157: return; ! 158: ! 159: inside_int14=TRUE; ! 160: ! 161: inregs.x.ax=_ax; ! 162: inregs.x.bx=_bx; ! 163: inregs.x.cx=_cx; ! 164: inregs.x.dx=_dx; ! 165: inregs.x.si=_si; ! 166: inregs.x.di=_di; ! 167: inregs.x.cflag=flags; ! 168: ! 169: sregs.es=_es; ! 170: sregs.ds=_ds; ! 171: ! 172: int86x(0x14,&inregs,&outregs,&sregs); ! 173: ! 174: /* FOSSIL driver only touches these AX and BX */ ! 175: _ax= outregs.x.ax; ! 176: _bx= outregs.x.bx; ! 177: ! 178: inside_int14=FALSE; ! 179: } ! 180: ! 181: void vdd_getstatus(vdd_status_t* status) ! 182: { ! 183: WORD buf_seg; ! 184: ! 185: _asm mov buf_seg, ss; ! 186: if(vdd_buf(VDD_STATUS, sizeof(vdd_status_t), buf_seg, (WORD)status)!=0) ! 187: memset(status,0,sizeof(vdd_status_t)); ! 188: } ! 189: ! 190: WORD PortStatus() ! 191: { ! 192: WORD status=0x0008; /* AL bit 3 (change in DCD) always set */ ! 193: vdd_status_t vdd_status; ! 194: ! 195: vdd_getstatus(&vdd_status); ! 196: ! 197: if(vdd_status.online) /* carrier detect */ ! 198: status|=0x0080; /* DCD */ ! 199: ! 200: if(vdd_status.inbuf_full) /* receive data ready */ ! 201: status|=0x0100; /* RDA */ ! 202: ! 203: /* if(vm->overrun) /* overrun error detected */ ! 204: /* status|=0x0200; /* OVRN */ ! 205: ! 206: if(vdd_status.outbuf_full ! 207: <vdd_status.outbuf_size/2) /* room available in output buffer */ ! 208: status|=0x2000; /* THRE */ ! 209: ! 210: if(!vdd_status.outbuf_full) /* output buffer is empty */ ! 211: status|=0x4000; /* TSRE */ ! 212: ! 213: return(status); ! 214: } ! 215: ! 216: #ifdef DEBUG_FOSSIL_CALLS ! 217: DWORD fossil_calls[0x100]; ! 218: #endif ! 219: ! 220: void interrupt winNTint14( ! 221: unsigned _es, unsigned _ds, ! 222: unsigned _di, unsigned _si, ! 223: unsigned _bp, unsigned _sp, ! 224: unsigned _bx, unsigned _dx, ! 225: unsigned _cx, unsigned _ax, ! 226: ) ! 227: { ! 228: BYTE ch; ! 229: BYTE far* p; ! 230: WORD buf_seg; ! 231: int wr; ! 232: vdd_status_t vdd_status; ! 233: fossil_info_t info = { ! 234: sizeof(info) ! 235: ,FOSSIL_REVISION ! 236: ,revision /* driver revision */ ! 237: ,0 /* ID string pointer */ ! 238: ,0,0 /* receive buffer size/free (overwritten later) */ ! 239: ,0,0 /* transmit buffer size/free (overwritten later) */ ! 240: ,80,25 /* screen dimensions (cols, rows) */ ! 241: /* port settings (i.e. 38400 N-8-1): */ ! 242: ,FOSSIL_BAUD_RATE_38400 ! 243: |FOSSIL_PARITY_NONE ! 244: |FOSSIL_DATA_BITS_8 ! 245: |FOSSIL_STOP_BITS_1 ! 246: }; ! 247: ! 248: #ifdef DEBUG_INT_CALLS ! 249: int14calls++; ! 250: #endif ! 251: ! 252: #ifdef DEBUG_FOSSIL_CALLS ! 253: fossil_calls[_ax>>8]++; ! 254: #endif ! 255: ! 256: switch(_ax>>8) { ! 257: case FOSSIL_FUNC_SET_RATE: /* Initialize/Set baud rate */ ! 258: _ax = PortStatus(); ! 259: break; ! 260: case FOSSIL_FUNC_PUT_CHAR: /* write char to com port, with wait */ ! 261: ch=_ax&0xff; ! 262: _asm mov buf_seg, ss; ! 263: vdd_buf(VDD_WRITE, 1, buf_seg, (WORD)&ch); ! 264: _ax = PortStatus(); ! 265: break; ! 266: case FOSSIL_FUNC_GET_CHAR: /* read char from com port, with wait */ ! 267: _asm mov buf_seg, ss; ! 268: _ax = vdd_buf(VDD_READ, 1, buf_seg, (WORD)&ch); ! 269: if(!_ax) { ! 270: _ax = 0x8000; /* timed-out */ ! 271: vdd_op(VDD_YIELD); ! 272: } else { ! 273: _ax = ch; ! 274: } ! 275: break; ! 276: case FOSSIL_FUNC_GET_STATUS: /* request status */ ! 277: _ax=PortStatus(); ! 278: if(_ax==0x6088) ! 279: vdd_op(VDD_MAYBE_YIELD); ! 280: break; ! 281: case FOSSIL_FUNC_INIT: /* initialize */ ! 282: _ax=FOSSIL_SIGNATURE; /* magic number = success */ ! 283: _bx=FOSSIL_REVISION<<8 | FOSSIL_FUNC_HIGHEST; /* FOSSIL rev/maximum FOSSIL func supported */ ! 284: break; ! 285: case FOSSIL_FUNC_DTR: ! 286: if((_ax&0xff)==0) /* Lower DTR */ ! 287: vdd_op(VDD_HANGUP); ! 288: break; ! 289: case FOSSIL_FUNC_FLUSH_OUT: /* flush output buffer */ ! 290: break; ! 291: case FOSSIL_FUNC_PURGE_OUT: /* purge output buffer */ ! 292: vdd_op(VDD_OUTBUF_PURGE); ! 293: break; ! 294: case FOSSIL_FUNC_PURGE_IN: /* purge input buffer */ ! 295: vdd_op(VDD_INBUF_PURGE); ! 296: break; ! 297: case FOSSIL_FUNC_WRITE_CHAR: /* write char to com port, no wait */ ! 298: if(0 /*RingBufFree(&vm->out)<2 */) { ! 299: _ax=0; /* char was not accepted */ ! 300: break; ! 301: } ! 302: ch=_ax&0xff; ! 303: _asm mov buf_seg, ss; ! 304: _ax = vdd_buf(VDD_WRITE, 1, buf_seg, (WORD)&ch); ! 305: break; ! 306: case FOSSIL_FUNC_PEEK: /* non-destructive read-ahead */ ! 307: vdd_getstatus(&vdd_status); ! 308: if(!vdd_status.inbuf_full) { ! 309: _ax=0xffff; /* no char available */ ! 310: vdd_op(VDD_YIELD); ! 311: break; ! 312: } ! 313: _asm mov buf_seg, ss; ! 314: _ax = vdd_buf(VDD_PEEK, 1, buf_seg, (WORD)&ch); ! 315: if(_ax == 0) ! 316: vdd_op(VDD_YIELD); ! 317: break; ! 318: case FOSSIL_FUNC_READ_BLOCK: /* read block, no wait */ ! 319: vdd_getstatus(&vdd_status); ! 320: if(!vdd_status.inbuf_full) ! 321: _ax = 0; /* no data available */ ! 322: else ! 323: _ax = vdd_buf(VDD_READ, _cx, _es, _di); ! 324: if(_ax == 0) ! 325: vdd_op(VDD_YIELD); ! 326: break; ! 327: case FOSSIL_FUNC_WRITE_BLOCK: /* write block, no wait */ ! 328: _ax = vdd_buf(VDD_WRITE, _cx, _es, _di); ! 329: break; ! 330: case FOSSIL_FUNC_GET_INFO: /* driver info */ ! 331: vdd_getstatus(&vdd_status); ! 332: info.inbuf_size=vdd_status.inbuf_size; ! 333: info.inbuf_free=info.inbuf_size-vdd_status.inbuf_full; ! 334: info.outbuf_size=vdd_status.outbuf_size; ! 335: info.outbuf_free=info.outbuf_size-vdd_status.outbuf_full; ! 336: info.id_string = id_string; ! 337: ! 338: if(vdd_status.inbuf_full==vdd_status.outbuf_full==0) ! 339: vdd_op(VDD_MAYBE_YIELD); ! 340: ! 341: p = _MK_FP(_es,_di); ! 342: wr=sizeof(info); ! 343: if(wr>_cx) ! 344: wr=_cx; ! 345: _fmemcpy(p, &info, wr); ! 346: _ax=wr; ! 347: break; ! 348: } ! 349: } ! 350: ! 351: void int14stub(void) ! 352: { ! 353: /* This function will be overwritten later (during runtime) with FOSSIL signature */ ! 354: } ! 355: ! 356: void interrupt winNTint16( ! 357: unsigned _es, unsigned _ds, ! 358: unsigned _di, unsigned _si, ! 359: unsigned _bp, unsigned _sp, ! 360: unsigned _bx, unsigned _dx, ! 361: unsigned _cx, unsigned _ax, ! 362: unsigned _ip, unsigned _cs, ! 363: unsigned flags ) ! 364: { ! 365: BYTE ch; ! 366: WORD buf_seg; ! 367: vdd_status_t status; ! 368: ! 369: #ifdef DEBUG_INT_CALLS ! 370: int16calls++; ! 371: #endif ! 372: ! 373: vdd_getstatus(&status); ! 374: switch(_ax>>8) { ! 375: case 0x00: /* Read char from keyboard */ ! 376: case 0x10: /* Read char from enhanced keyboard */ ! 377: if(status.inbuf_full) { ! 378: _asm mov buf_seg, ss; ! 379: vdd_buf(VDD_READ, 1, buf_seg, (WORD)&ch); ! 380: _ax=ch; ! 381: return; ! 382: } ! 383: vdd_op(VDD_MAYBE_YIELD); ! 384: break; ! 385: case 0x01: /* Get keyboard status */ ! 386: case 0x11: /* Get enhanced keyboard status */ ! 387: if(status.inbuf_full) { ! 388: _asm mov buf_seg, ss; ! 389: vdd_buf(VDD_PEEK, 1, buf_seg, (WORD)&ch); ! 390: flags&=~(1<<6); /* clear zero flag */ ! 391: _ax=ch; ! 392: return; ! 393: } ! 394: vdd_op(VDD_MAYBE_YIELD); ! 395: break; ! 396: } ! 397: ! 398: _chain_intr(oldint16); ! 399: } ! 400: ! 401: #ifdef DEBUG_DOS_CALLS ! 402: DWORD dos_calls[0x100]; ! 403: #endif ! 404: ! 405: void interrupt winNTint21( ! 406: unsigned _es, unsigned _ds, ! 407: unsigned _di, unsigned _si, ! 408: unsigned _bp, unsigned _sp, ! 409: unsigned _bx, unsigned _dx, ! 410: unsigned _cx, unsigned _ax, ! 411: ) ! 412: { ! 413: #ifdef DEBUG_INT_CALLS ! 414: int21calls++; ! 415: #endif ! 416: if(_ax>>8 == 0x2c) /* GET_SYSTEM_TIME */ ! 417: vdd_op(VDD_MAYBE_YIELD); ! 418: #ifdef DEBUG_DOS_CALLS ! 419: dos_calls[_ax>>8]++; ! 420: #endif ! 421: _chain_intr(oldint21); ! 422: } ! 423: ! 424: void interrupt winNTint29( ! 425: unsigned _es, unsigned _ds, ! 426: unsigned _di, unsigned _si, ! 427: unsigned _bp, unsigned _sp, ! 428: unsigned _bx, unsigned _dx, ! 429: unsigned _cx, unsigned _ax, ! 430: ) ! 431: { ! 432: char ch; ! 433: WORD buf_seg; ! 434: #ifdef DEBUG_INT_CALLS ! 435: int29calls++; ! 436: #endif ! 437: ! 438: ch=_ax&0xff; ! 439: _asm mov buf_seg, ss ! 440: vdd_buf(VDD_WRITE, 1, buf_seg, (WORD)&ch); ! 441: ! 442: _chain_intr(oldint29); ! 443: } ! 444: ! 445: /****************************************************************************/ ! 446: /* Return the filename portion of a full pathname */ ! 447: /****************************************************************************/ ! 448: char* getfname(const char* path) ! 449: { ! 450: const char* fname; ! 451: const char* bslash; ! 452: ! 453: fname=strrchr(path,'/'); ! 454: bslash=strrchr(path,'\\'); ! 455: if(bslash>fname) ! 456: fname=bslash; ! 457: if(fname!=NULL) ! 458: fname++; ! 459: else ! 460: fname=(char*)path; ! 461: return((char*)fname); ! 462: } ! 463: ! 464: char * DllName =VDD_FILENAME; ! 465: char * InitFunc ="VDDInitialize"; ! 466: char * DispFunc ="VDDDispatch"; ! 467: ! 468: int main(int argc, char **argv) ! 469: { ! 470: char str[128]; ! 471: char cmdline[128],*p; ! 472: char dll[256]; ! 473: char exec_dir[128]; ! 474: char* envvar[10]; ! 475: char* arg[16]; ! 476: int i,c,d,envnum=0; ! 477: FILE* fp; ! 478: BOOL NT=FALSE; ! 479: BOOL success=FALSE; ! 480: WORD buf_seg; ! 481: WORD w; ! 482: ! 483: sscanf("$Revision: 1.23 $", "%*s 1.%u", &revision); ! 484: ! 485: sprintf(id_string,"Synchronet FOSSIL Driver (DOSXTRN) revision %u", revision); ! 486: if(argc<2) { ! 487: fprintf(stderr ! 488: ,"%s - Copyright %s Rob Swindell\n" ! 489: ,id_string, __DATE__+7); ! 490: fprintf(stderr ! 491: ,"usage: dosxtrn <path/dosxtrn.env> [NT|95] [node_num] [mode]\n"); ! 492: return(1); ! 493: } ! 494: ! 495: sprintf(exec_dir,"%.*s",sizeof(exec_dir)-1,argv[0]); ! 496: p=getfname(exec_dir); ! 497: *p=0; ! 498: sprintf(dll,"%s%s",exec_dir,VDD_FILENAME); ! 499: DllName=dll; ! 500: ! 501: if(argc>2 && !strcmp(argv[2],"NT")) ! 502: NT=TRUE; ! 503: if(argc>3) ! 504: node_num=atoi(argv[3]); ! 505: if(argc>4) ! 506: mode=atoi(argv[4]); ! 507: ! 508: if((fp=fopen(argv[1],"r"))==NULL) { ! 509: fprintf(stderr,"!Error opening %s\n",argv[1]); ! 510: return(2); ! 511: } ! 512: ! 513: fgets(cmdline, sizeof(cmdline), fp); ! 514: truncsp(cmdline); ! 515: ! 516: arg[0]=cmdline; /* point to the beginning of the string */ ! 517: for(c=0,d=1;cmdline[c];c++) /* Break up command line */ ! 518: if(cmdline[c]==' ') { ! 519: cmdline[c]=0; /* insert nulls */ ! 520: arg[d++]=cmdline+c+1; /* point to the beginning of the next arg */ ! 521: } ! 522: arg[d]=0; ! 523: ! 524: while(!feof(fp)) { ! 525: if(!fgets(str, sizeof(str), fp)) ! 526: break; ! 527: truncsp(str); ! 528: if((envvar[envnum]=strdup(str))==NULL) { ! 529: fprintf(stderr,"!MALLOC ERROR\n"); ! 530: return(4); ! 531: } ! 532: _putenv(envvar[envnum++]); ! 533: } ! 534: fclose(fp); ! 535: ! 536: /* Save int14 handler */ ! 537: oldint14=_dos_getvect(0x14); ! 538: ! 539: /* Overwrite stub function */ ! 540: ((BYTE*)int14stub)[0] = 0xe9; /* jump (relative) */ ! 541: ((BYTE*)int14stub)[3] = 0x90; /* NOP */ ! 542: ((BYTE*)int14stub)[4] = 0x90; /* NOP */ ! 543: ((BYTE*)int14stub)[5] = 0x90; /* NOP */ ! 544: ((BYTE*)int14stub)[6] = FOSSIL_SIGNATURE&0xff; /* FOSSIL sig (LSB) */ ! 545: ((BYTE*)int14stub)[7] = FOSSIL_SIGNATURE>>8; /* FOSSIL sig (MSB) */ ! 546: ((BYTE*)int14stub)[8] = FOSSIL_FUNC_HIGHEST; /* FOSSIL highest func supported */ ! 547: ! 548: if(NT) { /* Windows NT/2000 */ ! 549: ! 550: for(i=0;i<2;i++) { ! 551: ! 552: /* Register VDD */ ! 553: _asm { ! 554: push es ! 555: push ds ! 556: pop es ! 557: mov si, DllName ; ds:si = dll name ! 558: mov di, InitFunc ; es:di = init routine ! 559: mov bx, DispFunc ; ds:bx = dispatch routine ! 560: #if 1 /* Vista work-around, apparently doesn't support an InitFunc (RegisterModule fails with AX=1) */ ! 561: xor di,di ! 562: mov es,di ! 563: #endif ! 564: ! 565: }; ! 566: RegisterModule(); ! 567: _asm { ! 568: mov vdd, ax ! 569: jc err ! 570: mov success, TRUE ! 571: err: ! 572: pop es ! 573: } ! 574: if(success) ! 575: break; ! 576: DllName=VDD_FILENAME; /* try again with no path (for Windows Vista) */ ! 577: } ! 578: if(!success) { ! 579: fprintf(stderr,"Error %d loading %s\n",vdd,DllName); ! 580: return(-1); ! 581: } ! 582: ! 583: #if 0 ! 584: fprintf(stderr,"vdd handle=%d\n",vdd); ! 585: fprintf(stderr,"mode=%d\n",mode); ! 586: #endif ! 587: vdd_str(VDD_LOAD_INI_FILE, exec_dir); ! 588: ! 589: vdd_str(VDD_LOAD_INI_SECTION, getfname(arg[0])); ! 590: ! 591: sprintf(str,"%s, rev %u, %s %s", __FILE__, revision, __DATE__, __TIME__); ! 592: vdd_str(VDD_DEBUG_OUTPUT, str); ! 593: ! 594: i=vdd_op(VDD_OPEN); ! 595: if(i) { ! 596: fprintf(stderr,"!VDD_OPEN ERROR: %d\n",i); ! 597: UnRegisterModule(); ! 598: return(-1); ! 599: } ! 600: oldint16=_dos_getvect(0x16); ! 601: oldint21=_dos_getvect(0x21); ! 602: oldint29=_dos_getvect(0x29); ! 603: if(mode==SBBSEXEC_MODE_FOSSIL) { ! 604: *(WORD*)((BYTE*)int14stub+1) = (WORD)winNTint14 - (WORD)&int14stub - 3; /* jmp offset */ ! 605: _dos_setvect(0x14,(void(interrupt *)())int14stub); ! 606: } ! 607: _dos_setvect(0x21,winNTint21); ! 608: if(mode&SBBSEXEC_MODE_DOS_IN) ! 609: _dos_setvect(0x16,winNTint16); ! 610: if(mode&SBBSEXEC_MODE_DOS_OUT) ! 611: _dos_setvect(0x29,winNTint29); ! 612: } ! 613: else if(mode==SBBSEXEC_MODE_FOSSIL) { /* Windows 95/98/Millennium */ ! 614: *(WORD*)((BYTE*)int14stub+1) = (WORD)win95int14 - (WORD)&int14stub - 3; /* jmp offset */ ! 615: _dos_setvect(0x14,(void(interrupt *)())int14stub); ! 616: } ! 617: ! 618: _heapmin(); ! 619: i=_spawnvp(_P_WAIT, arg[0], arg); ! 620: ! 621: p=argv[1]+(strlen(argv[1])-3); ! 622: strcpy(p,"RET"); ! 623: if((fp=fopen(argv[1],"w+"))==NULL) { ! 624: fprintf(stderr,"!Error opening %s\n",argv[1]); ! 625: return(3); ! 626: } ! 627: fprintf(fp,"%d",i); ! 628: ! 629: /* Restore original ISRs */ ! 630: _dos_setvect(0x14,oldint14); ! 631: ! 632: if(NT) { ! 633: vdd_op(VDD_CLOSE); ! 634: ! 635: _dos_setvect(0x16,oldint16); ! 636: _dos_setvect(0x21,oldint21); ! 637: _dos_setvect(0x29,oldint29); ! 638: ! 639: sprintf(str,"%s returned %d", arg[0], i); ! 640: vdd_str(VDD_DEBUG_OUTPUT, str); ! 641: ! 642: #ifdef DEBUG_INT_CALLS ! 643: sprintf(str,"int14h calls: %u", int14calls); vdd_str(VDD_DEBUG_OUTPUT, str); ! 644: sprintf(str,"int16h calls: %u", int16calls); vdd_str(VDD_DEBUG_OUTPUT, str); ! 645: sprintf(str,"int21h calls: %u", int21calls); vdd_str(VDD_DEBUG_OUTPUT, str); ! 646: sprintf(str,"int29h calls: %u", int29calls); vdd_str(VDD_DEBUG_OUTPUT, str); ! 647: #endif ! 648: #ifdef DEBUG_DOS_CALLS ! 649: for(i=0;i<0x100;i++) { ! 650: if(dos_calls[i]>100) { ! 651: sprintf(str,"int21h function %02X calls: %u\n" ! 652: ,i, dos_calls[i]); ! 653: vdd_str(VDD_DEBUG_OUTPUT, str); ! 654: } ! 655: } ! 656: #endif ! 657: #ifdef DEBUG_FOSSIL_CALLS ! 658: for(i=0;i<0x100;i++) { ! 659: if(fossil_calls[i]>0) { ! 660: sprintf(str,"int14h function %02X calls: %u" ! 661: ,i, fossil_calls[i]); ! 662: vdd_str(VDD_DEBUG_OUTPUT, str); } ! 663: } ! 664: #endif ! 665: ! 666: /* Unregister VDD */ ! 667: _asm mov ax, vdd; ! 668: UnRegisterModule(); ! 669: ! 670: } ! 671: ! 672: return(i); ! 673: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.