/* forces re-creation of DPB when drive is next accessed */ void Force_Drive_Recheck() { regs.h.ah = 0x0d; /* reset disk system of DOS, flush buffers */ intdos(®s, ®s); regs.h.ah = 0x32; /* force re-reading of boot sector (not useful for FAT1x?) */ regs.h.dl = param.drive_number + 1; intdosx(®s, ®s, &sregs); /* DS:BX is DPB pointer on return - ignored! */ segread(&sregs); /* restore defaults */ if (param.fat_type == FAT32) { /* structure is DW size 0x18, DW 0, DD function (2 "force media change"), * plus 0x10 unused bytes */ union REGS r; struct SREGS s; char some_struc[0x20]; memset(some_struc,0, 0x20); some_struc[0] = 0x18; some_struc[4] = 2; r.x.ax = 0x7304; /* get/set FAT32 flag stuff */ s.es = FP_SEG(&some_struc[0]); r.x.di = FP_OFF(&some_struc[0]); r.h.dl = param.drive_number+1; /* A: is 1 etc. */ r.x.cx = 0x18; /* structure size */ intdosx(&r, &r, &s); segread(&sregs); /* restore defaults */ } /* FAT32 */ }
static char *Truename(char *dst, char *src) { union REGS rg; struct SREGS rs; size_t len; if (!src || !*src || !dst) return NULL; rg.h.ah = 0x60; rg.x.si = FP_OFF(src); rg.x.di = FP_OFF(dst); rs.ds = FP_SEG(src); rs.es = FP_SEG(dst); intdosx(&rg, &rg, &rs); if (rg.x.cflag) return NULL; else len = strlen(dst); /* DRR: remove trailing '\', but not if it's a drive * specification */ if (len > 3 && dst[len-1] == '\\') dst[len-1] = '\0'; return dst; }
unsigned GetFAT32SectorSize(int drivenum) { union REGS inregs, outregs; struct SREGS sregs; char drive[4], far* fpDrive = (char far*) &drive; struct xdfree free, far* fpFree = (struct xdfree far*) &free; inregs.x.ax = 0x7303; memcpy(drive, "?:\\", 4); drive[0] = (char) (drivenum+'A'); sregs.ds = FP_SEG(fpDrive); inregs.x.dx = FP_OFF(fpDrive); free.version = 0; sregs.es = FP_SEG(fpFree); inregs.x.di = FP_OFF(fpFree); inregs.x.cx = sizeof(struct xdfree); intdosx(&inregs, &outregs, &sregs); if (outregs.x.cflag) return 0; else if (outregs.h.al == 0) /* Old DOS */ return 0; else return (unsigned) free.BytesPerSector; }
int srch1st(char *pszFile, uint16_t wAttr, fileinfo *pInfo) { /* Search first matching file */ union REGS inreg; union REGS outreg; struct SREGS sregs; DEBUG_ENTER(("srch1st(\"%s\", 0x%04X, 0x%p);\n", pszFile, wAttr, pInfo)); /* Make sure the DTA is assigned before calling DOS functions 4E and 4F */ put_dta((char *)pInfo); inreg.h.ah = 0x4e; inreg.x.cx = wAttr; inreg.x.dx = OFFSET_OF(pszFile); sregs.ds = SEGMENT_OF(pszFile); intdosx(&inreg, &outreg, &sregs); if (CF & outreg.x.cflag) { DEBUG_LEAVE(("return %d; // DOS error code\n", outreg.x.ax)); return (int)(outreg.x.ax); } previousFI = *pInfo; /* Save it for the workaround for the VMWare player bug */ DEBUG_LEAVE(("return 0; // Success\n")); return 0; }
emmtest() { /* Tests for the presence of expnaded memory by attempting to open the file EMMXXXX0. */ union REGS regs; struct SREGS sregs; int error; long handle; /* Attempt to open the file device EMMXXXX0 */ regs.x.ax = 0x3d00; regs.x.dx = (int)"EMMXXXX0"; sregs.ds = 0; //???? intdosx(®s,®s,&sregs); handle = regs.x.ax; error = regs.x.cflag; if (!error) { regs.h.ah = 0x3e; regs.x.bx = handle; intdos(®s,®s); } return error; }
WORD ProgramLoad(char *ProgName, char *Parameters) { char *LoadFile = ProgName; char *CmdLine = Parameters; union REGS r; struct SREGS s; WORD FreeMemorySize; WORD Stack_Seg = 0, Stack_Ptr = 0; struct Parameter_AL00 par_blk; par_blk.EnvSeg = 0; par_blk.CmdLineOffset = FP_OFF(CmdLine); par_blk.CmdLineSeg = FP_SEG(CmdLine); par_blk.FCB1 = par_blk.FCB2 = (DWORD)-1; r.h.ah = 0x48; r.x.bx = 0xFFFF; intdos(&r, &r); if (r.x.bx < MINPARA) { return 8; } Stack_Seg = _SS; Stack_Ptr = _SP; r.x.ax = 0x4B00; /* Load & Execute */ r.x.dx = FP_OFF(LoadFile); r.x.bx = FP_OFF(&par_blk); s.es = s.ds = FP_SEG(LoadFile); intdosx(&r, &r, &s); if (r.x.flags & 1) { return r.x.ax; } disable(); _SS = Stack_Seg; _SP = Stack_Ptr; enable(); return 0; }
extern DIR *opendirx( const char *dirname, char *pattern) { union REGS inregs, outregs; struct SREGS segregs; char pathname[FILENAME_MAX]; DTA far *dtasave; DTA far *dtaptr; char far *pathptr; /*--------------------------------------------------------------------*/ /* Build pathname to be scanned */ /*--------------------------------------------------------------------*/ strcpy(pathname, dirname); if ((*pattern != '/') || (dirname[ strlen(dirname) - 1] != '/')) strcat(pathname,"/"); strcat(pathname, pattern); /* allocate control block */ thisDirP = malloc(sizeof(DIR)); checkref( thisDirP ); /*--------------------------------------------------------------------*/ /* Set disk transfer address */ /*--------------------------------------------------------------------*/ dtasave = (DTA far *)getdta(); dtaptr = (DTA far *)&(thisDirP->dirdta); setdta((char far *)dtaptr); /*--------------------------------------------------------------------*/ /* look for the first file */ /*--------------------------------------------------------------------*/ inregs.h.ah = 0x4e; pathptr = (char far *)pathname; segregs.ds = FP_SEG(pathptr); inregs.x.dx = FP_OFF(pathptr); inregs.x.cx = 0; /* attribute */ intdosx(&inregs, &outregs, &segregs); /* bad directory name? */ if (outregs.x.cflag && (outregs.x.ax == 2 || outregs.x.ax == 3)) { free(thisDirP); return NULL; } thisDirP->dirfirst = outregs.x.cflag ? outregs.x.ax : 0; setdta((char far *)dtasave); strcpy(thisDirP->dirid, "DIR"); #ifdef UDEBUG printmsg(2,"opendir: Address is %p", thisDirP ); #endif openForBusiness = KWTrue; return thisDirP; } /*opendir*/
int ExtendedAbsReadWrite(int drive, int nsects, unsigned long lsect, void* buffer, unsigned area) { union REGS inregs, outregs; struct SREGS sregs; struct DISKIO io; void far* fpBuffer = (void far*) buffer; struct DISKIO far* fpio = (struct DISKIO far*) &io; assert(nsects && buffer); io.diStartSector = lsect; io.diSectors = nsects; io.diBuffer = (unsigned long) fpBuffer; inregs.x.ax = 0x7305; inregs.x.cx = 0xFFFF; inregs.x.si = area; inregs.h.dl = (unsigned char) drive; inregs.x.bx = FP_OFF(fpio); sregs.ds = FP_SEG(fpio); intdosx(&inregs, &outregs, &sregs); return (outregs.x.cflag) ? -1 : 0; }
/* -------------------------------------------------------------------- SCGetName: Gets the name into name of session. -------------------------------------------------------------------- */ int SCGetName( int session, char * name ) { union REGS regs; struct SREGS segregs; regs.h.ah = 0xDF; regs.x.di = 0x534C; regs.x.dx = 0x534C; regs.h.al = 0x04; regs.h.bl = session; intdosx( ®s, ®s, &segregs); { int rc; if (regs.h.al == 1) { if (regs.x.cx) { char far *aux = (char far *)name; /* Power C workaround */ movedata(segregs.es,regs.x.bx, FP_SEG(aux),FP_OFF(aux), regs.x.cx); name[regs.x.cx] = '\0'; } else { sprintf(name, "Work Area Number %d",session); } rc = 0; } else rc = regs.h.ah; return(rc); } }
int valid_drive(char *s) { char buf1[128],buf2[128]; struct SREGS sregs; union REGS regs; if (s[1] != ':') return(0); *TempDrive = *s; /* Make sure this is a valid drive. */ con_fcb[fcbDRIVE] = *TempDrive-'A'+1; regs.x.ax = 0x0f00; regs.x.dx = (unsigned)con_fcb; /* needs NEAR POINTER */ intdos(®s, ®s); if (regs.h.al) { myprintf("Not a valid drive\r\n",0); /* printf("Not a valid drive\n") */ exit(1); } /* end if. */ regs.x.ax = 0x1000; regs.x.dx = (unsigned)con_fcb; /* needs NEAR POINTER */ intdos(®s, ®s); /* Now close the file. */ /* Make sure user is not trying to label a network drive. */ regs.h.ah = IOCTL; regs.h.al = REMOTE; regs.h.bl = (char)(*TempDrive-'A'+1); intdos(®s, ®s); if (regs.x.dx & 0x1000) { myprintf("You cannot label a network drive\r\n",0); /* printf("You cannot label a network drive\n"); */ exit(5); } /* end if. */ /* Make sure the user is not trying to label a drive which has */ /* been ASSIGNed, JOINed, or SUBSTed. */ strcpy(buf1, TempDrive); strcat(buf1, "\\"); segread(&sregs); regs.x.si = (unsigned)buf1; /* needs NEAR POINTER */ regs.x.di = (unsigned)buf2; /* needs NEAR POINTER */ regs.x.ax = 0x6000; intdosx(®s, ®s, &sregs); if (*buf1 != *buf2) { myprintf("You cannot label a drive which has\r\n",0); myprintf("been ASSIGNed, JOINed, or SUBSTed.\r\n",0); exit(5); } /* end if. */ return(1); } /* end valid_drive. */
/* Get the attributes for a file */ int getattr(const char *file) { union REGS r; struct SREGS s; r.x.ax = 0x4300; s.ds = FP_SEG(file); r.x.dx = FP_OFF(file); intdosx(&r, &r, &s); return (r.x.cflag) ? -1 : (int)r.x.cx; }
void Setup_DDPT(void) { /* Get the location of the DDPT */ regs.h.ah =0x35; regs.h.al =0x1e; intdosx(®s, ®s, &sregs); ddpt = MK_FP(sregs.es, regs.x.bx); }
/** * [DosInit description] */ void DosInit() { union REGS regs; struct SREGS segregs; regs.h.ah = GET_INDOS; intdosx(®s, ®s, &segregs); indosPtr = MK_FP(segregs.es, regs.x.bx); if(_osmajor < 3) critErrPtr = indosPtr + 1; else if(_osmajor == 3 && _osminor == 0) critErrPtr = indosPtr - 1; else { regs.x.ax = GET_CRIT_ERR; intdosx(®s, ®s, &segregs); critErrPtr = MK_FP(segregs.ds, regs.x.si); } }
void setdta( char far *dtaptr ) { union REGS inregs, outregs; struct SREGS segregs; /* set DTA address to our buffer */ inregs.h.ah = 0x1a; segregs.ds = FP_SEG(dtaptr); inregs.x.dx = FP_OFF(dtaptr); intdosx(&inregs, &outregs, &segregs); } /* setdta */
int dosx(unsigned char fn) { r.h.ah = fn; intdosx(&r, &r, &s); if (r.x.cflag) { errno = _doserrno; /* Note: DOS error number, not errno.h number! */ return -1; } else return 0; }
void put_dta(char *p_dta) { /* Set the MS-DOS Disk Transfer Address */ union REGS inreg; union REGS outreg; struct SREGS sregs; inreg.h.ah = 0x1a; inreg.x.dx = OFFSET_OF(p_dta); sregs.ds = SEGMENT_OF(p_dta); intdosx(&inreg, &outreg, &sregs); }
int dos_read(int file, void *ptr, unsigned count) { union REGS r; struct SREGS s; r.h.ah = 0x3f; r.x.bx = file; r.x.cx = count; r.x.dx = FP_OFF(ptr); s.ds = FP_SEG(ptr); intdosx(&r,&r,&s); return ( (r.x.cflag) ? 0 : r.x.ax ); }
int dos_open(char *filename, int mode) { union REGS r; struct SREGS s; if (mode); /* mode ignored - readonly supported */ r.h.ah = 0x3d; r.h.al = 0; /* read mode only supoported now !! */ r.x.dx = FP_OFF(filename); s.ds = FP_SEG(filename); intdosx(&r,&r,&s); return ( (r.x.cflag) ? -1 : r.x.ax ); }
void disp_label() { unsigned char serialbuf[26]; union REGS regs; struct SREGS sregs; /* First set the dta to be fcb so information returned is put there. */ regs.x.ax = 0x1a00; regs.x.dx = (unsigned)fcb; /* needs NEAR POINTER */ intdos(®s, ®s); /* Now try to find the volume label. */ fcb[fcbDRIVE] = *Drive-'A'+1; regs.x.ax = 0x1100; regs.x.dx = (unsigned)fcb; /* needs NEAR POINTER */ intdos(®s, ®s); if (regs.h.al) { myprintf("Volume in drive ",0); myprintf(Drive,1); myprintf(" has no label\r\n",0); } /* end if. */ else { NoLabel = 0; fcb[ENDNAME] = '\0'; myprintf("Volume in drive ",0); myprintf(Drive,1); myprintf(" is ",0); myprintf(&fcb[NAME],0); myprintf("\r\n",0); } /* end else. */ /* Now print out the volume serial number, if it exists. */ segread(&sregs); regs.x.ax = 0x6900; regs.h.bl = *Drive-'A'+1; regs.x.dx = (unsigned)serialbuf; /* needs NEAR POINTER */ intdosx(®s, ®s, &sregs); if (!regs.x.cflag) { myprintf("Volume serial number is ",0); hexprint(serialbuf[5]); hexprint(serialbuf[4]); myprintf("-",0); hexprint(serialbuf[3]); hexprint(serialbuf[2]); myprintf("\r\n",0); } /* end if. */ } /* end disp_label. */
/* * newIntVect - set a new 32-bit interrupt vector */ static void newIntVect( int vect, void far *rtn ) { union REGS inregs, outregs; struct SREGS segregs; segread( &segregs ); inregs.w.ax = 0x2506; /* always gain control in prot. mode */ inregs.h.cl = vect; segregs.ds = FP_SEG( rtn ); inregs.x.edx = FP_OFF( rtn ); intdosx( &inregs, &outregs, &segregs ); } /* newIntVect */
/* -------------------------------------------------------------------- SCQuit: Terminate SC -------------------------------------------------------------------- */ void SCQuit( int type ) { union REGS regs; struct SREGS segregs; regs.h.ah = 0xDF; regs.x.di = 0x534C; regs.x.dx = 0x534C; regs.h.al = 14; regs.h.bl = type; intdosx( ®s, ®s, &segregs); }
main() { int i; int unsigned result; int drivestatus[26]; unsigned char FAR *DPB; union REGS regs; struct SREGS sregs; /* routine checks for all valid drive possibilities from A to Z */ /* ** if removable media drive ie. floppy drive A: has a latch door ** open you will get "Abort Retry" panic message */ for (i = 0; i < 26; i++) { /* drive number (0=default, 1=A, 2=B,etc.)*/ regs.h.dl = (unsigned char)(i + 1); segread(&sregs); regs.h.ah=0x32; /* DOS interrupt 32H */ /* was undocumented for DOS release 3.2 */ intdosx(®s,®s, &sregs); result=regs.h.al; DPB = MK_FP(sregs.ds, regs.x.bx); /* ** result =0 then valid drive ** =255 or ff hex then invalid or non-existent drive */ if (0 == result && *DPB != (unsigned char)i) drivestatus[i] = 1; else drivestatus[i]=result; } for (i = 0; i < 26; i = i + 2) { printf("drive %c: status code =%3d drive %c: status code =%3d\n", 'A' + i,drivestatus[i],'B' + i,drivestatus[i+1]); } return 0; }
/* * resetIntVect - reset a 32-bit interrupt vector */ static void resetIntVect( int vect, int_vect_32 *vinfo ) { union REGS inregs, outregs; struct SREGS segregs; segread( &segregs ); inregs.w.ax = 0x2507; /* set prot. and real mode vect */ inregs.h.cl = vect; segregs.ds = FP_SEG( vinfo->prot ); inregs.x.edx = FP_OFF( vinfo->prot ); inregs.x.ebx = (unsigned long) vinfo->real; intdosx( &inregs, &outregs, &segregs ); } /* resetIntVect */
/* * getIntVect - get a 32-bit interrupt vector */ static void getIntVect( int vect, int_vect_32 *vinfo ) { union REGS inregs, outregs; struct SREGS segregs; segread( &segregs ); inregs.w.ax = 0x2502; /* get prot. mode vect */ inregs.h.cl = vect; intdosx( &inregs, &outregs, &segregs ); vinfo->prot = MK_FP( segregs.es, outregs.x.ebx ); inregs.w.ax = 0x2503; /* get real mode vect */ inregs.h.cl = vect; intdos( &inregs, &outregs ); vinfo->real = (void *) outregs.x.ebx; } /* getIntVect */
void main() { union REGS r; struct SREGS s; #if defined(__386__) s.ds = s.es = s.fs = s.gs = FP_SEG( &s ); #endif r.h.ah = 0x35; /* get vector */ r.h.al = 0x33; /* vector 0x33 */ intdosx( &r, &r, &s ); #if defined(__386__) printf( "mouse handler address=%4.4x:%lx\n", s.es, r.x.ebx ); #else printf( "mouse handler address=%4.4x:%4.4x\n", s.es, r.x.bx ); #endif }
int get_file_attributes(const char *name, unsigned *pAttr) { /* Get File Attributes */ union REGS inreg; union REGS outreg; struct SREGS sregs; inreg.x.ax = 0x4300; inreg.x.dx = OFFSET_OF(name); sregs.ds = SEGMENT_OF(name); intdosx(&inreg, &outreg, &sregs); if (CF & outreg.x.cflag) { errno = outreg.x.ax; return errno; } *pAttr = outreg.x.cx; return 0; }
void _fullpath(char * truename, char * rawname, unsigned int namelen) { union REGS regs; struct SREGS sregs; if (namelen < 128) { truename[0] = '\0'; return; } regs.x.ax = 0x6000; /* truename */ regs.x.si = FP_OFF(rawname); sregs.ds = FP_SEG(rawname); regs.x.di = FP_OFF(truename); sregs.es = FP_SEG(truename); intdosx(®s, ®s, &sregs); if (regs.x.cflag != 0) { truename[0] = '\0'; } }
int main() {union REGS inregs, outregs; struct SREGS segs; char *filename="d:\\abc\\a.txt"; int handle; inregs.h.ah=0x3d; inregs.h.al=0; inregs.x.dx=(unsigned)filename; segread(&segs); intdosx(&inregs,&outregs, &segs); if(outregs.x.cflag) printf("Error:%d\n",outregs.x.ax); else {handle=outregs.x.ax; printf("Success! handle=%d\n",handle); } getch(); return 0; }
char *Truename(char *dst, char *src) { union REGS rg; struct SREGS rs; if (!src || !*src || !dst) return NULL; src = trim(src); rg.h.ah = 0x60; rg.x.si = FP_OFF(src); rg.x.di = FP_OFF(dst); rs.ds = FP_SEG(src); rs.es = FP_SEG(dst); intdosx(&rg, &rg, &rs); return (rg.x.cflag) ? NULL : dst; }
int EmsCheck(void) { static char DriverName[] = { 'E', 'M', 'M', 'X', 'X', 'X', 'X', '0' }; union REGS regs; struct SREGS sregs; char far *s; int i; /* retrieve pointer to driver header */ regs.x.ax = 0x3567; intdosx(®s, ®s, &sregs); /* getvect */ s = (char far *)MK_FP(sregs.es, 10); /* build far pointer */ /* now compare with what it should be */ for(i = 0; i < sizeof(DriverName); i++) { if(s[i] != DriverName[i]) break; } return i == sizeof(DriverName); }