`dissect.target.helpers.nfs.serializer`¶

Module Contents¶

Classes¶

`MountResultDeserializer`	Abstract base class for generic types.
`ReadDirPlusParamsSerializer`	Abstract base class for generic types.
`SpecDataSerializer`	Abstract base class for generic types.
`NfsTimeSerializer`	Abstract base class for generic types.
`FileAttributesSerializer`	Abstract base class for generic types.
`EntryPlusSerializer`	Abstract base class for generic types.
`ReadDirPlusResultDeserializer`	Abstract base class for generic types.
`Read3ArgsSerializer`	Abstract base class for generic types.
`Read3ResultDeserializer`	Abstract base class for generic types.

class dissect.target.helpers.nfs.serializer.MountResultDeserializer¶

Bases: dissect.target.helpers.sunrpc.serializer.XdrDeserializer[Union[dissect.target.helpers.nfs.nfs3.MountOK, dissect.target.helpers.nfs.nfs3.MountStat3]]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

deserialize(payload: io.BytesIO) → dissect.target.helpers.nfs.nfs3.MountOK | dissect.target.helpers.nfs.nfs3.MountStat3¶

class dissect.target.helpers.nfs.serializer.ReadDirPlusParamsSerializer¶

Bases: dissect.target.helpers.sunrpc.serializer.XdrSerializer[dissect.target.helpers.nfs.nfs3.ReadDirPlusParams]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

serialize(params: dissect.target.helpers.nfs.nfs3.ReadDirPlusParams) → bytes¶

class dissect.target.helpers.nfs.serializer.SpecDataSerializer¶

Bases: dissect.target.helpers.sunrpc.serializer.XdrDeserializer[dissect.target.helpers.nfs.nfs3.SpecData3]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

deserialize(payload: io.BytesIO) → bytes¶

class dissect.target.helpers.nfs.serializer.NfsTimeSerializer¶

Bases: dissect.target.helpers.sunrpc.serializer.XdrDeserializer[dissect.target.helpers.nfs.nfs3.NfsTime3]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

deserialize(payload: io.BytesIO) → bytes¶

class dissect.target.helpers.nfs.serializer.FileAttributesSerializer¶

Bases: dissect.target.helpers.sunrpc.serializer.XdrDeserializer[dissect.target.helpers.nfs.nfs3.FileAttributes3]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

deserialize(payload: io.BytesIO) → dissect.target.helpers.nfs.nfs3.FileAttributes3¶

class dissect.target.helpers.nfs.serializer.EntryPlusSerializer¶

Bases: dissect.target.helpers.sunrpc.serializer.XdrDeserializer[dissect.target.helpers.nfs.nfs3.EntryPlus3]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

deserialize(payload: io.BytesIO) → dissect.target.helpers.nfs.nfs3.EntryPlus3¶

class dissect.target.helpers.nfs.serializer.ReadDirPlusResultDeserializer¶

Bases: dissect.target.helpers.sunrpc.serializer.XdrDeserializer[Union[dissect.target.helpers.nfs.nfs3.ReadDirPlusResult3, dissect.target.helpers.nfs.nfs3.Nfs3Stat]]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

deserialize(payload: io.BytesIO) → dissect.target.helpers.nfs.nfs3.ReadDirPlusResult3¶

class dissect.target.helpers.nfs.serializer.Read3ArgsSerializer¶

Bases: dissect.target.helpers.sunrpc.serializer.XdrSerializer[dissect.target.helpers.nfs.nfs3.ReadDirPlusParams]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

serialize(args: dissect.target.helpers.nfs.nfs3.Read3args) → bytes¶

class dissect.target.helpers.nfs.serializer.Read3ResultDeserializer¶

Bases: dissect.target.helpers.sunrpc.serializer.XdrDeserializer[dissect.target.helpers.nfs.nfs3.Read3resok]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

deserialize(payload: io.BytesIO) → dissect.target.helpers.nfs.nfs3.Read3resok¶

dissect.target.helpers.nfs.serializer¶

Module Contents¶

Classes¶

`dissect.target.helpers.nfs.serializer`¶