lib/libhgfs/file.c

   1 /* Part of libhgfs - (c) 2009, D.C. van Moolenbroek */
   2
   3 #include "inc.h"
   4
   5 #include <fcntl.h>
   6 #include <sys/stat.h>
   7
   8 /*===========================================================================*
   9  *                              hgfs_open                                    *
  10  *===========================================================================*/
  11 PUBLIC int hgfs_open(path, flags, mode, handle)
  12 char *path;                     /* path name to open */
  13 int flags;                      /* open flags to use */
  14 int mode;                       /* mode to create (user bits only) */
  15 hgfs_file_t *handle;            /* place to store resulting handle */
  16 {
  17 /* Open a file. Store a file handle upon success.
  18  */
  19   int r, type;
  20
  21   /* We could implement this, but that means we would have to start tracking
  22    * open files in order to associate data with them. Rather not.
  23    */
  24   if (flags & O_APPEND) return EINVAL;
  25
  26   if (flags & O_CREAT) {
  27     if (flags & O_EXCL) type = HGFS_OPEN_TYPE_C;
  28     else if (flags & O_TRUNC) type = HGFS_OPEN_TYPE_COT;
  29     else type = HGFS_OPEN_TYPE_CO;
  30   } else {
  31     if (flags & O_TRUNC) type = HGFS_OPEN_TYPE_OT;
  32     else type = HGFS_OPEN_TYPE_O;
  33   }
  34
  35   RPC_REQUEST(HGFS_REQ_OPEN);
  36   RPC_NEXT32 = (flags & O_ACCMODE);
  37   RPC_NEXT32 = type;
  38   RPC_NEXT8 = HGFS_MODE_TO_PERM(mode);
  39
  40   path_put(path);
  41
  42   if ((r = rpc_query()) != OK)
  43         return r;
  44
  45   *handle = (hgfs_file_t)RPC_NEXT32;
  46
  47   return OK;
  48 }
  49
  50 /*===========================================================================*
  51  *                              hgfs_read                                    *
  52  *===========================================================================*/
  53 PUBLIC int hgfs_read(handle, buf, size, off)
  54 hgfs_file_t handle;             /* handle to open file */
  55 char *buf;                      /* data buffer or NULL */
  56 size_t size;                    /* maximum number of bytes to read */
  57 u64_t off;                      /* file offset */
  58 {
  59 /* Read from an open file. Upon success, return the number of bytes read.
  60  */
  61   int r, len, max;
  62
  63   RPC_REQUEST(HGFS_REQ_READ);
  64   RPC_NEXT32 = (u32_t)handle;
  65   RPC_NEXT32 = ex64lo(off);
  66   RPC_NEXT32 = ex64hi(off);
  67
  68   max = RPC_BUF_SIZE - RPC_LEN - sizeof(u32_t);
  69   RPC_NEXT32 = (size < max) ? size : max;
  70
  71   if ((r = rpc_query()) != OK)
  72         return r;
  73
  74   len = RPC_NEXT32;
  75   if (len > max) len = max; /* sanity check */
  76
  77   /* Only copy out data if we're requested to do so. */
  78   if (buf != NULL)
  79         memcpy(buf, RPC_PTR, len);
  80
  81   return len;
  82 }
  83
  84 /*===========================================================================*
  85  *                              hgfs_write                                   *
  86  *===========================================================================*/
  87 PUBLIC int hgfs_write(handle, buf, len, off, append)
  88 hgfs_file_t handle;             /* handle to open file */
  89 const char *buf;                /* data buffer or NULL */
  90 size_t len;                     /* number of bytes to write */
  91 u64_t off;                      /* file offset */
  92 int append;                     /* if set, append to file (ignore offset) */
  93 {
  94 /* Write to an open file. Upon success, return the number of bytes written.
  95  */
  96   int r;
  97
  98   RPC_REQUEST(HGFS_REQ_WRITE);
  99   RPC_NEXT32 = (u32_t)handle;
 100
 101   if (append) {
 102         RPC_NEXT8 = 1;
 103         RPC_NEXT32 = 0;
 104         RPC_NEXT32 = 0;
 105   }
 106   else {
 107         RPC_NEXT8 = 0;
 108         RPC_NEXT32 = ex64lo(off);
 109         RPC_NEXT32 = ex64hi(off);
 110   }
 111
 112   RPC_NEXT32 = len;
 113
 114   /* Only copy in data if we're requested to do so. */
 115   if (buf != NULL)
 116         memcpy(RPC_PTR, buf, len);
 117   RPC_ADVANCE(len);
 118
 119   if ((r = rpc_query()) != OK)
 120         return r;
 121
 122   return RPC_NEXT32;
 123 }
 124
 125 /*===========================================================================*
 126  *                              hgfs_close                                   *
 127  *===========================================================================*/
 128 PUBLIC int hgfs_close(handle)
 129 hgfs_file_t handle;             /* handle to open file */
 130 {
 131 /* Close an open file.
 132  */
 133
 134   RPC_REQUEST(HGFS_REQ_CLOSE);
 135   RPC_NEXT32 = (u32_t)handle;
 136
 137   return rpc_query();
 138 }
 139
 140 /*===========================================================================*
 141  *                              hgfs_readbuf                                 *
 142  *===========================================================================*/
 143 PUBLIC size_t hgfs_readbuf(ptr)
 144 char **ptr;
 145 {
 146 /* Return information about the read buffer, for zero-copy purposes. Store a
 147  * pointer to the first byte of the read buffer, and return the maximum data
 148  * size. The results are static, but must only be used directly prior to a
 149  * hgfs_read() call (with a NULL data buffer address).
 150  */
 151   u32_t off;
 152
 153   off = RPC_HDR_SIZE + sizeof(u32_t);
 154
 155   RPC_RESET;
 156   RPC_ADVANCE(off);
 157   *ptr = RPC_PTR;
 158
 159   return RPC_BUF_SIZE - off;
 160 }
 161
 162 /*===========================================================================*
 163  *                              hgfs_writebuf                                *
 164  *===========================================================================*/
 165 PUBLIC size_t hgfs_writebuf(ptr)
 166 char **ptr;
 167 {
 168 /* Return information about the write buffer, for zero-copy purposes. Store a
 169  * pointer to the first byte of the write buffer, and return the maximum data
 170  * size. The results are static, but must only be used immediately after a
 171  * hgfs_write() call (with a NULL data buffer address).
 172  */
 173   u32_t off;
 174
 175   off = RPC_HDR_SIZE + sizeof(u32_t) + sizeof(u8_t) + sizeof(u32_t) * 3;
 176
 177   RPC_RESET;
 178   RPC_ADVANCE(off);
 179   *ptr = RPC_PTR;
 180
 181   return RPC_BUF_SIZE - off;
 182 }