nfs41_client.c File Reference

#include <windows.h>
#include <stdio.h>
#include <time.h>
#include <winsock2.h>
#include <iphlpapi.h>
#include <wincrypt.h>
#include "tree.h"
#include "delegation.h"
#include "daemon_debug.h"
#include "nfs41_ops.h"

Include dependency graph for nfs41_client.c:

Go to the source code of this file.

Classes
struct	mac_entry

Functions
uint32_t	nfs41_exchange_id_flags (IN bool_t is_data)
static int	pnfs_client_init (IN nfs41_client *client)
static int	update_server (IN nfs41_client *client, IN const char *server_scope, IN const server_owner4 *owner)
static int	update_exchangeid_res (IN nfs41_client *client, IN const nfs41_exchange_id_res *exchangeid)
int	nfs41_client_create (IN nfs41_rpc_clnt *rpc, IN const client_owner4 *owner, IN bool_t is_data, IN const nfs41_exchange_id_res *exchangeid, OUT nfs41_client **client_out)
static void	dprint_roles (IN int level, IN uint32_t roles)
int	nfs41_client_renew (IN nfs41_client *client)
void	nfs41_client_free (IN nfs41_client *client)
int	mac_cmp (struct mac_entry *lhs, struct mac_entry *rhs)
	RB_HEAD (mac_tree, mac_entry)
static void	mac_entry_insert (IN struct mac_tree *root, IN PBYTE address, IN ULONG length)
static int	adapter_valid (IN const IP_ADAPTER_ADDRESSES *addr)
static DWORD	hash_mac_addrs (IN HCRYPTHASH hash)
int	nfs41_client_owner (IN const char *name, IN uint32_t sec_flavor, OUT client_owner4 *owner)

Function Documentation

adapter_valid()

static int adapter_valid ( IN const IP_ADAPTER_ADDRESSES *  addr )

static

Definition at line 276 of file nfs41_client.c.

{
    /* ignore generic interfaces whose address is not unique */
    switch (addr->IfType) {
    case IF_TYPE_SOFTWARE_LOOPBACK:
    case IF_TYPE_TUNNEL:
        return 0;
    }
    /* must have an address */
    if (addr->PhysicalAddressLength == 0)
        return 0;
#ifndef __REACTOS__
    /* must support ip */
    return addr->Ipv4Enabled || addr->Ipv6Enabled;
#else
    return 1;
#endif
}

Referenced by hash_mac_addrs().

dprint_roles()

static void dprint_roles ( IN int  level, IN uint32_t  roles  )

static

Definition at line 158 of file nfs41_client.c.

{
    dprintf(level, "roles: %s%s%s\n",
        (roles & EXCHGID4_FLAG_USE_NON_PNFS) ? "USE_NON_PNFS " : "",
        (roles & EXCHGID4_FLAG_USE_PNFS_MDS) ? "USE_PNFS_MDS " : "",
        (roles & EXCHGID4_FLAG_USE_PNFS_DS) ? "USE_PNFS_DS" : "");
}

Referenced by nfs41_client_renew().

hash_mac_addrs()

static DWORD hash_mac_addrs ( IN HCRYPTHASH  hash )

static

Definition at line 296 of file nfs41_client.c.

{
    PIP_ADAPTER_ADDRESSES addr, addrs = NULL;
    struct mac_tree rbtree = RB_INITIALIZER(rbtree);
    struct mac_entry *entry, *node;
    ULONG len;
    DWORD status;
 
    /* start with enough room for DEFAULT_MINIMUM_ENTITIES */
    len = DEFAULT_MINIMUM_ENTITIES * sizeof(IP_ADAPTER_ADDRESSES);
 
    do {
        PIP_ADAPTER_ADDRESSES tmp;
        /* reallocate the buffer until we can fit all of it */
        tmp = realloc(addrs, len);
        if (tmp == NULL) {
            status = GetLastError();
            goto out;
        }
        addrs = tmp;
        status = GetAdaptersAddresses(AF_UNSPEC,
            GAA_FLAG_INCLUDE_ALL_INTERFACES | GAA_FLAG_SKIP_ANYCAST |
            GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME |
            GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_UNICAST,
            NULL, addrs, &len);
    } while (status == ERROR_BUFFER_OVERFLOW);
 
    if (status) {
        eprintf("GetAdaptersAddresses() failed with %d\n", status);
        goto out;
    }
 
    /* get the mac address of each adapter */
    for (addr = addrs; addr; addr = addr->Next)
        if (adapter_valid(addr))
            mac_entry_insert(&rbtree, addr->PhysicalAddress,
                addr->PhysicalAddressLength);
 
    /* require at least one valid address */
    if (RB_EMPTY(&rbtree)) {
        status = ERROR_FILE_NOT_FOUND;
        eprintf("GetAdaptersAddresses() did not return "
            "any valid mac addresses, failing with %d.\n", status);
        goto out;
    }
 
    RB_FOREACH_SAFE(entry, mac_tree, &rbtree, node) {
        RB_REMOVE(mac_tree, &rbtree, entry);
 
        if (!CryptHashData(hash, entry->address, entry->length, 0)) {
            status = GetLastError();
            eprintf("CryptHashData() failed with %d\n", status);
            /* don't break here, we need to free the rest */
        }
        free(entry);
    }
out:
    free(addrs);
    return status;
}

Referenced by nfs41_client_owner().

mac_cmp()

int mac_cmp	(	struct mac_entry *	lhs,
		struct mac_entry *	rhs
	)

Definition at line 249 of file nfs41_client.c.

{
    const int diff = rhs->length - lhs->length;
    return diff ? diff : strncmp((const char*)lhs->address,
        (const char*)rhs->address, lhs->length);
}

mac_entry_insert()

static void mac_entry_insert ( IN struct mac_tree *  root, IN PBYTE  address, IN ULONG  length  )

static

Definition at line 258 of file nfs41_client.c.

{
    struct mac_entry *entry;
 
    entry = calloc(1, sizeof(struct mac_entry));
    if (entry == NULL)
        return;
 
    entry->address = address;
    entry->length = length;
 
    if (RB_INSERT(mac_tree, root, entry))
        free(entry);
}

Referenced by hash_mac_addrs().

nfs41_client_create()

int nfs41_client_create	(	IN nfs41_rpc_clnt *	rpc,
		IN const client_owner4 *	owner,
		IN bool_t	is_data,
		IN const nfs41_exchange_id_res *	exchangeid,
		OUT nfs41_client **	client_out
	)

Definition at line 108 of file nfs41_client.c.

{
    int status;
    nfs41_client *client;
 
    client = calloc(1, sizeof(nfs41_client));
    if (client == NULL) {
        status = GetLastError();
        goto out_err_rpc;
    }
 
    memcpy(&client->owner, owner, sizeof(client_owner4));
    client->rpc = rpc;
    client->is_data = is_data;
 
    status = update_exchangeid_res(client, exchangeid);
    if (status)
        goto out_err_client;
 
    list_init(&client->state.opens);
    list_init(&client->state.delegations);
    InitializeCriticalSection(&client->state.lock);
 
    //initialize a lock used to protect access to client id and client id seq#
    InitializeSRWLock(&client->exid_lock);
 
    InitializeConditionVariable(&client->recovery.cond);
    InitializeCriticalSection(&client->recovery.lock);
 
    status = pnfs_client_init(client);
    if (status) {
        eprintf("pnfs_client_init() failed with %d\n", status);
        goto out_err_client;
    }
    *client_out = client;
out:
    return status;
out_err_client:
    nfs41_client_free(client); /* also calls nfs41_rpc_clnt_free() */
    goto out;
out_err_rpc:
    nfs41_rpc_clnt_free(rpc);
    goto out;
}

nfs41_client_free()

void nfs41_client_free

(

IN nfs41_client *

client

)

Definition at line 206 of file nfs41_client.c.

{
    dprintf(2, "nfs41_client_free(%llu)\n", client->clnt_id);
    nfs41_client_delegation_free(client);
    if (client->session) nfs41_session_free(client->session);
    nfs41_destroy_clientid(client->rpc, client->clnt_id);
    if (client->server) nfs41_server_deref(client->server);
    nfs41_rpc_clnt_free(client->rpc);
    if (client->layouts) pnfs_layout_list_free(client->layouts);
    if (client->devices) pnfs_file_device_list_free(client->devices);
    DeleteCriticalSection(&client->state.lock);
    DeleteCriticalSection(&client->recovery.lock);
    free(client);
}

Referenced by nfs41_client_create(), nfs41_root_mount_addrs(), root_client_create(), and root_free().

nfs41_client_owner()

int nfs41_client_owner	(	IN const char *	name,
		IN uint32_t	sec_flavor,
		OUT client_owner4 *	owner
	)

Definition at line 358 of file nfs41_client.c.

{
    HCRYPTPROV context;
    HCRYPTHASH hash;
    PBYTE buffer;
    DWORD length;
    const ULONGLONG time_created = GetTickCount64();
    int status;
    char username[UNLEN + 1];
    DWORD len = UNLEN + 1;
 
    if (!GetUserNameA(username, &len)) {
        status = GetLastError();
        eprintf("GetUserName() failed with %d\n", status);
        goto out;
    }
 
    /* owner.verifier = "time created" */
    memcpy(owner->co_verifier, &time_created, sizeof(time_created));
 
    /* set up the md5 hash generator */
    if (!CryptAcquireContext(&context, NULL, NULL,
        PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
        status = GetLastError();
        eprintf("CryptAcquireContext() failed with %d\n", status);
        goto out;
    }
    if (!CryptCreateHash(context, CALG_MD5, 0, 0, &hash)) {
        status = GetLastError();
        eprintf("CryptCreateHash() failed with %d\n", status);
        goto out_context;
    }
 
    if (!CryptHashData(hash, (const BYTE*)&sec_flavor, (DWORD)sizeof(sec_flavor), 0)) {
        status = GetLastError();
        eprintf("CryptHashData() failed with %d\n", status);
        goto out_hash;
    }
 
    if (!CryptHashData(hash, (const BYTE*)username, (DWORD)strlen(username), 0)) {
        status = GetLastError();
        eprintf("CryptHashData() failed with %d\n", status);
        goto out_hash;
    }
 
    if (!CryptHashData(hash, (const BYTE*)name, (DWORD)strlen(name), 0)) {
        status = GetLastError();
        eprintf("CryptHashData() failed with %d\n", status);
        goto out_hash;
    }
 
    /* add the mac address from each applicable adapter to the hash */
    status = hash_mac_addrs(hash);
    if (status) {
        eprintf("hash_mac_addrs() failed with %d\n", status);
        goto out_hash;
    }
 
    /* extract the hash size (should always be 16 for md5) */
    buffer = (PBYTE)&owner->co_ownerid_len;
    length = (DWORD)sizeof(DWORD);
    if (!CryptGetHashParam(hash, HP_HASHSIZE, buffer, &length, 0)) {
        status = GetLastError();
        eprintf("CryptGetHashParam(size) failed with %d\n", status);
        goto out_hash;
    }
    /* extract the hash buffer */
    buffer = owner->co_ownerid;
    length = owner->co_ownerid_len;
    if (!CryptGetHashParam(hash, HP_HASHVAL, buffer, &length, 0)) {
        status = GetLastError();
        eprintf("CryptGetHashParam(val) failed with %d\n", status);
        goto out_hash;
    }
 
out_hash:
    CryptDestroyHash(hash);
out_context:
    CryptReleaseContext(context, 0);
out:
    return status;
}

Referenced by nfs41_root_create().

nfs41_client_renew()

int nfs41_client_renew

(

IN nfs41_client *

client

)

Definition at line 168 of file nfs41_client.c.

{
    nfs41_exchange_id_res exchangeid = { 0 };
    int status;
 
    status = nfs41_exchange_id(client->rpc, &client->owner,
        nfs41_exchange_id_flags(client->is_data), &exchangeid);
    if (status) {
        eprintf("nfs41_exchange_id() failed with %d\n", status);
        status = ERROR_BAD_NET_RESP;
        goto out;
    }
 
    if (client->is_data) { /* require USE_PNFS_DS */
        if ((exchangeid.flags & EXCHGID4_FLAG_USE_PNFS_DS) == 0) {
            eprintf("client expected USE_PNFS_DS\n");
            status = ERROR_BAD_NET_RESP;
            goto out;
        }
    } else { /* require USE_NON_PNFS or USE_PNFS_MDS */
        if ((exchangeid.flags & EXCHGID4_FLAG_USE_NON_PNFS) == 0 &&
            (exchangeid.flags & EXCHGID4_FLAG_USE_PNFS_MDS) == 0) {
            eprintf("client expected USE_NON_PNFS OR USE_PNFS_MDS\n");
            status = ERROR_BAD_NET_RESP;
            goto out;
        }
    }
 
    dprint_roles(2, exchangeid.flags);
 
    AcquireSRWLockExclusive(&client->exid_lock);
    status = update_exchangeid_res(client, &exchangeid);
    ReleaseSRWLockExclusive(&client->exid_lock);
out:
    return status;
}

Referenced by compound_encode_send_decode(), and nfs41_recover_session().

nfs41_exchange_id_flags()

uint32_t nfs41_exchange_id_flags

(

IN bool_t

is_data

)

Definition at line 36 of file nfs41_client.c.

{
    uint32_t flags = EXCHGID4_FLAG_SUPP_MOVED_REFER;
    if (is_data)
        flags |= EXCHGID4_FLAG_USE_PNFS_DS;
    else
        flags |= EXCHGID4_FLAG_USE_NON_PNFS | EXCHGID4_FLAG_USE_PNFS_MDS;
    return flags;
}

Referenced by nfs41_client_renew(), nfs41_root_mount_addrs(), root_client_find(), and root_client_find_addrs().

pnfs_client_init()

static int pnfs_client_init ( IN nfs41_client *  client )

static

Definition at line 47 of file nfs41_client.c.

{
    enum pnfs_status pnfsstat;
    int status = NO_ERROR;
 
    /* initialize the pnfs layout and device lists for metadata clients */
    pnfsstat = pnfs_layout_list_create(&client->layouts);
    if (pnfsstat) {
        status = ERROR_NOT_ENOUGH_MEMORY;
        goto out;
    }
    pnfsstat = pnfs_file_device_list_create(&client->devices);
    if (pnfsstat) {
        status = ERROR_NOT_ENOUGH_MEMORY;
        goto out_err_layouts;
    }
out:
    return status;
 
out_err_layouts:
    pnfs_layout_list_free(client->layouts);
    client->layouts = NULL;
    goto out;
}

Referenced by nfs41_client_create().

RB_HEAD()

RB_HEAD	(	mac_tree	,
		mac_entry
	)

update_exchangeid_res()

static int update_exchangeid_res ( IN nfs41_client *  client, IN const nfs41_exchange_id_res *  exchangeid  )

static

Definition at line 97 of file nfs41_client.c.

{
    client->clnt_id = exchangeid->clientid;
    client->seq_id = exchangeid->sequenceid;
    client->roles = exchangeid->flags & EXCHGID4_FLAG_MASK_PNFS;
    return update_server(client, exchangeid->server_scope,
        &exchangeid->server_owner);
}

Referenced by nfs41_client_create(), and nfs41_client_renew().

update_server()

static int update_server ( IN nfs41_client *  client, IN const char *  server_scope, IN const server_owner4 *  owner  )

static

Definition at line 73 of file nfs41_client.c.

{
    nfs41_server *server;
    int status;
 
    /* find a server matching the owner.major_id and scope */
    status = nfs41_server_find_or_create(owner->so_major_id,
        server_scope, nfs41_rpc_netaddr(client->rpc), &server);
    if (status)
        goto out;
 
    /* if the server is the same, we now have an extra reference. if
     * the servers are different, we still need to deref the old server.
     * so both cases can be treated the same */
    if (client->server)
        nfs41_server_deref(client->server);
    client->server = server;
out:
    return status;
}

Referenced by update_exchangeid_res().