/*
* @implemented
*/
HCOLORSPACE
WINAPI
CreateColorSpaceA(
LPLOGCOLORSPACEA lplcpa
)
{
LOGCOLORSPACEW lcpw;
if ((lplcpa->lcsSignature != LCS_SIGNATURE) ||
(lplcpa->lcsVersion != 0x400) ||
(lplcpa->lcsSize != sizeof(LOGCOLORSPACEA)))
{
SetLastError(ERROR_INVALID_COLORSPACE);
return NULL;
}
lcpw.lcsSignature = lplcpa->lcsSignature;
lcpw.lcsVersion = lplcpa->lcsVersion;
lcpw.lcsSize = sizeof(LOGCOLORSPACEW);
lcpw.lcsCSType = lplcpa->lcsCSType;
lcpw.lcsIntent = lplcpa->lcsIntent;
lcpw.lcsEndpoints = lplcpa->lcsEndpoints;
lcpw.lcsGammaRed = lplcpa->lcsGammaRed;
lcpw.lcsGammaGreen = lplcpa->lcsGammaGreen;
lcpw.lcsGammaBlue = lplcpa->lcsGammaBlue;
RtlMultiByteToUnicodeN( lcpw.lcsFilename,
MAX_PATH,
NULL,
lplcpa->lcsFilename,
strlen(lplcpa->lcsFilename) + 1);
return IntCreateColorSpaceW(&lcpw, FALSE);
}
/*
* @implemented
*/
size_t mbstowcs (wchar_t *wcstr, const char *mbstr, size_t count)
{
NTSTATUS Status;
ULONG Size;
ULONG Length;
Length = (ULONG)strlen (mbstr);
if (wcstr == NULL)
{
RtlMultiByteToUnicodeSize (&Size,
mbstr,
Length);
return (size_t)Size;
}
Status = RtlMultiByteToUnicodeN (wcstr,
(ULONG)count * sizeof(WCHAR),
&Size,
mbstr,
Length);
if (!NT_SUCCESS(Status))
return -1;
return (size_t)Size;
}
static inline int pf_output_stringA( pf_output *out, LPCSTR str, int len )
{
int space = out->len - out->used;
if( len < 0 )
len = strlen( str );
if( !out->unicode )
{
LPSTR p = out->buf.A + out->used;
if( space >= len )
{
memcpy( p, str, len );
out->used += len;
return len;
}
if( space > 0 )
memcpy( p, str, space );
out->used += len;
}
else
{
LPWSTR p = out->buf.W + out->used;
ULONG n;
RtlMultiByteToUnicodeSize( &n, str, len );
if (space >= n / sizeof(WCHAR))
{
RtlMultiByteToUnicodeN( p, n, NULL, str, len );
out->used += n / sizeof(WCHAR);
return len;
}
if (space > 0) RtlMultiByteToUnicodeN( p, space * sizeof(WCHAR), NULL, str, len );
out->used += n;
}
return -1;
}
/*********************************************************************
* mbstowcs (NTDLL.@)
*/
INT __cdecl NTDLL_mbstowcs( LPWSTR dst, LPCSTR src, INT n )
{
DWORD len;
if (!dst)
{
RtlMultiByteToUnicodeSize( &len, src, strlen(src) );
}
else
{
if (n <= 0) return 0;
RtlMultiByteToUnicodeN( dst, n*sizeof(WCHAR), &len, src, strlen(src) );
if (len / sizeof(WCHAR) < n) dst[len / sizeof(WCHAR)] = 0;
}
return len / sizeof(WCHAR);
}
PWSTR MByteToWChar(PCSTR AnsiString, ULONG_PTR Length)
{
PWSTR Unicode;
if (Length == -1)
Length = StrLengthA(AnsiString);
++Length;
Unicode = (PWSTR)AllocateMemoryP(Length * sizeof(WCHAR));
if (Unicode == NULL)
return NULL;
RtlMultiByteToUnicodeN(Unicode, Length * sizeof(WCHAR), NULL, AnsiString, Length);
return Unicode;
}
/*
* @implemented
*/
HACCEL WINAPI CreateAcceleratorTableA(LPACCEL lpaccl, int cEntries)
{
int i;
if (!cEntries || !lpaccl) return (HACCEL)0;
for(i = 0; i < cEntries; ++ i)
if(!lpaccl[i].fVirt)
{
NTSTATUS nErrCode = RtlMultiByteToUnicodeN
(
(PWCHAR)&lpaccl[i].key,
sizeof(lpaccl[i].key),
NULL,
(PCHAR)&lpaccl[i].key,
sizeof(lpaccl[i].key)
);
if(!NT_SUCCESS(nErrCode)) lpaccl[i].key = -1;
}
return CreateAcceleratorTableW(lpaccl, cEntries);
}
size_t __cdecl _mbstowcs_lk
#else
size_t __cdecl mbstowcs
#endif
(
wchar_t *pwcs,
const char *s,
size_t n
)
{
size_t count = 0;
if (pwcs && n == 0)
/* dest string exists, but 0 bytes converted */
return (size_t) 0;
_ASSERTE(s != NULL);
#ifdef _WIN32
#if !defined(_NTSUBSET_) && !defined(_POSIX_)
/* if destination string exists, fill it in */
if (pwcs)
{
if (__lc_handle[LC_CTYPE] == _CLOCALEHANDLE)
{
/* C locale: easy and fast */
while (count < n)
{
*pwcs = (wchar_t) ((unsigned char)s[count]);
if (!s[count])
return count;
count++;
pwcs++;
}
return count;
} else {
int bytecnt, charcnt;
unsigned char *p;
/* Assume that the buffer is large enough */
if ((count=MultiByteToWideChar(__lc_codepage, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
s, -1, pwcs, n)) != 0)
return count - 1; /* don't count NUL */
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
{
errno = EILSEQ;
return (size_t)-1;
}
/* User-supplied buffer not large enough. */
/* How many bytes are in n characters of the string? */
charcnt = n;
for (p = (unsigned char *)s; (charcnt-- && *p); p++)
{
if (isleadbyte(*p))
p++;
}
bytecnt = ((int) ((char *)p - (char *)s));
if ((count = MultiByteToWideChar (__lc_codepage, MB_PRECOMPOSED,
s, bytecnt, pwcs, n)) == 0)
{
errno = EILSEQ;
return (size_t)-1;
}
return count; /* no NUL in string */
}
}
else { /* pwcs == NULL, get size only, s must be NUL-terminated */
if (__lc_handle[LC_CTYPE] == _CLOCALEHANDLE)
return strlen(s);
else {
if ((count=MultiByteToWideChar(__lc_codepage, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
s, -1, NULL, 0)) == 0)
{
errno = EILSEQ;
return (size_t)-1;
}
return count - 1;
}
}
#else /* _NTSUBSET_/_POSIX_ */
if (pwcs) {
NTSTATUS Status;
int size;
size = _mbstrlen(s);
Status = RtlMultiByteToUnicodeN(pwcs,
n * sizeof( *pwcs ),
(PULONG)&size,
(char *)s,
size+1 );
if (!NT_SUCCESS(Status)) {
errno = EILSEQ;
size = -1;
} else {
size = size / sizeof(*pwcs);
if (pwcs[size-1] == L'\0') {
size -= 1;
}
}
return size;
} else { /* pwcs == NULL, get size only, s must be NUL-terminated */
return strlen(s);
}
#endif /* _NTSUBSET_/_POSIX_ */
#else /* _WIN32 */
/* if destination string exists, fill it in */
if (pwcs)
{
/* C locale: easy and fast */
while (count < n)
{
*pwcs = (wchar_t) ((unsigned char)s[count]);
if (!s[count])
return count;
count++;
pwcs++;
}
return count;
} else { /* pwcs == NULL, get size only, s must be NUL-terminated */
return strlen(s);
}
#endif /* _WIN32 */
}
/******************************************************************
* create_scsi_entry
*
* Initializes registry to contain scsi info about the cdrom in NT.
* All devices (even not real scsi ones) have this info in NT.
* NOTE: programs usually read these registry entries after sending the
* IOCTL_SCSI_GET_ADDRESS ioctl to the cdrom
*/
static void create_scsi_entry( PSCSI_ADDRESS scsi_addr, LPCSTR lpDriver, UINT uDriveType,
LPSTR lpDriveName, LPSTR lpUnixDeviceName )
{
static UCHAR uCdromNumber = 0;
static UCHAR uTapeNumber = 0;
OBJECT_ATTRIBUTES attr;
UNICODE_STRING nameW;
WCHAR dataW[50];
DWORD lenW;
char buffer[40];
DWORD value;
const char *data;
HANDLE scsiKey;
HANDLE portKey;
HANDLE busKey;
HANDLE targetKey;
HANDLE lunKey;
DWORD disp;
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
/* Ensure there is Scsi key */
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "Machine\\HARDWARE\\DEVICEMAP\\Scsi" ) ||
NtCreateKey( &scsiKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi registry key\n" );
return;
}
RtlFreeUnicodeString( &nameW );
snprintf(buffer,sizeof(buffer),"Scsi Port %d",scsi_addr->PortNumber);
attr.RootDirectory = scsiKey;
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||
NtCreateKey( &portKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi Port registry key\n" );
return;
}
RtlFreeUnicodeString( &nameW );
RtlCreateUnicodeStringFromAsciiz( &nameW, "Driver" );
RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &lenW, lpDriver, strlen(lpDriver));
NtSetValueKey( portKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
RtlFreeUnicodeString( &nameW );
value = 10;
RtlCreateUnicodeStringFromAsciiz( &nameW, "FirstBusTimeScanInMs" );
NtSetValueKey( portKey,&nameW, 0, REG_DWORD, (BYTE *)&value, sizeof(DWORD));
RtlFreeUnicodeString( &nameW );
value = 0;
if (strcmp(lpDriver, "atapi") == 0)
{
#ifdef HDIO_GET_DMA
int fd, dma;
fd = open(lpUnixDeviceName, O_RDONLY|O_NONBLOCK);
if (fd != -1)
{
if (ioctl(fd, HDIO_GET_DMA, &dma) != -1) value = dma;
close(fd);
}
#endif
RtlCreateUnicodeStringFromAsciiz( &nameW, "DMAEnabled" );
NtSetValueKey( portKey,&nameW, 0, REG_DWORD, (BYTE *)&value, sizeof(DWORD));
RtlFreeUnicodeString( &nameW );
}
snprintf(buffer, sizeof(buffer),"Scsi Bus %d", scsi_addr->PathId);
attr.RootDirectory = portKey;
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||
NtCreateKey( &busKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus registry key\n" );
return;
}
RtlFreeUnicodeString( &nameW );
attr.RootDirectory = busKey;
/* FIXME: get real controller Id for SCSI */
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "Initiator Id 255" ) ||
NtCreateKey( &targetKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus\\Initiator Id 255 registry key\n" );
return;
}
RtlFreeUnicodeString( &nameW );
NtClose( targetKey );
snprintf(buffer, sizeof(buffer),"Target Id %d", scsi_addr->TargetId);
attr.RootDirectory = busKey;
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||
NtCreateKey( &targetKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus 0\\Target Id registry key\n" );
return;
}
RtlFreeUnicodeString( &nameW );
snprintf(buffer, sizeof(buffer),"Logical Unit Id %d", scsi_addr->Lun);
attr.RootDirectory = targetKey;
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||
NtCreateKey( &lunKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus 0\\Target Id registry key\\Logical Unit Id\n" );
return;
}
RtlFreeUnicodeString( &nameW );
switch (uDriveType)
{
case DRIVE_NO_ROOT_DIR:
default:
data = "OtherPeripheral"; break;
case DRIVE_FIXED:
data = "DiskPeripheral"; break;
case DRIVE_REMOVABLE:
data = "TapePeripheral";
snprintf(buffer, sizeof(buffer), "Tape%d", uTapeNumber++);
break;
case DRIVE_CDROM:
data = "CdRomPeripheral";
snprintf(buffer, sizeof(buffer), "Cdrom%d", uCdromNumber++);
break;
}
RtlCreateUnicodeStringFromAsciiz( &nameW, "Type" );
RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &lenW, data, strlen(data));
NtSetValueKey( lunKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
RtlFreeUnicodeString( &nameW );
RtlCreateUnicodeStringFromAsciiz( &nameW, "Identifier" );
RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &lenW, lpDriveName, strlen(lpDriveName));
NtSetValueKey( lunKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
RtlFreeUnicodeString( &nameW );
if (uDriveType == DRIVE_CDROM || uDriveType == DRIVE_REMOVABLE)
{
RtlCreateUnicodeStringFromAsciiz( &nameW, "DeviceName" );
RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &lenW, buffer, strlen(buffer));
NtSetValueKey( lunKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
RtlFreeUnicodeString( &nameW );
}
RtlCreateUnicodeStringFromAsciiz( &nameW, "UnixDeviceName" );
RtlMultiByteToUnicodeN( dataW, sizeof(dataW), &lenW, lpUnixDeviceName, strlen(lpUnixDeviceName));
NtSetValueKey( lunKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
RtlFreeUnicodeString( &nameW );
NtClose( lunKey );
NtClose( targetKey );
NtClose( busKey );
NtClose( portKey );
NtClose( scsiKey );
}
NTSTATUS
RealUnicodeToFalseUnicode(
IN OUT LPWSTR Source,
IN int SourceLength, // in chars
IN UINT Codepage
)
/*
this routine converts a unicode string into the correct characters
for an OEM (cp 437) font. this code is needed because the gdi glyph
mapper converts unicode to ansi using codepage 1252 to index
font. this is how the data is stored internally.
*/
{
NTSTATUS Status;
LPSTR Temp;
ULONG TempLength;
ULONG Length;
CHAR StackBuffer[STACK_BUFFER_SIZE];
BOOL NormalChars;
int i;
DBGCHARS(("RealUnicodeToFalseUnicode U->%d:ACP->U %.*ls\n", Codepage,
SourceLength > 10 ? 10 : SourceLength, Source));
NormalChars = TRUE;
for (i=0;i<SourceLength;i++) {
if (Source[i] > 0x7f) {
NormalChars = FALSE;
break;
}
}
if (NormalChars) {
return STATUS_SUCCESS;
}
TempLength = SourceLength;
if (TempLength > STACK_BUFFER_SIZE) {
Temp = (LPSTR)HeapAlloc(pConHeap,MAKE_TAG( TMP_TAG ),TempLength);
if (Temp == NULL) {
return STATUS_NO_MEMORY;
}
} else {
Temp = StackBuffer;
}
if (Codepage == OEMCP) {
Status = RtlUnicodeToOemN(Temp,
TempLength,
&Length,
Source,
SourceLength * sizeof(WCHAR)
);
} else {
Status = WideCharToMultiByte(Codepage,
0,
Source,
SourceLength,
Temp,
TempLength,
NULL,
NULL);
}
if (!NT_SUCCESS(Status)) {
if (TempLength > STACK_BUFFER_SIZE) {
HeapFree(pConHeap,0,Temp);
}
return Status;
}
Status = RtlMultiByteToUnicodeN(Source,
SourceLength * sizeof(WCHAR),
&Length,
Temp,
TempLength
);
if (TempLength > STACK_BUFFER_SIZE) {
HeapFree(pConHeap,0,Temp);
}
if (!NT_SUCCESS(Status)) {
return Status;
} else {
return STATUS_SUCCESS;
}
}
int
main(
int argc,
char *argv[]
)
{
ULONG j;
ULONG cb;
char *pch;
printf("Start NlsXlatTest()\n");
//
// First initialize the buffers
//
for (j = 0; j < sizeof(OEMBuff); j++) {
OEMBuff[j] = (char)(j * 17);
ABuff[j] = (char)(j * 19);
}
//
// TEST 1
// RtlMultiByteToUnicodeN, RtlUnicodeToMultiByteN
//
printf("Test 1: MultiByteToUnicodeN & RtlUnicodeToMultiByteN\n");
// TEST 1.1
//
printf(" Test 1.1: A->U U->A\n");
RtlMultiByteToUnicodeN(UBuff, sizeof(UBuff), &cb, ABuff, sizeof(ABuff));
printf(" %d bytes converted to Unicode\n", cb);
RtlUnicodeToMultiByteN(ABuff, sizeof(ABuff), &cb, UBuff, sizeof(UBuff));
printf(" %d bytes converted back to ANSI\n", cb);
for (j = 0; j < sizeof(ABuff); j++) {
if (ABuff[j] != (char)(j * 19)) {
printf("ABuff[%d] was 0x%02x, now 0x%02x\n",
j, (char)(j * 19), ABuff[j]);
return FALSE;
}
}
printf(" Test 1.1 OK\n");
// TEST 1.2
//
printf(" Test 1.2: A->U U->A (source & dest buffers the same)\n");
RtlCopyMemory(UBuff, ABuff, sizeof(ABuff));
RtlMultiByteToUnicodeN(UBuff, sizeof(UBuff), &cb, UBuff, sizeof(ABuff));
printf(" %d bytes converted to Unicode\n", cb);
RtlUnicodeToMultiByteN(UBuff, sizeof(ABuff), &cb, UBuff, sizeof(UBuff));
printf(" %d bytes converted back to ANSI\n", cb);
pch = (LPSTR)UBuff;
for (j = 0; j < sizeof(ABuff); j++) {
if (pch[j] != ABuff[j]) {
printf(" ABuff[%d] was 0x%02x, was turned into 0x%02x\n",
j, ABuff[j], pch[j]);
printf(" Test 1.2 FAILED!\n");
return FALSE;
}
}
printf(" Test 1.2 OK!\n");
return TRUE;
}
HACCEL
APIENTRY
NtUserCreateAcceleratorTable(
LPACCEL Entries,
ULONG EntriesCount)
{
PACCELERATOR_TABLE Accel;
HACCEL hAccel;
ULONG Index;
NTSTATUS Status = STATUS_SUCCESS;
DECLARE_RETURN(HACCEL);
TRACE("Enter NtUserCreateAcceleratorTable(Entries %p, EntriesCount %u)\n",
Entries, EntriesCount);
UserEnterExclusive();
if (!Entries || EntriesCount <= 0)
{
SetLastNtError(STATUS_INVALID_PARAMETER);
RETURN( (HACCEL) NULL );
}
Accel = UserCreateObject(gHandleTable, NULL, NULL, (PHANDLE)&hAccel, TYPE_ACCELTABLE, sizeof(ACCELERATOR_TABLE));
if (Accel == NULL)
{
SetLastNtError(STATUS_NO_MEMORY);
RETURN( (HACCEL) NULL );
}
Accel->Count = EntriesCount;
Accel->Table = ExAllocatePoolWithTag(PagedPool, EntriesCount * sizeof(ACCEL), USERTAG_ACCEL);
if (Accel->Table == NULL)
{
UserDereferenceObject(Accel);
UserDeleteObject(hAccel, TYPE_ACCELTABLE);
SetLastNtError(STATUS_NO_MEMORY);
RETURN( (HACCEL) NULL);
}
_SEH2_TRY
{
ProbeForRead(Entries, EntriesCount * sizeof(ACCEL), 4);
for (Index = 0; Index < EntriesCount; Index++)
{
Accel->Table[Index].fVirt = Entries[Index].fVirt & FVIRT_MASK;
if(Accel->Table[Index].fVirt & FVIRTKEY)
{
Accel->Table[Index].key = Entries[Index].key;
}
else
{
RtlMultiByteToUnicodeN(&Accel->Table[Index].key,
sizeof(WCHAR),
NULL,
(PCSTR)&Entries[Index].key,
sizeof(CHAR));
}
Accel->Table[Index].cmd = Entries[Index].cmd;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
if (!NT_SUCCESS(Status))
{
ExFreePoolWithTag(Accel->Table, USERTAG_ACCEL);
UserDereferenceObject(Accel);
UserDeleteObject(hAccel, TYPE_ACCELTABLE);
SetLastNtError(Status);
RETURN( (HACCEL) NULL);
}
/* FIXME: Save HandleTable in a list somewhere so we can clean it up again */
RETURN(hAccel);
CLEANUP:
TRACE("Leave NtUserCreateAcceleratorTable(Entries %p, EntriesCount %u) = %p\n",
Entries, EntriesCount, _ret_);
UserLeave();
END_CLEANUP;
}
NTSTATUS
DfspProtocolToService(
IN PDS_TRANSPORT pdsTransport,
IN PWSTR pwszPrincipalName,
IN PWSTR pwszShareName,
IN OUT PDFS_SERVICE pService)
{
NTSTATUS status = STATUS_SUCCESS;
PTA_ADDRESS pTaddr = &pdsTransport->taddr;
PTDI_ADDRESS_NETBIOS pNBAddress;
USHORT i;
WCHAR NetBiosAddress[ TDI_ADDRESS_LENGTH_NETBIOS + 1];
ULONG cbUnused;
PUNICODE_STRING pServiceAddr;
DfsDbgTrace(+1, Dbg, "DfspProtocolToService - entered\n", 0);
//
// Initialize the service to nulls
//
RtlZeroMemory(pService, sizeof(DFS_SERVICE));
ASSERT(pTaddr->AddressType == TDI_ADDRESS_TYPE_NETBIOS);
pNBAddress = (PTDI_ADDRESS_NETBIOS) pTaddr->Address;
ASSERT(pTaddr->AddressLength == sizeof(TDI_ADDRESS_NETBIOS));
RtlMultiByteToUnicodeN(
NetBiosAddress,
sizeof(NetBiosAddress),
&cbUnused,
pNBAddress->NetbiosName,
16);
//
// Process a NetBIOS name. Throw away char 16, then ignore the trailing
// spaces
//
for (i = 14; NetBiosAddress[i] == L' '; i--) {
NOTHING;
}
NetBiosAddress[i+1] = UNICODE_NULL;
DfsDbgTrace(0, Dbg, "NetBIOS address is %ws\n", NetBiosAddress);
pService->Name.Length = wcslen(pwszPrincipalName) * sizeof(WCHAR);
pService->Name.MaximumLength = pService->Name.Length +
sizeof(UNICODE_NULL);
pService->Name.Buffer = ExAllocatePool(
PagedPool,
pService->Name.MaximumLength);
if (!pService->Name.Buffer) {
DfsDbgTrace(0, Dbg, "Unable to create principal name!\n", 0);
status = STATUS_INSUFFICIENT_RESOURCES;
DfsDbgTrace(-1, Dbg, "DfsProtocolToService returning %08lx\n", status);
return(status);
}
RtlCopyMemory(pService->Name.Buffer, pwszPrincipalName, pService->Name.Length);
pService->Address.MaximumLength =
sizeof(UNICODE_PATH_SEP) +
pService->Name.Length +
sizeof(UNICODE_PATH_SEP) +
wcslen(pwszShareName) * sizeof(WCHAR) +
sizeof(UNICODE_NULL);
pService->Address.Buffer = ExAllocatePool(
PagedPool,
pService->Address.MaximumLength);
if (!pService->Address.Buffer) {
DfsDbgTrace(0, Dbg, "Unable to create address!\n", 0);
ExFreePool(pService->Name.Buffer);
pService->Name.Buffer = NULL;
status = STATUS_INSUFFICIENT_RESOURCES;
DfsDbgTrace(-1, Dbg, "DfsProtocolToService returning %08lx\n", status);
return(status);
}
pService->Address.Length = sizeof(UNICODE_PATH_SEP);
pService->Address.Buffer[0] = UNICODE_PATH_SEP;
DnrConcatenateFilePath(
&pService->Address,
pService->Name.Buffer,
pService->Name.Length);
DnrConcatenateFilePath(
&pService->Address,
pwszShareName,
(USHORT) (wcslen(pwszShareName) * sizeof(WCHAR)));
DfsDbgTrace(0, Dbg, "Server Name is %wZ\n", &pService->Name);
DfsDbgTrace(0, Dbg, "Address is %wZ\n", &pService->Address);
pService->Type = DFS_SERVICE_TYPE_MASTER | DFS_SERVICE_TYPE_REFERRAL;
pService->Capability = PROV_DFS_RDR;
pService->ProviderId = PROV_ID_DFS_RDR;
pService->pProvider = NULL;
DfsDbgTrace(-1, Dbg, "DfsProtocolToService returning %08lx\n", status);
return(status);
}
/***************************************************************************\
* _ClientEventCallback
*
* Description:
* Called from the server side to perform event callbacks.
*
* History:
* 11-12-91 sanfords Created.
\***************************************************************************/
DWORD _ClientEventCallback(
PCL_INSTANCE_INFO pcii,
PEVENT_PACKET pep)
{
HDDEDATA hData;
EnterDDECrit;
switch (pep->EventType) {
case 0: // MonitorFlags change event - everybody gets it
pcii->MonitorFlags = pep->Data;
break;
case MF_CALLBACKS:
{
MONCBSTRUCT mcb;
mcb = *((MONCBSTRUCT *)&pep->Data);
mcb.hsz1 = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)mcb.hsz1));
mcb.hsz2 = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)mcb.hsz2));
if ( mcb.wType == XTYP_REGISTER ||
mcb.wType == XTYP_UNREGISTER) {
mcb.hsz2 = INST_SPECIFIC_HSZ_FROM_LATOM((LATOM)mcb.hsz2);
}
hData = InternalCreateDataHandle(pcii, (LPSTR)&mcb,
pep->cbEventData, 0,
HDATA_NOAPPFREE | HDATA_READONLY | HDATA_EXECUTE, 0, 0);
if (hData) {
DoCallback(pcii, (WORD)XTYP_MONITOR, 0, 0, 0, 0, hData, 0L,
pep->EventType);
InternalFreeDataHandle((HDDEDATA)hData, TRUE);
DeleteAtom(LATOM_FROM_HSZ(mcb.hsz1));
DeleteAtom(LATOM_FROM_HSZ(mcb.hsz2));
}
}
break;
case MF_LINKS:
{
MONLINKSTRUCT ml;
ml = *((MONLINKSTRUCT *)&pep->Data);
ml.hszSvc = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)ml.hszSvc));
ml.hszTopic = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)ml.hszTopic));
ml.hszItem = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)ml.hszItem));
hData = InternalCreateDataHandle(pcii, (LPSTR)&ml,
pep->cbEventData, 0,
HDATA_NOAPPFREE | HDATA_READONLY | HDATA_EXECUTE, 0, 0);
if (hData) {
DoCallback(pcii, (WORD)XTYP_MONITOR, 0, 0, 0, 0, hData, 0L,
pep->EventType);
InternalFreeDataHandle((HDDEDATA)hData, TRUE);
DeleteAtom(LATOM_FROM_HSZ(ml.hszSvc));
DeleteAtom(LATOM_FROM_HSZ(ml.hszTopic));
DeleteAtom(LATOM_FROM_HSZ(ml.hszItem));
}
}
break;
case MF_CONV:
{
MONCONVSTRUCT mc;
mc = *((MONCONVSTRUCT *)&pep->Data);
mc.hszSvc = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)mc.hszSvc));
mc.hszTopic = NORMAL_HSZ_FROM_LATOM(GlobalToLocalAtom((GATOM)mc.hszTopic));
hData = InternalCreateDataHandle(pcii, (LPSTR)&mc,
pep->cbEventData, 0,
HDATA_NOAPPFREE | HDATA_READONLY | HDATA_EXECUTE, 0, 0);
if (hData) {
DoCallback(pcii, (WORD)XTYP_MONITOR, 0, 0, 0, 0, hData, 0L,
pep->EventType);
InternalFreeDataHandle((HDDEDATA)hData, TRUE);
DeleteAtom(LATOM_FROM_HSZ(mc.hszSvc));
DeleteAtom(LATOM_FROM_HSZ(mc.hszTopic));
}
}
break;
case MF_HSZ_INFO:
if (!(pcii->flags & IIF_UNICODE)) {
LPSTR pszAnsi;
/*
* Translate HSZ string back into ANSI
*/
if (WCSToMB(((PMONHSZSTRUCT)&pep->Data)->str,
((int)pep->cbEventData - (int)((PMONHSZSTRUCT)&pep->Data)->cb) / sizeof(WCHAR),
&pszAnsi,
(int)pep->cbEventData - (int)((PMONHSZSTRUCT)&pep->Data)->cb,
TRUE)) {
strcpy(((PMONHSZSTRUCTA)&pep->Data)->str, pszAnsi);
UserLocalFree(pszAnsi);
}
((PMONHSZSTRUCT)&pep->Data)->cb = sizeof(MONHSZSTRUCTA);
}
// fall through
case MF_SENDMSGS:
case MF_POSTMSGS:
if (pep->EventType == MF_POSTMSGS) {
PMONMSGSTRUCT pmms = (PMONMSGSTRUCT)&pep->Data;
BYTE buf[32];
/*
* We may need to translate the Execute string to/from
* UNICODE depending on what type of monitor this is
* going to.
*/
if (pmms->wMsg == WM_DDE_EXECUTE) {
BOOL fUnicodeText;
int flags;
flags = (IS_TEXT_UNICODE_UNICODE_MASK |
IS_TEXT_UNICODE_REVERSE_MASK |
(IS_TEXT_UNICODE_NOT_UNICODE_MASK &
(~IS_TEXT_UNICODE_ILLEGAL_CHARS)) |
IS_TEXT_UNICODE_NOT_ASCII_MASK);
#ifdef ISTEXTUNICODE_WORKS
fUnicodeText = RtlIsTextUnicode(pmms->dmhd.Data,
min(32, pmms->dmhd.cbData), &flags);
#else
fUnicodeText = (*(LPSTR)pmms->dmhd.Data == '\0');
#endif
if (pcii->flags & IIF_UNICODE && !fUnicodeText) {
/* Ascii->UNICODE */
RtlMultiByteToUnicodeN((LPWSTR)buf, 32, NULL,
(LPSTR)&pmms->dmhd.Data,
min(32, pmms->dmhd.cbData));
RtlCopyMemory(&pmms->dmhd.Data, buf, 32);
} else if (!(pcii->flags & IIF_UNICODE) && fUnicodeText) {
/* UNICODE->Ascii */
RtlUnicodeToMultiByteN((LPSTR)buf, 32, NULL,
(LPWSTR)&pmms->dmhd.Data,
min(32, pmms->dmhd.cbData));
RtlCopyMemory(&pmms->dmhd.Data, buf, 32);
}
}
}
case MF_ERRORS:
hData = InternalCreateDataHandle(pcii, (LPSTR)&pep->Data,
pep->cbEventData, 0,
HDATA_NOAPPFREE | HDATA_READONLY | HDATA_EXECUTE, 0, 0);
if (hData) {
DoCallback(pcii, (WORD)XTYP_MONITOR, 0, 0, 0, 0, hData, 0L,
pep->EventType);
InternalFreeDataHandle((HDDEDATA)hData, TRUE);
}
break;
}
LeaveDDECrit;
return (0);
}
HWND WINAPI
User32CreateWindowEx(DWORD dwExStyle,
LPCSTR lpClassName,
LPCSTR lpWindowName,
DWORD dwStyle,
int x,
int y,
int nWidth,
int nHeight,
HWND hWndParent,
HMENU hMenu,
HINSTANCE hInstance,
LPVOID lpParam,
DWORD dwFlags)
{
LARGE_STRING WindowName;
LARGE_STRING lstrClassName, *plstrClassName;
UNICODE_STRING ClassName;
WNDCLASSEXA wceA;
WNDCLASSEXW wceW;
HMODULE hLibModule = NULL;
DWORD save_error;
BOOL Unicode, ClassFound = FALSE;
HWND Handle = NULL;
#if 0
DbgPrint("[window] User32CreateWindowEx style %d, exstyle %d, parent %d\n", dwStyle, dwExStyle, hWndParent);
#endif
if (!RegisterDefaultClasses)
{
TRACE("RegisterSystemControls\n");
RegisterSystemControls();
}
Unicode = !(dwFlags & NUCWE_ANSI);
if (IS_ATOM(lpClassName))
{
plstrClassName = (PVOID)lpClassName;
}
else
{
if(Unicode)
RtlInitUnicodeString(&ClassName, (PCWSTR)lpClassName);
else
{
if (!RtlCreateUnicodeStringFromAsciiz(&ClassName, (PCSZ)lpClassName))
{
SetLastError(ERROR_OUTOFMEMORY);
return (HWND)0;
}
}
/* Copy it to a LARGE_STRING */
lstrClassName.Buffer = ClassName.Buffer;
lstrClassName.Length = ClassName.Length;
lstrClassName.MaximumLength = ClassName.MaximumLength;
plstrClassName = &lstrClassName;
}
/* Initialize a LARGE_STRING */
RtlInitLargeString(&WindowName, lpWindowName, Unicode);
// HACK: The current implementation expects the Window name to be UNICODE
if (!Unicode)
{
NTSTATUS Status;
PSTR AnsiBuffer = WindowName.Buffer;
ULONG AnsiLength = WindowName.Length;
WindowName.Length = 0;
WindowName.MaximumLength = AnsiLength * sizeof(WCHAR);
WindowName.Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
0,
WindowName.MaximumLength);
if (!WindowName.Buffer)
{
SetLastError(ERROR_OUTOFMEMORY);
goto cleanup;
}
Status = RtlMultiByteToUnicodeN(WindowName.Buffer,
WindowName.MaximumLength,
&WindowName.Length,
AnsiBuffer,
AnsiLength);
if (!NT_SUCCESS(Status))
{
goto cleanup;
}
}
if(!hMenu && (dwStyle & (WS_OVERLAPPEDWINDOW | WS_POPUP)))
{
if(Unicode)
{
wceW.cbSize = sizeof(WNDCLASSEXW);
if(GetClassInfoExW(hInstance, (LPCWSTR)lpClassName, &wceW) && wceW.lpszMenuName)
{
hMenu = LoadMenuW(hInstance, wceW.lpszMenuName);
}
}
else
{
wceA.cbSize = sizeof(WNDCLASSEXA);
if(GetClassInfoExA(hInstance, lpClassName, &wceA) && wceA.lpszMenuName)
{
hMenu = LoadMenuA(hInstance, wceA.lpszMenuName);
}
}
}
if (!Unicode) dwExStyle |= WS_EX_SETANSICREATOR;
for(;;)
{
Handle = NtUserCreateWindowEx(dwExStyle,
plstrClassName,
NULL,
&WindowName,
dwStyle,
x,
y,
nWidth,
nHeight,
hWndParent,
hMenu,
hInstance,
lpParam,
dwFlags,
NULL);
if (Handle) break;
if (!ClassFound)
{
save_error = GetLastError();
if ( save_error == ERROR_CANNOT_FIND_WND_CLASS )
{
ClassFound = VersionRegisterClass(ClassName.Buffer, NULL, NULL, &hLibModule);
if (ClassFound) continue;
}
}
if (hLibModule)
{
save_error = GetLastError();
FreeLibrary(hLibModule);
SetLastError(save_error);
hLibModule = 0;
}
break;
}
#if 0
DbgPrint("[window] NtUserCreateWindowEx() == %d\n", Handle);
#endif
cleanup:
if(!Unicode)
{
if (!IS_ATOM(lpClassName))
{
RtlFreeUnicodeString(&ClassName);
}
RtlFreeLargeString(&WindowName);
}
return Handle;
}
int
InfHostOpenFile(PHINF InfHandle,
const CHAR *FileName,
LANGID LanguageId,
ULONG *ErrorLine)
{
FILE *File;
CHAR *FileBuffer;
ULONG FileLength;
ULONG FileBufferLength;
PINFCACHE Cache;
INFSTATUS Status = INF_STATUS_SUCCESS;
*InfHandle = NULL;
*ErrorLine = (ULONG)-1;
/* Open the inf file */
File = fopen(FileName, "rb");
if (NULL == File)
{
DPRINT1("fopen() failed (errno %d)\n", errno);
return -1;
}
DPRINT("fopen() successful\n");
/* Query file size */
if (fseek(File, (size_t)0, SEEK_END))
{
DPRINT1("fseek() to EOF failed (errno %d)\n", errno);
fclose(File);
return -1;
}
FileLength = (ULONG)ftell(File);
if ((ULONG) -1 == FileLength)
{
DPRINT1("ftell() failed (errno %d)\n", errno);
fclose(File);
return -1;
}
DPRINT("File size: %u\n", (UINT)FileLength);
/* Rewind */
if (fseek(File, (size_t)0, SEEK_SET))
{
DPRINT1("fseek() to BOF failed (errno %d)\n", errno);
fclose(File);
return -1;
}
/* Allocate file buffer */
FileBufferLength = FileLength + 2;
FileBuffer = MALLOC(FileBufferLength);
if (FileBuffer == NULL)
{
DPRINT1("MALLOC() failed\n");
fclose(File);
return -1;
}
/* Read file */
if (FileLength != fread(FileBuffer, (size_t)1, (size_t)FileLength, File))
{
DPRINT1("fread() failed (errno %d)\n", errno);
FREE(FileBuffer);
fclose(File);
return -1;
}
fclose(File);
/* Append string terminator */
FileBuffer[FileLength] = 0;
FileBuffer[FileLength + 1] = 0;
/* Allocate infcache header */
Cache = (PINFCACHE)MALLOC(sizeof(INFCACHE));
if (Cache == NULL)
{
DPRINT1("MALLOC() failed\n");
FREE(FileBuffer);
return -1;
}
/* Initialize inicache header */
ZEROMEMORY(Cache,
sizeof(INFCACHE));
Cache->LanguageId = LanguageId;
/* Parse the inf buffer */
if (!RtlIsTextUnicode(FileBuffer, (INT)FileBufferLength, NULL))
{
// static const BYTE utf8_bom[3] = { 0xef, 0xbb, 0xbf };
WCHAR *new_buff;
// UINT codepage = CP_ACP;
UINT offset = 0;
// if (FileLength > sizeof(utf8_bom) && !memcmp(FileBuffer, utf8_bom, sizeof(utf8_bom) ))
// {
// codepage = CP_UTF8;
// offset = sizeof(utf8_bom);
// }
new_buff = MALLOC(FileBufferLength * sizeof(WCHAR));
if (new_buff != NULL)
{
ULONG len;
Status = RtlMultiByteToUnicodeN(new_buff,
FileBufferLength * sizeof(WCHAR),
&len,
(char *)FileBuffer + offset,
FileBufferLength - offset);
Status = InfpParseBuffer(Cache,
new_buff,
new_buff + len / sizeof(WCHAR),
ErrorLine);
FREE(new_buff);
}
else
Status = INF_STATUS_INSUFFICIENT_RESOURCES;
}
else
{
WCHAR *new_buff = (WCHAR *)FileBuffer;
/* UCS-16 files should start with the Unicode BOM; we should skip it */
if (*new_buff == 0xfeff)
{
new_buff++;
FileBufferLength -= sizeof(WCHAR);
}
Status = InfpParseBuffer(Cache,
new_buff,
(WCHAR*)((char*)new_buff + FileBufferLength),
ErrorLine);
}
if (!INF_SUCCESS(Status))
{
FREE(Cache);
Cache = NULL;
}
/* Free file buffer */
FREE(FileBuffer);
*InfHandle = (HINF)Cache;
return INF_SUCCESS(Status) ? 0 : -1;
}
/******************************************************************
* CDROM_InitRegistry
*
* Initializes registry to contain scsi info about the cdrom in NT.
* All devices (even not real scsi ones) have this info in NT.
* TODO: for now it only works for non scsi devices
* NOTE: programs usually read these registry entries after sending the
* IOCTL_SCSI_GET_ADDRESS ioctl to the cdrom
*/
void CDROM_InitRegistry(int dev)
{
int portnum, targetid;
int dma;
OBJECT_ATTRIBUTES attr;
UNICODE_STRING nameW;
WCHAR dataW[50];
DWORD lenW;
char buffer[40];
DWORD value;
const char *data;
HKEY scsiKey;
HKEY portKey;
HKEY busKey;
HKEY targetKey;
DWORD disp;
attr.Length = sizeof(attr);
attr.RootDirectory = HKEY_LOCAL_MACHINE;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
if ( ! CDROM_GetIdeInterface(dev, &portnum, &targetid))
return;
/* Ensure there is Scsi key */
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "HARDWARE\\DEVICEMAP\\Scsi" ) ||
NtCreateKey( &scsiKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi registry key\n" );
return;
}
RtlFreeUnicodeString( &nameW );
snprintf(buffer,40,"Scsi Port %d",portnum);
attr.RootDirectory = scsiKey;
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||
NtCreateKey( &portKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi Port registry key\n" );
return;
}
RtlFreeUnicodeString( &nameW );
RtlCreateUnicodeStringFromAsciiz( &nameW, "Driver" );
data = "atapi";
RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
NtSetValueKey( portKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
RtlFreeUnicodeString( &nameW );
value = 10;
RtlCreateUnicodeStringFromAsciiz( &nameW, "FirstBusTimeScanInMs" );
NtSetValueKey( portKey,&nameW, 0, REG_DWORD, (BYTE *)&value, sizeof(DWORD));
RtlFreeUnicodeString( &nameW );
value = 0;
#ifdef HDIO_GET_DMA
if (ioctl(dev,HDIO_GET_DMA, &dma) != -1) {
value = dma;
TRACE("setting dma to %lx\n", value);
}
#endif
RtlCreateUnicodeStringFromAsciiz( &nameW, "DMAEnabled" );
NtSetValueKey( portKey,&nameW, 0, REG_DWORD, (BYTE *)&value, sizeof(DWORD));
RtlFreeUnicodeString( &nameW );
attr.RootDirectory = portKey;
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "Scsi Bus 0" ) ||
NtCreateKey( &busKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus registry key\n" );
return;
}
RtlFreeUnicodeString( &nameW );
attr.RootDirectory = busKey;
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, "Initiator Id 255" ) ||
NtCreateKey( &targetKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus\\Initiator Id 255 registry key\n" );
return;
}
RtlFreeUnicodeString( &nameW );
NtClose( targetKey );
snprintf(buffer,40,"Target Id %d", targetid);
attr.RootDirectory = busKey;
if (!RtlCreateUnicodeStringFromAsciiz( &nameW, buffer ) ||
NtCreateKey( &targetKey, KEY_ALL_ACCESS, &attr, 0,
NULL, REG_OPTION_VOLATILE, &disp ))
{
ERR("Cannot create DEVICEMAP\\Scsi Port\\Scsi Bus 0\\Target Id registry key\n" );
return;
}
RtlFreeUnicodeString( &nameW );
RtlCreateUnicodeStringFromAsciiz( &nameW, "Type" );
data = "CdRomPeripheral";
RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
RtlFreeUnicodeString( &nameW );
/* FIXME - maybe read the real identifier?? */
RtlCreateUnicodeStringFromAsciiz( &nameW, "Identifier" );
data = "Wine CDROM";
RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
RtlFreeUnicodeString( &nameW );
/* FIXME - we always use Cdrom0 - do not know about the nt behaviour */
RtlCreateUnicodeStringFromAsciiz( &nameW, "DeviceName" );
data = "Cdrom0";
RtlMultiByteToUnicodeN( dataW, 50, &lenW, data, strlen(data));
NtSetValueKey( targetKey, &nameW, 0, REG_SZ, (BYTE*)dataW, lenW );
RtlFreeUnicodeString( &nameW );
NtClose( targetKey );
NtClose( busKey );
NtClose( portKey );
NtClose( scsiKey );
}
BOOL RtlMBMessageWParamCharToWCS(DWORD msg, WPARAM *pWParam)
{
DWORD dwUni;
NTSTATUS Status;
// FE_SB (RtlMBMessageWParamCharToWCS)
BOOL bWmCrIrDbcsChar = FALSE;
WORD wAnsi = LOWORD(*pWParam);
// end FE_SB (RtlMBMessageWParamCharToWCS)
WORD CodePage = THREAD_CODEPAGE();
/*
* Only these messages have CHARs: others are passed through
*/
switch(msg) {
// FE_SB (RtlMBMessageWParamCharToWCS)
case WM_CHAR:
//
// WM_CHAR's wParam format for WM_IME_REPORT:IR_DBCSCHAR
//
if (IS_DBCS_ENABLED() && (*pWParam & WMCR_IR_DBCSCHAR)) {
//
// Mark this message is sent as IR_DBCSCHAR format.
//
bWmCrIrDbcsChar = TRUE;
}
//
// Fall through....
//
#ifdef FE_IME
case WM_IME_CHAR:
case WM_IME_COMPOSITION:
//
// We need to re-align for Unicode convertsion..
// WM_CHAR/WM_IME_CHAR/WM_IME_COMPOSITION's wParam format :
//
// ReAlign IR_DBCS char format to regular sequence.
//
// From:
//
// HIWORD(wParam) = 0;
// HIBYTE(LOWORD(wParam)) = DBCS LeadingByte.
// LOBYTE(LOWORD(wParan)) = DBCS TrailingByte or SBCS character.
//
// To:
// HIWORD(wParam) = 0;
// HIBYTE(LOWORD(wParam)) = DBCS TrailingByte.
// LOBYTE(LOWORD(wParam)) = DBCS LeadingByte or SBCS character.
//
if (IS_DBCS_ENABLED()) {
*pWParam = MAKE_WPARAM_DBCSCHAR(wAnsi);
}
#endif
//
// Fall through...
//
// end FE_SB (RtlMBMessageWParamCharToWCS)
case WM_CHARTOITEM:
case EM_SETPASSWORDCHAR:
case WM_DEADCHAR:
case WM_SYSCHAR:
case WM_SYSDEADCHAR:
case WM_MENUCHAR:
dwUni = 0;
if (IS_ACP(CodePage)) {
Status = RtlMultiByteToUnicodeN((LPWSTR)&dwUni, sizeof(dwUni),
NULL, (LPSTR)pWParam, 2 * sizeof(CHAR));
if (!NT_SUCCESS(Status))
return FALSE;
} else {
int cwch;
#ifdef _USERK_
cwch = EngMultiByteToWideChar(CodePage,
(LPWSTR)&dwUni, sizeof(dwUni),
(LPSTR)pWParam, 2);
#else
cwch = MultiByteToWideChar(CodePage, 0,
(LPSTR)pWParam, 2,
(LPWSTR)&dwUni, sizeof(dwUni) / sizeof(WCHAR));
#endif // _USERK_
// KdPrint(("0x%02x -> 0x%04x (%d)\n", *pWParam, dwUni, CodePage));
if (cwch == 0) {
return FALSE;
}
}
// FE_SB (RtlMBMessageWParamCharToWCS)
//
// if this character is sent for WM_IME_REPORT:IR_DBCSCHAR, we mark it.
//
if (bWmCrIrDbcsChar)
dwUni |= WMCR_IR_DBCSCHAR;
// else FE_SB (RtlMBMessageWParamCharToWCS)
#if DBG
if ((dwUni == 0) || (dwUni > 0xFF)) {
RIPMSG1(RIP_VERBOSE, "msgA -> msgW: wchar = 0x%lX\n", dwUni);
}
#endif
// end FE_SB
*pWParam = dwUni;
break;
}
return TRUE;
}
int MBToWCSEx(
WORD wCodePage,
LPCSTR pAnsiString,
int nAnsiChar,
LPWSTR *ppUnicodeString,
int cchUnicodeString,
BOOL bAllocateMem)
{
ULONG nBytesInUnicodeString;
if (nAnsiChar == 0 || cchUnicodeString == 0 || pAnsiString == NULL) {
return 0; // nothing to translate or nowhere to put it
}
/*
* Adjust the nAnsiChar value. If nAnsiChar == -1 then the
* string pointed to by pAnsiString is NUL terminated so we
* count the number of bytes. If nAnsiChar < -1 this is an
* illegal value so we return FALSE. Otherwise, nAnsiChar is
* set and requires no adjustment.
*/
#ifdef _USERK_
UserAssert(nAnsiChar >= USER_AWCONV_COUNTSTRINGSZ);
#endif
if (nAnsiChar < 0) {
/*
* Bug 268035 - joejo
* Need to fail if the count is a negative number less than -2!
*/
if (nAnsiChar < USER_AWCONV_COUNTSTRINGSZ) {
return 0;
}
#if (USER_AWCONV_COUNTSTRING != -1 || USER_AWCONV_COUNTSTRINGSZ != -2)
#error USER_AWCONV_COUNTSTRING or USER_AWCONV_COUNTSTRINGSZ has unexpected value.
#endif
/* HACK HACK HACK
* If nAnsiChar is -1 (USER_AWCONV_COUNTSTRING), nAnsiChar length will be strlen() + 1,
* to allocate the memory including trailing \0: this is compatible to the original code.
* If nAnsiCahr is -2 (USER_AWCONV_COUNTSTRINGSZ), memory for trailing \0 will not be needed,
* so memory allocation is optimized and the return value would be same as strlen().
*/
nAnsiChar = strlen(pAnsiString) + 2 + nAnsiChar; // don't forget the NUL if nAnsiChar == -1
if (nAnsiChar == 0) {
return 0;
}
}
/*
* Adjust the cchUnicodeString value. If cchUnicodeString == -1 then we
* pick a value based on nAnsiChar to hold the converted string. If
* cchUnicodeString < -1 this is an illegal value so we return FALSE.
* Otherwise, cchUnicodeString is set and requires no adjustment.
*/
if (cchUnicodeString == -1) {
if (bAllocateMem == FALSE) {
return 0; // no destination
}
cchUnicodeString = nAnsiChar;
} else if (cchUnicodeString < -1) {
return 0; // illegal value
}
if (bAllocateMem) {
*ppUnicodeString = (LPWSTR)UserRtlAllocMem(cchUnicodeString*sizeof(WCHAR));
if (*ppUnicodeString == NULL) {
return 0; // allocation failed
}
}
/*
* if codepage is CP_ACP, We will call faster RtlXXX function.
*/
if (IS_ACP(wCodePage)) {
/*
* translate ANSI string pointed to by pAnsiString into Unicode
* and store in location pointed to by pUnicodeString. We
* stop translating when we fill up the Unicode buffer or reach
* the end of the ANSI string.
*/
if (!NT_SUCCESS(RtlMultiByteToUnicodeN(
(PWCH)*ppUnicodeString,
cchUnicodeString * sizeof(WCHAR),
&nBytesInUnicodeString,
(PCH)pAnsiString,
nAnsiChar
))) {
if (bAllocateMem) {
UserRtlFreeMem(*ppUnicodeString);
}
return 0; // translation failed
}
return (int)(nBytesInUnicodeString / sizeof(WCHAR));
} else {
/*
* if wCodePage is not ACP, Call NLS API.
*/
ULONG nCharsInUnicodeString;
#ifdef _USERK_
/*
* I believe we will never hit this code which is why I am
* adding this assert. [gerritv] 5-21-96
*/
#define SHOULD_NOT_REACH_HERE 0
UserAssert(SHOULD_NOT_REACH_HERE);
#undef SHOULD_NOT_REACH_HERE
return 0;
#if 0 // FYI: old code
INT iCharsInUnicodeString;
/*
* Call GRE to convert string to Unicode. (Kernel mode)
* I believe we will never hit this code which is why I am
* adding this assert. [gerritv] 5-21-96
*/
UserAssert(0);
iCharsInUnicodeString = EngMultiByteToWideChar(
(UINT)wCodePage,
(LPWSTR)*ppUnicodeString,
(int)cchUnicodeString * sizeof(WCHAR),
(LPSTR)pAnsiString,
(int)nAnsiChar);
nCharsInUnicodeString = (iCharsInUnicodeString == -1) ? 0 :
(ULONG) iCharsInUnicodeString;
#endif
#else
/*
* Call NLS API (Kernel32) to convert string to Unicode. (User mode)
*/
nCharsInUnicodeString = MultiByteToWideChar(
(UINT)wCodePage, 0,
(LPCSTR)pAnsiString,
(int)nAnsiChar,
(LPWSTR)*ppUnicodeString,
(int)cchUnicodeString);
#endif // _USERK_
if (nCharsInUnicodeString == 0) {
if (bAllocateMem) {
UserRtlFreeMem(*ppUnicodeString);
}
}
return (int)nCharsInUnicodeString;
}
}
BOOL DefSetText(
PWND pwnd,
PLARGE_STRING cczpstr)
{
/*
* Note -- string buffer may be on client side.
*/
PDESKTOP pdesk;
DWORD cbString;
BOOL fTranslateOk;
if (pwnd->head.rpdesk == NULL || cczpstr == NULL || cczpstr->Buffer == NULL) {
pwnd->strName.Length = 0;
return TRUE;
}
/*
* Capture the new window name
*/
if (cczpstr->bAnsi)
cbString = (cczpstr->Length + 1) * sizeof(WCHAR);
else
cbString = cczpstr->Length + sizeof(WCHAR);
/*
* If the current buffer is not large enough,
* reallocate it.
*/
pdesk = pwnd->head.rpdesk;
if (pwnd->strName.MaximumLength < cbString) {
if (pwnd->strName.Buffer != NULL)
DesktopFree(pdesk, pwnd->strName.Buffer);
pwnd->strName.Buffer = (LPWSTR)DesktopAlloc(pdesk, cbString, DTAG_TEXT);
pwnd->strName.Length = 0;
if (pwnd->strName.Buffer == NULL) {
pwnd->strName.MaximumLength = 0;
return FALSE;
}
pwnd->strName.MaximumLength = cbString;
}
fTranslateOk = TRUE;
if (cczpstr->Length != 0) {
try {
if (!cczpstr->bAnsi) {
RtlCopyMemory(pwnd->strName.Buffer, cczpstr->Buffer, cbString);
} else {
LPCSTR ccxpszAnsi = (LPCSTR)cczpstr->Buffer;
fTranslateOk = NT_SUCCESS(RtlMultiByteToUnicodeN(pwnd->strName.Buffer,
cbString, &cbString,
(LPSTR)ccxpszAnsi, cbString / sizeof(WCHAR)));
}
} except (W32ExceptionHandler(FALSE, RIP_WARNING)) {
pwnd->strName.Length = 0;
return FALSE;
}
}
if (fTranslateOk) {
pwnd->strName.Length = cbString - sizeof(WCHAR);
return TRUE;
} else {
pwnd->strName.Length = 0;
return FALSE;
}
}
NTSTATUS
InfOpenFile(PHINF InfHandle,
PUNICODE_STRING FileName,
LANGID LanguageId,
PULONG ErrorLine)
{
OBJECT_ATTRIBUTES ObjectAttributes;
FILE_STANDARD_INFORMATION FileInfo;
IO_STATUS_BLOCK IoStatusBlock;
HANDLE FileHandle;
NTSTATUS Status;
PCHAR FileBuffer;
ULONG FileLength;
ULONG FileBufferLength;
LARGE_INTEGER FileOffset;
PINFCACHE Cache;
CheckHeap();
*InfHandle = NULL;
*ErrorLine = (ULONG)-1;
/* Open the inf file */
InitializeObjectAttributes(&ObjectAttributes,
FileName,
0,
NULL,
NULL);
Status = NtOpenFile(&FileHandle,
GENERIC_READ | SYNCHRONIZE,
&ObjectAttributes,
&IoStatusBlock,
FILE_SHARE_READ,
FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
if (!INF_SUCCESS(Status))
{
DPRINT("NtOpenFile() failed (Status %lx)\n", Status);
return(Status);
}
DPRINT("NtOpenFile() successful\n");
/* Query file size */
Status = NtQueryInformationFile(FileHandle,
&IoStatusBlock,
&FileInfo,
sizeof(FILE_STANDARD_INFORMATION),
FileStandardInformation);
if (!INF_SUCCESS(Status))
{
DPRINT("NtQueryInformationFile() failed (Status %lx)\n", Status);
NtClose(FileHandle);
return(Status);
}
FileLength = FileInfo.EndOfFile.u.LowPart;
DPRINT("File size: %lu\n", FileLength);
/* Allocate file buffer */
FileBufferLength = FileLength + 2;
FileBuffer = MALLOC(FileBufferLength);
if (FileBuffer == NULL)
{
DPRINT1("MALLOC() failed\n");
NtClose(FileHandle);
return(INF_STATUS_INSUFFICIENT_RESOURCES);
}
/* Read file */
FileOffset.QuadPart = 0ULL;
Status = NtReadFile(FileHandle,
NULL,
NULL,
NULL,
&IoStatusBlock,
FileBuffer,
FileLength,
&FileOffset,
NULL);
/* Append string terminator */
FileBuffer[FileLength] = 0;
FileBuffer[FileLength + 1] = 0;
NtClose(FileHandle);
if (!INF_SUCCESS(Status))
{
DPRINT("NtReadFile() failed (Status %lx)\n", Status);
FREE(FileBuffer);
return(Status);
}
/* Allocate infcache header */
Cache = (PINFCACHE)MALLOC(sizeof(INFCACHE));
if (Cache == NULL)
{
DPRINT("MALLOC() failed\n");
FREE(FileBuffer);
return(INF_STATUS_INSUFFICIENT_RESOURCES);
}
/* Initialize inicache header */
ZEROMEMORY(Cache,
sizeof(INFCACHE));
Cache->LanguageId = LanguageId;
/* Parse the inf buffer */
if (!RtlIsTextUnicode(FileBuffer, FileBufferLength, NULL))
{
// static const BYTE utf8_bom[3] = { 0xef, 0xbb, 0xbf };
WCHAR *new_buff;
// UINT codepage = CP_ACP;
UINT offset = 0;
// if (FileLength > sizeof(utf8_bom) && !memcmp(FileBuffer, utf8_bom, sizeof(utf8_bom) ))
// {
// codepage = CP_UTF8;
// offset = sizeof(utf8_bom);
// }
new_buff = MALLOC(FileBufferLength * sizeof(WCHAR));
if (new_buff != NULL)
{
ULONG len;
Status = RtlMultiByteToUnicodeN(new_buff,
FileBufferLength * sizeof(WCHAR),
&len,
(char *)FileBuffer + offset,
FileBufferLength - offset);
Status = InfpParseBuffer(Cache,
new_buff,
new_buff + len / sizeof(WCHAR),
ErrorLine);
FREE(new_buff);
}
else
Status = INF_STATUS_INSUFFICIENT_RESOURCES;
}
else
{
WCHAR *new_buff = (WCHAR *)FileBuffer;
/* UCS-16 files should start with the Unicode BOM; we should skip it */
if (*new_buff == 0xfeff)
{
new_buff++;
FileBufferLength -= sizeof(WCHAR);
}
Status = InfpParseBuffer(Cache,
new_buff,
(WCHAR*)((char*)new_buff + FileBufferLength),
ErrorLine);
}
if (!INF_SUCCESS(Status))
{
FREE(Cache);
Cache = NULL;
}
/* Free file buffer */
FREE(FileBuffer);
*InfHandle = (HINF)Cache;
return(Status);
}
DWORD DeviceCapsHandler(LPWOWFAXINFO lpfaxinfo)
{
LPWOWFAXINFO16 lpWFI16;
LPSTR lpSrc;
LPBYTE lpDest;
INT i;
DWORD cbData16; // Size of data items.
UINT cbUni;
LOGDEBUG(0,("DeviceCapsHandler, lpfaxinfo: %X, wCmd: %X\n", lpfaxinfo, lpfaxinfo->wCmd));
GETVDMPTR(lpfaxinfo->lpinfo16, sizeof(WOWFAXINFO16), lpWFI16);
// Get the number of data items with a call to the 16-bit printer driver.
lpWFI16->lpDriverName = 0;
lpWFI16->lpPortName = 0;
lpWFI16->wCmd = lpfaxinfo->wCmd;
lpWFI16->cData = 0;
lpWFI16->lpOut = 0;
lpfaxinfo->cData = 0;
lpfaxinfo->retvalue = CallWindowProc(gfaxinfo.proc16, gfaxinfo.hwnd,
lpfaxinfo->msg, lpfaxinfo->hdc,
(LPARAM)lpfaxinfo->lpinfo16);
cbData16 = gDC_ListItemSize[lpfaxinfo->wCmd];
if (lpfaxinfo->lpOut && cbData16 && lpfaxinfo->retvalue) {
// We need to allocate and copy for this query
lpWFI16->cData = cbData16 * lpfaxinfo->retvalue;
// assert the size of output buffer - and set it the actual data size
switch (lpfaxinfo->wCmd) {
case DC_BINNAMES:
case DC_PAPERNAMES:
// These fields need extra room for ANSI to UNICODE conversion.
WOW32ASSERT((lpfaxinfo->cData - (DWORD)lpfaxinfo->lpOut) >= lpWFI16->cData * sizeof(WCHAR));
lpfaxinfo->cData = lpWFI16->cData * sizeof(WCHAR);
break;
default:
WOW32ASSERT((lpfaxinfo->cData - (DWORD)lpfaxinfo->lpOut) >= lpWFI16->cData);
lpfaxinfo->cData = lpWFI16->cData;
break;
}
if ((lpWFI16->lpOut = (LPSTR)malloc16(lpWFI16->cData)) == NULL) {
lpfaxinfo->retvalue = 0;
goto LeaveDeviceCapsHandler;
}
// Get the list data with a call to the 16-bit printer driver.
lpfaxinfo->retvalue = CallWindowProc(gfaxinfo.proc16, gfaxinfo.hwnd,
lpfaxinfo->msg, lpfaxinfo->hdc,
(LPARAM)lpfaxinfo->lpinfo16);
GETVDMPTR(lpWFI16->lpOut, 0, lpSrc);
lpDest = (LPBYTE)lpfaxinfo + (DWORD)lpfaxinfo->lpOut;
switch (lpfaxinfo->wCmd) {
case DC_BINNAMES:
case DC_PAPERNAMES:
for (i = 0; i < (INT)lpfaxinfo->retvalue; i++) {
RtlMultiByteToUnicodeN((LPWSTR)lpDest,
cbData16 * sizeof(WCHAR),
(PULONG)&cbUni,
(LPBYTE)lpSrc, cbData16);
lpDest += cbData16 * sizeof(WCHAR);
lpSrc += cbData16;
}
break;
default:
RtlCopyMemory(lpDest, lpSrc, lpWFI16->cData);
break;
}
free16((VPVOID)lpWFI16->lpOut);
FREEVDMPTR(lpSrc);
}
LeaveDeviceCapsHandler:
FREEVDMPTR(lpWFI16);
return lpfaxinfo->retvalue;
}
int
InfHostOpenBufferedFile(PHINF InfHandle,
void *Buffer,
ULONG BufferSize,
LANGID LanguageId,
ULONG *ErrorLine)
{
INFSTATUS Status;
PINFCACHE Cache;
WCHAR *FileBuffer;
ULONG FileBufferSize;
*InfHandle = NULL;
*ErrorLine = (ULONG)-1;
/* Allocate file buffer */
FileBufferSize = BufferSize + 2;
FileBuffer = MALLOC(FileBufferSize);
if (FileBuffer == NULL)
{
DPRINT1("MALLOC() failed\n");
return(INF_STATUS_INSUFFICIENT_RESOURCES);
}
MEMCPY(FileBuffer, Buffer, BufferSize);
/* Append string terminator */
FileBuffer[BufferSize] = 0;
FileBuffer[BufferSize + 1] = 0;
/* Allocate infcache header */
Cache = (PINFCACHE)MALLOC(sizeof(INFCACHE));
if (Cache == NULL)
{
DPRINT1("MALLOC() failed\n");
FREE(FileBuffer);
return(INF_STATUS_INSUFFICIENT_RESOURCES);
}
/* Initialize inicache header */
ZEROMEMORY(Cache,
sizeof(INFCACHE));
Cache->LanguageId = LanguageId;
/* Parse the inf buffer */
if (!RtlIsTextUnicode(FileBuffer, (INT)FileBufferSize, NULL))
{
// static const BYTE utf8_bom[3] = { 0xef, 0xbb, 0xbf };
WCHAR *new_buff;
// UINT codepage = CP_ACP;
UINT offset = 0;
// if (BufferSize > sizeof(utf8_bom) && !memcmp(FileBuffer, utf8_bom, sizeof(utf8_bom) ))
// {
// codepage = CP_UTF8;
// offset = sizeof(utf8_bom);
// }
new_buff = MALLOC(FileBufferSize * sizeof(WCHAR));
if (new_buff != NULL)
{
ULONG len;
Status = RtlMultiByteToUnicodeN(new_buff,
FileBufferSize * sizeof(WCHAR),
&len,
(char *)FileBuffer + offset,
FileBufferSize - offset);
Status = InfpParseBuffer(Cache,
new_buff,
new_buff + len / sizeof(WCHAR),
ErrorLine);
FREE(new_buff);
}
else
Status = INF_STATUS_INSUFFICIENT_RESOURCES;
}
else
{
WCHAR *new_buff = (WCHAR *)FileBuffer;
/* UCS-16 files should start with the Unicode BOM; we should skip it */
if (*new_buff == 0xfeff)
{
new_buff++;
FileBufferSize -= sizeof(WCHAR);
}
Status = InfpParseBuffer(Cache,
new_buff,
(WCHAR*)((char*)new_buff + FileBufferSize),
ErrorLine);
}
if (!INF_SUCCESS(Status))
{
FREE(Cache);
Cache = NULL;
}
/* Free file buffer */
FREE(FileBuffer);
*InfHandle = (HINF)Cache;
return INF_SUCCESS(Status) ? 0 : -1;
}
BOOL bGetANSISetMap()
{
CHAR ch[256];
ULONG *pul;
ULONG ii,jj;
NTSTATUS st;
ULONG cjResult;
WCHAR *pwc;
WCHAR *pwcSBC;
// See if we know the answers already. (The client should not have called!)
if (gpwcANSICharSet != (WCHAR *) NULL)
return(TRUE);
// Create a mapping.
// Make an ANSI source char set. This funny way of initialization takes
// about 180 instructions to execute rather than over 1000.
pul = (ULONG *) ch;
for (ii=0x03020100L,jj=0; jj<64; jj+=4)
{
pul[jj+0] = ii;
ii += 0x04040404L;
pul[jj+1] = ii;
ii += 0x04040404L;
pul[jj+2] = ii;
ii += 0x04040404L;
pul[jj+3] = ii;
ii += 0x04040404L;
}
// Allocate the UNICODE buffer but don't write the pointer in until the
// table is valid, in case we're racing another thread.
pwc = LOCALALLOC(512 * sizeof(WCHAR));
pwcSBC = &pwc[256];
if (pwc == (WCHAR *) NULL)
return(FALSE);
// Convert the characters.
pwc[0] = 0;
st = RtlMultiByteToUnicodeN
(
&pwc[1], // OUT PWCH UnicodeString
255 * sizeof(WCHAR), // IN ULONG MaxBytesInUnicodeString
&cjResult, // OUT PULONG BytesInUnicodeString
&ch[1], // IN PCH MultiByteString
255 // IN ULONG BytesInMultiByteString
);
if( !NT_SUCCESS(st) )
{
// Clean up and forget about accelerations.
WARNING("GDI32: RtlMultiByteToUnicodeN error.");
LOCALFREE(pwc);
return(FALSE);
}
if( cjResult != 255 * sizeof(WCHAR) )
{
// There must be a DBCS code page so gpwcANSIMap takes on new meaning.
// It is used for fonts with ANSI,OEM, and SYMBOL charsets. Also,
// another table, gpwcDBCS is constructed that is used to map the SBCS
// of SHIFT-JIS fonts.
WARNING("GDI32:Assuming DBCS code page.\n");
st = MultiByteToWideChar
(
1252, // code page to use
0, // flags
&ch[1], // characters to translate
255, // number of multibyte characters
&pwc[1], // unicode values of characters
255 // number of wide characters
);
if( !NT_SUCCESS(st) )
{
// Clean up and forget about accelerations.
WARNING("GDI32: MultiByteToWideChar error.");
LOCALFREE(pwc);
return(FALSE);
}
// Okay now make a table for SBC bytes. Mark DBCS lead bytes
// with 0xFFFF.
for( jj = 0; jj < 256; jj++ )
{
if( IsDBCSLeadByte( (UCHAR)jj ))
{
pwcSBC[jj] = (WCHAR) 0xFFFF;
}
else
{
st = RtlMultiByteToUnicodeN
(
&pwcSBC[jj],
sizeof(WCHAR),
&cjResult,
&ch[jj],
1
);
if( !NT_SUCCESS(st) )
{
WARNING("GDI32: RtlMultByteToUnicodeN error.");
LOCALFREE(pwc);
return(FALSE);
}
}
}
}
// The table is good, jam it in. Watch out for another thread running this
// routine simultaneously.
ENTERCRITICALSECTION(&semLocal);
{
if (gpwcANSICharSet == (WCHAR *) NULL)
{
gpwcANSICharSet = pwc;
gpwcDBCSCharSet = pwcSBC;
pwc = (WCHAR *) NULL;
}
}
LEAVECRITICALSECTION(&semLocal);
// If we collided with another thread, clean up our extra space.
if (pwc != (WCHAR *) NULL)
LOCALFREE(pwc);
// At this point we have a valid mapping.
return(TRUE);
}
