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