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