Merge branch 'master' of gitlab.com:Mr_Goldberg/goldberg_emulator

Implemented a basic steampipe alloc system and fixed build.

.gitlab-ci.yml

@@ -153,6 +153,10 @@ deploy_all:
 
   script:
     - ls -lah
+    - dnf -y install git
+    - mkdir -p release/source_code
+    - git bundle create release/source_code/source_code.bundle --all
+    - "echo \"This is a git bundle of the full repo, to use: git clone source_code.bundle --branch master\" > release/source_code/Readme.txt"
     - mv linux release/
     - shopt -s extglob
     - rm -rf .g*

build_steamos.sh

@@ -7,10 +7,10 @@ mkdir -p linux/tools
 cp scripts/find_interfaces.sh linux/tools/
 cp scripts/steamclient_loader.sh linux/tools/
 ../protobuf/prefix_x86/bin/protoc -I./dll/ --cpp_out=./dll/ ./dll/*.proto
-g++ -m32 -shared -fPIC -fvisibility=hidden -Wl,--exclude-libs,ALL -DGNUC -DEMU_RELEASE_BUILD -DNDEBUG -s -o linux/x86/libsteam_api.so dll/*.cpp dll/*.cc -Wno-return-type -I../protobuf/prefix_x86/include/ -L../protobuf/prefix_x86/lib/ -lprotobuf-lite -std=c++11 && echo built32
+g++ -m32 -shared -fPIC -fvisibility=hidden -Wl,--exclude-libs,ALL -DGNUC -DEMU_RELEASE_BUILD -DNDEBUG -DCONTROLLER_SUPPORT -s -o linux/x86/libsteam_api.so dll/*.cpp dll/*.cc controller/*.c -Wno-return-type -I../protobuf/prefix_x86/include/ -L../protobuf/prefix_x86/lib/ -lprotobuf-lite -std=c++11 && echo built32
 g++ -m32 -fvisibility=hidden -Wl,--exclude-libs,ALL -DGNUC -DEMU_RELEASE_BUILD -DNDEBUG -DNO_DISK_WRITES -DLOBBY_CONNECT -s -o linux/lobby_connect/lobby_connect_x86 lobby_connect.cpp dll/*.cpp dll/*.cc -Wno-return-type -I../protobuf/prefix_x86/include/ -L../protobuf/prefix_x86/lib/ -lprotobuf-lite -lpthread -ldl -std=c++11 && echo built_lobby_connect32
-g++ -m32 -shared -fPIC -fvisibility=hidden -Wl,--exclude-libs,ALL -DGNUC -DEMU_RELEASE_BUILD -DSTEAMCLIENT_DLL -DNDEBUG -s -o linux/x86/steamclient.so dll/*.cpp dll/*.cc -Wno-return-type -I../protobuf/prefix_x86/include/ -L../protobuf/prefix_x86/lib/ -lprotobuf-lite -std=c++11 && echo built32_steamclient
+g++ -m32 -shared -fPIC -fvisibility=hidden -Wl,--exclude-libs,ALL -DGNUC -DEMU_RELEASE_BUILD -DSTEAMCLIENT_DLL -DNDEBUG -DCONTROLLER_SUPPORT -s -o linux/x86/steamclient.so dll/*.cpp dll/*.cc controller/*.c -Wno-return-type -I../protobuf/prefix_x86/include/ -L../protobuf/prefix_x86/lib/ -lprotobuf-lite -std=c++11 && echo built32_steamclient
 ../protobuf/prefix/bin/protoc -I./dll/ --cpp_out=./dll/ ./dll/*.proto
-g++ -shared -fPIC -fvisibility=hidden -Wl,--exclude-libs,ALL -DGNUC -DEMU_RELEASE_BUILD -DNDEBUG -s -o linux/x86_64/libsteam_api.so dll/*.cpp dll/*.cc -Wno-return-type -I../protobuf/prefix/include/ -L../protobuf/prefix/lib/ -lprotobuf-lite -std=c++11 && echo built64
+g++ -shared -fPIC -fvisibility=hidden -Wl,--exclude-libs,ALL -DGNUC -DEMU_RELEASE_BUILD -DNDEBUG -DCONTROLLER_SUPPORT -s -o linux/x86_64/libsteam_api.so dll/*.cpp dll/*.cc controller/*.c -Wno-return-type -I../protobuf/prefix/include/ -L../protobuf/prefix/lib/ -lprotobuf-lite -std=c++11 && echo built64
 g++ -fvisibility=hidden -Wl,--exclude-libs,ALL -DGNUC -DEMU_RELEASE_BUILD -DNDEBUG -DNO_DISK_WRITES -DLOBBY_CONNECT -s -o linux/lobby_connect/lobby_connect_x64 lobby_connect.cpp dll/*.cpp dll/*.cc -Wno-return-type -I../protobuf/prefix/include/ -L../protobuf/prefix/lib/ -lprotobuf-lite -lpthread -ldl -std=c++11 && echo built_lobby_connect64
-g++ -shared -fPIC -fvisibility=hidden -Wl,--exclude-libs,ALL -DGNUC -DEMU_RELEASE_BUILD -DSTEAMCLIENT_DLL -DNDEBUG -s -o linux/x86_64/steamclient.so dll/*.cpp dll/*.cc -Wno-return-type -I../protobuf/prefix/include/ -L../protobuf/prefix/lib/ -lprotobuf-lite -std=c++11 && echo built64_steamclient
+g++ -shared -fPIC -fvisibility=hidden -Wl,--exclude-libs,ALL -DGNUC -DEMU_RELEASE_BUILD -DSTEAMCLIENT_DLL -DNDEBUG -DCONTROLLER_SUPPORT -s -o linux/x86_64/steamclient.so dll/*.cpp dll/*.cc controller/*.c -Wno-return-type -I../protobuf/prefix/include/ -L../protobuf/prefix/lib/ -lprotobuf-lite -std=c++11 && echo built64_steamclient

controller/gamepad.c

@@ -25,7 +25,9 @@
 #	include <stdio.h>
 #	include <fcntl.h>
 #	include <unistd.h>
-#	include <libudev.h>
+#	include <dirent.h>
+#	include <sys/stat.h>
+#	include <time.h>
 #else
 #	error "Unknown platform in gamepad.c"
 #endif
@@ -60,6 +62,8 @@ struct GAMEPAD_STATE {
 	char* device;
 	int fd;
 	int effect;
+	double axis_min[ABS_MAX];
+	double axis_max[ABS_MAX];
 #endif
 };
 
@@ -126,7 +130,8 @@ void GamepadShutdown(void) {
 	/* no Win32 shutdown required */
 }
 
-void GamepadSetRumble(GAMEPAD_DEVICE gamepad, float left, float right) {
+void GamepadSetRumble(GAMEPAD_DEVICE gamepad, float left, float right, unsigned int rumble_length_ms) {
+	//TODO: rumble_length_ms
 	if ((STATE[gamepad].flags & FLAG_RUMBLE) != 0) {
 		XINPUT_VIBRATION vib;
 		ZeroMemory(&vib, sizeof(vib));
@@ -137,14 +142,103 @@ void GamepadSetRumble(GAMEPAD_DEVICE gamepad, float left, float right) {
 }
 
 #elif defined(__linux__)
+#define test_bit(nr, addr) \
+	(((1UL << ((nr) % (sizeof(long) * 8))) & ((addr)[(nr) / (sizeof(long) * 8)])) != 0)
+#define NBITS(x) ((((x)-1)/(sizeof(long) * 8))+1)
 
-/* UDev handles */
+
-static struct udev* UDEV = NULL;
+static int IsGamepad(int fd, char *namebuf, const size_t namebuflen)
-static struct udev_monitor* MON = NULL;
+{
+	struct input_id inpid;
+	//uint16_t *guid16 = (uint16_t *)guid->data;
+
+	/* When udev is enabled we only get joystick devices here, so there's no need to test them */
+	unsigned long evbit[NBITS(EV_MAX)] = { 0 };
+	unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
+	unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
+
+	if ((ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), evbit) < 0) ||
+		(ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
+		(ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0)) {
+		return (0);
+	}
+
+	if (!(test_bit(EV_KEY, evbit) && test_bit(EV_ABS, evbit) &&
+		  test_bit(ABS_X, absbit) && test_bit(ABS_Y, absbit))) {
+		return 0;
+	}
+
+	if (ioctl(fd, EVIOCGNAME(namebuflen), namebuf) < 0) {
+		return 0;
+	}
+
+	if (ioctl(fd, EVIOCGID, &inpid) < 0) {
+		return 0;
+	}
+
+	//printf("Joystick: %s, bustype = %d, vendor = 0x%.4x, product = 0x%.4x, version = %d\n", namebuf, inpid.bustype, inpid.vendor, inpid.product, inpid.version);
+
+	//memset(guid->data, 0, sizeof(guid->data));
+
+	/* We only need 16 bits for each of these; space them out to fill 128. */
+	/* Byteswap so devices get same GUID on little/big endian platforms. */
+/*
+	*guid16++ = SDL_SwapLE16(inpid.bustype);
+	*guid16++ = 0;
+
+	if (inpid.vendor && inpid.product) {
+		*guid16++ = SDL_SwapLE16(inpid.vendor);
+		*guid16++ = 0;
+		*guid16++ = SDL_SwapLE16(inpid.product);
+		*guid16++ = 0;
+		*guid16++ = SDL_SwapLE16(inpid.version);
+		*guid16++ = 0;
+	} else {
+		strlcpy((char*)guid16, namebuf, sizeof(guid->data) - 4);
+	}
+
+	if (SDL_ShouldIgnoreJoystick(namebuf, *guid)) {
+		return 0;
+	}
+*/
+	return 1;
+}
 
 static void GamepadAddDevice(const char* devPath);
 static void GamepadRemoveDevice(const char* devPath);
 
+static void GamepadDetect()
+{
+	DIR *folder;
+	struct dirent *dent;
+
+	folder = opendir("/dev/input");
+	if (folder) {
+		while ((dent = readdir(folder))) {
+			int len = strlen(dent->d_name);
+			if (len > 5 && strncmp(dent->d_name, "event", 5) == 0) {
+				char path[PATH_MAX];
+				snprintf(path, sizeof(path), "/dev/input/%s", dent->d_name);
+				GamepadAddDevice(path);
+			}
+		}
+
+		closedir(folder);
+	}
+
+	for (int i = 0; i != GAMEPAD_COUNT; ++i) {
+		if ((STATE[i].flags & FLAG_CONNECTED) && STATE[i].device) {
+			struct stat sb;
+			//printf("%s\n", STATE[i].device);
+			if (stat(STATE[i].device, &sb) == -1) {
+				GamepadRemoveDevice(STATE[i].device);
+			}
+		}
+	}
+}
+
+
+
 /* Helper to add a new device */
 static void GamepadAddDevice(const char* devPath) {
 	int i;
@@ -154,11 +248,25 @@ static void GamepadAddDevice(const char* devPath) {
 		if ((STATE[i].flags & FLAG_CONNECTED) == 0) {
 			break;
 		}
+
+		if (STATE[i].device && strcmp(devPath, STATE[i].device) == 0) {
+			return;
 		}
+	}
+
 	if (i == GAMEPAD_COUNT) {
 		return;
 	}
 
+	int fd = open(devPath, O_RDWR, 0);
+	if (fd < 0) return;
+	char namebuf[128];
+	int is_gamepad = IsGamepad(fd, namebuf, sizeof (namebuf));
+	if (!is_gamepad) {
+		close(fd);
+		return;
+	}
+
 	/* copy the device path */
 	STATE[i].device = strdup(devPath);
 	if (STATE[i].device == NULL) {
@@ -168,25 +276,87 @@ static void GamepadAddDevice(const char* devPath) {
 	/* reset device state */
 	GamepadResetState((GAMEPAD_DEVICE)i);
 
-	/* attempt to open the device in read-write mode, which we need fo rumble */
+	fcntl(fd, F_SETFL, O_NONBLOCK);
-	STATE[i].fd = open(STATE[i].device, O_RDWR|O_NONBLOCK);
+	STATE[i].fd = fd;
-	if (STATE[i].fd != -1) {
+	STATE[i].flags |= FLAG_CONNECTED;
-		STATE[i].flags = FLAG_CONNECTED|FLAG_RUMBLE;
-		return;
-	}
 
-	/* attempt to open in read-only mode if access was denied */
+	int controller = i;
-	if (errno == EACCES) {
+	{
-		STATE[i].fd = open(STATE[i].device, O_RDONLY|O_NONBLOCK);
+	int i, t;
-		if (STATE[i].fd != -1) {
+	unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
-			STATE[i].flags = FLAG_CONNECTED;
+	unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
-			return;
+	unsigned long relbit[NBITS(REL_MAX)] = { 0 };
+	unsigned long ffbit[NBITS(FF_MAX)] = { 0 };
+
+	/* See if this device uses the new unified event API */
+	if ((ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) >= 0) &&
+		(ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) >= 0) &&
+		(ioctl(fd, EVIOCGBIT(EV_REL, sizeof(relbit)), relbit) >= 0)) {
+
+		/* Get the number of buttons, axes, and other thingamajigs */
+		for (i = BTN_JOYSTICK; i < KEY_MAX; ++i) {
+			if (test_bit(i, keybit)) {
+				//printf("Joystick has button: 0x%x\n", i);
+			}
+		}
+		for (i = 0; i < BTN_JOYSTICK; ++i) {
+			if (test_bit(i, keybit)) {
+				//printf("Joystick has button: 0x%x\n", i);
+			}
+		}
+		for (i = 0; i < ABS_MAX; ++i) {
+			/* Skip hats */
+			if (i == ABS_HAT0X) {
+				i = ABS_HAT3Y;
+				continue;
+			}
+			if (test_bit(i, absbit)) {
+				struct input_absinfo absinfo;
+
+				if (ioctl(fd, EVIOCGABS(i), &absinfo) < 0) {
+					continue;
+				}
+/*
+				printf("Joystick has absolute axis: 0x%.2x\n", i);
+				printf("Values = { %d, %d, %d, %d, %d }\n",
+					   absinfo.value, absinfo.minimum, absinfo.maximum,
+					   absinfo.fuzz, absinfo.flat);
+*/
+				STATE[controller].axis_min[i] = absinfo.minimum;
+				STATE[controller].axis_max[i] = absinfo.maximum;
+			}
+		}
+		for (i = ABS_HAT0X; i <= ABS_HAT3Y; i += 2) {
+			if (test_bit(i, absbit) || test_bit(i + 1, absbit)) {
+				struct input_absinfo absinfo;
+				int hat_index = (i - ABS_HAT0X) / 2;
+
+				if (ioctl(fd, EVIOCGABS(i), &absinfo) < 0) {
+					continue;
+				}
+/*
+				printf("Joystick has hat %d\n", hat_index);
+				printf("Values = { %d, %d, %d, %d, %d }\n",
+					   absinfo.value, absinfo.minimum, absinfo.maximum,
+					   absinfo.fuzz, absinfo.flat);
+*/
+				//joystick->hwdata->hats_indices[joystick->nhats++] = hat_index;
+			}
+		}
+		if (test_bit(REL_X, relbit) || test_bit(REL_Y, relbit)) {
+			//++joystick->nballs;
 		}
 	}
 
-	/* could not open the device at all */
+	if (ioctl(fd, EVIOCGBIT(EV_FF, sizeof(ffbit)), ffbit) >= 0) {
-	free(STATE[i].device);
+		if (test_bit(FF_RUMBLE, ffbit)) {
-	STATE[i].device = NULL;
+			STATE[controller].flags |= FLAG_RUMBLE;
+		}
+		if (test_bit(FF_SINE, ffbit)) {
+			//printf("sine\n");
+		}
+	}
+	}
 }
 
 /* Helper to remove a device */
@@ -218,159 +388,145 @@ void GamepadInit(void) {
 		STATE[i].fd = STATE[i].effect = -1;
 	}
 
-	/* open the udev handle */
+	GamepadDetect();
-	UDEV = udev_new();
-	if (UDEV == NULL) {
-		/* FIXME: flag error? */
-		return;
-	}
-	
-	/* open monitoring device (safe to fail) */
-	MON = udev_monitor_new_from_netlink(UDEV, "udev");
-	/* FIXME: flag error if hot-plugging can't be supported? */
-	if (MON != NULL) {
-		udev_monitor_enable_receiving(MON);
-		udev_monitor_filter_add_match_subsystem_devtype(MON, "input", NULL);
-	}
-
-	/* enumerate joypad devices */
-	enu = udev_enumerate_new(UDEV);
-	udev_enumerate_add_match_subsystem(enu, "input");
-	udev_enumerate_scan_devices(enu);
-	devices = udev_enumerate_get_list_entry(enu);
-
-	udev_list_entry_foreach(item, devices) {
-		const char* name;
-		const char* sysPath;
-		const char* devPath;
-		struct udev_device* dev;
-
-		name = udev_list_entry_get_name(item);
-		dev = udev_device_new_from_syspath(UDEV, name);
-		sysPath = udev_device_get_syspath(dev);
-		devPath = udev_device_get_devnode(dev);
-
-		if (sysPath != NULL && devPath != NULL && strstr(sysPath, "/js") != 0) {
-			GamepadAddDevice(devPath);
-		}
-
-		udev_device_unref(dev);
-	}
-
-	/* cleanup */
-	udev_enumerate_unref(enu);
 }
 
 void GamepadUpdate(void) {
-	if (MON != NULL) {
+	static unsigned long last = 0;
-		fd_set r;
+	unsigned long cur = time(NULL);
-		struct timeval tv;
-		int fd = udev_monitor_get_fd(MON);
 
-		/* set up a poll on the udev device */
+	if (last + 2 < cur) {
-		FD_ZERO(&r);
+		GamepadDetect();
-		FD_SET(fd, &r);
+		last = cur;
-
-		tv.tv_sec = 0;
-		tv.tv_usec = 0;
-
-		select(fd + 1, &r, 0, 0, &tv);
-
-		/* test if we have a device change */
-		if (FD_ISSET(fd, &r)) {
-			struct udev_device* dev = udev_monitor_receive_device(MON);
-			if (dev) {
-				const char* devNode = udev_device_get_devnode(dev);
-				const char* sysPath = udev_device_get_syspath(dev);
-				const char* action = udev_device_get_action(dev);
-				sysPath = udev_device_get_syspath(dev);
-				action = udev_device_get_action(dev);
-
-				if (strstr(sysPath, "/js") != 0) {
-					if (strcmp(action, "remove") == 0) {
-						GamepadRemoveDevice(devNode);
-					} else if (strcmp(action, "add") == 0) {
-						GamepadAddDevice(devNode);
-					}
-				}
-
-				udev_device_unref(dev);
-			}
-		}
 	}
 
 	GamepadUpdateCommon();
 }
 
+static int adjust_values_trigger(double min, double max, double value)
+{
+	return (((value + (0 - min)) / (max - min)) * 255.0);
+}
+
+static int adjust_values_stick(double min, double max, double value)
+{
+	return (((value + (0 - min)) / (max - min)) * (65535.0)) - 32768.0;
+}
+
 static void GamepadUpdateDevice(GAMEPAD_DEVICE gamepad) {
 	if (STATE[gamepad].flags & FLAG_CONNECTED) {
-		struct js_event je;
+		struct input_event events[32];
-		while (read(STATE[gamepad].fd, &je, sizeof(je)) > 0) {
+		int i, len;
-			int button;
+		int code;
-			switch (je.type) {
+
-			case JS_EVENT_BUTTON:
+		while ((len = read(STATE[gamepad].fd, events, (sizeof events))) > 0) {
-				/* determine which button the event is for */
+			len /= sizeof(events[0]);
-				switch (je.number) {
+			for (i = 0; i < len; ++i) {
-				case 0: button = BUTTON_A; break;
+				int button = 0;
-				case 1: button = BUTTON_B; break;
+				code = events[i].code;
-				case 2: button = BUTTON_X; break;
+				switch (events[i].type) {
-				case 3: button = BUTTON_Y; break;
+				case EV_KEY:
-				case 4: button = BUTTON_LEFT_SHOULDER; break;
+					//printf("EV_KEY %i\n", code);
-				case 5: button = BUTTON_RIGHT_SHOULDER; break;
+					switch (code) {
-				case 6: button = BUTTON_BACK; break;
+					case BTN_SOUTH: button = BUTTON_A; break;
-				case 7: button = BUTTON_START; break;
+					case BTN_EAST: button = BUTTON_B; break;
-				case 8: button = 0; break; /* XBOX button  */
+					case BTN_NORTH: button = BUTTON_X; break;
-				case 9: button = BUTTON_LEFT_THUMB; break;
+					case BTN_WEST: button = BUTTON_Y; break;
-				case 10: button = BUTTON_RIGHT_THUMB; break;
+					case BTN_TL: button = BUTTON_LEFT_SHOULDER; break;
+					case BTN_TR: button = BUTTON_RIGHT_SHOULDER; break;
+					case BTN_SELECT: button = BUTTON_BACK; break;
+					case BTN_START: button = BUTTON_START; break;
+					case BTN_MODE: button = 0; break; /* XBOX button  */
+					case BTN_THUMBL: button = BUTTON_LEFT_THUMB; break;
+					case BTN_THUMBR: button = BUTTON_RIGHT_THUMB; break;
 					default: button = 0; break;
 					}
-
+					if (events[i].value) {
-				/* set or unset the button */
-				if (je.value) {
 						STATE[gamepad].bCurrent |= BUTTON_TO_FLAG(button);
 					} else {
 						STATE[gamepad].bCurrent ^= BUTTON_TO_FLAG(button);
 					}
-					
 					break;
-			case JS_EVENT_AXIS:
+				case EV_ABS:
-				/* normalize and store the axis */
+					switch (code) {
-				switch (je.number) {
+					case ABS_HAT0X:
-				case 0:	STATE[gamepad].stick[STICK_LEFT].x = je.value; break;
+					case ABS_HAT0Y:
-				case 1:	STATE[gamepad].stick[STICK_LEFT].y = -je.value; break;
+					case ABS_HAT1X:
-				case 2:	STATE[gamepad].trigger[TRIGGER_LEFT].value = (je.value + 32768) >> 8; break;
+					case ABS_HAT1Y:
-				case 3:	STATE[gamepad].stick[STICK_RIGHT].x = je.value; break;
+					case ABS_HAT2X:
-				case 4:	STATE[gamepad].stick[STICK_RIGHT].y = -je.value; break;
+					case ABS_HAT2Y:
-				case 5:	STATE[gamepad].trigger[TRIGGER_RIGHT].value = (je.value + 32768) >> 8; break;
+					case ABS_HAT3X:
-				case 6:
+					case ABS_HAT3Y:
-					if (je.value == -32767) {
+						//code -= ABS_HAT0X;
+						//printf("ABS_HAT %i\n", code);
+						switch(code) {
+							case ABS_HAT0X:
+								if (events[i].value < 0) {
 									STATE[gamepad].bCurrent |= BUTTON_TO_FLAG(BUTTON_DPAD_LEFT);
 									STATE[gamepad].bCurrent &= ~BUTTON_TO_FLAG(BUTTON_DPAD_RIGHT);
-					} else if (je.value == 32767) {
+								} else if (events[i].value > 0) {
 									STATE[gamepad].bCurrent |= BUTTON_TO_FLAG(BUTTON_DPAD_RIGHT);
 									STATE[gamepad].bCurrent &= ~BUTTON_TO_FLAG(BUTTON_DPAD_LEFT);
 								} else {
 									STATE[gamepad].bCurrent &= ~BUTTON_TO_FLAG(BUTTON_DPAD_LEFT) & ~BUTTON_TO_FLAG(BUTTON_DPAD_RIGHT);
 								}
 								break;
-				case 7:
+							case ABS_HAT0Y:
-					if (je.value == -32767) {
+								if (events[i].value < 0) {
 									STATE[gamepad].bCurrent |= BUTTON_TO_FLAG(BUTTON_DPAD_UP);
 									STATE[gamepad].bCurrent &= ~BUTTON_TO_FLAG(BUTTON_DPAD_DOWN);
-					} else if (je.value == 32767) {
+								} else if (events[i].value > 0) {
 									STATE[gamepad].bCurrent |= BUTTON_TO_FLAG(BUTTON_DPAD_DOWN);
 									STATE[gamepad].bCurrent &= ~BUTTON_TO_FLAG(BUTTON_DPAD_UP);
 								} else {
 									STATE[gamepad].bCurrent &= ~BUTTON_TO_FLAG(BUTTON_DPAD_UP) & ~BUTTON_TO_FLAG(BUTTON_DPAD_DOWN);
 								}
 								break;
-				default: break;
 						}
-
+						break;
+					default:
+						//printf("EV_ABS %i %i\n", code, events[i].value);
+						if (code == ABS_Z || code == ABS_RZ) {
+							int value = adjust_values_trigger(STATE[gamepad].axis_min[code], STATE[gamepad].axis_max[code], events[i].value);
+							switch(code) {
+								case ABS_Z :	STATE[gamepad].trigger[TRIGGER_LEFT].value = value; break;
+								case ABS_RZ:	STATE[gamepad].trigger[TRIGGER_RIGHT].value = value; break;
+							}
+						} else {
+							int value = adjust_values_stick(STATE[gamepad].axis_min[code], STATE[gamepad].axis_max[code], events[i].value);
+							switch(code) {
+								case ABS_X :	STATE[gamepad].stick[STICK_LEFT].x = value; break;
+								case ABS_Y :	STATE[gamepad].stick[STICK_LEFT].y = -value; break;
+								case ABS_RX:	STATE[gamepad].stick[STICK_RIGHT].x = value; break;
+								case ABS_RY:	STATE[gamepad].stick[STICK_RIGHT].y = -value; break;
+							}
+						}
+						break;
+					}
+					break;
+				case EV_REL:
+					switch (code) {
+					case REL_X:
+					case REL_Y:
+						code -= REL_X;
+						//printf("EV_REL %i %i\n", code, events[i].value);
 						break;
 					default:
 						break;
 					}
+					break;
+				case EV_SYN:
+					switch (code) {
+					case SYN_DROPPED :
+						//printf("Event SYN_DROPPED detected\n");
+						break;
+					default:
+						break;
+					}
+				default:
+					break;
+				}
+			}
 		}
 	}
 }
@@ -378,10 +534,6 @@ static void GamepadUpdateDevice(GAMEPAD_DEVICE gamepad) {
 void GamepadShutdown(void) {
 	int i;
 
-	/* cleanup udev */
-	udev_monitor_unref(MON);
-	udev_unref(UDEV);
-
 	/* cleanup devices */
 	for (i = 0; i != GAMEPAD_COUNT; ++i) {
 		if (STATE[i].device != NULL) {
@@ -394,33 +546,17 @@ void GamepadShutdown(void) {
 	}
 }
 
-void GamepadSetRumble(GAMEPAD_DEVICE gamepad, float left, float right) {
+void GamepadSetRumble(GAMEPAD_DEVICE gamepad, float left, float right, unsigned int rumble_length_ms) {
 	if (STATE[gamepad].fd != -1) {
 		struct input_event play;
-
-		/* delete any existing effect */
-		if (STATE[gamepad].effect != -1) {
-			/* stop the effect */
-			play.type = EV_FF;
-			play.code = STATE[gamepad].effect;
-			play.value = 0;
-
-			write(STATE[gamepad].fd, (const void*)&play, sizeof(play));
-
-			/* delete the effect */
-			ioctl(STATE[gamepad].fd, EVIOCRMFF, STATE[gamepad].effect);
-		}
-
-		/* if rumble parameters are non-zero, start the new effect */
-		if (left != 0.f || right != 0.f) {
 		struct ff_effect ff;
 
 		/* define an effect for this rumble setting */
 		ff.type = FF_RUMBLE;
-			ff.id = -1;
+		ff.id = STATE[gamepad].effect;
 		ff.u.rumble.strong_magnitude = (unsigned short)(left * 65535);
 		ff.u.rumble.weak_magnitude = (unsigned short)(right * 65535);
-			ff.replay.length = 5;
+		ff.replay.length = rumble_length_ms;
 		ff.replay.delay = 0;
 
 		/* upload the effect */
@@ -435,7 +571,6 @@ void GamepadSetRumble(GAMEPAD_DEVICE gamepad, float left, float right) {
 
 		write(STATE[gamepad].fd, (const void*)&play, sizeof(play));
 	}
-	}
 }
 
 #else /* !defined(_WIN32) && !defined(__linux__) */

controller/gamepad.h

@@ -232,8 +232,9 @@ GAMEPAD_API GAMEPAD_BOOL GamepadTriggerReleased(GAMEPAD_DEVICE device, GAMEPAD_T
  * \param device The device to update.
  * \param left Left motor strengh (0 to 1).
  * \param right Right motor strengh (0 to 1).
+ * \param rumble_length_ms rumble time in ms (0 = unlimited).
  */
-GAMEPAD_API void GamepadSetRumble(GAMEPAD_DEVICE device, float left, float right);
+GAMEPAD_API void GamepadSetRumble(GAMEPAD_DEVICE device, float left, float right,  unsigned int rumble_length_ms);
 
 /**
  * Query the position of an analog stick as raw values.

dll/base.cpp

@@ -193,6 +193,15 @@ std::string get_lib_path() {
 
 std::string get_full_program_path()
 {
+    std::string env_program_path = get_env_variable("SteamAppPath");
+    if (env_program_path.length()) {
+        if (env_program_path.back() != PATH_SEPARATOR[0]) {
+            env_program_path = env_program_path.append(PATH_SEPARATOR);
+        }
+
+        return env_program_path;
+    }
+
     std::string program_path;
 #if defined(STEAM_WIN32)
     char   DllPath[MAX_PATH] = {0};

dll/defines.h

@@ -2,9 +2,6 @@
 #define CLIENT_HSTEAMUSER 12
 #define SERVER_HSTEAMUSER 13
 
-#define CLIENT_STEAM_PIPE 5
-#define SERVER_STEAM_PIPE 6
-
 #define DEFAULT_NAME "Goldberg"
 #define PROGRAM_NAME "Goldberg SteamEmu"
 #define DEFAULT_LANGUAGE "english"

dll/dll.cpp

@@ -15,6 +15,7 @@
    License along with the Goldberg Emulator; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#define STEAM_API_FUNCTIONS_IMPL
 #include "dll.h"
 
 
@@ -203,14 +204,17 @@ STEAMAPI_API void * S_CALLTYPE SteamInternal_ContextInit( void *pContextInitData
 //steam_api.h
 // SteamAPI_Init must be called before using any other API functions. If it fails, an
 // error message will be output to the debugger (or stderr) with further information.
+static HSteamPipe user_steam_pipe;
 STEAMAPI_API bool S_CALLTYPE SteamAPI_Init()
 {
     PRINT_DEBUG("SteamAPI_Init called\n");
+    if (user_steam_pipe) return true;
 #ifdef EMU_EXPERIMENTAL_BUILD
     crack_SteamAPI_Init();
 #endif
     load_old_interface_versions();
-    get_steam_client()->userLogIn();
+    user_steam_pipe = get_steam_client()->CreateSteamPipe();
+    get_steam_client()->ConnectToGlobalUser(user_steam_pipe);
     return true;
 }
 
@@ -226,6 +230,8 @@ STEAMAPI_API void S_CALLTYPE SteamAPI_Shutdown()
 {
     PRINT_DEBUG("SteamAPI_Shutdown\n");
     get_steam_client()->clientShutdown();
+    get_steam_client()->BReleaseSteamPipe(user_steam_pipe);
+    user_steam_pipe = 0;
 }
 
 // SteamAPI_RestartAppIfNecessary ensures that your executable was launched through Steam.
@@ -416,8 +422,7 @@ STEAMAPI_API const char *SteamAPI_GetSteamInstallPath()
 STEAMAPI_API HSteamPipe SteamAPI_GetHSteamPipe()
 {
     PRINT_DEBUG("SteamAPI_GetHSteamPipe\n");
-    if (!get_steam_client()->user_logged_in) return 0;
+    return user_steam_pipe;
-    return CLIENT_STEAM_PIPE;
 }
 
 // sets whether or not Steam_RunCallbacks() should do a try {} catch (...) {} around calls to issuing callbacks
@@ -484,11 +489,11 @@ STEAMAPI_API void * S_CALLTYPE SteamGameServerInternal_CreateInterface( const ch
     return SteamInternal_CreateInterface(ver);
 }
 
+static HSteamPipe server_steam_pipe;
 STEAMAPI_API HSteamPipe S_CALLTYPE SteamGameServer_GetHSteamPipe()
 {
     PRINT_DEBUG("SteamGameServer_GetHSteamPipe\n");
-    if (!get_steam_client()->server_init) return 0;
+    return server_steam_pipe;
-    return SERVER_STEAM_PIPE;
 }
 
 STEAMAPI_API HSteamUser S_CALLTYPE SteamGameServer_GetHSteamUser()
@@ -533,10 +538,12 @@ STEAMAPI_API bool S_CALLTYPE SteamInternal_GameServer_Init( uint32 unIP, uint16
 {
     PRINT_DEBUG("SteamInternal_GameServer_Init %u %hu %hu %hu %u %s\n", unIP, usPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
     load_old_interface_versions();
-    get_steam_client()->serverInit();
+    get_steam_client()->CreateLocalUser(&server_steam_pipe, k_EAccountTypeGameServer);
     //g_pSteamClientGameServer is only used in pre 1.37 (where the interface versions are not provided by the game)
     g_pSteamClientGameServer = SteamGameServerClient();
-    return get_steam_client()->steam_gameserver->InitGameServer(unIP, usGamePort, usQueryPort, eServerMode, 0, pchVersionString);
+    uint32 unFlags = 0;
+    if (eServerMode == eServerModeAuthenticationAndSecure) unFlags = k_unServerFlagSecure;
+    return get_steam_client()->steam_gameserver->InitGameServer(unIP, usGamePort, usQueryPort, unFlags, 0, pchVersionString);
 }
 
 //SteamGameServer004 and before:
@@ -575,7 +582,9 @@ STEAMAPI_API bool SteamGameServer_Init( uint32 unIP, uint16 usSteamPort, uint16
 STEAMAPI_API void SteamGameServer_Shutdown()
 {
     PRINT_DEBUG("SteamGameServer_Shutdown\n");
-    get_steam_clientserver_old()->serverShutdown();
+    get_steam_client()->serverShutdown();
+    get_steam_client()->BReleaseSteamPipe(server_steam_pipe);
+    server_steam_pipe = 0;
     g_pSteamClientGameServer = NULL; //TODO: check if this actually gets nulled when SteamGameServer_Shutdown is called
 }
 
@@ -752,15 +761,26 @@ STEAMCLIENT_API bool Steam_BGetCallback( HSteamPipe hSteamPipe, CallbackMsg_t *p
     PRINT_DEBUG("%s %i\n", __FUNCTION__, hSteamPipe);
     std::queue<struct cb_data> *q = NULL;
     HSteamUser m_hSteamUser = 0;
-    get_steam_client()->callback_results_server->setCbAll(&cb_add_queue_server);
+    Steam_Client *steam_client = get_steam_client();
-    get_steam_client()->callback_results_client->setCbAll(&cb_add_queue_client);
+    steam_client->callback_results_server->setCbAll(&cb_add_queue_server);
-    get_steam_client()->RunCallbacks(true, true);
+    steam_client->callback_results_client->setCbAll(&cb_add_queue_client);
-    if (hSteamPipe == SERVER_STEAM_PIPE) {
+    steam_client->RunCallbacks(true, true);
+    if (!steam_client->steamclient_server_inited) {
+        while(!server_cb.empty()) server_cb.pop();
+    }
+
+    if (!steam_client->steam_pipes.count(hSteamPipe)) {
+        return false;
+    }
+
+    if (steam_client->steam_pipes[hSteamPipe] == Steam_Pipe::SERVER) {
         q = &server_cb;
         m_hSteamUser = SERVER_HSTEAMUSER;
-    } else {
+    } else if (steam_client->steam_pipes[hSteamPipe] == Steam_Pipe::CLIENT) {
         q = &client_cb;
         m_hSteamUser = CLIENT_HSTEAMUSER;
+    } else {
+        return false;
     }
 
     if (q->empty()) return false;
@@ -780,10 +800,17 @@ STEAMCLIENT_API void Steam_FreeLastCallback( HSteamPipe hSteamPipe )
 {
     PRINT_DEBUG("%s %i\n", __FUNCTION__, hSteamPipe);
     std::queue<struct cb_data> *q = NULL;
-    if (hSteamPipe == SERVER_STEAM_PIPE) {
+    Steam_Client *steam_client = get_steam_client();
+    if (!steam_client->steam_pipes.count(hSteamPipe)) {
+        return;
+    }
+
+    if (steam_client->steam_pipes[hSteamPipe] == Steam_Pipe::SERVER) {
         q = &server_cb;
-    } else {
+    } else if (steam_client->steam_pipes[hSteamPipe] == Steam_Pipe::CLIENT) {
         q = &client_cb;
+    } else {
+        return;
     }
 
     if (!q->empty()) q->pop();
@@ -792,11 +819,17 @@ STEAMCLIENT_API void Steam_FreeLastCallback( HSteamPipe hSteamPipe )
 STEAMCLIENT_API bool Steam_GetAPICallResult( HSteamPipe hSteamPipe, SteamAPICall_t hSteamAPICall, void* pCallback, int cubCallback, int iCallbackExpected, bool* pbFailed )
 {
     PRINT_DEBUG("Steam_GetAPICallResult %i %llu %i %i\n", hSteamPipe, hSteamAPICall, cubCallback, iCallbackExpected);
-    if (!hSteamPipe) return false;
+    Steam_Client *steam_client = get_steam_client();
-    if (hSteamPipe == SERVER_STEAM_PIPE) {
+    if (!steam_client->steam_pipes.count(hSteamPipe)) {
+        return false;
+    }
+
+    if (steam_client->steam_pipes[hSteamPipe] == Steam_Pipe::SERVER) {
         return get_steam_client()->steam_gameserver_utils->GetAPICallResult(hSteamAPICall, pCallback, cubCallback, iCallbackExpected, pbFailed);
-    } else {
+    } else if (steam_client->steam_pipes[hSteamPipe] == Steam_Pipe::CLIENT) {
         return get_steam_client()->steam_utils->GetAPICallResult(hSteamAPICall, pCallback, cubCallback, iCallbackExpected, pbFailed);
+    } else {
+        return false;
     }
 }
 

dll/steam_client.cpp

@@ -18,20 +18,25 @@
 #include "steam_client.h"
 #include "settings_parser.h"
 
+#include <condition_variable>
 
+static std::condition_variable kill_background_thread_cv;
+static std::atomic_bool kill_background_thread;
 static void background_thread(Steam_Client *client)
 {
     PRINT_DEBUG("background thread starting\n");
+    std::mutex mtx;
+    std::unique_lock<std::mutex> lck(mtx);
+
     while (1) {
-        std::this_thread::sleep_for(std::chrono::seconds(1));
+        if (kill_background_thread || kill_background_thread_cv.wait_for(lck, std::chrono::seconds(1)) != std::cv_status::timeout) {
-        global_mutex.lock();
+            if (kill_background_thread) {
-        if (!client->network->isAlive()) {
-            global_mutex.unlock();
-            //delete network;
                 PRINT_DEBUG("background thread exit\n");
                 return;
             }
+        }
 
+        global_mutex.lock();
         PRINT_DEBUG("background thread run\n");
         client->network->Run();
         client->steam_matchmaking->RunBackground();
@@ -154,15 +159,24 @@ void Steam_Client::setAppID(uint32 appid)
 HSteamPipe Steam_Client::CreateSteamPipe()
 {
     PRINT_DEBUG("CreateSteamPipe\n");
-    return CLIENT_STEAM_PIPE;
+    HSteamPipe pipe = steam_pipe_counter++;
+    PRINT_DEBUG("creating pipe %i\n", pipe);
+
+    steam_pipes[pipe] = Steam_Pipe::NO_USER;
+    return pipe;
 }
 
 // Releases a previously created communications pipe
 // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
 bool Steam_Client::BReleaseSteamPipe( HSteamPipe hSteamPipe )
 {
-    PRINT_DEBUG("BReleaseSteamPipe\n");
+    PRINT_DEBUG("BReleaseSteamPipe %i\n", hSteamPipe);
+    if (steam_pipes.count(hSteamPipe)) {
+        steam_pipes.erase(hSteamPipe);
         return true;
+    }
+
+    return false;
 }
 
 // connects to an existing global user, failing if none exists
@@ -170,7 +184,13 @@ bool Steam_Client::BReleaseSteamPipe( HSteamPipe hSteamPipe )
 // NOT THREADSAFE - ensure that no other threads are accessing Steamworks API when calling
 HSteamUser Steam_Client::ConnectToGlobalUser( HSteamPipe hSteamPipe )
 {
-    PRINT_DEBUG("ConnectToGlobalUser\n");
+    PRINT_DEBUG("ConnectToGlobalUser %i\n", hSteamPipe);
+    if (!steam_pipes.count(hSteamPipe)) {
+        return 0;
+    }
+
+    userLogIn();
+    steam_pipes[hSteamPipe] = Steam_Pipe::CLIENT;
     return CLIENT_HSTEAMUSER;
 }
 
@@ -179,13 +199,19 @@ HSteamUser Steam_Client::ConnectToGlobalUser( HSteamPipe hSteamPipe )
 HSteamUser Steam_Client::CreateLocalUser( HSteamPipe *phSteamPipe, EAccountType eAccountType )
 {
     PRINT_DEBUG("CreateLocalUser %p %i\n", phSteamPipe, eAccountType);
-    if (eAccountType == k_EAccountTypeIndividual) {
+    //if (eAccountType == k_EAccountTypeIndividual) {
-        if (phSteamPipe) *phSteamPipe = CLIENT_STEAM_PIPE;
+        //Is this actually used?
-        return CLIENT_HSTEAMUSER;
+        //if (phSteamPipe) *phSteamPipe = CLIENT_STEAM_PIPE;
-    } else {
+        //return CLIENT_HSTEAMUSER;
-        if (phSteamPipe) *phSteamPipe = SERVER_STEAM_PIPE;
+    //} else { //k_EAccountTypeGameServer
+    serverInit();
+
+    HSteamPipe pipe = CreateSteamPipe();
+    if (phSteamPipe) *phSteamPipe = pipe;
+    steam_pipes[pipe] = Steam_Pipe::SERVER;
+    steamclient_server_inited = true;
     return SERVER_HSTEAMUSER;
-    }
+    //}
 }
 
 HSteamUser Steam_Client::CreateLocalUser( HSteamPipe *phSteamPipe )
@@ -198,13 +224,16 @@ HSteamUser Steam_Client::CreateLocalUser( HSteamPipe *phSteamPipe )
 void Steam_Client::ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser )
 {
     PRINT_DEBUG("ReleaseUser\n");
+    if (hUser == SERVER_HSTEAMUSER && steam_pipes.count(hSteamPipe)) {
+        steamclient_server_inited = false;
+    }
 }
 
 // retrieves the ISteamUser interface associated with the handle
 ISteamUser *Steam_Client::GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamUser %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
     if (strcmp(pchVersion, "SteamUser009") == 0) {
         return (ISteamUser *)(void *)(ISteamUser009 *)steam_user;
@@ -241,7 +270,7 @@ ISteamUser *Steam_Client::GetISteamUser( HSteamUser hSteamUser, HSteamPipe hStea
 ISteamGameServer *Steam_Client::GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamGameServer %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
     if (strcmp(pchVersion, "SteamGameServer005") == 0) {
         return (ISteamGameServer *)(void *)(ISteamGameServer005 *)steam_gameserver;
@@ -284,7 +313,7 @@ void Steam_Client::SetLocalIPBinding( const SteamIPAddress_t &unIP, uint16 usPor
 ISteamFriends *Steam_Client::GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamFriends %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
     if (strcmp(pchVersion, "SteamFriends004") == 0) {
         return (ISteamFriends *)(void *)(ISteamFriends004 *)steam_friends;
@@ -325,11 +354,11 @@ ISteamFriends *Steam_Client::GetISteamFriends( HSteamUser hSteamUser, HSteamPipe
 ISteamUtils *Steam_Client::GetISteamUtils( HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamUtils %s\n", pchVersion);
-    if (!hSteamPipe) return NULL;
+    if (!steam_pipes.count(hSteamPipe)) return NULL;
 
     Steam_Utils *steam_utils_temp;
 
-    if (hSteamPipe == SERVER_STEAM_PIPE) {
+    if (steam_pipes[hSteamPipe] == Steam_Pipe::SERVER) {
         steam_utils_temp = steam_gameserver_utils;
     } else {
         steam_utils_temp = steam_utils;
@@ -362,7 +391,7 @@ ISteamUtils *Steam_Client::GetISteamUtils( HSteamPipe hSteamPipe, const char *pc
 ISteamMatchmaking *Steam_Client::GetISteamMatchmaking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamMatchmaking %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
     if (strcmp(pchVersion, "SteamMatchMaking001") == 0) {
         //TODO
@@ -399,7 +428,7 @@ ISteamMatchmaking *Steam_Client::GetISteamMatchmaking( HSteamUser hSteamUser, HS
 ISteamMatchmakingServers *Steam_Client::GetISteamMatchmakingServers( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamMatchmakingServers %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
     return steam_matchmaking_servers;
 }
 
@@ -407,7 +436,7 @@ ISteamMatchmakingServers *Steam_Client::GetISteamMatchmakingServers( HSteamUser
 void *Steam_Client::GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamGenericInterface %s\n", pchVersion);
-    if (!hSteamPipe) return NULL;
+    if (!steam_pipes.count(hSteamPipe)) return NULL;
 
     bool server = false;
     if (hSteamUser == SERVER_HSTEAMUSER) {
@@ -536,7 +565,7 @@ void *Steam_Client::GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe
 ISteamUserStats *Steam_Client::GetISteamUserStats( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamUserStats %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
     if (strcmp(pchVersion, "STEAMUSERSTATS_INTERFACE_VERSION001") == 0) {
         //TODO
@@ -573,7 +602,7 @@ ISteamUserStats *Steam_Client::GetISteamUserStats( HSteamUser hSteamUser, HSteam
 ISteamGameServerStats *Steam_Client::GetISteamGameServerStats( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamGameServerStats %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
     return steam_gameserverstats;
 }
 
@@ -581,7 +610,7 @@ ISteamGameServerStats *Steam_Client::GetISteamGameServerStats( HSteamUser hSteam
 ISteamApps *Steam_Client::GetISteamApps( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamApps %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
     if (hSteamUser == SERVER_HSTEAMUSER) {
         return steam_gameserver_apps;
     }
@@ -593,7 +622,7 @@ ISteamApps *Steam_Client::GetISteamApps( HSteamUser hSteamUser, HSteamPipe hStea
 ISteamNetworking *Steam_Client::GetISteamNetworking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamNetworking %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
     Steam_Networking *steam_networking_temp;
 
@@ -626,7 +655,7 @@ ISteamNetworking *Steam_Client::GetISteamNetworking( HSteamUser hSteamUser, HSte
 ISteamRemoteStorage *Steam_Client::GetISteamRemoteStorage( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamRemoteStorage %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
 
     if (strcmp(pchVersion, "STEAMREMOTESTORAGE_INTERFACE_VERSION001") == 0) {
         return (ISteamRemoteStorage *)(void *)(ISteamRemoteStorage001 *)steam_remote_storage;
@@ -667,7 +696,7 @@ ISteamRemoteStorage *Steam_Client::GetISteamRemoteStorage( HSteamUser hSteamuser
 ISteamScreenshots *Steam_Client::GetISteamScreenshots( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamScreenshots %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
     return steam_screenshots;
 }
 
@@ -701,14 +730,25 @@ void Steam_Client::SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction
 bool Steam_Client::BShutdownIfAllPipesClosed()
 {
     PRINT_DEBUG("BShutdownIfAllPipesClosed\n");
+    if (!steam_pipes.size()) {
+        if (background_keepalive.joinable()) {
+            kill_background_thread = true;
+            kill_background_thread_cv.notify_one();
+            background_keepalive.join();
+        }
+
+        PRINT_DEBUG("all pipes closed\n");
         return true;
+    }
+
+    return false;
 }
 
 // Expose HTTP interface
 ISteamHTTP *Steam_Client::GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamHTTP %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
     if (hSteamuser == SERVER_HSTEAMUSER) {
         return steam_gameserver_http;
     }
@@ -720,14 +760,14 @@ ISteamHTTP *Steam_Client::GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hStea
 void *Steam_Client::DEPRECATED_GetISteamUnifiedMessages( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) 
 {
     PRINT_DEBUG("DEPRECATED_GetISteamUnifiedMessages %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
     return (void *)(ISteamUnifiedMessages *)steam_unified_messages;
 }
 
 ISteamUnifiedMessages *Steam_Client::GetISteamUnifiedMessages( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamUnifiedMessages %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
     return steam_unified_messages;
 }
 
@@ -735,7 +775,7 @@ ISteamUnifiedMessages *Steam_Client::GetISteamUnifiedMessages( HSteamUser hSteam
 ISteamController *Steam_Client::GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamController %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
     if (strcmp(pchVersion, "STEAMCONTROLLER_INTERFACE_VERSION") == 0) {
         return (ISteamController *)(void *)(ISteamController001 *)steam_controller;
@@ -763,7 +803,7 @@ ISteamController *Steam_Client::GetISteamController( HSteamUser hSteamUser, HSte
 ISteamUGC *Steam_Client::GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamUGC %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
     Steam_UGC *steam_ugc_temp;
 
     if (hSteamUser == SERVER_HSTEAMUSER) {
@@ -815,7 +855,7 @@ ISteamUGC *Steam_Client::GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamP
 ISteamAppList *Steam_Client::GetISteamAppList( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamAppList %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
     return steam_applist;
 }
 
@@ -823,7 +863,7 @@ ISteamAppList *Steam_Client::GetISteamAppList( HSteamUser hSteamUser, HSteamPipe
 ISteamMusic *Steam_Client::GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamMusic %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
     return steam_music;
 }
 
@@ -831,7 +871,7 @@ ISteamMusic *Steam_Client::GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSt
 ISteamMusicRemote *Steam_Client::GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion)
 {
     PRINT_DEBUG("GetISteamMusicRemote %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
     return steam_musicremote;
 }
 
@@ -839,7 +879,7 @@ ISteamMusicRemote *Steam_Client::GetISteamMusicRemote(HSteamUser hSteamuser, HSt
 ISteamHTMLSurface *Steam_Client::GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion)
 {
     PRINT_DEBUG("GetISteamHTMLSurface %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
 
     if (strcmp(pchVersion, "STEAMHTMLSURFACE_INTERFACE_VERSION_001") == 0) {
         return (ISteamHTMLSurface *)(void *)(ISteamHTMLSurface001 *)steam_HTMLsurface;
@@ -888,7 +928,7 @@ void Steam_Client::Remove_SteamAPI_CPostAPIResultInProcess( SteamAPI_PostAPIResu
 ISteamInventory *Steam_Client::GetISteamInventory( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamInventory %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
     Steam_Inventory *steam_inventory_temp;
     Settings *settings_temp;
     SteamCallBacks *callbacks_temp;
@@ -917,7 +957,7 @@ ISteamInventory *Steam_Client::GetISteamInventory( HSteamUser hSteamuser, HSteam
 ISteamVideo *Steam_Client::GetISteamVideo( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamVideo %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
     return steam_video;
 }
 
@@ -925,21 +965,21 @@ ISteamVideo *Steam_Client::GetISteamVideo( HSteamUser hSteamuser, HSteamPipe hSt
 ISteamParentalSettings *Steam_Client::GetISteamParentalSettings( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamParentalSettings %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
     return steam_parental;
 }
 
 ISteamMasterServerUpdater *Steam_Client::GetISteamMasterServerUpdater( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamMasterServerUpdater %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
     return steam_masterserver_updater;
 }
 
 ISteamContentServer *Steam_Client::GetISteamContentServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamContentServer %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
     return NULL;
 }
 
@@ -947,7 +987,7 @@ ISteamContentServer *Steam_Client::GetISteamContentServer( HSteamUser hSteamUser
 ISteamGameSearch *Steam_Client::GetISteamGameSearch( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamGameSearch %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamuser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamuser) return NULL;
 
     return steam_game_search;
 }
@@ -956,7 +996,7 @@ ISteamGameSearch *Steam_Client::GetISteamGameSearch( HSteamUser hSteamuser, HSte
 ISteamInput *Steam_Client::GetISteamInput( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamInput %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
     return steam_controller;
 }
@@ -965,7 +1005,7 @@ ISteamInput *Steam_Client::GetISteamInput( HSteamUser hSteamUser, HSteamPipe hSt
 ISteamParties *Steam_Client::GetISteamParties( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamParties %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
     return steam_parties;
 }
@@ -973,7 +1013,7 @@ ISteamParties *Steam_Client::GetISteamParties( HSteamUser hSteamUser, HSteamPipe
 ISteamRemotePlay *Steam_Client::GetISteamRemotePlay( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion )
 {
     PRINT_DEBUG("GetISteamRemotePlay %s\n", pchVersion);
-    if (!hSteamPipe || !hSteamUser) return NULL;
+    if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
     return steam_remoteplay;
 }

dll/steam_client.h

@@ -55,6 +55,12 @@
 
 #include <thread>
 
+enum Steam_Pipe {
+    NO_USER,
+    CLIENT,
+    SERVER
+};
+
 class Steam_Client :
 public ISteamClient007,
 public ISteamClient008,
@@ -124,6 +130,10 @@ public:
     bool user_logged_in = false;
     bool server_init = false;
     std::thread background_keepalive;
+    bool steamclient_server_inited = false;
+
+    unsigned steam_pipe_counter = 2;
+    std::map<HSteamPipe, enum Steam_Pipe> steam_pipes;
 
     Steam_Client();
     ~Steam_Client();

dll/steam_controller.h

@@ -661,8 +661,8 @@ int GetAnalogActionOrigins( InputHandle_t inputHandle, InputActionSetHandle_t ac
     if (a == map->second.active_analog.end()) return 0;
 
     int count = 0;
-    for (auto a: a->second.first) {
+    for (auto b: a->second.first) {
-        switch (a) {
+        switch (b) {
             case TRIGGER_LEFT:
                 originsOut[count] = k_EInputActionOrigin_XBox360_LeftTrigger_Pull;
                 break;
@@ -692,7 +692,7 @@ int GetAnalogActionOrigins( InputHandle_t inputHandle, InputActionSetHandle_t ac
     
 void StopAnalogActionMomentum( ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction )
 {
-    PRINT_DEBUG("Steam_Controller::StopAnalogActionMomentum\n");
+    PRINT_DEBUG("Steam_Controller::StopAnalogActionMomentum %llu %llu\n", controllerHandle, eAction);
 }
 
 
@@ -723,7 +723,12 @@ void TriggerVibration( ControllerHandle_t controllerHandle, unsigned short usLef
     auto controller = controllers.find(controllerHandle);
     if (controller == controllers.end()) return;
 
-    GamepadSetRumble((GAMEPAD_DEVICE)(controllerHandle - 1), ((double)usLeftSpeed) / 65535.0, ((double)usRightSpeed) / 65535.0);
+    unsigned int rumble_length_ms = 0;
+#if defined(__linux__)
+    //FIXME: shadow of the tomb raider on linux doesn't seem to turn off the rumble so I made it expire after 100ms. Need to check if this is how linux steam actually behaves.
+    rumble_length_ms = 100;
+#endif
+    GamepadSetRumble((GAMEPAD_DEVICE)(controllerHandle - 1), ((double)usLeftSpeed) / 65535.0, ((double)usRightSpeed) / 65535.0, rumble_length_ms);
 }
 
 

dll/steam_gameserver.cpp

@@ -177,7 +177,7 @@ bool Steam_GameServer::BSecure()
     PRINT_DEBUG("BSecure\n");
     std::lock_guard<std::recursive_mutex> lock(global_mutex);
     if (!policy_response_called) return false;
-    return flags == eServerModeAuthenticationAndSecure;
+    return !!(flags & k_unServerFlagSecure);
 }
  
 CSteamID Steam_GameServer::GetSteamID()
@@ -414,6 +414,7 @@ bool Steam_GameServer::BSetServerType( uint32 unServerFlags, uint32 unGameIP, ui
     version.erase(std::remove(version.begin(), version.end(), ' '), version.end());
     version.erase(std::remove(version.begin(), version.end(), '.'), version.end());
     server_data.set_version(stoi(version));
+    flags = unServerFlags;
 
     //TODO?
     return true;
@@ -662,7 +663,7 @@ void Steam_GameServer::RunCallbacks()
     if (logged_in && !policy_response_called) {
         PRINT_DEBUG("Steam_GameServer::GSPolicyResponse_t\n");
         GSPolicyResponse_t data;
-        data.m_bSecure = flags == eServerModeAuthenticationAndSecure;
+        data.m_bSecure = !!(flags & k_unServerFlagSecure);
         callbacks->addCBResult(data.k_iCallback, &data, sizeof(data), 0.11);
         policy_response_called = true;
     }

dll/wrap.cpp

@@ -15,6 +15,8 @@
    License along with the Goldberg Emulator; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#define STEAM_API_FUNCTIONS_IMPL
+#include "base.h"
 #include "dll.h"
 
 #ifdef STEAM_WIN32
@@ -32,39 +34,266 @@
 #include <unistd.h>
 #include <utime.h>
 
-STEAMAPI_API FILE *__wrap_freopen(const char *pathname, const char *mode, FILE *stream)
+#define PATH_SEPARATOR_CHAR '/'
+#define STEAM_PATH_CACHE_SIZE 4096
+
+const char *STEAM_PATH;
+size_t STEAM_PATH_SIZE;
+
+const char *get_steam_path()
 {
-  return freopen(pathname, mode, stream);
+    char *home_path = getenv("HOME");
+    char steam_path[STEAM_PATH_CACHE_SIZE];
+    char *steam_realpath = nullptr;
+
+    // Build steam_path from home
+    int required_size = snprintf(steam_path, STEAM_PATH_CACHE_SIZE, "%s/.steam/steam", home_path);
+
+    // Allocate more space for steam_path if needed (required_size does not count terminator)
+    if (required_size > 0 && required_size >= STEAM_PATH_CACHE_SIZE) {
+        char *large_steam_path = (char *)malloc(sizeof(char) * (required_size + 1));
+        int check_size = snprintf(steam_path, required_size + 1, "%s/.steam/steam", home_path);
+        // Check that path fits this time
+        if (check_size == required_size) {
+            steam_realpath = realpath(large_steam_path, nullptr);
+        }
+        free(large_steam_path);
+    } else {
+        steam_realpath = realpath(steam_path, nullptr);
+    }
+
+    // Terminate path with a file separator
+    if (steam_realpath && *steam_realpath) {
+        size_t path_size = strlen(steam_realpath);
+        if (steam_realpath[path_size - 1] != PATH_SEPARATOR_CHAR) {
+            steam_realpath = (char *)realloc(steam_realpath, path_size + 2);
+            steam_realpath[path_size] = PATH_SEPARATOR_CHAR;
+            steam_realpath[path_size + 1] = 0;
+        }
+    } else {
+        // Failsafe to root
+        steam_realpath = strdup("/");
+    }
+
+    return steam_realpath;
 }
 
-STEAMAPI_API FILE *__wrap_fopen(const char *filename, const char *mode)
+
+bool match_path(char *path, int start, bool accept_same_case)
 {
-  return fopen(filename, mode);
+    if (!path[start + 1]) {
+        return true;
+    }
+
+    // Snap to the next separator in path
+    int separator = start + 1;
+    while (path[separator] != PATH_SEPARATOR_CHAR && path[separator]) {
+        separator++;
+    }
+
+    bool is_last_component = path[separator] != PATH_SEPARATOR_CHAR;
+
+    char stored_char = path[separator];
+    path[separator] = 0;
+    bool path_accessible = access(path, 0) == 0;
+    path[separator] = stored_char;
+
+    if (!path_accessible || (!is_last_component && !match_path(path, separator, accept_same_case))) {
+        DIR *current_directory = nullptr;
+        int component = start + 1;
+
+        if (start) {
+            stored_char = path[start];
+            path[start] = 0;
+            current_directory = opendir(path);
+            path[start] = stored_char;
+            component = start + 1;
+        } else {
+            if (*path == PATH_SEPARATOR_CHAR) {
+                component = start + 1;
+                current_directory = opendir("/");
+            } else {
+                component = start;
+                current_directory = opendir(".");
+            }
+        }
+
+        //        0123456789012345678901234567890123456789
+        // path = /this/is/a/sample/path/to/file.txt
+        //                  ^^     ^
+        //                  ab     c
+        // a. start = 10
+        // b. component = 11
+        // c. separator = 17
+        // current_directory = /this/is/a/
+
+        if (current_directory) {
+            dirent64 *entry = (dirent64 *)readdir64(current_directory);
+            while (entry) {
+                const char *entry_name = entry->d_name;
+                stored_char = path[separator];
+                path[separator] = 0;
+
+                // Fix current component if entry with similar name exists
+                if (!strcasecmp(&path[component], entry_name)) {
+                    bool case_differs = strcmp(&path[component], entry_name) != 0;
+                    path[separator] = stored_char;
+                    if (case_differs) {
+                        char *iterator = &path[component];
+                        // Replace with entry name
+                        while (*entry_name != PATH_SEPARATOR_CHAR && *entry_name) {
+                            *(iterator++) = *(entry_name++);
+                        }
+                        // Fix next component
+                        if (is_last_component || match_path(path, separator, accept_same_case)) {
+                            closedir(current_directory);
+                            return true;
+                        }
+                    }
+                } else {
+                    path[separator] = stored_char;
+                }
+                entry = (dirent64 *)readdir64(current_directory);
+            }
+        }
+
+        if (current_directory) {
+            closedir(current_directory);
+        }
+
+        return accept_same_case && is_last_component;
+    }
+
+    return true;
 }
 
-STEAMAPI_API FILE *__wrap_fopen64(const char *filename, const char *mode)
+const char *lowercase_path(const char *path, bool accept_same_case, bool stop_at_separator)
 {
-  return fopen64(filename, mode);
+    std::locale loc;
+    char *path_lowercased = nullptr;
+
+    if (path && *path) {
+        if (access(path, 0)) {
+            // Make a copy of the path on which to work on
+            path_lowercased = strdup(path);
+            if (!path_lowercased) {
+                return nullptr;
+            }
+            // Load steam path if not done already
+            if (!STEAM_PATH) {
+                STEAM_PATH = get_steam_path();
+                STEAM_PATH_SIZE = strlen(STEAM_PATH);
+            }
+
+            char *lowercase_iterator = path_lowercased;
+            // Lowercase whole steam path if possible
+            if (!strncasecmp(path_lowercased, STEAM_PATH, STEAM_PATH_SIZE)) {
+                memcpy(path_lowercased, STEAM_PATH, STEAM_PATH_SIZE);
+                lowercase_iterator = &path_lowercased[STEAM_PATH_SIZE - 1];
+            }
+            // Lowercase rest of the path
+            char *iterator = lowercase_iterator;
+            while ((!stop_at_separator || *iterator != PATH_SEPARATOR_CHAR) && *iterator) {
+                *iterator = std::tolower(*iterator, loc);
+                iterator++;
+            }
+
+            // Check if we can access the lowered-case path
+            int error = access(path_lowercased, 0);
+            if (!error) {
+                // The new path is valid
+                return path_lowercased;
+            } else {
+                if (accept_same_case) {
+                    const char *name_iterator = &path[lowercase_iterator - path_lowercased];
+                    while (*lowercase_iterator) {
+                        *(lowercase_iterator++) = *(name_iterator++);
+                    }
+                }
+                // Retry accesing the file again and tweak the path if needed
+                if (match_path(path_lowercased, STEAM_PATH_SIZE - 1, accept_same_case)) {
+                    return path_lowercased;
+                }
+            }
+        }
+    }
+
+    return path;
 }
 
-STEAMAPI_API int __wrap_open(const char *pathname, int flags, mode_t mode)
+STEAMAPI_API FILE *__wrap_freopen(const char *path, const char *modes, FILE *stream)
 {
-  return open(pathname, flags, mode);
+    bool is_writable = strpbrk(modes, "wa+") != 0;
+    const char *path_lowercased = lowercase_path(path, is_writable, true);
+    FILE *result = freopen(path_lowercased, modes, stream);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
-STEAMAPI_API int __wrap_open64(const char *pathname, int flags, mode_t mode)
+STEAMAPI_API FILE *__wrap_fopen(const char *path, const char *modes)
 {
-  return open64(pathname, flags, mode);
+    bool is_writable = strpbrk(modes, "wa+") != 0;
+    const char *path_lowercased = lowercase_path(path, is_writable, true);
+    FILE *result = fopen(path_lowercased, modes);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
-STEAMAPI_API int __wrap_access(const char *pathname, int mode)
+STEAMAPI_API FILE *__wrap_fopen64(const char *path, const char *modes)
 {
-  return access(pathname, mode);
+    bool is_writable = strpbrk(modes, "wa+") != 0;
+    const char *path_lowercased = lowercase_path(path, is_writable, true);
+    FILE *result = fopen64(path_lowercased, modes);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
+}
+
+STEAMAPI_API int __wrap_open(const char *path, int flags, mode_t mode)
+{
+    bool is_writable = flags & 3;
+    const char *path_lowercased = lowercase_path(path, is_writable, true);
+    int result = open(path_lowercased, flags, mode);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
+}
+
+STEAMAPI_API int __wrap_open64(const char *path, int flags, mode_t mode)
+{
+    bool is_writable = flags & 3;
+    const char *path_lowercased = lowercase_path(path, is_writable, true);
+    int result = open64(path_lowercased, flags, mode);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
+}
+
+STEAMAPI_API int __wrap_access(const char *path, int mode)
+{
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = access(path_lowercased, mode);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap___xstat(int ver, const char * path, struct stat * stat_buf)
 {
-  return __xstat(ver, path, stat_buf);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = __xstat(ver, path_lowercased, stat_buf);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_stat(const char * path, struct stat * stat_buf)
@@ -74,7 +303,12 @@ STEAMAPI_API int __wrap_stat(const char * path, struct stat * stat_buf)
 
 STEAMAPI_API int __wrap___lxstat(int ver, const char * path, struct stat * stat_buf)
 {
-  return __lxstat(ver, path, stat_buf);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = __lxstat(ver, path_lowercased, stat_buf);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_lstat(const char * path, struct stat * stat_buf)
@@ -82,119 +316,250 @@ STEAMAPI_API int __wrap_lstat(const char * path, struct stat * stat_buf)
     return __wrap___lxstat(3, path, stat_buf);
 }
 
-STEAMAPI_API int __wrap_scandir(const char *dir, struct dirent ***namelist, int (*sel)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **))
+STEAMAPI_API int __wrap_scandir(const char *path, struct dirent ***namelist, int (*sel)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **))
 {
-  return scandir(dir, namelist, sel, compar);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = scandir(path_lowercased, namelist, sel, compar);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
-STEAMAPI_API int __wrap_scandir64(const char *dir, struct dirent64 ***namelist, int (*sel)(const struct dirent64 *), int (*compar)(const struct dirent64 **, const struct dirent64 **))
+STEAMAPI_API int __wrap_scandir64(const char *path, struct dirent64 ***namelist, int (*sel)(const struct dirent64 *), int (*compar)(const struct dirent64 **, const struct dirent64 **))
 {
-  return scandir64(dir, namelist, sel, compar);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = scandir64(path_lowercased, namelist, sel, compar);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
-STEAMAPI_API DIR *__wrap_opendir(const char *name)
+STEAMAPI_API DIR *__wrap_opendir(const char *path)
 {
-  return opendir(name);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    DIR *result = opendir(path_lowercased);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
-STEAMAPI_API int __wrap___xstat64(int vers, const char *name, struct stat64 *buf)
+STEAMAPI_API int __wrap___xstat64(int ver, const char *path, struct stat64 *stat_buf)
 {
-  return __xstat64(vers, name, buf);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = __xstat64(ver, path_lowercased, stat_buf);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
-STEAMAPI_API int __wrap___lxstat64(int vers, const char *name, struct stat64 *buf)
+STEAMAPI_API int __wrap___lxstat64(int ver, const char *path, struct stat64 *stat_buf)
 {
-  return __lxstat64(vers, name, buf);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = __lxstat64(ver, path_lowercased, stat_buf);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_statvfs(const char *path, struct statvfs *buf)
 {
-  return statvfs(path, buf);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = statvfs(path_lowercased, buf);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_statvfs64(const char *path, struct statvfs64 *buf)
 {
-  return statvfs64(path, buf);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = statvfs64(path_lowercased, buf);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
-STEAMAPI_API int __wrap_chmod(const char *pathname, mode_t mode)
+STEAMAPI_API int __wrap_chmod(const char *path, mode_t mode)
 {
-  return chmod(pathname, mode);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = chmod(path_lowercased, mode);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_chown(const char *path, uid_t owner, gid_t group)
 {
-  return chown(path, owner, group);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = chown(path_lowercased, owner, group);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_lchown(const char *path, uid_t owner, gid_t group)
 {
-  return lchown(path, owner, group);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = lchown(path_lowercased, owner, group);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_symlink(const char *path1, const char *path2)
 {
-  return symlink(path1, path2);
+    const char *path_lowercased1 = lowercase_path(path1, true, true);
+    const char *path_lowercased2 = lowercase_path(path2, false, false);
+    int result = symlink(path_lowercased1, path_lowercased2);
+    if (path_lowercased1 != path1) {
+        free((void *)path_lowercased1);
+    }
+    if (path_lowercased2 != path2) {
+        free((void *)path_lowercased2);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_link(const char *path1, const char *path2)
 {
-  return link(path1, path2);
+    const char *path_lowercased1 = lowercase_path(path1, true, true);
+    const char *path_lowercased2 = lowercase_path(path2, false, false);
+    int result = link(path_lowercased1, path_lowercased2);
+    if (path_lowercased1 != path1) {
+        free((void *)path_lowercased1);
+    }
+    if (path_lowercased2 != path2) {
+        free((void *)path_lowercased2);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_mknod(const char *path, mode_t mode, dev_t dev)
 {
-  return __xmknod(1, path, mode, &dev);
+    const char *path_lowercased = lowercase_path(path, true, true);
+    int result = __xmknod(1, path_lowercased, mode, &dev);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_mount(const char *source, const char *target, const char *filesystemtype, unsigned long mountflags, const void *data)
 {
-  return mount(source, target, filesystemtype, mountflags, data);
+    const char *source_lowercased = lowercase_path(source, false, false);
+    const char *target_lowercased = lowercase_path(target, false, false);
+    int result = mount(source_lowercased, target_lowercased, filesystemtype, mountflags, data);
+    if (source_lowercased != source) {
+        free((void *)source_lowercased);
+    }
+    if (target_lowercased != target) {
+        free((void *)target_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_unlink(const char *path)
 {
-  return unlink(path);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = unlink(path);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_mkfifo(const char *path, mode_t mode)
 {
-  return mkfifo(path, mode);
+    const char *path_lowercased = lowercase_path(path, true, true);
+    int result = mkfifo(path, mode);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_rename(const char *old_name, const char *new_name)
 {
-  return rename(old_name, new_name);
+    const char *old_name_lowercased = lowercase_path(old_name, true, true);
+    const char *new_name_lowercased = lowercase_path(new_name, false, false);
+    int result = rename(old_name_lowercased, new_name_lowercased);
+    if (old_name_lowercased != old_name) {
+        free((void *)old_name_lowercased);
+    }
+    if (new_name_lowercased != new_name) {
+        free((void *)new_name_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_utime(const char *path, const struct utimbuf *times)
 {
-  return utime(path, times);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = utime(path_lowercased, times);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_utimes(const char *path, const struct timeval times[2])
 {
-  return utimes(path, times);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = utimes(path_lowercased, times);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_mkdir(const char *path, mode_t mode)
 {
-  return mkdir(path, mode);
+    const char *path_lowercased = lowercase_path(path, true, true);
+    int result = mkdir(path_lowercased, mode);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 STEAMAPI_API int __wrap_rmdir(const char *path)
 {
-  return rmdir(path);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    int result = rmdir(path_lowercased);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
-STEAMAPI_API void * __wrap_dlopen(const char *file, int mode)
+STEAMAPI_API void *__wrap_dlopen(const char *path, int mode)
 {
-  return dlopen(file, mode);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    void * result = dlopen(path_lowercased, mode);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
-STEAMAPI_API void * __wrap_dlmopen(Lmid_t lmid, const char *filename, int flags)
+STEAMAPI_API void *__wrap_dlmopen(Lmid_t lmid, const char *path, int flags)
 {
-  return dlmopen(lmid, filename, flags);
+    const char *path_lowercased = lowercase_path(path, false, false);
+    void * result = dlmopen(lmid, path_lowercased, flags);
+    if (path_lowercased != path) {
+        free((void *)path_lowercased);
+    }
+    return result;
 }
 
 #endif

scripts/steamclient_loader.sh

@@ -1,8 +1,13 @@
 #!/bin/bash
-APP_PATH=./example_executable
+APP_NAME="bin/test_executable"
 APP_ID=480
+APP_PATH=$(dirname "$0")
+CONFIG_PATH=$(dirname "$0")
+#path to steam-runtime/run.sh
+STEAM_RUNTIME=""
 
-set -e
+CUR_DIR=$(pwd)
+cd "$CONFIG_PATH"
 mkdir -p ~/.steam/sdk64
 mkdir -p ~/.steam/sdk32
 #make a backup of original files
@@ -13,8 +18,15 @@ mv ~/.steam/sdk32/steamclient.so ~/.steam/sdk32/steamclient.so.orig || true
 cp x86/steamclient.so ~/.steam/sdk32/steamclient.so
 cp x86_64/steamclient.so ~/.steam/sdk64/steamclient.so
 echo $BASHPID > ~/.steam/steam.pid
-SteamAppId=$APP_ID SteamGameId=$APP_ID $APP_PATH
+cd "$APP_PATH"
+if [ -z "$STEAM_RUNTIME" ]
+then
+SteamAppPath="$APP_PATH" SteamAppId=$APP_ID SteamGameId=$APP_ID "$APP_NAME"
+else
+SteamAppPath="$APP_PATH" SteamAppId=$APP_ID SteamGameId=$APP_ID "$STEAM_RUNTIME" "$APP_NAME"
+fi
 
+cd "$CUR_DIR"
 #restore original
 rm -f ~/.steam/steam.pid
 rm -f ~/.steam/sdk64/steamclient.so

sdk_includes/steam_api_common.h

@@ -39,11 +39,19 @@
 	#endif // STEAM_API_EXPORTS
 #endif
 
+#ifdef STEAM_API_EXPORTS
+#ifdef STEAM_API_FUNCTIONS_IMPL
 #ifdef STEAMCLIENT_DLL
 #define S_API static
 #else
 #define S_API S_API_EXPORT
 #endif
+#else
+#define S_API
+#endif
+#else
+#define S_API S_API_EXPORT
+#endif
 
 #if ( defined(STEAM_API_EXPORTS) || defined(STEAM_API_NODLL) ) && !defined(API_GEN)
 #define STEAM_PRIVATE_API( ... ) __VA_ARGS__