win32/device.c

   1 /*
   2  * Win32 device functions
   3  *
   4  * Copyright 1998 Marcus Meissner
   5  * Copyright 1998 Ulrich Weigand
   6  *
   7  */
   8
   9 #include <errno.h>
  10 #include <assert.h>
  11 #include <stdlib.h>
  12 #include <unistd.h>
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <sys/mman.h>
  16 #include <fcntl.h>
  17 #include <string.h>
  18 #include <time.h>
  19 #include "windows.h"
  20 #include "winbase.h"
  21 #include "winerror.h"
  22 #include "file.h"
  23 #include "process.h"
  24 #include "mmsystem.h"
  25 #include "heap.h"
  26 #include "debug.h"
  27 #include "winioctl.h"
  28 #include "stackframe.h"
  29
  30 static void DEVICE_Destroy(K32OBJ *dev);
  31 const K32OBJ_OPS DEVICE_Ops =
  32 {
  33     NULL,               /* signaled */
  34     NULL,               /* satisfied */
  35     NULL,               /* add_wait */
  36     NULL,               /* remove_wait */
  37     NULL,               /* read */
  38     NULL,               /* write */
  39     DEVICE_Destroy      /* destroy */
  40 };
  41
  42 /* The device object */
  43 typedef struct
  44 {
  45     K32OBJ    header;
  46
  47     struct VxDInfo *info;
  48     char     *devname;
  49     int       mode;
  50
  51 } DEVICE_OBJECT;
  52
  53
  54 static BOOL32 DeviceIo_VTDAPI(DEVICE_OBJECT *dev, DWORD dwIoControlCode,
  55                               LPVOID lpvInBuffer, DWORD cbInBuffer,
  56                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
  57                               LPDWORD lpcbBytesReturned,
  58                               LPOVERLAPPED lpOverlapped);
  59
  60 static BOOL32 VxDCall_VMM( DWORD *retv, DWORD service, CONTEXT *context );
  61
  62 /*
  63  * VxD names are taken from the Win95 DDK
  64  */
  65
  66 struct VxDInfo
  67 {
  68     LPCSTR  name;
  69     WORD    id;
  70     BOOL32  (*vxdcall)(DWORD *, DWORD, CONTEXT *);
  71     BOOL32  (*deviceio)(DEVICE_OBJECT *, DWORD, LPVOID, DWORD,
  72                         LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
  73 }
  74     VxDList[] =
  75 {
  76     /* Standard VxD IDs */
  77     { "VMM",      0x0001, VxDCall_VMM, NULL },
  78     { "DEBUG",    0x0002, NULL, NULL },
  79     { "VPICD",    0x0003, NULL, NULL },
  80     { "VDMAD",    0x0004, NULL, NULL },
  81     { "VTD",      0x0005, NULL, NULL },
  82     { "V86MMGR",  0x0006, NULL, NULL },
  83     { "PAGESWAP", 0x0007, NULL, NULL },
  84     { "PARITY",   0x0008, NULL, NULL },
  85     { "REBOOT",   0x0009, NULL, NULL },
  86     { "VDD",      0x000A, NULL, NULL },
  87     { "VSD",      0x000B, NULL, NULL },
  88     { "VMD",      0x000C, NULL, NULL },
  89     { "VKD",      0x000D, NULL, NULL },
  90     { "VCD",      0x000E, NULL, NULL },
  91     { "VPD",      0x000F, NULL, NULL },
  92     { "BLOCKDEV", 0x0010, NULL, NULL },
  93     { "VMCPD",    0x0011, NULL, NULL },
  94     { "EBIOS",    0x0012, NULL, NULL },
  95     { "BIOSXLAT", 0x0013, NULL, NULL },
  96     { "VNETBIOS", 0x0014, NULL, NULL },
  97     { "DOSMGR",   0x0015, NULL, NULL },
  98     { "WINLOAD",  0x0016, NULL, NULL },
  99     { "SHELL",    0x0017, NULL, NULL },
 100     { "VMPOLL",   0x0018, NULL, NULL },
 101     { "VPROD",    0x0019, NULL, NULL },
 102     { "DOSNET",   0x001A, NULL, NULL },
 103     { "VFD",      0x001B, NULL, NULL },
 104     { "VDD2",     0x001C, NULL, NULL },
 105     { "WINDEBUG", 0x001D, NULL, NULL },
 106     { "TSRLOAD",  0x001E, NULL, NULL },
 107     { "BIOSHOOK", 0x001F, NULL, NULL },
 108     { "INT13",    0x0020, NULL, NULL },
 109     { "PAGEFILE", 0x0021, NULL, NULL },
 110     { "SCSI",     0x0022, NULL, NULL },
 111     { "MCA_POS",  0x0023, NULL, NULL },
 112     { "SCSIFD",   0x0024, NULL, NULL },
 113     { "VPEND",    0x0025, NULL, NULL },
 114     { "VPOWERD",  0x0026, NULL, NULL },
 115     { "VXDLDR",   0x0027, NULL, NULL },
 116     { "NDIS",     0x0028, NULL, NULL },
 117     { "BIOS_EXT", 0x0029, NULL, NULL },
 118     { "VWIN32",   0x002A, NULL, NULL },
 119     { "VCOMM",    0x002B, NULL, NULL },
 120     { "SPOOLER",  0x002C, NULL, NULL },
 121     { "WIN32S",   0x002D, NULL, NULL },
 122     { "DEBUGCMD", 0x002E, NULL, NULL },
 123
 124     { "VNB",      0x0031, NULL, NULL },
 125     { "SERVER",   0x0032, NULL, NULL },
 126     { "CONFIGMG", 0x0033, NULL, NULL },
 127     { "DWCFGMG",  0x0034, NULL, NULL },
 128     { "SCSIPORT", 0x0035, NULL, NULL },
 129     { "VFBACKUP", 0x0036, NULL, NULL },
 130     { "ENABLE",   0x0037, NULL, NULL },
 131     { "VCOND",    0x0038, NULL, NULL },
 132
 133     { "EFAX",     0x003A, NULL, NULL },
 134     { "DSVXD",    0x003B, NULL, NULL },
 135     { "ISAPNP",   0x003C, NULL, NULL },
 136     { "BIOS",     0x003D, NULL, NULL },
 137     { "WINSOCK",  0x003E, NULL, NULL },
 138     { "WSOCK",    0x003E, NULL, NULL },
 139     { "WSIPX",    0x003F, NULL, NULL },
 140     { "IFSMgr",   0x0040, NULL, NULL },
 141     { "VCDFSD",   0x0041, NULL, NULL },
 142     { "MRCI2",    0x0042, NULL, NULL },
 143     { "PCI",      0x0043, NULL, NULL },
 144     { "PELOADER", 0x0044, NULL, NULL },
 145     { "EISA",     0x0045, NULL, NULL },
 146     { "DRAGCLI",  0x0046, NULL, NULL },
 147     { "DRAGSRV",  0x0047, NULL, NULL },
 148     { "PERF",     0x0048, NULL, NULL },
 149     { "AWREDIR",  0x0049, NULL, NULL },
 150
 151     /* Far East support */
 152     { "ETEN",     0x0060, NULL, NULL },
 153     { "CHBIOS",   0x0061, NULL, NULL },
 154     { "VMSGD",    0x0062, NULL, NULL },
 155     { "VPPID",    0x0063, NULL, NULL },
 156     { "VIME",     0x0064, NULL, NULL },
 157     { "VHBIOSD",  0x0065, NULL, NULL },
 158
 159     /* Multimedia OEM IDs */
 160     { "VTDAPI",   0x0442, NULL, DeviceIo_VTDAPI },
 161
 162     /* Network Device IDs */
 163     { "VNetSup",  0x0480, NULL, NULL },
 164     { "VRedir",   0x0481, NULL, NULL },
 165     { "VBrowse",  0x0482, NULL, NULL },
 166     { "VSHARE",   0x0483, NULL, NULL },
 167     { "IFSMgr",   0x0484, NULL, NULL },
 168     { "MEMPROBE", 0x0485, NULL, NULL },
 169     { "VFAT",     0x0486, NULL, NULL },
 170     { "NWLINK",   0x0487, NULL, NULL },
 171     { "VNWLINK",  0x0487, NULL, NULL },
 172     { "NWSUP",    0x0487, NULL, NULL },
 173     { "VTDI",     0x0488, NULL, NULL },
 174     { "VIP",      0x0489, NULL, NULL },
 175     { "VTCP",     0x048A, NULL, NULL },
 176     { "VCache",   0x048B, NULL, NULL },
 177     { "VUDP",     0x048C, NULL, NULL },
 178     { "VAsync",   0x048D, NULL, NULL },
 179     { "NWREDIR",  0x048E, NULL, NULL },
 180     { "STAT80",   0x048F, NULL, NULL },
 181     { "SCSIPORT", 0x0490, NULL, NULL },
 182     { "FILESEC",  0x0491, NULL, NULL },
 183     { "NWSERVER", 0x0492, NULL, NULL },
 184     { "SECPROV",  0x0493, NULL, NULL },
 185     { "NSCL",     0x0494, NULL, NULL },
 186     { "WSTCP",    0x0495, NULL, NULL },
 187     { "NDIS2SUP", 0x0496, NULL, NULL },
 188     { "MSODISUP", 0x0497, NULL, NULL },
 189     { "Splitter", 0x0498, NULL, NULL },
 190     { "PPP",      0x0499, NULL, NULL },
 191     { "VDHCP",    0x049A, NULL, NULL },
 192     { "VNBT",     0x049B, NULL, NULL },
 193     { "LOGGER",   0x049D, NULL, NULL },
 194     { "EFILTER",  0x049E, NULL, NULL },
 195     { "FFILTER",  0x049F, NULL, NULL },
 196     { "TFILTER",  0x04A0, NULL, NULL },
 197     { "AFILTER",  0x04A1, NULL, NULL },
 198     { "IRLAMP",   0x04A2, NULL, NULL },
 199
 200     { NULL,       0,      NULL, NULL }
 201 };
 202
 203 /*
 204  * VMM VxDCall service names are (mostly) taken from Stan Mitchell's
 205  * "Inside the Windows 95 File System"
 206  */
 207
 208 #define N_VMM_SERVICE 41
 209
 210 LPCSTR VMM_Service_Name[N_VMM_SERVICE] =
 211 {
 212     "PageReserve",            /* 0x0000 */
 213     "PageCommit",             /* 0x0001 */
 214     "PageDecommit",           /* 0x0002 */
 215     "PagerRegister",          /* 0x0003 */
 216     "PagerQuery",             /* 0x0004 */
 217     "HeapAllocate",           /* 0x0005 */
 218     "ContextCreate",          /* 0x0006 */
 219     "ContextDestroy",         /* 0x0007 */
 220     "PageAttach",             /* 0x0008 */
 221     "PageFlush",              /* 0x0009 */
 222     "PageFree",               /* 0x000A */
 223     "ContextSwitch",          /* 0x000B */
 224     "HeapReAllocate",         /* 0x000C */
 225     "PageModifyPerm",         /* 0x000D */
 226     "PageQuery",              /* 0x000E */
 227     "GetCurrentContext",      /* 0x000F */
 228     "HeapFree",               /* 0x0010 */
 229     "RegOpenKey",             /* 0x0011 */
 230     "RegCreateKey",           /* 0x0012 */
 231     "RegCloseKey",            /* 0x0013 */
 232     "RegDeleteKey",           /* 0x0014 */
 233     "RegSetValue",            /* 0x0015 */
 234     "RegDeleteValue",         /* 0x0016 */
 235     "RegQueryValue",          /* 0x0017 */
 236     "RegEnumKey",             /* 0x0018 */
 237     "RegEnumValue",           /* 0x0019 */
 238     "RegQueryValueEx",        /* 0x001A */
 239     "RegSetValueEx",          /* 0x001B */
 240     "RegFlushKey",            /* 0x001C */
 241     "RegQueryInfoKey",        /* 0x001D */
 242     "GetDemandPageInfo",      /* 0x001E */
 243     "BlockOnID",              /* 0x001F */
 244     "SignalID",               /* 0x0020 */
 245     "RegLoadKey",             /* 0x0021 */
 246     "RegUnLoadKey",           /* 0x0022 */
 247     "RegSaveKey",             /* 0x0023 */
 248     "RegRemapPreDefKey",      /* 0x0024 */
 249     "PageChangePager",        /* 0x0025 */
 250     "RegQueryMultipleValues", /* 0x0026 */
 251     "RegReplaceKey",          /* 0x0027 */
 252     "<KERNEL32.101>"          /* 0x0028 -- What does this do??? */
 253 };
 254
 255
 256
 257 HANDLE32 DEVICE_Open(LPCSTR filename, DWORD access)
 258 {
 259         DEVICE_OBJECT *dev;
 260         HANDLE32 handle;
 261         int i;
 262
 263         dev = HeapAlloc( SystemHeap, 0, sizeof(DEVICE_OBJECT) );
 264         if (!dev) return INVALID_HANDLE_VALUE32;
 265
 266         dev->header.type = K32OBJ_DEVICE_IOCTL;
 267         dev->header.refcount = 1;
 268         dev->mode       = access;
 269         dev->devname    = HEAP_strdupA(SystemHeap,0,filename);
 270         dev->info       = NULL;
 271
 272         for (i = 0; VxDList[i].name; i++)
 273             if (!lstrcmpi32A(VxDList[i].name, filename))
 274                 break;
 275         if (VxDList[i].name)
 276             dev->info = VxDList + i;
 277         else
 278             FIXME(win32, "Unknown VxD %s\n", filename);
 279
 280
 281         handle = HANDLE_Alloc( PROCESS_Current(), &(dev->header),
 282                                FILE_ALL_ACCESS | GENERIC_READ |
 283                                GENERIC_WRITE | GENERIC_EXECUTE /*FIXME*/, TRUE, -1 );
 284         /* If the allocation failed, the object is already destroyed */
 285         if (handle == INVALID_HANDLE_VALUE32) dev = NULL;
 286         return handle;
 287 }
 288
 289 static void DEVICE_Destroy(K32OBJ *obj)
 290 {
 291     DEVICE_OBJECT *dev = (DEVICE_OBJECT *)obj;
 292     assert( obj->type == K32OBJ_DEVICE_IOCTL );
 293
 294     if ( dev->devname )
 295     {
 296         HeapFree( SystemHeap, 0, dev->devname );
 297         dev->devname = NULL;
 298     }
 299
 300     obj->type = K32OBJ_UNKNOWN;
 301     HeapFree( SystemHeap, 0, dev );
 302 }
 303
 304 /****************************************************************************
 305  *              DeviceIoControl (KERNEL32.188)
 306  * This is one of those big ugly nasty procedure which can do
 307  * a million and one things when it comes to devices. It can also be
 308  * used for VxD communication.
 309  *
 310  * A return value of FALSE indicates that something has gone wrong which
 311  * GetLastError can decypher.
 312  */
 313 BOOL32 WINAPI DeviceIoControl(HANDLE32 hDevice, DWORD dwIoControlCode,
 314                               LPVOID lpvInBuffer, DWORD cbInBuffer,
 315                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
 316                               LPDWORD lpcbBytesReturned,
 317                               LPOVERLAPPED lpOverlapped)
 318 {
 319         DEVICE_OBJECT   *dev = (DEVICE_OBJECT *)HANDLE_GetObjPtr(
 320                 PROCESS_Current(), hDevice, K32OBJ_DEVICE_IOCTL, 0 /*FIXME*/, NULL );
 321
 322         TRACE(win32, "(%d,%ld,%p,%ld,%p,%ld,%p,%p)\n",
 323                 hDevice,dwIoControlCode,lpvInBuffer,cbInBuffer,
 324                 lpvOutBuffer,cbOutBuffer,lpcbBytesReturned,lpOverlapped
 325         );
 326
 327         if (!dev)
 328         {
 329                 SetLastError( ERROR_INVALID_PARAMETER );
 330                 return FALSE;
 331         }
 332
 333         /* Check if this is a user defined control code for a VxD */
 334         if( HIWORD( dwIoControlCode ) == 0 )
 335         {
 336             if ( dev->info && dev->info->deviceio )
 337                 return dev->info->deviceio( dev, dwIoControlCode,
 338                                             lpvInBuffer, cbInBuffer,
 339                                             lpvOutBuffer, cbOutBuffer,
 340                                             lpcbBytesReturned, lpOverlapped );
 341
 342             /* FIXME: Set appropriate error */
 343             FIXME( win32, "Unimplemented control %ld for VxD device %s\n",
 344                           dwIoControlCode, dev->devname );
 345         }
 346         else
 347         {
 348                 switch( dwIoControlCode )
 349                 {
 350                 case FSCTL_DELETE_REPARSE_POINT:
 351                 case FSCTL_DISMOUNT_VOLUME:
 352                 case FSCTL_GET_COMPRESSION:
 353                 case FSCTL_GET_REPARSE_POINT:
 354                 case FSCTL_LOCK_VOLUME:
 355                 case FSCTL_QUERY_ALLOCATED_RANGES:
 356                 case FSCTL_SET_COMPRESSION:
 357                 case FSCTL_SET_REPARSE_POINT:
 358                 case FSCTL_SET_SPARSE:
 359                 case FSCTL_SET_ZERO_DATA:
 360                 case FSCTL_UNLOCK_VOLUME:
 361                 case IOCTL_DISK_CHECK_VERIFY:
 362                 case IOCTL_DISK_EJECT_MEDIA:
 363                 case IOCTL_DISK_FORMAT_TRACKS:
 364                 case IOCTL_DISK_GET_DRIVE_GEOMETRY:
 365                 case IOCTL_DISK_GET_DRIVE_LAYOUT:
 366                 case IOCTL_DISK_GET_MEDIA_TYPES:
 367                 case IOCTL_DISK_GET_PARTITION_INFO:
 368                 case IOCTL_DISK_LOAD_MEDIA:
 369                 case IOCTL_DISK_MEDIA_REMOVAL:
 370                 case IOCTL_DISK_PERFORMANCE:
 371                 case IOCTL_DISK_REASSIGN_BLOCKS:
 372                 case IOCTL_DISK_SET_DRIVE_LAYOUT:
 373                 case IOCTL_DISK_SET_PARTITION_INFO:
 374                 case IOCTL_DISK_VERIFY:
 375                 case IOCTL_SERIAL_LSRMST_INSERT:
 376                 case IOCTL_STORAGE_CHECK_VERIFY:
 377                 case IOCTL_STORAGE_EJECT_MEDIA:
 378                 case IOCTL_STORAGE_GET_MEDIA_TYPES:
 379                 case IOCTL_STORAGE_LOAD_MEDIA:
 380                 case IOCTL_STORAGE_MEDIA_REMOVAL:
 381                         FIXME( win32, "unimplemented dwIoControlCode=%08lx\n", dwIoControlCode);
 382                         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 383                         return FALSE;
 384                         break;
 385                 default:
 386                         FIXME( win32, "ignored dwIoControlCode=%08lx\n",dwIoControlCode);
 387                         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 388                         return FALSE;
 389                         break;
 390                 }
 391         }
 392         return FALSE;
 393 }
 394
 395 /***********************************************************************
 396  *           DeviceIo_VTDAPI
 397  */
 398 static BOOL32 DeviceIo_VTDAPI(DEVICE_OBJECT *dev, DWORD dwIoControlCode,
 399                               LPVOID lpvInBuffer, DWORD cbInBuffer,
 400                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
 401                               LPDWORD lpcbBytesReturned,
 402                               LPOVERLAPPED lpOverlapped)
 403 {
 404     BOOL32 retv = TRUE;
 405
 406     switch (dwIoControlCode)
 407     {
 408     case 5:
 409         if (lpvOutBuffer && (cbOutBuffer>=4))
 410             *(DWORD*)lpvOutBuffer = timeGetTime();
 411
 412         if (lpcbBytesReturned)
 413             *lpcbBytesReturned = 4;
 414
 415         break;
 416
 417     default:
 418         FIXME(win32, "Control %ld not implemented\n", dwIoControlCode);
 419         retv = FALSE;
 420         break;
 421     }
 422
 423     return retv;
 424 }
 425
 426
 427
 428
 429
 430 /***********************************************************************
 431  *           VxDCall                   (KERNEL32.[1-9])
 432  */
 433 static void VxDCall( CONTEXT *context, int nArgs )
 434 {
 435     DWORD retv, service;
 436     int i, ok = FALSE;
 437
 438     /* Pop return address to caller */
 439     EIP_reg(context) = STACK32_POP(context);
 440
 441     /* Pop requested service ID */
 442     service = STACK32_POP(context);
 443
 444     TRACE(win32, "(%08lx, ...)\n", service);
 445
 446     for (i = 0; VxDList[i].name; i++)
 447         if (VxDList[i].id == HIWORD(service))
 448             break;
 449
 450     if (!VxDList[i].name)
 451         FIXME(win32, "Unknown VxD (%08lx)\n", service);
 452     else if (!VxDList[i].vxdcall)
 453         FIXME(win32, "Unimplemented VxD (%08lx)\n", service);
 454     else
 455         ok = VxDList[i].vxdcall(&retv, service, context);
 456
 457     /* If unimplemented, trust the caller to have called the
 458        version with the correct number of arguments */
 459     if (!ok)
 460     {
 461         ESP_reg(context) += 4 * nArgs;
 462         retv = 0xffffffff;  /* FIXME */
 463     }
 464
 465     /* Push return address back onto stack */
 466     STACK32_PUSH(context, EIP_reg(context));
 467
 468     /* Return to caller */
 469     EAX_reg(context) = retv;
 470 }
 471
 472 REGS_ENTRYPOINT(VxDCall0) { VxDCall( context, 0 ); }
 473 REGS_ENTRYPOINT(VxDCall1) { VxDCall( context, 1 ); }
 474 REGS_ENTRYPOINT(VxDCall2) { VxDCall( context, 2 ); }
 475 REGS_ENTRYPOINT(VxDCall3) { VxDCall( context, 3 ); }
 476 REGS_ENTRYPOINT(VxDCall4) { VxDCall( context, 4 ); }
 477 REGS_ENTRYPOINT(VxDCall5) { VxDCall( context, 5 ); }
 478 REGS_ENTRYPOINT(VxDCall6) { VxDCall( context, 6 ); }
 479 REGS_ENTRYPOINT(VxDCall7) { VxDCall( context, 7 ); }
 480 REGS_ENTRYPOINT(VxDCall8) { VxDCall( context, 8 ); }
 481
 482 /***********************************************************************
 483  *           VxDCall_VMM
 484  */
 485 BOOL32 VxDCall_VMM( DWORD *retv, DWORD service, CONTEXT *context )
 486 {
 487     BOOL32 ok = TRUE;
 488
 489     switch ( LOWORD(service) )
 490     {
 491     case 0x0011:  /* RegOpenKey */
 492     {
 493         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 494         LPCSTR  lpszSubKey = (LPCSTR) STACK32_POP( context );
 495         LPHKEY  retkey     = (LPHKEY) STACK32_POP( context );
 496         *retv = RegOpenKey32A( hkey, lpszSubKey, retkey );
 497     }
 498     break;
 499
 500     case 0x0012:  /* RegCreateKey */
 501     {
 502         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 503         LPCSTR  lpszSubKey = (LPCSTR) STACK32_POP( context );
 504         LPHKEY  retkey     = (LPHKEY) STACK32_POP( context );
 505         *retv = RegCreateKey32A( hkey, lpszSubKey, retkey );
 506     }
 507     break;
 508
 509     case 0x0013:  /* RegCloseKey */
 510     {
 511         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 512         *retv = RegCloseKey( hkey );
 513     }
 514     break;
 515
 516     case 0x0014:  /* RegDeleteKey */
 517     {
 518         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 519         LPCSTR  lpszSubKey = (LPCSTR) STACK32_POP( context );
 520         *retv = RegDeleteKey32A( hkey, lpszSubKey );
 521     }
 522     break;
 523
 524     case 0x0015:  /* RegSetValue */
 525     {
 526         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 527         LPCSTR  lpszSubKey = (LPCSTR) STACK32_POP( context );
 528         DWORD   dwType     = (DWORD)  STACK32_POP( context );
 529         LPCSTR  lpszData   = (LPCSTR) STACK32_POP( context );
 530         DWORD   cbData     = (DWORD)  STACK32_POP( context );
 531         *retv = RegSetValue32A( hkey, lpszSubKey, dwType, lpszData, cbData );
 532     }
 533     break;
 534
 535     case 0x0016:  /* RegDeleteValue */
 536     {
 537         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 538         LPSTR   lpszValue  = (LPSTR)  STACK32_POP( context );
 539         *retv = RegDeleteValue32A( hkey, lpszValue );
 540     }
 541     break;
 542
 543     case 0x0017:  /* RegQueryValue */
 544     {
 545         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 546         LPSTR   lpszSubKey = (LPSTR)  STACK32_POP( context );
 547         LPSTR   lpszData   = (LPSTR)  STACK32_POP( context );
 548         LPDWORD lpcbData   = (LPDWORD)STACK32_POP( context );
 549         *retv = RegQueryValue32A( hkey, lpszSubKey, lpszData, lpcbData );
 550     }
 551     break;
 552
 553     case 0x0018:  /* RegEnumKey */
 554     {
 555         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 556         DWORD   iSubkey    = (DWORD)  STACK32_POP( context );
 557         LPSTR   lpszName   = (LPSTR)  STACK32_POP( context );
 558         DWORD   lpcchName  = (DWORD)  STACK32_POP( context );
 559         *retv = RegEnumKey32A( hkey, iSubkey, lpszName, lpcchName );
 560     }
 561     break;
 562
 563     case 0x0019:  /* RegEnumValue */
 564     {
 565         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 566         DWORD   iValue     = (DWORD)  STACK32_POP( context );
 567         LPSTR   lpszValue  = (LPSTR)  STACK32_POP( context );
 568         LPDWORD lpcchValue = (LPDWORD)STACK32_POP( context );
 569         LPDWORD lpReserved = (LPDWORD)STACK32_POP( context );
 570         LPDWORD lpdwType   = (LPDWORD)STACK32_POP( context );
 571         LPBYTE  lpbData    = (LPBYTE) STACK32_POP( context );
 572         LPDWORD lpcbData   = (LPDWORD)STACK32_POP( context );
 573         *retv = RegEnumValue32A( hkey, iValue, lpszValue, lpcchValue,
 574                                  lpReserved, lpdwType, lpbData, lpcbData );
 575     }
 576     break;
 577
 578     case 0x001A:  /* RegQueryValueEx */
 579     {
 580         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 581         LPSTR   lpszValue  = (LPSTR)  STACK32_POP( context );
 582         LPDWORD lpReserved = (LPDWORD)STACK32_POP( context );
 583         LPDWORD lpdwType   = (LPDWORD)STACK32_POP( context );
 584         LPBYTE  lpbData    = (LPBYTE) STACK32_POP( context );
 585         LPDWORD lpcbData   = (LPDWORD)STACK32_POP( context );
 586         *retv = RegQueryValueEx32A( hkey, lpszValue, lpReserved,
 587                                     lpdwType, lpbData, lpcbData );
 588     }
 589     break;
 590
 591     case 0x001B:  /* RegSetValueEx */
 592     {
 593         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 594         LPSTR   lpszValue  = (LPSTR)  STACK32_POP( context );
 595         DWORD   dwReserved = (DWORD)  STACK32_POP( context );
 596         DWORD   dwType     = (DWORD)  STACK32_POP( context );
 597         LPBYTE  lpbData    = (LPBYTE) STACK32_POP( context );
 598         DWORD   cbData     = (DWORD)STACK32_POP( context );
 599         *retv = RegSetValueEx32A( hkey, lpszValue, dwReserved,
 600                                   dwType, lpbData, cbData );
 601     }
 602     break;
 603
 604     case 0x001C:  /* RegFlushKey */
 605     {
 606         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 607         *retv = RegFlushKey( hkey );
 608     }
 609     break;
 610
 611     case 0x001D:  /* RegQueryInfoKey */
 612     {
 613         /* NOTE: This VxDCall takes only a subset of the parameters that the
 614                  corresponding Win32 API call does. The implementation in Win95
 615                  ADVAPI32 sets all output parameters not mentioned here to zero. */
 616
 617         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 618         LPDWORD lpcSubKeys = (LPDWORD)STACK32_POP( context );
 619         LPDWORD lpcchMaxSubKey
 620                            = (LPDWORD)STACK32_POP( context );
 621         LPDWORD lpcValues  = (LPDWORD)STACK32_POP( context );
 622         LPDWORD lpcchMaxValueName
 623                            = (LPDWORD)STACK32_POP( context );
 624         LPDWORD lpcchMaxValueData
 625                            = (LPDWORD)STACK32_POP( context );
 626         *retv = RegQueryInfoKey32A( hkey, NULL, NULL, NULL, lpcSubKeys, lpcchMaxSubKey,
 627                                     NULL, lpcValues, lpcchMaxValueName, lpcchMaxValueData,
 628                                     NULL, NULL );
 629     }
 630     break;
 631
 632     case 0x0021:  /* RegLoadKey */
 633     {
 634         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 635         LPCSTR  lpszSubKey = (LPCSTR) STACK32_POP( context );
 636         LPCSTR  lpszFile   = (LPCSTR) STACK32_POP( context );
 637         *retv = RegLoadKey32A( hkey, lpszSubKey, lpszFile );
 638     }
 639     break;
 640
 641     case 0x0022:  /* RegUnLoadKey */
 642     {
 643         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 644         LPCSTR  lpszSubKey = (LPCSTR) STACK32_POP( context );
 645         *retv = RegUnLoadKey32A( hkey, lpszSubKey );
 646     }
 647     break;
 648
 649     case 0x0023:  /* RegSaveKey */
 650     {
 651         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 652         LPCSTR  lpszFile   = (LPCSTR) STACK32_POP( context );
 653         LPSECURITY_ATTRIBUTES sa =
 654                (LPSECURITY_ATTRIBUTES)STACK32_POP( context );
 655         *retv = RegSaveKey32A( hkey, lpszFile, sa );
 656     }
 657     break;
 658
 659 #if 0 /* Functions are not yet implemented in misc/registry.c */
 660     case 0x0024:  /* RegRemapPreDefKey */
 661     case 0x0026:  /* RegQueryMultipleValues */
 662 #endif
 663
 664     case 0x0027:  /* RegReplaceKey */
 665     {
 666         HKEY    hkey       = (HKEY)   STACK32_POP( context );
 667         LPCSTR  lpszSubKey = (LPCSTR) STACK32_POP( context );
 668         LPCSTR  lpszNewFile= (LPCSTR) STACK32_POP( context );
 669         LPCSTR  lpszOldFile= (LPCSTR) STACK32_POP( context );
 670         *retv = RegReplaceKey32A( hkey, lpszSubKey, lpszNewFile, lpszOldFile );
 671     }
 672     break;
 673
 674     default:
 675         if (LOWORD(service) < N_VMM_SERVICE)
 676             FIXME(win32, "Unimplemented service %s (%08lx)\n",
 677                           VMM_Service_Name[LOWORD(service)], service);
 678         else
 679             FIXME(win32, "Unknown service %08lx\n", service);
 680
 681         ok = FALSE;
 682         break;
 683     }
 684
 685     return ok;
 686 }
 687