diff -up shadow-4.6/configure.ac.libsubid_creation shadow-4.6/configure.ac

--- shadow-4.6/configure.ac.libsubid_creation	2021-10-19 16:12:02.663748272 +0200

+++ shadow-4.6/configure.ac	2021-10-19 16:13:07.194697194 +0200

@@ -1,11 +1,21 @@

 dnl Process this file with autoconf to produce a configure script.

-AC_PREREQ([2.64])

+AC_PREREQ([2.69])

+m4_define([libsubid_abi_major], 1)

+m4_define([libsubid_abi_minor], 0)

+m4_define([libsubid_abi_micro], 0)

+m4_define([libsubid_abi], [libsubid_abi_major.libsubid_abi_minor.libsubid_abi_micro])

 AC_INIT([shadow], [4.6], [pkg-shadow-devel@lists.alioth.debian.org], [],

 	[https://github.com/shadow-maint/shadow])

 AM_INIT_AUTOMAKE([1.11 foreign dist-xz])

+AC_CONFIG_MACRO_DIRS([m4])

 AM_SILENT_RULES([yes])

 AC_CONFIG_HEADERS([config.h])

+AC_SUBST([LIBSUBID_ABI_MAJOR], [libsubid_abi_major])

+AC_SUBST([LIBSUBID_ABI_MINOR], [libsubid_abi_minor])

+AC_SUBST([LIBSUBID_ABI_MICRO], [libsubid_abi_micro])

+AC_SUBST([LIBSUBID_ABI], [libsubid_abi])

+

 dnl Some hacks...

 test "$prefix" = "NONE" && prefix="/usr"

 test "$prefix" = "/usr" && exec_prefix=""

@@ -22,8 +22,8 @@ test "$prefix" = "/usr" && exec_prefix=""

 AC_GNU_SOURCE

-AM_DISABLE_SHARED

 AM_ENABLE_STATIC

+AM_ENABLE_SHARED

 AM_MAINTAINER_MODE

@@ -725,6 +725,7 @@ AC_CONFIG_FILES([

 	man/zh_TW/Makefile

 	libmisc/Makefile

 	lib/Makefile

+	libsubid/Makefile

 	src/Makefile

 	contrib/Makefile

 	etc/Makefile

diff -up shadow-4.6/libsubid/api.c.libsubid_creation shadow-4.6/libsubid/api.c

--- shadow-4.6/libsubid/api.c.libsubid_creation	2021-10-19 16:12:02.661748243 +0200

+++ shadow-4.6/libsubid/api.c	2021-10-19 16:12:02.661748243 +0200

@@ -0,0 +1,231 @@

+/*

+ * Copyright (c) 2020 Serge Hallyn

+ * All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ * 1. Redistributions of source code must retain the above copyright

+ *    notice, this list of conditions and the following disclaimer.

+ * 2. Redistributions in binary form must reproduce the above copyright

+ *    notice, this list of conditions and the following disclaimer in the

+ *    documentation and/or other materials provided with the distribution.

+ * 3. The name of the copyright holders or contributors may not be used to

+ *    endorse or promote products derived from this software without

+ *    specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

+ * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT

+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+

+#include <config.h>

+#include <fcntl.h>

+#include <stdio.h>

+#include <errno.h>

+#include <stdlib.h>

+#include <pwd.h>

+#include <stdbool.h>

+#include "subordinateio.h"

+#include "idmapping.h"

+#include "api.h"

+

+static struct subordinate_range **get_subid_ranges(const char *owner, enum subid_type id_type)

+{

+	struct subordinate_range **ranges = NULL;

+

+	switch (id_type) {

+	case ID_TYPE_UID:

+		if (!sub_uid_open(O_RDONLY)) {

+			return NULL;

+		}

+		break;

+	case ID_TYPE_GID:

+		if (!sub_gid_open(O_RDONLY)) {

+			return NULL;

+		}

+		break;

+	default:

+		return NULL;

+	}

+

+	ranges = list_owner_ranges(owner, id_type);

+

+	if (id_type == ID_TYPE_UID)

+		sub_uid_close();

+	else

+		sub_gid_close();

+

+	return ranges;

+}

+

+struct subordinate_range **get_subuid_ranges(const char *owner)

+{

+	return get_subid_ranges(owner, ID_TYPE_UID);

+}

+

+struct subordinate_range **get_subgid_ranges(const char *owner)

+{

+	return get_subid_ranges(owner, ID_TYPE_GID);

+}

+

+void subid_free_ranges(struct subordinate_range **ranges)

+{

+	return free_subordinate_ranges(ranges);

+}

+

+int get_subid_owner(unsigned long id, uid_t **owner, enum subid_type id_type)

+{

+	int ret = -1;

+

+	switch (id_type) {

+	case ID_TYPE_UID:

+		if (!sub_uid_open(O_RDONLY)) {

+			return -1;

+		}

+		break;

+	case ID_TYPE_GID:

+		if (!sub_gid_open(O_RDONLY)) {

+			return -1;

+		}

+		break;

+	default:

+		return -1;

+	}

+

+	ret = find_subid_owners(id, owner, id_type);

+

+	if (id_type == ID_TYPE_UID)

+		sub_uid_close();

+	else

+		sub_gid_close();

+

+	return ret;

+}

+

+int get_subuid_owners(uid_t uid, uid_t **owner)

+{

+	return get_subid_owner((unsigned long)uid, owner, ID_TYPE_UID);

+}

+

+int get_subgid_owners(gid_t gid, uid_t **owner)

+{

+	return get_subid_owner((unsigned long)gid, owner, ID_TYPE_GID);

+}

+

+bool grant_subid_range(struct subordinate_range *range, bool reuse,

+		       enum subid_type id_type)

+{

+	bool ret;

+

+	switch (id_type) {

+	case ID_TYPE_UID:

+		if (!sub_uid_lock()) {

+			printf("Failed loging subuids (errno %d)\n", errno);

+			return false;

+		}

+		if (!sub_uid_open(O_CREAT | O_RDWR)) {

+			printf("Failed opening subuids (errno %d)\n", errno);

+			sub_uid_unlock();

+			return false;

+		}

+		break;

+	case ID_TYPE_GID:

+		if (!sub_gid_lock()) {

+			printf("Failed loging subgids (errno %d)\n", errno);

+			return false;

+		}

+		if (!sub_gid_open(O_CREAT | O_RDWR)) {

+			printf("Failed opening subgids (errno %d)\n", errno);

+			sub_gid_unlock();

+			return false;

+		}

+		break;

+	default:

+		return false;

+	}

+

+	ret = new_subid_range(range, id_type, reuse);

+

+	if (id_type == ID_TYPE_UID) {

+		sub_uid_close();

+		sub_uid_unlock();

+	} else {

+		sub_gid_close();

+		sub_gid_unlock();

+	}

+

+	return ret;

+}

+

+bool grant_subuid_range(struct subordinate_range *range, bool reuse)

+{

+	return grant_subid_range(range, reuse, ID_TYPE_UID);

+}

+

+bool grant_subgid_range(struct subordinate_range *range, bool reuse)

+{

+	return grant_subid_range(range, reuse, ID_TYPE_GID);

+}

+

+bool free_subid_range(struct subordinate_range *range, enum subid_type id_type)

+{

+	bool ret;

+

+	switch (id_type) {

+	case ID_TYPE_UID:

+		if (!sub_uid_lock()) {

+			printf("Failed loging subuids (errno %d)\n", errno);

+			return false;

+		}

+		if (!sub_uid_open(O_CREAT | O_RDWR)) {

+			printf("Failed opening subuids (errno %d)\n", errno);

+			sub_uid_unlock();

+			return false;

+		}

+		break;

+	case ID_TYPE_GID:

+		if (!sub_gid_lock()) {

+			printf("Failed loging subgids (errno %d)\n", errno);

+			return false;

+		}

+		if (!sub_gid_open(O_CREAT | O_RDWR)) {

+			printf("Failed opening subgids (errno %d)\n", errno);

+			sub_gid_unlock();

+			return false;

+		}

+		break;

+	default:

+		return false;

+	}

+

+	ret = release_subid_range(range, id_type);

+

+	if (id_type == ID_TYPE_UID) {

+		sub_uid_close();

+		sub_uid_unlock();

+	} else {

+		sub_gid_close();

+		sub_gid_unlock();

+	}

+

+	return ret;

+}

+

+bool free_subuid_range(struct subordinate_range *range)

+{

+	return free_subid_range(range, ID_TYPE_UID);

+}

+

+bool free_subgid_range(struct subordinate_range *range)

+{

+	return free_subid_range(range, ID_TYPE_GID);

+}

diff -up shadow-4.6/libsubid/api.h.libsubid_creation shadow-4.6/libsubid/api.h

--- shadow-4.6/libsubid/api.h.libsubid_creation	2021-10-19 16:12:02.661748243 +0200

+++ shadow-4.6/libsubid/api.h	2021-10-19 16:12:02.662748257 +0200

@@ -0,0 +1,17 @@

+#include "subid.h"

+#include <stdbool.h>

+

+struct subordinate_range **get_subuid_ranges(const char *owner);

+struct subordinate_range **get_subgid_ranges(const char *owner);

+void subid_free_ranges(struct subordinate_range **ranges);

+

+int get_subuid_owners(uid_t uid, uid_t **owner);

+int get_subgid_owners(gid_t gid, uid_t **owner);

+

+/* range should be pre-allocated with owner and count filled in, start is

+ * ignored, can be 0 */

+bool grant_subuid_range(struct subordinate_range *range, bool reuse);

+bool grant_subgid_range(struct subordinate_range *range, bool reuse);

+

+bool free_subuid_range(struct subordinate_range *range);

+bool free_subgid_range(struct subordinate_range *range);

diff -up shadow-4.6/libsubid/Makefile.am.libsubid_creation shadow-4.6/libsubid/Makefile.am

--- shadow-4.6/libsubid/Makefile.am.libsubid_creation	2021-10-19 16:12:02.661748243 +0200

+++ shadow-4.6/libsubid/Makefile.am	2021-10-19 16:12:02.662748257 +0200

@@ -0,0 +1,24 @@

+lib_LTLIBRARIES = libsubid.la

+libsubid_la_LDFLAGS = -Wl,-soname,libsubid.so.@LIBSUBID_ABI@ \

+	-shared -version-info @LIBSUBID_ABI_MAJOR@

+libsubid_la_SOURCES = api.c

+

+MISCLIBS = \

+	$(LIBAUDIT) \

+	$(LIBSELINUX) \

+	$(LIBSEMANAGE) \

+	$(LIBCRYPT_NOPAM) \

+	$(LIBSKEY) \

+	$(LIBMD) \

+	$(LIBCRYPT) \

+	$(LIBTCB)

+

+libsubid_la_LIBADD = \

+	$(top_srcdir)/lib/libshadow.la \

+	$(MISCLIBS) \

+	$(top_srcdir)/libmisc/libmisc.a

+

+AM_CPPFLAGS = \

+	-I${top_srcdir}/lib \

+	-I${top_srcdir}/libmisc \

+	-DLOCALEDIR=\"$(datadir)/locale\"

diff -up shadow-4.6/libsubid/subid.h.libsubid_creation shadow-4.6/libsubid/subid.h

--- shadow-4.6/libsubid/subid.h.libsubid_creation	2021-10-19 16:12:02.661748243 +0200

+++ shadow-4.6/libsubid/subid.h	2021-10-19 16:12:02.661748243 +0200

@@ -0,0 +1,17 @@

+#include <sys/types.h>

+

+#ifndef SUBID_RANGE_DEFINED

+#define SUBID_RANGE_DEFINED 1

+struct subordinate_range {

+	const char *owner;

+	unsigned long start;

+	unsigned long count;

+};

+

+enum subid_type {

+	ID_TYPE_UID = 1,

+	ID_TYPE_GID = 2

+};

+

+#define SUBID_NFIELDS 3

+#endif

diff -up shadow-4.6/lib/subordinateio.c.libsubid_creation shadow-4.6/lib/subordinateio.c

--- shadow-4.6/lib/subordinateio.c.libsubid_creation	2021-10-19 16:12:02.654748139 +0200

+++ shadow-4.6/lib/subordinateio.c	2021-10-19 16:12:02.661748243 +0200

@@ -13,14 +13,7 @@

 #include "subordinateio.h"

 #include <sys/types.h>

 #include <pwd.h>

-

-struct subordinate_range {

-	const char *owner;

-	unsigned long start;

-	unsigned long count;

-};

-

-#define NFIELDS 3

+#include <ctype.h>

 /*

  * subordinate_dup: create a duplicate range

@@ -78,7 +71,7 @@ static void *subordinate_parse (const ch

 	static char rangebuf[1024];

 	int i;

 	char *cp;

-	char *fields[NFIELDS];

+	char *fields[SUBID_NFIELDS];

 	/*

 	 * Copy the string to a temporary buffer so the substrings can

@@ -93,7 +86,7 @@ static void *subordinate_parse (const ch

 	 * field.  The fields are converted into NUL terminated strings.

 	 */

-	for (cp = rangebuf, i = 0; (i < NFIELDS) && (NULL != cp); i++) {

+	for (cp = rangebuf, i = 0; (i < SUBID_NFIELDS) && (NULL != cp); i++) {

 		fields[i] = cp;

 		while (('\0' != *cp) && (':' != *cp)) {

 			cp++;

@@ -108,10 +101,10 @@ static void *subordinate_parse (const ch

 	}

 	/*

-	 * There must be exactly NFIELDS colon separated fields or

+	 * There must be exactly SUBID_NFIELDS colon separated fields or

 	 * the entry is invalid.  Also, fields must be non-blank.

 	 */

-	if (i != NFIELDS || *fields[0] == '\0' || *fields[1] == '\0' || *fields[2] == '\0')

+	if (i != SUBID_NFIELDS || *fields[0] == '\0' || *fields[1] == '\0' || *fields[2] == '\0')

 		return NULL;

 	range.owner = fields[0];

 	if (getulong (fields[1], &range.start) == 0)

@@ -319,6 +312,39 @@ static bool have_range(struct commonio_d

 	return false;

 }

+static bool append_range(struct subordinate_range ***ranges, const struct subordinate_range *new, int n)

+{

+	struct subordinate_range *tmp;

+	if (!*ranges) {

+		*ranges = malloc(2 * sizeof(struct subordinate_range **));

+		if (!*ranges)

+			return false;

+	} else {

+		struct subordinate_range **new;

+		new = realloc(*ranges, (n + 2) * (sizeof(struct subordinate_range **)));

+		if (!new)

+			return false;

+		*ranges = new;

+	}

+	(*ranges)[n] = (*ranges)[n+1] = NULL;

+	tmp = subordinate_dup(new);

+	if (!tmp)

+		return false;

+	(*ranges)[n] = tmp;

+	return true;

+}

+

+void free_subordinate_ranges(struct subordinate_range **ranges)

+{

+	int i;

+

+	if (!ranges)

+		return;

+	for (i = 0; ranges[i]; i++)

+		subordinate_free(ranges[i]);

+	free(ranges);

+}

+

 /*

  * subordinate_range_cmp: compare uid ranges

  *

@@ -697,6 +723,160 @@ gid_t sub_gid_find_free_range(gid_t min,

 	start = find_free_range (&subordinate_gid_db, min, max, count);

 	return start == ULONG_MAX ? (gid_t) -1 : start;

 }

+

+/*

+ struct subordinate_range **list_owner_ranges(const char *owner, enum subid_type id_type)

+ *

+ * @owner: username

+ * @id_type: UID or GUID

+ *

+ * Returns the subuid or subgid ranges which are owned by the specified

+ * user.  Username may be a username or a string representation of a

+ * UID number.  If id_type is UID, then subuids are returned, else

+ * subgids are returned.  If there is an error, < 0 is returned.

+ *

+ * The caller must free the subordinate range list.

+ */

+struct subordinate_range **list_owner_ranges(const char *owner, enum subid_type id_type)

+{

+	// TODO - need to handle owner being either uid or username

+	const struct subordinate_range *range;

+	struct subordinate_range **ranges = NULL;

+	struct commonio_db *db;

+	int size = 0;

+

+	if (id_type == ID_TYPE_UID)

+		db = &subordinate_uid_db;

+	else

+		db = &subordinate_gid_db;

+

+	commonio_rewind(db);

+	while ((range = commonio_next(db)) != NULL) {

+		if (0 == strcmp(range->owner, owner)) {

+			if (!append_range(&ranges, range, size++)) {

+				free_subordinate_ranges(ranges);

+				return NULL;

+			}

+		}

+	}

+

+	return ranges;

+}

+

+static bool all_digits(const char *str)

+{

+	int i;

+

+	for (i = 0; str[i] != '\0'; i++)

+		if (!isdigit(str[i]))

+			return false;

+	return true;

+}

+

+static int append_uids(uid_t **uids, const char *owner, int n)

+{

+	uid_t owner_uid;

+	uid_t *ret;

+	int i;

+

+	if (all_digits(owner)) {

+		i = sscanf(owner, "%d", &owner_uid);

+		if (i != 1) {

+			// should not happen

+			free(*uids);

+			*uids = NULL;

+			return -1;

+		}

+	} else {

+		struct passwd *pwd = getpwnam(owner);

+		if (NULL == pwd) {

+			/* Username not defined in /etc/passwd, or error occured during lookup */

+			free(*uids);

+			*uids = NULL;

+			return -1;

+		}

+		owner_uid = pwd->pw_uid;

+	}

+

+	for (i = 0; i < n; i++) {

+		if (owner_uid == (*uids)[i])

+			return n;

+	}

+

+	ret = realloc(*uids, (n + 1) * sizeof(uid_t));

+	if (!ret) {

+		free(*uids);

+		return -1;

+	}

+	ret[n] = owner_uid;

+	*uids = ret;

+	return n+1;

+}

+

+int find_subid_owners(unsigned long id, uid_t **uids, enum subid_type id_type)

+{

+	const struct subordinate_range *range;

+	struct commonio_db *db;

+	int n = 0;

+

+	*uids = NULL;

+	if (id_type == ID_TYPE_UID)

+		db = &subordinate_uid_db;

+	else

+		db = &subordinate_gid_db;

+

+	commonio_rewind(db);

+	while ((range = commonio_next(db)) != NULL) {

+		if (id >= range->start && id < range->start + range-> count) {

+			n = append_uids(uids, range->owner, n);

+			if (n < 0)

+				break;

+		}

+	}

+

+	return n;

+}

+

+bool new_subid_range(struct subordinate_range *range, enum subid_type id_type, bool reuse)

+{

+	struct commonio_db *db;

+	const struct subordinate_range *r;

+

+	if (id_type == ID_TYPE_UID)

+		db = &subordinate_uid_db;

+	else

+		db = &subordinate_gid_db;

+	commonio_rewind(db);

+	if (reuse) {

+		while ((r = commonio_next(db)) != NULL) {

+			// TODO account for username vs uid_t

+			if (0 != strcmp(r->owner, range->owner))

+				continue;

+			if (r->count >= range->count) {

+				range->count = r->count;

+				range->start = r->start;

+				return true;

+			}

+		}

+	}

+

+	range->start = find_free_range(db, range->start, ULONG_MAX, range->count);

+	if (range->start == ULONG_MAX)

+		return false;

+

+	return add_range(db, range->owner, range->start, range->count) == 1;

+}

+

+bool release_subid_range(struct subordinate_range *range, enum subid_type id_type)

+{

+	struct commonio_db *db;

+	if (id_type == ID_TYPE_UID)

+		db = &subordinate_uid_db;

+	else

+		db = &subordinate_gid_db;

+	return remove_range(db, range->owner, range->start, range->count) == 1;

+}

+

 #else				/* !ENABLE_SUBIDS */

 extern int errno;		/* warning: ANSI C forbids an empty source file */

 #endif				/* !ENABLE_SUBIDS */

diff -up shadow-4.6/lib/subordinateio.h.libsubid_creation shadow-4.6/lib/subordinateio.h

--- shadow-4.6/lib/subordinateio.h.libsubid_creation	2018-04-29 18:42:37.000000000 +0200

+++ shadow-4.6/lib/subordinateio.h	2021-10-19 16:12:02.661748243 +0200

@@ -11,6 +11,8 @@

 #include <sys/types.h>

+#include "../libsubid/subid.h"

+

 extern int sub_uid_close(void);

 extern bool have_sub_uids(const char *owner, uid_t start, unsigned long count);

 extern bool sub_uid_file_present (void);

@@ -23,6 +25,11 @@ extern int sub_uid_unlock (void);

 extern int sub_uid_add (const char *owner, uid_t start, unsigned long count);

 extern int sub_uid_remove (const char *owner, uid_t start, unsigned long count);

 extern uid_t sub_uid_find_free_range(uid_t min, uid_t max, unsigned long count);

+extern struct subordinate_range **list_owner_ranges(const char *owner, enum subid_type id_type);

+extern bool new_subid_range(struct subordinate_range *range, enum subid_type id_type, bool reuse);

+extern bool release_subid_range(struct subordinate_range *range, enum subid_type id_type);

+extern int find_subid_owners(unsigned long id, uid_t **uids, enum subid_type id_type);

+extern void free_subordinate_ranges(struct subordinate_range **ranges);

 extern int sub_gid_close(void);

 extern bool have_sub_gids(const char *owner, gid_t start, unsigned long count);

diff -up shadow-4.6/Makefile.am.libsubid_creation shadow-4.6/Makefile.am

--- shadow-4.6/Makefile.am.libsubid_creation	2018-04-29 18:42:37.000000000 +0200

+++ shadow-4.6/Makefile.am	2021-10-19 16:12:02.660748228 +0200

@@ -2,5 +2,14 @@

 EXTRA_DIST = NEWS README TODO shadow.spec.in

-SUBDIRS = po man libmisc lib src \

-	contrib doc etc

+SUBDIRS = libmisc lib 

+

+if ENABLE_SUBIDS

+SUBDIRS += libsubid

+endif

+

+SUBDIRS += src po contrib doc etc

+

+if ENABLE_REGENERATE_MAN

+SUBDIRS += man

+endif

diff -up shadow-4.6/src/free_subid_range.c.libsubid_creation shadow-4.6/src/free_subid_range.c

--- shadow-4.6/src/free_subid_range.c.libsubid_creation	2021-10-19 16:12:02.661748243 +0200

+++ shadow-4.6/src/free_subid_range.c	2021-10-19 16:12:02.661748243 +0200

@@ -0,0 +1,50 @@

+#include <stdio.h>

+#include <unistd.h>

+#include "api.h"

+#include "stdlib.h"

+#include "prototypes.h"

+

+/* Test program for the subid freeing routine */

+

+const char *Prog;

+

+void usage(void)

+{

+	fprintf(stderr, "Usage: %s [-g] user start count\n", Prog);

+	fprintf(stderr, "    Release a user's subuid (or with -g, subgid) range\n");

+	exit(EXIT_FAILURE);

+}

+

+int main(int argc, char *argv[])

+{

+	int c;

+	bool ok;

+	struct subordinate_range range;

+	bool group = false;   // get subuids by default

+

+	Prog = Basename (argv[0]);

+	while ((c = getopt(argc, argv, "g")) != EOF) {

+		switch(c) {

+		case 'g': group = true; break;

+		default: usage();

+		}

+	}

+	argv = &argv[optind];

+	argc = argc - optind;

+	if (argc < 3)

+		usage();

+	range.owner = argv[0];

+	range.start = atoi(argv[1]);

+	range.count = atoi(argv[2]);

+	if (group)

+		ok = free_subgid_range(&range);

+	else

+		ok = free_subuid_range(&range);

+

+	if (!ok) {

+		fprintf(stderr, "Failed freeing id range\n");

+		exit(EXIT_FAILURE);

+	}

+

+	return 0;

+}

diff -up shadow-4.6/src/get_subid_owners.c.libsubid_creation shadow-4.6/src/get_subid_owners.c

--- shadow-4.6/src/get_subid_owners.c.libsubid_creation	2021-10-19 16:12:02.661748243 +0200

+++ shadow-4.6/src/get_subid_owners.c	2021-10-19 16:12:02.661748243 +0200

@@ -0,0 +1,40 @@

+#include <stdio.h>

+#include "api.h"

+#include "stdlib.h"

+#include "prototypes.h"

+

+const char *Prog;

+

+void usage(void)

+{

+	fprintf(stderr, "Usage: [-g] %s subuid\n", Prog);

+	fprintf(stderr, "    list uids who own the given subuid\n");

+	fprintf(stderr, "    pass -g to query a subgid\n");

+	exit(EXIT_FAILURE);

+}

+

+int main(int argc, char *argv[])

+{