libnfs: Add lutimes

[deb_libnfs.git] / lib / libnfs-sync.c

diff --git a/lib/libnfs-sync.c b/lib/libnfs-sync.c
index 83d7086e16fc3d7785d60465af68f7620ce00906..fe1e063153d73fba48216acef7992d3398ac780a 100644 (file)
--- a/lib/libnfs-sync.c
+++ b/lib/libnfs-sync.c
@@ -29,6 +29,10 @@
 #include "win32_compat.h"
 #endif
 
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+
 #ifdef HAVE_NET_IF_H
 #include <net/if.h>
 #endif
@@ -49,10 +53,6 @@
 #include <sys/ioctl.h>
 #endif
 
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-
 #ifdef HAVE_POLL_H
 #include <poll.h>
 #endif
@@ -94,11 +94,12 @@
 #include "libnfs-private.h"
 
 struct sync_cb_data {
-       int is_finished;
-       int status;
-       uint64_t offset;
-       void *return_data;
-       int return_int;
+       int is_finished;
+       int status;
+       uint64_t offset;
+       void *return_data;
+       int return_int;
+       const char *call;
 };
 
 
@@ -267,6 +268,23 @@ int nfs_stat64(struct nfs_context *nfs, const char *path, struct nfs_stat_64 *st
        return cb_data.status;
 }
 
+int nfs_lstat64(struct nfs_context *nfs, const char *path, struct nfs_stat_64 *st)
+{
+       struct sync_cb_data cb_data;
+
+       cb_data.is_finished = 0;
+       cb_data.return_data = st;
+
+       if (nfs_lstat64_async(nfs, path, stat64_cb, &cb_data) != 0) {
+               nfs_set_error(nfs, "nfs_lstat64_async failed");
+               return -1;
+       }
+
+       wait_for_nfs_reply(nfs, &cb_data);
+
+       return cb_data.status;
+}
+
 /*
  * open()
  */
@@ -351,7 +369,7 @@ static void pread_cb(int status, struct nfs_context *nfs, void *data, void *priv
        cb_data->status = status;
 
        if (status < 0) {
-               nfs_set_error(nfs, "pread call failed with \"%s\"", (char *)data);
+               nfs_set_error(nfs, "%s call failed with \"%s\"", cb_data->call, (char *)data);
                return;
        }
 
@@ -365,6 +383,7 @@ int nfs_pread(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uin
 
        cb_data.is_finished = 0;
        cb_data.return_data = buffer;
+       cb_data.call = "pread";
 
        if (nfs_pread_async(nfs, nfsfh, offset, count, pread_cb, &cb_data) != 0) {
                nfs_set_error(nfs, "nfs_pread_async failed");
@@ -381,7 +400,20 @@ int nfs_pread(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uin
  */
 int nfs_read(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, char *buffer)
 {
-       return nfs_pread(nfs, nfsfh, nfs_get_current_offset(nfsfh), count, buffer);
+       struct sync_cb_data cb_data;
+
+       cb_data.is_finished = 0;
+       cb_data.return_data = buffer;
+       cb_data.call = "read";
+
+       if (nfs_read_async(nfs, nfsfh, count, pread_cb, &cb_data) != 0) {
+               nfs_set_error(nfs, "nfs_read_async failed");
+               return -1;
+       }
+
+       wait_for_nfs_reply(nfs, &cb_data);
+
+       return cb_data.status;
 }
 
 /*
@@ -438,6 +470,26 @@ int nfs_fstat(struct nfs_context *nfs, struct nfsfh *nfsfh, struct stat *st)
        return cb_data.status;
 }
 
+/*
+ * fstat64()
+ */
+int nfs_fstat64(struct nfs_context *nfs, struct nfsfh *nfsfh, struct nfs_stat_64 *st)
+{
+       struct sync_cb_data cb_data;
+
+       cb_data.is_finished = 0;
+       cb_data.return_data = st;
+
+       if (nfs_fstat64_async(nfs, nfsfh, stat64_cb, &cb_data) != 0) {
+               nfs_set_error(nfs, "nfs_fstat64_async failed");
+               return -1;
+       }
+
+       wait_for_nfs_reply(nfs, &cb_data);
+
+       return cb_data.status;
+}
+
 
 /*
  * pwrite()
@@ -448,10 +500,8 @@ static void pwrite_cb(int status, struct nfs_context *nfs, void *data, void *pri
        cb_data->is_finished = 1;
        cb_data->status = status;
 
-       if (status < 0) {
-               nfs_set_error(nfs, "pwrite call failed with \"%s\"", (char *)data);
-               return;
-       }
+       if (status < 0)
+               nfs_set_error(nfs, "%s call failed with \"%s\"", cb_data->call, (char *)data);
 }
 
 int nfs_pwrite(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, uint64_t count, char *buf)
@@ -459,6 +509,7 @@ int nfs_pwrite(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, ui
        struct sync_cb_data cb_data;
 
        cb_data.is_finished = 0;
+       cb_data.call = "pwrite";
 
        if (nfs_pwrite_async(nfs, nfsfh, offset, count, buf, pwrite_cb, &cb_data) != 0) {
                nfs_set_error(nfs, "nfs_pwrite_async failed");
@@ -475,7 +526,19 @@ int nfs_pwrite(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, ui
  */
 int nfs_write(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, char *buf)
 {
-       return nfs_pwrite(nfs, nfsfh, nfs_get_current_offset(nfsfh), count, buf);
+       struct sync_cb_data cb_data;
+
+       cb_data.is_finished = 0;
+       cb_data.call = "write";
+
+       if (nfs_write_async(nfs, nfsfh, count, buf, pwrite_cb, &cb_data) != 0) {
+               nfs_set_error(nfs, "nfs_write_async failed");
+               return -1;
+       }
+
+       wait_for_nfs_reply(nfs, &cb_data);
+
+       return cb_data.status;
 }
 
 
@@ -670,15 +733,15 @@ static void creat_cb(int status, struct nfs_context *nfs, void *data, void *priv
        *nfsfh = fh;
 }
 
-int nfs_creat(struct nfs_context *nfs, const char *path, int mode, struct nfsfh **nfsfh)
+int nfs_create(struct nfs_context *nfs, const char *path, int flags, int mode, struct nfsfh **nfsfh)
 {
        struct sync_cb_data cb_data;
 
        cb_data.is_finished = 0;
        cb_data.return_data = nfsfh;
 
-       if (nfs_creat_async(nfs, path, mode, creat_cb, &cb_data) != 0) {
-               nfs_set_error(nfs, "nfs_creat_async failed");
+       if (nfs_create_async(nfs, path, flags, mode, creat_cb, &cb_data) != 0) {
+               nfs_set_error(nfs, "nfs_create_async failed");
                return -1;
        }
 
@@ -687,6 +750,11 @@ int nfs_creat(struct nfs_context *nfs, const char *path, int mode, struct nfsfh
        return cb_data.status;
 }
 
+int nfs_creat(struct nfs_context *nfs, const char *path, int mode, struct nfsfh **nfsfh)
+{
+       return nfs_create(nfs, path, 0, mode, nfsfh);
+}
+
 /*
  * mknod()
  */
@@ -1017,6 +1085,25 @@ int nfs_chown(struct nfs_context *nfs, const char *path, int uid, int gid)
        return cb_data.status;
 }
 
+/*
+ * lchown()
+ */
+int nfs_lchown(struct nfs_context *nfs, const char *path, int uid, int gid)
+{
+       struct sync_cb_data cb_data;
+
+       cb_data.is_finished = 0;
+
+       if (nfs_lchown_async(nfs, path, uid, gid, chown_cb, &cb_data) != 0) {
+               nfs_set_error(nfs, "nfs_lchown_async failed");
+               return -1;
+       }
+
+       wait_for_nfs_reply(nfs, &cb_data);
+
+       return cb_data.status;
+}
+
 /*
  * fchown()
  */
@@ -1083,6 +1170,22 @@ int nfs_utimes(struct nfs_context *nfs, const char *path, struct timeval *times)
        return cb_data.status;
 }
 
+int nfs_lutimes(struct nfs_context *nfs, const char *path, struct timeval *times)
+{
+       struct sync_cb_data cb_data;
+
+       cb_data.is_finished = 0;
+
+       if (nfs_lutimes_async(nfs, path, times, utimes_cb, &cb_data) != 0) {
+               nfs_set_error(nfs, "nfs_lutimes_async failed");
+               return -1;
+       }
+
+       wait_for_nfs_reply(nfs, &cb_data);
+
+       return cb_data.status;
+}
+
 
 
 /*