nfs41_server.c File Reference

#include <windows.h>
#include <strsafe.h>
#include <stdio.h>
#include "wintirpc.h"
#include "rpc/rpc.h"
#include "name_cache.h"
#include "daemon_debug.h"
#include "nfs41.h"
#include "util.h"

Include dependency graph for nfs41_server.c:

Go to the source code of this file.

Classes
struct	server_list
struct	server_info

Macros
#define	SRVLVL   2 /* dprintf level for server logging */
#define	server_entry(pos)   list_container(pos, nfs41_server, entry)

Functions
void	nfs41_server_list_init ()
static int	server_compare (const struct list_entry *entry, const void *value)
static int	server_entry_find (IN struct server_list *servers, IN const struct server_info *info, OUT struct list_entry **entry_out)
static int	server_create (IN const struct server_info *info, OUT nfs41_server **server_out)
static void	server_free (IN nfs41_server *server)
static __inline void	server_ref_locked (IN nfs41_server *server)
void	nfs41_server_ref (IN nfs41_server *server)
void	nfs41_server_deref (IN nfs41_server *server)
static void	server_addrs_add (IN OUT struct server_addrs *addrs, IN const netaddr4 *addr)
void	nfs41_server_addrs (IN nfs41_server *server, OUT multi_addr4 *addrs)
int	nfs41_server_find_or_create (IN const char *server_owner_major_id, IN const char *server_scope, IN const netaddr4 *addr, OUT nfs41_server **server_out)
int	nfs41_server_resolve (IN const char *hostname, IN unsigned short port, OUT multi_addr4 *addrs)

Variables
static struct server_list	g_server_list

Macro Definition Documentation

server_entry

#define server_entry

(

pos

)

list_container(pos, nfs41_server, entry)

Definition at line 45 of file nfs41_server.c.

SRVLVL

#define SRVLVL   2 /* dprintf level for server logging */

Definition at line 35 of file nfs41_server.c.

Function Documentation

nfs41_server_addrs()

void nfs41_server_addrs	(	IN nfs41_server *	server,
		OUT multi_addr4 *	addrs
	)

Definition at line 203 of file nfs41_server.c.

{
    struct server_addrs *saddrs = &server->addrs;
    uint32_t i, j;

    /* make a copy of the server's addrs, with most recent first */
    AcquireSRWLockShared(&saddrs->lock);
    j = saddrs->next_index;
    for (i = 0; i < saddrs->addrs.count; i++) {
        /* decrement/wrap j */
        j = (NFS41_ADDRS_PER_SERVER + j - 1) % NFS41_ADDRS_PER_SERVER;
        memcpy(&addrs->arr[i], &saddrs->addrs.arr[j], sizeof(netaddr4));
    }
    ReleaseSRWLockShared(&saddrs->lock);
}

nfs41_server_deref()

void nfs41_server_deref

(

IN nfs41_server *

server

)

Definition at line 155 of file nfs41_server.c.

{
    EnterCriticalSection(&g_server_list.lock);

    server->ref_count--;
    dprintf(SRVLVL, "nfs41_server_deref(%s) count %d\n",
        server->owner, server->ref_count);
    if (server->ref_count == 0) {
        list_remove(&server->entry);
        server_free(server);
    }

    LeaveCriticalSection(&g_server_list.lock);
}

Referenced by nfs41_client_free(), and update_server().

nfs41_server_find_or_create()

int nfs41_server_find_or_create	(	IN const char *	server_owner_major_id,
		IN const char *	server_scope,
		IN const netaddr4 *	addr,
		OUT nfs41_server **	server_out
	)

Definition at line 221 of file nfs41_server.c.

{
    struct server_info info;
    struct list_entry *entry;
    nfs41_server *server;
    int status;

    info.owner = server_owner_major_id;
    info.scope = server_scope;

    dprintf(SRVLVL, "--> nfs41_server_find_or_create(%s)\n", info.owner);

    EnterCriticalSection(&g_server_list.lock);

    /* search for an existing server */
    entry = list_search(&g_server_list.head, &info, server_compare);
    if (entry == NULL) {
        /* create a new server */
        status = server_create(&info, &server);
        if (status == NO_ERROR) {
            /* add it to the list */
            list_add_tail(&g_server_list.head, &server->entry);
            *server_out = server;

            dprintf(SRVLVL, "<-- nfs41_server_find_or_create() "
                "returning new server %p\n", server);
        } else {
            dprintf(SRVLVL, "<-- nfs41_server_find_or_create() "
                "returning %d\n", status);
        }
    } else {
        server = server_entry(entry);
        status = NO_ERROR;

        dprintf(SRVLVL, "<-- nfs41_server_find_or_create() "
            "returning existing server %p\n", server);
    }

    if (server) {
        /* register the address used to connect */
        server_addrs_add(&server->addrs, addr);

        server_ref_locked(server);
    }

    *server_out = server;
    LeaveCriticalSection(&g_server_list.lock);
    return status;
}

Referenced by update_server().

nfs41_server_list_init()

void nfs41_server_list_init

(

)

Definition at line 48 of file nfs41_server.c.

{
    list_init(&g_server_list.head);
    InitializeCriticalSection(&g_server_list.lock);
}

Referenced by ServiceStart().

nfs41_server_ref()

void nfs41_server_ref

(

IN nfs41_server *

server

)

Definition at line 145 of file nfs41_server.c.

{
    EnterCriticalSection(&g_server_list.lock);

    server_ref_locked(server);

    LeaveCriticalSection(&g_server_list.lock);
}

nfs41_server_resolve()

int nfs41_server_resolve	(	IN const char *	hostname,
		IN unsigned short	port,
		OUT multi_addr4 *	addrs
	)

Definition at line 275 of file nfs41_server.c.

{
    int status = ERROR_BAD_NET_NAME;
    char service[16];
    struct addrinfo hints = { 0 }, *res, *info;
    struct netconfig *nconf;
    struct netbuf addr;
    char *netid, *uaddr;

    dprintf(SRVLVL, "--> nfs41_server_resolve(%s:%u)\n",
        hostname, port);

    addrs->count = 0;

    StringCchPrintfA(service, 16, "%u", port);

    /* request a list of tcp addrs for the given hostname,port */
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    if (getaddrinfo(hostname, service, &hints, &res) != 0)
        goto out;

    for (info = res; info != NULL; info = info->ai_next) {
        /* find the appropriate entry in /etc/netconfig */
        switch (info->ai_family) {
        case AF_INET:  netid = "tcp";  break;
        case AF_INET6: netid = "tcp6"; break;
        default: continue;
        }

        nconf = getnetconfigent(netid);
        if (nconf == NULL)
            continue;

        /* convert to a transport-independent universal address */
        addr.buf = info->ai_addr;
        addr.maxlen = addr.len = (unsigned int)info->ai_addrlen;

        uaddr = taddr2uaddr(nconf, &addr);
        freenetconfigent(nconf);

        if (uaddr == NULL)
            continue;

        StringCchCopyA(addrs->arr[addrs->count].netid,
            NFS41_NETWORK_ID_LEN+1, netid);
        StringCchCopyA(addrs->arr[addrs->count].uaddr,
            NFS41_UNIVERSAL_ADDR_LEN+1, uaddr);
        freeuaddr(uaddr);

        status = NO_ERROR;
        if (++addrs->count >= NFS41_ADDRS_PER_SERVER)
            break;
    }
    freeaddrinfo(res);
out:
    if (status)
        dprintf(SRVLVL, "<-- nfs41_server_resolve(%s:%u) returning "
            "error %d\n", hostname, port, status);
    else
        dprintf(SRVLVL, "<-- nfs41_server_resolve(%s:%u) returning "
            "%s\n", hostname, port, addrs->arr[0].uaddr);
    return status;
}

Referenced by handle_mount(), and referral_mount_location().

server_addrs_add()

static void server_addrs_add ( IN OUT struct server_addrs *  addrs, IN const netaddr4 *  addr  )

static

Definition at line 171 of file nfs41_server.c.

{
    /* we keep a list of addrs used to connect to each server. once it gets
     * bigger than NFS41_ADDRS_PER_SERVER, overwrite the oldest addrs. use
     * server_addrs.next_index to implement a circular array */

    AcquireSRWLockExclusive(&addrs->lock);

    if (multi_addr_find(&addrs->addrs, addr, NULL)) {
        dprintf(SRVLVL, "server_addrs_add() found existing addr '%s'.\n",
            addr->uaddr);
    } else {
        /* overwrite the address at 'next_index' */
        StringCchCopyA(addrs->addrs.arr[addrs->next_index].netid,
            NFS41_NETWORK_ID_LEN+1, addr->netid);
        StringCchCopyA(addrs->addrs.arr[addrs->next_index].uaddr,
            NFS41_UNIVERSAL_ADDR_LEN+1, addr->uaddr);

        /* increment/wrap next_index */
        addrs->next_index = (addrs->next_index + 1) % NFS41_ADDRS_PER_SERVER;
        /* update addrs.count if necessary */
        if (addrs->addrs.count < addrs->next_index)
            addrs->addrs.count = addrs->next_index;

        dprintf(SRVLVL, "server_addrs_add() added new addr '%s'.\n",
            addr->uaddr);
    }
    ReleaseSRWLockExclusive(&addrs->lock);
}

Referenced by nfs41_server_find_or_create().

server_compare()

static int server_compare ( const struct list_entry *  entry, const void *  value  )

static

Definition at line 75 of file nfs41_server.c.

{
    const nfs41_server *server = server_entry(entry);
    const struct server_info *info = (const struct server_info*)value;
    const int diff = strncmp(server->scope, info->scope, NFS4_OPAQUE_LIMIT);
    return diff ? diff : strncmp(server->owner, info->owner, NFS4_OPAQUE_LIMIT);
}

Referenced by nfs41_server_find_or_create(), and server_entry_find().

server_create()

static int server_create ( IN const struct server_info *  info, OUT nfs41_server **  server_out  )

static

Definition at line 94 of file nfs41_server.c.

{
    int status = NO_ERROR;
    nfs41_server *server;

    server = calloc(1, sizeof(nfs41_server));
    if (server == NULL) {
        status = GetLastError();
        eprintf("failed to allocate server %s\n", info->owner);
        goto out;
    }

    StringCchCopyA(server->scope, NFS4_OPAQUE_LIMIT, info->scope);
    StringCchCopyA(server->owner, NFS4_OPAQUE_LIMIT, info->owner);
    InitializeSRWLock(&server->addrs.lock);
    nfs41_superblock_list_init(&server->superblocks);

    status = nfs41_name_cache_create(&server->name_cache);
    if (status) {
        eprintf("nfs41_name_cache_create() failed with %d\n", status);
        goto out_free;
    }
out:
    *server_out = server;
    return status;

out_free:
    free(server);
    server = NULL;
    goto out;
}

Referenced by nfs41_server_find_or_create().

server_entry_find()

static int server_entry_find ( IN struct server_list *  servers, IN const struct server_info *  info, OUT struct list_entry **  entry_out  )

static

Definition at line 85 of file nfs41_server.c.

{
    *entry_out = list_search(&servers->head, info, server_compare);
    return *entry_out ? NO_ERROR : ERROR_FILE_NOT_FOUND;
}

server_free()

static void server_free ( IN nfs41_server *  server )

static

Definition at line 128 of file nfs41_server.c.

{
    dprintf(SRVLVL, "server_free(%s)\n", server->owner);
    nfs41_superblock_list_free(&server->superblocks);
    nfs41_name_cache_free(&server->name_cache);
    free(server);
}

Referenced by nfs41_server_deref().

server_ref_locked()

static __inline void server_ref_locked ( IN nfs41_server *  server )

static

Definition at line 137 of file nfs41_server.c.

{
    server->ref_count++;
    dprintf(SRVLVL, "nfs41_server_ref(%s) count %d\n",
        server->owner, server->ref_count);
}

Referenced by nfs41_server_find_or_create(), and nfs41_server_ref().

Variable Documentation

g_server_list

struct server_list g_server_list

static

Definition at line 43 of file nfs41_server.c.

Referenced by nfs41_server_deref(), nfs41_server_find_or_create(), nfs41_server_list_init(), and nfs41_server_ref().