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.status = NFS3_OK;
 144     result.lookup3res_u.resok.dir_attributes.present = TRUE;
 145     encode_fattr3(&result.lookup3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
 146     result.lookup3res_u.resok.obj_attributes.present = TRUE;
 147     encode_fattr3(&result.lookup3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 148
 149     static uint64_t fh_bytes;
 150     fh_bytes = GUINT64_TO_BE(inum);
 151     result.lookup3res_u.resok.object.data.data_len = 8;
 152     result.lookup3res_u.resok.object.data.data_val = (char *)&fh_bytes;
 153
 154     return &result;
 155 }
 156
 157 access3res *
 158 nfsproc3_access_3_svc(access3args *argp, struct svc_req *rqstp)
 159 {
 160     static access3res result;
 161
 162     BlueSkyInode *inode = lookup_fh(&argp->object);
 163     if (inode == NULL) {
 164         result.status = NFS3ERR_STALE;
 165         result.access3res_u.resfail.present = FALSE;
 166         return &result;
 167     }
 168
 169     result.status = NFS3_OK;
 170     result.access3res_u.resok.obj_attributes.present = TRUE;
 171     encode_fattr3(&result.access3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 172     result.access3res_u.resok.access = argp->access;
 173
 174     return &result;
 175 }
 176
 177 readlink3res *
 178 nfsproc3_readlink_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 179 {
 180     static readlink3res result;
 181
 182     result.status = NFS3ERR_NOTSUPP;
 183
 184     return &result;
 185 }
 186
 187 read3res *
 188 nfsproc3_read_3_svc(read3args *argp, struct svc_req *rqstp)
 189 {
 190     static read3res result;
 191     static char buf[32768];
 192
 193     BlueSkyInode *inode = lookup_fh(&argp->file);
 194     if (inode == NULL) {
 195         result.status = NFS3ERR_STALE;
 196         result.read3res_u.resfail.present = FALSE;
 197         return &result;
 198     }
 199
 200     int count = argp->count;
 201     if (argp->offset >= inode->size) {
 202         count = 0;
 203         result.read3res_u.resok.eof = TRUE;
 204     } else {
 205         count = MIN(count, inode->size - argp->offset);
 206         if (argp->offset + count == inode->size)
 207             result.read3res_u.resok.eof = TRUE;
 208         else
 209             result.read3res_u.resok.eof = FALSE;
 210
 211         bluesky_file_read(inode, argp->offset, buf, count);
 212     }
 213
 214     result.status = NFS3_OK;
 215     result.read3res_u.resok.file_attributes.present = TRUE;
 216     encode_fattr3(&result.read3res_u.resok.file_attributes.post_op_attr_u.attributes, inode);
 217     result.read3res_u.resok.count = count;
 218     result.read3res_u.resok.data.data_val = buf;
 219     result.read3res_u.resok.data.data_len = count;
 220
 221     return &result;
 222 }
 223
 224 write3res *
 225 nfsproc3_write_3_svc(write3args *argp, struct svc_req *rqstp)
 226 {
 227     static write3res result;
 228     struct wcc_data wcc;
 229     memset(&wcc, 0, sizeof(wcc));
 230
 231     BlueSkyInode *inode = lookup_fh(&argp->file);
 232     if (inode == NULL) {
 233         result.status = NFS3ERR_STALE;
 234         result.write3res_u.resfail = wcc;
 235         return &result;
 236     }
 237
 238     encode_pre_wcc(&wcc, inode);
 239     if (inode->type != BLUESKY_REGULAR) {
 240         result.status = NFS3ERR_INVAL;
 241         result.write3res_u.resfail = wcc;
 242         return &result;
 243     }
 244
 245     uint64_t lastbyte = argp->offset + argp->count;
 246     if (lastbyte > inode->size) {
 247         bluesky_file_truncate(inode, lastbyte);
 248     }
 249
 250     if (argp->data.data_len < argp->count) {
 251         /* ??? */
 252     } else {
 253         bluesky_file_write(inode, argp->offset,
 254                            argp->data.data_val, argp->count);
 255     }
 256
 257     encode_fattr3(&wcc.after.post_op_attr_u.attributes, inode);
 258     result.write3res_u.resok.file_wcc = wcc;
 259     result.write3res_u.resok.count = argp->count;
 260     result.write3res_u.resok.committed = FILE_SYNC;
 261
 262     return &result;
 263 }
 264
 265 diropres3 *
 266 nfsproc3_create_3_svc(create3args *argp, struct svc_req *rqstp)
 267 {
 268     static diropres3 result;
 269     struct wcc_data wcc;
 270     memset(&wcc, 0, sizeof(wcc));
 271
 272     BlueSkyInode *dir = lookup_fh(&argp->where.dir);
 273     if (dir == NULL) {
 274         result.status = NFS3ERR_STALE;
 275         result.diropres3_u.resfail = wcc;
 276         return &result;
 277     }
 278
 279     encode_pre_wcc(&wcc, dir);
 280     if (dir->type != BLUESKY_DIRECTORY) {
 281         result.status = NFS3ERR_NOTDIR;
 282         result.diropres3_u.resfail = wcc;
 283         return &result;
 284     }
 285
 286     if (!validate_filename(argp->where.name)
 287         || strcmp(argp->where.name, ".") == 0
 288         || strcmp(argp->where.name, "..") == 0)
 289     {
 290         result.status = NFS3ERR_EXIST;
 291         result.diropres3_u.resfail = wcc;
 292         return &result;
 293     }
 294
 295     BlueSkyInode *file;
 296     file = bluesky_new_inode(bluesky_fs_alloc_inode(fs), BLUESKY_REGULAR);
 297     file->nlink = 1;
 298     file->mode = 0755;
 299     int64_t time = bluesky_get_current_time();
 300     printf("time: %lld\n", time);
 301     file->mtime = time;
 302     file->ctime = time;
 303     file->atime = time;
 304     bluesky_insert_inode(fs, file);
 305     bluesky_directory_insert(dir, argp->where.name, file->inum);
 306
 307     wcc.after.present = TRUE;
 308     encode_fattr3(&wcc.after.post_op_attr_u.attributes, dir);
 309     result.diropres3_u.resok.obj_attributes.present = TRUE;
 310     encode_fattr3(&result.diropres3_u.resok.obj_attributes.post_op_attr_u.attributes, file);
 311     result.diropres3_u.resok.dir_wcc = wcc;
 312
 313     static uint64_t fh_bytes;
 314     fh_bytes = GUINT64_TO_BE(file->inum);
 315     result.diropres3_u.resok.obj.present = TRUE;
 316     result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_len = 8;
 317     result.diropres3_u.resok.obj.post_op_fh3_u.handle.data.data_val = (char *)&fh_bytes;
 318
 319     return &result;
 320 }
 321
 322 diropres3 *
 323 nfsproc3_mkdir_3_svc(mkdir3args *argp, struct svc_req *rqstp)
 324 {
 325     static diropres3 result;
 326
 327     result.status = NFS3ERR_NOTSUPP;
 328
 329     return &result;
 330 }
 331
 332 diropres3 *
 333 nfsproc3_symlink_3_svc(symlink3args *argp, struct svc_req *rqstp)
 334 {
 335     static diropres3 result;
 336
 337     result.status = NFS3ERR_NOTSUPP;
 338
 339     return &result;
 340 }
 341
 342 diropres3 *
 343 nfsproc3_mknod_3_svc(mknod3args *argp, struct svc_req *rqstp)
 344 {
 345     static diropres3 result;
 346
 347     result.status = NFS3ERR_NOTSUPP;
 348
 349     return &result;
 350 }
 351
 352 wccstat3 *
 353 nfsproc3_remove_3_svc(diropargs3 *argp, struct svc_req *rqstp)
 354 {
 355     static wccstat3 result;
 356
 357     result.status = NFS3ERR_NOTSUPP;
 358
 359     return &result;
 360 }
 361
 362 wccstat3 *
 363 nfsproc3_rmdir_3_svc(diropargs3 *argp, struct svc_req *rqstp)
 364 {
 365     static wccstat3 result;
 366
 367     result.status = NFS3ERR_NOTSUPP;
 368
 369     return &result;
 370 }
 371
 372 rename3res *
 373 nfsproc3_rename_3_svc(rename3args *argp, struct svc_req *rqstp)
 374 {
 375     static rename3res result;
 376
 377     result.status = NFS3ERR_NOTSUPP;
 378
 379     return &result;
 380 }
 381
 382 link3res *
 383 nfsproc3_link_3_svc(link3args *argp, struct svc_req *rqstp)
 384 {
 385     static link3res result;
 386
 387     result.status = NFS3ERR_NOTSUPP;
 388
 389     return &result;
 390 }
 391
 392 gint bluesky_dirent_compare(gconstpointer a, gconstpointer b,
 393                             gpointer unused);
 394
 395 readdir3res *
 396 nfsproc3_readdir_3_svc(readdir3args *argp, struct svc_req *rqstp)
 397 {
 398     static readdir3res result;
 399
 400     BlueSkyInode *dir = lookup_fh(&argp->dir);
 401     if (dir == NULL) {
 402         result.status = NFS3ERR_STALE;
 403         result.readdir3res_u.resfail.present = FALSE;
 404         return &result;
 405     }
 406
 407     result.status = NFS3_OK;
 408     result.readdir3res_u.resok.dir_attributes.present = TRUE;
 409     encode_fattr3(&result.readdir3res_u.resok.dir_attributes.post_op_attr_u.attributes, dir);
 410     memset(result.readdir3res_u.resok.cookieverf, 0,
 411            sizeof(result.readdir3res_u.resok.cookieverf));
 412
 413 #define MAX_READDIR_DIRENTS 4
 414     static entry3 dirents[MAX_READDIR_DIRENTS];
 415     int count = 0;
 416
 417     BlueSkyDirent start = {NULL, argp->cookie, 0};
 418     GSequenceIter *i = g_sequence_search(dir->dirents, &start,
 419                                          bluesky_dirent_compare, NULL);
 420
 421     while (count < MAX_READDIR_DIRENTS && !g_sequence_iter_is_end(i)) {
 422         BlueSkyDirent *d = g_sequence_get(i);
 423         dirents[count].fileid = d->inum;
 424         dirents[count].name = d->name;
 425         dirents[count].cookie = d->cookie;
 426         dirents[count].nextentry = NULL;
 427         if (count > 0)
 428             dirents[count - 1].nextentry = &dirents[count];
 429         i = g_sequence_iter_next(i);
 430         count++;
 431     }
 432
 433     if (count > 0)
 434         result.readdir3res_u.resok.reply.entries = &dirents[0];
 435     else
 436         result.readdir3res_u.resok.reply.entries = NULL;
 437     result.readdir3res_u.resok.reply.eof = g_sequence_iter_is_end(i);
 438
 439     return &result;
 440 }
 441
 442 readdirplus3res *
 443 nfsproc3_readdirplus_3_svc(readdirplus3args *argp, struct svc_req *rqstp)
 444 {
 445     static readdirplus3res result;
 446
 447     result.status = NFS3ERR_NOTSUPP;
 448
 449     return &result;
 450 }
 451
 452 fsstat3res *
 453 nfsproc3_fsstat_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 454 {
 455     static fsstat3res result;
 456
 457     result.status = NFS3ERR_NOTSUPP;
 458
 459     return &result;
 460 }
 461
 462 fsinfo3res *
 463 nfsproc3_fsinfo_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 464 {
 465     static fsinfo3res result;
 466
 467     BlueSkyInode *inode = bluesky_get_inode(fs, 1);
 468     result.status = NFS3_OK;
 469     result.fsinfo3res_u.resok.obj_attributes.present = TRUE;
 470     encode_fattr3(&result.fsinfo3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 471     result.fsinfo3res_u.resok.rtmax = 32768;
 472     result.fsinfo3res_u.resok.rtpref = 32768;
 473     result.fsinfo3res_u.resok.rtmult = 4096;
 474     result.fsinfo3res_u.resok.wtmax = 32768;
 475     result.fsinfo3res_u.resok.wtpref = 32768;
 476     result.fsinfo3res_u.resok.wtmult = 4096;
 477     result.fsinfo3res_u.resok.dtpref = 4096;
 478     result.fsinfo3res_u.resok.maxfilesize = 0x7fffffffffffffffULL;
 479     result.fsinfo3res_u.resok.time_delta.seconds = 0;
 480     result.fsinfo3res_u.resok.time_delta.nseconds = 1000;
 481     result.fsinfo3res_u.resok.properties
 482         = FSF3_LINK | FSF3_SYMLINK | FSF3_HOMOGENEOUS | FSF3_CANSETTIME;
 483
 484     return &result;
 485 }
 486
 487 pathconf3res *
 488 nfsproc3_pathconf_3_svc(nfs_fh3 *argp, struct svc_req *rqstp)
 489 {
 490     static pathconf3res result;
 491
 492     BlueSkyInode *inode = bluesky_get_inode(fs, 1);
 493     result.status = NFS3_OK;
 494     result.pathconf3res_u.resok.obj_attributes.present = TRUE;
 495     encode_fattr3(&result.pathconf3res_u.resok.obj_attributes.post_op_attr_u.attributes, inode);
 496     result.pathconf3res_u.resok.linkmax = 0xffffffff;
 497     result.pathconf3res_u.resok.name_max = 255;
 498     result.pathconf3res_u.resok.no_trunc = TRUE;
 499     result.pathconf3res_u.resok.chown_restricted = TRUE;
 500     result.pathconf3res_u.resok.case_insensitive = FALSE;
 501     result.pathconf3res_u.resok.case_preserving = TRUE;
 502
 503     return &result;
 504 }
 505
 506 commit3res *
 507 nfsproc3_commit_3_svc(commit3args *argp, struct svc_req *rqstp)
 508 {
 509     static commit3res result;
 510
 511     result.status = NFS3ERR_NOTSUPP;
 512
 513     return &result;
 514 }