symlink.c File Reference

#include <windows.h>
#include <strsafe.h>
#include "nfs41_ops.h"
#include "upcall.h"
#include "util.h"
#include "daemon_debug.h"

Include dependency graph for symlink.c:

Go to the source code of this file.

Functions
static int	abs_path_link (OUT nfs41_abs_path *path, IN char *path_pos, IN const char *link, IN uint32_t link_len)
int	nfs41_symlink_target (IN nfs41_session *session, IN nfs41_path_fh *file, OUT nfs41_abs_path *target)
int	nfs41_symlink_follow (IN nfs41_root *root, IN nfs41_session *session, IN nfs41_path_fh *symlink, OUT nfs41_file_info *info)
static int	parse_symlink (unsigned char *buffer, uint32_t length, nfs41_upcall *upcall)
static int	handle_symlink (nfs41_upcall *upcall)
static int	marshall_symlink (unsigned char *buffer, uint32_t *length, nfs41_upcall *upcall)

Variables
const nfs41_upcall_op	nfs41_op_symlink

Function Documentation

abs_path_link()

static int abs_path_link ( OUT nfs41_abs_path *  path, IN char *  path_pos, IN const char *  link, IN uint32_t  link_len  )

static

Definition at line 31 of file symlink.c.

{
    nfs41_component name;
    const char *path_max = path->path + NFS41_MAX_PATH_LEN;
    const char *link_pos = link;
    const char *link_end = link + link_len;
    int status = NO_ERROR;
 
    /* if link is an absolute path, start path_pos at the beginning */
    if (is_delimiter(*link))
        path_pos = path->path;
 
    /* copy each component of link into the path */
    while (next_component(link_pos, link_end, &name)) {
        link_pos = name.name + name.len;
 
        if (is_delimiter(*path_pos))
            path_pos++;
 
        /* handle special components . and .. */
        if (name.len == 1 && name.name[0] == '.')
            continue;
        if (name.len == 2 && name.name[0] == '.' && name.name[1] == '.') {
            /* back path_pos up by one component */
            if (!last_component(path->path, path_pos, &name)) {
                eprintf("symlink with .. that points below server root!\n");
                status = ERROR_BAD_NETPATH;
                goto out;
            }
            path_pos = (char*)prev_delimiter(name.name, path->path);
            continue;
        }
 
        /* copy the component and add a \ */
        if (FAILED(StringCchCopyNA(path_pos, path_max-path_pos, name.name, 
                name.len))) {
            status = ERROR_BUFFER_OVERFLOW;
            goto out;
        }
        path_pos += name.len;
        if (FAILED(StringCchCopyNA(path_pos, path_max-path_pos, "\\", 1))) {
            status = ERROR_BUFFER_OVERFLOW;
            goto out;
        }
    }
 
    /* make sure the path is null terminated */
    if (path_pos == path_max) {
        status = ERROR_BUFFER_OVERFLOW;
        goto out;
    }
    *path_pos = '\0';
out:
    path->len = (unsigned short)(path_pos - path->path);
    return status;
}

Referenced by nfs41_symlink_target().

handle_symlink()

static int handle_symlink ( nfs41_upcall *  upcall )

static

Definition at line 211 of file symlink.c.

{
    symlink_upcall_args *args = &upcall->args.symlink;
    nfs41_open_state *state = upcall->state_ref;
    int status = NO_ERROR;
 
    if (args->set) {
        nfs41_file_info info, createattrs;
 
        /* don't send windows slashes to the server */
        char *p;
        for (p = args->target_set; *p; p++) if (*p == '\\') *p = '/';
 
        if (state->file.fh.len) {
            /* the check in handle_open() didn't catch that we're creating
             * a symlink, so we have to remove the file it already created */
            eprintf("handle_symlink: attempting to create a symlink when "
                "the file=%s was already created on open; sending REMOVE "
                "first\n", state->file.path->path);
            status = nfs41_remove(state->session, &state->parent,
                &state->file.name, state->file.fh.fileid);
            if (status) {
                eprintf("nfs41_remove() for symlink=%s failed with %s\n",
                    args->target_set, nfs_error_string(status));
                status = map_symlink_errors(status);
                goto out;
            }
        }
 
        /* create the symlink */
        createattrs.attrmask.count = 2;
        createattrs.attrmask.arr[0] = 0;
        createattrs.attrmask.arr[1] = FATTR4_WORD1_MODE;
        createattrs.mode = 0777;
        status = nfs41_create(state->session, NF4LNK, &createattrs,
            args->target_set, &state->parent, &state->file, &info);
        if (status) {
            eprintf("nfs41_create() for symlink=%s failed with %s\n",
                args->target_set, nfs_error_string(status));
            status = map_symlink_errors(status);
            goto out;
        }
    } else {
        uint32_t len;
 
        /* read the link */
        status = nfs41_readlink(state->session, &state->file,
            NFS41_MAX_PATH_LEN, args->target_get.path, &len);
        if (status) {
            eprintf("nfs41_readlink() for filename=%s failed with %s\n",
                state->file.path->path, nfs_error_string(status));
            status = map_symlink_errors(status);
            goto out;
        }
        args->target_get.len = (unsigned short)len;
        dprintf(2, "returning symlink target '%s'\n", args->target_get.path);
    }
out:
    return status;
}

marshall_symlink()

static int marshall_symlink ( unsigned char *  buffer, uint32_t *  length, nfs41_upcall *  upcall  )

static

Definition at line 272 of file symlink.c.

{
    symlink_upcall_args *args = &upcall->args.symlink;
    unsigned short len = (args->target_get.len + 1) * sizeof(WCHAR);
    int status = NO_ERROR;
 
    if (args->set)
        goto out;
 
    status = safe_write(&buffer, length, &len, sizeof(len));
    if (status) goto out;
 
    if (*length <= len || !MultiByteToWideChar(CP_UTF8, 0,
            args->target_get.path, args->target_get.len,
            (LPWSTR)buffer, len / sizeof(WCHAR))) {
        status = ERROR_BUFFER_OVERFLOW;
        goto out;
    }
out:
    return status;
}

nfs41_symlink_follow()

int nfs41_symlink_follow	(	IN nfs41_root *	root,
		IN nfs41_session *	session,
		IN nfs41_path_fh *	symlink,
		OUT nfs41_file_info *	info
	)

Definition at line 146 of file symlink.c.

{
    nfs41_abs_path path;
    nfs41_path_fh file;
    uint32_t depth = 0;
    int status = NO_ERROR;
 
    file.path = &path;
    InitializeSRWLock(&path.lock);
 
    dprintf(2, "--> nfs41_symlink_follow('%s')\n", symlink->path->path);
 
    do {
        if (++depth > NFS41_MAX_SYMLINK_DEPTH) {
            status = ERROR_TOO_MANY_LINKS;
            goto out;
        }
 
        /* construct the target path */
        status = nfs41_symlink_target(session, symlink, &path);
        if (status) goto out;
 
        dprintf(2, "looking up '%s'\n", path.path);
 
        last_component(path.path, path.path + path.len, &file.name);
 
        /* get attributes for the target */
        status = nfs41_lookup(root, session, &path,
            NULL, &file, info, &session);
        if (status) goto out;
 
        symlink = &file;
    } while (info->type == NF4LNK);
out:
    dprintf(2, "<-- nfs41_symlink_follow() returning %d\n", status);
    return status;
}

Referenced by handle_getattr(), handle_open(), and lookup_symlink().

nfs41_symlink_target()

int nfs41_symlink_target	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		OUT nfs41_abs_path *	target
	)

Definition at line 92 of file symlink.c.

{
    char link[NFS41_MAX_PATH_LEN];
    const nfs41_abs_path *path = file->path;
    ptrdiff_t path_offset;
    uint32_t link_len;
    int status;
 
    /* read the link */
    status = nfs41_readlink(session, file, NFS41_MAX_PATH_LEN, link, &link_len);
    if (status) {
        eprintf("nfs41_readlink() for %s failed with %s\n", file->path->path, 
            nfs_error_string(status));
        status = ERROR_PATH_NOT_FOUND;
        goto out;
    }
 
    dprintf(2, "--> nfs41_symlink_target('%s', '%s')\n", path->path, link);
 
    /* append any components after the symlink */
    if (FAILED(StringCchCatA(link, NFS41_MAX_PATH_LEN,
            file->name.name + file->name.len))) {
        status = ERROR_BUFFER_OVERFLOW;
        goto out;
    }
    link_len = (uint32_t)strlen(link);
 
    /* overwrite the last component of the path; get the starting offset */
    path_offset = file->name.name - path->path;
 
    /* copy the path and update it with the results from link */
    if (target != path) {
        target->len = path->len;
        if (FAILED(StringCchCopyNA(target->path, NFS41_MAX_PATH_LEN,
                path->path, path->len))) {
            status = ERROR_BUFFER_OVERFLOW;
            goto out;
        }
    }
    status = abs_path_link(target, target->path + path_offset, link, link_len);
    if (status) {
        eprintf("abs_path_link() for path %s with link %s failed with %d\n", 
            target->path, link, status);
        goto out;
    }
out:
    dprintf(2, "<-- nfs41_symlink_target('%s') returning %d\n",
        target->path, status);
    return status;
}

Referenced by handle_open(), and nfs41_symlink_follow().

parse_symlink()

static int parse_symlink ( unsigned char *  buffer, uint32_t  length, nfs41_upcall *  upcall  )

static

Definition at line 190 of file symlink.c.

{
    symlink_upcall_args *args = &upcall->args.symlink;
    int status;
 
    status = get_name(&buffer, &length, &args->path);
    if (status) goto out;
    status = safe_read(&buffer, &length, &args->set, sizeof(BOOLEAN));
    if (status) goto out;
 
    if (args->set)
        status = get_name(&buffer, &length, &args->target_set);
    else
        args->target_set = NULL;
 
    dprintf(1, "parsing NFS41_SYMLINK: path='%s' set=%u target='%s'\n",
        args->path, args->set, args->target_set);
out:
    return status;
}

Variable Documentation

nfs41_op_symlink

const nfs41_upcall_op nfs41_op_symlink

Initial value:

= {
    parse_symlink,
    handle_symlink,
    marshall_symlink
}

Definition at line 295 of file symlink.c.