/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2024 RackTop Systems, Inc.
 */

/*
 * Stubs to replace libidmap and libc calls for these test programs.
 * See -Wl,-zinterpose in Makefile
 */


#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <pwd.h>
#include <grp.h>
#include "idmap.h"

struct mapping {
	uid_t pid;
	int is_user;
	char *sid;	/* may be NULL */
	char *name;
	char *domain;	/* may be NULL */
};

struct mapping mappings[] = {
	/* User and group with no SID, no domain */
	{
		.pid = 501,
		.is_user = 1,
		.sid = NULL,
		.name = "user501",
		.domain = NULL
	},
	{
		.pid = 502,
		.is_user = 0,
		.sid = NULL,
		.name = "group502",
		.domain = NULL
	},
	/* Users and groups with SID, names, domains of various length. */
	{
		.pid = 0x80000001,
		.is_user = 1,
		.sid = "S-1-5-21-1813420391-1960978090-3893453001-1001",
		.name = "user1001",
		.domain = "test-domain-name"
	},
	{
		.pid = 0x80000002,
		.is_user = 0,
		.sid = "S-1-5-21-1813420391-1960978090-3893453001-1002",
		.name = "group1002",
		.domain = "test-domain-name"
	},
	{
		.pid = 0x80000003,
		.is_user = 0,
		.sid = "S-1-5-21-1813420391-1960978090-3893453001-1003",
		.name = "group1003-name-really-crazy-long-long"
			"-long-long-long-long-long-long-long",
		.domain = "test-domain-name"
	},
	{
		.pid = 0x80000004,
		.is_user = 0,
		.sid = "S-1-5-21-1813420391-1960978090-3893453002-2002",
		.name = "group2002",
		.domain = "test-domain-name-somewhat-longer"
	},
	{
		.pid = 0x80000005,
		.is_user = 0,
		.sid = "S-1-5-21-1813420391-1960978090-3893453003-3003",
		.name = "group3003",
		.domain = "test-domain-name-really-crazy-long"
			"-long-long-long-long-long-long-long-long"
	},
	{
		.pid = 0
	}
};


idmap_get_handle_t *stub_idmh = (idmap_get_handle_t *)0x40;

idmap_stat
idmap_get_create(idmap_get_handle_t **gh)
{
	*gh = stub_idmh;
	return (0);
}

void
idmap_get_destroy(idmap_get_handle_t *gh)
{
}

idmap_stat
idmap_get_mappings(idmap_get_handle_t *gh)
{
	if (gh != stub_idmh)
		return (IDMAP_ERR_ARG);
	return (0);
}


/*
 * Get winname given pid
 */
idmap_stat
idmap_getwinnamebypid(uid_t pid, int is_user, int flag, char **name,
    char **domain)
{
	struct mapping	*mp;

	if (name == NULL)
		return (IDMAP_ERR_ARG);

	/* Get mapping */
	for (mp = mappings; mp->pid != 0; mp++) {
		if (mp->is_user != is_user)
			continue;
		if (mp->pid == pid)
			break;
	}
	if (mp->pid == 0 || mp->name == NULL || mp->domain == NULL)
		return (IDMAP_ERR_NORESULT);

	if (domain != NULL) {
		*name = strdup(mp->name);
		*domain = strdup(mp->domain);
	} else {
		(void) asprintf(name, "%s@%s", mp->name, mp->domain);
	}

	return (0);
}

idmap_stat
idmap_getwinnamebyuid(uid_t uid, int flag, char **name, char **domain)
{
	return (idmap_getwinnamebypid(uid, 1, flag, name, domain));
}

idmap_stat
idmap_getwinnamebygid(gid_t gid, int flag, char **name, char **domain)
{
	return (idmap_getwinnamebypid(gid, 0, flag, name, domain));
}

idmap_stat
idmap_getpidbywinname(const char *name, const char *domain, int flag,
    uid_t *uid, int is_user)
{
	struct mapping	*mp;

	/* Get mapping */
	for (mp = mappings; mp->pid != 0; mp++) {
		if (mp->is_user != is_user)
			continue;
		if (mp->domain == NULL)
			continue;
		if (strcmp(mp->domain, domain) == 0 &&
		    strcmp(mp->name, name) == 0)
			break;
	}
	if (mp->pid == 0)
		return (IDMAP_ERR_NORESULT);

	*uid = mp->pid;
	return (0);
}


idmap_stat
idmap_getuidbywinname(const char *name, const char *domain, int flag,
    uid_t *uid)
{
	return (idmap_getpidbywinname(name, domain, flag, uid, 1));
}

idmap_stat
idmap_getgidbywinname(const char *name, const char *domain, int flag,
    gid_t *gid)
{
	return (idmap_getpidbywinname(name, domain, flag, gid, 0));
}


idmap_stat
idmap_get_sidbypid(idmap_get_handle_t *gh, uid_t pid, int flag,
    char **sidprefix, idmap_rid_t *rid, idmap_stat *stat, int is_user)
{
	struct mapping	*mp;
	char *p;
	int len;

	/* Get mapping */
	for (mp = mappings; mp->pid != 0; mp++) {
		if (mp->is_user != is_user)
			continue;
		if (mp->pid == pid)
			break;
	}
	if (mp->pid == 0 || mp->sid == NULL)
		goto errout;

	p = strrchr(mp->sid, '-');
	if (p == NULL)
		goto errout;
	len = p - mp->sid;
	*sidprefix = malloc(len + 1);
	if (*sidprefix == NULL)
		goto errout;
	(void) strlcpy(*sidprefix, mp->sid, len + 1);

	*rid = strtol(p + 1, NULL, 10);
	*stat = 0;
	return (0);

errout:
	*stat = IDMAP_ERR_NORESULT;
	return (0);
}

idmap_stat
idmap_get_sidbyuid(idmap_get_handle_t *gh, uid_t uid, int flag,
    char **sidprefix, idmap_rid_t *rid, idmap_stat *stat)
{
	return (idmap_get_sidbypid(gh, uid, flag,
	    sidprefix, rid, stat, 1));
}

idmap_stat
idmap_get_sidbygid(idmap_get_handle_t *gh, gid_t gid, int flag,
    char **sidprefix, idmap_rid_t *rid, idmap_stat *stat)
{
	return (idmap_get_sidbypid(gh, gid, flag,
	    sidprefix, rid, stat, 0));
}

idmap_stat
idmap_get_pidbysid(idmap_get_handle_t *gh, char *sidprefix, idmap_rid_t rid,
    int flag, uid_t *pid, int *is_user, idmap_stat *stat)
{
	char tmpsid[80];
	struct mapping	*mp;

	(void) snprintf(tmpsid, sizeof (tmpsid), "%s-%u", sidprefix, rid);

	/* Get mapping */
	for (mp = mappings; mp->pid != 0; mp++) {
		if (mp->sid != NULL &&
		    strcmp(mp->sid, tmpsid) == 0)
			break;
	}
	if (mp->pid == 0)
		return (IDMAP_ERR_NORESULT);

	*pid = mp->pid;
	*is_user = mp->is_user;
	*stat = 0;

	return (0);
}

idmap_stat
idmap_get_uidbysid(idmap_get_handle_t *gh, char *sidprefix, idmap_rid_t rid,
    int flag, uid_t *uid, idmap_stat *stat)
{
	idmap_stat rc;
	uid_t pid;
	int is_user;

	rc = idmap_get_pidbysid(gh, sidprefix, rid, flag, &pid, &is_user, stat);
	if (rc == 0) {
		if (is_user != 1) {
			*stat = IDMAP_ERR_NOTUSER;
			return (0);
		}
		*uid = pid;
	}

	return (rc);
}

idmap_stat
idmap_get_gidbysid(idmap_get_handle_t *gh, char *sidprefix, idmap_rid_t rid,
    int flag, gid_t *gid, idmap_stat *stat)
{
	idmap_stat rc;
	uid_t pid;
	int is_user;

	rc = idmap_get_pidbysid(gh, sidprefix, rid, flag, &pid, &is_user, stat);
	if (rc == 0) {
		if (is_user != 0) {
			*stat = IDMAP_ERR_NOTGROUP;
			return (rc);
		}
		*gid = pid;
	}

	return (rc);
}

struct passwd *
getpwnam(const char *nam)
{
	static char pwname[128];
	static struct passwd pw;
	struct mapping	*mp;
	char *p;

	/* Allow lookup with or without domain part */
	if ((p = strchr(nam, '@')) != NULL) {
		int len = p - nam;
		if (len >= sizeof (pwname))
			return (NULL);
		(void) strlcpy(pwname, nam, len + 1);
		pwname[len] = '\0';
	} else {
		(void) strlcpy(pwname, nam, sizeof (pwname));
	}

	/* Get mapping */
	for (mp = mappings; mp->pid != 0; mp++) {
		if (mp->is_user != 1)
			continue;
		if (strcmp(mp->name, pwname) == 0)
			break;
	}
	if (mp->pid == 0)
		return (NULL);

	if (mp->domain != NULL)
		(void) snprintf(pwname, sizeof (pwname),
		    "%s@%s", mp->name, mp->domain);
	else
		(void) strlcpy(pwname, mp->name, sizeof (pwname));

	pw.pw_name = pwname;
	pw.pw_uid = mp->pid;
	return (&pw);
}

struct passwd *
getpwuid(uid_t uid)
{
	static char pwname[128];
	static struct passwd pw;
	struct mapping	*mp;

	/* Get mapping */
	for (mp = mappings; mp->pid != 0; mp++) {
		if (mp->is_user != 1)
			continue;
		if (mp->pid == uid)
			break;
	}
	if (mp->pid == 0)
		return (NULL);

	if (mp->domain != NULL)
		(void) snprintf(pwname, sizeof (pwname),
		    "%s@%s", mp->name, mp->domain);
	else
		(void) strlcpy(pwname, mp->name, sizeof (pwname));

	pw.pw_name = pwname;
	pw.pw_uid = uid;
	return (&pw);
}

struct group *
getgrnam(const char *nam)
{
	static char grname[128];
	static struct group gr;
	struct mapping	*mp;
	char *p;

	/* Allow lookup with or without domain part */
	if ((p = strchr(nam, '@')) != NULL) {
		int len = p - nam;
		if (len >= sizeof (grname))
			return (NULL);
		(void) strlcpy(grname, nam, len + 1);
		grname[len] = '\0';
	} else {
		(void) strlcpy(grname, nam, sizeof (grname));
	}

	/* Get mapping */
	for (mp = mappings; mp->pid != 0; mp++) {
		if (mp->is_user != 0)
			continue;
		if (strcmp(mp->name, grname) == 0)
			break;
	}
	if (mp->pid == 0)
		return (NULL);

	if (mp->domain != NULL)
		(void) snprintf(grname, sizeof (grname),
		    "%s@%s", mp->name, mp->domain);
	else
		(void) strlcpy(grname, mp->name, sizeof (grname));

	gr.gr_name = grname;
	gr.gr_gid = mp->pid;
	return (&gr);
}

struct group *
getgrgid(gid_t gid)
{
	static char grname[128];
	static struct group gr;
	struct mapping	*mp;

	/* Get mapping */
	for (mp = mappings; mp->pid != 0; mp++) {
		if (mp->is_user != 0)
			continue;
		if (mp->pid == gid)
			break;
	}
	if (mp->pid == 0)
		return (NULL);

	if (mp->domain != NULL)
		(void) snprintf(grname, sizeof (grname),
		    "%s@%s", mp->name, mp->domain);
	else
		(void) strlcpy(grname, mp->name, sizeof (grname));

	gr.gr_name = grname;
	gr.gr_gid = gid;
	return (&gr);
}