[gvg] 19303: Wine-0_9_1 vendor import

Wine-0_9_1 vendor import
Added: trunk/reactos/lib/dplay/
Deleted: trunk/reactos/lib/dplay/Makefile.in
Added: trunk/reactos/lib/dplay/dplay.xml
Added: trunk/reactos/lib/dplayx/
Deleted: trunk/reactos/lib/dplayx/Makefile.in
Modified: trunk/reactos/lib/dplayx/dplay.c
Added: trunk/reactos/lib/dplayx/dplayx.xml
Modified: trunk/reactos/lib/dplayx/dplayx_global.c
Modified: trunk/reactos/lib/dplayx/name_server.c
  _____  

Copied: trunk/reactos/lib/dplay (from rev 19302,
vendor/wine/dlls/dplay/current)
  _____  

Deleted: trunk/reactos/lib/dplay/Makefile.in
--- vendor/wine/dlls/dplay/current/Makefile.in	2005-11-17 20:11:40 UTC
(rev 19302)
+++ trunk/reactos/lib/dplay/Makefile.in	2005-11-17 20:16:02 UTC (rev
19303)
@@ -1,15 +0,0 @@

-TOPSRCDIR = @top_srcdir@
-TOPOBJDIR = ../..
-SRCDIR    = @srcdir@
-VPATH     = @srcdir@
-MODULE    = dplay.dll
-IMPORTLIB = libdplay.$(IMPLIBEXT)
-IMPORTS   = dplayx kernel32
-
-C_SRCS = dplay_main.c
-
-RC_SRCS = version.rc
-
-@MAKE_DLL_RULES@
-
-### Dependencies:
  _____  

Added: trunk/reactos/lib/dplay/dplay.xml
--- vendor/wine/dlls/dplay/current/dplay.xml	2005-11-17 20:11:40 UTC
(rev 19302)
+++ trunk/reactos/lib/dplay/dplay.xml	2005-11-17 20:16:02 UTC (rev
19303)
@@ -0,0 +1,25 @@

+<module name="dplay" type="win32dll"
baseaddress="${BASEADDRESS_DPLAY}"
installbase="system32" installname="dplay.dll">
+	<importlibrary definition="dplay.spec.def" />
+	<include base="dinput8">.</include>
+	<include base="ReactOS">include/wine</include>
+	<define name="UNICODE" />
+	<define name="_UNICODE" />
+	<define name="__REACTOS__" />
+	<define name="__USE_W32API" />
+	<define name="_WIN32_IE">0x600</define>
+	<define name="_WIN32_WINNT">0x501</define>
+	<define name="WINVER">0x501</define>
+	<library>wine</library>
+	<library>uuid</library>
+	<library>ntdll</library>
+	<library>kernel32</library>
+	<library>user32</library>
+	<library>advapi32</library>
+	<library>ole32</library>
+	<library>winmm</library>
+	<library>dxguid</library>
+	<library>dinput</library>
+      <file>version.rc</file>
+	<file>dplay_main.c</file>
+	<file>dplay.spec</file>
+</module>
Property changes on: trunk/reactos/lib/dplay/dplay.xml
___________________________________________________________________
Name: svn:eol-style
   + native
  _____  

Copied: trunk/reactos/lib/dplayx (from rev 19302,
vendor/wine/dlls/dplayx/current)
  _____  

Deleted: trunk/reactos/lib/dplayx/Makefile.in
--- vendor/wine/dlls/dplayx/current/Makefile.in	2005-11-17 20:11:40 UTC
(rev 19302)
+++ trunk/reactos/lib/dplayx/Makefile.in	2005-11-17 20:16:02 UTC
(rev 19303)
@@ -1,27 +0,0 @@

-EXTRADEFS = -DCOM_NO_WINDOWS_H
-TOPSRCDIR = @top_srcdir@
-TOPOBJDIR = ../..
-SRCDIR    = @srcdir@
-VPATH     = @srcdir@
-MODULE    = dplayx.dll
-IMPORTLIB = libdplayx.$(IMPLIBEXT)
-IMPORTS   = winmm ole32 user32 advapi32 kernel32
-EXTRALIBS = -ldxguid -luuid
-
-C_SRCS = \
-	dpclassfactory.c \
-	dplay.c \
-	dplaysp.c \
-	dplayx_global.c \
-	dplayx_main.c \
-	dplayx_messages.c \
-	dplobby.c \
-	lobbysp.c \
-	name_server.c \
-	regsvr.c
-
-RC_SRCS = version.rc
-
-@MAKE_DLL_RULES@
-
-### Dependencies:
  _____  

Modified: trunk/reactos/lib/dplayx/dplay.c
--- vendor/wine/dlls/dplayx/current/dplay.c	2005-11-17 20:11:40 UTC
(rev 19302)
+++ trunk/reactos/lib/dplayx/dplay.c	2005-11-17 20:16:02 UTC (rev
19303)
@@ -1232,8 +1232,8 @@

 static void
 DP_DeleteDPNameStruct( LPDPNAME lpDPName )
 {
-  HeapFree( GetProcessHeap(), HEAP_ZERO_MEMORY,
lpDPName->u1.lpszShortNameA );
-  HeapFree( GetProcessHeap(), HEAP_ZERO_MEMORY,
lpDPName->u2.lpszLongNameA );
+  HeapFree( GetProcessHeap(), HEAP_ZERO_MEMORY,
lpDPName->lpszShortNameA );
+  HeapFree( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDPName->lpszLongNameA
);
 }
 
 /* This method assumes that all links to it are already deleted */
@@ -1296,40 +1296,40 @@
   }
 
   /* Delete any existing pointers */
-  HeapFree( GetProcessHeap(), 0, lpDst->u1.lpszShortNameA );
-  HeapFree( GetProcessHeap(), 0, lpDst->u2.lpszLongNameA );
+  HeapFree( GetProcessHeap(), 0, lpDst->lpszShortNameA );
+  HeapFree( GetProcessHeap(), 0, lpDst->lpszLongNameA );
 
   /* Copy as required */
   CopyMemory( lpDst, lpSrc, lpSrc->dwSize );
 
   if( bAnsi )
   {
-    if( lpSrc->u1.lpszShortNameA )
+    if( lpSrc->lpszShortNameA )
     {
-        lpDst->u1.lpszShortNameA = HeapAlloc( GetProcessHeap(), 0,
-
strlen(lpSrc->u1.lpszShortNameA)+1 );
-        strcpy( lpDst->u1.lpszShortNameA, lpSrc->u1.lpszShortNameA );
+        lpDst->lpszShortNameA = HeapAlloc( GetProcessHeap(), 0,
+
strlen(lpSrc->lpszShortNameA)+1 );
+        strcpy( lpDst->lpszShortNameA, lpSrc->lpszShortNameA );
     }
-    if( lpSrc->u2.lpszLongNameA )
+    if( lpSrc->lpszLongNameA )
     {
-        lpDst->u2.lpszLongNameA = HeapAlloc( GetProcessHeap(), 0,
-
strlen(lpSrc->u2.lpszLongNameA)+1 );
-        strcpy( lpDst->u2.lpszLongNameA, lpSrc->u2.lpszLongNameA );
+        lpDst->lpszLongNameA = HeapAlloc( GetProcessHeap(), 0,
+
strlen(lpSrc->lpszLongNameA)+1 );
+        strcpy( lpDst->lpszLongNameA, lpSrc->lpszLongNameA );
     }
   }
   else
   {
-    if( lpSrc->u1.lpszShortNameA )
+    if( lpSrc->lpszShortNameA )
     {
-        lpDst->u1.lpszShortName = HeapAlloc( GetProcessHeap(), 0,
-
(strlenW(lpSrc->u1.lpszShortName)+1)*sizeof(WCHAR) );
-        strcpyW( lpDst->u1.lpszShortName, lpSrc->u1.lpszShortName );
+        lpDst->lpszShortName = HeapAlloc( GetProcessHeap(), 0,
+
(strlenW(lpSrc->lpszShortName)+1)*sizeof(WCHAR) );
+        strcpyW( lpDst->lpszShortName, lpSrc->lpszShortName );
     }
-    if( lpSrc->u2.lpszLongNameA )
+    if( lpSrc->lpszLongNameA )
     {
-        lpDst->u2.lpszLongName = HeapAlloc( GetProcessHeap(), 0,
-
(strlenW(lpSrc->u2.lpszLongName)+1)*sizeof(WCHAR) );
-        strcpyW( lpDst->u2.lpszLongName, lpSrc->u2.lpszLongName );
+        lpDst->lpszLongName = HeapAlloc( GetProcessHeap(), 0,
+
(strlenW(lpSrc->lpszLongName)+1)*sizeof(WCHAR) );
+        strcpyW( lpDst->lpszLongName, lpSrc->lpszLongName );
     }
   }
 
@@ -2475,14 +2475,14 @@
 
   dwRequiredDataSize = lpGData->name.dwSize;
 
-  if( lpGData->name.u1.lpszShortNameA )
+  if( lpGData->name.lpszShortNameA )
   {
-    dwRequiredDataSize += strlen( lpGData->name.u1.lpszShortNameA ) +
1;
+    dwRequiredDataSize += strlen( lpGData->name.lpszShortNameA ) + 1;
   }
 
-  if( lpGData->name.u2.lpszLongNameA )
+  if( lpGData->name.lpszLongNameA )
   {
-    dwRequiredDataSize += strlen( lpGData->name.u2.lpszLongNameA ) + 1;
+    dwRequiredDataSize += strlen( lpGData->name.lpszLongNameA ) + 1;
   }
 
   if( ( lpData == NULL ) ||
@@ -2496,24 +2496,24 @@
   /* Copy the structure */
   CopyMemory( lpName, &lpGData->name, lpGData->name.dwSize );
 
-  if( lpGData->name.u1.lpszShortNameA )
+  if( lpGData->name.lpszShortNameA )
   {
     strcpy( ((char*)lpName)+lpGData->name.dwSize,
-            lpGData->name.u1.lpszShortNameA );
+            lpGData->name.lpszShortNameA );
   }
   else
   {
-    lpName->u1.lpszShortNameA = NULL;
+    lpName->lpszShortNameA = NULL;
   }
 
-  if( lpGData->name.u1.lpszShortNameA )
+  if( lpGData->name.lpszShortNameA )
   {
     strcpy( ((char*)lpName)+lpGData->name.dwSize,
-            lpGData->name.u2.lpszLongNameA );
+            lpGData->name.lpszLongNameA );
   }
   else
   {
-    lpName->u2.lpszLongNameA = NULL;
+    lpName->lpszLongNameA = NULL;
   }
 
   return DP_OK;
@@ -2674,14 +2674,14 @@
 
   dwRequiredDataSize = lpPList->lpPData->name.dwSize;
 
-  if( lpPList->lpPData->name.u1.lpszShortNameA )
+  if( lpPList->lpPData->name.lpszShortNameA )
   {
-    dwRequiredDataSize += strlen(
lpPList->lpPData->name.u1.lpszShortNameA ) + 1;
+    dwRequiredDataSize += strlen( lpPList->lpPData->name.lpszShortNameA
) + 1;
   }
 
-  if( lpPList->lpPData->name.u2.lpszLongNameA )
+  if( lpPList->lpPData->name.lpszLongNameA )
   {
-    dwRequiredDataSize += strlen(
lpPList->lpPData->name.u2.lpszLongNameA ) + 1;
+    dwRequiredDataSize += strlen( lpPList->lpPData->name.lpszLongNameA
) + 1;
   }
 
   if( ( lpData == NULL ) ||
@@ -2695,24 +2695,24 @@
   /* Copy the structure */
   CopyMemory( lpName, &lpPList->lpPData->name,
lpPList->lpPData->name.dwSize );
 
-  if( lpPList->lpPData->name.u1.lpszShortNameA )
+  if( lpPList->lpPData->name.lpszShortNameA )
   {
     strcpy( ((char*)lpName)+lpPList->lpPData->name.dwSize,
-            lpPList->lpPData->name.u1.lpszShortNameA );
+            lpPList->lpPData->name.lpszShortNameA );
   }
   else
   {
-    lpName->u1.lpszShortNameA = NULL;
+    lpName->lpszShortNameA = NULL;
   }
 
-  if( lpPList->lpPData->name.u1.lpszShortNameA )
+  if( lpPList->lpPData->name.lpszShortNameA )
   {
     strcpy( ((char*)lpName)+lpPList->lpPData->name.dwSize,
-            lpPList->lpPData->name.u2.lpszLongNameA );
+            lpPList->lpPData->name.lpszLongNameA );
   }
   else
   {
-    lpName->u2.lpszLongNameA = NULL;
+    lpName->lpszLongNameA = NULL;
   }
 
   return DP_OK;
@@ -3290,28 +3290,28 @@
 
   if( bAnsi )
   {
-    if( lpSessDesc->u1.lpszSessionNameA )
+    if( lpSessDesc->lpszSessionNameA )
     {
-      dwSize += lstrlenA( lpSessDesc->u1.lpszSessionNameA ) + 1;
+      dwSize += lstrlenA( lpSessDesc->lpszSessionNameA ) + 1;
     }
 
-    if( lpSessDesc->u2.lpszPasswordA )
+    if( lpSessDesc->lpszPasswordA )
     {
-      dwSize += lstrlenA( lpSessDesc->u2.lpszPasswordA ) + 1;
+      dwSize += lstrlenA( lpSessDesc->lpszPasswordA ) + 1;
     }
   }
   else /* UNICODE */
   {
-    if( lpSessDesc->u1.lpszSessionName )
+    if( lpSessDesc->lpszSessionName )
     {
       dwSize += sizeof( WCHAR ) *
-        ( lstrlenW( lpSessDesc->u1.lpszSessionName ) + 1 );
+        ( lstrlenW( lpSessDesc->lpszSessionName ) + 1 );
     }
 
-    if( lpSessDesc->u2.lpszPassword )
+    if( lpSessDesc->lpszPassword )
     {
       dwSize += sizeof( WCHAR ) *
-        ( lstrlenW( lpSessDesc->u2.lpszPassword ) + 1 );
+        ( lstrlenW( lpSessDesc->lpszPassword ) + 1 );
     }
   }
 
@@ -3336,42 +3336,42 @@
 
   if( bAnsi )
   {
-    if( lpSessionSrc->u1.lpszSessionNameA )
+    if( lpSessionSrc->lpszSessionNameA )
     {
       lstrcpyA( (LPSTR)lpStartOfFreeSpace,
-                lpSessionDest->u1.lpszSessionNameA );
-      lpSessionDest->u1.lpszSessionNameA = (LPSTR)lpStartOfFreeSpace;
+                lpSessionDest->lpszSessionNameA );
+      lpSessionDest->lpszSessionNameA = (LPSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace +=
-        lstrlenA( (LPSTR)lpSessionDest->u1.lpszSessionNameA ) + 1;
+        lstrlenA( (LPSTR)lpSessionDest->lpszSessionNameA ) + 1;
     }
 
-    if( lpSessionSrc->u2.lpszPasswordA )
+    if( lpSessionSrc->lpszPasswordA )
     {
       lstrcpyA( (LPSTR)lpStartOfFreeSpace,
-                lpSessionDest->u2.lpszPasswordA );
-      lpSessionDest->u2.lpszPasswordA = (LPSTR)lpStartOfFreeSpace;
+                lpSessionDest->lpszPasswordA );
+      lpSessionDest->lpszPasswordA = (LPSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace +=
-        lstrlenA( (LPSTR)lpSessionDest->u2.lpszPasswordA ) + 1;
+        lstrlenA( (LPSTR)lpSessionDest->lpszPasswordA ) + 1;
     }
   }
   else /* UNICODE */
   {
-    if( lpSessionSrc->u1.lpszSessionName )
+    if( lpSessionSrc->lpszSessionName )
     {
       lstrcpyW( (LPWSTR)lpStartOfFreeSpace,
-                lpSessionDest->u1.lpszSessionName );
-      lpSessionDest->u1.lpszSessionName = (LPWSTR)lpStartOfFreeSpace;
+                lpSessionDest->lpszSessionName );
+      lpSessionDest->lpszSessionName = (LPWSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace += sizeof(WCHAR) *
-        ( lstrlenW( (LPWSTR)lpSessionDest->u1.lpszSessionName ) + 1 );
+        ( lstrlenW( (LPWSTR)lpSessionDest->lpszSessionName ) + 1 );
     }
 
-    if( lpSessionSrc->u2.lpszPassword )
+    if( lpSessionSrc->lpszPassword )
     {
       lstrcpyW( (LPWSTR)lpStartOfFreeSpace,
-                lpSessionDest->u2.lpszPassword );
-      lpSessionDest->u2.lpszPassword = (LPWSTR)lpStartOfFreeSpace;
+                lpSessionDest->lpszPassword );
+      lpSessionDest->lpszPassword = (LPWSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace += sizeof(WCHAR) *
-        ( lstrlenW( (LPWSTR)lpSessionDest->u2.lpszPassword ) + 1 );
+        ( lstrlenW( (LPWSTR)lpSessionDest->lpszPassword ) + 1 );
     }
   }
 }
@@ -3722,8 +3722,8 @@
       /* Fill in the DPNAME struct for the service provider */
       dpName.dwSize             = sizeof( dpName );
       dpName.dwFlags            = 0;
-      dpName.u1.lpszShortNameA = subKeyName;
-      dpName.u2.lpszLongNameA  = NULL;
+      dpName.lpszShortNameA = subKeyName;
+      dpName.lpszLongNameA  = NULL;
 
       /* Create the compound address for the service provider.
        * NOTE: This is a gruesome architectural scar right now.  DP
@@ -3817,8 +3817,8 @@
       /* Fill in the DPNAME struct for the service provider */
       dpName.dwSize             = sizeof( dpName );
       dpName.dwFlags            = 0;
-      dpName.u1.lpszShortNameA = subKeyName;
-      dpName.u2.lpszLongNameA  = NULL;
+      dpName.lpszShortNameA = subKeyName;
+      dpName.lpszLongNameA  = NULL;
 
       /* Create the compound address for the service provider.
          NOTE: This is a gruesome architectural scar right now. DP uses
DPL and DPL uses DP
  _____  

Added: trunk/reactos/lib/dplayx/dplayx.xml
--- vendor/wine/dlls/dplayx/current/dplayx.xml	2005-11-17 20:11:40 UTC
(rev 19302)
+++ trunk/reactos/lib/dplayx/dplayx.xml	2005-11-17 20:16:02 UTC (rev
19303)
@@ -0,0 +1,33 @@

+<module name="dplayx" type="win32dll"
baseaddress="${BASEADDRESS_DPLAYX}" installbase="system32"
installname="dplayx.dll" allowwarnings ="true">
+	<importlibrary definition="dplayx.spec.def" />
+	<include base="dplayx">.</include>
+	<include base="ReactOS">include/wine</include>
+	<define name="UNICODE" />
+	<define name="_UNICODE" />
+	<define name="__REACTOS__" />
+	<define name="__USE_W32API" />
+	<define name="_WIN32_IE">0x600</define>
+	<define name="_WIN32_WINNT">0x501</define>
+	<define name="WINVER">0x501</define>
+	<library>wine</library>
+	<library>uuid</library>
+	<library>ntdll</library>
+	<library>kernel32</library>
+	<library>user32</library>
+	<library>advapi32</library>
+	<library>ole32</library>
+	<library>winmm</library>
+	<library>dxguid</library>
+      <file>version.rc</file>
+	<file>dpclassfactory.c</file>
+	<file>dplay.c</file>
+	<file>dplaysp.c</file>
+	<file>dplayx_global.c</file>
+	<file>dplayx_main.c</file>
+	<file>dplayx_messages.c</file>
+	<file>dplobby.c</file>
+	<file>lobbysp.c</file>
+	<file>name_server.c</file>
+	<file>regsvr.c</file>
+	<file>dplayx.spec</file>	
+</module>
Property changes on: trunk/reactos/lib/dplayx/dplayx.xml
___________________________________________________________________
Name: svn:eol-style
   + native
  _____  

Modified: trunk/reactos/lib/dplayx/dplayx_global.c
--- vendor/wine/dlls/dplayx/current/dplayx_global.c	2005-11-17
20:11:40 UTC (rev 19302)
+++ trunk/reactos/lib/dplayx/dplayx_global.c	2005-11-17 20:16:02 UTC
(rev 19303)
@@ -671,20 +671,20 @@

     CopyMemory( dest->lpSessionDesc, src->lpSessionDesc, sizeof(
DPSESSIONDESC2 ) );
 
     /* Session names may or may not exist */
-    if( src->lpSessionDesc->u1.lpszSessionNameA )
+    if( src->lpSessionDesc->lpszSessionNameA )
     {
-      strcpy( (LPSTR)lpStartOfFreeSpace,
src->lpSessionDesc->u1.lpszSessionNameA );
-      dest->lpSessionDesc->u1.lpszSessionNameA =
(LPSTR)lpStartOfFreeSpace;
+      strcpy( (LPSTR)lpStartOfFreeSpace,
src->lpSessionDesc->lpszSessionNameA );
+      dest->lpSessionDesc->lpszSessionNameA =
(LPSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace +=
-        strlen( (LPSTR)dest->lpSessionDesc->u1.lpszSessionNameA ) + 1;
+        strlen( (LPSTR)dest->lpSessionDesc->lpszSessionNameA ) + 1;
     }
 
-    if( src->lpSessionDesc->u2.lpszPasswordA )
+    if( src->lpSessionDesc->lpszPasswordA )
     {
-      strcpy( (LPSTR)lpStartOfFreeSpace,
src->lpSessionDesc->u2.lpszPasswordA );
-      dest->lpSessionDesc->u2.lpszPasswordA =
(LPSTR)lpStartOfFreeSpace;
+      strcpy( (LPSTR)lpStartOfFreeSpace,
src->lpSessionDesc->lpszPasswordA );
+      dest->lpSessionDesc->lpszPasswordA = (LPSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace +=
-        strlen( (LPSTR)dest->lpSessionDesc->u2.lpszPasswordA ) + 1;
+        strlen( (LPSTR)dest->lpSessionDesc->lpszPasswordA ) + 1;
     }
   }
 
@@ -695,20 +695,20 @@
     lpStartOfFreeSpace += sizeof( DPNAME );
     CopyMemory( dest->lpPlayerName, src->lpPlayerName, sizeof( DPNAME )
);
 
-    if( src->lpPlayerName->u1.lpszShortNameA )
+    if( src->lpPlayerName->lpszShortNameA )
     {
-      strcpy( (LPSTR)lpStartOfFreeSpace,
src->lpPlayerName->u1.lpszShortNameA );
-      dest->lpPlayerName->u1.lpszShortNameA =
(LPSTR)lpStartOfFreeSpace;
+      strcpy( (LPSTR)lpStartOfFreeSpace,
src->lpPlayerName->lpszShortNameA );
+      dest->lpPlayerName->lpszShortNameA = (LPSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace +=
-        strlen( (LPSTR)dest->lpPlayerName->u1.lpszShortNameA ) + 1;
+        strlen( (LPSTR)dest->lpPlayerName->lpszShortNameA ) + 1;
     }
 
-    if( src->lpPlayerName->u2.lpszLongNameA )
+    if( src->lpPlayerName->lpszLongNameA )
     {
-      strcpy( (LPSTR)lpStartOfFreeSpace,
src->lpPlayerName->u2.lpszLongNameA );
-      dest->lpPlayerName->u2.lpszLongNameA = (LPSTR)lpStartOfFreeSpace;
+      strcpy( (LPSTR)lpStartOfFreeSpace,
src->lpPlayerName->lpszLongNameA );
+      dest->lpPlayerName->lpszLongNameA = (LPSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace +=
-        strlen( (LPSTR)dest->lpPlayerName->u2.lpszLongName ) + 1 ;
+        strlen( (LPSTR)dest->lpPlayerName->lpszLongName ) + 1 ;
     }
 
   }
@@ -793,20 +793,20 @@
     CopyMemory( dest->lpSessionDesc, src->lpSessionDesc, sizeof(
DPSESSIONDESC2 ) );
 
     /* Session names may or may not exist */
-    if( src->lpSessionDesc->u1.lpszSessionName )
+    if( src->lpSessionDesc->lpszSessionName )
     {
-      strcpyW( (LPWSTR)lpStartOfFreeSpace,
dest->lpSessionDesc->u1.lpszSessionName );
-      src->lpSessionDesc->u1.lpszSessionName =
(LPWSTR)lpStartOfFreeSpace;
+      strcpyW( (LPWSTR)lpStartOfFreeSpace,
dest->lpSessionDesc->lpszSessionName );
+      src->lpSessionDesc->lpszSessionName = (LPWSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace +=  sizeof(WCHAR) *
-        ( strlenW( (LPWSTR)dest->lpSessionDesc->u1.lpszSessionName ) +
1 );
+        ( strlenW( (LPWSTR)dest->lpSessionDesc->lpszSessionName ) + 1
);
     }
 
-    if( src->lpSessionDesc->u2.lpszPassword )
+    if( src->lpSessionDesc->lpszPassword )
     {
-      strcpyW( (LPWSTR)lpStartOfFreeSpace,
src->lpSessionDesc->u2.lpszPassword );
-      dest->lpSessionDesc->u2.lpszPassword =
(LPWSTR)lpStartOfFreeSpace;
+      strcpyW( (LPWSTR)lpStartOfFreeSpace,
src->lpSessionDesc->lpszPassword );
+      dest->lpSessionDesc->lpszPassword = (LPWSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace +=  sizeof(WCHAR) *
-        ( strlenW( (LPWSTR)dest->lpSessionDesc->u2.lpszPassword ) + 1
);
+        ( strlenW( (LPWSTR)dest->lpSessionDesc->lpszPassword ) + 1 );
     }
   }
 
@@ -817,20 +817,20 @@
     lpStartOfFreeSpace += sizeof( DPNAME );
     CopyMemory( dest->lpPlayerName, src->lpPlayerName, sizeof( DPNAME )
);
 
-    if( src->lpPlayerName->u1.lpszShortName )
+    if( src->lpPlayerName->lpszShortName )
     {
-      strcpyW( (LPWSTR)lpStartOfFreeSpace,
src->lpPlayerName->u1.lpszShortName );
-      dest->lpPlayerName->u1.lpszShortName =
(LPWSTR)lpStartOfFreeSpace;
+      strcpyW( (LPWSTR)lpStartOfFreeSpace,
src->lpPlayerName->lpszShortName );
+      dest->lpPlayerName->lpszShortName = (LPWSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace +=  sizeof(WCHAR) *
-        ( strlenW( (LPWSTR)dest->lpPlayerName->u1.lpszShortName ) + 1
);
+        ( strlenW( (LPWSTR)dest->lpPlayerName->lpszShortName ) + 1 );
     }
 
-    if( src->lpPlayerName->u2.lpszLongName )
+    if( src->lpPlayerName->lpszLongName )
     {
-      strcpyW( (LPWSTR)lpStartOfFreeSpace,
src->lpPlayerName->u2.lpszLongName );
-      dest->lpPlayerName->u2.lpszLongName = (LPWSTR)lpStartOfFreeSpace;
+      strcpyW( (LPWSTR)lpStartOfFreeSpace,
src->lpPlayerName->lpszLongName );
+      dest->lpPlayerName->lpszLongName = (LPWSTR)lpStartOfFreeSpace;
       lpStartOfFreeSpace +=  sizeof(WCHAR) *
-        ( strlenW( (LPWSTR)dest->lpPlayerName->u2.lpszLongName ) + 1 );
+        ( strlenW( (LPWSTR)dest->lpPlayerName->lpszLongName ) + 1 );
     }
 
   }
@@ -976,14 +976,14 @@
   {
     dwTotalSize += sizeof( DPSESSIONDESC2 );
 
-    if( lpConn->lpSessionDesc->u1.lpszSessionNameA )
+    if( lpConn->lpSessionDesc->lpszSessionNameA )
     {
-      dwTotalSize += strlen( lpConn->lpSessionDesc->u1.lpszSessionNameA
) + 1;
+      dwTotalSize += strlen( lpConn->lpSessionDesc->lpszSessionNameA )
+ 1;
     }
 
-    if( lpConn->lpSessionDesc->u2.lpszPasswordA )
+    if( lpConn->lpSessionDesc->lpszPasswordA )
     {
-      dwTotalSize += strlen( lpConn->lpSessionDesc->u2.lpszPasswordA )
+ 1;
+      dwTotalSize += strlen( lpConn->lpSessionDesc->lpszPasswordA ) +
1;
     }
   }
 
@@ -991,14 +991,14 @@
   {
     dwTotalSize += sizeof( DPNAME );
 
-    if( lpConn->lpPlayerName->u1.lpszShortNameA )
+    if( lpConn->lpPlayerName->lpszShortNameA )
     {
-      dwTotalSize += strlen( lpConn->lpPlayerName->u1.lpszShortNameA )
+ 1;
+      dwTotalSize += strlen( lpConn->lpPlayerName->lpszShortNameA ) +
1;
     }
 
-    if( lpConn->lpPlayerName->u2.lpszLongNameA )
+    if( lpConn->lpPlayerName->lpszLongNameA )
     {
-      dwTotalSize += strlen( lpConn->lpPlayerName->u2.lpszLongNameA ) +
1;
+      dwTotalSize += strlen( lpConn->lpPlayerName->lpszLongNameA ) + 1;
     }
 
   }
@@ -1023,16 +1023,16 @@
   {
     dwTotalSize += sizeof( DPSESSIONDESC2 );
 
-    if( lpConn->lpSessionDesc->u1.lpszSessionName )
+    if( lpConn->lpSessionDesc->lpszSessionName )
     {
       dwTotalSize += sizeof( WCHAR ) *
-        ( strlenW( lpConn->lpSessionDesc->u1.lpszSessionName ) + 1 );
+        ( strlenW( lpConn->lpSessionDesc->lpszSessionName ) + 1 );
     }
 
-    if( lpConn->lpSessionDesc->u2.lpszPassword )
+    if( lpConn->lpSessionDesc->lpszPassword )
     {
       dwTotalSize += sizeof( WCHAR ) *
-        ( strlenW( lpConn->lpSessionDesc->u2.lpszPassword ) + 1 );
+        ( strlenW( lpConn->lpSessionDesc->lpszPassword ) + 1 );
     }
   }
 
@@ -1040,16 +1040,16 @@
   {
     dwTotalSize += sizeof( DPNAME );
 
-    if( lpConn->lpPlayerName->u1.lpszShortName )
+    if( lpConn->lpPlayerName->lpszShortName )
     {
       dwTotalSize += sizeof( WCHAR ) *
-        ( strlenW( lpConn->lpPlayerName->u1.lpszShortName ) + 1 );
+        ( strlenW( lpConn->lpPlayerName->lpszShortName ) + 1 );
     }
 
-    if( lpConn->lpPlayerName->u2.lpszLongName )
+    if( lpConn->lpPlayerName->lpszLongName )
     {
       dwTotalSize += sizeof( WCHAR ) *
-        ( strlenW( lpConn->lpPlayerName->u2.lpszLongName ) + 1 );
+        ( strlenW( lpConn->lpPlayerName->lpszLongName ) + 1 );
     }
 
   }
@@ -1076,17 +1076,17 @@
 {
   CopyMemory( lpSessionDest, lpSessionSrc, sizeof( *lpSessionSrc ) );
 
-  if( lpSessionSrc->u1.lpszSessionNameA )
+  if( lpSessionSrc->lpszSessionNameA )
   {
-      if ((lpSessionDest->u1.lpszSessionNameA = HeapAlloc(
GetProcessHeap(), 0,
-
strlen(lpSessionSrc->u1.lpszSessionNameA)+1 )))
-          strcpy( lpSessionDest->u1.lpszSessionNameA,
lpSessionSrc->u1.lpszSessionNameA );
+      if ((lpSessionDest->lpszSessionNameA = HeapAlloc(
GetProcessHeap(), 0,
+
strlen(lpSessionSrc->lpszSessionNameA)+1 )))
+          strcpy( lpSessionDest->lpszSessionNameA,
lpSessionSrc->lpszSessionNameA );
   }
-  if( lpSessionSrc->u2.lpszPasswordA )
+  if( lpSessionSrc->lpszPasswordA )
   {
-      if ((lpSessionDest->u2.lpszPasswordA = HeapAlloc(
GetProcessHeap(), 0,
-
strlen(lpSessionSrc->u2.lpszPasswordA)+1 )))
-          strcpy( lpSessionDest->u2.lpszPasswordA,
lpSessionSrc->u2.lpszPasswordA );
+      if ((lpSessionDest->lpszPasswordA = HeapAlloc( GetProcessHeap(),
0,
+
strlen(lpSessionSrc->lpszPasswordA)+1 )))
+          strcpy( lpSessionDest->lpszPasswordA,
lpSessionSrc->lpszPasswordA );
   }
 
   return TRUE;
  _____  

Modified: trunk/reactos/lib/dplayx/name_server.c
--- vendor/wine/dlls/dplayx/current/name_server.c	2005-11-17
20:11:40 UTC (rev 19302)
+++ trunk/reactos/lib/dplayx/name_server.c	2005-11-17 20:16:02 UTC
(rev 19303)
@@ -142,10 +142,10 @@

 
   CopyMemory( lpCacheNode->data, &lpMsg->sd, sizeof( *lpCacheNode->data
) );
   len = WideCharToMultiByte( CP_ACP, 0, (LPWSTR)(lpMsg+1), -1, NULL, 0,
NULL, NULL );
-  if ((lpCacheNode->data->u1.lpszSessionNameA = HeapAlloc(
GetProcessHeap(), 0, len )))
+  if ((lpCacheNode->data->lpszSessionNameA = HeapAlloc(
GetProcessHeap(), 0, len )))
   {
       WideCharToMultiByte( CP_ACP, 0, (LPWSTR)(lpMsg+1), -1,
-                           lpCacheNode->data->u1.lpszSessionNameA, len,
NULL, NULL );
+                           lpCacheNode->data->lpszSessionNameA, len,
NULL, NULL );
   }
 
   lpCacheNode->dwTime = timeGetTime();
@@ -388,12 +388,12 @@
   if (bAnsi)
   {
       dwVariableLen = MultiByteToWideChar( CP_ACP, 0,
-
lpDP->dp2->lpSessionDesc->u1.lpszSessionNameA,
+
lpDP->dp2->lpSessionDesc->lpszSessionNameA,
                                            -1, NULL, 0 );
   }
   else
   {
-      dwVariableLen = strlenW(
lpDP->dp2->lpSessionDesc->u1.lpszSessionName ) + 1;
+      dwVariableLen = strlenW(
lpDP->dp2->lpSessionDesc->lpszSessionName ) + 1;
   }
 
   dwVariableSize = dwVariableLen * sizeof( WCHAR );
@@ -415,11 +415,11 @@
   rmsg->dwUnknown = 0x0000005c;
   if( bAnsi )
   {
-      MultiByteToWideChar( CP_ACP, 0,
lpDP->dp2->lpSessionDesc->u1.lpszSessionNameA, -1,
+      MultiByteToWideChar( CP_ACP, 0,
lpDP->dp2->lpSessionDesc->lpszSessionNameA, -1,
                            (LPWSTR)(rmsg+1), dwVariableLen );
   }
   else
   {
-      strcpyW( (LPWSTR)(rmsg+1),
lpDP->dp2->lpSessionDesc->u1.lpszSessionName );
+      strcpyW( (LPWSTR)(rmsg+1),
lpDP->dp2->lpSessionDesc->lpszSessionName );
   }
 }