idmap.c File Reference

#include <windows.h>
#include <strsafe.h>
#include <winldap.h>
#include <stdlib.h>
#include <errno.h>
#include <time.h>
#include "idmap.h"
#include "nfs41_const.h"
#include "list.h"
#include "daemon_debug.h"

Include dependency graph for idmap.c:

Go to the source code of this file.

Classes
struct	idmap_lookup
struct	idmap_config
struct	config_option
struct	config_pair
struct	cache_ops
struct	idmap_cache
struct	idmap_user
struct	idmap_group
struct	idmap_context

Macros
#define	IDLVL   2 /* dprintf level for idmap logging */
#define	FILTER_LEN   1024
#define	NAME_LEN   32
#define	VAL_LEN   257
#define	ATTR_FLAG(attr)   (1 << (attr))
#define	ATTR_ISSET(mask, attr)   (((mask) & ATTR_FLAG(attr)) != 0)
#define	OPT_INT(key, def, field)   { key, def, TYPE_INT, FIELD_OFFSET(struct idmap_config, field), 0 }
#define	OPT_STR(key, def, field, len)   { key, def, TYPE_STR, FIELD_OFFSET(struct idmap_config, field), len }
#define	OPT_CLASS(key, def, index)   { key, def, TYPE_STR, FIELD_OFFSET(struct idmap_config, classes[index]), NAME_LEN }
#define	OPT_ATTR(key, def, index)   { key, def, TYPE_STR, FIELD_OFFSET(struct idmap_config, attributes[index]), NAME_LEN }

Typedefs
typedef struct list_entry *(*	entry_alloc_fn) ()
typedef void(*	entry_free_fn) (struct list_entry *)
typedef void(*	entry_copy_fn) (struct list_entry *, const struct list_entry *)

Enumerations
enum	ldap_class { CLASS_USER, CLASS_GROUP, NUM_CLASSES }
enum	ldap_attr {   ATTR_USER_NAME, ATTR_GROUP_NAME, ATTR_PRINCIPAL, ATTR_UID,   ATTR_GID, NUM_ATTRIBUTES }
enum	config_type { TYPE_STR, TYPE_INT }

Functions
static int	config_parse_pair (char *line, struct config_pair *pair)
static BOOL	parse_uint (const char *str, UINT *id_out)
static int	config_defaults (struct idmap_config *config)
static int	config_find_option (const struct config_pair *pair, const struct config_option **option)
static int	config_load (struct idmap_config *config, const char *filename)
static int	config_init (struct idmap_config *config)
static void	cache_init (struct idmap_cache *cache, const struct cache_ops *ops)
static void	cache_cleanup (struct idmap_cache *cache)
static int	cache_insert (struct idmap_cache *cache, const struct idmap_lookup *lookup, const struct list_entry *src)
static int	cache_lookup (struct idmap_cache *cache, const struct idmap_lookup *lookup, struct list_entry *entry_out)
static struct list_entry *	user_cache_alloc ()
static void	user_cache_free (struct list_entry *entry)
static void	user_cache_copy (struct list_entry *lhs, const struct list_entry *rhs)
static struct list_entry *	group_cache_alloc ()
static void	group_cache_free (struct list_entry *entry)
static void	group_cache_copy (struct list_entry *lhs, const struct list_entry *rhs)
static int	idmap_filter (struct idmap_config *config, const struct idmap_lookup *lookup, char *filter, size_t filter_len)
static int	idmap_query_attrs (struct idmap_context *context, const struct idmap_lookup *lookup, const unsigned attributes, const unsigned optional, PCHAR *values[], const int len)
static int	idmap_lookup_user (struct idmap_context *context, const struct idmap_lookup *lookup, struct idmap_user *user)
static int	idmap_lookup_group (struct idmap_context *context, const struct idmap_lookup *lookup, struct idmap_group *group)
int	nfs41_idmap_create (struct idmap_context **context_out)
void	nfs41_idmap_free (struct idmap_context *context)
static int	username_cmp (const struct list_entry *list, const void *value)
int	nfs41_idmap_name_to_ids (struct idmap_context *context, const char *username, uid_t *uid_out, gid_t *gid_out)
static int	uid_cmp (const struct list_entry *list, const void *value)
int	nfs41_idmap_uid_to_name (struct idmap_context *context, uid_t uid, char *name, size_t len)
static int	principal_cmp (const struct list_entry *list, const void *value)
int	nfs41_idmap_principal_to_ids (struct idmap_context *context, const char *principal, uid_t *uid_out, gid_t *gid_out)
static int	group_cmp (const struct list_entry *list, const void *value)
int	nfs41_idmap_group_to_gid (struct idmap_context *context, const char *name, gid_t *gid_out)
static int	gid_cmp (const struct list_entry *list, const void *value)
int	nfs41_idmap_gid_to_group (struct idmap_context *context, gid_t gid, char *name, size_t len)

Variables
static const char	CONFIG_FILENAME [] = "C:\\ReactOS\\System32\\drivers\\etc\\ms-nfs41-idmap.conf"
static const struct config_option	g_options []
static const struct cache_ops	user_cache_ops
static const struct cache_ops	group_cache_ops

Macro Definition Documentation

ATTR_FLAG

#define ATTR_FLAG

(

attr

)

(1 << (attr))

Definition at line 59 of file idmap.c.

Referenced by idmap_lookup_group(), and idmap_lookup_user().

ATTR_ISSET

#define ATTR_ISSET	(		mask,
			attr
	)		(((mask) & ATTR_FLAG(attr)) != 0)

Definition at line 60 of file idmap.c.

Referenced by idmap_query_attrs().

FILTER_LEN

#define FILTER_LEN   1024

Definition at line 37 of file idmap.c.

Referenced by idmap_query_attrs().

IDLVL

#define IDLVL   2 /* dprintf level for idmap logging */

Definition at line 35 of file idmap.c.

Referenced by nfs41_idmap_gid_to_group(), nfs41_idmap_group_to_gid(), nfs41_idmap_name_to_ids(), nfs41_idmap_principal_to_ids(), and nfs41_idmap_uid_to_name().

NAME_LEN

#define NAME_LEN   32

Definition at line 38 of file idmap.c.

OPT_ATTR

#define OPT_ATTR	(		key,
			def,
			index
	)		{ key, def, TYPE_STR, FIELD_OFFSET(struct idmap_config, attributes[index]), NAME_LEN }

Definition at line 119 of file idmap.c.

OPT_CLASS

#define OPT_CLASS	(		key,
			def,
			index
	)		{ key, def, TYPE_STR, FIELD_OFFSET(struct idmap_config, classes[index]), NAME_LEN }

Definition at line 117 of file idmap.c.

OPT_INT

#define OPT_INT	(		key,
			def,
			field
	)		{ key, def, TYPE_INT, FIELD_OFFSET(struct idmap_config, field), 0 }

Definition at line 113 of file idmap.c.

OPT_STR

#define OPT_STR	(		key,
			def,
			field,
			len
	)		{ key, def, TYPE_STR, FIELD_OFFSET(struct idmap_config, field), len }

Definition at line 115 of file idmap.c.

VAL_LEN

#define VAL_LEN   257

Definition at line 39 of file idmap.c.

Referenced by group_cache_copy(), idmap_lookup_group(), idmap_lookup_user(), and user_cache_copy().

Typedef Documentation

entry_alloc_fn

typedef struct list_entry*(* entry_alloc_fn) ()

Definition at line 408 of file idmap.c.

entry_copy_fn

typedef void(* entry_copy_fn) (struct list_entry *, const struct list_entry *)

Definition at line 410 of file idmap.c.

entry_free_fn

typedef void(* entry_free_fn) (struct list_entry *)

Definition at line 409 of file idmap.c.

Enumeration Type Documentation

config_type

enum config_type

Enumerator
TYPE_STR
TYPE_INT

Definition at line 99 of file idmap.c.

                 {
    TYPE_STR,
    TYPE_INT
};

ldap_attr

enum ldap_attr

Enumerator
ATTR_USER_NAME
ATTR_GROUP_NAME
ATTR_PRINCIPAL
ATTR_UID
ATTR_GID
NUM_ATTRIBUTES

Definition at line 49 of file idmap.c.

               {
    ATTR_USER_NAME,
    ATTR_GROUP_NAME,
    ATTR_PRINCIPAL,
    ATTR_UID,
    ATTR_GID,

    NUM_ATTRIBUTES
};

ldap_class

enum ldap_class

Enumerator
CLASS_USER
CLASS_GROUP
NUM_CLASSES

Definition at line 42 of file idmap.c.

                {
    CLASS_USER,
    CLASS_GROUP,

    NUM_CLASSES
};

Function Documentation

cache_cleanup()

static void cache_cleanup ( struct idmap_cache *  cache )

static

Definition at line 434 of file idmap.c.

Referenced by nfs41_idmap_free().

{
    struct list_entry *entry, *tmp;
    list_for_each_tmp(entry, tmp, &cache->head)
        cache->ops->entry_free(entry);
    list_init(&cache->head);
}

cache_init()

static void cache_init ( struct idmap_cache *  cache, const struct cache_ops *  ops  )

static

Definition at line 425 of file idmap.c.

Referenced by nfs41_idmap_create().

{
    list_init(&cache->head);
    cache->ops = ops;
    InitializeSRWLock(&cache->lock);
}

cache_insert()

static int cache_insert ( struct idmap_cache *  cache, const struct idmap_lookup *  lookup, const struct list_entry *  src  )

static

Definition at line 443 of file idmap.c.

Referenced by idmap_lookup_group(), and idmap_lookup_user().

{
    struct list_entry *entry;
    int status = NO_ERROR;

    AcquireSRWLockExclusive(&cache->lock);

    /* search for an existing match */
    entry = list_search(&cache->head, lookup->value, lookup->compare);
    if (entry) {
        /* overwrite the existing entry with the new results */
        cache->ops->entry_copy(entry, src);
        goto out;
    }

    /* initialize a new entry and add it to the list */
    entry = cache->ops->entry_alloc();
    if (entry == NULL) {
        status = GetLastError();
        goto out;
    }
    cache->ops->entry_copy(entry, src);
    list_add_head(&cache->head, entry);
out:
    ReleaseSRWLockExclusive(&cache->lock);
    return status;
}

cache_lookup()

static int cache_lookup ( struct idmap_cache *  cache, const struct idmap_lookup *  lookup, struct list_entry *  entry_out  )

static

Definition at line 474 of file idmap.c.

Referenced by idmap_lookup_group(), and idmap_lookup_user().

{
    struct list_entry *entry;
    int status = ERROR_NOT_FOUND;

    AcquireSRWLockShared(&cache->lock);

    entry = list_search(&cache->head, lookup->value, lookup->compare);
    if (entry) {
        /* make a copy for use outside of the lock */
        cache->ops->entry_copy(entry_out, entry);
        status = NO_ERROR;
    }

    ReleaseSRWLockShared(&cache->lock);
    return status;
}

config_defaults()

static int config_defaults ( struct idmap_config *  config )

static

Definition at line 243 of file idmap.c.

Referenced by config_init().

{
    const struct config_option *option;
    const int count = ARRAYSIZE(g_options);
    char *dst;
    int i, status = NO_ERROR;

    for (i = 0; i < count; i++) {
        option = &g_options[i];
        dst = (char*)config + option->offset;

        if (option->type == TYPE_INT) {
            if (!parse_uint(option->def, (UINT*)dst)) {
                status = ERROR_INVALID_PARAMETER;
                eprintf("failed to parse default value of %s=\"%s\": "
                    "expected a number\n", option->key, option->def);
                break;
            }
        } else {
            if (FAILED(StringCchCopyA(dst, option->max_len, option->def))) {
                status = ERROR_BUFFER_OVERFLOW;
                eprintf("failed to parse default value of %s=\"%s\": "
                    "buffer overflow > %u\n", option->key, option->def,
                    option->max_len);
                break;
            }
        }
    }
    return status;
}

config_find_option()

static int config_find_option ( const struct config_pair *  pair, const struct config_option **  option  )

static

Definition at line 275 of file idmap.c.

Referenced by config_load().

{
    int i, count = ARRAYSIZE(g_options);
    int status = ERROR_NOT_FOUND;

    /* find the config_option by key */
    for (i = 0; i < count; i++) {
        if (stricmp(pair->key, g_options[i].key) == 0) {
            *option = &g_options[i];
            status = NO_ERROR;
            break;
        }
    }
    return status;
}

config_init()

static int config_init ( struct idmap_config *  config )

static

Definition at line 362 of file idmap.c.

Referenced by nfs41_idmap_create().

{
    int status;
#ifdef __REACTOS__
    char config_path[MAX_PATH];
#endif

    /* load default values */
    status = config_defaults(config);
    if (status) {
        eprintf("config_defaults() failed with %d\n", status);
        goto out;
    }

#ifdef __REACTOS__
    if (GetSystemDirectoryA(config_path, ARRAYSIZE(config_path)))
    {
        StringCchCatA(config_path, ARRAYSIZE(config_path), "\\drivers\\etc\\ms-nfs41-idmap.conf");
    }
    else
    {
        StringCchCopyA(config_path, ARRAYSIZE(config_path), "C:\\ReactOS\\system32\\drivers\\etc\\ms-nfs41-idmap.conf");
    }
#endif

    /* load configuration from file */
#ifdef __REACTOS__
    status = config_load(config, config_path);
#else
    status = config_load(config, CONFIG_FILENAME);
#endif
    if (status) {
#ifdef __REACTOS__
        eprintf("config_load('%s') failed with %d\n", config_path, status);
#else
        eprintf("config_load('%s') failed with %d\n", CONFIG_FILENAME, status);
#endif
        goto out;
    }
out:
    return status;
}

config_load()

static int config_load ( struct idmap_config *  config, const char *  filename  )

static

Definition at line 293 of file idmap.c.

Referenced by config_init().

{
    char buffer[1024], *pos;
    FILE *file;
    struct config_pair pair;
    const struct config_option *option;
    int line = 0;
    int status = NO_ERROR;

    /* open the file */
    file = fopen(filename, "r");
    if (file == NULL) {
        eprintf("config_load() failed to open file '%s'\n", filename);
        goto out;
    }

    /* read each line */
    while (fgets(buffer, sizeof(buffer), file)) {
        line++;

        /* skip whitespace */
        pos = buffer;
        while (isspace(*pos)) pos++;

        /* skip comments and empty lines */
        if (*pos == '#' || *pos == 0)
            continue;

        /* parse line into a key=value pair */
        status = config_parse_pair(buffer, &pair);
        if (status) {
            eprintf("error on line %d: %s\n", line, buffer);
            break;
        }

        /* find the config_option by key */
        status = config_find_option(&pair, &option);
        if (status) {
            eprintf("unrecognized option '%s' on line %d: %s\n",
                pair.key, line, buffer);
            status = ERROR_INVALID_PARAMETER;
            break;
        }

        if (option->type == TYPE_INT) {
            if (!parse_uint(pair.value, (UINT*)((char*)config + option->offset))) {
                status = ERROR_INVALID_PARAMETER;
                eprintf("expected a number on line %d: %s=\"%s\"\n",
                    line, pair.key, pair.value);
                break;
            }
        } else {
            if (FAILED(StringCchCopyNA((char*)config + option->offset,
                    option->max_len, pair.value, pair.value_len))) {
                status = ERROR_BUFFER_OVERFLOW;
                eprintf("overflow on line %d: %s=\"%s\"\n",
                    line, pair.key, pair.value);
                break;
            }
        }
    }

    fclose(file);
out:
    return status;
}

config_parse_pair()

static int config_parse_pair ( char *  line, struct config_pair *  pair  )

static

Definition at line 153 of file idmap.c.

Referenced by config_load().

{
    char *pos = line;
    int status = NO_ERROR;

    /* terminate at comment */
    pos = strchr(line, '#');
    if (pos) *pos = 0;

    /* skip whitespace before key */
    pos = line;
    while (isspace(*pos)) pos++;
    pair->key = pos;

    pos = strchr(pos, '=');
    if (pos == NULL) {
        eprintf("missing '='\n");
        status = ERROR_INVALID_PARAMETER;
        goto out;
    }

    /* skip whitespace after key */
    pair->key_len = pos - pair->key;
    while (pair->key_len && isspace(pair->key[pair->key_len-1]))
        pair->key_len--;

    if (pair->key_len <= 0) {
        eprintf("empty key\n");
        status = ERROR_INVALID_PARAMETER;
        goto out;
    }

    /* skip whitespace after = */
    pos++;
    while (isspace(*pos)) pos++;

    if (*pos == 0) {
        eprintf("end of line looking for value\n");
        status = ERROR_INVALID_PARAMETER;
        goto out;
    }

    if (*pos == '\"') {
        /* value is between the "s */
        pair->value = pos + 1;
        pos = strchr(pair->value, '\"');
        if (pos == NULL) {
            eprintf("no matching '\"'\n");
            status = ERROR_INVALID_PARAMETER;
            goto out;
        }
        pair->value_len = pos - pair->value;
    } else {
        pair->value = pos;
        pair->value_len = strlen(pair->value);

        /* skip whitespace after value */
        while (pair->value_len && isspace(pair->value[pair->value_len-1]))
            pair->value_len--;
    }

    /* on success, null terminate the key and value */
    ((char*)pair->key)[pair->key_len] = 0;
    ((char*)pair->value)[pair->value_len] = 0;
out:
    return status;
}

gid_cmp()

static int gid_cmp ( const struct list_entry *  list, const void *  value  )

static

Definition at line 1045 of file idmap.c.

Referenced by nfs41_idmap_gid_to_group().

{
    const struct idmap_group *entry = list_container(list,
        const struct idmap_group, entry);
    const UINT_PTR gid = (const UINT_PTR)value;
    return (UINT)gid - entry->gid;
}

group_cache_alloc()

static struct list_entry* group_cache_alloc ( )

static

Definition at line 542 of file idmap.c.

{
    struct idmap_group *group = calloc(1, sizeof(struct idmap_group));
    return group == NULL ? NULL : &group->entry;
}

group_cache_copy()

static void group_cache_copy ( struct list_entry *  lhs, const struct list_entry *  rhs  )

static

Definition at line 551 of file idmap.c.

{
    struct idmap_group *dst = list_container(lhs, struct idmap_group, entry);
    const struct idmap_group *src = list_container(rhs, const struct idmap_group, entry);
    StringCchCopyA(dst->name, VAL_LEN, src->name);
    dst->gid = src->gid;
    dst->last_updated = src->last_updated;
}

group_cache_free()

static void group_cache_free ( struct list_entry *  entry )

static

Definition at line 547 of file idmap.c.

{
    free(list_container(entry, struct idmap_group, entry));
}

group_cmp()

static int group_cmp ( const struct list_entry *  list, const void *  value  )

static

Definition at line 1007 of file idmap.c.

Referenced by nfs41_idmap_group_to_gid().

{
    const struct idmap_group *entry = list_container(list,
        const struct idmap_group, entry);
    const char *group = (const char*)value;
    return strcmp(entry->name, group);
}

idmap_filter()

static int idmap_filter ( struct idmap_config *  config, const struct idmap_lookup *  lookup, char *  filter, size_t  filter_len  )

static

Definition at line 577 of file idmap.c.

Referenced by idmap_query_attrs().

{
    UINT_PTR i;
    int status = NO_ERROR;

    switch (lookup->type) {
    case TYPE_INT:
        i = (UINT_PTR)lookup->value;
        if (FAILED(StringCchPrintfA(filter, filter_len,
                "(&(objectClass=%s)(%s=%u))",
                config->classes[lookup->klass],
                config->attributes[lookup->attr], (UINT)i))) {
            status = ERROR_BUFFER_OVERFLOW;
            eprintf("ldap filter buffer overflow: '%s=%u'\n",
                config->attributes[lookup->attr], (UINT)i);
        }
        break;

    case TYPE_STR:
        if (FAILED(StringCchPrintfA(filter, filter_len,
                "(&(objectClass=%s)(%s=%s))",
                config->classes[lookup->klass],
                config->attributes[lookup->attr], lookup->value))) {
            status = ERROR_BUFFER_OVERFLOW;
            eprintf("ldap filter buffer overflow: '%s=%s'\n",
                config->attributes[lookup->attr], lookup->value);
        }
        break;

    default:
        status = ERROR_INVALID_PARAMETER;
        break;
    }
    return status;
}

idmap_lookup_group()

static int idmap_lookup_group ( struct idmap_context *  context, const struct idmap_lookup *  lookup, struct idmap_group *  group  )

static

Definition at line 748 of file idmap.c.

Referenced by nfs41_idmap_gid_to_group(), and nfs41_idmap_group_to_gid().

{
    PCHAR* values[NUM_ATTRIBUTES] = { NULL };
    const unsigned attributes = ATTR_FLAG(ATTR_GROUP_NAME)
        | ATTR_FLAG(ATTR_GID);
    int i, status;

    /* check the group cache for an existing entry */
    status = cache_lookup(&context->groups, lookup, &group->entry);
    if (status == NO_ERROR) {
        /* don't return expired entries; query new attributes
         * and overwrite the entry with cache_insert() */
        if (time(NULL) - group->last_updated < context->config.cache_ttl)
            goto out;
    }

    /* send the query to the ldap server */
    status = idmap_query_attrs(context, lookup,
        attributes, 0, values, NUM_ATTRIBUTES);
    if (status)
        goto out_free_values;

    /* parse attributes */
    if (FAILED(StringCchCopyA(group->name, VAL_LEN,
            *values[ATTR_GROUP_NAME]))) {
        eprintf("ldap attribute %s='%s' longer than %u characters\n",
            context->config.attributes[ATTR_GROUP_NAME],
            *values[ATTR_GROUP_NAME], VAL_LEN);
        status = ERROR_BUFFER_OVERFLOW;
        goto out_free_values;
    }
    if (!parse_uint(*values[ATTR_GID], &group->gid)) {
        eprintf("failed to parse ldap attribute %s='%s'\n",
            context->config.attributes[ATTR_GID], *values[ATTR_GID]);
        status = ERROR_INVALID_PARAMETER;
        goto out_free_values;
    }
    group->last_updated = time(NULL);

    if (context->config.cache_ttl) {
        /* insert the entry into the cache */
        cache_insert(&context->groups, lookup, &group->entry);
    }
out_free_values:
    for (i = 0; i < NUM_ATTRIBUTES; i++)
        ldap_value_free(values[i]);
out:
    return status;
}

idmap_lookup_user()

static int idmap_lookup_user ( struct idmap_context *  context, const struct idmap_lookup *  lookup, struct idmap_user *  user  )

static

Definition at line 677 of file idmap.c.

Referenced by nfs41_idmap_name_to_ids(), nfs41_idmap_principal_to_ids(), and nfs41_idmap_uid_to_name().

{
    PCHAR* values[NUM_ATTRIBUTES] = { NULL };
    const unsigned attributes = ATTR_FLAG(ATTR_USER_NAME)
        | ATTR_FLAG(ATTR_PRINCIPAL)
        | ATTR_FLAG(ATTR_UID)
        | ATTR_FLAG(ATTR_GID);
    /* principal is optional; we'll cache it if we have it */
    const unsigned optional = ATTR_FLAG(ATTR_PRINCIPAL);
    int i, status;

    /* check the user cache for an existing entry */
    status = cache_lookup(&context->users, lookup, &user->entry);
    if (status == NO_ERROR) {
        /* don't return expired entries; query new attributes
         * and overwrite the entry with cache_insert() */
        if (time(NULL) - user->last_updated < context->config.cache_ttl)
            goto out;
    }

    /* send the query to the ldap server */
    status = idmap_query_attrs(context, lookup,
        attributes, optional, values, NUM_ATTRIBUTES);
    if (status)
        goto out_free_values;

    /* parse attributes */
    if (FAILED(StringCchCopyA(user->username, VAL_LEN,
            *values[ATTR_USER_NAME]))) {
        eprintf("ldap attribute %s='%s' longer than %u characters\n",
            context->config.attributes[ATTR_USER_NAME],
            *values[ATTR_USER_NAME], VAL_LEN);
        status = ERROR_BUFFER_OVERFLOW;
        goto out_free_values;
    }
    if (FAILED(StringCchCopyA(user->principal, VAL_LEN,
            values[ATTR_PRINCIPAL] ? *values[ATTR_PRINCIPAL] : ""))) {
        eprintf("ldap attribute %s='%s' longer than %u characters\n",
            context->config.attributes[ATTR_PRINCIPAL],
            values[ATTR_PRINCIPAL] ? *values[ATTR_PRINCIPAL] : "", VAL_LEN);
        status = ERROR_BUFFER_OVERFLOW;
        goto out_free_values;
    }
    if (!parse_uint(*values[ATTR_UID], &user->uid)) {
        eprintf("failed to parse ldap attribute %s='%s'\n",
            context->config.attributes[ATTR_UID], *values[ATTR_UID]);
        status = ERROR_INVALID_PARAMETER;
        goto out_free_values;
    }
    if (!parse_uint(*values[ATTR_GID], &user->gid)) {
        eprintf("failed to parse ldap attribute %s='%s'\n",
            context->config.attributes[ATTR_GID], *values[ATTR_GID]);
        status = ERROR_INVALID_PARAMETER;
        goto out_free_values;
    }
    user->last_updated = time(NULL);

    if (context->config.cache_ttl) {
        /* insert the entry into the cache */
        cache_insert(&context->users, lookup, &user->entry);
    }
out_free_values:
    for (i = 0; i < NUM_ATTRIBUTES; i++)
        ldap_value_free(values[i]);
out:
    return status;
}

idmap_query_attrs()

static int idmap_query_attrs ( struct idmap_context *  context, const struct idmap_lookup *  lookup, const unsigned  attributes, const unsigned  optional, PCHAR *  values[], const int  len  )

static

Definition at line 617 of file idmap.c.

Referenced by idmap_lookup_group(), and idmap_lookup_user().

{
    char filter[FILTER_LEN];
    struct idmap_config *config = &context->config;
    LDAPMessage *res = NULL, *entry;
    int i, status;

    /* format the ldap filter */
    status = idmap_filter(config, lookup, filter, FILTER_LEN);
    if (status)
        goto out;

    /* send the ldap query */
    status = ldap_search_st(context->ldap, config->base,
        LDAP_SCOPE_SUBTREE, filter, NULL, 0, NULL, &res);
    if (status) {
        eprintf("ldap search for '%s' failed with %d: %s\n",
            filter, status, ldap_err2stringA(status));
        status = LdapMapErrorToWin32(status);
        goto out;
    }

    entry = ldap_first_entry(context->ldap, res);
    if (entry == NULL) {
        status = LDAP_NO_RESULTS_RETURNED;
        eprintf("ldap search for '%s' failed with %d: %s\n",
            filter, status, ldap_err2stringA(status));
        status = LdapMapErrorToWin32(status);
        goto out;
    }

    /* fetch the attributes */
    for (i = 0; i < len; i++) {
        if (ATTR_ISSET(attributes, i)) {
            values[i] = ldap_get_values(context->ldap,
                entry, config->attributes[i]);

            /* fail if required attributes are missing */
            if (values[i] == NULL && !ATTR_ISSET(optional, i)) {
                status = LDAP_NO_SUCH_ATTRIBUTE;
                eprintf("ldap entry for '%s' missing required "
                    "attribute '%s', returning %d: %s\n",
                    filter, config->attributes[i],
                    status, ldap_err2stringA(status));
                status = LdapMapErrorToWin32(status);
                goto out;
            }
        }
    }
out:
    if (res) ldap_msgfree(res);
    return status;
}

nfs41_idmap_create()

int nfs41_idmap_create

(

struct idmap_context **

context_out

)

Definition at line 803 of file idmap.c.

Referenced by ServiceStart().

{
    struct idmap_context *context;
    int status = NO_ERROR;

    context = calloc(1, sizeof(struct idmap_context));
    if (context == NULL) {
        status = GetLastError();
        goto out;
    }

    /* initialize the caches */
    cache_init(&context->users, &user_cache_ops);
    cache_init(&context->groups, &group_cache_ops);

    /* load ldap configuration from file */
    status = config_init(&context->config);
    if (status) {
        eprintf("config_init() failed with %d\n", status);
        goto out_err_free;
    }

    /* initialize ldap and configure options */
    context->ldap = ldap_init(context->config.hostname, context->config.port);
    if (context->ldap == NULL) {
        status = LdapGetLastError();
        eprintf("ldap_init(%s) failed with %d: %s\n",
            context->config.hostname, status, ldap_err2stringA(status));
        status = LdapMapErrorToWin32(status);
        goto out_err_free;
    }

    status = ldap_set_option(context->ldap, LDAP_OPT_PROTOCOL_VERSION,
        (void *)&context->config.version);
    if (status != LDAP_SUCCESS) {
        eprintf("ldap_set_option(version=%d) failed with %d\n",
            context->config.version, status);
        status = LdapMapErrorToWin32(status);
        goto out_err_free;
    }

    if (context->config.timeout) {
        status = ldap_set_option(context->ldap, LDAP_OPT_TIMELIMIT,
            (void *)&context->config.timeout);
        if (status != LDAP_SUCCESS) {
            eprintf("ldap_set_option(timeout=%d) failed with %d\n",
                context->config.timeout, status);
            status = LdapMapErrorToWin32(status);
            goto out_err_free;
        }
    }

    *context_out = context;
out:
    return status;

out_err_free:
    nfs41_idmap_free(context);
    goto out;
}

nfs41_idmap_free()

void nfs41_idmap_free

(

struct idmap_context *

context

)

Definition at line 865 of file idmap.c.

Referenced by nfs41_idmap_create(), and ServiceStart().

{
    /* clean up the connection */
    if (context->ldap)
        ldap_unbind(context->ldap);

    cache_cleanup(&context->users);
    cache_cleanup(&context->groups);
    free(context);
}

nfs41_idmap_gid_to_group()

int nfs41_idmap_gid_to_group	(	struct idmap_context *	context,
		gid_t	gid,
		char *	name,
		size_t	len
	)

Definition at line 1053 of file idmap.c.

{
    UINT_PTR gidp = gid; /* convert to pointer size to pass as void* */
    struct idmap_lookup lookup = { ATTR_GID, CLASS_GROUP, TYPE_INT, gid_cmp };
    struct idmap_group group;
    int status;

    dprintf(IDLVL, "--> nfs41_idmap_gid_to_group(%u)\n", gid);

    lookup.value = (const void*)gidp;

    /* look up the group entry */
    status = idmap_lookup_group(context, &lookup, &group);
    if (status) {
        dprintf(IDLVL, "<-- nfs41_idmap_gid_to_group(%u) "
            "failed with %d\n", gid, status);
        goto out;
    }

    if (FAILED(StringCchCopyA(name, len, group.name))) {
        status = ERROR_BUFFER_OVERFLOW;
        eprintf("group name buffer overflow: '%s' > %u\n",
            group.name, len);
        goto out;
    }

    dprintf(IDLVL, "<-- nfs41_idmap_gid_to_group(%u) "
        "returning '%s'\n", gid, name);
out:
    return status;
}

nfs41_idmap_group_to_gid()

int nfs41_idmap_group_to_gid	(	struct idmap_context *	context,
		const char *	name,
		gid_t *	gid_out
	)

Definition at line 1015 of file idmap.c.

{
    struct idmap_lookup lookup = { ATTR_GROUP_NAME,
        CLASS_GROUP, TYPE_STR, group_cmp };
    struct idmap_group group;
    int status;

    dprintf(IDLVL, "--> nfs41_idmap_group_to_gid('%s')\n", name);

    lookup.value = name;

    /* look up the group entry */
    status = idmap_lookup_group(context, &lookup, &group);
    if (status) {
        dprintf(IDLVL, "<-- nfs41_idmap_group_to_gid('%s') "
            "failed with %d\n", name, status);
        goto out;
    }

    *gid_out = group.gid;
    dprintf(IDLVL, "<-- nfs41_idmap_group_to_gid('%s') "
        "returning %u\n", name, group.gid);
out:
    return status;
}

nfs41_idmap_name_to_ids()

int nfs41_idmap_name_to_ids	(	struct idmap_context *	context,
		const char *	username,
		uid_t *	uid_out,
		gid_t *	gid_out
	)

Definition at line 887 of file idmap.c.

Referenced by map_user_to_ids().

{
    struct idmap_lookup lookup = { ATTR_USER_NAME,
        CLASS_USER, TYPE_STR, username_cmp };
    struct idmap_user user;
    int status;

    if (context == NULL)
        return ERROR_FILE_NOT_FOUND;

    dprintf(IDLVL, "--> nfs41_idmap_name_to_ids('%s')\n", username);

    lookup.value = username;

    /* look up the user entry */
    status = idmap_lookup_user(context, &lookup, &user);
    if (status) {
        dprintf(IDLVL, "<-- nfs41_idmap_name_to_ids('%s') "
            "failed with %d\n", username, status);
        goto out;
    }

    *uid_out = user.uid;
    *gid_out = user.gid;
    dprintf(IDLVL, "<-- nfs41_idmap_name_to_ids('%s') "
        "returning uid=%u, gid=%u\n", username, user.uid, user.gid);
out:
    return status;
}

nfs41_idmap_principal_to_ids()

int nfs41_idmap_principal_to_ids	(	struct idmap_context *	context,
		const char *	principal,
		uid_t *	uid_out,
		gid_t *	gid_out
	)

Definition at line 975 of file idmap.c.

{
    struct idmap_lookup lookup = { ATTR_PRINCIPAL,
        CLASS_USER, TYPE_STR, principal_cmp };
    struct idmap_user user;
    int status;

    dprintf(IDLVL, "--> nfs41_idmap_principal_to_ids('%s')\n", principal);

    lookup.value = principal;

    /* look up the user entry */
    status = idmap_lookup_user(context, &lookup, &user);
    if (status) {
        dprintf(IDLVL, "<-- nfs41_idmap_principal_to_ids('%s') "
            "failed with %d\n", principal, status);
        goto out;
    }

    *uid_out = user.uid;
    *gid_out = user.gid;
    dprintf(IDLVL, "<-- nfs41_idmap_principal_to_ids('%s') "
        "returning uid=%u, gid=%u\n", principal, user.uid, user.gid);
out:
    return status;
}

nfs41_idmap_uid_to_name()

int nfs41_idmap_uid_to_name	(	struct idmap_context *	context,
		uid_t	uid,
		char *	name,
		size_t	len
	)

Definition at line 930 of file idmap.c.

{
    UINT_PTR uidp = uid; /* convert to pointer size to pass as void* */
    struct idmap_lookup lookup = { ATTR_UID, CLASS_USER, TYPE_INT, uid_cmp };
    struct idmap_user user;
    int status;

    dprintf(IDLVL, "--> nfs41_idmap_uid_to_name(%u)\n", uid);

    lookup.value = (const void*)uidp;

    /* look up the user entry */
    status = idmap_lookup_user(context, &lookup, &user);
    if (status) {
        dprintf(IDLVL, "<-- nfs41_idmap_uid_to_name(%u) "
            "failed with %d\n", uid, status);
        goto out;
    }

    if (FAILED(StringCchCopyA(name, len, user.username))) {
        status = ERROR_BUFFER_OVERFLOW;
        eprintf("username buffer overflow: '%s' > %u\n",
            user.username, len);
        goto out;
    }

    dprintf(IDLVL, "<-- nfs41_idmap_uid_to_name(%u) "
        "returning '%s'\n", uid, name);
out:
    return status;
}

parse_uint()

static BOOL parse_uint ( const char *  str, UINT *  id_out  )

static

Definition at line 223 of file idmap.c.

Referenced by config_defaults(), config_load(), idmap_lookup_group(), and idmap_lookup_user().

{
    PCHAR endp;
    const UINT id = strtoul(str, &endp, 10);

    /* must convert the whole string */
    if ((endp - str) < (ptrdiff_t)strlen(str))
        return FALSE;

    /* result must fit in 32 bits */
    if (id == ULONG_MAX && errno == ERANGE)
        return FALSE;

    *id_out = id;
    return TRUE;
}

principal_cmp()

static int principal_cmp ( const struct list_entry *  list, const void *  value  )

static

Definition at line 967 of file idmap.c.

Referenced by nfs41_idmap_principal_to_ids().

{
    const struct idmap_user *entry = list_container(list,
        const struct idmap_user, entry);
    const char *principal = (const char*)value;
    return strcmp(entry->principal, principal);
}

uid_cmp()

static int uid_cmp ( const struct list_entry *  list, const void *  value  )

static

Definition at line 922 of file idmap.c.

Referenced by nfs41_idmap_uid_to_name().

{
    const struct idmap_user *entry = list_container(list,
        const struct idmap_user, entry);
    const UINT_PTR uid = (const UINT_PTR)value;
    return (UINT)uid - entry->uid;
}

user_cache_alloc()

static struct list_entry* user_cache_alloc ( )

static

Definition at line 506 of file idmap.c.

{
    struct idmap_user *user = calloc(1, sizeof(struct idmap_user));
    return user == NULL ? NULL : &user->entry;
}

user_cache_copy()

static void user_cache_copy ( struct list_entry *  lhs, const struct list_entry *  rhs  )

static

Definition at line 515 of file idmap.c.

{
    struct idmap_user *dst = list_container(lhs, struct idmap_user, entry);
    const struct idmap_user *src = list_container(rhs, const struct idmap_user, entry);
    StringCchCopyA(dst->username, VAL_LEN, src->username);
    StringCchCopyA(dst->principal, VAL_LEN, src->principal);
    dst->uid = src->uid;
    dst->gid = src->gid;
    dst->last_updated = src->last_updated;
}

user_cache_free()

static void user_cache_free ( struct list_entry *  entry )

static

Definition at line 511 of file idmap.c.

{
    free(list_container(entry, struct idmap_user, entry));
}

username_cmp()

static int username_cmp ( const struct list_entry *  list, const void *  value  )

static

Definition at line 879 of file idmap.c.

Referenced by nfs41_idmap_name_to_ids().

{
    const struct idmap_user *entry = list_container(list,
        const struct idmap_user, entry);
    const char *username = (const char*)value;
    return strcmp(entry->username, username);
}

Variable Documentation

CONFIG_FILENAME

const char CONFIG_FILENAME[] = "C:\\ReactOS\\System32\\drivers\\etc\\ms-nfs41-idmap.conf"

static

Definition at line 79 of file idmap.c.

Referenced by config_init().

g_options

const struct config_option g_options[]

static

Initial value:

= {
    
    OPT_STR("ldap_hostname", "localhost", hostname, NFS41_HOSTNAME_LEN+1),
    OPT_INT("ldap_port", "389", port),
    OPT_INT("ldap_version", "3", version),
    OPT_INT("ldap_timeout", "0", timeout),

    
    OPT_STR("ldap_base", "cn=localhost", base, VAL_LEN),
    OPT_CLASS("ldap_class_users", "user", CLASS_USER),
    OPT_CLASS("ldap_class_groups", "group", CLASS_GROUP),
    OPT_ATTR("ldap_attr_username", "cn", ATTR_USER_NAME),
    OPT_ATTR("ldap_attr_groupname", "cn", ATTR_GROUP_NAME),
    OPT_ATTR("ldap_attr_gssAuthName", "gssAuthName", ATTR_PRINCIPAL),
    OPT_ATTR("ldap_attr_uidNumber", "uidNumber", ATTR_UID),
    OPT_ATTR("ldap_attr_gidNumber", "gidNumber", ATTR_GID),

    
    OPT_INT("cache_ttl", "60", cache_ttl),
}

Definition at line 123 of file idmap.c.

group_cache_ops

const struct cache_ops group_cache_ops

static

Initial value:

= {
    group_cache_alloc,
    group_cache_free,
    group_cache_copy
}

Definition at line 561 of file idmap.c.

user_cache_ops

const struct cache_ops user_cache_ops

static

Initial value:

= {
    user_cache_alloc,
    user_cache_free,
    user_cache_copy
}

Definition at line 527 of file idmap.c.