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 encode_pre_wcc(struct wcc_data *wcc, BlueSkyInode *inode)
  69 {
  70     wcc->before.present = TRUE;
  71     wcc->before.pre_op_attr_u.attributes.size = inode->size;
  72     wcc->before.pre_op_attr_u.attributes.mtime.seconds = inode->mtime / 1000000;
  73     wcc->before.pre_op_attr_u.attributes.mtime.nseconds = (inode->mtime % 1000000) * 1000;
  74     wcc->before.pre_op_attr_u.attributes.ctime.seconds = inode->ctime / 1000000;
  75     wcc->before.pre_op_attr_u.attributes.ctime.nseconds = (inode->ctime % 1000000) * 1000;
  76 }
  77 void *
  78 nfsproc3_null_3_svc(void *argp, struct svc_req *rqstp)
  79 {
  80     return null_result;
  81 }
  82
  83 getattr3res *
  84 nfsproc3_getattr_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
  85 {
  86     static getattr3res result;
  87
  88     BlueSkyInode *inode = lookup_fh(argp);
  89     if (inode != NULL) {
  90         result.status = NFS3_OK;
  91         encode_fattr3(&result.getattr3res_u.attributes, inode);
  92     } else {
  93         result.status = NFS3ERR_STALE;
  94     }
  95
  96     return &result;
  97 }
  98
  99 wccstat3 *
 100 nfsproc3_setattr_3_svc(setattr3args *argp, struct svc_req *rqstp)
 101 {
 102     static wccstat3 result;
 103
 104     result.status = NFS3ERR_NOTSUPP;
 105
 106     return &result;
 107 }
 108
 109 lookup3res *
 110 nfsproc3_lookup_3_svc(diropargs3 *argp, struct svc_req *rqstp)
 111 {
 112     static lookup3res result;
 113
 114     BlueSkyInode *dir = lookup_fh(&argp->dir);
 115     if (dir == NULL) {
 116         result.status = NFS3ERR_STALE;
 117         result.lookup3res_u.resfail.present = FALSE;
 118         return &result;
 119     }
 120
 121     result.lookup3res_u.resfail.present = TRUE;
 122     encode_fattr3(&result.lookup3res_u.resfail.post_op_attr_u.attributes, dir);
 123     if (!validate_filename(argp->name)) {
 124         if (strlen(argp->name) > 255)
 125             result.status = NFS3ERR_NAMETOOLONG;
 126         else
 127             result.status = NFS3ERR_NOENT;
 128         return &result;
 129     }
 130
 131     /* TODO: Special-case "." and "..". */
 132     uint64_t inum = bluesky_directory_lookup(dir, argp->name);
 133     if (inum == 0) {
 134         result.status = NFS3ERR_NOENT;
 135         return &result;
 136     }
 137     BlueSkyInode *inode = bluesky_get_inode(fs, inum);
 138     if (inode == NULL) {
 139         result.status = NFS3ERR_NOENT;
 140         return &result;
 141     }
 142
 143     result.lookup3res_u.resok.dir_attributes.present = TRUE;
 144     encode_fattr3(&result.lookup3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
 145     result.lookup3res_u.resok.obj_attributes.present = TRUE;
 146     encode_fattr3(&result.lookup3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 147
 148     static uint64_t fh_bytes;
 149     fh_bytes = GUINT64_TO_BE(inum);
 150     result.lookup3res_u.resok.object.data.data_len = 8;
 151     result.lookup3res_u.resok.object.data.data_val = (char *)&fh_bytes;
 152
 153     return &result;
 154 }
 155
 156 access3res *
 157 nfsproc3_access_3_svc(access3args *argp, struct svc_req *rqstp)
 158 {
 159     static access3res result;
 160
 161     BlueSkyInode *inode = lookup_fh(&argp->object);
 162     if (inode == NULL) {
 163         result.status = NFS3ERR_STALE;
 164         result.access3res_u.resfail.present = FALSE;
 165         return &result;
 166     }
 167
 168     result.status = NFS3_OK;
 169     result.access3res_u.resok.obj_attributes.present = TRUE;
 170     encode_fattr3(&result.access3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 171     result.access3res_u.resok.access = argp->access;
 172
 173     return &result;
 174 }
 175
 176 readlink3res *
 177 nfsproc3_readlink_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 178 {
 179     static readlink3res result;
 180
 181     result.status = NFS3ERR_NOTSUPP;
 182
 183     return &result;
 184 }
 185
 186 read3res *
 187 nfsproc3_read_3_svc(read3args *argp, struct svc_req *rqstp)
 188 {
 189     static read3res result;
 190
 191     result.status = NFS3ERR_NOTSUPP;
 192
 193     return &result;
 194 }
 195
 196 write3res *
 197 nfsproc3_write_3_svc(write3args *argp, struct svc_req *rqstp)
 198 {
 199     static write3res result;
 200
 201     result.status = NFS3ERR_NOTSUPP;
 202
 203     return &result;
 204 }
 205
 206 diropres3 *
 207 nfsproc3_create_3_svc(create3args *argp, struct svc_req *rqstp)
 208 {
 209     static diropres3 result;
 210     struct wcc_data wcc;
 211     memset(&wcc, 0, sizeof(wcc));
 212
 213     BlueSkyInode *dir = lookup_fh(&argp->where.dir);
 214     if (dir == NULL) {
 215         result.status = NFS3ERR_STALE;
 216         result.diropres3_u.resfail = wcc;
 217         return &result;
 218     }
 219
 220     encode_pre_wcc(&wcc, dir);
 221     if (dir->type != BLUESKY_DIRECTORY) {
 222         result.status = NFS3ERR_NOTDIR;
 223         result.diropres3_u.resfail = wcc;
 224         return &result;
 225     }
 226
 227     if (!validate_filename(argp->where.name)
 228         || strcmp(argp->where.name, ".") == 0
 229         || strcmp(argp->where.name, "..") == 0)
 230     {
 231         result.status = NFS3ERR_EXIST;
 232         result.diropres3_u.resfail = wcc;
 233         return &result;
 234     }
 235
 236     BlueSkyInode *file;
 237     file = bluesky_new_inode(bluesky_fs_alloc_inode(fs), BLUESKY_REGULAR);
 238     file->nlink = 1;
 239     file->mode = 0755;
 240     bluesky_insert_inode(fs, file);
 241     bluesky_directory_insert(dir, argp->where.name, file->inum);
 242
 243     wcc.after.present = TRUE;
 244     encode_fattr3(&wcc.after.post_op_attr_u.attributes, dir);
 245     result.diropres3_u.resok.obj_attributes.present = TRUE;
 246     encode_fattr3(&result.diropres3_u.resok.obj_attributes.post_op_attr_u.attributes, file);
 247     result.diropres3_u.resok.dir_wcc = wcc;
 248
 249     static uint64_t fh_bytes;
 250     fh_bytes = GUINT64_TO_BE(file->inum);
 251     result.diropres3_u.resok.obj.present = TRUE;
 252     result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_len = 8;
 253     result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_val = (char *)&fh_bytes;
 254
 255     return &result;
 256 }
 257
 258 diropres3 *
 259 nfsproc3_mkdir_3_svc(mkdir3args *argp, struct svc_req *rqstp)
 260 {
 261     static diropres3 result;
 262
 263     result.status = NFS3ERR_NOTSUPP;
 264
 265     return &result;
 266 }
 267
 268 diropres3 *
 269 nfsproc3_symlink_3_svc(symlink3args *argp, struct svc_req *rqstp)
 270 {
 271     static diropres3 result;
 272
 273     result.status = NFS3ERR_NOTSUPP;
 274
 275     return &result;
 276 }
 277
 278 diropres3 *
 279 nfsproc3_mknod_3_svc(mknod3args *argp, struct svc_req *rqstp)
 280 {
 281     static diropres3 result;
 282
 283     result.status = NFS3ERR_NOTSUPP;
 284
 285     return &result;
 286 }
 287
 288 wccstat3 *
 289 nfsproc3_remove_3_svc(diropargs3 *argp, struct svc_req *rqstp)
 290 {
 291     static wccstat3 result;
 292
 293     result.status = NFS3ERR_NOTSUPP;
 294
 295     return &result;
 296 }
 297
 298 wccstat3 *
 299 nfsproc3_rmdir_3_svc(diropargs3 *argp, struct svc_req *rqstp)
 300 {
 301     static wccstat3 result;
 302
 303     result.status = NFS3ERR_NOTSUPP;
 304
 305     return &result;
 306 }
 307
 308 rename3res *
 309 nfsproc3_rename_3_svc(rename3args *argp, struct svc_req *rqstp)
 310 {
 311     static rename3res result;
 312
 313     result.status = NFS3ERR_NOTSUPP;
 314
 315     return &result;
 316 }
 317
 318 link3res *
 319 nfsproc3_link_3_svc(link3args *argp, struct svc_req *rqstp)
 320 {
 321     static link3res result;
 322
 323     result.status = NFS3ERR_NOTSUPP;
 324
 325     return &result;
 326 }
 327
 328 gint bluesky_dirent_compare(gconstpointer a, gconstpointer b,
 329                             gpointer unused);
 330
 331 readdir3res *
 332 nfsproc3_readdir_3_svc(readdir3args *argp, struct svc_req *rqstp)
 333 {
 334     static readdir3res result;
 335
 336     BlueSkyInode *dir = lookup_fh(&argp->dir);
 337     if (dir == NULL) {
 338         result.status = NFS3ERR_STALE;
 339         result.readdir3res_u.resfail.present = FALSE;
 340         return &result;
 341     }
 342
 343     result.status = NFS3_OK;
 344     result.readdir3res_u.resok.dir_attributes.present = TRUE;
 345     encode_fattr3(&result.readdir3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
 346     memset(result.readdir3res_u.resok.cookieverf, 0,
 347            sizeof(result.readdir3res_u.resok.cookieverf));
 348
 349 #define MAX_READDIR_DIRENTS 4
 350     static entry3 dirents[MAX_READDIR_DIRENTS];
 351     int count = 0;
 352
 353     BlueSkyDirent start = {NULL, argp->cookie, 0};
 354     GSequenceIter *i = g_sequence_search(dir->dirents, &start,
 355                                          bluesky_dirent_compare, NULL);
 356
 357     while (count < MAX_READDIR_DIRENTS && !g_sequence_iter_is_end(i)) {
 358         BlueSkyDirent *d = g_sequence_get(i);
 359         dirents[count].fileid = d->inum;
 360         dirents[count].name = d->name;
 361         dirents[count].cookie = d->hash;
 362         dirents[count].nextentry = NULL;
 363         if (count > 0)
 364             dirents[count - 1].nextentry = &dirents[count];
 365         i = g_sequence_iter_next(i);
 366         count++;
 367     }
 368
 369     if (count > 0)
 370         result.readdir3res_u.resok.reply.entries = &dirents[0];
 371     else
 372         result.readdir3res_u.resok.reply.entries = NULL;
 373     result.readdir3res_u.resok.reply.eof = g_sequence_iter_is_end(i);
 374
 375     return &result;
 376 }
 377
 378 readdirplus3res *
 379 nfsproc3_readdirplus_3_svc(readdirplus3args *argp, struct svc_req *rqstp)
 380 {
 381     static readdirplus3res result;
 382
 383     result.status = NFS3ERR_NOTSUPP;
 384
 385     return &result;
 386 }
 387
 388 fsstat3res *
 389 nfsproc3_fsstat_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 390 {
 391     static fsstat3res result;
 392
 393     result.status = NFS3ERR_NOTSUPP;
 394
 395     return &result;
 396 }
 397
 398 fsinfo3res *
 399 nfsproc3_fsinfo_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 400 {
 401     static fsinfo3res result;
 402
 403     BlueSkyInode *inode = bluesky_get_inode(fs, 1);
 404     result.status = NFS3_OK;
 405     result.fsinfo3res_u.resok.obj_attributes.present = TRUE;
 406     encode_fattr3(&result.fsinfo3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 407     result.fsinfo3res_u.resok.rtmax = 32768;
 408     result.fsinfo3res_u.resok.rtpref = 32768;
 409     result.fsinfo3res_u.resok.rtmult = 4096;
 410     result.fsinfo3res_u.resok.wtmax = 32768;
 411     result.fsinfo3res_u.resok.wtpref = 32768;
 412     result.fsinfo3res_u.resok.wtmult = 4096;
 413     result.fsinfo3res_u.resok.dtpref = 4096;
 414     result.fsinfo3res_u.resok.maxfilesize = 0x7fffffffffffffffULL;
 415     result.fsinfo3res_u.resok.time_delta.seconds = 0;
 416     result.fsinfo3res_u.resok.time_delta.nseconds = 1000;
 417     result.fsinfo3res_u.resok.properties
 418         = FSF3_LINK | FSF3_SYMLINK | FSF3_HOMOGENEOUS | FSF3_CANSETTIME;
 419
 420     return &result;
 421 }
 422
 423 pathconf3res *
 424 nfsproc3_pathconf_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 425 {
 426     static pathconf3res result;
 427
 428     BlueSkyInode *inode = bluesky_get_inode(fs, 1);
 429     result.status = NFS3_OK;
 430     result.pathconf3res_u.resok.obj_attributes.present = TRUE;
 431     encode_fattr3(&result.pathconf3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 432     result.pathconf3res_u.resok.linkmax = 0xffffffff;
 433     result.pathconf3res_u.resok.name_max = 255;
 434     result.pathconf3res_u.resok.no_trunc = TRUE;
 435     result.pathconf3res_u.resok.chown_restricted = TRUE;
 436     result.pathconf3res_u.resok.case_insensitive = FALSE;
 437     result.pathconf3res_u.resok.case_preserving = TRUE;
 438
 439     return &result;
 440 }
 441
 442 commit3res *
 443 nfsproc3_commit_3_svc(commit3args *argp, struct svc_req *rqstp)
 444 {
 445     static commit3res result;
 446
 447     result.status = NFS3ERR_NOTSUPP;
 448
 449     return &result;
 450 }