NFS3(3)

📦 version 3.2, in debian trixie, fedora 43, fedora 44, ubuntu noble, ubuntu questing, ubuntu resolute, ubuntu stonking

✨ NFS3(3) ✨

okay so bestie, welcome to the nfs3 manual page, version 3.0 — yes, this is NFS3(3), and yes, it's giving big protocol energy. This is the NFSv3 decoding module, and we're gonna walk through every single class together, no skimming, no skipping. Grab a snack. 🍓

🌸 NAME 🌸

packet.nfs.nfs3 — the NFSv3 decoding module. That's the whole name section, short and iconic. 💅

👑 CLASSES 👑

Okay so this is the main character section. Every one of these bad boys inherits from baseobj.BaseObj, and every single one of them has the same adorable little constructor. We're doing them all, in order, no cap. 🫶

class ACCESS3args(baseobj.BaseObj)

The args side of the ACCESS situation, bestie. Look at her. ✨

struct ACCESS3args {
    nfs_fh3 fh;
    access3 access;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — it's the constructor 💖

It sets up the object's private data according to whatever arguments you give it. You can hand those over positionally, as named arguments, or a combination of both — all three are valid, pick your fighter.

class ACCESS3res(baseobj.BaseObj)

The result half of ACCESS, and it's a union switch — so it's picking a lane based on status. Very choose-your-own-adventure of it. 🦋

union switch ACCESS3res (nfsstat3 status) {
    case const.NFS3_OK:
        ACCESS3resok resok;
    default:
        ACCESS3resfail resfail;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — constructor, babes 🌸

It initializes the object's private data based on the arguments you pass in, and those arguments can be positional, named, or a mix of both. Easy.

class ACCESS3resfail(baseobj.BaseObj)

The not-okay branch. Sometimes things just don't work out and that's valid. 😭

struct ACCESS3resfail {
    post_op_attr attributes;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — yep, the constructor 💫

Whatever arguments you give it get used to set up the object's private data. Positional, named, or a combination of the two — it's not picky.

class ACCESS3resok(baseobj.BaseObj)

The okay branch, the one we're all rooting for. 🎀

struct ACCESS3resok {
    post_op_attr attributes;
    access3      access;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor, obviously 💅

It sets up the object's private data according to the arguments given, and you're free to give them positionally, by name, or as a combination of both.

class COMMIT3args(baseobj.BaseObj)

COMMIT time! Args edition. She's got an fh, an offset and a count and she knows how to use them. 🔥

struct COMMIT3args {
    nfs_fh3 fh;
    offset3 offset;
    count3  count;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — constructor ✨

It initializes the object's private data according to the arguments you give it, and those can be positional, named, or any combination of both. Flexible queen.

class COMMIT3res(baseobj.BaseObj)

The result side of COMMIT, and it's a union switch on status because of course it is. 👑

union switch COMMIT3res (nfsstat3 status) {
    case const.NFS3_OK:
        COMMIT3resok resok;
    default:
        COMMIT3resfail resfail;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor, bestie 💖

It sets up the object's private data based on whatever arguments you hand it. Positional, named, or a combo of both — all good.

class COMMIT3resfail(baseobj.BaseObj)

The sad path. She carries a wcc_data wcc and honestly, same. 💀

struct COMMIT3resfail {
    wcc_data wcc;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — constructor vibes 🌈

It initializes the object's private data according to the arguments given, and you can give those arguments positionally, as named arguments, or a combination of both.

class COMMIT3resok(baseobj.BaseObj)

The happy path for COMMIT, complete with a writeverf3 verifier for ✨flavor✨.

struct COMMIT3resok {
    wcc_data   wcc;
    writeverf3 verifier;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — it's the constructor 🫶

It sets up the object's private data according to the arguments you give it — positional, named, or a mix of both, whatever suits the moment.

class CREATE3args(baseobj.BaseObj)

The args for CREATE. where plus how — honestly a whole mood, that's just life advice. 🦋

struct CREATE3args {
    diropargs3 where;
    createhow3 how;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor 💫

It initializes the object's private data according to the arguments given, and those arguments may be positional, named, or a combination of both.

class CREATE3res(baseobj.BaseObj)

Result side of CREATE, union switch on status, you know the drill by now. ⭐

union switch CREATE3res (nfsstat3 status) {
    case const.NFS3_OK:
        CREATE3resok resok;
    default:
        CREATE3resfail resfail;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — constructor, no cap 🎀

It sets up the object's private data based on the arguments you pass in, and you can pass them positionally, by name, or as a combination of both.

class CREATE3resfail(baseobj.BaseObj)

Fail branch for CREATE. She's carrying a wcc_data wcc and a dream. 😭

struct CREATE3resfail {
    wcc_data wcc;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — yep, constructor 🌸

It initializes the object's private data according to the arguments you give it. Positional, named, or both at once — all valid.

class CREATE3resok(baseobj.BaseObj)

Success branch for CREATE — obj, attributes, wcc, the whole little family. 👑

struct CREATE3resok {
    post_op_fh3  obj;
    post_op_attr attributes;
    wcc_data     wcc;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor 💖

It sets up the object's private data according to the arguments given, and those arguments can be positional, named, or any combination of both.

class FSINFO3args(baseobj.BaseObj)

The args for FSINFO, and honestly? Minimalist. She's just one fh. Less is more. 💅

struct FSINFO3args {
    nfs_fh3 fh;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — constructor energy ✨

It initializes the object's private data based on whatever arguments you give it, and those can be positional, named, or a combination of the two.

class FSINFO3res(baseobj.BaseObj)

FSINFO result, union switch on status, doing the exact same dance as all her sisters. 🌈

union switch FSINFO3res (nfsstat3 status) {
    case const.NFS3_OK:
        FSINFO3resok resok;
    default:
        FSINFO3resfail resfail;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor 🫶

It sets up the object's private data according to the arguments you hand it — positional, named, or a mix of both, dealer's choice.

class FSINFO3resfail(baseobj.BaseObj)

Fail branch for FSINFO. One lonely attributes field. She's fine. It's fine. 🙈

struct FSINFO3resfail {
    post_op_attr attributes;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — constructor, bestie 💫

It initializes the object's private data according to the arguments given, and you can give them positionally, as named arguments, or a combination of both.

class FSINFO3resok(baseobj.BaseObj)

Okay this one is the main event — look at all those uint32s, the size3 maxfilesize, the nfstime3 time_delta, the uint32 properties. She's stacked. 👑

struct FSINFO3resok {
    post_op_attr attributes;
    uint32       rtmax;
    uint32       rtpref;
    uint32       rtmult;
    uint32       wtmax;
    uint32       wtpref;
    uint32       wtmult;
    uint32       dtpref;
    size3        maxfilesize;
    nfstime3     time_delta;
    uint32       properties;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor 💖

It sets up the object's private data according to the arguments you give it, and those arguments may be positional, named, or a combination of both.

class FSSTAT3args(baseobj.BaseObj)

FSSTAT args, and she's also rocking the single-fh look. Iconic, minimal, slay. 🎀

struct FSSTAT3args {
    nfs_fh3 fh;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — it's the constructor 🌸

It initializes the object's private data according to whatever arguments you give it — positional, named, or both in combination.

class FSSTAT3res(baseobj.BaseObj)

FSSTAT result, union switch on status. At this point it's a family tradition. ⭐

union switch FSSTAT3res (nfsstat3 status) {
    case const.NFS3_OK:
        FSSTAT3resok resok;
    default:
        FSSTAT3resfail resfail;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — constructor 🦋

It sets up the object's private data based on the arguments you pass it, and you're welcome to pass them positionally, by name, or as a combination of both.

class FSSTAT3resfail(baseobj.BaseObj)

Fail branch for FSSTAT. Just an attributes field, living her truth. 😭

struct FSSTAT3resfail {
    post_op_attr attributes;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor 💅

It initializes the object's private data according to the arguments given, and those arguments can be positional, named, or any combination of both.

class FSSTAT3resok(baseobj.BaseObj)

Success branch for FSSTAT, and she brought seven size3s plus an invarsec to the party. Not me being obsessed with a struct. 🔥

struct FSSTAT3resok {
    post_op_attr attributes;
    size3        tbytes;
    size3        fbytes;
    size3        abytes;
    size3        tfiles;
    size3        ffiles;
    size3        afiles;
    uint32       invarsec;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor ✨

It sets up the object's private data according to the arguments you give it — positional, named, or a combination of both, all fine.

class GETATTR3args(baseobj.BaseObj)

GETATTR args. One fh. That's the whole personality and honestly, respect. 🫶

struct GETATTR3args {
    nfs_fh3 fh;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — constructor, babes 💖

It initializes the object's private data according to the arguments you give it, and you can give those arguments positionally, as named arguments, or a combination of both.

class GETATTR3res(baseobj.BaseObj)

GETATTR result! Union switch on status, but look — the default case is just void. No fail struct. She said "no thoughts, head empty". 💀

union switch GETATTR3res (nfsstat3 status) {
    case const.NFS3_OK:
        GETATTR3resok resok;
    default:
        void;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor 🌈

It sets up the object's private data based on the arguments given, and those may be positional, named, or a combination of both.

class GETATTR3resok(baseobj.BaseObj)

The okay branch, carrying exactly one fattr3 attributes. Simple. Clean. Iconic. 🎀

struct GETATTR3resok {
    fattr3 attributes;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — yep, the constructor 💫

It initializes the object's private data according to the arguments you hand it, and you can hand them over positionally, by name, or a mix of both.

class LINK3args(baseobj.BaseObj)

LINK args! An fh and a diropargs3 link. Two besties, one struct. 🦋

struct LINK3args {
    nfs_fh3    fh;
    diropargs3 link;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor 🌸

It sets up the object's private data according to the arguments given — positional, named, or any combination of both, all welcome here.

class LINK3res(baseobj.BaseObj)

LINK result, union switch on status. Consistency queen. ⭐

union switch LINK3res (nfsstat3 status) {
    case const.NFS3_OK:
        LINK3resok resok;
    default:
        LINK3resfail resfail;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — constructor, bestie 💅

It initializes the object's private data according to the arguments you give it, and those arguments can be positional, named, or a combination of both.

class LINK3resfail(baseobj.BaseObj)

Fail branch for LINK, holding an attributes and a wcc. She's doing her best. 😭

struct LINK3resfail {
    post_op_attr attributes;
    wcc_data     wcc;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — the constructor 💖

It sets up the object's private data based on whatever arguments you give it — positionally, by name, or both at once.

class LINK3resok(baseobj.BaseObj)

And the okay branch for LINK, same duo of attributes and wcc, but make it successful. 👑

struct LINK3resok {
    post_op_attr attributes;
    wcc_data     wcc;
};

okay so that class we were just talking about? here's its method sitch, and then we're rolling straight into the next batch of classes — they're alphabetical btw, the authors really said "organization ✨".

🎀 Methods defined here 🎀

  • __init__(self, unpack) — Constructor
Constructor means it's the thing that runs when the object is born 💖 It sets up the object's private data based on whatever arguments you give it. Positional, named, or a lil mix of both — all three are valid, bestie, it's not picky.

🦋 class LOOKUP3args(baseobj.BaseObj)

the whole vibe:

struct LOOKUP3args {
    diropargs3 what;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

it initializes the object's private data from the arguments you pass in, and you can do that positionally, with named args, or a combo of both 🫶

🌸 class LOOKUP3res(baseobj.BaseObj)

this one's a union switch, so it flips based on status:

union switch LOOKUP3res (nfsstat3 status) {
    case const.NFS3_OK:
        LOOKUP3resok resok;
    default:
        LOOKUP3resfail resfail;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

sets up the object's private data according to the args you hand over — positional, named, or both together, whatever feels right 💅

🎀 class LOOKUP3resfail(baseobj.BaseObj)

struct LOOKUP3resfail {
    post_op_attr dir_attributes;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

initializes the object's private data based on the arguments given — positional, named, or a mix of the two, no notes 🔥

💜 class LOOKUP3resok(baseobj.BaseObj)

struct LOOKUP3resok {
    nfs_fh3      fh;
    post_op_attr attributes;
    post_op_attr dir_attributes;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

same deal: private data gets set up from the arguments you give it, and you can pass those positionally, by name, or both at once 🌈

⭐ class MKDIR3args(baseobj.BaseObj)

struct MKDIR3args {
    diropargs3 where;
    sattr3     attributes;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

initializes the object's private data per the arguments given — positional, named, or a combination, all good 😌

🦋 class MKDIR3res(baseobj.BaseObj)

union switch MKDIR3res (nfsstat3 status) {
    case const.NFS3_OK:
        MKDIR3resok resok;
    default:
        MKDIR3resfail resfail;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

object's private data, set up from your arguments, and yes you can mix positional and named ones together 💖

🍓 class MKDIR3resfail(baseobj.BaseObj)

struct MKDIR3resfail {
    wcc_data wcc;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

initializes the object's private data from the arguments provided — positional, named, or a blend of both, periodt ✨

🎀 class MKDIR3resok(baseobj.BaseObj)

struct MKDIR3resok {
    post_op_fh3  obj;
    post_op_attr attributes;
    wcc_data     wcc;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

private data gets initialized according to the arguments you give — and yeah, positional, named, or both, it's flexible like that 🫶

🧚 class MKNOD3args(baseobj.BaseObj)

struct MKNOD3args {
    diropargs3 where;
    mknoddata3 what;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

sets the object's private data from the arguments given — positional, named, or a combo, you already know 💅

👑 class MKNOD3res(baseobj.BaseObj)

union switch MKNOD3res (nfsstat3 status) {
    case const.NFS3_OK:
        MKNOD3resok resok;
    default:
        MKNOD3resfail resfail;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

initializes the object's private data per the arguments you pass — positional, named, or a mix of both, no cap 🧚

💜 class MKNOD3resfail(baseobj.BaseObj)

struct MKNOD3resfail {
    wcc_data wcc;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

object's private data → initialized from the arguments given → and those can be positional, named, or both 🌸

🌈 class MKNOD3resok(baseobj.BaseObj)

struct MKNOD3resok {
    post_op_fh3  obj;
    post_op_attr attributes;
    wcc_data     wcc;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

initializes the object's private data according to the arguments given — positional, named, or a combination of both, iconic behaviour honestly 💖

🔥 class NFS3args(packet.utils.RPCload)

okay THIS one is the big one, bestie, it's a union switch on nfs_proc3 procedure and it branches into basically the entire NFSv3 op set:

union switch NFS3args (nfs_proc3 procedure) {
    case const.NFSPROC3_NULL:
        void;
    case const.NFSPROC3_GETATTR:
        GETATTR3args opgetattr;
    case const.NFSPROC3_SETATTR:
        SETATTR3args opsetattr;
    case const.NFSPROC3_LOOKUP:
        LOOKUP3args oplookup;
    case const.NFSPROC3_ACCESS:
        ACCESS3args opaccess;
    case const.NFSPROC3_READLINK:
        READLINK3args opreadlink;
    case const.NFSPROC3_READ:
        READ3args opread;
    case const.NFSPROC3_WRITE:
        WRITE3args opwrite;
    case const.NFSPROC3_CREATE:
        CREATE3args opcreate;
    case const.NFSPROC3_MKDIR:
        MKDIR3args opmkdir;
    case const.NFSPROC3_SYMLINK:
        SYMLINK3args opsymlink;
    case const.NFSPROC3_MKNOD:
        MKNOD3args opmknod;
    case const.NFSPROC3_REMOVE:
        REMOVE3args opremove;
    case const.NFSPROC3_RMDIR:
        RMDIR3args oprmdir;
    case const.NFSPROC3_RENAME:
        RENAME3args oprename;
    case const.NFSPROC3_LINK:
        LINK3args oplink;
    case const.NFSPROC3_READDIR:
        READDIR3args opreaddir;
    case const.NFSPROC3_READDIRPLUS:
        READDIRPLUS3args opreaddirplus;
    case const.NFSPROC3_FSSTAT:
        FSSTAT3args opfsstat;
    case const.NFSPROC3_FSINFO:
        FSINFO3args opfsinfo;
    case const.NFSPROC3_PATHCONF:
        PATHCONF3args oppathconf;
    case const.NFSPROC3_COMMIT:
        COMMIT3args opcommit;
};

✨ Methods defined here ✨

  • __init__(self, unpack, procedure) — Constructor
⚠️ heads up, this constructor takes two things, not one — unpack and procedure 👀

it initializes the object's private data according to the arguments given, and you can pass those positionally, as named arguments, or a combination of both 💅

💀 class NFS3res(packet.utils.RPCload)

and here's its matching response side, also switching on nfs_proc3 procedure:

union switch NFS3res (nfs_proc3 procedure) {
    case const.NFSPROC3_NULL:
        void;
    case const.NFSPROC3_GETATTR:
        GETATTR3res opgetattr;
    case const.NFSPROC3_SETATTR:
        SETATTR3res opsetattr;
    case const.NFSPROC3_LOOKUP:
        LOOKUP3res oplookup;
    case const.NFSPROC3_ACCESS:
        ACCESS3res opaccess;
    case const.NFSPROC3_READLINK:
        READLINK3res opreadlink;
    case const.NFSPROC3_READ:
        READ3res opread;
    case const.NFSPROC3_WRITE:
        WRITE3res opwrite;
    case const.NFSPROC3_CREATE:
        CREATE3res opcreate;
    case const.NFSPROC3_MKDIR:
        MKDIR3res opmkdir;
    case const.NFSPROC3_SYMLINK:
        SYMLINK3res opsymlink;
    case const.NFSPROC3_MKNOD:
        MKNOD3res opmknod;
    case const.NFSPROC3_REMOVE:
        REMOVE3res opremove;
    case const.NFSPROC3_RMDIR:
        RMDIR3res oprmdir;
    case const.NFSPROC3_RENAME:
        RENAME3res oprename;
    case const.NFSPROC3_LINK:
        LINK3res oplink;
    case const.NFSPROC3_READDIR:
        READDIR3res opreaddir;
    case const.NFSPROC3_READDIRPLUS:
        READDIRPLUS3res opreaddirplus;
    case const.NFSPROC3_FSSTAT:
        FSSTAT3res opfsstat;
    case const.NFSPROC3_FSINFO:
        FSINFO3res opfsinfo;
    case const.NFSPROC3_PATHCONF:
        PATHCONF3res oppathconf;
    case const.NFSPROC3_COMMIT:
        COMMIT3res opcommit;
};

✨ Methods defined here ✨

  • __init__(self, unpack, procedure) — Constructor
⚠️ again — this one wants unpack and procedure, don't forget the second one bestie 😭

initializes the object's private data from the arguments given — positional, named, or a mix of both, whichever ✨

🌸 class PATHCONF3args(baseobj.BaseObj)

struct PATHCONF3args {
    nfs_fh3 fh;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

sets up the object's private data according to the arguments given — positional, named, or both together, all valid 💖

🦋 class PATHCONF3res(baseobj.BaseObj)

union switch PATHCONF3res (nfsstat3 status) {
    case const.NFS3_OK:
        PATHCONF3resok resok;
    default:
        PATHCONF3resfail resfail;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

initializes the object's private data per the arguments given — positional, named, or a combination of both 🫶

🎀 class PATHCONF3resfail(baseobj.BaseObj)

struct PATHCONF3resfail {
    post_op_attr attributes;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

object's private data, initialized from your arguments, and yep — positional, named, or both, it's giving flexible 💅

⭐ class PATHCONF3resok(baseobj.BaseObj)

this one's got a whole lil pile of fields, look:

struct PATHCONF3resok {
    post_op_attr attributes;
    uint32       linkmax;
    uint32       name_max;
    bool         no_trunc;
    bool         chown_restricted;
    bool         case_insensitive;
    bool         case_preserving;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

initializes the object's private data according to the arguments given — positional, named, or a combination of both, no cap 🌈

💜 class READ3args(baseobj.BaseObj)

struct READ3args {
    nfs_fh3 fh;
    offset3 offset;
    count3  count;
};

✨ Methods defined here ✨

  • __init__(self, unpack) — Constructor

sets the object's private data from the arguments you give it — positional, named, or both at once, iconic 🔥

class READ3res(baseobj.BaseObj) 💖

       union switch READ3res (nfsstat3 status) {
           case const.NFS3_OK:
               READ3resok resok;
           default:
               READ3resfail resfail;
       };

okay so this one is a union that switches on nfsstat3 status. If the status is const.NFS3_OK, you get READ3resok resok; otherwise it's READ3resfail resfail. No cap, that's the whole vibe. 🦋

Methods defined here:

  • __init__(self, unpack) — Constructor moment. It initializes the object's private data according to the arguments given. You can pass them positionally, as named arguments, or a mix of both. Slay. ✨

class READ3resfail(baseobj.BaseObj) 💅

       struct READ3resfail {
           post_op_attr file_attributes;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor alert. It sets up the object's private data based on the arguments you give it. Positional, named, or a combo — all valid, bestie. 🫶

class READ3resok(packet.utils.RDMAbase) 🌸

       struct READ3resok {
           post_op_attr attributes;
           count3       count;
           bool         eof;
           opaque       data<>;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor vibes. It initializes the object's private data according to the arguments given. You can go positional, named, or mix both. Periodt. 💖

class READDIR3args(baseobj.BaseObj) 🎀

       struct READDIR3args {
           nfs_fh3     fh;
           cookie3     cookie;
           cookieverf3 verifier;
           count3      count;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor time. It sets up the object's private data based on whatever arguments you hand it. Positional, named, or a combination — all good. ✨

class READDIR3res(baseobj.BaseObj) 🦋

       union switch READDIR3res (nfsstat3 status) {
           case const.NFS3_OK:
               READDIR3resok resok;
           default:
               READDIR3resfail resfail;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor energy. It initializes the object's private data according to the arguments given. You can pass them positionally, as named arguments, or both. 💅

class READDIR3resfail(baseobj.BaseObj) 🌈

       struct READDIR3resfail {
           post_op_attr attributes;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor o'clock. It sets up the object's private data based on the arguments you provide. Positional, named, or a mix — slay. 🫶

class READDIR3resok(baseobj.BaseObj) 💜

       struct READDIR3resok {
           post_op_attr attributes;
           cookieverf3  verifier;
           dirlist3     reply;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor moment. It initializes the object's private data according to the arguments given. Positional, named, or a combination of both — no cap. ✨

class READDIRPLUS3args(baseobj.BaseObj) ⭐

       struct READDIRPLUS3args {
           nfs_fh3     fh;
           cookie3     cookie;
           cookieverf3 verifier;
           count3      dircount;
           count3      maxcount;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor vibes. It sets up the object's private data based on the arguments you give it. You can go positional, named, or mix both. 💖

class READDIRPLUS3res(baseobj.BaseObj) 🔥

       union switch READDIRPLUS3res (nfsstat3 status) {
           case const.NFS3_OK:
               READDIRPLUS3resok resok;
           default:
               READDIRPLUS3resfail resfail;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor alert. It initializes the object's private data according to the arguments given. Positional, named, or a mix — all valid, bestie. 🎀

class READDIRPLUS3resfail(baseobj.BaseObj) 🌸

       struct READDIRPLUS3resfail {
           post_op_attr attributes;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor time. It sets up the object's private data based on the arguments you provide. Positional, named, or both — periodt. 🦋

class READDIRPLUS3resok(baseobj.BaseObj) 💅

       struct READDIRPLUS3resok {
           post_op_attr attributes;
           cookieverf3  verifier;
           dirlistplus3 reply;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor energy. It initializes the object's private data according to the arguments given. You can pass them positionally, as named arguments, or a combination. ✨

class READLINK3args(baseobj.BaseObj) 🫶

       struct READLINK3args {
           nfs_fh3 fh;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor moment. It sets up the object's private data based on the arguments you give it. Positional, named, or a mix — slay. 💖

class READLINK3res(baseobj.BaseObj) 🌈

       union switch READLINK3res (nfsstat3 status) {
           case const.NFS3_OK:
               READLINK3resok resok;
           default:
               READLINK3resfail resfail;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor vibes. It initializes the object's private data according to the arguments given. Positional, named, or a combination of both — no cap. 🎀

class READLINK3resfail(baseobj.BaseObj) 💜

       struct READLINK3resfail {
           post_op_attr attributes;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor alert. It sets up the object's private data based on the arguments you provide. You can go positional, named, or mix both. ✨

class READLINK3resok(packet.utils.RDMAbase) ⭐

       struct READLINK3resok {
           post_op_attr attributes;
           nfspath3     link;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor time. It initializes the object's private data according to the arguments given. Positional, named, or both — all valid, bestie. 💅

class REMOVE3args(baseobj.BaseObj) 🔥

       struct REMOVE3args {
           diropargs3 object;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor energy. It sets up the object's private data based on the arguments you give it. Positional, named, or a mix — slay. 🫶

class REMOVE3res(baseobj.BaseObj) 🌸

       union switch REMOVE3res (nfsstat3 status) {
           case const.NFS3_OK:
               REMOVE3resok resok;
           default:
               REMOVE3resfail resfail;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor moment. It initializes the object's private data according to the arguments given. You can pass them positionally, as named arguments, or a combination. 💖

class REMOVE3resfail(baseobj.BaseObj) 🦋

       struct REMOVE3resfail {
           wcc_data wcc;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor vibes. It sets up the object's private data based on the arguments you provide. Positional, named, or both — periodt. ✨

class REMOVE3resok(baseobj.BaseObj) 🎀

       struct REMOVE3resok {
           wcc_data wcc;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor alert. It initializes the object's private data according to the arguments given. Positional, named, or a mix — all valid, bestie. 💅

class RENAME3args(baseobj.BaseObj) 🌈

       struct RENAME3args {
           diropargs3 nfrom;
           diropargs3 nto;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor time. It sets up the object's private data based on the arguments you give it. You can go positional, named, or mix both. 🫶

class RENAME3res(baseobj.BaseObj) 💜

       union switch RENAME3res (nfsstat3 status) {
           case const.NFS3_OK:
               RENAME3resok resok;
           default:
               RENAME3resfail resfail;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor energy. It initializes the object's private data according to the arguments given. Positional, named, or a combination of both — no cap. 💖

class RENAME3resfail(baseobj.BaseObj) ⭐

       struct RENAME3resfail {
           wcc_data fromdir_wcc;
           wcc_data todir_wcc;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor moment. It sets up the object's private data based on the arguments you provide. Positional, named, or both — slay. ✨

class RENAME3resok(baseobj.BaseObj) 🔥

       struct RENAME3resok {
           wcc_data fromdir_wcc;
           wcc_data todir_wcc;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor vibes. It initializes the object's private data according to the arguments given. You can pass them positionally, as named arguments, or a mix. 🎀

class RMDIR3args(baseobj.BaseObj) 🌸

       struct RMDIR3args {
           diropargs3 object;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor alert. It sets up the object's private data based on the arguments you give it. Positional, named, or a combination — all valid, bestie. 💅

class RMDIR3res(baseobj.BaseObj) 🦋

       union switch RMDIR3res (nfsstat3 status) {
           case const.NFS3_OK:
               RMDIR3resok resok;
           default:
               RMDIR3resfail resfail;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor time. It initializes the object's private data according to the arguments given. Positional, named, or both — periodt. 🫶

class RMDIR3resfail(baseobj.BaseObj) 🌈

       struct RMDIR3resfail {
           wcc_data wcc;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor energy. It sets up the object's private data based on the arguments you provide. You can go positional, named, or mix both. 💖

class RMDIR3resok(baseobj.BaseObj) 💜

       struct RMDIR3resok {
           wcc_data wcc;
       };

Methods defined here:

  • __init__(self, unpack) — Constructor moment. It initializes the object's private data according to the arguments given. Positional, named, or a combination of both — no cap. ✨

okay bestie, part 4 of the class roster — let’s keep it moving 💖

💅 class SETATTR3args(baseobj.BaseObj)

struct SETATTR3args {
    nfs_fh3     fh;
    sattr3      attributes;
    sattrguard3 guard;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. It sets up the object’s private data from whatever args you hand it. You can pass them positionally, by name, or mix both — all valid, no cap.

✨ class SETATTR3res(baseobj.BaseObj)

union switch SETATTR3res (nfsstat3 status) {
    case const.NFS3_OK:
        SETATTR3resok resok;
    default:
        SETATTR3resfail resfail;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes the object’s private data according to the arguments given. Positional, named, or a combo of both — it ate.

🎀 class SETATTR3resfail(baseobj.BaseObj)

struct SETATTR3resfail {
    wcc_data wcc;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Sets up private data from your args. You can go positional, named, or both at once, bestie.

🦋 class SETATTR3resok(baseobj.BaseObj)

struct SETATTR3resok {
    wcc_data wcc;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes object’s private data from the arguments you pass. Positional, named, or a mix — literally all fine.

🌸 class SYMLINK3args(baseobj.BaseObj)

struct SYMLINK3args {
    diropargs3   where;
    symlinkdata3 symlink;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. It does the private-data setup based on the args you give. Positional, named, or a combination of both — slay.

💖 class SYMLINK3res(baseobj.BaseObj)

union switch SYMLINK3res (nfsstat3 status) {
    case const.NFS3_OK:
        SYMLINK3resok resok;
    default:
        SYMLINK3resfail resfail;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes the object’s private data according to the arguments. Positional, named, or both — the usual iconic behavior.

💜 class SYMLINK3resfail(baseobj.BaseObj)

struct SYMLINK3resfail {
    wcc_data dir_wcc;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Sets up private data from whatever you pass in. Positional, named, or a mix — yes bestie, both is allowed.

🧚 class SYMLINK3resok(baseobj.BaseObj)

struct SYMLINK3resok {
    post_op_fh3  obj;
    post_op_attr attributes;
    wcc_data     wcc;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes object’s private data from the arguments given. You can do positional, named, or both — periodt.

🔥 class WRITE3args(baseobj.BaseObj)

struct WRITE3args {
    nfs_fh3    fh;
    offset3    offset;
    count3     count;
    stable_how stable;
    opaque     data<>;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. It handles the private-data init from your args. Positional, named, or a combination of both — go off.

⭐ class WRITE3res(baseobj.BaseObj)

union switch WRITE3res (nfsstat3 status) {
    case const.NFS3_OK:
        WRITE3resok resok;
    default:
        WRITE3resfail resfail;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes object’s private data according to the arguments. Positional, named, or both — it’s giving flexible.

🌈 class WRITE3resfail(baseobj.BaseObj)

struct WRITE3resfail {
    wcc_data wcc;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Sets up private data from whatever args you provide. Positional, named, or a mix — all valid, no stress.

👑 class WRITE3resok(baseobj.BaseObj)

struct WRITE3resok {
    wcc_data   wcc;
    count3     count;
    stable_how committed;
    writeverf3 verifier;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes the object’s private data based on the arguments. Positional, named, or both — main character energy.

💫 class createhow3(baseobj.BaseObj)

union switch createhow3 (createmode3 mode) {
    case const.UNCHECKED:
    case const.GUARDED:
        sattr3 attributes;
    case const.EXCLUSIVE:
        createverf3 verifier;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. It sets up private data from the args you give. Positional, named, or a combination of both — yes queen.

🍓 class createmode3(packet.utils.Enum)

enum createmode3

No methods listed — it’s just an enum, bestie. Pure vibes, no constructor drama. ✨

🎀 class devicedata3(baseobj.BaseObj)

struct devicedata3 {
    sattr3    attributes;
    specdata3 spec;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes object’s private data according to the arguments given. Positional, named, or both — iconic.

🦋 class dirlist3(baseobj.BaseObj)

struct dirlist3 {
    entry3 *entries;
    bool   eof;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Sets up private data from whatever you pass. Positional, named, or a mix — it’s giving versatile.

🌸 class dirlistplus3(baseobj.BaseObj)

struct dirlistplus3 {
    entryplus3 *entries;
    bool       eof;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes the object’s private data based on the args. Positional, named, or both — no cap.

💖 class diropargs3(baseobj.BaseObj)

struct diropargs3 {
    nfs_fh3   fh;
    filename3 name;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. It sets up private data from the arguments you provide. Positional, named, or a combination — all good.

💜 class entry3(baseobj.BaseObj)

struct entry3 {
    fileid3   fileid;
    filename3 name;
    cookie3   cookie;
    entry3    *nextentry;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes object’s private data according to the arguments given. Positional, named, or both — periodt.

🧚 class entryplus3(baseobj.BaseObj)

struct entryplus3 {
    fileid3      fileid;
    filename3    name;
    cookie3      cookie;
    post_op_attr attributes;
    post_op_fh3  obj;
    entryplus3   *nextentry;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Sets up private data from whatever args you hand it. Positional, named, or a mix — yes bestie.

🔥 class fattr3(baseobj.BaseObj)

struct fattr3 {
    ftype3    type;
    mode3     mode;
    uint32    nlink;
    uid3      uid;
    gid3      gid;
    size3     size;
    size3     used;
    specdata3 rdev;
    uint64    fsid;
    fileid3   fileid;
    nfstime3  atime;
    nfstime3  mtime;
    nfstime3  ctime;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes the object’s private data based on the arguments. Positional, named, or both — it ate.

⭐ class ftype3(packet.utils.Enum)

enum ftype3

No methods listed — just an enum, bestie. It’s lowkey iconic. 💅

🌈 class mknoddata3(baseobj.BaseObj)

union switch mknoddata3 (ftype3 type) {
    case const.NF3CHR:
    case const.NF3BLK:
        devicedata3 device;
    case const.NF3SOCK:
    case const.NF3FIFO:
        sattr3 attributes;
    default:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Sets up private data from the args you give. Positional, named, or a combination of both — slay.

👑 class nfs_bool(packet.utils.Enum)

enum nfs_bool

No methods listed — enum only, no constructor chaos. 🎀

💫 class nfs_proc3(packet.utils.Enum)

enum nfs_proc3

No methods listed — it’s an enum, periodt. ✨

🍓 class nfsstat3(packet.utils.Enum)

enum nfsstat3

No methods listed — enum vibes only. 🦋

💖 class nfstime3(baseobj.BaseObj)

struct nfstime3 {
    uint32 seconds;
    uint32 nseconds;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes object’s private data according to the arguments given. Positional, named, or both — all valid.

💜 class post_op_attr(baseobj.BaseObj)

union switch post_op_attr (bool attributes_follow) {
    case const.TRUE:
        fattr3 attributes;
    case const.FALSE:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Sets up private data from whatever args you pass. Positional, named, or a mix — no cap.

🧚 class post_op_fh3(baseobj.BaseObj)

union switch post_op_fh3 (bool handle_follows) {
    case const.TRUE:
        nfs_fh3 fh;
    case const.FALSE:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. Initializes the object’s private data based on the arguments. Positional, named, or both — iconic.

🌸 class pre_op_attr(baseobj.BaseObj)

union switch pre_op_attr (bool attributes_follow) {
    case const.TRUE:
        wcc_attr attributes;
    case const.FALSE:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor. It sets up private data from the args you give. Positional, named, or a combination of both — yes queen.

class sattr3(baseobj.BaseObj)

okay so this one is THE glow-up kit for file attributes 💅 like mode, owner, group, size, times — all the "who am i / how big am i / when did i change" lore:

struct sattr3 {
    set_mode3 mode;
    set_uid3  uid;
    set_gid3  gid;
    set_size3 size;
    set_atime atime;
    set_mtime mtime;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

This sets up the object's private data based on whatever arguments you hand it. You can pass them positionally, as named arguments, or a lil mix of both — whatever feels right ✨

class sattrguard3(baseobj.BaseObj)

the ✨conditional✨ vibe, bestie — it only carries a ctime when check says TRUE, otherwise it's just... void, no thoughts, head empty:

union switch sattrguard3 (bool check) {
    case const.TRUE:
        nfstime3 ctime;
    case const.FALSE:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

Yep, same deal: it initializes the object's private data from the arguments given, and those args can be positional, named, or a combo of both 🫶

class set_atime(baseobj.BaseObj)

access-time glow-up moment 🌸 — if set_it is SET_TO_CLIENT_TIME you get a real nfstime3 atime, and anything else falls into default and hits you with the void:

union switch set_atime (time_how set_it) {
    case const.SET_TO_CLIENT_TIME:
        nfstime3 atime;
    default:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

Initializes the object's private data according to the arguments you gave. Positional, named, or both — dealer's choice 💖

class set_gid3(baseobj.BaseObj)

group id but make it a switch 💜 — TRUE means you actually get a gid3 gid, everything else is the void path:

union switch set_gid3 (bool set_it) {
    case const.TRUE:
        gid3 gid;
    default:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

It initializes the object's private data from the arguments given, and those arguments may be positional, named, or a mix of the two ⭐

class set_mode3(baseobj.BaseObj)

permission bits era 🎀 — when set_it is TRUE you're carrying a mode3 mode, otherwise default hands you the void:

union switch set_mode3 (bool set_it) {
    case const.TRUE:
        mode3 mode;
    default:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

Constructor behavior, as always: it initializes the object's private data according to the arguments given, which can be positional, named, or both at once 😌

class set_mtime(baseobj.BaseObj)

modification-time sister to set_atime, no cap 🦋 — SET_TO_CLIENT_TIME unlocks the nfstime3 mtime, and the default case gives you absolutely nothing:

union switch set_mtime (time_how set_it) {
    case const.SET_TO_CLIENT_TIME:
        nfstime3 mtime;
    default:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

It initializes the object's private data based on the arguments given — positional, named, or a combination of both 💫

class set_size3(baseobj.BaseObj)

size check, but make it a union 📏 — TRUE gets you a size3 size, and default gets you the void, periodt:

union switch set_size3 (bool set_it) {
    case const.TRUE:
        size3 size;
    default:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

It initializes the object's private data from the arguments given, and honestly you can pass them positional, named, or both 💅

class set_uid3(baseobj.BaseObj)

user id time 👑 — TRUE means you're holding a uid3 uid, and the default branch is the void, respectfully:

union switch set_uid3 (bool set_it) {
    case const.TRUE:
        uid3 uid;
    default:
        void;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

Constructor things: it initializes the object's private data according to the arguments given, whether those are positional, named, or a combo 🍓

class specdata3(baseobj.BaseObj)

the little two-slot duo for special device numbers, main character energy in a struct that's only two fields long:

struct specdata3 {
    uint32 specdata1;
    uint32 specdata2;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

It initializes the object's private data according to the arguments given, and yes bestie, they can be positional, named, or both 🌈

class stable_how(packet.utils.Enum)

enum stable_how

a whole enum, that's it, that's the entry 💀 — no methods listed here, it just is.

class symlinkdata3(baseobj.BaseObj)

symlink reveal ✨ — you get the attributes AND the path it points at, all in one struct:

struct symlinkdata3 {
    sattr3   attributes;
    nfspath3 linkdata;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

It initializes the object's private data according to the arguments given, which can be positional, named, or a combination of both 🧚

class time_how(packet.utils.Enum)

enum time_how

another enum, standing there, being iconic, listing zero methods 🎀

class wcc_attr(baseobj.BaseObj)

weak cache consistency, but for attributes — the trio of size and both timestamps, lowkey the receipts of a file's whole timeline:

struct wcc_attr {
    size3    size;
    nfstime3 mtime;
    nfstime3 ctime;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

It initializes the object's private data from the arguments given — positional, named, or both, your call 💖

class wcc_data(baseobj.BaseObj)

the before/after of it all 😭 — pre-op attributes and post-op attributes, side by side like a glow-up reveal:

struct wcc_data {
    pre_op_attr  before;
    post_op_attr after;
};

Methods defined here:

  • __init__(self, unpack) — Constructor

It initializes the object's private data according to the arguments given, and those arguments can be positional, named, or a mix of both 💜

✨ FUNCTIONS ✨

four lil standalone unpacking helpers, all taking unpack and giving you the good stuff:

  • cookieverf3(unpack)
  • createverf3(unpack)
  • nfs_fh3(unpack)
  • writeverf3(unpack)

🌸 SEE ALSO 🌸

go read these next, bestie, they're all part of the same friend group:

💀 BUGS 💀

No known bugs. flawless behavior, we love that for it ✨

🫶 AUTHOR 🫶

Jorge Mora (mora@netapp.com) — the icon, the moment, the author 👑

and that's the whole page, babes 💖 this was NFStest 3.2, dated 21 March 2023, and no cap it ate. k bye, go write some NFS3 code 🦋✨

📦 where this page comes from