miscemu/int21.c

   1 /*
   2  * (c) 1993, 1994 Erik Bos
   3  */
   4
   5 #include <time.h>
   6 #include <fcntl.h>
   7 #include <errno.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <sys/file.h>
  11 #include <string.h>
  12 #include <sys/stat.h>
  13 #include <sys/time.h>
  14 #include <sys/types.h>
  15 #include <unistd.h>
  16 #include <utime.h>
  17 #include <ctype.h>
  18 #include "prototypes.h"
  19 #include "regfunc.h"
  20 #include "windows.h"
  21 #include "wine.h"
  22 #include "msdos.h"
  23 #include "registers.h"
  24 #include "options.h"
  25 #include "stddebug.h"
  26 /* #define DEBUG_INT */
  27 /* #undef  DEBUG_INT */
  28 #include "debug.h"
  29
  30 WORD ExtendedError, CodePage = 437;
  31 BYTE ErrorClass, Action, ErrorLocus;
  32 BYTE *dta;
  33
  34 struct DosHeap {
  35         BYTE dta[256];
  36         BYTE InDosFlag;
  37         BYTE biosdate[8];
  38 };
  39 static struct DosHeap *heap;
  40
  41 WORD sharing_retries = 3;      /* number of retries at sharing violation */
  42 WORD sharing_pause = 1;        /* pause between retries */
  43
  44 extern char TempDirectory[];
  45 void IntBarf(int i, struct sigcontext_struct *context);
  46
  47 static int Error(int e, int class, int el)
  48 {
  49         ErrorClass = class;
  50         Action = SA_Ask4Retry;
  51         ErrorLocus = el;
  52         ExtendedError = e;
  53
  54         return e;
  55 }
  56
  57 void errno_to_doserr(void)
  58 {
  59         switch (errno) {
  60                 case EAGAIN:
  61                         Error (ShareViolation, EC_Temporary, EL_Unknown);
  62                         break;
  63                 case EBADF:
  64                         Error (InvalidHandle, EC_AppError, EL_Unknown);
  65                         break;
  66                 case ENOSPC:
  67                         Error (DiskFull, EC_MediaError, EL_Disk);
  68                         break;
  69                 case EACCES:
  70                 case EPERM:
  71                 case EROFS:
  72                         Error (WriteProtected, EC_AccessDenied, EL_Unknown);
  73                         break;
  74                 case EBUSY:
  75                         Error (LockViolation, EC_AccessDenied, EL_Unknown);
  76                         break;
  77                 case ENOENT:
  78                         Error (FileNotFound, EC_NotFound, EL_Unknown);
  79                         break;
  80                 case EISDIR:
  81                         Error (CanNotMakeDir, EC_AccessDenied, EL_Unknown);
  82                         break;
  83                 case ENFILE:
  84                 case EMFILE:
  85                         Error (NoMoreFiles, EC_MediaError, EL_Unknown);
  86                         break;
  87                 case EEXIST:
  88                         Error (FileExists, EC_Exists, EL_Disk);
  89                         break;
  90                 default:
  91                         fprintf(stderr, "int21: unknown errno %d!\n", errno);
  92                         Error (GeneralFailure, EC_SystemFailure, EL_Unknown);
  93                         break;
  94         }
  95 }
  96
  97 /*
  98 static void Barf(struct sigcontext_struct *context)
  99 {
 100         fprintf(stdnimp, "int21: unknown/not implemented parameters:\n");
 101         fprintf(stdnimp, "int21: AX %04x, BX %04x, CX %04x, DX %04x, "
 102                "SI %04x, DI %04x, DS %04x, ES %04x\n",
 103                AX, BX, CX, DX, SI, DI, DS, ES);
 104 }
 105 */
 106
 107 void ChopOffWhiteSpace(char *string)
 108 {
 109         int length;
 110
 111         for (length = strlen(string) ; length ; length--)
 112                 if (string[length] == ' ')
 113                         string[length] = '\0';
 114 }
 115
 116 static void CreateBPB(int drive, BYTE *data)
 117 {
 118         if (drive > 1) {
 119                 setword(data, 512);
 120                 data[2] = 2;
 121                 setword(&data[3], 0);
 122                 data[5] = 2;
 123                 setword(&data[6], 240);
 124                 setword(&data[8], 64000);
 125                 data[0x0a] = 0xf8;
 126                 setword(&data[0x0b], 40);
 127                 setword(&data[0x0d], 56);
 128                 setword(&data[0x0f], 2);
 129                 setword(&data[0x11], 0);
 130                 setword(&data[0x1f], 800);
 131                 data[0x21] = 5;
 132                 setword(&data[0x22], 1);
 133         } else { /* 1.44mb */
 134                 setword(data, 512);
 135                 data[2] = 2;
 136                 setword(&data[3], 0);
 137                 data[5] = 2;
 138                 setword(&data[6], 240);
 139                 setword(&data[8], 2880);
 140                 data[0x0a] = 0xf8;
 141                 setword(&data[0x0b], 6);
 142                 setword(&data[0x0d], 18);
 143                 setword(&data[0x0f], 2);
 144                 setword(&data[0x11], 0);
 145                 setword(&data[0x1f], 80);
 146                 data[0x21] = 7;
 147                 setword(&data[0x22], 2);
 148         }
 149 }
 150
 151 static void GetFreeDiskSpace(struct sigcontext_struct *context)
 152 {
 153         int drive;
 154         long size,available;
 155
 156         if (DL == 0)
 157                 drive = DOS_GetDefaultDrive();
 158         else
 159                 drive = DL - 1;
 160
 161         if (!DOS_ValidDrive(drive)) {
 162                 Error(InvalidDrive, EC_MediaError , EL_Disk);
 163                 AX = 0xffff;
 164                 return;
 165         }
 166
 167         if (!DOS_GetFreeSpace(drive, &size, &available)) {
 168                 Error(GeneralFailure, EC_MediaError , EL_Disk);
 169                 AX = 0xffff;
 170                 return;
 171         }
 172
 173         AX = 4;
 174         CX = 512;
 175
 176         BX = (available / (CX * AX));
 177         DX = (size / (CX * AX));
 178         Error (0,0,0);
 179 }
 180
 181 static void GetDriveAllocInfo(struct sigcontext_struct *context)
 182 {
 183         int drive;
 184         long size, available;
 185         BYTE mediaID;
 186
 187         if (!DOS_ValidDrive(DL)) {
 188                 AX = 4;
 189                 CX = 512;
 190                 DX = 0;
 191                 Error (InvalidDrive, EC_MediaError, EL_Disk);
 192                 return;
 193         }
 194
 195         if (!DOS_GetFreeSpace(DL, &size, &available)) {
 196                 Error(GeneralFailure, EC_MediaError , EL_Disk);
 197                 AX = 0xffff;
 198                 return;
 199         }
 200
 201         EAX = 4;
 202         ECX = 512;
 203         EDX = (size / (CX * AX));
 204
 205         mediaID = 0xf0;
 206
 207         DS = segment(mediaID);
 208         BX = offset(mediaID);
 209         Error (0,0,0);
 210 }
 211
 212 static void GetDefDriveAllocInfo(struct sigcontext_struct *context)
 213 {
 214         DX = DOS_GetDefaultDrive();
 215         GetDriveAllocInfo(context);
 216 }
 217
 218 static void GetDrivePB(struct sigcontext_struct *context)
 219 {
 220         Error (InvalidDrive, EC_MediaError, EL_Disk);
 221         AX = 0x00ff;
 222                 /* I'm sorry but I only got networked drives :-) */
 223 }
 224
 225 static void ReadFile(struct sigcontext_struct *context)
 226 {
 227         char *ptr;
 228         int size;
 229
 230         /* can't read from stdout / stderr */
 231         if ((BX == 1) || (BX == 2)) {
 232                 Error (InvalidHandle, EL_Unknown, EC_Unknown);
 233                 AX = InvalidHandle;
 234                 SetCflag;
 235                 return;
 236         }
 237
 238         ptr = SAFEMAKEPTR (DS,DX);
 239         if (BX == 0) {
 240                 *ptr = EOF;
 241                 Error (0,0,0);
 242                 AX = 1;
 243                 ResetCflag;
 244                 return;
 245         } else {
 246                 size = read(BX, ptr, CX);
 247                 if (size == -1) {
 248                         errno_to_doserr();
 249                         AL = ExtendedError;
 250                         SetCflag;
 251                         return;
 252                 }
 253                 Error (0,0,0);
 254                 AX = size;
 255                 ResetCflag;
 256         }
 257 }
 258
 259 static void WriteFile(struct sigcontext_struct *context)
 260 {
 261         char *ptr;
 262         int x,size;
 263
 264         ptr = SAFEMAKEPTR (DS,DX);
 265
 266         if (BX == 0) {
 267                 Error (InvalidHandle, EC_Unknown, EL_Unknown);
 268                 EAX = InvalidHandle;
 269                 SetCflag;
 270                 return;
 271         }
 272
 273         if (BX < 3) {
 274                 for (x = 0;x != CX;x++) {
 275                         dprintf_int(stddeb, "%c", *ptr++);
 276                 }
 277                 fflush(stddeb);
 278
 279                 Error (0,0,0);
 280                 AL = CX;
 281                 ResetCflag;
 282         } else {
 283                 size = write(BX, ptr , CX);
 284                 if (size == 0) {
 285                         Error (WriteFault, EC_Unknown, EL_Unknown);
 286                         AL = ExtendedError;
 287                         return;
 288                 }
 289
 290                 if (size == -1) {
 291                         errno_to_doserr();
 292                         AL = ExtendedError;
 293                         SetCflag;
 294                         return;
 295                 }
 296                 Error (0,0,0);
 297                 AX = size;
 298                 ResetCflag;
 299         }
 300 }
 301
 302 static void SeekFile(struct sigcontext_struct *context)
 303 {
 304         off_t status, fileoffset;
 305
 306         switch (AL) {
 307                 case 1: fileoffset = SEEK_CUR;
 308                         break;
 309                 case 2: fileoffset = SEEK_END;
 310                         break;
 311                 default:
 312                 case 0: fileoffset = SEEK_SET;
 313                         break;
 314                 }
 315         status = lseek(BX, (CX << 16) + DX, fileoffset);
 316         if (status == -1) {
 317                 errno_to_doserr();
 318                 AL = ExtendedError;                     SetCflag;
 319                 return;
 320         }
 321         Error (0,0,0);
 322         AX = (status & 0xffff);
 323         DX = ((status >> 16) & 0xffff);
 324
 325         ResetCflag;
 326 }
 327
 328 static void ioctlGetDeviceInfo(struct sigcontext_struct *context)
 329 {
 330         switch (BX) {
 331                 case 0:
 332                 case 1:
 333                 case 2:
 334                         DX = 0x80d3;
 335                         break;
 336
 337                 default:
 338                 {
 339                     struct stat sbuf;
 340
 341                     if (fstat(BX, &sbuf) < 0)
 342                     {
 343                         IntBarf(0x21, context);
 344                         DX = 0x50;
 345                         SetCflag;
 346                         return;
 347                     }
 348
 349                     /* This isn't the right answer, but should be close enough. */
 350                     DX = 0x0943;
 351                 }
 352         }
 353         ResetCflag;
 354 }
 355
 356 static void ioctlGenericBlkDevReq(struct sigcontext_struct *context)
 357 {
 358         BYTE *dataptr = SAFEMAKEPTR(DS, DX);
 359         int drive;
 360
 361         if (BL == 0)
 362                 drive = DOS_GetDefaultDrive();
 363         else
 364                 drive = BL - 1;
 365
 366         if (!DOS_ValidDrive(drive)) {
 367                 AX = 0x02;
 368                 SetCflag;
 369                 return;
 370         }
 371
 372         if (CH != 0x08) {
 373                 IntBarf(0x21, context);
 374                 return;
 375         }
 376         switch (CL) {
 377                 case 0x60: /* get device parameters */
 378                            /* used by w4wgrp's winfile */
 379                         memset(dataptr, 0, 0x26);
 380                         dataptr[0] = 0x04;
 381                         dataptr[6] = 0; /* media type */
 382                         if (drive > 1)
 383                         {
 384                                 dataptr[1] = 0x05; /* fixed disk */
 385                                 setword(&dataptr[2], 0x01); /* non removable */
 386                                 setword(&dataptr[4], 0x300); /* # of cylinders */
 387                         }
 388                         else
 389                         {
 390                                 dataptr[1] = 0x07; /* block dev, floppy */
 391                                 setword(&dataptr[2], 0x02); /* removable */
 392                                 setword(&dataptr[4], 80); /* # of cylinders */
 393                         }
 394                         CreateBPB(drive, &dataptr[7]);
 395                         ResetCflag;
 396                         return;
 397                 default:
 398                         IntBarf(0x21, context);
 399         }
 400 }
 401
 402 static void GetSystemDate(struct sigcontext_struct *context)
 403 {
 404         struct tm *now;
 405         time_t ltime;
 406
 407         ltime = time(NULL);
 408         now = localtime(&ltime);
 409
 410         CX = now->tm_year + 1900;
 411         DX = ((now->tm_mon + 1) << 8) | now->tm_mday;
 412         AX = now->tm_wday;
 413 }
 414
 415 static void GetSystemTime(struct sigcontext_struct *context)
 416 {
 417         struct tm *now;
 418         struct timeval tv;
 419
 420         gettimeofday(&tv,NULL);         /* Note use of gettimeofday(), instead of time() */
 421         now = localtime(&tv.tv_sec);
 422
 423         CX = (now->tm_hour<<8) | now->tm_min;
 424         DX = (now->tm_sec<<8) | tv.tv_usec/10000;
 425                                         /* Note hundredths of seconds */
 426 }
 427
 428 static void GetExtendedErrorInfo(struct sigcontext_struct *context)
 429 {
 430         AL = ExtendedError;
 431         BX = (ErrorClass << 8) | Action;
 432         CH = ErrorLocus << 8;
 433 }
 434
 435 static void CreateFile(struct sigcontext_struct *context)
 436 {
 437         int handle;
 438
 439         if ((handle = open(GetUnixFileName( SAFEMAKEPTR(DS,DX)),
 440            O_CREAT | O_TRUNC | O_RDWR )) == -1) {
 441                 errno_to_doserr();
 442                 AL = ExtendedError;
 443                 SetCflag;
 444                 return;
 445                 }
 446         Error (0,0,0);
 447         EAX = (EAX & 0xffff0000) | handle;
 448         ResetCflag;
 449 }
 450
 451 void OpenExistingFile(struct sigcontext_struct *context)
 452 {
 453         int handle;
 454         int mode;
 455         int lock;
 456
 457         switch (AX & 0x0007)
 458         {
 459           case 0:
 460             mode = O_RDONLY;
 461             break;
 462
 463           case 1:
 464             mode = O_WRONLY;
 465             break;
 466
 467           default:
 468             mode = O_RDWR;
 469             break;
 470         }
 471
 472         if ((handle = open(GetUnixFileName(SAFEMAKEPTR(DS,DX)), mode)) == -1) {
 473                 errno_to_doserr();
 474                 AL = ExtendedError;
 475                 SetCflag;
 476                 return;
 477         }
 478
 479         switch (AX & 0x0070)
 480         {
 481           case 0x00:    /* compatability mode */
 482           case 0x40:    /* DENYNONE */
 483             lock = -1;
 484             break;
 485
 486           case 0x30:    /* DENYREAD */
 487             dprintf_int(stdnimp,
 488               "OpenExistingFile (%s): DENYREAD changed to DENYALL\n",
 489               SAFEMAKEPTR(DS,DX));
 490           case 0x10:    /* DENYALL */
 491             lock = LOCK_EX;
 492             break;
 493
 494           case 0x20:    /* DENYWRITE */
 495             lock = LOCK_SH;
 496             break;
 497
 498           default:
 499             lock = -1;
 500         }
 501
 502         if (lock != -1)
 503         {
 504
 505           int result,retries=sharing_retries;
 506           {
 507             result = flock(handle, lock | LOCK_NB);
 508             if ( retries && (!result) )
 509             {
 510               int i;
 511               for(i=0;i<32768*((int)sharing_pause);i++)
 512                   result++;                          /* stop the optimizer */
 513               for(i=0;i<32768*((int)sharing_pause);i++)
 514                   result--;
 515             }
 516           }
 517           while( (!result) && (!(retries--)) );
 518
 519           if(result)
 520           {
 521             errno_to_doserr();
 522             EAX = (EAX & 0xffffff00) | ExtendedError;
 523             close(handle);
 524             SetCflag;
 525             return;
 526           }
 527
 528         }
 529
 530         Error (0,0,0);
 531         EAX = (EAX & 0xffff0000) | handle;
 532         ResetCflag;
 533 }
 534
 535 static void CloseFile(struct sigcontext_struct *context)
 536 {
 537         if (close(BX) == -1) {
 538                 errno_to_doserr();
 539                 AL = ExtendedError;
 540                 SetCflag;
 541                 return;
 542         }
 543         Error (0,0,0);
 544         AL = NoError;
 545         ResetCflag;
 546 }
 547
 548 static void RenameFile(struct sigcontext_struct *context)
 549 {
 550         char *newname, *oldname;
 551
 552         dprintf_int(stddeb,"int21: renaming %s to %s\n",
 553                         SAFEMAKEPTR(DS,DX), SAFEMAKEPTR(ES,DI) );
 554
 555         oldname = GetUnixFileName( SAFEMAKEPTR(DS,DX) );
 556         newname = GetUnixFileName( SAFEMAKEPTR(ES,DI) );
 557
 558         rename( oldname, newname);
 559         ResetCflag;
 560 }
 561
 562
 563 static void MakeDir(struct sigcontext_struct *context)
 564 {
 565         char *dirname;
 566
 567         dprintf_int(stddeb,"int21: makedir %s\n", SAFEMAKEPTR(DS,DX) );
 568
 569         if ((dirname = GetUnixFileName( SAFEMAKEPTR(DS,DX) ))== NULL) {
 570                 AL = CanNotMakeDir;
 571                 SetCflag;
 572                 return;
 573         }
 574
 575         if (mkdir(dirname,0) == -1) {
 576                 AL = CanNotMakeDir;
 577                 SetCflag;
 578                 return;
 579         }
 580         ResetCflag;
 581 }
 582
 583 static void ChangeDir(struct sigcontext_struct *context)
 584 {
 585         int drive;
 586         char *dirname = SAFEMAKEPTR(DS,DX);
 587         drive = DOS_GetDefaultDrive();
 588         dprintf_int(stddeb,"int21: changedir %s\n", dirname);
 589         if (dirname != NULL && dirname[1] == ':') {
 590                 drive = toupper(dirname[0]) - 'A';
 591                 dirname += 2;
 592                 }
 593         if (!DOS_ChangeDir(drive, dirname))
 594         {
 595                 SetCflag;
 596                 AX=0x03;
 597         }
 598 }
 599
 600 static void RemoveDir(struct sigcontext_struct *context)
 601 {
 602         char *dirname;
 603
 604         dprintf_int(stddeb,"int21: removedir %s\n", SAFEMAKEPTR(DS,DX) );
 605
 606         if ((dirname = GetUnixFileName( SAFEMAKEPTR(DS,DX) ))== NULL) {
 607                 AL = CanNotMakeDir;
 608                 SetCflag;
 609                 return;
 610         }
 611
 612 /*
 613         if (strcmp(unixname,DosDrives[drive].CurrentDirectory)) {
 614                 AL = CanNotRemoveCwd;
 615                 SetCflag;
 616         }
 617 */
 618         if (rmdir(dirname) == -1) {
 619                 AL = CanNotMakeDir;
 620                 SetCflag;
 621         }
 622         ResetCflag;
 623 }
 624
 625 static void ExecProgram(struct sigcontext_struct *context)
 626 {
 627         execl("wine", GetUnixFileName( SAFEMAKEPTR(DS,DX)) );
 628 }
 629
 630 static void FindNext(struct sigcontext_struct *context)
 631 {
 632         struct dosdirent *dp;
 633
 634         memcpy(&dp, dta+0x0d, sizeof(dp));
 635
 636         do {
 637                 if ((dp = DOS_readdir(dp)) == NULL) {
 638                         Error(NoMoreFiles, EC_MediaError , EL_Disk);
 639                         AL = NoMoreFiles;
 640                         SetCflag;
 641                         return;
 642                 }
 643         } /* while (*(dta + 0x0c) != dp->attribute);*/
 644        while ( ( dp->search_attribute & dp->attribute) != dp->attribute);
 645
 646         *(dta + 0x15) = dp->attribute;
 647         setword(&dta[0x16], 0x1234); /* time */
 648         setword(&dta[0x18], 0x1234); /* date */
 649         setdword(&dta[0x1a], dp->filesize);
 650         strncpy(dta + 0x1e, dp->filename, 13);
 651
 652         AL = 0;
 653         ResetCflag;
 654         return;
 655 }
 656
 657 static void FindFirst(struct sigcontext_struct *context)
 658 {
 659         BYTE drive, *path = SAFEMAKEPTR(DS, DX);
 660         struct dosdirent *dp;
 661
 662         if ((*path)&&(path[1] == ':')) {
 663                 drive = (islower(*path) ? toupper(*path) : *path) - 'A';
 664
 665                 if (!DOS_ValidDrive(drive)) {
 666                         Error(InvalidDrive, EC_MediaError , EL_Disk);
 667                         AL = InvalidDrive;
 668                         SetCflag;
 669                         return;
 670                 }
 671         } else
 672                 drive = DOS_GetDefaultDrive();
 673
 674         *dta = drive;
 675         memset(dta + 1 , '?', 11);
 676         *(dta + 0x0c) = ECX & (FA_LABEL | FA_DIREC);
 677
 678         if (ECX & FA_LABEL) {
 679                 /* return volume label */
 680
 681                 if (DOS_GetVolumeLabel(drive) != NULL)
 682                         strncpy(dta + 0x1e, DOS_GetVolumeLabel(drive), 8);
 683
 684                 AL = 0;
 685                 ResetCflag;
 686                 return;
 687         }
 688
 689         if ((dp = DOS_opendir(path)) == NULL) {
 690                 Error(PathNotFound, EC_MediaError, EL_Disk);
 691                 AL = FileNotFound;
 692                 SetCflag;
 693                 return;
 694         }
 695
 696         dp->search_attribute = ECX & (FA_LABEL | FA_DIREC);
 697         memcpy(dta + 0x0d, &dp, sizeof(dp));
 698         FindNext(context);
 699 }
 700
 701 static void GetFileDateTime(struct sigcontext_struct *context)
 702 {
 703         char *filename;
 704         struct stat filestat;
 705         struct tm *now;
 706
 707         if ((filename = GetUnixFileName( SAFEMAKEPTR(DS,DX) ))== NULL) {
 708                 AL = FileNotFound;
 709                 SetCflag;
 710                 return;
 711         }
 712         stat(filename, &filestat);
 713
 714         now = localtime (&filestat.st_mtime);
 715
 716         CX = ((now->tm_hour * 0x2000) + (now->tm_min * 0x20) + now->tm_sec/2);
 717         DX = ((now->tm_year * 0x200) + (now->tm_mon * 0x20) + now->tm_mday);
 718
 719         ResetCflag;
 720 }
 721
 722 static void SetFileDateTime(struct sigcontext_struct *context)
 723 {
 724         char *filename;
 725         struct utimbuf filetime;
 726
 727         filename = GetUnixFileName( SAFEMAKEPTR(DS,DX) );
 728
 729         filetime.actime = 0L;
 730         filetime.modtime = filetime.actime;
 731
 732         utime(filename, &filetime);
 733         ResetCflag;
 734 }
 735
 736 static void CreateTempFile(struct sigcontext_struct *context)
 737 {
 738         char temp[256];
 739         int handle;
 740
 741         sprintf(temp,"%s\\win%d.tmp",TempDirectory,(int) getpid());
 742
 743         dprintf_int(stddeb,"CreateTempFile %s\n",temp);
 744
 745         handle = open(GetUnixFileName(temp), O_CREAT | O_TRUNC | O_RDWR);
 746
 747         if (handle == -1) {
 748                 AL = WriteProtected;
 749                 SetCflag;
 750                 return;
 751         }
 752
 753         strcpy(SAFEMAKEPTR(DS,DX), temp);
 754
 755         AX = handle;
 756         ResetCflag;
 757 }
 758
 759 static void CreateNewFile(struct sigcontext_struct *context)
 760 {
 761         int handle;
 762
 763         if ((handle = open(GetUnixFileName( SAFEMAKEPTR(DS,DX) ), O_CREAT | O_EXCL | O_RDWR)) == -1) {
 764                 AL = WriteProtected;
 765                 SetCflag;
 766                 return;
 767         }
 768
 769         AX = handle;
 770         ResetCflag;
 771 }
 772
 773 static void GetCurrentDirectory(struct sigcontext_struct *context)
 774 {
 775         int drive;
 776
 777         if (DL == 0)
 778                 drive = DOS_GetDefaultDrive();
 779         else
 780                 drive = DL - 1;
 781
 782         if (!DOS_ValidDrive(drive)) {
 783                 AL = InvalidDrive;
 784                 SetCflag;
 785                 return;
 786         }
 787
 788         strcpy(SAFEMAKEPTR(DS,SI), DOS_GetCurrentDir(drive) );
 789         ResetCflag;
 790 }
 791
 792 static void GetDiskSerialNumber(struct sigcontext_struct *context)
 793 {
 794         int drive;
 795         BYTE *dataptr = SAFEMAKEPTR(DS, DX);
 796         DWORD serialnumber;
 797
 798         if (BL == 0)
 799                 drive = DOS_GetDefaultDrive();
 800         else
 801                 drive = BL - 1;
 802
 803         if (!DOS_ValidDrive(drive)) {
 804                 AL =InvalidDrive;
 805                 SetCflag;
 806                 return;
 807         }
 808
 809         DOS_GetSerialNumber(drive, &serialnumber);
 810
 811         setword(dataptr, 0);
 812         setdword(&dataptr[2], serialnumber);
 813         strncpy(dataptr + 6, DOS_GetVolumeLabel(drive), 8);
 814         strncpy(dataptr + 0x11, "FAT16   ", 8);
 815
 816         AL = 0;
 817         ResetCflag;
 818 }
 819
 820 static void SetDiskSerialNumber(struct sigcontext_struct *context)
 821 {
 822         int drive;
 823         BYTE *dataptr = SAFEMAKEPTR(DS, DX);
 824         DWORD serialnumber;
 825
 826         if (BL == 0)
 827                 drive = DOS_GetDefaultDrive();
 828         else
 829                 drive = BL - 1;
 830
 831         if (!DOS_ValidDrive(drive)) {
 832                 AL = InvalidDrive;
 833                 SetCflag;
 834                 return;
 835         }
 836
 837         serialnumber = dataptr[1] + (dataptr[2] << 8) + (dataptr[3] << 16) +
 838                         (dataptr[4] << 24);
 839
 840         DOS_SetSerialNumber(drive, serialnumber);
 841         AL = 1L;
 842         ResetCflag;
 843 }
 844
 845 static void DumpFCB(BYTE *fcb)
 846 {
 847         int x, y;
 848
 849         fcb -= 7;
 850
 851         for (y = 0; y !=2 ; y++) {
 852                 for (x = 0; x!=15;x++)
 853                         dprintf_int(stddeb, "%02x ", *fcb++);
 854                 dprintf_int(stddeb,"\n");
 855         }
 856 }
 857
 858 /* microsoft's programmers should be shot for using CP/M style int21
 859    calls in Windows for Workgroup's winfile.exe */
 860
 861 static void FindFirstFCB(struct sigcontext_struct *context)
 862 {
 863         BYTE *fcb = SAFEMAKEPTR(DS, DX);
 864         struct fcb *standard_fcb;
 865         struct fcb *output_fcb;
 866         int drive;
 867         char path[12];
 868
 869         DumpFCB( fcb );
 870
 871         if ((*fcb) == 0xff)
 872           {
 873             standard_fcb = (struct fcb *)(fcb + 7);
 874             output_fcb = (struct fcb *)(dta + 7);
 875             *dta = 0xff;
 876           }
 877         else
 878           {
 879             standard_fcb = (struct fcb *)fcb;
 880             output_fcb = (struct fcb *)dta;
 881           }
 882
 883         if (standard_fcb->drive)
 884           {
 885             drive = standard_fcb->drive - 1;
 886             if (!DOS_ValidDrive(drive))
 887               {
 888                 Error (InvalidDrive, EC_MediaError, EL_Disk);
 889                 AL = 0xff;
 890                 return;
 891               }
 892           }
 893         else
 894           drive = DOS_GetDefaultDrive();
 895
 896         output_fcb->drive = drive;
 897
 898         if (*(fcb) == 0xff)
 899           {
 900             if (*(fcb+6) & FA_LABEL)      /* return volume label */
 901               {
 902                 *(dta+6) = FA_LABEL;
 903                 memset(&output_fcb->name, ' ', 11);
 904                 if (DOS_GetVolumeLabel(drive) != NULL)
 905                   {
 906                     strncpy(output_fcb->name, DOS_GetVolumeLabel(drive), 11);
 907                     AL = 0x00;
 908                     return;
 909                   }
 910               }
 911           }
 912
 913         strncpy(output_fcb->name, standard_fcb->name, 11);
 914         if (*fcb == 0xff)
 915           *(dta+6) = ( *(fcb+6) & (!FA_DIREC));
 916
 917         sprintf(path,"%c:*.*",drive+'A');
 918         if ((output_fcb->directory = DOS_opendir(path))==NULL)
 919           {
 920             Error (PathNotFound, EC_MediaError, EL_Disk);
 921             AL = 0xff;
 922             return;
 923           }
 924
 925 }
 926
 927
 928 static void DeleteFileFCB(struct sigcontext_struct *context)
 929 {
 930         BYTE *fcb = SAFEMAKEPTR(DS, DX);
 931         int drive;
 932         struct dosdirent *dp;
 933         char temp[256], *ptr;
 934
 935         DumpFCB( fcb );
 936
 937         if (*fcb)
 938                 drive = *fcb - 1;
 939         else
 940                 drive = DOS_GetDefaultDrive();
 941
 942         strcpy(temp, DOS_GetCurrentDir(drive));
 943         strcat(temp, "\\");
 944         strncat(temp, fcb + 1, 8);
 945         ChopOffWhiteSpace(temp);
 946         strncat(temp, fcb + 9, 3);
 947         ChopOffWhiteSpace(temp);
 948
 949         if ((dp = DOS_opendir(temp)) == NULL) {
 950                 Error(InvalidDrive, EC_MediaError , EL_Disk);
 951                 AL = 0xffL;
 952                 return;
 953         }
 954
 955         strcpy(temp, DOS_GetCurrentDir(drive) );
 956         strcat(temp, "\\");
 957
 958         ptr = temp + strlen(temp);
 959
 960         while (DOS_readdir(dp) != NULL)
 961         {
 962                 strcpy(ptr, dp->filename);
 963                 dprintf_int(stddeb, "int21: delete file %s\n", temp);
 964                 /* unlink(GetUnixFileName(temp)); */
 965         }
 966         DOS_closedir(dp);
 967         AL = 0;
 968 }
 969
 970 static void RenameFileFCB(struct sigcontext_struct *context)
 971 {
 972         BYTE *fcb = SAFEMAKEPTR(DS, DX);
 973         int drive;
 974         struct dosdirent *dp;
 975         char temp[256], oldname[256], newname[256], *oldnameptr, *newnameptr;
 976
 977         DumpFCB( fcb );
 978
 979         if (*fcb)
 980                 drive = *fcb - 1;
 981         else
 982                 drive = DOS_GetDefaultDrive();
 983
 984         strcpy(temp, DOS_GetCurrentDir(drive));
 985         strcat(temp, "\\");
 986         strncat(temp, fcb + 1, 8);
 987         ChopOffWhiteSpace(temp);
 988         strncat(temp, fcb + 9, 3);
 989         ChopOffWhiteSpace(temp);
 990
 991         if ((dp = DOS_opendir(temp)) == NULL) {
 992                 Error(InvalidDrive, EC_MediaError , EL_Disk);
 993                 AL = 0xffL;
 994                 return;
 995         }
 996
 997         strcpy(oldname, DOS_GetCurrentDir(drive) );
 998         strcat(oldname, "\\");
 999         oldnameptr = oldname + strlen(oldname);
1000
1001         strcpy(newname, DOS_GetCurrentDir(drive) );
1002         strcat(newname, "\\");
1003         newnameptr = newname + strlen(newname);
1004
1005         while (DOS_readdir(dp) != NULL)
1006         {
1007                 strcpy(oldnameptr, dp->filename);
1008                 strcpy(newnameptr, fcb + 1);
1009                 dprintf_int(stddeb, "int21: renamefile %s -> %s\n",
1010                         oldname, newname);
1011         }
1012         DOS_closedir(dp);
1013         AL = 0;
1014 }
1015
1016
1017
1018 static void fLock (struct sigcontext_struct * context)
1019 {
1020     struct flock f;
1021     int result,retries=sharing_retries;
1022
1023     f.l_start = MAKELONG(DX,CX);
1024     f.l_len   = MAKELONG(DI,SI);
1025     f.l_whence = 0;
1026     f.l_pid = 0;
1027
1028     switch ( AX & 0xff )
1029     {
1030         case 0x00: /* LOCK */
1031           f.l_type = F_WRLCK;
1032           break;
1033
1034         case 0x01: /* UNLOCK */
1035           f.l_type = F_UNLCK;
1036           break;
1037
1038         default:
1039           EAX = (EAX & 0xffff0000) | 0x0001;
1040           SetCflag;
1041           return;
1042      }
1043
1044      {
1045           result = fcntl(BX,F_SETLK,&f);
1046           if ( retries && (!result) )
1047           {
1048               int i;
1049               for(i=0;i<32768*((int)sharing_pause);i++)
1050                   result++;                          /* stop the optimizer */
1051               for(i=0;i<32768*((int)sharing_pause);i++)
1052                   result--;
1053           }
1054       }
1055       while( (!result) && (!(retries--)) );
1056
1057       if(result)
1058       {
1059          errno_to_doserr();
1060          EAX = (EAX & 0xffffff00) | ExtendedError;
1061          SetCflag;
1062          return;
1063       }
1064
1065        Error (0,0,0);
1066        ResetCflag;
1067 }
1068
1069
1070 static void GetFileAttribute (struct sigcontext_struct * context)
1071 {
1072   char *filename = SAFEMAKEPTR (DS,DX);
1073   struct stat s;
1074   int res,cx;
1075
1076   res = stat(GetUnixFileName(filename), &s);
1077   if (res==-1)
1078   {
1079     errno_to_doserr();
1080     EAX = (EAX & 0xffffff00) | ExtendedError;
1081     SetCflag;
1082     return;
1083   }
1084
1085   cx = 0;
1086   if (S_ISDIR(s.st_mode))
1087     cx|=0x10;
1088   if ((S_IWRITE & s.st_mode) != S_IWRITE)
1089     cx|=0x01;
1090
1091   ECX = (ECX & 0xffff0000) | cx;
1092   ResetCflag;
1093   Error (0,0,0);
1094 }
1095
1096
1097
1098 /************************************************************************/
1099
1100 int do_int21(struct sigcontext_struct * context)
1101 {
1102     if (Options.relay_debug)
1103     {
1104         fprintf(stddeb,"int21: AX %04x, BX %04x, CX %04x, DX %04x, "
1105                "SI %04x, DI %04x, DS %04x, ES %04x\n",
1106                AX, BX, CX, DX, SI, DI, DS, ES);
1107     }
1108
1109     if (AH == 0x59)
1110     {
1111         GetExtendedErrorInfo(context);
1112         return 1;
1113     }
1114     else
1115     {
1116         Error (0,0,0);
1117         switch(AH)
1118         {
1119           case 0x00: /* TERMINATE PROGRAM */
1120             exit(0);
1121
1122           case 0x01: /* READ CHARACTER FROM STANDARD INPUT, WITH ECHO */
1123           case 0x02: /* WRITE CHARACTER TO STANDARD OUTPUT */
1124           case 0x03: /* READ CHARACTER FROM STDAUX  */
1125           case 0x04: /* WRITE CHARACTER TO STDAUX */
1126           case 0x05: /* WRITE CHARACTER TO PRINTER */
1127           case 0x06: /* DIRECT CONSOLE IN/OUTPUT */
1128           case 0x07: /* DIRECT CHARACTER INPUT, WITHOUT ECHO */
1129           case 0x08: /* CHARACTER INPUT WITHOUT ECHO */
1130           case 0x09: /* WRITE STRING TO STANDARD OUTPUT */
1131           case 0x0a: /* BUFFERED INPUT */
1132           case 0x0b: /* GET STDIN STATUS */
1133           case 0x0c: /* FLUSH BUFFER AND READ STANDARD INPUT */
1134           case 0x0f: /* OPEN FILE USING FCB */
1135           case 0x10: /* CLOSE FILE USING FCB */
1136           case 0x12: /* FIND NEXT MATCHING FILE USING FCB */
1137           case 0x14: /* SEQUENTIAL READ FROM FCB FILE */
1138           case 0x15: /* SEQUENTIAL WRITE TO FCB FILE */
1139           case 0x16: /* CREATE OR TRUNCATE FILE USING FCB */
1140           case 0x21: /* READ RANDOM RECORD FROM FCB FILE */
1141           case 0x22: /* WRITE RANDOM RECORD TO FCB FILE */
1142           case 0x23: /* GET FILE SIZE FOR FCB */
1143           case 0x24: /* SET RANDOM RECORD NUMBER FOR FCB */
1144           case 0x26: /* CREATE NEW PROGRAM SEGMENT PREFIX */
1145           case 0x27: /* RANDOM BLOCK READ FROM FCB FILE */
1146           case 0x28: /* RANDOM BLOCK WRITE TO FCB FILE */
1147           case 0x29: /* PARSE FILENAME INTO FCB */
1148           case 0x2e: /* SET VERIFY FLAG */
1149             IntBarf(0x21, context);
1150             break;
1151
1152           case 0x18: /* NULL FUNCTIONS FOR CP/M COMPATIBILITY */
1153           case 0x1d:
1154           case 0x1e:
1155           case 0x20:
1156           case 0x2b: /* SET SYSTEM DATE */
1157           case 0x2d: /* SET SYSTEM TIME */
1158           case 0x37: /* "SWITCHAR" - GET SWITCH CHARACTER
1159                         "SWITCHAR" - SET SWITCH CHARACTER
1160                         "AVAILDEV" - SPECIFY \DEV\ PREFIX USE */
1161           case 0x54: /* GET VERIFY FLAG */
1162           case 0x6b: /* NULL FUNCTION */
1163             IntBarf(0x21, context);
1164             EAX &= 0xff00;
1165             break;
1166
1167           case 0x5c: /* "FLOCK" - RECORD LOCKING */
1168             fLock(context);
1169             break;
1170
1171           case 0x0d: /* DISK BUFFER FLUSH */
1172             ResetCflag; /* dos 6+ only */
1173             break;
1174
1175           case 0x0e: /* SELECT DEFAULT DRIVE */
1176                 if (!DOS_ValidDrive(DL)) {
1177                         Error (InvalidDrive, EC_MediaError, EL_Disk);
1178                         break;
1179                 } else {
1180                         DOS_SetDefaultDrive(DL);
1181                         AX = MAX_DOS_DRIVES;
1182                         Error(0,0,0);
1183                 }
1184                 break;
1185
1186           case 0x11: /* FIND FIRST MATCHING FILE USING FCB */
1187             FindFirstFCB(context);
1188             break;
1189
1190           case 0x13: /* DELETE FILE USING FCB */
1191             DeleteFileFCB(context);
1192             break;
1193
1194           case 0x17: /* RENAME FILE USING FCB */
1195             RenameFileFCB(context);
1196             break;
1197
1198           case 0x19: /* GET CURRENT DEFAULT DRIVE */
1199                 AL = DOS_GetDefaultDrive();
1200                 Error (0,0,0);
1201             break;
1202
1203           case 0x1a: /* SET DISK TRANSFER AREA ADDRESS */
1204             dta = SAFEMAKEPTR(DS, DX);
1205             break;
1206
1207           case 0x1b: /* GET ALLOCATION INFORMATION FOR DEFAULT DRIVE */
1208             GetDefDriveAllocInfo(context);
1209             break;
1210
1211           case 0x1c: /* GET ALLOCATION INFORMATION FOR SPECIFIC DRIVE */
1212             GetDriveAllocInfo(context);
1213             break;
1214
1215           case 0x1f: /* GET DRIVE PARAMETER BLOCK FOR DEFAULT DRIVE */
1216             GetDrivePB(context);
1217             break;
1218
1219           case 0x25: /* SET INTERRUPT VECTOR */
1220             /* Ignore any attempt to set a segment vector */
1221                 dprintf_int(stdnimp,
1222                         "int21: set interrupt vector %2x (%04x:%04x)\n",
1223                         AL, DS, DX);
1224             break;
1225
1226           case 0x2a: /* GET SYSTEM DATE */
1227             GetSystemDate(context);
1228             break;
1229
1230           case 0x2c: /* GET SYSTEM TIME */
1231             GetSystemTime(context);
1232             break;
1233
1234           case 0x2f: /* GET DISK TRANSFER AREA ADDRESS */
1235             ES = segment(dta);
1236             BX = offset(dta);
1237             break;
1238
1239           case 0x30: /* GET DOS VERSION */
1240             AX = DOSVERSION;
1241             BX = 0x0012;     /* 0x123456 is Wine's serial # */
1242             CX = 0x3456;
1243             break;
1244
1245           case 0x31: /* TERMINATE AND STAY RESIDENT */
1246             IntBarf(0x21, context);
1247             break;
1248
1249           case 0x32: /* GET DOS DRIVE PARAMETER BLOCK FOR SPECIFIC DRIVE */
1250             GetDrivePB(context);
1251             break;
1252
1253           case 0x33: /* MULTIPLEXED */
1254             switch (AL) {
1255               case 0x00: /* GET CURRENT EXTENDED BREAK STATE */
1256                 if (!(AL))
1257                     EDX &= 0xff00L;
1258                 break;
1259
1260               case 0x01: /* SET EXTENDED BREAK STATE */
1261                 break;
1262
1263               case 0x02: /* GET AND SET EXTENDED CONTROL-BREAK CHECKING STATE*/
1264                 DL = 0;
1265                 break;
1266
1267               case 0x05: /* GET BOOT DRIVE */
1268                 DL = 2;
1269                 /* c: is Wine's bootdrive */
1270                 break;
1271
1272               case 0x06: /* GET TRUE VERSION NUMBER */
1273                 EBX = DOSVERSION;
1274                 EDX = 0x00;
1275                 break;
1276
1277               default:
1278                 IntBarf(0x21, context);
1279                 break;
1280             }
1281             break;
1282
1283           case 0x34: /* GET ADDRESS OF INDOS FLAG */
1284                 ES = segment(heap->InDosFlag);
1285                 BX = offset(heap->InDosFlag);
1286             break;
1287
1288           case 0x35: /* GET INTERRUPT VECTOR */
1289             /* Return a NULL segment selector - this will bomb,
1290                         if anyone ever tries to use it */
1291             dprintf_int(stdnimp, "int21: get interrupt vector %2x\n",
1292                 AX & 0xff);
1293             ES = 0;
1294             BX = 0;
1295             break;
1296
1297           case 0x36: /* GET FREE DISK SPACE */
1298             GetFreeDiskSpace(context);
1299             break;
1300
1301           case 0x38: /* GET COUNTRY-SPECIFIC INFORMATION */
1302             AX = 0x02; /* no country support available */
1303             SetCflag;
1304             break;
1305
1306           case 0x39: /* "MKDIR" - CREATE SUBDIRECTORY */
1307             MakeDir(context);
1308             break;
1309
1310           case 0x3a: /* "RMDIR" - REMOVE SUBDIRECTORY */
1311             RemoveDir(context);
1312             break;
1313
1314           case 0x3b: /* "CHDIR" - SET CURRENT DIRECTORY */
1315             ChangeDir(context);
1316             break;
1317
1318           case 0x3c: /* "CREAT" - CREATE OR TRUNCATE FILE */
1319             CreateFile(context);
1320             break;
1321
1322           case 0x3d: /* "OPEN" - OPEN EXISTING FILE */
1323             OpenExistingFile(context);
1324             break;
1325
1326           case 0x3e: /* "CLOSE" - CLOSE FILE */
1327             CloseFile(context);
1328             break;
1329
1330           case 0x3f: /* "READ" - READ FROM FILE OR DEVICE */
1331             ReadFile(context);
1332             break;
1333
1334           case 0x40: /* "WRITE" - WRITE TO FILE OR DEVICE */
1335             WriteFile(context);
1336             break;
1337
1338           case 0x41: /* "UNLINK" - DELETE FILE */
1339                 if (unlink( GetUnixFileName( SAFEMAKEPTR(DS,DX)) ) == -1) {
1340                         errno_to_doserr();
1341                         AL = ExtendedError;
1342                         SetCflag;
1343                         break;
1344                 }
1345                 Error(0,0,0);
1346                 ResetCflag;
1347                 break;
1348
1349           case 0x42: /* "LSEEK" - SET CURRENT FILE POSITION */
1350             SeekFile(context);
1351             break;
1352
1353           case 0x43: /* FILE ATTRIBUTES */
1354             switch (AL)
1355             {
1356               case 0x00:
1357                         GetFileAttribute(context);
1358                 break;
1359               case 0x01:
1360                         ResetCflag;
1361                 break;
1362             }
1363             break;
1364
1365           case 0x44: /* IOCTL */
1366             switch (AL)
1367             {
1368               case 0x00:
1369                 ioctlGetDeviceInfo(context);
1370                 break;
1371
1372               case 0x09:   /* CHECK IF BLOCK DEVICE REMOTE */
1373                 EDX = (EDX & 0xffff0000) | (1<<9) | (1<<12) | (1<<15);
1374                 ResetCflag;
1375                 break;
1376
1377               case 0x0b:   /* SET SHARING RETRY COUNT */
1378                 if (!CX)
1379                 {
1380                   EAX = (EAX & 0xffff0000) | 0x0001;
1381                   SetCflag;
1382                   break;
1383                 }
1384                 sharing_pause = CX;
1385                 if (!DX)
1386                   sharing_retries = DX;
1387                 ResetCflag;
1388                 break;
1389
1390               case 0x0d:
1391                 ioctlGenericBlkDevReq(context);
1392                 break;
1393
1394               default:
1395                 IntBarf(0x21, context);
1396                 break;
1397             }
1398             break;
1399
1400           case 0x45: /* "DUP" - DUPLICATE FILE HANDLE */
1401           case 0x46: /* "DUP2", "FORCEDUP" - FORCE DUPLICATE FILE HANDLE */
1402                 AX = dup(BX);
1403                 ResetCflag;
1404             break;
1405
1406           case 0x47: /* "CWD" - GET CURRENT DIRECTORY */
1407             GetCurrentDirectory(context);
1408             AX = 0x0100;
1409             /* intlist: many Microsoft products for Windows rely on this */
1410             break;
1411
1412           case 0x48: /* ALLOCATE MEMORY */
1413           case 0x49: /* FREE MEMORY */
1414           case 0x4a: /* RESIZE MEMORY BLOCK */
1415             IntBarf(0x21, context);
1416             break;
1417
1418           case 0x4b: /* "EXEC" - LOAD AND/OR EXECUTE PROGRAM */
1419             ExecProgram(context);
1420             break;
1421
1422           case 0x4c: /* "EXIT" - TERMINATE WITH RETURN CODE */
1423             exit(AL);
1424             break;
1425
1426           case 0x4d: /* GET RETURN CODE */
1427             AL = NoError; /* normal exit */
1428             break;
1429
1430           case 0x4e: /* "FINDFIRST" - FIND FIRST MATCHING FILE */
1431             FindFirst(context);
1432             break;
1433
1434           case 0x4f: /* "FINDNEXT" - FIND NEXT MATCHING FILE */
1435             FindNext(context);
1436             break;
1437
1438           case 0x52: /* "SYSVARS" - GET LIST OF LISTS */
1439                 ES = 0x0;
1440                 BX = 0x0;
1441                 IntBarf(0x21, context);
1442             break;
1443
1444           case 0x56: /* "RENAME" - RENAME FILE */
1445             RenameFile(context);
1446             break;
1447
1448           case 0x57: /* FILE DATE AND TIME */
1449             switch (AL)
1450             {
1451               case 0x00:
1452                 GetFileDateTime(context);
1453                 break;
1454               case 0x01:
1455                 SetFileDateTime(context);
1456                 break;
1457             }
1458             break;
1459
1460           case 0x58: /* GET OR SET MEMORY/UMB ALLOCATION STRATEGY */
1461             switch (AL)
1462             {
1463               case 0x00:
1464                 AL = 0x01L;
1465                 break;
1466               case 0x02:
1467                 EAX &= 0xff00L;
1468                 break;
1469               case 0x01:
1470               case 0x03:
1471                 break;
1472             }
1473             ResetCflag;
1474             break;
1475
1476           case 0x5a: /* CREATE TEMPORARY FILE */
1477             CreateTempFile(context);
1478             break;
1479
1480           case 0x5b: /* CREATE NEW FILE */
1481             CreateNewFile(context);
1482             break;
1483
1484           case 0x5d: /* NETWORK */
1485           case 0x5e:
1486             /* network software not installed */
1487             AL = NoNetwork;
1488             SetCflag;
1489             break;
1490
1491           case 0x5f: /* NETWORK */
1492             switch (AL)
1493             {
1494               case 0x07: /* ENABLE DRIVE */
1495                 if (!DOS_EnableDrive(DL))
1496                 {
1497                     Error(InvalidDrive, EC_MediaError , EL_Disk);
1498                     AL = InvalidDrive;
1499                     SetCflag;
1500                     break;
1501                 }
1502                 else
1503                 {
1504                     ResetCflag;
1505                     break;
1506                 }
1507               case 0x08: /* DISABLE DRIVE */
1508                 if (!DOS_DisableDrive(DL))
1509                 {
1510                     Error(InvalidDrive, EC_MediaError , EL_Disk);
1511                     AL = InvalidDrive;
1512                     SetCflag;
1513                     break;
1514                 }
1515                 else
1516                 {
1517                     ResetCflag;
1518                     break;
1519                 }
1520               default:
1521                 /* network software not installed */
1522                 AL = NoNetwork;
1523                 SetCflag;
1524                 break;
1525             }
1526             break;
1527
1528           case 0x60: /* "TRUENAME" - CANONICALIZE FILENAME OR PATH */
1529                 strncpy(SAFEMAKEPTR(ES,DI), SAFEMAKEPTR(DS,SI), strlen(SAFEMAKEPTR(DS,SI)) & 0x7f);
1530                 ResetCflag;
1531             break;
1532
1533           case 0x61: /* UNUSED */
1534           case 0x62: /* GET CURRENT PSP ADDRESS */
1535           case 0x63: /* UNUSED */
1536           case 0x64: /* OS/2 DOS BOX */
1537           case 0x65: /* GET EXTENDED COUNTRY INFORMATION */
1538                 IntBarf(0x21, context);
1539             break;
1540
1541           case 0x66: /* GLOBAL CODE PAGE TABLE */
1542             switch (AL) {
1543               case 0x01:
1544                 BX = CodePage;
1545                 DX = BX;
1546                 ResetCflag;
1547                 break;
1548               case 0x02:
1549                 CodePage = BX;
1550                 ResetCflag;
1551                 break;
1552             }
1553             break;
1554
1555           case 0x67: /* SET HANDLE COUNT */
1556             ResetCflag;
1557             break;
1558
1559           case 0x68: /* "FFLUSH" - COMMIT FILE */
1560             ResetCflag;
1561             break;
1562
1563           case 0x69: /* DISK SERIAL NUMBER */
1564             switch (AL)
1565             {
1566               case 0x00:
1567                 GetDiskSerialNumber(context);
1568                 break;
1569               case 0x01:
1570                 SetDiskSerialNumber(context);
1571                 break;
1572             }
1573             break;
1574
1575           case 0x6a: /* COMMIT FILE */
1576             ResetCflag;
1577             break;
1578
1579           case 0xea: /* NOVELL NETWARE - RETURN SHELL VERSION */
1580             break;
1581
1582           default:
1583             IntBarf(0x21, context);
1584             return 1;
1585         }
1586     }
1587     return 1;
1588 }
1589
1590 /**********************************************************************
1591  *                      DOS3Call
1592  */
1593 void DOS3Call()
1594 {
1595     do_int21((struct sigcontext_struct *) _CONTEXT);
1596     ReturnFromRegisterFunc();
1597 }
1598
1599 void INT21_Init(void)
1600 {
1601         int handle;
1602         MDESC *DosHeapDesc;
1603
1604         if ((handle = GlobalAlloc(GMEM_FIXED,sizeof(struct DosHeap))) == 0)
1605                 myerror("out of memory");
1606
1607         heap = (struct DosHeap *) GlobalLock(handle);
1608         HEAP_Init(&DosHeapDesc, heap, sizeof(struct DosHeap));
1609
1610         dta = heap->dta;
1611         heap->InDosFlag = 0;
1612         strcpy(heap->biosdate, "01/01/80");
1613 }