nfs3/nfs3.c

   1 /*
   2  * This is sample code generated by rpcgen.
   3  * These are only templates and you can use them
   4  * as a guideline for developing your own functions.
   5  */
   6
   7 #include "nfs3_prot.h"
   8 #include "bluesky.h"
   9
  10 extern BlueSkyFS *fs;
  11
  12 static int null_int;
  13 static void *null_result = (void *)&null_int;
  14
  15 /* Check that a string is a valid file name.  We require that it be valid
  16  * UTF-8, that it not be empty, and that it not contain embedded forward
  17  * slashes.  Also checks that the length of the string is not more than the
  18  * maximum allowed length.  This function does allow the names "." and "..".
  19  * Returns TRUE if te string is allowed as a filename. */
  20 gboolean validate_filename(const char *filename)
  21 {
  22     if (filename == NULL || filename[0] == '\0')
  23         return FALSE;
  24     if (strlen(filename) > 255)
  25         return FALSE;
  26     if (!g_utf8_validate(filename, -1, NULL))
  27         return FALSE;
  28     if (strchr(filename, '/') != NULL)
  29         return FALSE;
  30     return TRUE;
  31 }
  32
  33 /* Look up a BlueSkyInode given an NFS filehandle.  Returns NULL if the
  34  * filehandle is invalid. */
  35 BlueSkyInode *lookup_fh(nfs_fh3 *fh)
  36 {
  37     BlueSkyInode *inode = NULL;
  38     if (fh->data.data_len == 8) {
  39         uint64_t inum = GUINT64_FROM_BE(*(uint64_t *)(fh->data.data_val));
  40         inode = bluesky_get_inode(fs, inum);
  41     }
  42     return inode;
  43 }
  44
  45 /* Copy inode attributes into NFS response.  The BlueSkyInode should be locked
  46  * by the caller. */
  47 void encode_fattr3(struct fattr3 *result, BlueSkyInode *inode)
  48 {
  49     result->type = inode->type;
  50     result->mode = inode->mode;
  51     result->nlink = inode->nlink;
  52     result->uid = inode->uid;
  53     result->gid = inode->gid;
  54     result->size = inode->size;
  55     result->used = 0;
  56     result->rdev.major = 0;
  57     result->rdev.minor = 0;
  58     result->fsid = 0;
  59     result->fileid = inode->inum;
  60     result->atime.seconds = inode->atime / 1000000;
  61     result->atime.nseconds = (inode->atime % 1000000) * 1000;
  62     result->mtime.seconds = inode->mtime / 1000000;
  63     result->mtime.nseconds = (inode->mtime % 1000000) * 1000;
  64     result->ctime.seconds = inode->ctime / 1000000;
  65     result->ctime.nseconds = (inode->ctime % 1000000) * 1000;
  66 }
  67
  68 void *
  69 nfsproc3_null_3_svc(void *argp, struct svc_req *rqstp)
  70 {
  71     return null_result;
  72 }
  73
  74 getattr3res *
  75 nfsproc3_getattr_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
  76 {
  77     static getattr3res result;
  78
  79     BlueSkyInode *inode = lookup_fh(argp);
  80     if (inode != NULL) {
  81         result.status = NFS3_OK;
  82         encode_fattr3(&result.getattr3res_u.attributes, inode);
  83     } else {
  84         result.status = NFS3ERR_STALE;
  85     }
  86
  87     return &result;
  88 }
  89
  90 wccstat3 *
  91 nfsproc3_setattr_3_svc(setattr3args *argp, struct svc_req *rqstp)
  92 {
  93     static wccstat3 result;
  94
  95     result.status = NFS3ERR_NOTSUPP;
  96
  97     return &result;
  98 }
  99
 100 lookup3res *
 101 nfsproc3_lookup_3_svc(diropargs3 *argp, struct svc_req *rqstp)
 102 {
 103     static lookup3res result;
 104
 105     BlueSkyInode *dir = lookup_fh(&argp->dir);
 106     if (dir == NULL) {
 107         result.status = NFS3ERR_STALE;
 108         result.lookup3res_u.resfail.present = FALSE;
 109         return &result;
 110     }
 111
 112     result.lookup3res_u.resfail.present = TRUE;
 113     encode_fattr3(&result.lookup3res_u.resfail.post_op_attr_u.attributes, dir);
 114     if (!validate_filename(argp->name)) {
 115         if (strlen(argp->name) > 255)
 116             result.status = NFS3ERR_NAMETOOLONG;
 117         else
 118             result.status = NFS3ERR_NOENT;
 119         return &result;
 120     }
 121
 122     /* TODO: Special-case "." and "..". */
 123     uint64_t inum = bluesky_directory_lookup(dir, argp->name);
 124     if (inum == 0) {
 125         result.status = NFS3ERR_NOENT;
 126         return &result;
 127     }
 128     BlueSkyInode *inode = bluesky_get_inode(fs, inum);
 129     if (inode == NULL) {
 130         result.status = NFS3ERR_NOENT;
 131         return &result;
 132     }
 133
 134     result.lookup3res_u.resok.dir_attributes.present = TRUE;
 135     encode_fattr3(&result.lookup3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
 136     result.lookup3res_u.resok.obj_attributes.present = TRUE;
 137     encode_fattr3(&result.lookup3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 138
 139     static uint64_t fh_bytes;
 140     fh_bytes = GUINT64_TO_BE(inum);
 141     result.lookup3res_u.resok.object.data.data_len = 8;
 142     result.lookup3res_u.resok.object.data.data_val = (char *)&fh_bytes;
 143
 144     return &result;
 145 }
 146
 147 access3res *
 148 nfsproc3_access_3_svc(access3args *argp, struct svc_req *rqstp)
 149 {
 150     static access3res result;
 151
 152     BlueSkyInode *inode = lookup_fh(&argp->object);
 153     if (inode == NULL) {
 154         result.status = NFS3ERR_STALE;
 155         result.access3res_u.resfail.present = FALSE;
 156         return &result;
 157     }
 158
 159     result.status = NFS3_OK;
 160     result.access3res_u.resok.obj_attributes.present = TRUE;
 161     encode_fattr3(&result.access3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 162     result.access3res_u.resok.access = argp->access;
 163
 164     return &result;
 165 }
 166
 167 readlink3res *
 168 nfsproc3_readlink_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 169 {
 170     static readlink3res result;
 171
 172     result.status = NFS3ERR_NOTSUPP;
 173
 174     return &result;
 175 }
 176
 177 read3res *
 178 nfsproc3_read_3_svc(read3args *argp, struct svc_req *rqstp)
 179 {
 180     static read3res result;
 181
 182     result.status = NFS3ERR_NOTSUPP;
 183
 184     return &result;
 185 }
 186
 187 write3res *
 188 nfsproc3_write_3_svc(write3args *argp, struct svc_req *rqstp)
 189 {
 190     static write3res result;
 191
 192     result.status = NFS3ERR_NOTSUPP;
 193
 194     return &result;
 195 }
 196
 197 diropres3 *
 198 nfsproc3_create_3_svc(create3args *argp, struct svc_req *rqstp)
 199 {
 200     static diropres3 result;
 201
 202     result.status = NFS3ERR_NOTSUPP;
 203
 204     return &result;
 205 }
 206
 207 diropres3 *
 208 nfsproc3_mkdir_3_svc(mkdir3args *argp, struct svc_req *rqstp)
 209 {
 210     static diropres3 result;
 211
 212     result.status = NFS3ERR_NOTSUPP;
 213
 214     return &result;
 215 }
 216
 217 diropres3 *
 218 nfsproc3_symlink_3_svc(symlink3args *argp, struct svc_req *rqstp)
 219 {
 220     static diropres3 result;
 221
 222     result.status = NFS3ERR_NOTSUPP;
 223
 224     return &result;
 225 }
 226
 227 diropres3 *
 228 nfsproc3_mknod_3_svc(mknod3args *argp, struct svc_req *rqstp)
 229 {
 230     static diropres3 result;
 231
 232     result.status = NFS3ERR_NOTSUPP;
 233
 234     return &result;
 235 }
 236
 237 wccstat3 *
 238 nfsproc3_remove_3_svc(diropargs3 *argp, struct svc_req *rqstp)
 239 {
 240     static wccstat3 result;
 241
 242     result.status = NFS3ERR_NOTSUPP;
 243
 244     return &result;
 245 }
 246
 247 wccstat3 *
 248 nfsproc3_rmdir_3_svc(diropargs3 *argp, struct svc_req *rqstp)
 249 {
 250     static wccstat3 result;
 251
 252     result.status = NFS3ERR_NOTSUPP;
 253
 254     return &result;
 255 }
 256
 257 rename3res *
 258 nfsproc3_rename_3_svc(rename3args *argp, struct svc_req *rqstp)
 259 {
 260     static rename3res result;
 261
 262     result.status = NFS3ERR_NOTSUPP;
 263
 264     return &result;
 265 }
 266
 267 link3res *
 268 nfsproc3_link_3_svc(link3args *argp, struct svc_req *rqstp)
 269 {
 270     static link3res result;
 271
 272     result.status = NFS3ERR_NOTSUPP;
 273
 274     return &result;
 275 }
 276
 277 gint bluesky_dirent_compare(gconstpointer a, gconstpointer b,
 278                             gpointer unused);
 279
 280 readdir3res *
 281 nfsproc3_readdir_3_svc(readdir3args *argp, struct svc_req *rqstp)
 282 {
 283     static readdir3res result;
 284
 285     BlueSkyInode *dir = lookup_fh(&argp->dir);
 286     if (dir == NULL) {
 287         result.status = NFS3ERR_STALE;
 288         result.readdir3res_u.resfail.present = FALSE;
 289         return &result;
 290     }
 291
 292     result.status = NFS3_OK;
 293     result.readdir3res_u.resok.dir_attributes.present = TRUE;
 294     encode_fattr3(&result.readdir3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
 295     memset(result.readdir3res_u.resok.cookieverf, 0,
 296            sizeof(result.readdir3res_u.resok.cookieverf));
 297
 298 #define MAX_READDIR_DIRENTS 4
 299     static entry3 dirents[MAX_READDIR_DIRENTS];
 300     int count = 0;
 301
 302     BlueSkyDirent start = {NULL, argp->cookie, 0};
 303     GSequenceIter *i = g_sequence_search(dir->dirents, &start,
 304                                          bluesky_dirent_compare, NULL);
 305
 306     while (count < MAX_READDIR_DIRENTS && !g_sequence_iter_is_end(i)) {
 307         BlueSkyDirent *d = g_sequence_get(i);
 308         dirents[count].fileid = d->inum;
 309         dirents[count].name = d->name;
 310         dirents[count].cookie = d->hash;
 311         dirents[count].nextentry = NULL;
 312         if (count > 0)
 313             dirents[count - 1].nextentry = &dirents[count];
 314         i = g_sequence_iter_next(i);
 315         count++;
 316         printf("readdir: %s %lld\n", d->name, d->inum);
 317     }
 318
 319     if (count > 0)
 320         result.readdir3res_u.resok.reply.entries = &dirents[0];
 321     else
 322         result.readdir3res_u.resok.reply.entries = NULL;
 323     result.readdir3res_u.resok.reply.eof = g_sequence_iter_is_end(i);
 324
 325     return &result;
 326 }
 327
 328 readdirplus3res *
 329 nfsproc3_readdirplus_3_svc(readdirplus3args *argp, struct svc_req *rqstp)
 330 {
 331     static readdirplus3res result;
 332
 333     result.status = NFS3ERR_NOTSUPP;
 334
 335     return &result;
 336 }
 337
 338 fsstat3res *
 339 nfsproc3_fsstat_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 340 {
 341     static fsstat3res result;
 342
 343     result.status = NFS3ERR_NOTSUPP;
 344
 345     return &result;
 346 }
 347
 348 fsinfo3res *
 349 nfsproc3_fsinfo_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 350 {
 351     static fsinfo3res result;
 352
 353     BlueSkyInode *inode = bluesky_get_inode(fs, 1);
 354     result.status = NFS3_OK;
 355     result.fsinfo3res_u.resok.obj_attributes.present = TRUE;
 356     encode_fattr3(&result.fsinfo3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 357     result.fsinfo3res_u.resok.rtmax = 32768;
 358     result.fsinfo3res_u.resok.rtpref = 32768;
 359     result.fsinfo3res_u.resok.rtmult = 4096;
 360     result.fsinfo3res_u.resok.wtmax = 32768;
 361     result.fsinfo3res_u.resok.wtpref = 32768;
 362     result.fsinfo3res_u.resok.wtmult = 4096;
 363     result.fsinfo3res_u.resok.dtpref = 4096;
 364     result.fsinfo3res_u.resok.maxfilesize = 0x7fffffffffffffffULL;
 365     result.fsinfo3res_u.resok.time_delta.seconds = 0;
 366     result.fsinfo3res_u.resok.time_delta.nseconds = 1000;
 367     result.fsinfo3res_u.resok.properties
 368         = FSF3_LINK | FSF3_SYMLINK | FSF3_HOMOGENEOUS | FSF3_CANSETTIME;
 369
 370     return &result;
 371 }
 372
 373 pathconf3res *
 374 nfsproc3_pathconf_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 375 {
 376     static pathconf3res result;
 377
 378     BlueSkyInode *inode = bluesky_get_inode(fs, 1);
 379     result.status = NFS3_OK;
 380     result.pathconf3res_u.resok.obj_attributes.present = TRUE;
 381     encode_fattr3(&result.pathconf3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 382     result.pathconf3res_u.resok.linkmax = 0xffffffff;
 383     result.pathconf3res_u.resok.name_max = 255;
 384     result.pathconf3res_u.resok.no_trunc = TRUE;
 385     result.pathconf3res_u.resok.chown_restricted = TRUE;
 386     result.pathconf3res_u.resok.case_insensitive = FALSE;
 387     result.pathconf3res_u.resok.case_preserving = TRUE;
 388
 389     return &result;
 390 }
 391
 392 commit3res *
 393 nfsproc3_commit_3_svc(commit3args *argp, struct svc_req *rqstp)
 394 {
 395     static commit3res result;
 396
 397     result.status = NFS3ERR_NOTSUPP;
 398
 399     return &result;
 400 }