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.
12 /* Check that a string is a valid file name. We require that it be valid
13 * UTF-8, that it not be empty, and that it not contain embedded forward
14 * slashes. Also checks that the length of the string is not more than the
15 * maximum allowed length. This function does allow the names "." and "..".
16 * Returns TRUE if the string is allowed as a filename. */
17 gboolean validate_filename(const char *filename)
19 if (filename == NULL || filename[0] == '\0')
21 if (strlen(filename) > 255)
23 if (!g_utf8_validate(filename, -1, NULL))
25 if (strchr(filename, '/') != NULL)
30 /* Look up a BlueSkyInode given an NFS filehandle. Returns NULL if the
31 * filehandle is invalid. */
32 BlueSkyInode *lookup_fh(nfs_fh3 *fh)
34 BlueSkyInode *inode = NULL;
35 if (fh->data.data_len == 8) {
36 uint64_t inum = GUINT64_FROM_BE(*(uint64_t *)(fh->data.data_val));
37 inode = bluesky_get_inode(fs, inum);
42 int64_t decode_nfstime3(nfstime3 *time)
44 int64_t result = (int64_t)time->seconds * 1000000;
45 result += time->nseconds / 1000;
49 void set_attributes(BlueSkyInode *inode, sattr3 *attributes)
51 int64_t now = bluesky_get_current_time();
53 if (attributes->mode.set) {
54 inode->mode = attributes->mode.set_uint32_u.val;
57 if (attributes->uid.set) {
58 inode->uid = attributes->uid.set_uint32_u.val;
61 if (attributes->gid.set) {
62 inode->gid = attributes->gid.set_uint32_u.val;
65 if (attributes->size.set) {
66 if (inode->type == BLUESKY_REGULAR) {
67 bluesky_file_truncate(inode, attributes->size.set_uint64_u.val);
72 switch (attributes->atime.set) {
75 case SET_TO_SERVER_TIME:
78 case SET_TO_CLIENT_TIME:
79 inode->atime = decode_nfstime3(&attributes->atime.set_time_u.time);
83 switch (attributes->mtime.set) {
86 case SET_TO_SERVER_TIME:
89 case SET_TO_CLIENT_TIME:
90 inode->mtime = decode_nfstime3(&attributes->mtime.set_time_u.time);
95 inode->change_count++;
98 /* Copy inode attributes into NFS response. The BlueSkyInode should be locked
100 void encode_fattr3(struct fattr3 *result, BlueSkyInode *inode)
102 result->type = inode->type;
103 result->mode = inode->mode;
104 result->nlink = inode->nlink;
105 result->uid = inode->uid;
106 result->gid = inode->gid;
107 result->size = inode->size;
109 result->rdev.major = 0;
110 result->rdev.minor = 0;
112 result->fileid = inode->inum;
113 result->atime.seconds = inode->atime / 1000000;
114 result->atime.nseconds = (inode->atime % 1000000) * 1000;
115 result->mtime.seconds = inode->mtime / 1000000;
116 result->mtime.nseconds = (inode->mtime % 1000000) * 1000;
117 result->ctime.seconds = inode->ctime / 1000000;
118 result->ctime.nseconds = (inode->ctime % 1000000) * 1000;
120 switch (inode->type) {
121 case BLUESKY_SYMLINK:
122 result->size = strlen(inode->symlink_contents);
129 void encode_pre_wcc(struct wcc_data *wcc, BlueSkyInode *inode)
131 wcc->before.present = TRUE;
132 wcc->before.pre_op_attr_u.attributes.size = inode->size;
133 wcc->before.pre_op_attr_u.attributes.mtime.seconds = inode->mtime / 1000000;
134 wcc->before.pre_op_attr_u.attributes.mtime.nseconds = (inode->mtime % 1000000) * 1000;
135 wcc->before.pre_op_attr_u.attributes.ctime.seconds = inode->ctime / 1000000;
136 wcc->before.pre_op_attr_u.attributes.ctime.nseconds = (inode->ctime % 1000000) * 1000;
139 void nfsproc3_null_3_svc(void *argp, RPCRequest *req)
141 async_rpc_send_reply(req, NULL);
144 void nfsproc3_getattr_3_svc(nfs_fh3 *argp, RPCRequest *req)
147 memset(&result, 0, sizeof(result));
149 BlueSkyInode *inode = lookup_fh(argp);
151 result.status = NFS3_OK;
152 encode_fattr3(&result.getattr3res_u.attributes, inode);
154 result.status = NFS3ERR_STALE;
157 async_rpc_send_reply(req, &result);
160 void nfsproc3_setattr_3_svc(setattr3args *argp, RPCRequest *req)
163 memset(&result, 0, sizeof(result));
165 result.wccstat3_u.wcc.before.present = FALSE;
166 result.wccstat3_u.wcc.after.present = FALSE;
167 BlueSkyInode *inode = lookup_fh(&argp->object);
169 result.status = NFS3ERR_STALE;
170 async_rpc_send_reply(req, &result);
174 encode_pre_wcc(&result.wccstat3_u.wcc, inode);
175 if (argp->guard.check) {
176 if (inode->ctime != decode_nfstime3(&argp->guard.sattrguard3_u.ctime)) {
177 result.status = NFS3ERR_NOT_SYNC;
178 result.wccstat3_u.wcc.after.present = TRUE;
179 encode_fattr3(&result.wccstat3_u.wcc.after.post_op_attr_u.attributes, inode);
180 async_rpc_send_reply(req, &result);
185 set_attributes(inode, &argp->new_attributes);
187 result.wccstat3_u.wcc.after.present = TRUE;
188 encode_fattr3(&result.wccstat3_u.wcc.after.post_op_attr_u.attributes,
190 result.status = NFS3_OK;
192 async_rpc_send_reply(req, &result);
195 void nfsproc3_lookup_3_svc(diropargs3 *argp, RPCRequest *req)
198 memset(&result, 0, sizeof(result));
200 BlueSkyInode *dir = lookup_fh(&argp->dir);
202 result.status = NFS3ERR_STALE;
203 result.lookup3res_u.resfail.present = FALSE;
204 async_rpc_send_reply(req, &result);
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;
214 result.status = NFS3ERR_NOENT;
215 async_rpc_send_reply(req, &result);
219 /* TODO: Special-case "." and "..". */
220 uint64_t inum = bluesky_directory_lookup(dir, argp->name);
222 result.status = NFS3ERR_NOENT;
223 async_rpc_send_reply(req, &result);
226 BlueSkyInode *inode = bluesky_get_inode(fs, inum);
228 result.status = NFS3ERR_NOENT;
229 async_rpc_send_reply(req, &result);
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);
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;
244 async_rpc_send_reply(req, &result);
247 void nfsproc3_access_3_svc(access3args *argp, RPCRequest *req)
250 memset(&result, 0, sizeof(result));
252 BlueSkyInode *inode = lookup_fh(&argp->object);
254 result.status = NFS3ERR_STALE;
255 result.access3res_u.resfail.present = FALSE;
256 async_rpc_send_reply(req, &result);
260 result.status = NFS3_OK;
261 result.access3res_u.resok.obj_attributes.present = TRUE;
262 encode_fattr3(&result.access3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
263 result.access3res_u.resok.access = argp->access;
265 async_rpc_send_reply(req, &result);
268 void nfsproc3_readlink_3_svc(nfs_fh3 *argp, RPCRequest *req)
271 memset(&result, 0, sizeof(result));
273 BlueSkyInode *inode = lookup_fh(argp);
275 if (inode->type == BLUESKY_SYMLINK) {
276 result.status = NFS3_OK;
277 result.readlink3res_u.resok.symlink_attributes.present = TRUE;
278 encode_fattr3(&result.readlink3res_u.resok.symlink_attributes.post_op_attr_u.attributes, inode);
279 result.readlink3res_u.resok.data = inode->symlink_contents;
281 result.status = NFS3ERR_INVAL;
282 result.readlink3res_u.resfail.present = TRUE;
283 encode_fattr3(&result.readlink3res_u.resfail.post_op_attr_u.attributes, inode);
286 result.status = NFS3ERR_STALE;
289 async_rpc_send_reply(req, &result);
292 void nfsproc3_read_3_svc(read3args *argp, RPCRequest *req)
295 memset(&result, 0, sizeof(result));
298 BlueSkyInode *inode = lookup_fh(&argp->file);
300 result.status = NFS3ERR_STALE;
301 result.read3res_u.resfail.present = FALSE;
302 async_rpc_send_reply(req, &result);
306 int count = argp->count;
307 if (argp->offset >= inode->size) {
309 result.read3res_u.resok.eof = TRUE;
311 count = MIN(count, inode->size - argp->offset);
312 if (argp->offset + count == inode->size)
313 result.read3res_u.resok.eof = TRUE;
315 result.read3res_u.resok.eof = FALSE;
317 bluesky_file_read(inode, argp->offset, buf, count);
320 result.status = NFS3_OK;
321 result.read3res_u.resok.file_attributes.present = TRUE;
322 encode_fattr3(&result.read3res_u.resok.file_attributes.post_op_attr_u.attributes, inode);
323 result.read3res_u.resok.count = count;
324 result.read3res_u.resok.data.data_val = buf;
325 result.read3res_u.resok.data.data_len = count;
327 async_rpc_send_reply(req, &result);
330 void nfsproc3_write_3_svc(write3args *argp, RPCRequest *req)
333 memset(&result, 0, sizeof(result));
335 memset(&wcc, 0, sizeof(wcc));
337 BlueSkyInode *inode = lookup_fh(&argp->file);
339 result.status = NFS3ERR_STALE;
340 result.write3res_u.resfail = wcc;
341 async_rpc_send_reply(req, &result);
345 encode_pre_wcc(&wcc, inode);
346 if (inode->type != BLUESKY_REGULAR) {
347 result.status = NFS3ERR_INVAL;
348 result.write3res_u.resfail = wcc;
349 async_rpc_send_reply(req, &result);
353 uint64_t lastbyte = argp->offset + argp->count;
354 if (lastbyte > inode->size) {
355 bluesky_file_truncate(inode, lastbyte);
358 if (argp->data.data_len < argp->count) {
361 bluesky_file_write(inode, argp->offset,
362 argp->data.data_val, argp->count);
365 wcc.after.present = TRUE;
366 encode_fattr3(&wcc.after.post_op_attr_u.attributes, inode);
367 result.write3res_u.resok.file_wcc = wcc;
368 result.write3res_u.resok.count = argp->count;
369 result.write3res_u.resok.committed = FILE_SYNC;
371 async_rpc_send_reply(req, &result);
374 void nfsproc3_create_3_svc(create3args *argp, RPCRequest *req)
377 memset(&result, 0, sizeof(result));
379 memset(&wcc, 0, sizeof(wcc));
381 BlueSkyInode *dir = lookup_fh(&argp->where.dir);
383 result.status = NFS3ERR_STALE;
384 result.diropres3_u.resfail = wcc;
385 async_rpc_send_reply(req, &result);
389 encode_pre_wcc(&wcc, dir);
390 if (dir->type != BLUESKY_DIRECTORY) {
391 result.status = NFS3ERR_NOTDIR;
392 result.diropres3_u.resfail = wcc;
393 async_rpc_send_reply(req, &result);
397 if (!validate_filename(argp->where.name)
398 || strcmp(argp->where.name, ".") == 0
399 || strcmp(argp->where.name, "..") == 0)
401 result.status = NFS3ERR_EXIST;
402 result.diropres3_u.resfail = wcc;
403 async_rpc_send_reply(req, &result);
408 file = bluesky_new_inode(bluesky_fs_alloc_inode(fs), fs, BLUESKY_REGULAR);
411 int64_t time = bluesky_get_current_time();
412 printf("time: %"PRIi64"\n", time);
417 bluesky_insert_inode(fs, file);
418 bluesky_directory_insert(dir, argp->where.name, file->inum);
420 dir->mtime = dir->ctime = bluesky_get_current_time();
423 wcc.after.present = TRUE;
424 encode_fattr3(&wcc.after.post_op_attr_u.attributes, dir);
425 result.diropres3_u.resok.obj_attributes.present = TRUE;
426 encode_fattr3(&result.diropres3_u.resok.obj_attributes.post_op_attr_u.attributes, file);
427 result.diropres3_u.resok.dir_wcc = wcc;
430 fh_bytes = GUINT64_TO_BE(file->inum);
431 result.diropres3_u.resok.obj.present = TRUE;
432 result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_len = 8;
433 result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_val = (char *)&fh_bytes;
435 async_rpc_send_reply(req, &result);
438 void nfsproc3_mkdir_3_svc(mkdir3args *argp, RPCRequest *req)
441 memset(&result, 0, sizeof(result));
443 memset(&wcc, 0, sizeof(wcc));
445 BlueSkyInode *dir = lookup_fh(&argp->where.dir);
447 result.status = NFS3ERR_STALE;
448 result.diropres3_u.resfail = wcc;
449 async_rpc_send_reply(req, &result);
453 encode_pre_wcc(&wcc, dir);
454 if (dir->type != BLUESKY_DIRECTORY) {
455 result.status = NFS3ERR_NOTDIR;
456 result.diropres3_u.resfail = wcc;
457 async_rpc_send_reply(req, &result);
461 if (!validate_filename(argp->where.name)
462 || strcmp(argp->where.name, ".") == 0
463 || strcmp(argp->where.name, "..") == 0)
465 result.status = NFS3ERR_EXIST;
466 result.diropres3_u.resfail = wcc;
467 async_rpc_send_reply(req, &result);
472 file = bluesky_new_inode(bluesky_fs_alloc_inode(fs), fs, BLUESKY_DIRECTORY);
475 int64_t time = bluesky_get_current_time();
480 bluesky_insert_inode(fs, file);
481 bluesky_directory_insert(dir, argp->where.name, file->inum);
482 set_attributes(file, &argp->attributes);
484 dir->mtime = dir->ctime = bluesky_get_current_time();
487 wcc.after.present = TRUE;
488 encode_fattr3(&wcc.after.post_op_attr_u.attributes, dir);
489 result.diropres3_u.resok.obj_attributes.present = TRUE;
490 encode_fattr3(&result.diropres3_u.resok.obj_attributes.post_op_attr_u.attributes, file);
491 result.diropres3_u.resok.dir_wcc = wcc;
494 fh_bytes = GUINT64_TO_BE(file->inum);
495 result.diropres3_u.resok.obj.present = TRUE;
496 result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_len = 8;
497 result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_val = (char *)&fh_bytes;
499 async_rpc_send_reply(req, &result);
502 void nfsproc3_symlink_3_svc(symlink3args *argp, RPCRequest *req)
505 memset(&result, 0, sizeof(result));
507 memset(&wcc, 0, sizeof(wcc));
509 BlueSkyInode *dir = lookup_fh(&argp->where.dir);
511 result.status = NFS3ERR_STALE;
512 result.diropres3_u.resfail = wcc;
513 async_rpc_send_reply(req, &result);
517 encode_pre_wcc(&wcc, dir);
518 if (dir->type != BLUESKY_DIRECTORY) {
519 result.status = NFS3ERR_NOTDIR;
520 result.diropres3_u.resfail = wcc;
521 async_rpc_send_reply(req, &result);
525 if (!validate_filename(argp->where.name)
526 || strcmp(argp->where.name, ".") == 0
527 || strcmp(argp->where.name, "..") == 0)
529 result.status = NFS3ERR_EXIST;
530 result.diropres3_u.resfail = wcc;
531 async_rpc_send_reply(req, &result);
536 file = bluesky_new_inode(bluesky_fs_alloc_inode(fs), fs, BLUESKY_SYMLINK);
539 int64_t time = bluesky_get_current_time();
544 file->symlink_contents = g_strdup(argp->symlink.symlink_data);
545 bluesky_insert_inode(fs, file);
546 bluesky_directory_insert(dir, argp->where.name, file->inum);
548 dir->mtime = dir->ctime = bluesky_get_current_time();
551 wcc.after.present = TRUE;
552 encode_fattr3(&wcc.after.post_op_attr_u.attributes, dir);
553 result.diropres3_u.resok.obj_attributes.present = TRUE;
554 encode_fattr3(&result.diropres3_u.resok.obj_attributes.post_op_attr_u.attributes, file);
555 result.diropres3_u.resok.dir_wcc = wcc;
558 fh_bytes = GUINT64_TO_BE(file->inum);
559 result.diropres3_u.resok.obj.present = TRUE;
560 result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_len = 8;
561 result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_val = (char *)&fh_bytes;
563 async_rpc_send_reply(req, &result);
566 void nfsproc3_mknod_3_svc(mknod3args *argp, RPCRequest *req)
569 memset(&result, 0, sizeof(result));
571 result.status = NFS3ERR_NOTSUPP;
573 async_rpc_send_reply(req, &result);
576 void nfsproc3_remove_3_svc(diropargs3 *argp, RPCRequest *req)
579 memset(&result, 0, sizeof(result));
581 BlueSkyInode *dir = lookup_fh(&argp->dir);
583 result.status = NFS3ERR_STALE;
584 async_rpc_send_reply(req, &result);
588 encode_pre_wcc(&result.wccstat3_u.wcc, dir);
590 if (!validate_filename(argp->name)
591 || strcmp(argp->name, ".") == 0
592 || strcmp(argp->name, "..") == 0)
594 result.status = NFS3ERR_NOENT;
595 async_rpc_send_reply(req, &result);
599 /* TODO: Decrement link count, deallocate inode if needed. */
601 bluesky_directory_remove(dir, argp->name);
603 result.status = NFS3_OK;
604 result.wccstat3_u.wcc.after.present = TRUE;
605 encode_fattr3(&result.wccstat3_u.wcc.after.post_op_attr_u.attributes,
608 async_rpc_send_reply(req, &result);
611 void nfsproc3_rmdir_3_svc(diropargs3 *argp, RPCRequest *req)
614 memset(&result, 0, sizeof(result));
616 BlueSkyInode *dir = lookup_fh(&argp->dir);
618 result.status = NFS3ERR_STALE;
619 async_rpc_send_reply(req, &result);
623 encode_pre_wcc(&result.wccstat3_u.wcc, dir);
625 if (!validate_filename(argp->name)
626 || strcmp(argp->name, ".") == 0
627 || strcmp(argp->name, "..") == 0)
629 result.status = NFS3ERR_NOENT;
630 async_rpc_send_reply(req, &result);
634 uint64_t inum = bluesky_directory_lookup(dir, argp->name);
635 BlueSkyInode *inode = bluesky_get_inode(fs, inum);
637 result.status = NFS3ERR_NOENT;
638 async_rpc_send_reply(req, &result);
642 if (inode->type != BLUESKY_DIRECTORY) {
643 result.status = NFS3ERR_NOTDIR;
644 async_rpc_send_reply(req, &result);
647 if (g_sequence_get_length(inode->dirents) > 0) {
648 printf("Directory not empty: %d entries\n",
649 g_sequence_get_length(inode->dirents));
650 result.status = NFS3ERR_NOTEMPTY;
651 async_rpc_send_reply(req, &result);
655 /* TODO: Decrement link count, deallocate inode if needed. */
657 bluesky_directory_remove(dir, argp->name);
659 result.status = NFS3_OK;
660 result.wccstat3_u.wcc.after.present = TRUE;
661 encode_fattr3(&result.wccstat3_u.wcc.after.post_op_attr_u.attributes,
664 async_rpc_send_reply(req, &result);
667 void nfsproc3_rename_3_svc(rename3args *argp, RPCRequest *req)
670 memset(&result, 0, sizeof(result));
671 wcc_data *wcc1 = &result.rename3res_u.res.fromdir_wcc;
672 wcc_data *wcc2 = &result.rename3res_u.res.todir_wcc;
674 BlueSkyInode *dir1 = lookup_fh(&argp->from.dir);
676 result.status = NFS3ERR_STALE;
677 async_rpc_send_reply(req, &result);
680 encode_pre_wcc(wcc1, dir1);
682 BlueSkyInode *dir2 = lookup_fh(&argp->to.dir);
684 result.status = NFS3ERR_STALE;
685 async_rpc_send_reply(req, &result);
688 encode_pre_wcc(wcc2, dir1);
690 gboolean status = bluesky_rename(dir1, argp->from.name,
694 wcc1->after.present = TRUE;
695 encode_fattr3(&wcc1->after.post_op_attr_u.attributes, dir1);
696 wcc2->after.present = TRUE;
697 encode_fattr3(&wcc2->after.post_op_attr_u.attributes, dir2);
699 result.status = NFS3_OK;
701 result.status = NFS3ERR_PERM;
703 async_rpc_send_reply(req, &result);
706 void nfsproc3_link_3_svc(link3args *argp, RPCRequest *req)
709 memset(&result, 0, sizeof(result));
711 memset(&wcc, 0, sizeof(wcc));
713 BlueSkyInode *inode = lookup_fh(&argp->file);
715 result.status = NFS3ERR_STALE;
716 result.link3res_u.res.linkdir_wcc = wcc;
717 async_rpc_send_reply(req, &result);
721 BlueSkyInode *dir = lookup_fh(&argp->link.dir);
723 result.status = NFS3ERR_STALE;
724 result.link3res_u.res.linkdir_wcc = wcc;
725 async_rpc_send_reply(req, &result);
729 encode_pre_wcc(&wcc, dir);
730 if (dir->type != BLUESKY_DIRECTORY) {
731 result.status = NFS3ERR_NOTDIR;
732 result.link3res_u.res.linkdir_wcc = wcc;
733 async_rpc_send_reply(req, &result);
737 if (!validate_filename(argp->link.name)
738 || strcmp(argp->link.name, ".") == 0
739 || strcmp(argp->link.name, "..") == 0
740 || bluesky_directory_lookup(dir, argp->link.name) != 0)
742 result.status = NFS3ERR_EXIST;
743 result.link3res_u.res.linkdir_wcc = wcc;
744 async_rpc_send_reply(req, &result);
748 if (!bluesky_directory_insert(dir, argp->link.name, inode->inum)) {
749 result.status = NFS3ERR_EXIST;
750 result.link3res_u.res.linkdir_wcc = wcc;
751 async_rpc_send_reply(req, &result);
755 bluesky_inode_update_ctime(inode, 0);
757 result.status = NFS3_OK;
758 wcc.after.present = TRUE;
759 encode_fattr3(&wcc.after.post_op_attr_u.attributes, dir);
760 result.link3res_u.res.file_attributes.present = TRUE;
761 encode_fattr3(&result.link3res_u.res.file_attributes.post_op_attr_u.attributes, inode);
762 result.link3res_u.res.linkdir_wcc = wcc;
764 async_rpc_send_reply(req, &result);
767 gint bluesky_dirent_compare(gconstpointer a, gconstpointer b,
770 #define MAX_READDIR_DIRENTS 64
771 void nfsproc3_readdir_3_svc(readdir3args *argp, RPCRequest *req)
774 memset(&result, 0, sizeof(result));
776 BlueSkyInode *dir = lookup_fh(&argp->dir);
778 result.status = NFS3ERR_STALE;
779 result.readdir3res_u.resfail.present = FALSE;
780 async_rpc_send_reply(req, &result);
784 result.status = NFS3_OK;
785 result.readdir3res_u.resok.dir_attributes.present = TRUE;
786 encode_fattr3(&result.readdir3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
787 memset(result.readdir3res_u.resok.cookieverf, 0,
788 sizeof(result.readdir3res_u.resok.cookieverf));
790 entry3 dirents[MAX_READDIR_DIRENTS];
793 BlueSkyDirent start = {NULL, NULL, argp->cookie, 0};
794 GSequenceIter *i = g_sequence_search(dir->dirents, &start,
795 bluesky_dirent_compare, NULL);
797 while (count < MAX_READDIR_DIRENTS && !g_sequence_iter_is_end(i)) {
798 BlueSkyDirent *d = g_sequence_get(i);
799 dirents[count].fileid = d->inum;
800 dirents[count].name = d->name;
801 dirents[count].cookie = d->cookie;
802 dirents[count].nextentry = NULL;
804 dirents[count - 1].nextentry = &dirents[count];
805 i = g_sequence_iter_next(i);
810 result.readdir3res_u.resok.reply.entries = &dirents[0];
812 result.readdir3res_u.resok.reply.entries = NULL;
813 result.readdir3res_u.resok.reply.eof = g_sequence_iter_is_end(i);
815 async_rpc_send_reply(req, &result);
818 void nfsproc3_readdirplus_3_svc(readdirplus3args *argp, RPCRequest *req)
820 /* XDR-encoded sizes:
821 * post_op_attr: 88 bytes
822 * base readdirplus3resok: 88 + 16 bytes
823 * base directory entry: 24 bytes + filename
824 * attributes/fh3: 88 + 8 + filehandle size
826 size_t dircount = 88 + 16, attrcount = 0;
827 readdirplus3res result;
828 memset(&result, 0, sizeof(result));
830 BlueSkyInode *dir = lookup_fh(&argp->dir);
832 result.status = NFS3ERR_STALE;
833 result.readdirplus3res_u.resfail.present = FALSE;
834 async_rpc_send_reply(req, &result);
838 result.status = NFS3_OK;
839 result.readdirplus3res_u.resok.dir_attributes.present = TRUE;
840 encode_fattr3(&result.readdirplus3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
841 memset(result.readdirplus3res_u.resok.cookieverf, 0,
842 sizeof(result.readdirplus3res_u.resok.cookieverf));
844 entryplus3 dirents[MAX_READDIR_DIRENTS];
845 uint64_t fh_bytes[MAX_READDIR_DIRENTS];
848 /* TODO: Handle dircount, maxcount arguments from client. */
850 BlueSkyDirent start = {NULL, NULL, argp->cookie, 0};
851 GSequenceIter *i = g_sequence_search(dir->dirents, &start,
852 bluesky_dirent_compare, NULL);
854 while (count < MAX_READDIR_DIRENTS && !g_sequence_iter_is_end(i)) {
855 BlueSkyDirent *d = g_sequence_get(i);
856 BlueSkyInode *inode = bluesky_get_inode(fs, d->inum);
858 dircount += 24 + ((strlen(d->name) + 3) & ~3);
859 attrcount += 88 + 8 + 8;
860 if (dircount > argp->dircount
861 || dircount + attrcount > argp->maxcount)
863 dirents[count].fileid = d->inum;
864 dirents[count].name = d->name;
865 dirents[count].cookie = d->cookie;
866 dirents[count].nextentry = NULL;
867 dirents[count].name_attributes.present = TRUE;
868 encode_fattr3(&dirents[count].name_attributes.post_op_attr_u.attributes, inode);
869 fh_bytes[count] = GUINT64_TO_BE(d->inum);
870 dirents[count].name_handle.present = TRUE;
871 dirents[count].name_handle.post_op_fh3_u.handle.data.data_len = 8;
872 dirents[count].name_handle.post_op_fh3_u.handle.data.data_val
873 = (char *)&fh_bytes[count];
875 dirents[count - 1].nextentry = &dirents[count];
878 i = g_sequence_iter_next(i);
882 result.readdirplus3res_u.resok.reply.entries = &dirents[0];
884 result.readdirplus3res_u.resok.reply.entries = NULL;
885 result.readdirplus3res_u.resok.reply.eof = g_sequence_iter_is_end(i);
887 async_rpc_send_reply(req, &result);
890 void nfsproc3_fsstat_3_svc(nfs_fh3 *argp, RPCRequest *req)
893 memset(&result, 0, sizeof(result));
895 BlueSkyInode *inode = lookup_fh(argp);
897 result.status = NFS3ERR_STALE;
898 result.fsstat3res_u.resfail.present = FALSE;
899 async_rpc_send_reply(req, &result);
903 result.status = NFS3_OK;
904 result.fsstat3res_u.resok.obj_attributes.present = TRUE;
905 encode_fattr3(&result.fsstat3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
907 result.fsstat3res_u.resok.tbytes = (1 << 30);
908 result.fsstat3res_u.resok.fbytes = (1 << 30);
909 result.fsstat3res_u.resok.abytes = (1 << 30);
910 result.fsstat3res_u.resok.tfiles = 0;
911 result.fsstat3res_u.resok.ffiles = 0;
912 result.fsstat3res_u.resok.afiles = 0;
913 result.fsstat3res_u.resok.invarsec = 0;
915 async_rpc_send_reply(req, &result);
918 void nfsproc3_fsinfo_3_svc(nfs_fh3 *argp, RPCRequest *req)
921 memset(&result, 0, sizeof(result));
923 BlueSkyInode *inode = bluesky_get_inode(fs, 1);
924 result.status = NFS3_OK;
925 result.fsinfo3res_u.resok.obj_attributes.present = TRUE;
926 encode_fattr3(&result.fsinfo3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
927 result.fsinfo3res_u.resok.rtmax = 32768;
928 result.fsinfo3res_u.resok.rtpref = 32768;
929 result.fsinfo3res_u.resok.rtmult = 4096;
930 result.fsinfo3res_u.resok.wtmax = 32768;
931 result.fsinfo3res_u.resok.wtpref = 32768;
932 result.fsinfo3res_u.resok.wtmult = 4096;
933 result.fsinfo3res_u.resok.dtpref = 4096;
934 result.fsinfo3res_u.resok.maxfilesize = 0x7fffffffffffffffULL;
935 result.fsinfo3res_u.resok.time_delta.seconds = 0;
936 result.fsinfo3res_u.resok.time_delta.nseconds = 1000;
937 result.fsinfo3res_u.resok.properties
938 = FSF3_LINK | FSF3_SYMLINK | FSF3_HOMOGENEOUS | FSF3_CANSETTIME;
940 async_rpc_send_reply(req, &result);
943 void nfsproc3_pathconf_3_svc(nfs_fh3 *argp, RPCRequest *req)
946 memset(&result, 0, sizeof(result));
948 BlueSkyInode *inode = bluesky_get_inode(fs, 1);
949 result.status = NFS3_OK;
950 result.pathconf3res_u.resok.obj_attributes.present = TRUE;
951 encode_fattr3(&result.pathconf3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
952 result.pathconf3res_u.resok.linkmax = 0xffffffff;
953 result.pathconf3res_u.resok.name_max = 255;
954 result.pathconf3res_u.resok.no_trunc = TRUE;
955 result.pathconf3res_u.resok.chown_restricted = TRUE;
956 result.pathconf3res_u.resok.case_insensitive = FALSE;
957 result.pathconf3res_u.resok.case_preserving = TRUE;
959 async_rpc_send_reply(req, &result);
962 void nfsproc3_commit_3_svc(commit3args *argp, RPCRequest *req)
965 memset(&result, 0, sizeof(result));
967 result.status = NFS3ERR_NOTSUPP;
969 async_rpc_send_reply(req, &result);