update submodules

CW-Bug-Id: #20733

.gitmodules

@@ -3,7 +3,7 @@
 	url = ../wine
 [submodule "dxvk"]
 	path = dxvk
-	url = https://github.com/doitsujin/dxvk.git
+	url = ../dxvk
 [submodule "openvr"]
 	path = openvr
 	url = https://github.com/ValveSoftware/openvr

Makefile

@@ -129,6 +129,7 @@ proton: downloads
 	echo "Proton built locally. Use 'install', 'deploy' or 'redist' targets."
 
 install: downloads
+	rm -rf $(STEAM_DIR)/compatibilitytools.d/$(_build_name)/files/ #remove proton's internal files, but preserve user_settings etc from top-level
 	$(MAKE) $(MFLAGS) $(MAKEOVERRIDES) -C $(BUILD_DIR)/ $(UNSTRIPPED) install
 	echo "Proton installed to your local Steam installation"
 
@@ -167,8 +168,8 @@ dxvk: | $(BUILD_ROOT)/dxvk/lib/wine/dxvk
 dxvk: | $(BUILD_ROOT)/dxvk/lib64/wine/dxvk
 dxvk: downloads
 	$(MAKE) $(MFLAGS) $(MAKEOVERRIDES) -C $(BUILD_DIR)/ $(UNSTRIPPED) dxvk && \
-	cp -f $(BUILD_DIR)/dist/dist/lib/wine/dxvk/*.dll $(BUILD_ROOT)/dxvk/lib/wine/dxvk/ && \
+	cp -f $(BUILD_DIR)/dist/files/lib/wine/dxvk/*.dll $(BUILD_ROOT)/dxvk/lib/wine/dxvk/ && \
-	cp -f $(BUILD_DIR)/dist/dist/lib64/wine/dxvk/*.dll $(BUILD_ROOT)/dxvk/lib64/wine/dxvk/
+	cp -f $(BUILD_DIR)/dist/files/lib64/wine/dxvk/*.dll $(BUILD_ROOT)/dxvk/lib64/wine/dxvk/
 
 dxvk-nvapi: | $(BUILD_ROOT)/dxvk-nvapi/lib/wine/nvapi
 dxvk-nvapi: | $(BUILD_ROOT)/dxvk-nvapi/lib64/wine/nvapi
@@ -181,8 +182,8 @@ vkd3d-proton: | $(BUILD_ROOT)/vkd3d-proton/lib/wine/vkd3d-proton
 vkd3d-proton: | $(BUILD_ROOT)/vkd3d-proton/lib64/wine/vkd3d-proton
 vkd3d-proton: downloads
 	$(MAKE) $(MFLAGS) $(MAKEOVERRIDES) -C $(BUILD_DIR)/ $(UNSTRIPPED) vkd3d-proton && \
-	cp -f $(BUILD_DIR)/dist/dist/lib/wine/vkd3d-proton/*.dll $(BUILD_ROOT)/vkd3d-proton/lib/wine/vkd3d-proton/ && \
+	cp -f $(BUILD_DIR)/dist/files/lib/wine/vkd3d-proton/*.dll $(BUILD_ROOT)/vkd3d-proton/lib/wine/vkd3d-proton/ && \
-	cp -f $(BUILD_DIR)/dist/dist/lib64/wine/vkd3d-proton/*.dll $(BUILD_ROOT)/vkd3d-proton/lib64/wine/vkd3d-proton/
+	cp -f $(BUILD_DIR)/dist/files/lib64/wine/vkd3d-proton/*.dll $(BUILD_ROOT)/vkd3d-proton/lib64/wine/vkd3d-proton/
 
 lsteamclient: | $(BUILD_ROOT)/lsteamclient/lib/wine/i386-windows
 lsteamclient: | $(BUILD_ROOT)/lsteamclient/lib/wine/i386-unix
@@ -190,10 +191,10 @@ lsteamclient: | $(BUILD_ROOT)/lsteamclient/lib64/wine/x86_64-windows
 lsteamclient: | $(BUILD_ROOT)/lsteamclient/lib64/wine/x86_64-unix
 lsteamclient: downloads
 	$(MAKE) $(MFLAGS) $(MAKEOVERRIDES) -C $(BUILD_DIR)/ $(UNSTRIPPED) lsteamclient && \
-	cp -f $(BUILD_DIR)/dist/dist/lib/wine/i386-windows/lsteamclient.dll $(BUILD_ROOT)/lsteamclient/lib/wine/i386-windows/ && \
+	cp -f $(BUILD_DIR)/dist/files/lib/wine/i386-windows/lsteamclient.dll $(BUILD_ROOT)/lsteamclient/lib/wine/i386-windows/ && \
-	cp -f $(BUILD_DIR)/dist/dist/lib/wine/i386-unix/lsteamclient.dll.so $(BUILD_ROOT)/lsteamclient/lib/wine/i386-unix/ && \
+	cp -f $(BUILD_DIR)/dist/files/lib/wine/i386-unix/lsteamclient.dll.so $(BUILD_ROOT)/lsteamclient/lib/wine/i386-unix/ && \
-	cp -f $(BUILD_DIR)/dist/dist/lib64/wine/x86_64-windows/lsteamclient.dll $(BUILD_ROOT)/lsteamclient/lib64/wine/x86_64-windows/ && \
+	cp -f $(BUILD_DIR)/dist/files/lib64/wine/x86_64-windows/lsteamclient.dll $(BUILD_ROOT)/lsteamclient/lib64/wine/x86_64-windows/ && \
-	cp -f $(BUILD_DIR)/dist/dist/lib64/wine/x86_64-unix/lsteamclient.dll.so $(BUILD_ROOT)/lsteamclient/lib64/wine/x86_64-unix/
+	cp -f $(BUILD_DIR)/dist/files/lib64/wine/x86_64-unix/lsteamclient.dll.so $(BUILD_ROOT)/lsteamclient/lib64/wine/x86_64-unix/
 
 vrclient: | $(BUILD_ROOT)/vrclient/lib/wine/i386-windows
 vrclient: | $(BUILD_ROOT)/vrclient/lib/wine/i386-unix
@@ -201,17 +202,17 @@ vrclient: | $(BUILD_ROOT)/vrclient/lib64/wine/x86_64-windows
 vrclient: | $(BUILD_ROOT)/vrclient/lib64/wine/x86_64-unix
 vrclient: downloads
 	$(MAKE) $(MFLAGS) $(MAKEOVERRIDES) -C $(BUILD_DIR)/ $(UNSTRIPPED) vrclient && \
-	cp -f $(BUILD_DIR)/dist/dist/lib/wine/i386-windows/vrclient.dll $(BUILD_ROOT)/vrclient/lib/wine/i386-windows/ && \
+	cp -f $(BUILD_DIR)/dist/files/lib/wine/i386-windows/vrclient.dll $(BUILD_ROOT)/vrclient/lib/wine/i386-windows/ && \
-	cp -f $(BUILD_DIR)/dist/dist/lib/wine/i386-unix/vrclient.dll.so $(BUILD_ROOT)/vrclient/lib/wine/i386-unix/ && \
+	cp -f $(BUILD_DIR)/dist/files/lib/wine/i386-unix/vrclient.dll.so $(BUILD_ROOT)/vrclient/lib/wine/i386-unix/ && \
-	cp -f $(BUILD_DIR)/dist/dist/lib64/wine/x86_64-windows/vrclient_x64.dll $(BUILD_ROOT)/vrclient/lib64/wine/x86_64-windows/ && \
+	cp -f $(BUILD_DIR)/dist/files/lib64/wine/x86_64-windows/vrclient_x64.dll $(BUILD_ROOT)/vrclient/lib64/wine/x86_64-windows/ && \
-	cp -f $(BUILD_DIR)/dist/dist/lib64/wine/x86_64-unix/vrclient_x64.dll.so $(BUILD_ROOT)/vrclient/lib64/wine/x86_64-unix/
+	cp -f $(BUILD_DIR)/dist/files/lib64/wine/x86_64-unix/vrclient_x64.dll.so $(BUILD_ROOT)/vrclient/lib64/wine/x86_64-unix/
 
 wineopenxr: | $(BUILD_ROOT)/wineopenxr/lib64/wine/x86_64-windows
 wineopenxr: | $(BUILD_ROOT)/wineopenxr/lib64/wine/x86_64-unix
 wineopenxr: downloads
 	$(MAKE) $(MFLAGS) $(MAKEOVERRIDES) -C $(BUILD_DIR)/ $(UNSTRIPPED) wineopenxr && \
-	cp -f $(BUILD_DIR)/dist/dist/lib64/wine/x86_64-windows/wineopenxr.dll $(BUILD_ROOT)/wineopenxr/lib64/wine/x86_64-windows/ && \
+	cp -f $(BUILD_DIR)/dist/files/lib64/wine/x86_64-windows/wineopenxr.dll $(BUILD_ROOT)/wineopenxr/lib64/wine/x86_64-windows/ && \
-	cp -f $(BUILD_DIR)/dist/dist/lib64/wine/x86_64-unix/wineopenxr.dll.so $(BUILD_ROOT)/wineopenxr/lib64/wine/x86_64-unix/
+	cp -f $(BUILD_DIR)/dist/files/lib64/wine/x86_64-unix/wineopenxr.dll.so $(BUILD_ROOT)/wineopenxr/lib64/wine/x86_64-unix/
 
 battleye: | $(BUILD_ROOT)/battleye/v1/lib/wine/i386-windows
 battleye: | $(BUILD_ROOT)/battleye/v1/lib/wine/i386-unix

Makefile.in

@@ -147,7 +147,7 @@ endif
 ##
 
 DST_BASE := $(OBJ)/dist
-DST_DIR := $(DST_BASE)/dist
+DST_DIR := $(DST_BASE)/files
 DST_LIBDIR32 := $(DST_DIR)/lib
 DST_LIBDIR64 := $(DST_DIR)/lib64
 DEPLOY_DIR := ./deploy
@@ -190,6 +190,7 @@ COMPAT_MANIFEST_TEMPLATE := $(SRCDIR)/compatibilitytool.vdf.template
 LICENSE := $(SRCDIR)/dist.LICENSE
 OFL_LICENSE := $(SRCDIR)/fonts/liberation-fonts/LICENSE
 AV1_PATENTS := $(SRCDIR)/dav1d/doc/PATENTS
+STEAMPIPE_FIXUPS_PY := $(SRCDIR)/steampipe_fixups.py
 
 GECKO_VER := 2.47.2
 GECKO32_TARBALL := wine-gecko-$(GECKO_VER)-x86.tar.xz
@@ -278,9 +279,10 @@ DIST_TARGETS := $(DIST_COPY_TARGETS) $(DIST_OVR32) $(DIST_OVR64) \
                 $(DIST_COMPAT_MANIFEST) $(DIST_LICENSE) $(DIST_TOOLMANIFEST) \
                 $(DIST_OFL_LICENSE) $(DIST_AV1_PATENTS) $(DIST_FONTS)
 
-DEPLOY_COPY_TARGETS := $(DIST_COPY_TARGETS) $(DIST_VERSION) $(DIST_LICENSE) \
+BASE_COPY_TARGETS := $(DIST_COPY_TARGETS) $(DIST_VERSION) $(DIST_LICENSE) \
-                       $(DIST_TOOLMANIFEST) $(DIST_OFL_LICENSE) $(DIST_AV1_PATENTS)
+                     $(DIST_TOOLMANIFEST) $(DIST_OFL_LICENSE) $(DIST_AV1_PATENTS) $(DST_DIR)
-REDIST_COPY_TARGETS := $(DEPLOY_COPY_TARGETS) $(DIST_COMPAT_MANIFEST)
+DEPLOY_COPY_TARGETS := $(BASE_COPY_TARGETS) $(STEAMPIPE_FIXUPS_PY)
+REDIST_COPY_TARGETS := $(BASE_COPY_TARGETS) $(DIST_COMPAT_MANIFEST)
 
 $(DIST_LICENSE): $(LICENSE)
 	cp -a $< $@
@@ -375,24 +377,21 @@ dist: $(DIST_TARGETS) all-dist dist_wineopenxr | $(DST_DIR)
 	echo `date '+%s'` `GIT_DIR=$(abspath $(SRCDIR)/.git) git describe --tags` > $(DIST_VERSION)
 
 deploy: dist | $(filter-out dist deploy install redist,$(MAKECMDGOALS))
-	mkdir -p $(DEPLOY_DIR) && \
+	mkdir -p $(DEPLOY_DIR)
-	cp -a $(DEPLOY_COPY_TARGETS) $(DEPLOY_DIR) && \
+	cp -af --no-dereference --preserve=mode,links $(DEPLOY_COPY_TARGETS) $(DEPLOY_DIR)
-	tar -C $(DST_DIR) -c . > $(DEPLOY_DIR)/proton_dist.tar
+	python3 $(STEAMPIPE_FIXUPS_PY) process $(DEPLOY_DIR)
-	@echo "Created deployment archive at "$(DEPLOY_DIR)"/proton_dist.tar"
 
 install: dist | $(filter-out dist deploy install redist,$(MAKECMDGOALS))
 	if [ ! -d $(STEAM_DIR) ]; then echo >&2 "!! "$(STEAM_DIR)" does not exist, cannot install"; return 1; fi
 	mkdir -p $(STEAM_DIR)/compatibilitytools.d/$(BUILD_NAME)
+	# Use -r instead of -a for sshfs
 	cp -rf --no-dereference --preserve=mode,links $(DST_BASE)/* $(STEAM_DIR)/compatibilitytools.d/$(BUILD_NAME)
-	cp -f $(DIST_VERSION) $(STEAM_DIR)/compatibilitytools.d/$(BUILD_NAME)/dist/
 	@echo "Installed Proton to "$(STEAM_DIR)/compatibilitytools.d/$(BUILD_NAME)
 	@echo "You may need to restart Steam to select this tool"
 
 redist: dist | $(filter-out dist deploy install redist,$(MAKECMDGOALS))
 	mkdir -p $(REDIST_DIR)
-	cp -a $(REDIST_COPY_TARGETS) $(REDIST_DIR)
+	cp -af --no-dereference --preserve=mode,links $(REDIST_COPY_TARGETS) $(REDIST_DIR)
-	tar -C $(DST_DIR) -c . | gzip -c -1 > $(REDIST_DIR)/proton_dist.tar.gz
-	@echo "Created redistribution tarball at "$(REDIST_DIR)"/proton_dist.tar.gz"
 
 .PHONY: module32 module64 module
 

default_pfx.py

@@ -71,6 +71,14 @@ def setup_dll_symlinks(default_pfx_dir, dist_dir):
                 os.unlink(filename)
                 make_relative_symlink(target, filename)
 
+#steampipe can't handle filenames with colons, so we remove them here
+#and restore them in the proton script
+def fixup_drive_links(default_pfx_dir):
+    for walk_dir, dirs, files in os.walk(os.path.join(default_pfx_dir, "dosdevices")):
+        for dir_ in dirs:
+            if ":" in dir_:
+                os.remove(os.path.join(walk_dir, dir_))
+
 def make_default_pfx(default_pfx_dir, dist_dir, runtime):
     local_env = dict(os.environ)
 
@@ -94,6 +102,7 @@ def make_default_pfx(default_pfx_dir, dist_dir, runtime):
 
         env=local_env, check=True)
     setup_dll_symlinks(default_pfx_dir, dist_dir)
+    fixup_drive_links(default_pfx_dir)
 
 if __name__ == '__main__':
     import sys

docker/proton.Dockerfile.in

@@ -52,10 +52,13 @@ RUN bash -c 'mkdir -p /usr/lib/ccache && ls /usr/bin/{,*-}{cc,c++,gcc,g++}{,-[0-
 ENV PATH=/usr/lib/ccache:$PATH
 
 RUN apt-get install -y \
+  autoconf-archive \
   fontforge \
   fonttools \
   libxpresent-dev \
   libxpresent-dev:i386 \
+  libopenblas-dev \
+  libopenblas-dev:i386 \
   python3-pefile \
   libcapstone-dev \
   libcapstone-dev:i386 \

dxvk

@@ -1 +1 @@
-Subproject commit 279b4b7ec225c2c4bddc4eb6ddfa8bfe89c8bf5c
+Subproject commit bd29fbd95d543156ac900b12295d29bcec436290

lsteamclient/cppISteamClient_SteamClient007.cpp

@@ -112,6 +112,7 @@ void *cppISteamClient_SteamClient007_GetISteamNetworking(void *linux_side, HStea
 
 void cppISteamClient_SteamClient007_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient008.cpp

@@ -112,6 +112,7 @@ uint32 cppISteamClient_SteamClient008_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient008_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient009.cpp

@@ -117,6 +117,7 @@ uint32 cppISteamClient_SteamClient009_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient009_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient010.cpp

@@ -117,6 +117,7 @@ uint32 cppISteamClient_SteamClient010_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient010_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient011.cpp

@@ -122,6 +122,7 @@ uint32 cppISteamClient_SteamClient011_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient011_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient012.cpp

@@ -117,6 +117,7 @@ uint32 cppISteamClient_SteamClient012_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient012_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient013.cpp

@@ -117,6 +117,7 @@ uint32 cppISteamClient_SteamClient013_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient013_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient014.cpp

@@ -117,6 +117,7 @@ uint32 cppISteamClient_SteamClient014_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient014_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient015.cpp

@@ -117,6 +117,7 @@ uint32 cppISteamClient_SteamClient015_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient015_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient016.cpp

@@ -117,6 +117,7 @@ uint32 cppISteamClient_SteamClient016_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient016_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient017.cpp

@@ -117,6 +117,7 @@ uint32 cppISteamClient_SteamClient017_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient017_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient018.cpp

@@ -123,6 +123,7 @@ uint32 cppISteamClient_SteamClient018_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient018_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient019.cpp

@@ -123,6 +123,7 @@ uint32 cppISteamClient_SteamClient019_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient019_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamClient_SteamClient020.cpp

@@ -123,6 +123,7 @@ uint32 cppISteamClient_SteamClient020_GetIPCCallCount(void *linux_side)
 
 void cppISteamClient_SteamClient020_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamUtils_SteamUtils004.cpp

@@ -92,6 +92,7 @@ uint32 cppISteamUtils_SteamUtils004_GetIPCCallCount(void *linux_side)
 
 void cppISteamUtils_SteamUtils004_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamUtils*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamUtils_SteamUtils005.cpp

@@ -92,6 +92,7 @@ uint32 cppISteamUtils_SteamUtils005_GetIPCCallCount(void *linux_side)
 
 void cppISteamUtils_SteamUtils005_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamUtils*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamUtils_SteamUtils006.cpp

@@ -92,6 +92,7 @@ uint32 cppISteamUtils_SteamUtils006_GetIPCCallCount(void *linux_side)
 
 void cppISteamUtils_SteamUtils006_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamUtils*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamUtils_SteamUtils007.cpp

@@ -92,6 +92,7 @@ uint32 cppISteamUtils_SteamUtils007_GetIPCCallCount(void *linux_side)
 
 void cppISteamUtils_SteamUtils007_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamUtils*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamUtils_SteamUtils008.cpp

@@ -92,6 +92,7 @@ uint32 cppISteamUtils_SteamUtils008_GetIPCCallCount(void *linux_side)
 
 void cppISteamUtils_SteamUtils008_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamUtils*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamUtils_SteamUtils009.cpp

@@ -93,6 +93,7 @@ uint32 cppISteamUtils_SteamUtils009_GetIPCCallCount(void *linux_side)
 
 void cppISteamUtils_SteamUtils009_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamUtils*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/cppISteamUtils_SteamUtils010.cpp

@@ -93,6 +93,7 @@ uint32 cppISteamUtils_SteamUtils010_GetIPCCallCount(void *linux_side)
 
 void cppISteamUtils_SteamUtils010_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
 {
+    pFunction = (SteamAPIWarningMessageHook_t)manual_convert_SteamAPIWarningMessageHook_t((void*)pFunction);
     ((ISteamUtils*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
 }
 

lsteamclient/gen_wrapper.py

@@ -281,6 +281,7 @@ manually_handled_methods = {
 # manual converters for simple types (function pointers)
 manual_type_converters = [
         "FSteamNetworkingSocketsDebugOutput",
+        "SteamAPIWarningMessageHook_t",
         "SteamAPI_CheckCallbackRegistered_t"
 ]
 

lsteamclient/steam_defs.h

@@ -235,7 +235,7 @@ typedef struct SteamNetConnectionRealTimeLaneStatus_t SteamNetConnectionRealTime
 typedef struct SteamNetworkingFakeIPResult_t SteamNetworkingFakeIPResult_t;
 
 typedef uint32 (*SteamAPI_CheckCallbackRegistered_t)(int cb);
-typedef void *SteamAPIWarningMessageHook_t; //already cdecl, no need for conversion(?)
+typedef void *SteamAPIWarningMessageHook_t;
 typedef void *SteamAPI_PostAPIResultInProcess_t; //unused
 typedef void (*FSteamNetworkingSocketsDebugOutput)(ESteamNetworkingSocketsDebugOutputType nType, const char *pszMsg);
 

lsteamclient/steamclient_main.c

@@ -654,6 +654,7 @@ static void callback_complete(UINT64 cookie)
 
 typedef void (WINAPI *win_FSteamNetworkingSocketsDebugOutput)(ESteamNetworkingSocketsDebugOutputType nType,
         const char *pszMsg);
+typedef void (CDECL *win_SteamAPIWarningMessageHook_t)(int, const char *pszMsg);
 
 static DWORD WINAPI callback_thread(void *dummy)
 {
@@ -672,6 +673,15 @@ static DWORD WINAPI callback_thread(void *dummy)
                         cb_data.sockets_debug_output.msg);
                 callback_complete(cookie);
                 break;
+            case STEAM_API_WARNING_HOOK:
+                TRACE("STEAM_API_WARNING_HOOK func %p, type %u, msg %s.\n",
+                        cb_data.func, cb_data.steam_api_warning_hook.severity,
+                        wine_dbgstr_a(cb_data.steam_api_warning_hook.msg));
+                ((win_SteamAPIWarningMessageHook_t)cb_data.func)(cb_data.steam_api_warning_hook.severity,
+                        cb_data.steam_api_warning_hook.msg);
+                callback_complete(cookie);
+                break;
+
             default:
                 ERR("Unexpected callback type %u.\n", cb_data.type);
                 break;

lsteamclient/steamclient_private.h

@@ -59,6 +59,7 @@ void *create_LinuxISteamMatchmakingServerListResponse(void *win, const char *ver
 void *create_LinuxISteamMatchmakingPingResponse(void *win, const char *version);
 void *create_LinuxISteamMatchmakingPlayersResponse(void *win, const char *version);
 void *create_LinuxISteamMatchmakingRulesResponse(void *win, const char *version);
+void *manual_convert_SteamAPIWarningMessageHook_t(void *win_func);
 void *manual_convert_FSteamNetworkingSocketsDebugOutput(void *win_func);
 void *manual_convert_SteamAPI_CheckCallbackRegistered_t(void *win_func);
 
@@ -72,6 +73,7 @@ void *alloc_mem_for_iface(size_t size, const char *iface_version);
 enum callback_type
 {
     SOCKET_DEBUG_OUTPUT = 1,
+    STEAM_API_WARNING_HOOK,
 };
 
 struct callback_data
@@ -87,6 +89,12 @@ struct callback_data
             const char *msg;
         }
         sockets_debug_output;
+        struct
+        {
+            int severity;
+            const char *msg;
+        }
+        steam_api_warning_hook;
     };
 };
 

lsteamclient/steamclient_wrappers.c

@@ -315,6 +315,29 @@ void *manual_convert_FSteamNetworkingSocketsDebugOutput(void *win_func)
 }
 
 
+static void *stored_SteamAPIWarningMessageHook_t;
+
+static void lin_SteamAPIWarningMessageHook_t(int severity, const char *msg)
+{
+    struct callback_data cb_data = { 0 };
+    /* Only Unix native calls from here (not even TRACE):
+     * this is native Unix thread which is not initialized by Wine. */
+    cb_data.type = STEAM_API_WARNING_HOOK;
+    cb_data.func = stored_SteamAPIWarningMessageHook_t;
+    cb_data.steam_api_warning_hook.severity = severity;
+    cb_data.steam_api_warning_hook.msg = msg;
+    execute_callback(&cb_data);
+}
+
+void *manual_convert_SteamAPIWarningMessageHook_t(void *win_func)
+{
+    TRACE("win_func %p, returning %p.\n", win_func, lin_SteamAPIWarningMessageHook_t);
+
+    stored_SteamAPIWarningMessageHook_t = win_func;
+
+    return &lin_SteamAPIWarningMessageHook_t;
+}
+
 /***** SteamAPI_CheckCallbackRegistered_t *****/
 static uint32 (__attribute__((ms_abi)) *stored_SteamAPI_CheckCallbackRegistered_t)(int cb);
 

proton

@@ -10,6 +10,7 @@ import json
 import os
 import shutil
 import errno
+import platform
 import stat
 import subprocess
 import sys
@@ -17,13 +18,21 @@ import tarfile
 import shlex
 
 from ctypes import CDLL
+from ctypes import CFUNCTYPE
 from ctypes import POINTER
 from ctypes import Structure
 from ctypes import addressof
 from ctypes import cast
+from ctypes import get_errno
+from ctypes import sizeof
 from ctypes import c_int
+from ctypes import c_int64
+from ctypes import c_uint
+from ctypes import c_long
 from ctypes import c_char_p
 from ctypes import c_void_p
+from ctypes import c_size_t
+from ctypes import c_ssize_t
 
 from filelock import FileLock
 from random import randrange
@@ -142,10 +151,15 @@ def try_copy(src, dst, prefix=None, add_write_perm=True, copy_metadata=False, op
         elif track_file and prefix is not None:
             track_file.write(os.path.relpath(dst, prefix) + '\n')
 
-        if copy_metadata:
+        if os.path.islink(src) and not follow_symlinks:
-            shutil.copy2(src, dst, follow_symlinks=follow_symlinks)
+            shutil.copyfile(src, dst, follow_symlinks=False)
         else:
-            shutil.copy(src, dst, follow_symlinks=follow_symlinks)
+            copyfile(src, dst)
+
+        if copy_metadata:
+            shutil.copystat(src, dst, follow_symlinks=follow_symlinks)
+        else:
+            shutil.copymode(src, dst, follow_symlinks=follow_symlinks)
 
         if add_write_perm:
             new_mode = os.lstat(dst).st_mode | stat.S_IWUSR | stat.S_IWGRP
@@ -175,15 +189,62 @@ def try_copy(src, dst, prefix=None, add_write_perm=True, copy_metadata=False, op
         else:
             raise
 
+# copy_file_range implementation for old Python versions
+__syscall__copy_file_range = None
+
+def copy_file_range_ctypes(fd_in, fd_out, count):
+    "Copy data using the copy_file_range syscall through ctypes, assuming x86_64 Linux"
+    global __syscall__copy_file_range
+    __NR_copy_file_range = 326
+
+    if __syscall__copy_file_range is None:
+        c_int64_p = POINTER(c_int64)
+        prototype = CFUNCTYPE(c_ssize_t, c_long, c_int, c_int64_p,
+            c_int, c_int64_p, c_size_t, c_uint, use_errno=True)
+        __syscall__copy_file_range = prototype(('syscall', CDLL(None, use_errno=True)))
+
+    while True:
+        ret = __syscall__copy_file_range(__NR_copy_file_range, fd_in, None, fd_out, None, count, 0)
+        if ret >= 0 or get_errno() != errno.EINTR:
+            break
+
+    if ret < 0:
+        raise OSError(get_errno(), errno.errorcode.get(get_errno(), 'unknown'))
+
+    return ret
+
+def copyfile_reflink(srcname, dstname):
+    "Copy srcname to dstname, making reflink if possible"
+    global copyfile
+    with open(srcname, 'rb', buffering=0) as src:
+        bytes_to_copy = os.fstat(src.fileno()).st_size
+        try:
+            with open(dstname, 'wb', buffering=0) as dst:
+                while bytes_to_copy > 0:
+                    bytes_to_copy -= copy_file_range(src.fileno(), dst.fileno(), bytes_to_copy)
+        except OSError as e:
+            if e.errno not in (errno.EXDEV, errno.ENOSYS, errno.EINVAL):
+                raise e
+            if e.errno == errno.ENOSYS:
+                copyfile = shutil.copyfile
+            shutil.copyfile(srcname, dstname)
+
+if hasattr(os, 'copy_file_range'):
+    copyfile = copyfile_reflink
+    copy_file_range = os.copy_file_range
+elif sys.platform == 'linux' and platform.machine() == 'x86_64' and sizeof(c_void_p) == 8:
+    copyfile = copyfile_reflink
+    copy_file_range = copy_file_range_ctypes
+else:
+    copyfile = shutil.copyfile
+
 def try_copyfile(src, dst):
     try:
         if os.path.isdir(dst):
-            dstfile = dst + "/" + os.path.basename(src)
+            dst = dst + "/" + os.path.basename(src)
-            if file_exists(dstfile, follow_symlinks=False):
+        if file_exists(dst, follow_symlinks=False):
-                os.remove(dstfile)
-        elif file_exists(dst, follow_symlinks=False):
             os.remove(dst)
-        shutil.copyfile(src, dst)
+        copyfile(src, dst)
     except PermissionError as e:
         if e.errno == errno.EPERM:
             #be forgiving about permissions errors; if it's a real problem, things will explode later anyway
@@ -343,15 +404,15 @@ def set_dir_casefold_bit(dir_path):
 class Proton:
     def __init__(self, base_dir):
         self.base_dir = base_dir + "/"
-        self.dist_dir = self.path("dist/")
+        self.dist_dir = self.path("files/")
-        self.bin_dir = self.path("dist/bin/")
+        self.bin_dir = self.path("files/bin/")
-        self.lib_dir = self.path("dist/lib/")
+        self.lib_dir = self.path("files/lib/")
-        self.lib64_dir = self.path("dist/lib64/")
+        self.lib64_dir = self.path("files/lib64/")
-        self.fonts_dir = self.path("dist/share/fonts/")
+        self.fonts_dir = self.path("files/share/fonts/")
-        self.wine_fonts_dir = self.path("dist/share/wine/fonts/")
+        self.wine_fonts_dir = self.path("files/share/wine/fonts/")
-        self.wine_inf = self.path("dist/share/wine/wine.inf")
+        self.wine_inf = self.path("files/share/wine/wine.inf")
         self.version_file = self.path("version")
-        self.default_pfx_dir = self.path("dist/share/default_pfx/")
+        self.default_pfx_dir = self.path("files/share/default_pfx/")
         self.user_settings_file = self.path("user_settings.py")
         self.wine_bin = self.bin_dir + "wine"
         self.wine64_bin = self.bin_dir + "wine64"
@@ -361,28 +422,34 @@ class Proton:
     def path(self, d):
         return self.base_dir + d
 
-    def need_tarball_extraction(self):
+    def cleanup_legacy_dist(self):
-        '''Checks if the proton_dist tarball archive must be extracted. Returns true if extraction is needed, false otherwise'''
+        old_dist_dir = self.path("dist/")
-        return not file_exists(self.dist_dir, follow_symlinks=True) or \
+        if file_exists(old_dist_dir, follow_symlinks=True):
-            not file_exists(self.path("dist/version"), follow_symlinks=True) or \
+            with self.dist_lock:
-            not filecmp.cmp(self.version_file, self.path("dist/version"))
+                if file_exists(old_dist_dir, follow_symlinks=True):
+                    shutil.rmtree(old_dist_dir)
 
-    def extract_tarball(self):
+    def do_steampipe_fixups(self):
-        with self.dist_lock:
+        fixups_json = self.path("steampipe_fixups.json")
-            if self.need_tarball_extraction():
+        fixups_mtime = self.path("files/steampipe_fixups_mtime")
-                if file_exists(self.dist_dir, follow_symlinks=True):
+
-                    shutil.rmtree(self.dist_dir)
+        if file_exists(fixups_json, follow_symlinks=True):
-                tar = None
+            with self.dist_lock:
-                for sf in ["", ".xz", ".bz2", ".gz"]:
+                import steampipe_fixups
-                    if file_exists(self.path("proton_dist.tar" + sf), follow_symlinks=True):
+
-                        tar = tarfile.open(self.path("proton_dist.tar" + sf), mode="r:*")
+                current_fixup_mtime = None
-                        break
+                if file_exists(fixups_mtime, follow_symlinks=True):
-                if not tar:
+                    with open(fixups_mtime, "r") as f:
-                    log("No proton_dist tarball??")
+                        current_fixup_mtime = f.readline().strip()
-                    sys.exit(1)
+
-                tar.extractall(path=self.dist_dir)
+                new_fixup_mtime = getmtimestr(fixups_json)
-                tar.close()
+
-                try_copy(self.version_file, self.dist_dir)
+                if current_fixup_mtime != new_fixup_mtime:
+                    result_code = steampipe_fixups.do_restore(self.base_dir, fixups_json)
+
+                    if result_code == 0:
+                        with open(fixups_mtime, "w") as f:
+                            f.write(new_fixup_mtime + "\n")
 
     def missing_default_prefix(self):
         '''Check if the default prefix dir is missing. Returns true if missing, false if present'''
@@ -719,6 +786,12 @@ class CompatData:
 
             self.migrate_user_paths()
 
+            if not file_exists(self.prefix_dir + "/dosdevices/c:", follow_symlinks=False):
+                os.symlink("../drive_c", self.prefix_dir + "/dosdevices/c:")
+
+            if not file_exists(self.prefix_dir + "/dosdevices/z:", follow_symlinks=False):
+                os.symlink("/", self.prefix_dir + "/dosdevices/z:")
+
             # collect configuration info
             steamdir = os.environ["STEAM_COMPAT_CLIENT_INSTALL_PATH"]
 
@@ -939,14 +1012,18 @@ def default_compat_config():
                 "1135230", #Ember Knights
                 "1161580", #Hardspace: Shipbreaker
                 "1190000", #Car Mechanic Simulator 2021
+                "1328350", #Turbo Overkill
                 "1331440", #FUSER
                 "1341290", #We Were Here Forever
+                "1359980", #POSTAL: Brain Damaged
                 "1361320", #The Room 4: Old Sins
                 "1477590", #EZ2ON REBOOT : R
                 "1523720", #Cook-Out
                 "1569550", #Dread X Collection: The Hunt
                 "1604030", #V Rising
+                "1766430", #POSTAL Brain Damaged Demo
                 "1913910", #Nine Sols Demo
+                "2001540", #Slayers X Demo
 
                 #affected by CW bug 19741
                 "1017900", #Age of Empires: Definitive Edition
@@ -961,6 +1038,7 @@ class Session:
         self.dlloverrides = {
                 "steam.exe": "b", #always use our special built-in steam.exe
                 "dotnetfx35.exe": "b", #replace the broken installer, as does Windows
+                "dotnetfx35setup.exe": "b",
                 "beclient.dll": "b,n",
                 "beclient_x64.dll": "b,n",
         }
@@ -1392,8 +1470,8 @@ if __name__ == "__main__":
 
     g_proton = Proton(os.path.dirname(sys.argv[0]))
 
-    if g_proton.need_tarball_extraction():
+    g_proton.cleanup_legacy_dist()
-        g_proton.extract_tarball()
+    g_proton.do_steampipe_fixups()
 
     g_compatdata = CompatData(os.environ["STEAM_COMPAT_DATA_PATH"])
 

steampipe_fixups.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+
+#Steampipe doesn't support certain unix-y things which may be required by
+#native Linux applications. This file will process a directory of Linux files
+#and store the file properties into a manifest file. After a round trip through
+#Steampipe, the original file properties can be restored using this same
+#script.
+
+import json
+import os
+import secrets
+import stat
+
+DEFAULT_MANIFEST_NAME = "steampipe_fixups.json"
+
+def usage():
+    print("Usage:")
+    print("\t" + sys.argv[0] + "\tprepare\t<path to directory to process>\t[manifest output file]")
+    print("\t\tProcess the given path and output the manifest file to the given path, or <path/" + DEFAULT_MANIFEST_NAME + "> if unspecified.")
+    print("")
+    print("\t" + sys.argv[0] + "\trestore\t<path to directory to process>\t[manifest file]")
+    print("\t\tRestore the given path using the manifest file, or <path/" + DEFAULT_MANIFEST_NAME + "> if unspecified.")
+
+empty_dirs = []
+no_write_paths = []
+
+def canonicalize(path, prefix):
+    return path.replace(prefix, "", 1).lstrip('/')
+
+def process_dir(path):
+    for root, subdirs, files in os.walk(path):
+        if len(subdirs) == 0 and len(files) == 0:
+            empty_dirs.append(canonicalize(root, path))
+
+        for file_ in files:
+            this_file = os.path.join(root, file_)
+            stat_result = os.lstat(this_file)
+            if (stat_result.st_mode & stat.S_IWUSR) == 0:
+                no_write_paths.append(canonicalize(this_file, path))
+
+    return 0
+
+def write_manifest(manifest):
+    out = open(manifest, "w")
+    json.dump(
+        {
+            "id": str(secrets.randbits(32)), #we need steampipe to update this file for every build
+            "empty_dirs": empty_dirs,
+            "no_write_paths": no_write_paths,
+        },
+        out,
+        indent = 4,
+        sort_keys = True
+    )
+    return 0
+
+def do_process(path, manifest):
+    if os.path.exists(manifest):
+        os.remove(manifest)
+
+    ret = process_dir(path)
+    if ret != 0:
+        return ret
+
+    #output should be deterministic
+    empty_dirs.sort()
+    no_write_paths.sort()
+
+    ret = write_manifest(manifest)
+    if ret != 0:
+        return ret
+
+    return 0
+
+def do_restore(path, manifest):
+    loaded = json.load(open(manifest, "r"))
+
+    empty_dirs = loaded["empty_dirs"]
+    no_write_paths = loaded["no_write_paths"]
+
+    for empty_dir in empty_dirs:
+        try:
+            os.makedirs(os.path.join(path, empty_dir))
+        except OSError:
+            #already exists
+            pass
+
+    for file_ in no_write_paths:
+        this_file = os.path.join(path, file_)
+        stat_result = os.lstat(this_file)
+        os.chmod(this_file,
+                stat_result.st_mode & ~(stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH))
+
+    return 0
+
+if __name__ == '__main__':
+    import sys
+    if len(sys.argv) < 3 or len(sys.argv) > 4:
+        usage()
+        sys.exit(1)
+
+    verb = sys.argv[1]
+    path = sys.argv[2]
+    if len(sys.argv) >= 4:
+        manifest = sys.argv[3]
+    else:
+        manifest = os.path.join(path, DEFAULT_MANIFEST_NAME)
+
+    if verb == "process":
+        sys.exit(do_process(path, manifest))
+
+    if verb == "restore":
+        sys.exit(do_restore(path, manifest))
+
+    usage()
+    sys.exit(1)

vkd3d-proton

@@ -1 +1 @@
-Subproject commit 3e5aab6fb3e18f81a71b339be4cb5cdf55140980
+Subproject commit 829ac72e3d381006a843c183e613e8ee77e0b292

wine

@@ -1 +1 @@
-Subproject commit a7618abea5ffeb3bfb1e69c0dbcdc1008bd88163
+Subproject commit ab141d8c778f5882a90b2454a2e3191d88026396