#define HGFS_ATTR_MTIME 0x08 /* get/set file modification time */
#define HGFS_ATTR_CTIME 0x10 /* get/set file change time */
#define HGFS_ATTR_MODE 0x20 /* get/set file mode */
-#define HGFS_ATTR_ATIME_SET 0x40 /* set specific file access time */
-#define HGFS_ATTR_MTIME_SET 0x80 /* set specific file modify time */
-#define HGFS_ATTR_ALL \
- (HGFS_ATTR_SIZE | HGFS_ATTR_CRTIME | HGFS_ATTR_ATIME | \
- HGFS_ATTR_MTIME | HGFS_ATTR_CTIME | HGFS_ATTR_MODE | \
- HGFS_ATTR_ATIME_SET | HGFS_ATTR_MTIME_SET)
int hgfs_init(void);
void hgfs_cleanup(void);
-int hgfs_enabled(void);
-
int hgfs_open(char *path, int flags, int mode, hgfs_file_t *handle);
int hgfs_read(hgfs_file_t handle, char *buf, size_t size, u64_t offset);
-int hgfs_write(hgfs_file_t handle, const char *buf, size_t len, u64_t
- offset, int append);
+int hgfs_write(hgfs_file_t handle, char *buf, size_t len, u64_t offset);
int hgfs_close(hgfs_file_t handle);
size_t hgfs_readbuf(char **ptr);
LIB= hgfs
SRCS= backdoor.S attr.c channel.c dir.c error.c file.c \
- link.c misc.c path.c rpc.c time.c
+ info.c link.c misc.c path.c rpc.c time.c
.include <bsd.lib.mk>
{
/* Set selected attributes of a file by path name.
*/
+ u8_t mask;
RPC_REQUEST(HGFS_REQ_SETATTR);
- RPC_NEXT8 = (attr->a_mask & HGFS_ATTR_ALL);
+ /* This library implements the HGFS v1 protocol, which is largely
+ * path-oriented. This is the only method to set the file size, and thus,
+ * truncating a deleted file is not possible. This has been fixed in later
+ * HGFS protocol version (v2/v3).
+ */
+ mask = 0;
+ if (attr->a_mask & HGFS_ATTR_MODE) mask |= HGFS_ATTR_MODE;
+ if (attr->a_mask & HGFS_ATTR_SIZE) mask |= HGFS_ATTR_SIZE;
+ if (attr->a_mask & HGFS_ATTR_CRTIME) mask |= HGFS_ATTR_CRTIME;
+ if (attr->a_mask & HGFS_ATTR_ATIME)
+ mask |= HGFS_ATTR_ATIME | HGFS_ATTR_ATIME_SET;
+ if (attr->a_mask & HGFS_ATTR_MTIME)
+ mask |= HGFS_ATTR_MTIME | HGFS_ATTR_MTIME_SET;
+ if (attr->a_mask & HGFS_ATTR_CTIME) mask |= HGFS_ATTR_CTIME;
+
+ RPC_NEXT8 = mask;
RPC_NEXT32 = !!(S_ISDIR(attr->a_mode));
RPC_NEXT32 = ex64lo(attr->a_size);
RPC_NEXT32 = ex64hi(attr->a_size);
time_put((attr->a_mask & HGFS_ATTR_CRTIME) ? &attr->a_crtime : NULL);
- time_put((attr->a_mask & HGFS_ATTR_ATIME_SET) ? &attr->a_atime : NULL);
- time_put((attr->a_mask & HGFS_ATTR_MTIME_SET) ? &attr->a_mtime : NULL);
+ time_put((attr->a_mask & HGFS_ATTR_ATIME) ? &attr->a_atime : NULL);
+ time_put((attr->a_mask & HGFS_ATTR_MTIME) ? &attr->a_mtime : NULL);
time_put((attr->a_mask & HGFS_ATTR_CTIME) ? &attr->a_ctime : NULL);
RPC_NEXT8 = HGFS_MODE_TO_PERM(attr->a_mode);
/* HGFS mode/perms conversion macros */
#define HGFS_MODE_TO_PERM(m) (((m) & S_IRWXU) >> 6)
#define HGFS_PERM_TO_MODE(p) (((p) << 6) & S_IRWXU)
+
+/* HGFS attribute flags */
+#define HGFS_ATTR_SIZE 0x01 /* get/set file size */
+#define HGFS_ATTR_CRTIME 0x02 /* get/set file creation time */
+#define HGFS_ATTR_ATIME 0x04 /* get/set file access time */
+#define HGFS_ATTR_MTIME 0x08 /* get/set file modification time */
+#define HGFS_ATTR_CTIME 0x10 /* get/set file change time */
+#define HGFS_ATTR_MODE 0x20 /* get/set file mode */
+#define HGFS_ATTR_ATIME_SET 0x40 /* set specific file access time */
+#define HGFS_ATTR_MTIME_SET 0x80 /* set specific file modify time */
* number. Upon success, the resulting path name is stored in the given buffer
* and the given attribute structure is filled selectively as requested. Upon
* error, the contents of the path buffer and attribute structure are
- * undefined.
+ * undefined. ENOENT is returned upon end of directory.
*/
int r;
RPC_NEXT32 = (u32_t)handle;
RPC_NEXT32 = index;
+ /* EINVAL signifies end of directory. */
if ((r = rpc_query()) != OK)
- return r;
+ return (r == EINVAL) ? ENOENT : OK;
attr_get(attr);
- return path_get(buf, size);
+ if ((r = path_get(buf, size)) != OK)
+ return r;
+
+ /* VMware Player 3 returns an empty name, instead of EINVAL, when reading
+ * from an EOF position right after opening the directory handle. Seems to be
+ * a newly introduced bug..
+ */
+ return (!buf[0]) ? ENOENT : OK;
}
/*===========================================================================*
len = RPC_NEXT32;
if (len > max) len = max; /* sanity check */
- /* Only copy out data if we're requested to do so. */
- if (buf != NULL)
+ /* Only copy out data if we're not operating directly on the RPC buffer. */
+ if (buf != RPC_PTR)
memcpy(buf, RPC_PTR, len);
return len;
/*===========================================================================*
* hgfs_write *
*===========================================================================*/
-int hgfs_write(handle, buf, len, off, append)
+int hgfs_write(handle, buf, len, off)
hgfs_file_t handle; /* handle to open file */
-const char *buf; /* data buffer or NULL */
+char *buf; /* data buffer or NULL */
size_t len; /* number of bytes to write */
u64_t off; /* file offset */
-int append; /* if set, append to file (ignore offset) */
{
/* Write to an open file. Upon success, return the number of bytes written.
*/
RPC_REQUEST(HGFS_REQ_WRITE);
RPC_NEXT32 = (u32_t)handle;
-
- if (append) {
- RPC_NEXT8 = 1;
- RPC_NEXT32 = 0;
- RPC_NEXT32 = 0;
- }
- else {
- RPC_NEXT8 = 0;
- RPC_NEXT32 = ex64lo(off);
- RPC_NEXT32 = ex64hi(off);
- }
-
+ RPC_NEXT8 = 0; /* append flag */
+ RPC_NEXT32 = ex64lo(off);
+ RPC_NEXT32 = ex64hi(off);
RPC_NEXT32 = len;
- /* Only copy in data if we're requested to do so. */
- if (buf != NULL)
+ /* Only copy in data if we're not operating directly on the RPC buffer. */
+ if (RPC_PTR != buf)
memcpy(RPC_PTR, buf, len);
RPC_ADVANCE(len);
--- /dev/null
+/* Part of libhgfs - (c) 2009, D.C. van Moolenbroek */
+
+#include "inc.h"
+
+/*===========================================================================*
+ * hgfs_queryvol *
+ *===========================================================================*/
+int hgfs_queryvol(path, free, total)
+char *path;
+u64_t *free;
+u64_t *total;
+{
+/* Retrieve information about available and total volume space associated with
+ * a given path.
+ */
+ u32_t lo, hi;
+ int r;
+
+ RPC_REQUEST(HGFS_REQ_QUERYVOL);
+
+ path_put(path);
+
+ /* It appears that this call always fails with EACCES ("permission denied")
+ * on read-only folders. As far as I can tell, this is a VMware bug.
+ */
+ if ((r = rpc_query()) != OK)
+ return r;
+
+ lo = RPC_NEXT32;
+ hi = RPC_NEXT32;
+ *free = make64(lo, hi);
+
+ lo = RPC_NEXT32;
+ hi = RPC_NEXT32;
+ *total = make64(lo, hi);
+
+ return OK;
+}
int hgfs_init()
{
/* Initialize the library. Return OK on success, or a negative error code
- * otherwise. If EAGAIN is returned, shared folders are disabled; in that
- * case, other operations may be tried (and possibly succeed).
+ * otherwise. If EAGAIN is returned, shared folders are disabled.
*/
time_init();
rpc_close();
}
-
-/*===========================================================================*
- * hgfs_enabled *
- *===========================================================================*/
-int hgfs_enabled()
-{
-/* Check if shared folders are enabled. Return OK if so, EAGAIN if not, and
- * another negative error code on error.
- */
-
- return rpc_test();
-}
-
-/*===========================================================================*
- * hgfs_queryvol *
- *===========================================================================*/
-int hgfs_queryvol(path, free, total)
-char *path;
-u64_t *free;
-u64_t *total;
-{
-/* Retrieve information about available and total volume space associated with
- * a given path.
- */
- u32_t lo, hi;
- int r;
-
- RPC_REQUEST(HGFS_REQ_QUERYVOL);
-
- path_put(path);
-
- if ((r = rpc_query()) != OK)
- return r;
-
- lo = RPC_NEXT32;
- hi = RPC_NEXT32;
- *free = make64(lo, hi);
-
- lo = RPC_NEXT32;
- hi = RPC_NEXT32;
- *total = make64(lo, hi);
-
- return OK;
-}
int rpc_open()
{
/* Open a HGFS RPC backdoor channel to the VMware host, and make sure that it
- * is working. Return OK upon success, or a negative error code otherwise.
+ * is working. Return OK upon success, or a negative error code otherwise; in
+ * particular, return EAGAIN if shared folders are disabled.
*/
int r;
r = rpc_test();
- if (r != OK && r != EAGAIN)
+ if (r != OK)
channel_close(&rpc_chan);
return r;
#define NUM_HASH_SLOTS 1023
/* Arbitrary block size constant returned by fstatfs and statvfs.
- * Also used by getdents. This is not the actual HGFS data transfer unit size.
+ * Also used by getdents. This is not the underlying data transfer unit size.
*/
#define BLOCK_SIZE 4096
* modifications on the host system are not part of the protocol, so sometimes
* the server may discover that some files do not exist anymore. In that case,
* they are marked as DELETED in the inode table. Such files may still be used
- * because of open file handles, but cannot be referenced by path anymore.
- * Unfortunately the HGFS v1 protocol is largely path-oriented, so even
- * truncating a deleted file is not possible. This has been fixed in v2/v3, but
- * we currently use the v1 protocol for VMware backwards compatibility reasons.
+ * because of open file handles, but cannot be referenced by path anymore. The
+ * underlying protocol may not support truncation of open files anyway. Since
+ * we currently cannot guarantee that a file is actually opened before it is
+ * deleted (as this would consistute opening every file being looked up), we
+ * effectively do not properly support open deleted files at all anyway.
*
* An inode is REFERENCED iff it has a reference count > 0 *or* has children.
* An inode is LINKED IN iff it has a parent.
unsigned short i_flags; /* any combination of I_* flags */
union {
TAILQ_ENTRY(inode) u_free; /* free list chain entry */
- hgfs_file_t u_file; /* handle to open HGFS file */
- hgfs_dir_t u_dir; /* handle to open HGFS directory */
+ hgfs_file_t u_file; /* handle to open file */
+ hgfs_dir_t u_dir; /* handle to open directory */
} i_u;
char i_name[NAME_MAX+1]; /* entry name in parent directory */
};
/* Initialize the HGFS library. If this fails, exit immediately. */
r = hgfs_init();
- if (r != OK && r != EAGAIN) {
- printf("HGFS: unable to initialize HGFS library (%d)\n", r);
+ if (r != OK) {
+ if (r == EAGAIN)
+ printf("HGFS: shared folders are disabled\n");
+ else
+ printf("HGFS: unable to initialize HGFS library (%d)\n", r);
return r;
}
/* Unfortunately, we cannot be any more specific than this, because we are
* not given an inode number. Statistics of individual shared folders can
- * only be obtained by using the "prefix=" option when mounting.
+ * only be obtained by making sure that the root of the file system is an
+ * actual share, and not a list of available shares.
*/
if ((ino = find_inode(ROOT_INODE_NR)) == NULL)
return EINVAL;
if ((r = verify_inode(ino, path, NULL)) != OK)
return r;
- /* It appears that this call always fails with EACCES ("permission denied")
- * on read-only folders. As far as I can tell, this is a VMware bug.
- */
if ((r = hgfs_queryvol(path, &free, &total)) != OK)
return r;
* VFS. Print a (hopefully) helpful error message, and abort the mount.
*/
if ((r = verify_inode(ino, path, &attr)) != OK) {
- if (r == EAGAIN)
- printf("HGFS: shared folders disabled\n");
- else if (opt.prefix[0] && (r == ENOENT || r == EACCES))
+ if (opt.prefix[0] && (r == ENOENT || r == EACCES))
printf("HGFS: unable to access the given prefix directory\n");
else
printf("HGFS: unable to access shared folders\n");
while (count > 0) {
chunk = MIN(count, size);
- if ((r = hgfs_read(ino->i_file, NULL, chunk, pos)) <= 0)
+ if ((r = hgfs_read(ino->i_file, ptr, chunk, pos)) <= 0)
break;
chunk = r;
*/
for (pos = m_in.REQ_SEEK_POS_LO; ; pos++) {
/* Determine which inode and name to use for this entry.
- * We have no idea whether the HGFS host will give us "." and/or "..",
+ * We have no idea whether the host will give us "." and/or "..",
* so generate our own and skip those from the host.
*/
if (pos == 0) {
r = hgfs_readdir(ino->i_dir, pos - 2, name, sizeof(name),
&attr);
- if (r != OK || !name[0]) {
+ if (r != OK) {
/* No more entries? Then close the handle and stop. */
- /* VMware Player 3 returns an empty name, instead of
- * EINVAL, when reading from an EOF position right
- * after opening the directory handle. Seems to be a
- * newly introduced bug..
- */
- if (r == EINVAL || !name[0]) {
+ if (r == ENOENT) {
put_handle(ino);
break;
struct inode *ino;
int mode;
{
-/* Return the mode for an inode, given the inode and the HGFS retrieved mode.
+/* Return the mode for an inode, given the inode and the retrieved mode.
*/
mode &= S_IRWXU;
mode = S_IFREG | (mode & opt.file_mask);
if (state.read_only)
- mode &= ~0222;
+ mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
return mode;
}
if ((r = verify_inode(ino, path, NULL)) != OK)
return r;
- attr.a_mask = HGFS_ATTR_ATIME | HGFS_ATTR_MTIME | HGFS_ATTR_ATIME_SET |
- HGFS_ATTR_MTIME_SET;
+ attr.a_mask = HGFS_ATTR_ATIME | HGFS_ATTR_MTIME;
attr.a_atime.tv_sec = m_in.REQ_ACTIME;
attr.a_atime.tv_nsec = 0;
attr.a_mtime.tv_sec = m_in.REQ_MODTIME;
memset(ptr, 0, chunk);
}
- if ((r = hgfs_write(ino->i_file, NULL, chunk, pos, FALSE)) <= 0)
+ if ((r = hgfs_write(ino->i_file, ptr, chunk, pos)) <= 0)
break;
count -= r;