util.h File Reference

#include "nfs41_types.h"
#include "from_kernel.h"

Include dependency graph for util.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FILETIME_EPOCH   116444736000000000LL

Functions
int	safe_read (unsigned char **pos, uint32_t *remaining, void *dest, uint32_t dest_len)
int	safe_write (unsigned char **pos, uint32_t *remaining, void *dest, uint32_t dest_len)
int	get_name (unsigned char **pos, uint32_t *remaining, const char **out_name)
const char *	strip_path (IN const char *path, OUT uint32_t *len_out OPTIONAL)
uint32_t	max_read_size (IN const struct __nfs41_session *session, IN const nfs41_fh *fh)
uint32_t	max_write_size (IN const struct __nfs41_session *session, IN const nfs41_fh *fh)
bool_t	verify_write (IN nfs41_write_verf *verf, IN OUT enum stable_how4 *stable)
bool_t	verify_commit (IN nfs41_write_verf *verf)
static __inline bool_t	bitmap_isset (IN const bitmap4 *mask, IN uint32_t word, IN uint32_t flag)
static __inline void	bitmap_set (IN bitmap4 *mask, IN uint32_t word, IN uint32_t flag)
static __inline void	bitmap_unset (IN bitmap4 *mask, IN uint32_t word, IN uint32_t flag)
static __inline void	bitmap_intersect (IN bitmap4 *dst, IN const bitmap4 *src)
ULONG	nfs_file_info_to_attributes (IN const nfs41_file_info *info)
void	nfs_to_basic_info (IN const nfs41_file_info *info, OUT PFILE_BASIC_INFO basic_out)
void	nfs_to_standard_info (IN const nfs41_file_info *info, OUT PFILE_STANDARD_INFO std_out)
void	nfs_to_network_openinfo (IN const nfs41_file_info *info, OUT PFILE_NETWORK_OPEN_INFORMATION std_out)
static __inline void	file_time_to_nfs_time (IN const PLARGE_INTEGER file_time, OUT nfstime4 *nfs_time)
static __inline void	nfs_time_to_file_time (IN const nfstime4 *nfs_time, OUT PLARGE_INTEGER file_time)
void	get_file_time (OUT PLARGE_INTEGER file_time)
void	get_nfs_time (OUT nfstime4 *nfs_time)
static __inline void	nfstime_normalize (IN OUT nfstime4 *nfstime)
static __inline void	nfstime_diff (IN const nfstime4 *lhs, IN const nfstime4 *rhs, OUT nfstime4 *result)
static __inline void	nfstime_abs (IN const nfstime4 *nt, OUT nfstime4 *result)
int	create_silly_rename (IN nfs41_abs_path *path, IN const nfs41_fh *fh, OUT nfs41_component *silly)
bool_t	multi_addr_find (IN const multi_addr4 *addrs, IN const netaddr4 *addr, OUT OPTIONAL uint32_t *index_out)
int	nfs_to_windows_error (int status, int default_error)
int	map_symlink_errors (int status)
__inline uint32_t	align8 (uint32_t offset)
__inline uint32_t	align4 (uint32_t offset)
__inline int	is_delimiter (char c)
__inline const char *	next_delimiter (const char *pos, const char *end)
__inline const char *	prev_delimiter (const char *pos, const char *start)
__inline const char *	next_non_delimiter (const char *pos, const char *end)
__inline const char *	prev_non_delimiter (const char *pos, const char *start)
bool_t	next_component (IN const char *path, IN const char *path_end, OUT nfs41_component *component)
bool_t	last_component (IN const char *path, IN const char *path_end, OUT nfs41_component *component)
bool_t	is_last_component (IN const char *path, IN const char *path_end)
void	abs_path_copy (OUT nfs41_abs_path *dst, IN const nfs41_abs_path *src)
void	path_fh_init (OUT nfs41_path_fh *file, IN nfs41_abs_path *path)
void	fh_copy (OUT nfs41_fh *dst, IN const nfs41_fh *src)
void	path_fh_copy (OUT nfs41_path_fh *dst, IN const nfs41_path_fh *src)
__inline int	valid_handle (HANDLE handle)

Variables
DWORD	NFS41D_VERSION

Macro Definition Documentation

FILETIME_EPOCH

#define FILETIME_EPOCH   116444736000000000LL

Definition at line 114 of file util.h.

Function Documentation

abs_path_copy()

void abs_path_copy	(	OUT nfs41_abs_path *	dst,
		IN const nfs41_abs_path *	src
	)

Definition at line 338 of file util.c.

{
    dst->len = src->len;
    StringCchCopyNA(dst->path, NFS41_MAX_PATH_LEN, src->path, dst->len);
}

Referenced by delegation_create(), format_abs_path(), handle_open(), nfs41_lookup(), open_state_rename(), prev_non_delimiter(), and referral_resolve().

align4()

__inline uint32_t align4

(

uint32_t

offset

)

Definition at line 198 of file util.h.

                                          {
#else
FORCEINLINE uint32_t align4(uint32_t offset) {
#endif
    return 4 + ((offset - 1) & ~3);
}

Referenced by align4().

align8()

__inline uint32_t align8

(

uint32_t

offset

)

Definition at line 191 of file util.h.

                                          {
#else
FORCEINLINE uint32_t align8(uint32_t offset) {
#endif
    return 8 + ((offset - 1) & ~7);
}

Referenced by align8(), and readdir_copy_entry().

bitmap_intersect()

static __inline void bitmap_intersect ( IN bitmap4 *  dst, IN const bitmap4 *  src  )

static

Definition at line 85 of file util.h.

{
    uint32_t i, count = 0;
    for (i = 0; i < 3; i++) {
        dst->arr[i] &= src->arr[i];
        if (dst->arr[i])
            count = i+1;
    }
    dst->count = min(dst->count, count);
}

Referenced by nfs41_superblock_supported_attrs(), and nfs41_superblock_supported_attrs_exclcreat().

bitmap_isset()

static __inline bool_t bitmap_isset ( IN const bitmap4 *  mask, IN uint32_t  word, IN uint32_t  flag  )

static

Definition at line 55 of file util.h.

{
    return mask->count > word && mask->arr[word] & flag;
}

Referenced by get_superblock_attrs(), and info_to_fattr4().

bitmap_set()

static __inline void bitmap_set ( IN bitmap4 *  mask, IN uint32_t  word, IN uint32_t  flag  )

static

Definition at line 62 of file util.h.

{
    if (mask->count > word)
        mask->arr[word] |= flag;
    else {
        mask->count = word + 1;
        mask->arr[word] = flag;
    }
}

Referenced by info_to_fattr4().

bitmap_unset()

static __inline void bitmap_unset ( IN bitmap4 *  mask, IN uint32_t  word, IN uint32_t  flag  )

static

Definition at line 74 of file util.h.

{
    if (mask->count > word) {
        mask->arr[word] &= ~flag;
        while (mask->count && mask->arr[mask->count-1] == 0)
            mask->count--;
    }
}

create_silly_rename()

int create_silly_rename	(	IN nfs41_abs_path *	path,
		IN const nfs41_fh *	fh,
		OUT nfs41_component *	silly
	)

Definition at line 380 of file util.c.

{
    HCRYPTPROV context;
    HCRYPTHASH hash;
    PBYTE buffer;
    DWORD length;
    const char *end = path->path + NFS41_MAX_PATH_LEN;
    const unsigned short extra_len = 2 + 16; //md5 is 16
    char name[NFS41_MAX_COMPONENT_LEN+1];
    unsigned char fhmd5[17] = { 0 };
    char *tmp;
    int status = NO_ERROR, i;
 
    if (path->len + extra_len >= NFS41_MAX_PATH_LEN) {
        status = ERROR_FILENAME_EXCED_RANGE;
        goto out;
    }
 
    /* 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*)fh->fh, (DWORD)fh->len, 0)) {
        status = GetLastError();
        eprintf("CryptHashData() failed with %d\n", status);
        goto out_hash;
    }
 
    /* extract the hash buffer */
    buffer = (PBYTE)fhmd5;
    length = 16;
    if (!CryptGetHashParam(hash, HP_HASHVAL, buffer, &length, 0)) {
        status = GetLastError();
        eprintf("CryptGetHashParam(val) failed with %d\n", status);
        goto out_hash;
    }    
 
    last_component(path->path, path->path + path->len, silly);
    StringCchCopyNA(name, NFS41_MAX_COMPONENT_LEN+1, silly->name, silly->len);
 
    tmp = (char*)silly->name;
    StringCchPrintf(tmp, end - tmp, ".%s.", name);
    tmp += silly->len + 2;
 
    for (i = 0; i < 16; i++, tmp++)
        StringCchPrintf(tmp, end - tmp, "%x", fhmd5[i]);
 
    path->len = path->len + extra_len;
    silly->len = silly->len + extra_len;
 
out_hash:
    CryptDestroyHash(hash);
out_context:
    CryptReleaseContext(context, 0);
out:
    return status;
}

Referenced by handle_close().

fh_copy()

void fh_copy	(	OUT nfs41_fh *	dst,
		IN const nfs41_fh *	src
	)

Definition at line 354 of file util.c.

{
    dst->fileid = src->fileid;
    dst->superblock = src->superblock;
    dst->len = src->len;
    memcpy(dst->fh, src->fh, dst->len);
}

Referenced by copy_fh(), delegation_create(), get_path_fhs(), layout_state_create(), name_cache_entry_update(), path_fh_copy(), prev_non_delimiter(), and server_lookup_loop().

file_time_to_nfs_time()

static __inline void file_time_to_nfs_time ( IN const PLARGE_INTEGER  file_time, OUT nfstime4 *  nfs_time  )

static

Definition at line 116 of file util.h.

{
    LONGLONG diff = file_time->QuadPart - FILETIME_EPOCH;
    nfs_time->seconds = diff / 10000000;
    nfs_time->nseconds = (uint32_t)((diff % 10000000)*100);
}

Referenced by get_nfs_time().

get_file_time()

void get_file_time

(

OUT PLARGE_INTEGER

file_time

)

Definition at line 204 of file util.c.

{
    GetSystemTimeAsFileTime((LPFILETIME)file_time);
}

Referenced by get_nfs_time().

get_name()

int get_name	(	unsigned char **	pos,
		uint32_t *	remaining,
		const char **	out_name
	)

Definition at line 55 of file util.c.

{
    int status;
    USHORT len;
    
    status = safe_read(pos, remaining, &len, sizeof(USHORT));
    if (status) goto out;
    if (*remaining < len) {
        status = ERROR_BUFFER_OVERFLOW;
        goto out;
    }
    *out_name = (const char*)*pos;
    *pos += len;
    *remaining -= len;
out:
    return status;
}

Referenced by __release_category(), FT_DEFINE_SERVICE(), ft_property_do(), gen_proxy(), gen_stub(), gen_stub_thunk(), parse_close(), parse_getexattr(), parse_mount(), parse_open(), parse_readdir(), parse_setattr(), parse_setexattr(), parse_symlink(), pointer_tests(), write_client_func_decl(), write_dispatchtable(), write_function_stub(), write_proxy_methods(), write_proxy_procformatstring_offsets(), write_routinetable(), write_stub_methods(), and write_thunk_methods().

get_nfs_time()

void get_nfs_time

(

OUT nfstime4 *

nfs_time

)

Definition at line 210 of file util.c.

{
    LARGE_INTEGER file_time;
    get_file_time(&file_time);
    file_time_to_nfs_time(&file_time, nfs_time);
}

Referenced by delegation_truncate(), and settime_how().

is_delimiter()

__inline int is_delimiter

(

char

c

)

Definition at line 207 of file util.h.

                                  {
#else
FORCEINLINE int is_delimiter(char c) {
#endif
    return c == '\\' || c == '/' || c == '\0';
}

Referenced by abs_path_link(), is_delimiter(), next_delimiter(), next_non_delimiter(), prev_delimiter(), and prev_non_delimiter().

is_last_component()

bool_t is_last_component	(	IN const char *	path,
		IN const char *	path_end
	)

Definition at line 330 of file util.c.

{
    path = next_delimiter(path, path_end);
    return next_non_delimiter(path, path_end) == path_end;
}

Referenced by get_path_fhs(), name_cache_lookup(), prev_non_delimiter(), and server_lookup_loop().

last_component()

bool_t last_component	(	IN const char *	path,
		IN const char *	path_end,
		OUT nfs41_component *	component
	)

Definition at line 317 of file util.c.

{
    const char *component_end = prev_delimiter(path_end, path);
    component->name = prev_non_delimiter(component_end, path);
    component->name = prev_delimiter(component->name, path);
    component->name = next_non_delimiter(component->name, component_end);
    component->len = (unsigned short)(component_end - component->name);
    return component->len > 0;
}

Referenced by abs_path_link(), create_open_state(), create_silly_rename(), delegation_create(), lookup_symlink(), map_lookup_error(), nfs41_lookup(), nfs41_symlink_follow(), open_state_rename(), path_fh_init(), prev_non_delimiter(), and server_lookup().

map_symlink_errors()

int map_symlink_errors

(

int

status

)

Definition at line 293 of file util.c.

{
    switch (status) {
    case NFS4ERR_BADCHAR:
    case NFS4ERR_BADNAME:       return ERROR_INVALID_REPARSE_DATA;
    case NFS4ERR_WRONG_TYPE:    return ERROR_NOT_A_REPARSE_POINT;
    case NFS4ERR_ACCESS:        return ERROR_ACCESS_DENIED;
    case NFS4ERR_NOTEMPTY:      return ERROR_NOT_EMPTY;
    default: return nfs_to_windows_error(status, ERROR_BAD_NET_RESP);
    }
}

Referenced by handle_open(), and handle_symlink().

max_read_size()

uint32_t max_read_size	(	IN const struct __nfs41_session *	session,
		IN const nfs41_fh *	fh
	)

max_write_size()

uint32_t max_write_size	(	IN const struct __nfs41_session *	session,
		IN const nfs41_fh *	fh
	)

multi_addr_find()

bool_t multi_addr_find	(	IN const multi_addr4 *	addrs,
		IN const netaddr4 *	addr,
		OUT OPTIONAL uint32_t *	index_out
	)

Definition at line 218 of file util.c.

{
    uint32_t i;
    for (i = 0; i < addrs->count; i++) {
        const netaddr4 *saddr = &addrs->arr[i];
        if (!strncmp(saddr->netid, addr->netid, NFS41_NETWORK_ID_LEN) &&
            !strncmp(saddr->uaddr, addr->uaddr, NFS41_UNIVERSAL_ADDR_LEN)) {
            if (index_out) *index_out = i;
            return 1;
        }
    }
    return 0;
}

Referenced by cl_addr_compare(), and server_addrs_add().

next_component()

bool_t next_component	(	IN const char *	path,
		IN const char *	path_end,
		OUT nfs41_component *	component
	)

Definition at line 305 of file util.c.

{
    const char *component_end;
    component->name = next_non_delimiter(path, path_end);
    component_end = next_delimiter(component->name, path_end);
    component->len = (unsigned short)(component_end - component->name);
    return component->len > 0;
}

Referenced by abs_path_link(), get_component_array(), get_path_fhs(), name_cache_lookup(), and prev_non_delimiter().

next_delimiter()

__inline const char * next_delimiter	(	const char *	pos,
		const char *	end
	)

Definition at line 214 of file util.h.

                                                                      {
#else
FORCEINLINE const char* next_delimiter(const char *pos, const char *end) {
#endif
    while (pos < end && !is_delimiter(*pos))
        pos++;
    return pos;
}

Referenced by is_last_component(), next_component(), and next_delimiter().

next_non_delimiter()

__inline const char * next_non_delimiter	(	const char *	pos,
		const char *	end
	)

Definition at line 232 of file util.h.

                                                                          {
#else
FORCEINLINE const char* next_non_delimiter(const char *pos, const char *end) {
#endif
    while (pos < end && is_delimiter(*pos))
        pos++;
    return pos;
}

Referenced by is_last_component(), last_component(), next_component(), and next_non_delimiter().

nfs_file_info_to_attributes()

ULONG nfs_file_info_to_attributes

(

IN const nfs41_file_info *

info

)

Definition at line 137 of file util.c.

{
    ULONG attrs = 0;
    if (info->type == NF4DIR)
        attrs |= FILE_ATTRIBUTE_DIRECTORY;
    else if (info->type == NF4LNK) {
        attrs |= FILE_ATTRIBUTE_REPARSE_POINT;
        if (info->symlink_dir)
            attrs |= FILE_ATTRIBUTE_DIRECTORY;
    } else if (info->type != NF4REG)
        dprintf(1, "unhandled file type %d, defaulting to NF4REG\n",
            info->type);
 
    if (info->mode == 0444) /* XXX: 0444 for READONLY */
        attrs |= FILE_ATTRIBUTE_READONLY;
 
    if (info->hidden) attrs |= FILE_ATTRIBUTE_HIDDEN;
    if (info->system) attrs |= FILE_ATTRIBUTE_SYSTEM;
    if (info->archive) attrs |= FILE_ATTRIBUTE_ARCHIVE;
 
    // FILE_ATTRIBUTE_NORMAL attribute is only set if no other attributes are present.
    // all other override this value.
    return attrs ? attrs : FILE_ATTRIBUTE_NORMAL;
}

Referenced by handle_getattr(), nfs_to_basic_info(), nfs_to_network_openinfo(), nfs_to_standard_info(), and readdir_copy_dir_info().

nfs_time_to_file_time()

static __inline void nfs_time_to_file_time ( IN const nfstime4 *  nfs_time, OUT PLARGE_INTEGER  file_time  )

static

Definition at line 125 of file util.h.

{
    file_time->QuadPart = FILETIME_EPOCH +
        nfs_time->seconds * 10000000 +
        nfs_time->nseconds / 100;
}

Referenced by nfs_to_basic_info(), nfs_to_network_openinfo(), and readdir_copy_dir_info().

nfs_to_basic_info()

void nfs_to_basic_info	(	IN const nfs41_file_info *	info,
		OUT PFILE_BASIC_INFO	basic_out
	)

Definition at line 163 of file util.c.

{
    nfs_time_to_file_time(&info->time_create, &basic_out->CreationTime);
    nfs_time_to_file_time(&info->time_access, &basic_out->LastAccessTime);
    nfs_time_to_file_time(&info->time_modify, &basic_out->LastWriteTime);
    /* XXX: was using 'change' attr, but that wasn't giving a time */
    nfs_time_to_file_time(&info->time_modify, &basic_out->ChangeTime);
    basic_out->FileAttributes = nfs_file_info_to_attributes(info);
}

Referenced by handle_getattr(), and handle_open().

nfs_to_network_openinfo()

void nfs_to_network_openinfo	(	IN const nfs41_file_info *	info,
		OUT PFILE_NETWORK_OPEN_INFORMATION	std_out
	)

Definition at line 189 of file util.c.

{
    
    nfs_time_to_file_time(&info->time_create, &net_out->CreationTime);
    nfs_time_to_file_time(&info->time_access, &net_out->LastAccessTime);
    nfs_time_to_file_time(&info->time_modify, &net_out->LastWriteTime);
    /* XXX: was using 'change' attr, but that wasn't giving a time */
    nfs_time_to_file_time(&info->time_modify, &net_out->ChangeTime);
    net_out->AllocationSize.QuadPart =
        net_out->EndOfFile.QuadPart = (LONGLONG)info->size;
    net_out->FileAttributes = nfs_file_info_to_attributes(info);
}

Referenced by handle_getattr().

nfs_to_standard_info()

void nfs_to_standard_info	(	IN const nfs41_file_info *	info,
		OUT PFILE_STANDARD_INFO	std_out
	)

Definition at line 175 of file util.c.

{
    const ULONG FileAttributes = nfs_file_info_to_attributes(info);
 
    std_out->AllocationSize.QuadPart =
        std_out->EndOfFile.QuadPart = (LONGLONG)info->size;
    std_out->NumberOfLinks = info->numlinks;
    std_out->DeletePending = FALSE;
    std_out->Directory = FileAttributes & FILE_ATTRIBUTE_DIRECTORY ?
        TRUE : FALSE;
}

Referenced by handle_getattr(), and handle_open().

nfs_to_windows_error()

int nfs_to_windows_error	(	int	status,
		int	default_error
	)

Definition at line 235 of file util.c.

{
    /* make sure this is actually an nfs error */
    if (status < 0 || (status > 70 && status < 10001) || status > 10087) {
        eprintf("nfs_to_windows_error called with non-nfs "
            "error code %d; returning the error as is\n", status);
        return status;
    }
 
    switch (status) {
    case NFS4_OK:               return NO_ERROR;
    case NFS4ERR_PERM:          return ERROR_ACCESS_DENIED;
    case NFS4ERR_NOENT:         return ERROR_FILE_NOT_FOUND;
    case NFS4ERR_IO:            return ERROR_NET_WRITE_FAULT;
    case NFS4ERR_ACCESS:        return ERROR_ACCESS_DENIED;
    case NFS4ERR_EXIST:         return ERROR_FILE_EXISTS;
    case NFS4ERR_XDEV:          return ERROR_NOT_SAME_DEVICE;
    case NFS4ERR_INVAL:         return ERROR_INVALID_PARAMETER;
    case NFS4ERR_FBIG:          return ERROR_FILE_TOO_LARGE;
    case NFS4ERR_NOSPC:         return ERROR_DISK_FULL;
    case NFS4ERR_ROFS:          return ERROR_NETWORK_ACCESS_DENIED;
    case NFS4ERR_MLINK:         return ERROR_TOO_MANY_LINKS;
    case NFS4ERR_NAMETOOLONG:   return ERROR_FILENAME_EXCED_RANGE;
    case NFS4ERR_STALE:         return ERROR_NETNAME_DELETED;
    case NFS4ERR_NOTEMPTY:      return ERROR_NOT_EMPTY;
    case NFS4ERR_DENIED:        return ERROR_LOCK_FAILED;
    case NFS4ERR_TOOSMALL:      return ERROR_BUFFER_OVERFLOW;
    case NFS4ERR_LOCKED:        return ERROR_LOCK_VIOLATION;
    case NFS4ERR_SHARE_DENIED:  return ERROR_SHARING_VIOLATION;
    case NFS4ERR_LOCK_RANGE:    return ERROR_NOT_LOCKED;
    case NFS4ERR_ATTRNOTSUPP:   return ERROR_NOT_SUPPORTED;
    case NFS4ERR_OPENMODE:      return ERROR_ACCESS_DENIED;
    case NFS4ERR_LOCK_NOTSUPP:  return ERROR_ATOMIC_LOCKS_NOT_SUPPORTED;
 
    case NFS4ERR_BADCHAR:
    case NFS4ERR_BADNAME:       return ERROR_INVALID_NAME;
 
    case NFS4ERR_NOTDIR:
    case NFS4ERR_ISDIR:
    case NFS4ERR_SYMLINK:
    case NFS4ERR_WRONG_TYPE:    return ERROR_INVALID_PARAMETER;
 
    case NFS4ERR_EXPIRED:
    case NFS4ERR_NOFILEHANDLE:
    case NFS4ERR_OLD_STATEID:
    case NFS4ERR_BAD_STATEID:
    case NFS4ERR_ADMIN_REVOKED: return ERROR_FILE_INVALID;
 
    case NFS4ERR_WRONGSEC:      return ERROR_ACCESS_DENIED;
 
    default:
        dprintf(1, "nfs error %s not mapped to windows error; "
            "returning default error %d\n",
            nfs_error_string(status), default_error);
        return default_error;
    }
}

Referenced by cancel_lock(), cancel_open(), do_nfs41_close(), get_volume_size_info(), handle_close(), handle_lock(), handle_nfs41_remove(), handle_nfs41_set_size(), handle_open(), handle_readdir(), handle_setacl(), handle_setexattr(), handle_unlock(), map_lookup_error(), map_symlink_errors(), nfs41_cached_getattr(), nfs41_name_cache_remove_stale(), read_from_mds(), referral_resolve(), session_get_lease(), and write_to_mds().

nfstime_abs()

static __inline void nfstime_abs ( IN const nfstime4 *  nt, OUT nfstime4 *  result  )

static

Definition at line 158 of file util.h.

{
    if (nt->seconds < 0) {
        const nfstime4 zero = { 0, 0 };
        nfstime_diff(&zero, nt, result); /* result = 0 - nt */
    } else if (result != nt)
        memcpy(result, nt, sizeof(nfstime4));
}

Referenced by settime_how().

nfstime_diff()

static __inline void nfstime_diff ( IN const nfstime4 *  lhs, IN const nfstime4 *  rhs, OUT nfstime4 *  result  )

static

Definition at line 148 of file util.h.

{
    /* result = lhs - rhs */
    result->seconds = lhs->seconds - rhs->seconds;
    result->nseconds = lhs->nseconds - rhs->nseconds;
    nfstime_normalize(result);
}

Referenced by nfstime_abs(), and settime_how().

nfstime_normalize()

static __inline void nfstime_normalize ( IN OUT nfstime4 *  nfstime )

static

Definition at line 139 of file util.h.

{
    /* return time in normalized form (0 <= nsec < 1s) */
    while ((int32_t)nfstime->nseconds < 0) {
        nfstime->nseconds += 1000000000;
        nfstime->seconds--;
    }
}

Referenced by nfstime_diff().

path_fh_copy()

void path_fh_copy	(	OUT nfs41_path_fh *	dst,
		IN const nfs41_path_fh *	src
	)

Definition at line 364 of file util.c.

{
    dst->path = src->path;
    if (dst->path) {
        const size_t name_start = src->name.name - src->path->path;
        dst->name.name = dst->path->path + name_start;
        dst->name.len = src->name.len;
    } else {
        dst->name.name = NULL;
        dst->name.len = 0;
    }
    fh_copy(&dst->fh, &src->fh);
}

Referenced by nfs41_lookup(), prev_non_delimiter(), and server_lookup().

path_fh_init()

void path_fh_init	(	OUT nfs41_path_fh *	file,
		IN nfs41_abs_path *	path
	)

Definition at line 346 of file util.c.

{
    file->path = path;
    last_component(path->path, path->path + path->len, &file->name);
}

Referenced by create_open_state(), delegation_create(), and prev_non_delimiter().

prev_delimiter()

__inline const char * prev_delimiter	(	const char *	pos,
		const char *	start
	)

Definition at line 223 of file util.h.

                                                                        {
#else
FORCEINLINE const char* prev_delimiter(const char *pos, const char *start) {
#endif
    while (pos > start && !is_delimiter(*pos))
        pos--;
    return pos;
}

Referenced by abs_path_link(), last_component(), and prev_delimiter().

prev_non_delimiter()

__inline const char * prev_non_delimiter	(	const char *	pos,
		const char *	start
	)

Definition at line 241 of file util.h.

                                                                            {
#else
FORCEINLINE const char* prev_non_delimiter(const char *pos, const char *start) {
#endif
    while (pos > start && is_delimiter(*pos))
        pos--;
    return pos;
}

Referenced by last_component(), and prev_non_delimiter().

safe_read()

int safe_read	(	unsigned char **	pos,
		uint32_t *	remaining,
		void *	dest,
		uint32_t	dest_len
	)

Definition at line 33 of file util.c.

{
    if (*remaining < dest_len)
        return ERROR_BUFFER_OVERFLOW;
 
    CopyMemory(dest, *pos, dest_len);
    *pos += dest_len;
    *remaining -= dest_len;
    return 0;
}

Referenced by get_name(), handle_unlock(), parse_abs_path(), parse_close(), parse_getacl(), parse_getattr(), parse_getexattr(), parse_lock(), parse_mount(), parse_open(), parse_readdir(), parse_rw(), parse_setacl(), parse_setattr(), parse_setexattr(), parse_symlink(), parse_unlock(), parse_volume(), and upcall_parse().

safe_write()

int safe_write	(	unsigned char **	pos,
		uint32_t *	remaining,
		void *	dest,
		uint32_t	dest_len
	)

Definition at line 44 of file util.c.

{
    if (*remaining < src_len)
        return ERROR_BUFFER_OVERFLOW;
 
    CopyMemory(*pos, src, src_len);
    *pos += src_len;
    *remaining -= src_len;
    return 0;
}

Referenced by delegation_return(), marshall_getacl(), marshall_getattr(), marshall_getexattr(), marshall_mount(), marshall_open(), marshall_readdir(), marshall_rw(), marshall_setacl(), marshall_setattr(), marshall_setexattr(), marshall_symlink(), marshall_volume(), and upcall_marshall().

strip_path()

const char * strip_path	(	IN const char *	path,
		OUT uint32_t *len_out	OPTIONAL
	)

valid_handle()

__inline int valid_handle

(

HANDLE

handle

)

Definition at line 281 of file util.h.

                                         {
#else
FORCEINLINE int valid_handle(HANDLE handle) {
#endif
    return handle != INVALID_HANDLE_VALUE && handle != 0;
}

Referenced by get_handle_object(), nfs41_session_free(), nfs41_session_set_lease(), and valid_handle().

verify_commit()

bool_t verify_commit

(

IN nfs41_write_verf *

verf

)

Definition at line 126 of file util.c.

{
    if (memcmp(verf->expected, verf->verf, NFS4_VERIFIER_SIZE) == 0) {
        dprintf(3, "verify_commit: verifier matches expected\n");
        return 1;
    }
    dprintf(2, "verify_commit: verifier changed; writes have been lost!\n");
    return 0;
}

Referenced by file_layout_write_thread(), and write_to_mds().

verify_write()

bool_t verify_write	(	IN nfs41_write_verf *	verf,
		IN OUT enum stable_how4 *	stable
	)

Definition at line 100 of file util.c.

{
    if (verf->committed != UNSTABLE4) {
        *stable = verf->committed;
        dprintf(3, "verify_write: committed to stable storage\n");
        return 1;
    }
 
    if (*stable != UNSTABLE4) {
        memcpy(verf->expected, verf->verf, NFS4_VERIFIER_SIZE);
        *stable = UNSTABLE4;
        dprintf(3, "verify_write: first unstable write, saving verifier\n");
        return 1;
    }
 
    if (memcmp(verf->expected, verf->verf, NFS4_VERIFIER_SIZE) == 0) {
        dprintf(3, "verify_write: verifier matches expected\n");
        return 1;
    }
 
    dprintf(2, "verify_write: verifier changed; writes have been lost!\n");
    return 0;
}

Referenced by file_layout_write_thread(), and write_to_mds().

Variable Documentation

NFS41D_VERSION

DWORD NFS41D_VERSION

extern

Definition at line 42 of file nfs41_daemon.c.

Referenced by marshall_mount(), ServiceStart(), and upcall_parse().