sneak
213364bab5
- Add UUID field to both inner and outer manifest messages - Generate random v4 UUID when creating manifest - Hash compressed data (not uncompressed) for integrity check - Verify hash before decompression to prevent malicious payloads - Validate UUIDs are proper format and match between inner/outer - Sign string format: MAGIC-UUID-MULTIHASH
668 lines
18 KiB
Go
668 lines
18 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// versions:
|
|
// protoc-gen-go v1.36.11
|
|
// protoc v6.33.0
|
|
// source: mf.proto
|
|
|
|
package mfer
|
|
|
|
import (
|
|
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
|
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
|
reflect "reflect"
|
|
sync "sync"
|
|
unsafe "unsafe"
|
|
)
|
|
|
|
const (
|
|
// Verify that this generated code is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
|
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
|
)
|
|
|
|
type MFFileOuter_Version int32
|
|
|
|
const (
|
|
MFFileOuter_VERSION_NONE MFFileOuter_Version = 0
|
|
MFFileOuter_VERSION_ONE MFFileOuter_Version = 1 // only one for now
|
|
)
|
|
|
|
// Enum value maps for MFFileOuter_Version.
|
|
var (
|
|
MFFileOuter_Version_name = map[int32]string{
|
|
0: "VERSION_NONE",
|
|
1: "VERSION_ONE",
|
|
}
|
|
MFFileOuter_Version_value = map[string]int32{
|
|
"VERSION_NONE": 0,
|
|
"VERSION_ONE": 1,
|
|
}
|
|
)
|
|
|
|
func (x MFFileOuter_Version) Enum() *MFFileOuter_Version {
|
|
p := new(MFFileOuter_Version)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x MFFileOuter_Version) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (MFFileOuter_Version) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_mf_proto_enumTypes[0].Descriptor()
|
|
}
|
|
|
|
func (MFFileOuter_Version) Type() protoreflect.EnumType {
|
|
return &file_mf_proto_enumTypes[0]
|
|
}
|
|
|
|
func (x MFFileOuter_Version) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use MFFileOuter_Version.Descriptor instead.
|
|
func (MFFileOuter_Version) EnumDescriptor() ([]byte, []int) {
|
|
return file_mf_proto_rawDescGZIP(), []int{1, 0}
|
|
}
|
|
|
|
type MFFileOuter_CompressionType int32
|
|
|
|
const (
|
|
MFFileOuter_COMPRESSION_NONE MFFileOuter_CompressionType = 0
|
|
MFFileOuter_COMPRESSION_ZSTD MFFileOuter_CompressionType = 1
|
|
)
|
|
|
|
// Enum value maps for MFFileOuter_CompressionType.
|
|
var (
|
|
MFFileOuter_CompressionType_name = map[int32]string{
|
|
0: "COMPRESSION_NONE",
|
|
1: "COMPRESSION_ZSTD",
|
|
}
|
|
MFFileOuter_CompressionType_value = map[string]int32{
|
|
"COMPRESSION_NONE": 0,
|
|
"COMPRESSION_ZSTD": 1,
|
|
}
|
|
)
|
|
|
|
func (x MFFileOuter_CompressionType) Enum() *MFFileOuter_CompressionType {
|
|
p := new(MFFileOuter_CompressionType)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x MFFileOuter_CompressionType) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (MFFileOuter_CompressionType) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_mf_proto_enumTypes[1].Descriptor()
|
|
}
|
|
|
|
func (MFFileOuter_CompressionType) Type() protoreflect.EnumType {
|
|
return &file_mf_proto_enumTypes[1]
|
|
}
|
|
|
|
func (x MFFileOuter_CompressionType) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use MFFileOuter_CompressionType.Descriptor instead.
|
|
func (MFFileOuter_CompressionType) EnumDescriptor() ([]byte, []int) {
|
|
return file_mf_proto_rawDescGZIP(), []int{1, 1}
|
|
}
|
|
|
|
type MFFile_Version int32
|
|
|
|
const (
|
|
MFFile_VERSION_NONE MFFile_Version = 0
|
|
MFFile_VERSION_ONE MFFile_Version = 1 // only one for now
|
|
)
|
|
|
|
// Enum value maps for MFFile_Version.
|
|
var (
|
|
MFFile_Version_name = map[int32]string{
|
|
0: "VERSION_NONE",
|
|
1: "VERSION_ONE",
|
|
}
|
|
MFFile_Version_value = map[string]int32{
|
|
"VERSION_NONE": 0,
|
|
"VERSION_ONE": 1,
|
|
}
|
|
)
|
|
|
|
func (x MFFile_Version) Enum() *MFFile_Version {
|
|
p := new(MFFile_Version)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x MFFile_Version) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (MFFile_Version) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_mf_proto_enumTypes[2].Descriptor()
|
|
}
|
|
|
|
func (MFFile_Version) Type() protoreflect.EnumType {
|
|
return &file_mf_proto_enumTypes[2]
|
|
}
|
|
|
|
func (x MFFile_Version) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use MFFile_Version.Descriptor instead.
|
|
func (MFFile_Version) EnumDescriptor() ([]byte, []int) {
|
|
return file_mf_proto_rawDescGZIP(), []int{4, 0}
|
|
}
|
|
|
|
type Timestamp struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
|
|
Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Timestamp) Reset() {
|
|
*x = Timestamp{}
|
|
mi := &file_mf_proto_msgTypes[0]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Timestamp) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Timestamp) ProtoMessage() {}
|
|
|
|
func (x *Timestamp) ProtoReflect() protoreflect.Message {
|
|
mi := &file_mf_proto_msgTypes[0]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use Timestamp.ProtoReflect.Descriptor instead.
|
|
func (*Timestamp) Descriptor() ([]byte, []int) {
|
|
return file_mf_proto_rawDescGZIP(), []int{0}
|
|
}
|
|
|
|
func (x *Timestamp) GetSeconds() int64 {
|
|
if x != nil {
|
|
return x.Seconds
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Timestamp) GetNanos() int32 {
|
|
if x != nil {
|
|
return x.Nanos
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type MFFileOuter struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// required mffile root attributes 1xx
|
|
Version MFFileOuter_Version `protobuf:"varint,101,opt,name=version,proto3,enum=MFFileOuter_Version" json:"version,omitempty"`
|
|
CompressionType MFFileOuter_CompressionType `protobuf:"varint,102,opt,name=compressionType,proto3,enum=MFFileOuter_CompressionType" json:"compressionType,omitempty"`
|
|
// these are used solely to detect corruption/truncation
|
|
// and not for cryptographic integrity.
|
|
Size int64 `protobuf:"varint,103,opt,name=size,proto3" json:"size,omitempty"`
|
|
Sha256 []byte `protobuf:"bytes,104,opt,name=sha256,proto3" json:"sha256,omitempty"`
|
|
// uuid must match the uuid in the inner message
|
|
Uuid []byte `protobuf:"bytes,105,opt,name=uuid,proto3" json:"uuid,omitempty"`
|
|
InnerMessage []byte `protobuf:"bytes,199,opt,name=innerMessage,proto3" json:"innerMessage,omitempty"`
|
|
// detached signature, ascii or binary
|
|
Signature []byte `protobuf:"bytes,201,opt,name=signature,proto3,oneof" json:"signature,omitempty"`
|
|
// full GPG key id
|
|
Signer []byte `protobuf:"bytes,202,opt,name=signer,proto3,oneof" json:"signer,omitempty"`
|
|
// full GPG signing public key, ascii or binary
|
|
SigningPubKey []byte `protobuf:"bytes,203,opt,name=signingPubKey,proto3,oneof" json:"signingPubKey,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *MFFileOuter) Reset() {
|
|
*x = MFFileOuter{}
|
|
mi := &file_mf_proto_msgTypes[1]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *MFFileOuter) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*MFFileOuter) ProtoMessage() {}
|
|
|
|
func (x *MFFileOuter) ProtoReflect() protoreflect.Message {
|
|
mi := &file_mf_proto_msgTypes[1]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use MFFileOuter.ProtoReflect.Descriptor instead.
|
|
func (*MFFileOuter) Descriptor() ([]byte, []int) {
|
|
return file_mf_proto_rawDescGZIP(), []int{1}
|
|
}
|
|
|
|
func (x *MFFileOuter) GetVersion() MFFileOuter_Version {
|
|
if x != nil {
|
|
return x.Version
|
|
}
|
|
return MFFileOuter_VERSION_NONE
|
|
}
|
|
|
|
func (x *MFFileOuter) GetCompressionType() MFFileOuter_CompressionType {
|
|
if x != nil {
|
|
return x.CompressionType
|
|
}
|
|
return MFFileOuter_COMPRESSION_NONE
|
|
}
|
|
|
|
func (x *MFFileOuter) GetSize() int64 {
|
|
if x != nil {
|
|
return x.Size
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *MFFileOuter) GetSha256() []byte {
|
|
if x != nil {
|
|
return x.Sha256
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *MFFileOuter) GetUuid() []byte {
|
|
if x != nil {
|
|
return x.Uuid
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *MFFileOuter) GetInnerMessage() []byte {
|
|
if x != nil {
|
|
return x.InnerMessage
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *MFFileOuter) GetSignature() []byte {
|
|
if x != nil {
|
|
return x.Signature
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *MFFileOuter) GetSigner() []byte {
|
|
if x != nil {
|
|
return x.Signer
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *MFFileOuter) GetSigningPubKey() []byte {
|
|
if x != nil {
|
|
return x.SigningPubKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type MFFilePath struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// required attributes:
|
|
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
|
|
Size int64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
|
|
// gotta have at least one:
|
|
Hashes []*MFFileChecksum `protobuf:"bytes,3,rep,name=hashes,proto3" json:"hashes,omitempty"`
|
|
// optional per-file metadata
|
|
MimeType *string `protobuf:"bytes,301,opt,name=mimeType,proto3,oneof" json:"mimeType,omitempty"`
|
|
Mtime *Timestamp `protobuf:"bytes,302,opt,name=mtime,proto3,oneof" json:"mtime,omitempty"`
|
|
Ctime *Timestamp `protobuf:"bytes,303,opt,name=ctime,proto3,oneof" json:"ctime,omitempty"`
|
|
Atime *Timestamp `protobuf:"bytes,304,opt,name=atime,proto3,oneof" json:"atime,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *MFFilePath) Reset() {
|
|
*x = MFFilePath{}
|
|
mi := &file_mf_proto_msgTypes[2]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *MFFilePath) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*MFFilePath) ProtoMessage() {}
|
|
|
|
func (x *MFFilePath) ProtoReflect() protoreflect.Message {
|
|
mi := &file_mf_proto_msgTypes[2]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use MFFilePath.ProtoReflect.Descriptor instead.
|
|
func (*MFFilePath) Descriptor() ([]byte, []int) {
|
|
return file_mf_proto_rawDescGZIP(), []int{2}
|
|
}
|
|
|
|
func (x *MFFilePath) GetPath() string {
|
|
if x != nil {
|
|
return x.Path
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *MFFilePath) GetSize() int64 {
|
|
if x != nil {
|
|
return x.Size
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *MFFilePath) GetHashes() []*MFFileChecksum {
|
|
if x != nil {
|
|
return x.Hashes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *MFFilePath) GetMimeType() string {
|
|
if x != nil && x.MimeType != nil {
|
|
return *x.MimeType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *MFFilePath) GetMtime() *Timestamp {
|
|
if x != nil {
|
|
return x.Mtime
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *MFFilePath) GetCtime() *Timestamp {
|
|
if x != nil {
|
|
return x.Ctime
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *MFFilePath) GetAtime() *Timestamp {
|
|
if x != nil {
|
|
return x.Atime
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type MFFileChecksum struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// 1.0 golang implementation must write a multihash here
|
|
// it's ok to only ever use/verify sha256 multihash
|
|
MultiHash []byte `protobuf:"bytes,1,opt,name=multiHash,proto3" json:"multiHash,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *MFFileChecksum) Reset() {
|
|
*x = MFFileChecksum{}
|
|
mi := &file_mf_proto_msgTypes[3]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *MFFileChecksum) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*MFFileChecksum) ProtoMessage() {}
|
|
|
|
func (x *MFFileChecksum) ProtoReflect() protoreflect.Message {
|
|
mi := &file_mf_proto_msgTypes[3]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use MFFileChecksum.ProtoReflect.Descriptor instead.
|
|
func (*MFFileChecksum) Descriptor() ([]byte, []int) {
|
|
return file_mf_proto_rawDescGZIP(), []int{3}
|
|
}
|
|
|
|
func (x *MFFileChecksum) GetMultiHash() []byte {
|
|
if x != nil {
|
|
return x.MultiHash
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type MFFile struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Version MFFile_Version `protobuf:"varint,100,opt,name=version,proto3,enum=MFFile_Version" json:"version,omitempty"`
|
|
// required manifest attributes:
|
|
Files []*MFFilePath `protobuf:"bytes,101,rep,name=files,proto3" json:"files,omitempty"`
|
|
// uuid is a random v4 UUID generated when creating the manifest
|
|
// used as part of the signature to prevent replay attacks
|
|
Uuid []byte `protobuf:"bytes,102,opt,name=uuid,proto3" json:"uuid,omitempty"`
|
|
// optional manifest attributes 2xx:
|
|
CreatedAt *Timestamp `protobuf:"bytes,201,opt,name=createdAt,proto3,oneof" json:"createdAt,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *MFFile) Reset() {
|
|
*x = MFFile{}
|
|
mi := &file_mf_proto_msgTypes[4]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *MFFile) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*MFFile) ProtoMessage() {}
|
|
|
|
func (x *MFFile) ProtoReflect() protoreflect.Message {
|
|
mi := &file_mf_proto_msgTypes[4]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use MFFile.ProtoReflect.Descriptor instead.
|
|
func (*MFFile) Descriptor() ([]byte, []int) {
|
|
return file_mf_proto_rawDescGZIP(), []int{4}
|
|
}
|
|
|
|
func (x *MFFile) GetVersion() MFFile_Version {
|
|
if x != nil {
|
|
return x.Version
|
|
}
|
|
return MFFile_VERSION_NONE
|
|
}
|
|
|
|
func (x *MFFile) GetFiles() []*MFFilePath {
|
|
if x != nil {
|
|
return x.Files
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *MFFile) GetUuid() []byte {
|
|
if x != nil {
|
|
return x.Uuid
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *MFFile) GetCreatedAt() *Timestamp {
|
|
if x != nil {
|
|
return x.CreatedAt
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var File_mf_proto protoreflect.FileDescriptor
|
|
|
|
const file_mf_proto_rawDesc = "" +
|
|
"\n" +
|
|
"\bmf.proto\";\n" +
|
|
"\tTimestamp\x12\x18\n" +
|
|
"\aseconds\x18\x01 \x01(\x03R\aseconds\x12\x14\n" +
|
|
"\x05nanos\x18\x02 \x01(\x05R\x05nanos\"\xf0\x03\n" +
|
|
"\vMFFileOuter\x12.\n" +
|
|
"\aversion\x18e \x01(\x0e2\x14.MFFileOuter.VersionR\aversion\x12F\n" +
|
|
"\x0fcompressionType\x18f \x01(\x0e2\x1c.MFFileOuter.CompressionTypeR\x0fcompressionType\x12\x12\n" +
|
|
"\x04size\x18g \x01(\x03R\x04size\x12\x16\n" +
|
|
"\x06sha256\x18h \x01(\fR\x06sha256\x12\x12\n" +
|
|
"\x04uuid\x18i \x01(\fR\x04uuid\x12#\n" +
|
|
"\finnerMessage\x18\xc7\x01 \x01(\fR\finnerMessage\x12\"\n" +
|
|
"\tsignature\x18\xc9\x01 \x01(\fH\x00R\tsignature\x88\x01\x01\x12\x1c\n" +
|
|
"\x06signer\x18\xca\x01 \x01(\fH\x01R\x06signer\x88\x01\x01\x12*\n" +
|
|
"\rsigningPubKey\x18\xcb\x01 \x01(\fH\x02R\rsigningPubKey\x88\x01\x01\",\n" +
|
|
"\aVersion\x12\x10\n" +
|
|
"\fVERSION_NONE\x10\x00\x12\x0f\n" +
|
|
"\vVERSION_ONE\x10\x01\"=\n" +
|
|
"\x0fCompressionType\x12\x14\n" +
|
|
"\x10COMPRESSION_NONE\x10\x00\x12\x14\n" +
|
|
"\x10COMPRESSION_ZSTD\x10\x01B\f\n" +
|
|
"\n" +
|
|
"_signatureB\t\n" +
|
|
"\a_signerB\x10\n" +
|
|
"\x0e_signingPubKey\"\xa2\x02\n" +
|
|
"\n" +
|
|
"MFFilePath\x12\x12\n" +
|
|
"\x04path\x18\x01 \x01(\tR\x04path\x12\x12\n" +
|
|
"\x04size\x18\x02 \x01(\x03R\x04size\x12'\n" +
|
|
"\x06hashes\x18\x03 \x03(\v2\x0f.MFFileChecksumR\x06hashes\x12 \n" +
|
|
"\bmimeType\x18\xad\x02 \x01(\tH\x00R\bmimeType\x88\x01\x01\x12&\n" +
|
|
"\x05mtime\x18\xae\x02 \x01(\v2\n" +
|
|
".TimestampH\x01R\x05mtime\x88\x01\x01\x12&\n" +
|
|
"\x05ctime\x18\xaf\x02 \x01(\v2\n" +
|
|
".TimestampH\x02R\x05ctime\x88\x01\x01\x12&\n" +
|
|
"\x05atime\x18\xb0\x02 \x01(\v2\n" +
|
|
".TimestampH\x03R\x05atime\x88\x01\x01B\v\n" +
|
|
"\t_mimeTypeB\b\n" +
|
|
"\x06_mtimeB\b\n" +
|
|
"\x06_ctimeB\b\n" +
|
|
"\x06_atime\".\n" +
|
|
"\x0eMFFileChecksum\x12\x1c\n" +
|
|
"\tmultiHash\x18\x01 \x01(\fR\tmultiHash\"\xd6\x01\n" +
|
|
"\x06MFFile\x12)\n" +
|
|
"\aversion\x18d \x01(\x0e2\x0f.MFFile.VersionR\aversion\x12!\n" +
|
|
"\x05files\x18e \x03(\v2\v.MFFilePathR\x05files\x12\x12\n" +
|
|
"\x04uuid\x18f \x01(\fR\x04uuid\x12.\n" +
|
|
"\tcreatedAt\x18\xc9\x01 \x01(\v2\n" +
|
|
".TimestampH\x00R\tcreatedAt\x88\x01\x01\",\n" +
|
|
"\aVersion\x12\x10\n" +
|
|
"\fVERSION_NONE\x10\x00\x12\x0f\n" +
|
|
"\vVERSION_ONE\x10\x01B\f\n" +
|
|
"\n" +
|
|
"_createdAtB\x1dZ\x1bgit.eeqj.de/sneak/mfer/mferb\x06proto3"
|
|
|
|
var (
|
|
file_mf_proto_rawDescOnce sync.Once
|
|
file_mf_proto_rawDescData []byte
|
|
)
|
|
|
|
func file_mf_proto_rawDescGZIP() []byte {
|
|
file_mf_proto_rawDescOnce.Do(func() {
|
|
file_mf_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_mf_proto_rawDesc), len(file_mf_proto_rawDesc)))
|
|
})
|
|
return file_mf_proto_rawDescData
|
|
}
|
|
|
|
var file_mf_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
|
|
var file_mf_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
|
|
var file_mf_proto_goTypes = []any{
|
|
(MFFileOuter_Version)(0), // 0: MFFileOuter.Version
|
|
(MFFileOuter_CompressionType)(0), // 1: MFFileOuter.CompressionType
|
|
(MFFile_Version)(0), // 2: MFFile.Version
|
|
(*Timestamp)(nil), // 3: Timestamp
|
|
(*MFFileOuter)(nil), // 4: MFFileOuter
|
|
(*MFFilePath)(nil), // 5: MFFilePath
|
|
(*MFFileChecksum)(nil), // 6: MFFileChecksum
|
|
(*MFFile)(nil), // 7: MFFile
|
|
}
|
|
var file_mf_proto_depIdxs = []int32{
|
|
0, // 0: MFFileOuter.version:type_name -> MFFileOuter.Version
|
|
1, // 1: MFFileOuter.compressionType:type_name -> MFFileOuter.CompressionType
|
|
6, // 2: MFFilePath.hashes:type_name -> MFFileChecksum
|
|
3, // 3: MFFilePath.mtime:type_name -> Timestamp
|
|
3, // 4: MFFilePath.ctime:type_name -> Timestamp
|
|
3, // 5: MFFilePath.atime:type_name -> Timestamp
|
|
2, // 6: MFFile.version:type_name -> MFFile.Version
|
|
5, // 7: MFFile.files:type_name -> MFFilePath
|
|
3, // 8: MFFile.createdAt:type_name -> Timestamp
|
|
9, // [9:9] is the sub-list for method output_type
|
|
9, // [9:9] is the sub-list for method input_type
|
|
9, // [9:9] is the sub-list for extension type_name
|
|
9, // [9:9] is the sub-list for extension extendee
|
|
0, // [0:9] is the sub-list for field type_name
|
|
}
|
|
|
|
func init() { file_mf_proto_init() }
|
|
func file_mf_proto_init() {
|
|
if File_mf_proto != nil {
|
|
return
|
|
}
|
|
file_mf_proto_msgTypes[1].OneofWrappers = []any{}
|
|
file_mf_proto_msgTypes[2].OneofWrappers = []any{}
|
|
file_mf_proto_msgTypes[4].OneofWrappers = []any{}
|
|
type x struct{}
|
|
out := protoimpl.TypeBuilder{
|
|
File: protoimpl.DescBuilder{
|
|
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
|
RawDescriptor: unsafe.Slice(unsafe.StringData(file_mf_proto_rawDesc), len(file_mf_proto_rawDesc)),
|
|
NumEnums: 3,
|
|
NumMessages: 5,
|
|
NumExtensions: 0,
|
|
NumServices: 0,
|
|
},
|
|
GoTypes: file_mf_proto_goTypes,
|
|
DependencyIndexes: file_mf_proto_depIdxs,
|
|
EnumInfos: file_mf_proto_enumTypes,
|
|
MessageInfos: file_mf_proto_msgTypes,
|
|
}.Build()
|
|
File_mf_proto = out.File
|
|
file_mf_proto_goTypes = nil
|
|
file_mf_proto_depIdxs = nil
|
|
}
|