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 the 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 int64_t decode_nfstime3(nfstime3 *time)
  46 {
  47     int64_t result = (int64_t)time->seconds * 1000000;
  48     result += time->nseconds / 1000;
  49     return result;
  50 }
  51
  52 void set_attributes(BlueSkyInode *inode, sattr3 *attributes)
  53 {
  54     int64_t now = bluesky_get_current_time();
  55
  56     if (attributes->mode.set) {
  57         inode->mode = attributes->mode.set_uint32_u.val;
  58     }
  59
  60     if (attributes->uid.set) {
  61         inode->uid = attributes->uid.set_uint32_u.val;
  62     }
  63
  64     if (attributes->gid.set) {
  65         inode->gid = attributes->gid.set_uint32_u.val;
  66     }
  67
  68     if (attributes->size.set) {
  69         if (inode->type == BLUESKY_REGULAR) {
  70             bluesky_file_truncate(inode, attributes->size.set_uint64_u.val);
  71             inode->mtime = now;
  72         }
  73     }
  74
  75     switch (attributes->atime.set) {
  76     case DONT_CHANGE:
  77         break;
  78     case SET_TO_SERVER_TIME:
  79         inode->atime = now;
  80         break;
  81     case SET_TO_CLIENT_TIME:
  82         inode->atime = decode_nfstime3(&attributes->atime.set_time_u.time);
  83         break;
  84     }
  85
  86     switch (attributes->mtime.set) {
  87     case DONT_CHANGE:
  88         break;
  89     case SET_TO_SERVER_TIME:
  90         inode->mtime = now;
  91         break;
  92     case SET_TO_CLIENT_TIME:
  93         inode->mtime = decode_nfstime3(&attributes->mtime.set_time_u.time);
  94         break;
  95     }
  96
  97     inode->ctime = now;
  98     inode->change_count++;
  99 }
 100
 101 /* Copy inode attributes into NFS response.  The BlueSkyInode should be locked
 102  * by the caller. */
 103 void encode_fattr3(struct fattr3 *result, BlueSkyInode *inode)
 104 {
 105     result->type = inode->type;
 106     result->mode = inode->mode;
 107     result->nlink = inode->nlink;
 108     result->uid = inode->uid;
 109     result->gid = inode->gid;
 110     result->size = inode->size;
 111     result->used = 0;
 112     result->rdev.major = 0;
 113     result->rdev.minor = 0;
 114     result->fsid = 0;
 115     result->fileid = inode->inum;
 116     result->atime.seconds = inode->atime / 1000000;
 117     result->atime.nseconds = (inode->atime % 1000000) * 1000;
 118     result->mtime.seconds = inode->mtime / 1000000;
 119     result->mtime.nseconds = (inode->mtime % 1000000) * 1000;
 120     result->ctime.seconds = inode->ctime / 1000000;
 121     result->ctime.nseconds = (inode->ctime % 1000000) * 1000;
 122
 123     switch (inode->type) {
 124     case BLUESKY_SYMLINK:
 125         result->size = strlen(inode->symlink_contents);
 126         break;
 127     default:
 128         break;
 129     }
 130 }
 131
 132 void encode_pre_wcc(struct wcc_data *wcc, BlueSkyInode *inode)
 133 {
 134     wcc->before.present = TRUE;
 135     wcc->before.pre_op_attr_u.attributes.size = inode->size;
 136     wcc->before.pre_op_attr_u.attributes.mtime.seconds = inode->mtime / 1000000;
 137     wcc->before.pre_op_attr_u.attributes.mtime.nseconds = (inode->mtime % 1000000) * 1000;
 138     wcc->before.pre_op_attr_u.attributes.ctime.seconds = inode->ctime / 1000000;
 139     wcc->before.pre_op_attr_u.attributes.ctime.nseconds = (inode->ctime % 1000000) * 1000;
 140 }
 141
 142 void nfsproc3_null_3_svc(void *argp, RPCRequest *req)
 143 {
 144     async_rpc_send_reply(req, null_result);
 145 }
 146
 147 void nfsproc3_getattr_3_svc(nfs_fh3 *argp, RPCRequest *req)
 148 {
 149     static getattr3res result;
 150
 151     BlueSkyInode *inode = lookup_fh(argp);
 152     if (inode != NULL) {
 153         result.status = NFS3_OK;
 154         encode_fattr3(&result.getattr3res_u.attributes, inode);
 155     } else {
 156         result.status = NFS3ERR_STALE;
 157     }
 158
 159     async_rpc_send_reply(req, &result);
 160 }
 161
 162 void nfsproc3_setattr_3_svc(setattr3args *argp, RPCRequest *req)
 163 {
 164     static wccstat3 result;
 165
 166     result.wccstat3_u.wcc.before.present = FALSE;
 167     result.wccstat3_u.wcc.after.present = FALSE;
 168     BlueSkyInode *inode = lookup_fh(&argp->object);
 169     if (inode == NULL) {
 170         result.status = NFS3ERR_STALE;
 171         async_rpc_send_reply(req, &result);
 172         return;
 173     }
 174
 175     encode_pre_wcc(&result.wccstat3_u.wcc, inode);
 176     if (argp->guard.check) {
 177         if (inode->ctime != decode_nfstime3(&argp->guard.sattrguard3_u.ctime)) {
 178             result.status = NFS3ERR_NOT_SYNC;
 179             result.wccstat3_u.wcc.after.present = TRUE;
 180             encode_fattr3(&result.wccstat3_u.wcc.after.post_op_attr_u.attributes, inode);
 181             async_rpc_send_reply(req, &result);
 182             return;
 183         }
 184     }
 185
 186     set_attributes(inode, &argp->new_attributes);
 187
 188     result.wccstat3_u.wcc.after.present = TRUE;
 189     encode_fattr3(&result.wccstat3_u.wcc.after.post_op_attr_u.attributes,
 190                   inode);
 191     result.status = NFS3_OK;
 192
 193     async_rpc_send_reply(req, &result);
 194 }
 195
 196 void nfsproc3_lookup_3_svc(diropargs3 *argp, RPCRequest *req)
 197 {
 198     static lookup3res result;
 199
 200     BlueSkyInode *dir = lookup_fh(&argp->dir);
 201     if (dir == NULL) {
 202         result.status = NFS3ERR_STALE;
 203         result.lookup3res_u.resfail.present = FALSE;
 204         async_rpc_send_reply(req, &result);
 205         return;
 206     }
 207
 208     result.lookup3res_u.resfail.present = TRUE;
 209     encode_fattr3(&result.lookup3res_u.resfail.post_op_attr_u.attributes, dir);
 210     if (!validate_filename(argp->name)) {
 211         if (strlen(argp->name) > 255)
 212             result.status = NFS3ERR_NAMETOOLONG;
 213         else
 214             result.status = NFS3ERR_NOENT;
 215         async_rpc_send_reply(req, &result);
 216         return;
 217     }
 218
 219     /* TODO: Special-case "." and "..". */
 220     uint64_t inum = bluesky_directory_lookup(dir, argp->name);
 221     if (inum == 0) {
 222         result.status = NFS3ERR_NOENT;
 223         async_rpc_send_reply(req, &result);
 224         return;
 225     }
 226     BlueSkyInode *inode = bluesky_get_inode(fs, inum);
 227     if (inode == NULL) {
 228         result.status = NFS3ERR_NOENT;
 229         async_rpc_send_reply(req, &result);
 230         return;
 231     }
 232
 233     result.status = NFS3_OK;
 234     result.lookup3res_u.resok.dir_attributes.present = TRUE;
 235     encode_fattr3(&result.lookup3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
 236     result.lookup3res_u.resok.obj_attributes.present = TRUE;
 237     encode_fattr3(&result.lookup3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 238
 239     static uint64_t fh_bytes;
 240     fh_bytes = GUINT64_TO_BE(inum);
 241     result.lookup3res_u.resok.object.data.data_len = 8;
 242     result.lookup3res_u.resok.object.data.data_val = (char *)&fh_bytes;
 243
 244     async_rpc_send_reply(req, &result);
 245 }
 246
 247 void nfsproc3_access_3_svc(access3args *argp, RPCRequest *req)
 248 {
 249     static access3res result;
 250
 251     BlueSkyInode *inode = lookup_fh(&argp->object);
 252     if (inode == NULL) {
 253         result.status = NFS3ERR_STALE;
 254         result.access3res_u.resfail.present = FALSE;
 255         async_rpc_send_reply(req, &result);
 256         return;
 257     }
 258
 259     result.status = NFS3_OK;
 260     result.access3res_u.resok.obj_attributes.present = TRUE;
 261     encode_fattr3(&result.access3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 262     result.access3res_u.resok.access = argp->access;
 263
 264     async_rpc_send_reply(req, &result);
 265 }
 266
 267 void nfsproc3_readlink_3_svc(nfs_fh3 *argp, RPCRequest *req)
 268 {
 269     static readlink3res result;
 270     memset(&result, 0, sizeof(result));
 271
 272     BlueSkyInode *inode = lookup_fh(argp);
 273     if (inode != NULL) {
 274         if (inode->type == BLUESKY_SYMLINK) {
 275             result.status = NFS3_OK;
 276             result.readlink3res_u.resok.symlink_attributes.present = TRUE;
 277             encode_fattr3(&result.readlink3res_u.resok.symlink_attributes.post_op_attr_u.attributes, inode);
 278             result.readlink3res_u.resok.data = inode->symlink_contents;
 279         } else {
 280             result.status = NFS3ERR_INVAL;
 281             result.readlink3res_u.resfail.present = TRUE;
 282             encode_fattr3(&result.readlink3res_u.resfail.post_op_attr_u.attributes, inode);
 283         }
 284     } else {
 285         result.status = NFS3ERR_STALE;
 286     }
 287
 288     async_rpc_send_reply(req, &result);
 289 }
 290
 291 void nfsproc3_read_3_svc(read3args *argp, RPCRequest *req)
 292 {
 293     static read3res result;
 294     static char buf[32768];
 295
 296     BlueSkyInode *inode = lookup_fh(&argp->file);
 297     if (inode == NULL) {
 298         result.status = NFS3ERR_STALE;
 299         result.read3res_u.resfail.present = FALSE;
 300         async_rpc_send_reply(req, &result);
 301         return;
 302     }
 303
 304     int count = argp->count;
 305     if (argp->offset >= inode->size) {
 306         count = 0;
 307         result.read3res_u.resok.eof = TRUE;
 308     } else {
 309         count = MIN(count, inode->size - argp->offset);
 310         if (argp->offset + count == inode->size)
 311             result.read3res_u.resok.eof = TRUE;
 312         else
 313             result.read3res_u.resok.eof = FALSE;
 314
 315         bluesky_file_read(inode, argp->offset, buf, count);
 316     }
 317
 318     result.status = NFS3_OK;
 319     result.read3res_u.resok.file_attributes.present = TRUE;
 320     encode_fattr3(&result.read3res_u.resok.file_attributes.post_op_attr_u.attributes, inode);
 321     result.read3res_u.resok.count = count;
 322     result.read3res_u.resok.data.data_val = buf;
 323     result.read3res_u.resok.data.data_len = count;
 324
 325     async_rpc_send_reply(req, &result);
 326 }
 327
 328 void nfsproc3_write_3_svc(write3args *argp, RPCRequest *req)
 329 {
 330     static write3res result;
 331     struct wcc_data wcc;
 332     memset(&wcc, 0, sizeof(wcc));
 333
 334     BlueSkyInode *inode = lookup_fh(&argp->file);
 335     if (inode == NULL) {
 336         result.status = NFS3ERR_STALE;
 337         result.write3res_u.resfail = wcc;
 338         async_rpc_send_reply(req, &result);
 339         return;
 340     }
 341
 342     encode_pre_wcc(&wcc, inode);
 343     if (inode->type != BLUESKY_REGULAR) {
 344         result.status = NFS3ERR_INVAL;
 345         result.write3res_u.resfail = wcc;
 346         async_rpc_send_reply(req, &result);
 347         return;
 348     }
 349
 350     uint64_t lastbyte = argp->offset + argp->count;
 351     if (lastbyte > inode->size) {
 352         bluesky_file_truncate(inode, lastbyte);
 353     }
 354
 355     if (argp->data.data_len < argp->count) {
 356         /* ??? */
 357     } else {
 358         bluesky_file_write(inode, argp->offset,
 359                            argp->data.data_val, argp->count);
 360     }
 361
 362     wcc.after.present = TRUE;
 363     encode_fattr3(&wcc.after.post_op_attr_u.attributes, inode);
 364     result.write3res_u.resok.file_wcc = wcc;
 365     result.write3res_u.resok.count = argp->count;
 366     result.write3res_u.resok.committed = FILE_SYNC;
 367
 368     async_rpc_send_reply(req, &result);
 369 }
 370
 371 void nfsproc3_create_3_svc(create3args *argp, RPCRequest *req)
 372 {
 373     static diropres3 result;
 374     struct wcc_data wcc;
 375     memset(&wcc, 0, sizeof(wcc));
 376
 377     BlueSkyInode *dir = lookup_fh(&argp->where.dir);
 378     if (dir == NULL) {
 379         result.status = NFS3ERR_STALE;
 380         result.diropres3_u.resfail = wcc;
 381         async_rpc_send_reply(req, &result);
 382         return;
 383     }
 384
 385     encode_pre_wcc(&wcc, dir);
 386     if (dir->type != BLUESKY_DIRECTORY) {
 387         result.status = NFS3ERR_NOTDIR;
 388         result.diropres3_u.resfail = wcc;
 389         async_rpc_send_reply(req, &result);
 390         return;
 391     }
 392
 393     if (!validate_filename(argp->where.name)
 394         || strcmp(argp->where.name, ".") == 0
 395         || strcmp(argp->where.name, "..") == 0)
 396     {
 397         result.status = NFS3ERR_EXIST;
 398         result.diropres3_u.resfail = wcc;
 399         async_rpc_send_reply(req, &result);
 400         return;
 401     }
 402
 403     BlueSkyInode *file;
 404     file = bluesky_new_inode(bluesky_fs_alloc_inode(fs), fs, BLUESKY_REGULAR);
 405     file->nlink = 1;
 406     file->mode = 0755;
 407     int64_t time = bluesky_get_current_time();
 408     printf("time: %"PRIi64"\n", time);
 409     file->mtime = time;
 410     file->ctime = time;
 411     file->atime = time;
 412     file->ntime = time;
 413     bluesky_insert_inode(fs, file);
 414     bluesky_directory_insert(dir, argp->where.name, file->inum);
 415
 416     dir->mtime = dir->ctime = bluesky_get_current_time();
 417     dir->change_count++;
 418
 419     wcc.after.present = TRUE;
 420     encode_fattr3(&wcc.after.post_op_attr_u.attributes, dir);
 421     result.diropres3_u.resok.obj_attributes.present = TRUE;
 422     encode_fattr3(&result.diropres3_u.resok.obj_attributes.post_op_attr_u.attributes, file);
 423     result.diropres3_u.resok.dir_wcc = wcc;
 424
 425     static uint64_t fh_bytes;
 426     fh_bytes = GUINT64_TO_BE(file->inum);
 427     result.diropres3_u.resok.obj.present = TRUE;
 428     result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_len = 8;
 429     result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_val = (char *)&fh_bytes;
 430
 431     async_rpc_send_reply(req, &result);
 432 }
 433
 434 void nfsproc3_mkdir_3_svc(mkdir3args *argp, RPCRequest *req)
 435 {
 436     static diropres3 result;
 437     struct wcc_data wcc;
 438     memset(&wcc, 0, sizeof(wcc));
 439
 440     BlueSkyInode *dir = lookup_fh(&argp->where.dir);
 441     if (dir == NULL) {
 442         result.status = NFS3ERR_STALE;
 443         result.diropres3_u.resfail = wcc;
 444         async_rpc_send_reply(req, &result);
 445         return;
 446     }
 447
 448     encode_pre_wcc(&wcc, dir);
 449     if (dir->type != BLUESKY_DIRECTORY) {
 450         result.status = NFS3ERR_NOTDIR;
 451         result.diropres3_u.resfail = wcc;
 452         async_rpc_send_reply(req, &result);
 453         return;
 454     }
 455
 456     if (!validate_filename(argp->where.name)
 457         || strcmp(argp->where.name, ".") == 0
 458         || strcmp(argp->where.name, "..") == 0)
 459     {
 460         result.status = NFS3ERR_EXIST;
 461         result.diropres3_u.resfail = wcc;
 462         async_rpc_send_reply(req, &result);
 463         return;
 464     }
 465
 466     BlueSkyInode *file;
 467     file = bluesky_new_inode(bluesky_fs_alloc_inode(fs), fs, BLUESKY_DIRECTORY);
 468     file->nlink = 1;
 469     file->mode = 0755;
 470     int64_t time = bluesky_get_current_time();
 471     file->mtime = time;
 472     file->ctime = time;
 473     file->atime = time;
 474     file->ntime = time;
 475     bluesky_insert_inode(fs, file);
 476     bluesky_directory_insert(dir, argp->where.name, file->inum);
 477     set_attributes(file, &argp->attributes);
 478
 479     dir->mtime = dir->ctime = bluesky_get_current_time();
 480     dir->change_count++;
 481
 482     wcc.after.present = TRUE;
 483     encode_fattr3(&wcc.after.post_op_attr_u.attributes, dir);
 484     result.diropres3_u.resok.obj_attributes.present = TRUE;
 485     encode_fattr3(&result.diropres3_u.resok.obj_attributes.post_op_attr_u.attributes, file);
 486     result.diropres3_u.resok.dir_wcc = wcc;
 487
 488     static uint64_t fh_bytes;
 489     fh_bytes = GUINT64_TO_BE(file->inum);
 490     result.diropres3_u.resok.obj.present = TRUE;
 491     result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_len = 8;
 492     result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_val = (char *)&fh_bytes;
 493
 494     async_rpc_send_reply(req, &result);
 495 }
 496
 497 void nfsproc3_symlink_3_svc(symlink3args *argp, RPCRequest *req)
 498 {
 499     static diropres3 result;
 500     struct wcc_data wcc;
 501     memset(&wcc, 0, sizeof(wcc));
 502
 503     BlueSkyInode *dir = lookup_fh(&argp->where.dir);
 504     if (dir == NULL) {
 505         result.status = NFS3ERR_STALE;
 506         result.diropres3_u.resfail = wcc;
 507         async_rpc_send_reply(req, &result);
 508         return;
 509     }
 510
 511     encode_pre_wcc(&wcc, dir);
 512     if (dir->type != BLUESKY_DIRECTORY) {
 513         result.status = NFS3ERR_NOTDIR;
 514         result.diropres3_u.resfail = wcc;
 515         async_rpc_send_reply(req, &result);
 516         return;
 517     }
 518
 519     if (!validate_filename(argp->where.name)
 520         || strcmp(argp->where.name, ".") == 0
 521         || strcmp(argp->where.name, "..") == 0)
 522     {
 523         result.status = NFS3ERR_EXIST;
 524         result.diropres3_u.resfail = wcc;
 525         async_rpc_send_reply(req, &result);
 526         return;
 527     }
 528
 529     BlueSkyInode *file;
 530     file = bluesky_new_inode(bluesky_fs_alloc_inode(fs), fs, BLUESKY_SYMLINK);
 531     file->nlink = 1;
 532     file->mode = 0755;
 533     int64_t time = bluesky_get_current_time();
 534     file->mtime = time;
 535     file->ctime = time;
 536     file->atime = time;
 537     file->ntime = time;
 538     file->symlink_contents = g_strdup(argp->symlink.symlink_data);
 539     bluesky_insert_inode(fs, file);
 540     bluesky_directory_insert(dir, argp->where.name, file->inum);
 541
 542     dir->mtime = dir->ctime = bluesky_get_current_time();
 543     dir->change_count++;
 544
 545     wcc.after.present = TRUE;
 546     encode_fattr3(&wcc.after.post_op_attr_u.attributes, dir);
 547     result.diropres3_u.resok.obj_attributes.present = TRUE;
 548     encode_fattr3(&result.diropres3_u.resok.obj_attributes.post_op_attr_u.attributes, file);
 549     result.diropres3_u.resok.dir_wcc = wcc;
 550
 551     static uint64_t fh_bytes;
 552     fh_bytes = GUINT64_TO_BE(file->inum);
 553     result.diropres3_u.resok.obj.present = TRUE;
 554     result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_len = 8;
 555     result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_val = (char *)&fh_bytes;
 556
 557     async_rpc_send_reply(req, &result);
 558 }
 559
 560 void nfsproc3_mknod_3_svc(mknod3args *argp, RPCRequest *req)
 561 {
 562     static diropres3 result;
 563
 564     result.status = NFS3ERR_NOTSUPP;
 565
 566     async_rpc_send_reply(req, &result);
 567 }
 568
 569 void nfsproc3_remove_3_svc(diropargs3 *argp, RPCRequest *req)
 570 {
 571     static wccstat3 result;
 572
 573     result.wccstat3_u.wcc.before.present = FALSE;
 574     result.wccstat3_u.wcc.after.present = FALSE;
 575
 576     BlueSkyInode *dir = lookup_fh(&argp->dir);
 577     if (dir == NULL) {
 578         result.status = NFS3ERR_STALE;
 579         async_rpc_send_reply(req, &result);
 580         return;
 581     }
 582
 583     encode_pre_wcc(&result.wccstat3_u.wcc, dir);
 584
 585     if (!validate_filename(argp->name)
 586         || strcmp(argp->name, ".") == 0
 587         || strcmp(argp->name, "..") == 0)
 588     {
 589         result.status = NFS3ERR_NOENT;
 590         async_rpc_send_reply(req, &result);
 591         return;
 592     }
 593
 594     /* TODO: Decrement link count, deallocate inode if needed. */
 595
 596     bluesky_directory_remove(dir, argp->name);
 597
 598     result.status = NFS3_OK;
 599     result.wccstat3_u.wcc.after.present = TRUE;
 600     encode_fattr3(&result.wccstat3_u.wcc.after.post_op_attr_u.attributes,
 601                   dir);
 602
 603     async_rpc_send_reply(req, &result);
 604 }
 605
 606 void nfsproc3_rmdir_3_svc(diropargs3 *argp, RPCRequest *req)
 607 {
 608     static wccstat3 result;
 609
 610     result.wccstat3_u.wcc.before.present = FALSE;
 611     result.wccstat3_u.wcc.after.present = FALSE;
 612
 613     BlueSkyInode *dir = lookup_fh(&argp->dir);
 614     if (dir == NULL) {
 615         result.status = NFS3ERR_STALE;
 616         async_rpc_send_reply(req, &result);
 617         return;
 618     }
 619
 620     encode_pre_wcc(&result.wccstat3_u.wcc, dir);
 621
 622     if (!validate_filename(argp->name)
 623         || strcmp(argp->name, ".") == 0
 624         || strcmp(argp->name, "..") == 0)
 625     {
 626         result.status = NFS3ERR_NOENT;
 627         async_rpc_send_reply(req, &result);
 628         return;
 629     }
 630
 631     uint64_t inum = bluesky_directory_lookup(dir, argp->name);
 632     BlueSkyInode *inode = bluesky_get_inode(fs, inum);
 633     if (inode == NULL) {
 634         result.status = NFS3ERR_NOENT;
 635         async_rpc_send_reply(req, &result);
 636         return;
 637     }
 638
 639     if (inode->type != BLUESKY_DIRECTORY) {
 640         result.status = NFS3ERR_NOTDIR;
 641         async_rpc_send_reply(req, &result);
 642         return;
 643     }
 644     if (g_sequence_get_length(inode->dirents) > 0) {
 645         printf("Directory not empty: %d entries\n",
 646                g_sequence_get_length(inode->dirents));
 647         result.status = NFS3ERR_NOTEMPTY;
 648         async_rpc_send_reply(req, &result);
 649         return;
 650     }
 651
 652     /* TODO: Decrement link count, deallocate inode if needed. */
 653
 654     bluesky_directory_remove(dir, argp->name);
 655
 656     result.status = NFS3_OK;
 657     result.wccstat3_u.wcc.after.present = TRUE;
 658     encode_fattr3(&result.wccstat3_u.wcc.after.post_op_attr_u.attributes,
 659                   dir);
 660
 661     async_rpc_send_reply(req, &result);
 662 }
 663
 664 void nfsproc3_rename_3_svc(rename3args *argp, RPCRequest *req)
 665 {
 666     static rename3res result;
 667     wcc_data *wcc1 = &result.rename3res_u.res.fromdir_wcc;
 668     wcc_data *wcc2 = &result.rename3res_u.res.todir_wcc;
 669     memset(wcc1, 0, sizeof(*wcc1));
 670     memset(wcc2, 0, sizeof(*wcc2));
 671
 672     BlueSkyInode *dir1 = lookup_fh(&argp->from.dir);
 673     if (dir1 == NULL) {
 674         result.status = NFS3ERR_STALE;
 675         async_rpc_send_reply(req, &result);
 676         return;
 677     }
 678     encode_pre_wcc(wcc1, dir1);
 679
 680     BlueSkyInode *dir2 = lookup_fh(&argp->to.dir);
 681     if (dir2 == NULL) {
 682         result.status = NFS3ERR_STALE;
 683         async_rpc_send_reply(req, &result);
 684         return;
 685     }
 686     encode_pre_wcc(wcc2, dir1);
 687
 688     gboolean status = bluesky_rename(dir1, argp->from.name,
 689                                      dir2, argp->to.name,
 690                                      TRUE, TRUE);
 691
 692     wcc1->after.present = TRUE;
 693     encode_fattr3(&wcc1->after.post_op_attr_u.attributes, dir1);
 694     wcc2->after.present = TRUE;
 695     encode_fattr3(&wcc2->after.post_op_attr_u.attributes, dir2);
 696     if (status)
 697         result.status = NFS3_OK;
 698     else
 699         result.status = NFS3ERR_PERM;
 700
 701     async_rpc_send_reply(req, &result);
 702 }
 703
 704 void nfsproc3_link_3_svc(link3args *argp, RPCRequest *req)
 705 {
 706     static link3res result;
 707     struct wcc_data wcc;
 708     memset(&wcc, 0, sizeof(wcc));
 709
 710     BlueSkyInode *inode = lookup_fh(&argp->file);
 711     if (inode == NULL) {
 712         result.status = NFS3ERR_STALE;
 713         result.link3res_u.res.linkdir_wcc = wcc;
 714         async_rpc_send_reply(req, &result);
 715         return;
 716     }
 717
 718     BlueSkyInode *dir = lookup_fh(&argp->link.dir);
 719     if (dir == NULL) {
 720         result.status = NFS3ERR_STALE;
 721         result.link3res_u.res.linkdir_wcc = wcc;
 722         async_rpc_send_reply(req, &result);
 723         return;
 724     }
 725
 726     encode_pre_wcc(&wcc, dir);
 727     if (dir->type != BLUESKY_DIRECTORY) {
 728         result.status = NFS3ERR_NOTDIR;
 729         result.link3res_u.res.linkdir_wcc = wcc;
 730         async_rpc_send_reply(req, &result);
 731         return;
 732     }
 733
 734     if (!validate_filename(argp->link.name)
 735         || strcmp(argp->link.name, ".") == 0
 736         || strcmp(argp->link.name, "..") == 0
 737         || bluesky_directory_lookup(dir, argp->link.name) != 0)
 738     {
 739         result.status = NFS3ERR_EXIST;
 740         result.link3res_u.res.linkdir_wcc = wcc;
 741         async_rpc_send_reply(req, &result);
 742         return;
 743     }
 744
 745     if (!bluesky_directory_insert(dir, argp->link.name, inode->inum)) {
 746         result.status = NFS3ERR_EXIST;
 747         result.link3res_u.res.linkdir_wcc = wcc;
 748         async_rpc_send_reply(req, &result);
 749         return;
 750     }
 751     inode->nlink++;
 752     bluesky_inode_update_ctime(inode, 0);
 753
 754     result.status = NFS3_OK;
 755     wcc.after.present = TRUE;
 756     encode_fattr3(&wcc.after.post_op_attr_u.attributes, dir);
 757     result.link3res_u.res.file_attributes.present = TRUE;
 758     encode_fattr3(&result.link3res_u.res.file_attributes.post_op_attr_u.attributes, inode);
 759     result.link3res_u.res.linkdir_wcc = wcc;
 760
 761     async_rpc_send_reply(req, &result);
 762 }
 763
 764 gint bluesky_dirent_compare(gconstpointer a, gconstpointer b,
 765                             gpointer unused);
 766
 767 #define MAX_READDIR_DIRENTS 64
 768 void nfsproc3_readdir_3_svc(readdir3args *argp, RPCRequest *req)
 769 {
 770     static readdir3res result;
 771
 772     BlueSkyInode *dir = lookup_fh(&argp->dir);
 773     if (dir == NULL) {
 774         result.status = NFS3ERR_STALE;
 775         result.readdir3res_u.resfail.present = FALSE;
 776         async_rpc_send_reply(req, &result);
 777         return;
 778     }
 779
 780     result.status = NFS3_OK;
 781     result.readdir3res_u.resok.dir_attributes.present = TRUE;
 782     encode_fattr3(&result.readdir3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
 783     memset(result.readdir3res_u.resok.cookieverf, 0,
 784            sizeof(result.readdir3res_u.resok.cookieverf));
 785
 786     static entry3 dirents[MAX_READDIR_DIRENTS];
 787     int count = 0;
 788
 789     BlueSkyDirent start = {NULL, NULL, argp->cookie, 0};
 790     GSequenceIter *i = g_sequence_search(dir->dirents, &start,
 791                                          bluesky_dirent_compare, NULL);
 792
 793     while (count < MAX_READDIR_DIRENTS && !g_sequence_iter_is_end(i)) {
 794         BlueSkyDirent *d = g_sequence_get(i);
 795         dirents[count].fileid = d->inum;
 796         dirents[count].name = d->name;
 797         dirents[count].cookie = d->cookie;
 798         dirents[count].nextentry = NULL;
 799         if (count > 0)
 800             dirents[count - 1].nextentry = &dirents[count];
 801         i = g_sequence_iter_next(i);
 802         count++;
 803     }
 804
 805     if (count > 0)
 806         result.readdir3res_u.resok.reply.entries = &dirents[0];
 807     else
 808         result.readdir3res_u.resok.reply.entries = NULL;
 809     result.readdir3res_u.resok.reply.eof = g_sequence_iter_is_end(i);
 810
 811     async_rpc_send_reply(req, &result);
 812 }
 813
 814 void nfsproc3_readdirplus_3_svc(readdirplus3args *argp, RPCRequest *req)
 815 {
 816     /* XDR-encoded sizes:
 817      *   post_op_attr: 88 bytes
 818      *   base readdirplus3resok: 88 + 16 bytes
 819      *   base directory entry: 24 bytes + filename
 820      *   attributes/fh3: 88 + 8 + filehandle size
 821      */
 822     size_t dircount = 88 + 16, attrcount = 0;
 823     static readdirplus3res result;
 824
 825     BlueSkyInode *dir = lookup_fh(&argp->dir);
 826     if (dir == NULL) {
 827         result.status = NFS3ERR_STALE;
 828         result.readdirplus3res_u.resfail.present = FALSE;
 829         async_rpc_send_reply(req, &result);
 830         return;
 831     }
 832
 833     result.status = NFS3_OK;
 834     result.readdirplus3res_u.resok.dir_attributes.present = TRUE;
 835     encode_fattr3(&result.readdirplus3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
 836     memset(result.readdirplus3res_u.resok.cookieverf, 0,
 837            sizeof(result.readdirplus3res_u.resok.cookieverf));
 838
 839     static entryplus3 dirents[MAX_READDIR_DIRENTS];
 840     static uint64_t fh_bytes[MAX_READDIR_DIRENTS];
 841     int count = 0;
 842
 843     /* TODO: Handle dircount, maxcount arguments from client. */
 844
 845     BlueSkyDirent start = {NULL, NULL, argp->cookie, 0};
 846     GSequenceIter *i = g_sequence_search(dir->dirents, &start,
 847                                          bluesky_dirent_compare, NULL);
 848
 849     while (count < MAX_READDIR_DIRENTS && !g_sequence_iter_is_end(i)) {
 850         BlueSkyDirent *d = g_sequence_get(i);
 851         BlueSkyInode *inode = bluesky_get_inode(fs, d->inum);
 852         if (inode != NULL) {
 853             dircount += 24 + ((strlen(d->name) + 3) & ~3);
 854             attrcount += 88 + 8 + 8;
 855             if (dircount > argp->dircount
 856                 || dircount + attrcount > argp->maxcount)
 857                 break;
 858             dirents[count].fileid = d->inum;
 859             dirents[count].name = d->name;
 860             dirents[count].cookie = d->cookie;
 861             dirents[count].nextentry = NULL;
 862             dirents[count].name_attributes.present = TRUE;
 863             encode_fattr3(&dirents[count].name_attributes.post_op_attr_u.attributes, inode);
 864             fh_bytes[count] = GUINT64_TO_BE(d->inum);
 865             dirents[count].name_handle.present = TRUE;
 866             dirents[count].name_handle.post_op_fh3_u.handle.data.data_len = 8;
 867             dirents[count].name_handle.post_op_fh3_u.handle.data.data_val
 868                 = (char *)&fh_bytes[count];
 869             if (count > 0)
 870                 dirents[count - 1].nextentry = &dirents[count];
 871             count++;
 872         }
 873         i = g_sequence_iter_next(i);
 874     }
 875
 876     if (count > 0)
 877         result.readdirplus3res_u.resok.reply.entries = &dirents[0];
 878     else
 879         result.readdirplus3res_u.resok.reply.entries = NULL;
 880     result.readdirplus3res_u.resok.reply.eof = g_sequence_iter_is_end(i);
 881
 882     async_rpc_send_reply(req, &result);
 883 }
 884
 885 void nfsproc3_fsstat_3_svc(nfs_fh3 *argp, RPCRequest *req)
 886 {
 887     static fsstat3res result;
 888
 889     BlueSkyInode *inode = lookup_fh(argp);
 890     if (inode == NULL) {
 891         result.status = NFS3ERR_STALE;
 892         result.fsstat3res_u.resfail.present = FALSE;
 893         async_rpc_send_reply(req, &result);
 894         return;
 895     }
 896
 897     result.status = NFS3_OK;
 898     result.fsstat3res_u.resok.obj_attributes.present = TRUE;
 899     encode_fattr3(&result.fsstat3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 900
 901     result.fsstat3res_u.resok.tbytes = (1 << 30);
 902     result.fsstat3res_u.resok.fbytes = (1 << 30);
 903     result.fsstat3res_u.resok.abytes = (1 << 30);
 904     result.fsstat3res_u.resok.tfiles = 0;
 905     result.fsstat3res_u.resok.ffiles = 0;
 906     result.fsstat3res_u.resok.afiles = 0;
 907     result.fsstat3res_u.resok.invarsec = 0;
 908
 909     async_rpc_send_reply(req, &result);
 910 }
 911
 912 void nfsproc3_fsinfo_3_svc(nfs_fh3 *argp, RPCRequest *req)
 913 {
 914     static fsinfo3res result;
 915
 916     BlueSkyInode *inode = bluesky_get_inode(fs, 1);
 917     result.status = NFS3_OK;
 918     result.fsinfo3res_u.resok.obj_attributes.present = TRUE;
 919     encode_fattr3(&result.fsinfo3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 920     result.fsinfo3res_u.resok.rtmax = 32768;
 921     result.fsinfo3res_u.resok.rtpref = 32768;
 922     result.fsinfo3res_u.resok.rtmult = 4096;
 923     result.fsinfo3res_u.resok.wtmax = 32768;
 924     result.fsinfo3res_u.resok.wtpref = 32768;
 925     result.fsinfo3res_u.resok.wtmult = 4096;
 926     result.fsinfo3res_u.resok.dtpref = 4096;
 927     result.fsinfo3res_u.resok.maxfilesize = 0x7fffffffffffffffULL;
 928     result.fsinfo3res_u.resok.time_delta.seconds = 0;
 929     result.fsinfo3res_u.resok.time_delta.nseconds = 1000;
 930     result.fsinfo3res_u.resok.properties
 931         = FSF3_LINK | FSF3_SYMLINK | FSF3_HOMOGENEOUS | FSF3_CANSETTIME;
 932
 933     async_rpc_send_reply(req, &result);
 934 }
 935
 936 void nfsproc3_pathconf_3_svc(nfs_fh3 *argp, RPCRequest *req)
 937 {
 938     static pathconf3res result;
 939
 940     BlueSkyInode *inode = bluesky_get_inode(fs, 1);
 941     result.status = NFS3_OK;
 942     result.pathconf3res_u.resok.obj_attributes.present = TRUE;
 943     encode_fattr3(&result.pathconf3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 944     result.pathconf3res_u.resok.linkmax = 0xffffffff;
 945     result.pathconf3res_u.resok.name_max = 255;
 946     result.pathconf3res_u.resok.no_trunc = TRUE;
 947     result.pathconf3res_u.resok.chown_restricted = TRUE;
 948     result.pathconf3res_u.resok.case_insensitive = FALSE;
 949     result.pathconf3res_u.resok.case_preserving = TRUE;
 950
 951     async_rpc_send_reply(req, &result);
 952 }
 953
 954 void nfsproc3_commit_3_svc(commit3args *argp, RPCRequest *req)
 955 {
 956     static commit3res result;
 957
 958     result.status = NFS3ERR_NOTSUPP;
 959
 960     async_rpc_send_reply(req, &result);
 961 }