agent.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: agent/agent.proto

package agentpb

import (
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type InetFamily int32

const (
	InetFamily_AF_UNSPECIFIED InetFamily = 0
	InetFamily_AF_INET        InetFamily = 2
	InetFamily_AF_INET6       InetFamily = 10
)

var InetFamily_name = map[int32]string{
	0:  "AF_UNSPECIFIED",
	2:  "AF_INET",
	10: "AF_INET6",
}

var InetFamily_value = map[string]int32{
	"AF_UNSPECIFIED": 0,
	"AF_INET":        2,
	"AF_INET6":       10,
}

func (x InetFamily) String() string {
	return proto.EnumName(InetFamily_name, int32(x))
}

func (InetFamily) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{0}
}

type RouteScope int32

const (
	RouteScope_SCOPE_UNIVERSE RouteScope = 0
	RouteScope_SCOPE_SITE     RouteScope = 200
	RouteScope_SCOPE_LINK     RouteScope = 253
	RouteScope_SCOPE_HOST     RouteScope = 254
	RouteScope_SCOPE_NOWHERE  RouteScope = 255
)

var RouteScope_name = map[int32]string{
	0:   "SCOPE_UNIVERSE",
	200: "SCOPE_SITE",
	253: "SCOPE_LINK",
	254: "SCOPE_HOST",
	255: "SCOPE_NOWHERE",
}

var RouteScope_value = map[string]int32{
	"SCOPE_UNIVERSE": 0,
	"SCOPE_SITE":     200,
	"SCOPE_LINK":     253,
	"SCOPE_HOST":     254,
	"SCOPE_NOWHERE":  255,
}

func (x RouteScope) String() string {
	return proto.EnumName(RouteScope_name, int32(x))
}

func (RouteScope) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{1}
}

type GuestInfo struct {
	Uname                *GuestInfo_Utsname       `protobuf:"bytes,1,opt,name=uname,proto3" json:"uname,omitempty"`
	Uptime               int64                    `protobuf:"varint,2,opt,name=uptime,proto3" json:"uptime,omitempty"`
	Loadavg              *GuestInfo_LoadAverage   `protobuf:"bytes,3,opt,name=loadavg,proto3" json:"loadavg,omitempty"`
	Mem                  *GuestInfo_MemStat       `protobuf:"bytes,4,opt,name=mem,proto3" json:"mem,omitempty"`
	Swap                 *GuestInfo_SwapStat      `protobuf:"bytes,5,opt,name=swap,proto3" json:"swap,omitempty"`
	Users                []*GuestInfo_LoggedUser  `protobuf:"bytes,6,rep,name=users,proto3" json:"users,omitempty"`
	BlockDevices         []*GuestInfo_BlockDevice `protobuf:"bytes,7,rep,name=block_devices,json=blockDevices,proto3" json:"block_devices,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *GuestInfo) Reset()         { *m = GuestInfo{} }
func (m *GuestInfo) String() string { return proto.CompactTextString(m) }
func (*GuestInfo) ProtoMessage()    {}
func (*GuestInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{0}
}
func (m *GuestInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GuestInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GuestInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GuestInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GuestInfo.Merge(m, src)
}
func (m *GuestInfo) XXX_Size() int {
	return m.Size()
}
func (m *GuestInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_GuestInfo.DiscardUnknown(m)
}

var xxx_messageInfo_GuestInfo proto.InternalMessageInfo

func (m *GuestInfo) GetUname() *GuestInfo_Utsname {
	if m != nil {
		return m.Uname
	}
	return nil
}

func (m *GuestInfo) GetUptime() int64 {
	if m != nil {
		return m.Uptime
	}
	return 0
}

func (m *GuestInfo) GetLoadavg() *GuestInfo_LoadAverage {
	if m != nil {
		return m.Loadavg
	}
	return nil
}

func (m *GuestInfo) GetMem() *GuestInfo_MemStat {
	if m != nil {
		return m.Mem
	}
	return nil
}

func (m *GuestInfo) GetSwap() *GuestInfo_SwapStat {
	if m != nil {
		return m.Swap
	}
	return nil
}

func (m *GuestInfo) GetUsers() []*GuestInfo_LoggedUser {
	if m != nil {
		return m.Users
	}
	return nil
}

func (m *GuestInfo) GetBlockDevices() []*GuestInfo_BlockDevice {
	if m != nil {
		return m.BlockDevices
	}
	return nil
}

type GuestInfo_Utsname struct {
	Sysname              string   `protobuf:"bytes,1,opt,name=sysname,proto3" json:"sysname,omitempty"`
	Nodename             string   `protobuf:"bytes,2,opt,name=nodename,proto3" json:"nodename,omitempty"`
	Release              string   `protobuf:"bytes,3,opt,name=release,proto3" json:"release,omitempty"`
	Version              string   `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
	Machine              string   `protobuf:"bytes,5,opt,name=machine,proto3" json:"machine,omitempty"`
	Domainname           string   `protobuf:"bytes,6,opt,name=domainname,proto3" json:"domainname,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GuestInfo_Utsname) Reset()         { *m = GuestInfo_Utsname{} }
func (m *GuestInfo_Utsname) String() string { return proto.CompactTextString(m) }
func (*GuestInfo_Utsname) ProtoMessage()    {}
func (*GuestInfo_Utsname) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{0, 0}
}
func (m *GuestInfo_Utsname) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GuestInfo_Utsname) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GuestInfo_Utsname.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GuestInfo_Utsname) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GuestInfo_Utsname.Merge(m, src)
}
func (m *GuestInfo_Utsname) XXX_Size() int {
	return m.Size()
}
func (m *GuestInfo_Utsname) XXX_DiscardUnknown() {
	xxx_messageInfo_GuestInfo_Utsname.DiscardUnknown(m)
}

var xxx_messageInfo_GuestInfo_Utsname proto.InternalMessageInfo

func (m *GuestInfo_Utsname) GetSysname() string {
	if m != nil {
		return m.Sysname
	}
	return ""
}

func (m *GuestInfo_Utsname) GetNodename() string {
	if m != nil {
		return m.Nodename
	}
	return ""
}

func (m *GuestInfo_Utsname) GetRelease() string {
	if m != nil {
		return m.Release
	}
	return ""
}

func (m *GuestInfo_Utsname) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *GuestInfo_Utsname) GetMachine() string {
	if m != nil {
		return m.Machine
	}
	return ""
}

func (m *GuestInfo_Utsname) GetDomainname() string {
	if m != nil {
		return m.Domainname
	}
	return ""
}

type GuestInfo_LoadAverage struct {
	One                  float64  `protobuf:"fixed64,1,opt,name=one,proto3" json:"one,omitempty"`
	Five                 float64  `protobuf:"fixed64,2,opt,name=five,proto3" json:"five,omitempty"`
	Fifteen              float64  `protobuf:"fixed64,3,opt,name=fifteen,proto3" json:"fifteen,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GuestInfo_LoadAverage) Reset()         { *m = GuestInfo_LoadAverage{} }
func (m *GuestInfo_LoadAverage) String() string { return proto.CompactTextString(m) }
func (*GuestInfo_LoadAverage) ProtoMessage()    {}
func (*GuestInfo_LoadAverage) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{0, 1}
}
func (m *GuestInfo_LoadAverage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GuestInfo_LoadAverage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GuestInfo_LoadAverage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GuestInfo_LoadAverage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GuestInfo_LoadAverage.Merge(m, src)
}
func (m *GuestInfo_LoadAverage) XXX_Size() int {
	return m.Size()
}
func (m *GuestInfo_LoadAverage) XXX_DiscardUnknown() {
	xxx_messageInfo_GuestInfo_LoadAverage.DiscardUnknown(m)
}

var xxx_messageInfo_GuestInfo_LoadAverage proto.InternalMessageInfo

func (m *GuestInfo_LoadAverage) GetOne() float64 {
	if m != nil {
		return m.One
	}
	return 0
}

func (m *GuestInfo_LoadAverage) GetFive() float64 {
	if m != nil {
		return m.Five
	}
	return 0
}

func (m *GuestInfo_LoadAverage) GetFifteen() float64 {
	if m != nil {
		return m.Fifteen
	}
	return 0
}

type GuestInfo_MemStat struct {
	Total                uint64   `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
	Free                 uint64   `protobuf:"varint,2,opt,name=free,proto3" json:"free,omitempty"`
	Buffers              uint64   `protobuf:"varint,3,opt,name=buffers,proto3" json:"buffers,omitempty"`
	Cached               uint64   `protobuf:"varint,4,opt,name=cached,proto3" json:"cached,omitempty"`
	FreeTotal            uint64   `protobuf:"varint,5,opt,name=free_total,json=freeTotal,proto3" json:"free_total,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GuestInfo_MemStat) Reset()         { *m = GuestInfo_MemStat{} }
func (m *GuestInfo_MemStat) String() string { return proto.CompactTextString(m) }
func (*GuestInfo_MemStat) ProtoMessage()    {}
func (*GuestInfo_MemStat) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{0, 2}
}
func (m *GuestInfo_MemStat) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GuestInfo_MemStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GuestInfo_MemStat.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GuestInfo_MemStat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GuestInfo_MemStat.Merge(m, src)
}
func (m *GuestInfo_MemStat) XXX_Size() int {
	return m.Size()
}
func (m *GuestInfo_MemStat) XXX_DiscardUnknown() {
	xxx_messageInfo_GuestInfo_MemStat.DiscardUnknown(m)
}

var xxx_messageInfo_GuestInfo_MemStat proto.InternalMessageInfo

func (m *GuestInfo_MemStat) GetTotal() uint64 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *GuestInfo_MemStat) GetFree() uint64 {
	if m != nil {
		return m.Free
	}
	return 0
}

func (m *GuestInfo_MemStat) GetBuffers() uint64 {
	if m != nil {
		return m.Buffers
	}
	return 0
}

func (m *GuestInfo_MemStat) GetCached() uint64 {
	if m != nil {
		return m.Cached
	}
	return 0
}

func (m *GuestInfo_MemStat) GetFreeTotal() uint64 {
	if m != nil {
		return m.FreeTotal
	}
	return 0
}

type GuestInfo_SwapStat struct {
	Total                uint64   `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
	Free                 uint64   `protobuf:"varint,2,opt,name=free,proto3" json:"free,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GuestInfo_SwapStat) Reset()         { *m = GuestInfo_SwapStat{} }
func (m *GuestInfo_SwapStat) String() string { return proto.CompactTextString(m) }
func (*GuestInfo_SwapStat) ProtoMessage()    {}
func (*GuestInfo_SwapStat) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{0, 3}
}
func (m *GuestInfo_SwapStat) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GuestInfo_SwapStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GuestInfo_SwapStat.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GuestInfo_SwapStat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GuestInfo_SwapStat.Merge(m, src)
}
func (m *GuestInfo_SwapStat) XXX_Size() int {
	return m.Size()
}
func (m *GuestInfo_SwapStat) XXX_DiscardUnknown() {
	xxx_messageInfo_GuestInfo_SwapStat.DiscardUnknown(m)
}

var xxx_messageInfo_GuestInfo_SwapStat proto.InternalMessageInfo

func (m *GuestInfo_SwapStat) GetTotal() uint64 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *GuestInfo_SwapStat) GetFree() uint64 {
	if m != nil {
		return m.Free
	}
	return 0
}

type GuestInfo_LoggedUser struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Device               string   `protobuf:"bytes,2,opt,name=device,proto3" json:"device,omitempty"`
	Host                 string   `protobuf:"bytes,3,opt,name=host,proto3" json:"host,omitempty"`
	LoginTime            int64    `protobuf:"varint,4,opt,name=login_time,json=loginTime,proto3" json:"login_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GuestInfo_LoggedUser) Reset()         { *m = GuestInfo_LoggedUser{} }
func (m *GuestInfo_LoggedUser) String() string { return proto.CompactTextString(m) }
func (*GuestInfo_LoggedUser) ProtoMessage()    {}
func (*GuestInfo_LoggedUser) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{0, 4}
}
func (m *GuestInfo_LoggedUser) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GuestInfo_LoggedUser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GuestInfo_LoggedUser.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GuestInfo_LoggedUser) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GuestInfo_LoggedUser.Merge(m, src)
}
func (m *GuestInfo_LoggedUser) XXX_Size() int {
	return m.Size()
}
func (m *GuestInfo_LoggedUser) XXX_DiscardUnknown() {
	xxx_messageInfo_GuestInfo_LoggedUser.DiscardUnknown(m)
}

var xxx_messageInfo_GuestInfo_LoggedUser proto.InternalMessageInfo

func (m *GuestInfo_LoggedUser) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *GuestInfo_LoggedUser) GetDevice() string {
	if m != nil {
		return m.Device
	}
	return ""
}

func (m *GuestInfo_LoggedUser) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

func (m *GuestInfo_LoggedUser) GetLoginTime() int64 {
	if m != nil {
		return m.LoginTime
	}
	return 0
}

type GuestInfo_BlockDevice struct {
	Path                 string   `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	IsMounted            bool     `protobuf:"varint,2,opt,name=is_mounted,json=isMounted,proto3" json:"is_mounted,omitempty"`
	MountPoint           string   `protobuf:"bytes,3,opt,name=mount_point,json=mountPoint,proto3" json:"mount_point,omitempty"`
	SizeTotal            int64    `protobuf:"varint,4,opt,name=size_total,json=sizeTotal,proto3" json:"size_total,omitempty"`
	SizeUsed             int64    `protobuf:"varint,5,opt,name=size_used,json=sizeUsed,proto3" json:"size_used,omitempty"`
	SizeAvail            int64    `protobuf:"varint,6,opt,name=size_avail,json=sizeAvail,proto3" json:"size_avail,omitempty"`
	InodesTotal          int64    `protobuf:"varint,7,opt,name=inodes_total,json=inodesTotal,proto3" json:"inodes_total,omitempty"`
	InodesUsed           int64    `protobuf:"varint,8,opt,name=inodes_used,json=inodesUsed,proto3" json:"inodes_used,omitempty"`
	InodesAvail          int64    `protobuf:"varint,9,opt,name=inodes_avail,json=inodesAvail,proto3" json:"inodes_avail,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GuestInfo_BlockDevice) Reset()         { *m = GuestInfo_BlockDevice{} }
func (m *GuestInfo_BlockDevice) String() string { return proto.CompactTextString(m) }
func (*GuestInfo_BlockDevice) ProtoMessage()    {}
func (*GuestInfo_BlockDevice) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{0, 5}
}
func (m *GuestInfo_BlockDevice) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GuestInfo_BlockDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GuestInfo_BlockDevice.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GuestInfo_BlockDevice) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GuestInfo_BlockDevice.Merge(m, src)
}
func (m *GuestInfo_BlockDevice) XXX_Size() int {
	return m.Size()
}
func (m *GuestInfo_BlockDevice) XXX_DiscardUnknown() {
	xxx_messageInfo_GuestInfo_BlockDevice.DiscardUnknown(m)
}

var xxx_messageInfo_GuestInfo_BlockDevice proto.InternalMessageInfo

func (m *GuestInfo_BlockDevice) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *GuestInfo_BlockDevice) GetIsMounted() bool {
	if m != nil {
		return m.IsMounted
	}
	return false
}

func (m *GuestInfo_BlockDevice) GetMountPoint() string {
	if m != nil {
		return m.MountPoint
	}
	return ""
}

func (m *GuestInfo_BlockDevice) GetSizeTotal() int64 {
	if m != nil {
		return m.SizeTotal
	}
	return 0
}

func (m *GuestInfo_BlockDevice) GetSizeUsed() int64 {
	if m != nil {
		return m.SizeUsed
	}
	return 0
}

func (m *GuestInfo_BlockDevice) GetSizeAvail() int64 {
	if m != nil {
		return m.SizeAvail
	}
	return 0
}

func (m *GuestInfo_BlockDevice) GetInodesTotal() int64 {
	if m != nil {
		return m.InodesTotal
	}
	return 0
}

func (m *GuestInfo_BlockDevice) GetInodesUsed() int64 {
	if m != nil {
		return m.InodesUsed
	}
	return 0
}

func (m *GuestInfo_BlockDevice) GetInodesAvail() int64 {
	if m != nil {
		return m.InodesAvail
	}
	return 0
}

type AgentInfo struct {
	Version              string   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	IsLocked             bool     `protobuf:"varint,2,opt,name=is_locked,json=isLocked,proto3" json:"is_locked,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AgentInfo) Reset()         { *m = AgentInfo{} }
func (m *AgentInfo) String() string { return proto.CompactTextString(m) }
func (*AgentInfo) ProtoMessage()    {}
func (*AgentInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{1}
}
func (m *AgentInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentInfo.Merge(m, src)
}
func (m *AgentInfo) XXX_Size() int {
	return m.Size()
}
func (m *AgentInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentInfo.DiscardUnknown(m)
}

var xxx_messageInfo_AgentInfo proto.InternalMessageInfo

func (m *AgentInfo) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *AgentInfo) GetIsLocked() bool {
	if m != nil {
		return m.IsLocked
	}
	return false
}

type RouteListRequest struct {
	Family               InetFamily `protobuf:"varint,1,opt,name=family,proto3,enum=agent.InetFamily" json:"family,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *RouteListRequest) Reset()         { *m = RouteListRequest{} }
func (m *RouteListRequest) String() string { return proto.CompactTextString(m) }
func (*RouteListRequest) ProtoMessage()    {}
func (*RouteListRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{2}
}
func (m *RouteListRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RouteListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RouteListRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RouteListRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RouteListRequest.Merge(m, src)
}
func (m *RouteListRequest) XXX_Size() int {
	return m.Size()
}
func (m *RouteListRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RouteListRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RouteListRequest proto.InternalMessageInfo

func (m *RouteListRequest) GetFamily() InetFamily {
	if m != nil {
		return m.Family
	}
	return InetFamily_AF_UNSPECIFIED
}

type RouteInfo struct {
	LinkIndex            int32      `protobuf:"varint,1,opt,name=link_index,json=linkIndex,proto3" json:"link_index,omitempty"`
	LinkName             string     `protobuf:"bytes,2,opt,name=link_name,json=linkName,proto3" json:"link_name,omitempty"`
	Scope                RouteScope `protobuf:"varint,3,opt,name=scope,proto3,enum=agent.RouteScope" json:"scope,omitempty"`
	Dst                  string     `protobuf:"bytes,4,opt,name=dst,proto3" json:"dst,omitempty"`
	Src                  string     `protobuf:"bytes,5,opt,name=src,proto3" json:"src,omitempty"`
	Gw                   string     `protobuf:"bytes,6,opt,name=gw,proto3" json:"gw,omitempty"`
	Table                int32      `protobuf:"varint,7,opt,name=table,proto3" json:"table,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *RouteInfo) Reset()         { *m = RouteInfo{} }
func (m *RouteInfo) String() string { return proto.CompactTextString(m) }
func (*RouteInfo) ProtoMessage()    {}
func (*RouteInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{3}
}
func (m *RouteInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RouteInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RouteInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RouteInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RouteInfo.Merge(m, src)
}
func (m *RouteInfo) XXX_Size() int {
	return m.Size()
}
func (m *RouteInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_RouteInfo.DiscardUnknown(m)
}

var xxx_messageInfo_RouteInfo proto.InternalMessageInfo

func (m *RouteInfo) GetLinkIndex() int32 {
	if m != nil {
		return m.LinkIndex
	}
	return 0
}

func (m *RouteInfo) GetLinkName() string {
	if m != nil {
		return m.LinkName
	}
	return ""
}

func (m *RouteInfo) GetScope() RouteScope {
	if m != nil {
		return m.Scope
	}
	return RouteScope_SCOPE_UNIVERSE
}

func (m *RouteInfo) GetDst() string {
	if m != nil {
		return m.Dst
	}
	return ""
}

func (m *RouteInfo) GetSrc() string {
	if m != nil {
		return m.Src
	}
	return ""
}

func (m *RouteInfo) GetGw() string {
	if m != nil {
		return m.Gw
	}
	return ""
}

func (m *RouteInfo) GetTable() int32 {
	if m != nil {
		return m.Table
	}
	return 0
}

type RouteList struct {
	Routes               []*RouteInfo `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *RouteList) Reset()         { *m = RouteList{} }
func (m *RouteList) String() string { return proto.CompactTextString(m) }
func (*RouteList) ProtoMessage()    {}
func (*RouteList) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{4}
}
func (m *RouteList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RouteList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RouteList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RouteList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RouteList.Merge(m, src)
}
func (m *RouteList) XXX_Size() int {
	return m.Size()
}
func (m *RouteList) XXX_DiscardUnknown() {
	xxx_messageInfo_RouteList.DiscardUnknown(m)
}

var xxx_messageInfo_RouteList proto.InternalMessageInfo

func (m *RouteList) GetRoutes() []*RouteInfo {
	if m != nil {
		return m.Routes
	}
	return nil
}

type RouteRequest struct {
	LinkName             string     `protobuf:"bytes,1,opt,name=link_name,json=linkName,proto3" json:"link_name,omitempty"`
	Scope                RouteScope `protobuf:"varint,2,opt,name=scope,proto3,enum=agent.RouteScope" json:"scope,omitempty"`
	Dst                  string     `protobuf:"bytes,3,opt,name=dst,proto3" json:"dst,omitempty"`
	Src                  string     `protobuf:"bytes,4,opt,name=src,proto3" json:"src,omitempty"`
	Gw                   string     `protobuf:"bytes,5,opt,name=gw,proto3" json:"gw,omitempty"`
	Table                int32      `protobuf:"varint,6,opt,name=table,proto3" json:"table,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *RouteRequest) Reset()         { *m = RouteRequest{} }
func (m *RouteRequest) String() string { return proto.CompactTextString(m) }
func (*RouteRequest) ProtoMessage()    {}
func (*RouteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{5}
}
func (m *RouteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RouteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RouteRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RouteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RouteRequest.Merge(m, src)
}
func (m *RouteRequest) XXX_Size() int {
	return m.Size()
}
func (m *RouteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RouteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RouteRequest proto.InternalMessageInfo

func (m *RouteRequest) GetLinkName() string {
	if m != nil {
		return m.LinkName
	}
	return ""
}

func (m *RouteRequest) GetScope() RouteScope {
	if m != nil {
		return m.Scope
	}
	return RouteScope_SCOPE_UNIVERSE
}

func (m *RouteRequest) GetDst() string {
	if m != nil {
		return m.Dst
	}
	return ""
}

func (m *RouteRequest) GetSrc() string {
	if m != nil {
		return m.Src
	}
	return ""
}

func (m *RouteRequest) GetGw() string {
	if m != nil {
		return m.Gw
	}
	return ""
}

func (m *RouteRequest) GetTable() int32 {
	if m != nil {
		return m.Table
	}
	return 0
}

type InterfaceInfo struct {
	Index                int32    `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	HwAddr               string   `protobuf:"bytes,3,opt,name=hw_addr,json=hwAddr,proto3" json:"hw_addr,omitempty"`
	Flags                uint32   `protobuf:"varint,4,opt,name=flags,proto3" json:"flags,omitempty"`
	MTU                  int32    `protobuf:"varint,5,opt,name=mtu,proto3" json:"mtu,omitempty"`
	Addrs                []string `protobuf:"bytes,6,rep,name=addrs,proto3" json:"addrs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *InterfaceInfo) Reset()         { *m = InterfaceInfo{} }
func (m *InterfaceInfo) String() string { return proto.CompactTextString(m) }
func (*InterfaceInfo) ProtoMessage()    {}
func (*InterfaceInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{6}
}
func (m *InterfaceInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InterfaceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InterfaceInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InterfaceInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InterfaceInfo.Merge(m, src)
}
func (m *InterfaceInfo) XXX_Size() int {
	return m.Size()
}
func (m *InterfaceInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_InterfaceInfo.DiscardUnknown(m)
}

var xxx_messageInfo_InterfaceInfo proto.InternalMessageInfo

func (m *InterfaceInfo) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *InterfaceInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *InterfaceInfo) GetHwAddr() string {
	if m != nil {
		return m.HwAddr
	}
	return ""
}

func (m *InterfaceInfo) GetFlags() uint32 {
	if m != nil {
		return m.Flags
	}
	return 0
}

func (m *InterfaceInfo) GetMTU() int32 {
	if m != nil {
		return m.MTU
	}
	return 0
}

func (m *InterfaceInfo) GetAddrs() []string {
	if m != nil {
		return m.Addrs
	}
	return nil
}

type InterfaceList struct {
	Interfaces           []*InterfaceInfo `protobuf:"bytes,1,rep,name=interfaces,proto3" json:"interfaces,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *InterfaceList) Reset()         { *m = InterfaceList{} }
func (m *InterfaceList) String() string { return proto.CompactTextString(m) }
func (*InterfaceList) ProtoMessage()    {}
func (*InterfaceList) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{7}
}
func (m *InterfaceList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InterfaceList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InterfaceList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InterfaceList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InterfaceList.Merge(m, src)
}
func (m *InterfaceList) XXX_Size() int {
	return m.Size()
}
func (m *InterfaceList) XXX_DiscardUnknown() {
	xxx_messageInfo_InterfaceList.DiscardUnknown(m)
}

var xxx_messageInfo_InterfaceList proto.InternalMessageInfo

func (m *InterfaceList) GetInterfaces() []*InterfaceInfo {
	if m != nil {
		return m.Interfaces
	}
	return nil
}

type LinkNameRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LinkNameRequest) Reset()         { *m = LinkNameRequest{} }
func (m *LinkNameRequest) String() string { return proto.CompactTextString(m) }
func (*LinkNameRequest) ProtoMessage()    {}
func (*LinkNameRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{8}
}
func (m *LinkNameRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LinkNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LinkNameRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LinkNameRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LinkNameRequest.Merge(m, src)
}
func (m *LinkNameRequest) XXX_Size() int {
	return m.Size()
}
func (m *LinkNameRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LinkNameRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LinkNameRequest proto.InternalMessageInfo

func (m *LinkNameRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type IPAddrRequest struct {
	LinkName             string   `protobuf:"bytes,1,opt,name=link_name,json=linkName,proto3" json:"link_name,omitempty"`
	Addr                 string   `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IPAddrRequest) Reset()         { *m = IPAddrRequest{} }
func (m *IPAddrRequest) String() string { return proto.CompactTextString(m) }
func (*IPAddrRequest) ProtoMessage()    {}
func (*IPAddrRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{9}
}
func (m *IPAddrRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IPAddrRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IPAddrRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IPAddrRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IPAddrRequest.Merge(m, src)
}
func (m *IPAddrRequest) XXX_Size() int {
	return m.Size()
}
func (m *IPAddrRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_IPAddrRequest.DiscardUnknown(m)
}

var xxx_messageInfo_IPAddrRequest proto.InternalMessageInfo

func (m *IPAddrRequest) GetLinkName() string {
	if m != nil {
		return m.LinkName
	}
	return ""
}

func (m *IPAddrRequest) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

type FileRequest struct {
	Path                 string   `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Owner                string   `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
	Group                string   `protobuf:"bytes,3,opt,name=group,proto3" json:"group,omitempty"`
	Mode                 uint32   `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FileRequest) Reset()         { *m = FileRequest{} }
func (m *FileRequest) String() string { return proto.CompactTextString(m) }
func (*FileRequest) ProtoMessage()    {}
func (*FileRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{10}
}
func (m *FileRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FileRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileRequest.Merge(m, src)
}
func (m *FileRequest) XXX_Size() int {
	return m.Size()
}
func (m *FileRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FileRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FileRequest proto.InternalMessageInfo

func (m *FileRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *FileRequest) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *FileRequest) GetGroup() string {
	if m != nil {
		return m.Group
	}
	return ""
}

func (m *FileRequest) GetMode() uint32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

type FileStatRequest struct {
	Path                 string   `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	WithDirContent       bool     `protobuf:"varint,2,opt,name=with_dir_content,json=withDirContent,proto3" json:"with_dir_content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FileStatRequest) Reset()         { *m = FileStatRequest{} }
func (m *FileStatRequest) String() string { return proto.CompactTextString(m) }
func (*FileStatRequest) ProtoMessage()    {}
func (*FileStatRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{11}
}
func (m *FileStatRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileStatRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileStatRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FileStatRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileStatRequest.Merge(m, src)
}
func (m *FileStatRequest) XXX_Size() int {
	return m.Size()
}
func (m *FileStatRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FileStatRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FileStatRequest proto.InternalMessageInfo

func (m *FileStatRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *FileStatRequest) GetWithDirContent() bool {
	if m != nil {
		return m.WithDirContent
	}
	return false
}

type FileMD5Hash struct {
	Hash                 string   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FileMD5Hash) Reset()         { *m = FileMD5Hash{} }
func (m *FileMD5Hash) String() string { return proto.CompactTextString(m) }
func (*FileMD5Hash) ProtoMessage()    {}
func (*FileMD5Hash) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{12}
}
func (m *FileMD5Hash) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileMD5Hash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileMD5Hash.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FileMD5Hash) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileMD5Hash.Merge(m, src)
}
func (m *FileMD5Hash) XXX_Size() int {
	return m.Size()
}
func (m *FileMD5Hash) XXX_DiscardUnknown() {
	xxx_messageInfo_FileMD5Hash.DiscardUnknown(m)
}

var xxx_messageInfo_FileMD5Hash proto.InternalMessageInfo

func (m *FileMD5Hash) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

type FileStat struct {
	Name                 string          `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Mode                 uint32          `protobuf:"varint,2,opt,name=mode,proto3" json:"mode,omitempty"`
	IsDir                bool            `protobuf:"varint,3,opt,name=is_dir,json=isDir,proto3" json:"is_dir,omitempty"`
	Owner                *FileStat_Owner `protobuf:"bytes,4,opt,name=owner,proto3" json:"owner,omitempty"`
	Group                *FileStat_Group `protobuf:"bytes,5,opt,name=group,proto3" json:"group,omitempty"`
	SizeBytes            int64           `protobuf:"varint,6,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *FileStat) Reset()         { *m = FileStat{} }
func (m *FileStat) String() string { return proto.CompactTextString(m) }
func (*FileStat) ProtoMessage()    {}
func (*FileStat) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{13}
}
func (m *FileStat) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileStat.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FileStat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileStat.Merge(m, src)
}
func (m *FileStat) XXX_Size() int {
	return m.Size()
}
func (m *FileStat) XXX_DiscardUnknown() {
	xxx_messageInfo_FileStat.DiscardUnknown(m)
}

var xxx_messageInfo_FileStat proto.InternalMessageInfo

func (m *FileStat) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *FileStat) GetMode() uint32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

func (m *FileStat) GetIsDir() bool {
	if m != nil {
		return m.IsDir
	}
	return false
}

func (m *FileStat) GetOwner() *FileStat_Owner {
	if m != nil {
		return m.Owner
	}
	return nil
}

func (m *FileStat) GetGroup() *FileStat_Group {
	if m != nil {
		return m.Group
	}
	return nil
}

func (m *FileStat) GetSizeBytes() int64 {
	if m != nil {
		return m.SizeBytes
	}
	return 0
}

type FileStat_Owner struct {
	Uid                  uint32   `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FileStat_Owner) Reset()         { *m = FileStat_Owner{} }
func (m *FileStat_Owner) String() string { return proto.CompactTextString(m) }
func (*FileStat_Owner) ProtoMessage()    {}
func (*FileStat_Owner) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{13, 0}
}
func (m *FileStat_Owner) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileStat_Owner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileStat_Owner.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FileStat_Owner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileStat_Owner.Merge(m, src)
}
func (m *FileStat_Owner) XXX_Size() int {
	return m.Size()
}
func (m *FileStat_Owner) XXX_DiscardUnknown() {
	xxx_messageInfo_FileStat_Owner.DiscardUnknown(m)
}

var xxx_messageInfo_FileStat_Owner proto.InternalMessageInfo

func (m *FileStat_Owner) GetUid() uint32 {
	if m != nil {
		return m.Uid
	}
	return 0
}

func (m *FileStat_Owner) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type FileStat_Group struct {
	Gid                  uint32   `protobuf:"varint,1,opt,name=gid,proto3" json:"gid,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FileStat_Group) Reset()         { *m = FileStat_Group{} }
func (m *FileStat_Group) String() string { return proto.CompactTextString(m) }
func (*FileStat_Group) ProtoMessage()    {}
func (*FileStat_Group) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{13, 1}
}
func (m *FileStat_Group) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileStat_Group) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileStat_Group.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FileStat_Group) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileStat_Group.Merge(m, src)
}
func (m *FileStat_Group) XXX_Size() int {
	return m.Size()
}
func (m *FileStat_Group) XXX_DiscardUnknown() {
	xxx_messageInfo_FileStat_Group.DiscardUnknown(m)
}

var xxx_messageInfo_FileStat_Group proto.InternalMessageInfo

func (m *FileStat_Group) GetGid() uint32 {
	if m != nil {
		return m.Gid
	}
	return 0
}

func (m *FileStat_Group) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type FileStatList struct {
	Files                []*FileStat `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *FileStatList) Reset()         { *m = FileStatList{} }
func (m *FileStatList) String() string { return proto.CompactTextString(m) }
func (*FileStatList) ProtoMessage()    {}
func (*FileStatList) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{14}
}
func (m *FileStatList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileStatList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileStatList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FileStatList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileStatList.Merge(m, src)
}
func (m *FileStatList) XXX_Size() int {
	return m.Size()
}
func (m *FileStatList) XXX_DiscardUnknown() {
	xxx_messageInfo_FileStatList.DiscardUnknown(m)
}

var xxx_messageInfo_FileStatList proto.InternalMessageInfo

func (m *FileStatList) GetFiles() []*FileStat {
	if m != nil {
		return m.Files
	}
	return nil
}

type UploadFileRequest struct {
	// Types that are valid to be assigned to Data:
	//	*UploadFileRequest_Info
	//	*UploadFileRequest_ChunkData
	Data                 isUploadFileRequest_Data `protobuf_oneof:"data"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *UploadFileRequest) Reset()         { *m = UploadFileRequest{} }
func (m *UploadFileRequest) String() string { return proto.CompactTextString(m) }
func (*UploadFileRequest) ProtoMessage()    {}
func (*UploadFileRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{15}
}
func (m *UploadFileRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UploadFileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UploadFileRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UploadFileRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UploadFileRequest.Merge(m, src)
}
func (m *UploadFileRequest) XXX_Size() int {
	return m.Size()
}
func (m *UploadFileRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UploadFileRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UploadFileRequest proto.InternalMessageInfo

type isUploadFileRequest_Data interface {
	isUploadFileRequest_Data()
	MarshalTo([]byte) (int, error)
	Size() int
}

type UploadFileRequest_Info struct {
	Info *UploadFileRequest_FileInfo `protobuf:"bytes,1,opt,name=info,proto3,oneof" json:"info,omitempty"`
}
type UploadFileRequest_ChunkData struct {
	ChunkData []byte `protobuf:"bytes,2,opt,name=chunk_data,json=chunkData,proto3,oneof" json:"chunk_data,omitempty"`
}

func (*UploadFileRequest_Info) isUploadFileRequest_Data()      {}
func (*UploadFileRequest_ChunkData) isUploadFileRequest_Data() {}

func (m *UploadFileRequest) GetData() isUploadFileRequest_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *UploadFileRequest) GetInfo() *UploadFileRequest_FileInfo {
	if x, ok := m.GetData().(*UploadFileRequest_Info); ok {
		return x.Info
	}
	return nil
}

func (m *UploadFileRequest) GetChunkData() []byte {
	if x, ok := m.GetData().(*UploadFileRequest_ChunkData); ok {
		return x.ChunkData
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*UploadFileRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*UploadFileRequest_Info)(nil),
		(*UploadFileRequest_ChunkData)(nil),
	}
}

type UploadFileRequest_FileInfo struct {
	Path                 string   `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UploadFileRequest_FileInfo) Reset()         { *m = UploadFileRequest_FileInfo{} }
func (m *UploadFileRequest_FileInfo) String() string { return proto.CompactTextString(m) }
func (*UploadFileRequest_FileInfo) ProtoMessage()    {}
func (*UploadFileRequest_FileInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{15, 0}
}
func (m *UploadFileRequest_FileInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UploadFileRequest_FileInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UploadFileRequest_FileInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UploadFileRequest_FileInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UploadFileRequest_FileInfo.Merge(m, src)
}
func (m *UploadFileRequest_FileInfo) XXX_Size() int {
	return m.Size()
}
func (m *UploadFileRequest_FileInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_UploadFileRequest_FileInfo.DiscardUnknown(m)
}

var xxx_messageInfo_UploadFileRequest_FileInfo proto.InternalMessageInfo

func (m *UploadFileRequest_FileInfo) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

type FileContent struct {
	ChunkData            []byte   `protobuf:"bytes,1,opt,name=chunk_data,json=chunkData,proto3" json:"chunk_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FileContent) Reset()         { *m = FileContent{} }
func (m *FileContent) String() string { return proto.CompactTextString(m) }
func (*FileContent) ProtoMessage()    {}
func (*FileContent) Descriptor() ([]byte, []int) {
	return fileDescriptor_253ddf9934d56132, []int{16}
}
func (m *FileContent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileContent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FileContent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileContent.Merge(m, src)
}
func (m *FileContent) XXX_Size() int {
	return m.Size()
}
func (m *FileContent) XXX_DiscardUnknown() {
	xxx_messageInfo_FileContent.DiscardUnknown(m)
}

var xxx_messageInfo_FileContent proto.InternalMessageInfo

func (m *FileContent) GetChunkData() []byte {
	if m != nil {
		return m.ChunkData
	}
	return nil
}

func init() {
	proto.RegisterEnum("agent.InetFamily", InetFamily_name, InetFamily_value)
	proto.RegisterEnum("agent.RouteScope", RouteScope_name, RouteScope_value)
	proto.RegisterType((*GuestInfo)(nil), "agent.GuestInfo")
	proto.RegisterType((*GuestInfo_Utsname)(nil), "agent.GuestInfo.Utsname")
	proto.RegisterType((*GuestInfo_LoadAverage)(nil), "agent.GuestInfo.LoadAverage")
	proto.RegisterType((*GuestInfo_MemStat)(nil), "agent.GuestInfo.MemStat")
	proto.RegisterType((*GuestInfo_SwapStat)(nil), "agent.GuestInfo.SwapStat")
	proto.RegisterType((*GuestInfo_LoggedUser)(nil), "agent.GuestInfo.LoggedUser")
	proto.RegisterType((*GuestInfo_BlockDevice)(nil), "agent.GuestInfo.BlockDevice")
	proto.RegisterType((*AgentInfo)(nil), "agent.AgentInfo")
	proto.RegisterType((*RouteListRequest)(nil), "agent.RouteListRequest")
	proto.RegisterType((*RouteInfo)(nil), "agent.RouteInfo")
	proto.RegisterType((*RouteList)(nil), "agent.RouteList")
	proto.RegisterType((*RouteRequest)(nil), "agent.RouteRequest")
	proto.RegisterType((*InterfaceInfo)(nil), "agent.InterfaceInfo")
	proto.RegisterType((*InterfaceList)(nil), "agent.InterfaceList")
	proto.RegisterType((*LinkNameRequest)(nil), "agent.LinkNameRequest")
	proto.RegisterType((*IPAddrRequest)(nil), "agent.IPAddrRequest")
	proto.RegisterType((*FileRequest)(nil), "agent.FileRequest")
	proto.RegisterType((*FileStatRequest)(nil), "agent.FileStatRequest")
	proto.RegisterType((*FileMD5Hash)(nil), "agent.FileMD5Hash")
	proto.RegisterType((*FileStat)(nil), "agent.FileStat")
	proto.RegisterType((*FileStat_Owner)(nil), "agent.FileStat.Owner")
	proto.RegisterType((*FileStat_Group)(nil), "agent.FileStat.Group")
	proto.RegisterType((*FileStatList)(nil), "agent.FileStatList")
	proto.RegisterType((*UploadFileRequest)(nil), "agent.UploadFileRequest")
	proto.RegisterType((*UploadFileRequest_FileInfo)(nil), "agent.UploadFileRequest.FileInfo")
	proto.RegisterType((*FileContent)(nil), "agent.FileContent")
}

func init() { proto.RegisterFile("agent/agent.proto", fileDescriptor_253ddf9934d56132) }

var fileDescriptor_253ddf9934d56132 = []byte{
	// 1712 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x5f, 0x8f, 0x1a, 0xc9,
	0x11, 0x67, 0x80, 0x01, 0xa6, 0x60, 0xd7, 0xb8, 0xbd, 0x67, 0x73, 0x38, 0x59, 0xdb, 0x23, 0x9d,
	0xb2, 0xf1, 0xc5, 0x38, 0xb1, 0xcf, 0x17, 0xe5, 0x7c, 0x51, 0xc2, 0x1a, 0x76, 0x17, 0x65, 0xff,
	0x58, 0xcd, 0x92, 0x48, 0x79, 0x41, 0x03, 0xd3, 0x0c, 0x23, 0xc3, 0x0c, 0x99, 0x1e, 0x96, 0xec,
	0x3d, 0xe7, 0x2b, 0xe4, 0x21, 0x2f, 0x51, 0xa4, 0x3c, 0x46, 0xf9, 0x02, 0xf9, 0x04, 0xf7, 0x98,
	0x4f, 0x10, 0x45, 0xfe, 0x1e, 0x97, 0x44, 0x55, 0xdd, 0x03, 0xe3, 0x5d, 0xf0, 0x79, 0x4f, 0x79,
	0x41, 0x5d, 0xbf, 0xfa, 0x5f, 0x5d, 0x55, 0xd3, 0xc0, 0x6d, 0xc7, 0x13, 0x41, 0xfc, 0x94, 0x7e,
	0x1b, 0xb3, 0x28, 0x8c, 0x43, 0x66, 0x12, 0x51, 0xbf, 0xef, 0x85, 0xa1, 0x37, 0x11, 0x4f, 0x09,
	0x1c, 0xcc, 0x47, 0x4f, 0xc5, 0x74, 0x16, 0x5f, 0x2a, 0x99, 0xfa, 0x13, 0xcf, 0x8f, 0xc7, 0xf3,
	0x41, 0x63, 0x18, 0x4e, 0x9f, 0x7a, 0xa1, 0x17, 0xae, 0xa4, 0x90, 0x22, 0x82, 0x4e, 0x4a, 0xdc,
	0xfe, 0x9b, 0x05, 0xd6, 0xe1, 0x5c, 0xc8, 0xb8, 0x13, 0x8c, 0x42, 0xd6, 0x00, 0x73, 0x1e, 0x38,
	0x53, 0x51, 0x33, 0x1e, 0x1a, 0x7b, 0xe5, 0x67, 0xb5, 0x86, 0xf2, 0xbe, 0x14, 0x68, 0xf4, 0x62,
	0x89, 0x7c, 0xae, 0xc4, 0xd8, 0x5d, 0x28, 0xcc, 0x67, 0xb1, 0x3f, 0x15, 0xb5, 0xec, 0x43, 0x63,
	0x2f, 0xc7, 0x35, 0xc5, 0x3e, 0x87, 0xe2, 0x24, 0x74, 0x5c, 0xe7, 0xc2, 0xab, 0xe5, 0xc8, 0xd2,
	0xf7, 0xae, 0x59, 0x3a, 0x0e, 0x1d, 0xb7, 0x79, 0x21, 0x22, 0xc7, 0x13, 0x3c, 0x11, 0x66, 0x8f,
	0x21, 0x37, 0x15, 0xd3, 0x5a, 0x7e, 0x83, 0xf7, 0x13, 0x31, 0xed, 0xc6, 0x4e, 0xcc, 0x51, 0x88,
	0x3d, 0x81, 0xbc, 0x5c, 0x38, 0xb3, 0x9a, 0x49, 0xc2, 0x1f, 0x5f, 0x13, 0xee, 0x2e, 0x9c, 0x19,
	0x49, 0x93, 0x18, 0xfb, 0x09, 0x98, 0x73, 0x29, 0x22, 0x59, 0x2b, 0x3c, 0xcc, 0xed, 0x95, 0x9f,
	0xdd, 0x5f, 0x13, 0x90, 0xe7, 0x09, 0xb7, 0x27, 0x45, 0xc4, 0x95, 0x24, 0x6b, 0xc2, 0xd6, 0x60,
	0x12, 0x0e, 0xdf, 0xf4, 0x5d, 0x71, 0xe1, 0x0f, 0x85, 0xac, 0x15, 0x49, 0xf5, 0x7a, 0x2e, 0xfb,
	0x28, 0xd5, 0x22, 0x21, 0x5e, 0x19, 0xac, 0x08, 0x59, 0xff, 0xbb, 0x01, 0x45, 0x5d, 0x33, 0x56,
	0x83, 0xa2, 0xbc, 0x94, 0xcb, 0xf2, 0x5a, 0x3c, 0x21, 0x59, 0x1d, 0x4a, 0x41, 0xe8, 0x0a, 0x62,
	0x65, 0x89, 0xb5, 0xa4, 0x51, 0x2b, 0x12, 0x13, 0xe1, 0x48, 0x41, 0xa5, 0xb4, 0x78, 0x42, 0x22,
	0xe7, 0x42, 0x44, 0xd2, 0x0f, 0x03, 0x2a, 0x98, 0xc5, 0x13, 0x12, 0x39, 0x53, 0x67, 0x38, 0xf6,
	0x03, 0x41, 0xd5, 0xb1, 0x78, 0x42, 0xb2, 0x5d, 0x00, 0x37, 0x9c, 0x3a, 0x7e, 0x40, 0xbe, 0x0a,
	0xc4, 0x4c, 0x21, 0xf5, 0x13, 0x28, 0xa7, 0x2e, 0x86, 0x55, 0x21, 0x17, 0x06, 0x2a, 0x5c, 0x83,
	0xe3, 0x91, 0x31, 0xc8, 0x8f, 0xfc, 0x0b, 0x15, 0xa6, 0xc1, 0xe9, 0x8c, 0xee, 0x46, 0xfe, 0x28,
	0x16, 0x22, 0xa0, 0x10, 0x0d, 0x9e, 0x90, 0xf5, 0x3f, 0x18, 0x50, 0xd4, 0x97, 0xc6, 0x76, 0xc0,
	0x8c, 0xc3, 0xd8, 0x99, 0x90, 0xb5, 0x3c, 0x57, 0x04, 0xd9, 0x8b, 0x84, 0xb2, 0x97, 0xe7, 0x74,
	0x46, 0x7b, 0x83, 0xf9, 0x68, 0x84, 0x97, 0x95, 0x23, 0x38, 0x21, 0xb1, 0xdf, 0x86, 0xce, 0x70,
	0x2c, 0x5c, 0xca, 0x38, 0xcf, 0x35, 0xc5, 0xbe, 0x0f, 0x80, 0x9a, 0x7d, 0xe5, 0xc0, 0x24, 0x9e,
	0x85, 0xc8, 0x39, 0x02, 0xf5, 0xcf, 0xa0, 0x94, 0x74, 0xc3, 0x87, 0x87, 0x51, 0x7f, 0x03, 0xb0,
	0xea, 0x09, 0x94, 0x48, 0x5d, 0x5d, 0x3e, 0x69, 0x7f, 0xd5, 0x1a, 0xfa, 0xd6, 0x34, 0x85, 0xb2,
	0xe3, 0x50, 0xc6, 0xfa, 0xc2, 0xe8, 0x8c, 0x21, 0x4e, 0x42, 0xcf, 0x0f, 0xfa, 0x34, 0x2e, 0x79,
	0x1a, 0x17, 0x8b, 0x90, 0x73, 0x7f, 0x2a, 0xea, 0x7f, 0xcd, 0x42, 0x39, 0xd5, 0x46, 0x68, 0x62,
	0xe6, 0xc4, 0xe3, 0xc4, 0x1d, 0x9e, 0xd1, 0x84, 0x2f, 0xfb, 0xd3, 0x70, 0x1e, 0xc4, 0xc2, 0x25,
	0x97, 0x25, 0x6e, 0xf9, 0xf2, 0x44, 0x01, 0xec, 0x01, 0x94, 0x89, 0xd7, 0x9f, 0x85, 0x7e, 0x90,
	0x38, 0x07, 0x82, 0x5e, 0x23, 0x82, 0xfa, 0xd2, 0xff, 0x2a, 0xa9, 0x92, 0x0e, 0x01, 0x11, 0xaa,
	0x12, 0xbb, 0x0f, 0x44, 0xf4, 0xe7, 0x52, 0xb8, 0x54, 0xc3, 0x1c, 0x2f, 0x21, 0xd0, 0x93, 0xaa,
	0xc2, 0xc4, 0x74, 0x2e, 0x1c, 0x7f, 0x42, 0x8d, 0xa3, 0x75, 0x9b, 0x08, 0xb0, 0x47, 0x50, 0xf1,
	0xb1, 0x65, 0xa5, 0x36, 0x5e, 0x24, 0x81, 0xb2, 0xc2, 0x94, 0xf9, 0x07, 0xa0, 0x49, 0xe5, 0xa0,
	0x44, 0x12, 0xa0, 0x20, 0x72, 0xb1, 0xb2, 0xa1, 0x9c, 0x58, 0x69, 0x1b, 0xe4, 0xc6, 0xde, 0x07,
	0xab, 0x89, 0xb3, 0x47, 0xcb, 0x2a, 0xd5, 0xff, 0xc6, 0xbb, 0xfd, 0x7f, 0x1f, 0x2c, 0x5f, 0xf6,
	0xb1, 0x9a, 0xcb, 0x3a, 0x95, 0x7c, 0x79, 0x4c, 0xb4, 0xfd, 0x73, 0xa8, 0xf2, 0x70, 0x1e, 0x8b,
	0x63, 0x5f, 0xc6, 0x5c, 0xfc, 0x0e, 0x87, 0x98, 0xfd, 0x10, 0x0a, 0x23, 0x67, 0xea, 0x4f, 0x2e,
	0xc9, 0xd2, 0xf6, 0xb3, 0xdb, 0x7a, 0xc4, 0x3b, 0x81, 0x88, 0x0f, 0x88, 0xc1, 0xb5, 0x80, 0xfd,
	0x0f, 0x03, 0x2c, 0xd2, 0xa7, 0x18, 0xf0, 0x56, 0xfd, 0xe0, 0x4d, 0xdf, 0x0f, 0x5c, 0xf1, 0x7b,
	0x52, 0x36, 0xb9, 0x85, 0x48, 0x07, 0x01, 0x0c, 0x84, 0xd8, 0xe9, 0xc9, 0x46, 0xe0, 0x14, 0xbb,
	0xe7, 0x07, 0x60, 0xca, 0x61, 0x38, 0x53, 0x73, 0xbd, 0xf2, 0x49, 0xc6, 0xbb, 0xc8, 0xe0, 0x8a,
	0x8f, 0x53, 0xe8, 0xca, 0x58, 0x0f, 0x39, 0x1e, 0x11, 0x91, 0xd1, 0x50, 0x0f, 0x37, 0x1e, 0xd9,
	0x36, 0x64, 0xbd, 0x85, 0x1e, 0xe8, 0xac, 0xb7, 0xa0, 0x36, 0x77, 0x06, 0x13, 0x41, 0x37, 0x61,
	0x72, 0x45, 0xd8, 0x2f, 0x74, 0xec, 0x98, 0x3b, 0xdb, 0x83, 0x42, 0x84, 0x84, 0xac, 0x19, 0xb4,
	0xd7, 0xaa, 0xe9, 0x00, 0x30, 0x3b, 0xae, 0xf9, 0xf6, 0x9f, 0x0d, 0xa8, 0x10, 0x9a, 0xd4, 0xeb,
	0x9d, 0xbc, 0x8c, 0x4d, 0x79, 0x65, 0x3f, 0x2c, 0xaf, 0xdc, 0xb5, 0xbc, 0xf2, 0x57, 0xf3, 0x32,
	0xaf, 0xe7, 0x55, 0x48, 0xe7, 0xf5, 0x27, 0x03, 0xb6, 0x3a, 0x41, 0x2c, 0xa2, 0x91, 0x33, 0x54,
	0x17, 0xb3, 0x03, 0x66, 0xfa, 0x4e, 0x14, 0xb1, 0x1c, 0xe2, 0x6c, 0x6a, 0x88, 0xef, 0x41, 0x71,
	0xbc, 0xe8, 0x3b, 0xae, 0x1b, 0xe9, 0x48, 0x0a, 0xe3, 0x45, 0xd3, 0x75, 0x23, 0x34, 0x31, 0x9a,
	0x38, 0x9e, 0xa4, 0x70, 0xb6, 0xb8, 0x22, 0xd8, 0xc7, 0x90, 0x9b, 0xc6, 0x73, 0x8a, 0xc8, 0xdc,
	0x2f, 0xbe, 0xfd, 0xd7, 0x83, 0xdc, 0xc9, 0x79, 0x8f, 0x23, 0x86, 0x0a, 0x68, 0x46, 0x7d, 0x62,
	0x2c, 0xae, 0x08, 0xbb, 0x9d, 0x0a, 0x8d, 0xea, 0xfe, 0x19, 0x80, 0x9f, 0x00, 0x49, 0xed, 0x77,
	0x96, 0x0d, 0x97, 0x4a, 0x82, 0xa7, 0xe4, 0xec, 0x4f, 0xe0, 0xd6, 0xb1, 0xae, 0x70, 0x72, 0x0b,
	0x6b, 0x56, 0x92, 0xfd, 0x4b, 0xd8, 0xea, 0xbc, 0xc6, 0xf0, 0x3f, 0xe8, 0xaa, 0x18, 0xe4, 0x29,
	0x71, 0x5d, 0x0f, 0x3c, 0xdb, 0x0e, 0x94, 0x0f, 0xfc, 0x49, 0xda, 0xc9, 0xb5, 0x45, 0xb4, 0x03,
	0x66, 0xb8, 0x08, 0x44, 0xa2, 0xa7, 0x08, 0x44, 0xbd, 0x28, 0x9c, 0xcf, 0x74, 0x19, 0x15, 0x81,
	0xfa, 0xd3, 0xd0, 0x15, 0xba, 0x88, 0x74, 0xb6, 0xcf, 0xe0, 0x16, 0xba, 0xa0, 0xaf, 0xf3, 0x7b,
	0xdc, 0xec, 0x41, 0x75, 0xe1, 0xc7, 0xe3, 0xbe, 0xeb, 0x47, 0xfd, 0x61, 0x18, 0xc4, 0x22, 0x88,
	0xf5, 0x34, 0x6f, 0x23, 0xde, 0xf2, 0xa3, 0x57, 0x0a, 0xb5, 0x1f, 0xa9, 0x98, 0x4f, 0x5a, 0x2f,
	0x8e, 0x1c, 0x39, 0xa6, 0xfd, 0xeb, 0xc8, 0xa5, 0x31, 0x3c, 0xdb, 0x7f, 0xc9, 0x42, 0x29, 0x71,
	0xba, 0x76, 0x99, 0x27, 0x81, 0x66, 0x57, 0x81, 0xb2, 0x8f, 0xa0, 0xe0, 0x4b, 0xf4, 0x4f, 0x39,
	0x95, 0xb8, 0xe9, 0xcb, 0x96, 0x1f, 0xb1, 0x4f, 0x93, 0xfc, 0xd5, 0x43, 0xe5, 0x23, 0x7d, 0x79,
	0x89, 0xf9, 0xc6, 0x19, 0x32, 0x93, 0xb2, 0x7c, 0x9a, 0x94, 0xc5, 0x5c, 0x2f, 0x7c, 0x88, 0xcc,
	0xa4, 0x5a, 0xc9, 0x9a, 0x1d, 0x5c, 0xe2, 0x5c, 0xa6, 0xd6, 0xec, 0x3e, 0x02, 0xf5, 0x27, 0x60,
	0x92, 0x6d, 0x1c, 0x94, 0xb9, 0xef, 0x52, 0xfc, 0x5b, 0x1c, 0x8f, 0xeb, 0x5a, 0x1b, 0xc5, 0xc9,
	0x3a, 0x8a, 0x7b, 0x2b, 0x71, 0x6f, 0xbd, 0xb8, 0xfd, 0x02, 0x2a, 0x49, 0x54, 0xd4, 0xa8, 0x9f,
	0x80, 0x39, 0xf2, 0x27, 0xcb, 0x1e, 0xbd, 0x75, 0x25, 0x72, 0xae, 0xb8, 0xf6, 0x1f, 0x0d, 0xb8,
	0xdd, 0x9b, 0xe1, 0x13, 0x2e, 0xdd, 0x37, 0x3f, 0x85, 0xbc, 0x1f, 0x8c, 0x42, 0xfd, 0x92, 0x7c,
	0xa4, 0x75, 0xaf, 0xc9, 0x91, 0x35, 0x6c, 0xf6, 0xa3, 0x0c, 0x27, 0x05, 0xf6, 0x00, 0x60, 0x38,
	0x9e, 0x07, 0x6f, 0xfa, 0xae, 0x13, 0x3b, 0x14, 0x5f, 0xe5, 0x28, 0xc3, 0x2d, 0xc2, 0x5a, 0x4e,
	0xec, 0xd4, 0x77, 0xd5, 0x45, 0xd2, 0x98, 0xaf, 0x69, 0x9b, 0xfd, 0x02, 0xe4, 0x51, 0xd5, 0xfe,
	0x91, 0x6a, 0x0a, 0xdd, 0x23, 0x58, 0xda, 0x94, 0x5d, 0x54, 0xa8, 0xa4, 0xac, 0x3e, 0x7e, 0x09,
	0xb0, 0xda, 0xf6, 0x8c, 0xc1, 0x76, 0xf3, 0xa0, 0xdf, 0x3b, 0xed, 0xbe, 0x6e, 0xbf, 0xea, 0x1c,
	0x74, 0xda, 0xad, 0x6a, 0x86, 0x95, 0xa1, 0xd8, 0x3c, 0xe8, 0x77, 0x4e, 0xdb, 0xe7, 0xd5, 0x2c,
	0xab, 0x40, 0x49, 0x13, 0x9f, 0x57, 0xe1, 0xb1, 0x07, 0xb0, 0x5a, 0x6f, 0xa8, 0xdc, 0x7d, 0x75,
	0xf6, 0xba, 0xdd, 0xef, 0x9d, 0x76, 0x7e, 0xdd, 0xe6, 0xdd, 0x76, 0x35, 0xc3, 0x6e, 0x01, 0x28,
	0xac, 0xdb, 0x39, 0x6f, 0x57, 0xbf, 0x36, 0x56, 0xc0, 0x71, 0xe7, 0xf4, 0x57, 0xd5, 0x6f, 0x52,
	0xc0, 0xd1, 0x59, 0xf7, 0xbc, 0xfa, 0x1f, 0x83, 0x31, 0xd8, 0x52, 0xc0, 0xe9, 0xd9, 0x6f, 0x8e,
	0xda, 0xbc, 0x5d, 0xfd, 0xaf, 0xf1, 0xec, 0x1b, 0x0b, 0x2a, 0xf4, 0x05, 0xec, 0x8a, 0x88, 0xde,
	0x09, 0x5f, 0x40, 0xe5, 0x50, 0xc4, 0xab, 0x17, 0xfc, 0xdd, 0x86, 0xfa, 0x73, 0xd0, 0x48, 0x9e,
	0xfd, 0x8d, 0x36, 0xfe, 0x39, 0xa8, 0x57, 0xaf, 0x3e, 0x5a, 0xed, 0x0c, 0x7b, 0x49, 0xba, 0xab,
	0x0f, 0xc2, 0xbd, 0xf4, 0xa6, 0x4e, 0x7d, 0x1e, 0xeb, 0xd5, 0xab, 0x0c, 0x3b, 0xc3, 0x9e, 0x43,
	0xa9, 0xe9, 0xba, 0x84, 0xb0, 0x3b, 0x69, 0xfe, 0x5a, 0x25, 0xed, 0xf1, 0x39, 0x94, 0x5a, 0x62,
	0x72, 0x43, 0xa5, 0x5f, 0xc0, 0xd6, 0xa1, 0x88, 0x97, 0x9b, 0x51, 0x6e, 0xcc, 0xf1, 0xda, 0x12,
	0xd5, 0xa1, 0x1e, 0x00, 0xeb, 0xa6, 0x0c, 0xe0, 0x1a, 0xed, 0xcd, 0xd8, 0x5d, 0x2d, 0x7d, 0x65,
	0xab, 0xd6, 0x37, 0x58, 0xb7, 0x33, 0xec, 0x08, 0x76, 0xae, 0xda, 0x69, 0x85, 0x8b, 0xe0, 0x3b,
	0x58, 0x7a, 0x09, 0x56, 0xd3, 0x75, 0xd5, 0xa2, 0x66, 0xcb, 0xb0, 0xd3, 0x7b, 0xfb, 0xfd, 0xca,
	0x2d, 0x31, 0xf9, 0x8e, 0xca, 0x6d, 0xb8, 0x7d, 0x10, 0x09, 0xf1, 0x95, 0xa0, 0x29, 0xbe, 0x94,
	0xb1, 0x98, 0x6e, 0x2e, 0xe8, 0x66, 0x33, 0x87, 0x70, 0xa7, 0x17, 0x8c, 0xfe, 0x0f, 0x86, 0xbe,
	0x80, 0xed, 0x43, 0x11, 0xbf, 0xb3, 0xbc, 0x53, 0x6b, 0x26, 0xc9, 0x27, 0x8d, 0x69, 0x39, 0x3b,
	0xc3, 0xbe, 0x84, 0xb2, 0xd6, 0xa5, 0xa5, 0x7e, 0xf7, 0xea, 0x7e, 0xd2, 0xca, 0x77, 0xae, 0xe0,
	0xba, 0x2b, 0xbe, 0x84, 0x4a, 0x57, 0x69, 0xab, 0x95, 0xba, 0xce, 0xef, 0xfb, 0x2e, 0xa1, 0xac,
	0xb5, 0x4f, 0xf0, 0x43, 0x71, 0x33, 0xe5, 0x9f, 0x81, 0xf5, 0x2a, 0x12, 0x4e, 0x2c, 0xf0, 0x63,
	0x72, 0x33, 0xd5, 0x7d, 0x80, 0xd5, 0x0e, 0x65, 0xb5, 0x4d, 0x6b, 0x75, 0xb3, 0x85, 0x3d, 0x03,
	0x77, 0x06, 0xf6, 0xed, 0xd2, 0xca, 0xb7, 0x55, 0x3c, 0xf9, 0xca, 0x66, 0x7e, 0x6c, 0xe8, 0x7d,
	0xb3, 0x7a, 0x84, 0x7f, 0xdb, 0xbe, 0x59, 0x4a, 0xda, 0x19, 0xfc, 0x3f, 0xdd, 0x1d, 0xcf, 0x63,
	0x37, 0x5c, 0x04, 0x04, 0xdf, 0xbc, 0x5d, 0xf6, 0xef, 0x7d, 0xfd, 0x76, 0xd7, 0xf8, 0xe7, 0xdb,
	0x5d, 0xe3, 0xdf, 0x6f, 0x77, 0x8d, 0xdf, 0x5a, 0x8d, 0x97, 0xe4, 0x65, 0x36, 0x18, 0x14, 0x48,
	0xf4, 0xf9, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x27, 0x7c, 0x3b, 0x2f, 0x36, 0x11, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// AgentServiceClient is the client API for AgentService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AgentServiceClient interface {
	GetGuestInfo(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*GuestInfo, error)
	GetRouteList(ctx context.Context, in *RouteListRequest, opts ...grpc.CallOption) (*RouteList, error)
	AddRoute(ctx context.Context, in *RouteRequest, opts ...grpc.CallOption) (*RouteInfo, error)
	DelRoute(ctx context.Context, in *RouteRequest, opts ...grpc.CallOption) (*RouteInfo, error)
	GetInterfaces(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*InterfaceList, error)
	SetInterfaceLinkUp(ctx context.Context, in *LinkNameRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	SetInterfaceLinkDown(ctx context.Context, in *LinkNameRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	AddIPAddr(ctx context.Context, in *IPAddrRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	DelIPAddr(ctx context.Context, in *IPAddrRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	FreezeFileSystems(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*empty.Empty, error)
	UnfreezeFileSystems(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*empty.Empty, error)
	GetFileMD5Hash(ctx context.Context, in *FileRequest, opts ...grpc.CallOption) (*FileMD5Hash, error)
	GetFileStat(ctx context.Context, in *FileStatRequest, opts ...grpc.CallOption) (*FileStatList, error)
	SetFileOwner(ctx context.Context, in *FileRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	SetFileMode(ctx context.Context, in *FileRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	CreateDir(ctx context.Context, in *FileRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	UploadFile(ctx context.Context, opts ...grpc.CallOption) (AgentService_UploadFileClient, error)
	DownloadFile(ctx context.Context, in *FileRequest, opts ...grpc.CallOption) (AgentService_DownloadFileClient, error)
	GetAgentInfo(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*AgentInfo, error)
	ShutdownAgent(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*empty.Empty, error)
}

type agentServiceClient struct {
	cc *grpc.ClientConn
}

func NewAgentServiceClient(cc *grpc.ClientConn) AgentServiceClient {
	return &agentServiceClient{cc}
}

func (c *agentServiceClient) GetGuestInfo(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*GuestInfo, error) {
	out := new(GuestInfo)
	err := c.cc.Invoke(ctx, "/agent.AgentService/GetGuestInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) GetRouteList(ctx context.Context, in *RouteListRequest, opts ...grpc.CallOption) (*RouteList, error) {
	out := new(RouteList)
	err := c.cc.Invoke(ctx, "/agent.AgentService/GetRouteList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) AddRoute(ctx context.Context, in *RouteRequest, opts ...grpc.CallOption) (*RouteInfo, error) {
	out := new(RouteInfo)
	err := c.cc.Invoke(ctx, "/agent.AgentService/AddRoute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) DelRoute(ctx context.Context, in *RouteRequest, opts ...grpc.CallOption) (*RouteInfo, error) {
	out := new(RouteInfo)
	err := c.cc.Invoke(ctx, "/agent.AgentService/DelRoute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) GetInterfaces(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*InterfaceList, error) {
	out := new(InterfaceList)
	err := c.cc.Invoke(ctx, "/agent.AgentService/GetInterfaces", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) SetInterfaceLinkUp(ctx context.Context, in *LinkNameRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/agent.AgentService/SetInterfaceLinkUp", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) SetInterfaceLinkDown(ctx context.Context, in *LinkNameRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/agent.AgentService/SetInterfaceLinkDown", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) AddIPAddr(ctx context.Context, in *IPAddrRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/agent.AgentService/AddIPAddr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) DelIPAddr(ctx context.Context, in *IPAddrRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/agent.AgentService/DelIPAddr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) FreezeFileSystems(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/agent.AgentService/FreezeFileSystems", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) UnfreezeFileSystems(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/agent.AgentService/UnfreezeFileSystems", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) GetFileMD5Hash(ctx context.Context, in *FileRequest, opts ...grpc.CallOption) (*FileMD5Hash, error) {
	out := new(FileMD5Hash)
	err := c.cc.Invoke(ctx, "/agent.AgentService/GetFileMD5Hash", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) GetFileStat(ctx context.Context, in *FileStatRequest, opts ...grpc.CallOption) (*FileStatList, error) {
	out := new(FileStatList)
	err := c.cc.Invoke(ctx, "/agent.AgentService/GetFileStat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) SetFileOwner(ctx context.Context, in *FileRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/agent.AgentService/SetFileOwner", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) SetFileMode(ctx context.Context, in *FileRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/agent.AgentService/SetFileMode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) CreateDir(ctx context.Context, in *FileRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/agent.AgentService/CreateDir", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) UploadFile(ctx context.Context, opts ...grpc.CallOption) (AgentService_UploadFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AgentService_serviceDesc.Streams[0], "/agent.AgentService/UploadFile", opts...)
	if err != nil {
		return nil, err
	}
	x := &agentServiceUploadFileClient{stream}
	return x, nil
}

type AgentService_UploadFileClient interface {
	Send(*UploadFileRequest) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type agentServiceUploadFileClient struct {
	grpc.ClientStream
}

func (x *agentServiceUploadFileClient) Send(m *UploadFileRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *agentServiceUploadFileClient) CloseAndRecv() (*empty.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(empty.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *agentServiceClient) DownloadFile(ctx context.Context, in *FileRequest, opts ...grpc.CallOption) (AgentService_DownloadFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AgentService_serviceDesc.Streams[1], "/agent.AgentService/DownloadFile", opts...)
	if err != nil {
		return nil, err
	}
	x := &agentServiceDownloadFileClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type AgentService_DownloadFileClient interface {
	Recv() (*FileContent, error)
	grpc.ClientStream
}

type agentServiceDownloadFileClient struct {
	grpc.ClientStream
}

func (x *agentServiceDownloadFileClient) Recv() (*FileContent, error) {
	m := new(FileContent)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *agentServiceClient) GetAgentInfo(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*AgentInfo, error) {
	out := new(AgentInfo)
	err := c.cc.Invoke(ctx, "/agent.AgentService/GetAgentInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentServiceClient) ShutdownAgent(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/agent.AgentService/ShutdownAgent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AgentServiceServer is the server API for AgentService service.
type AgentServiceServer interface {
	GetGuestInfo(context.Context, *empty.Empty) (*GuestInfo, error)
	GetRouteList(context.Context, *RouteListRequest) (*RouteList, error)
	AddRoute(context.Context, *RouteRequest) (*RouteInfo, error)
	DelRoute(context.Context, *RouteRequest) (*RouteInfo, error)
	GetInterfaces(context.Context, *empty.Empty) (*InterfaceList, error)
	SetInterfaceLinkUp(context.Context, *LinkNameRequest) (*empty.Empty, error)
	SetInterfaceLinkDown(context.Context, *LinkNameRequest) (*empty.Empty, error)
	AddIPAddr(context.Context, *IPAddrRequest) (*empty.Empty, error)
	DelIPAddr(context.Context, *IPAddrRequest) (*empty.Empty, error)
	FreezeFileSystems(context.Context, *empty.Empty) (*empty.Empty, error)
	UnfreezeFileSystems(context.Context, *empty.Empty) (*empty.Empty, error)
	GetFileMD5Hash(context.Context, *FileRequest) (*FileMD5Hash, error)
	GetFileStat(context.Context, *FileStatRequest) (*FileStatList, error)
	SetFileOwner(context.Context, *FileRequest) (*empty.Empty, error)
	SetFileMode(context.Context, *FileRequest) (*empty.Empty, error)
	CreateDir(context.Context, *FileRequest) (*empty.Empty, error)
	UploadFile(AgentService_UploadFileServer) error
	DownloadFile(*FileRequest, AgentService_DownloadFileServer) error
	GetAgentInfo(context.Context, *empty.Empty) (*AgentInfo, error)
	ShutdownAgent(context.Context, *empty.Empty) (*empty.Empty, error)
}

// UnimplementedAgentServiceServer can be embedded to have forward compatible implementations.
type UnimplementedAgentServiceServer struct {
}

func (*UnimplementedAgentServiceServer) GetGuestInfo(ctx context.Context, req *empty.Empty) (*GuestInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetGuestInfo not implemented")
}
func (*UnimplementedAgentServiceServer) GetRouteList(ctx context.Context, req *RouteListRequest) (*RouteList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRouteList not implemented")
}
func (*UnimplementedAgentServiceServer) AddRoute(ctx context.Context, req *RouteRequest) (*RouteInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddRoute not implemented")
}
func (*UnimplementedAgentServiceServer) DelRoute(ctx context.Context, req *RouteRequest) (*RouteInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelRoute not implemented")
}
func (*UnimplementedAgentServiceServer) GetInterfaces(ctx context.Context, req *empty.Empty) (*InterfaceList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInterfaces not implemented")
}
func (*UnimplementedAgentServiceServer) SetInterfaceLinkUp(ctx context.Context, req *LinkNameRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetInterfaceLinkUp not implemented")
}
func (*UnimplementedAgentServiceServer) SetInterfaceLinkDown(ctx context.Context, req *LinkNameRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetInterfaceLinkDown not implemented")
}
func (*UnimplementedAgentServiceServer) AddIPAddr(ctx context.Context, req *IPAddrRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddIPAddr not implemented")
}
func (*UnimplementedAgentServiceServer) DelIPAddr(ctx context.Context, req *IPAddrRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelIPAddr not implemented")
}
func (*UnimplementedAgentServiceServer) FreezeFileSystems(ctx context.Context, req *empty.Empty) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FreezeFileSystems not implemented")
}
func (*UnimplementedAgentServiceServer) UnfreezeFileSystems(ctx context.Context, req *empty.Empty) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnfreezeFileSystems not implemented")
}
func (*UnimplementedAgentServiceServer) GetFileMD5Hash(ctx context.Context, req *FileRequest) (*FileMD5Hash, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetFileMD5Hash not implemented")
}
func (*UnimplementedAgentServiceServer) GetFileStat(ctx context.Context, req *FileStatRequest) (*FileStatList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetFileStat not implemented")
}
func (*UnimplementedAgentServiceServer) SetFileOwner(ctx context.Context, req *FileRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetFileOwner not implemented")
}
func (*UnimplementedAgentServiceServer) SetFileMode(ctx context.Context, req *FileRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetFileMode not implemented")
}
func (*UnimplementedAgentServiceServer) CreateDir(ctx context.Context, req *FileRequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateDir not implemented")
}
func (*UnimplementedAgentServiceServer) UploadFile(srv AgentService_UploadFileServer) error {
	return status.Errorf(codes.Unimplemented, "method UploadFile not implemented")
}
func (*UnimplementedAgentServiceServer) DownloadFile(req *FileRequest, srv AgentService_DownloadFileServer) error {
	return status.Errorf(codes.Unimplemented, "method DownloadFile not implemented")
}
func (*UnimplementedAgentServiceServer) GetAgentInfo(ctx context.Context, req *empty.Empty) (*AgentInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAgentInfo not implemented")
}
func (*UnimplementedAgentServiceServer) ShutdownAgent(ctx context.Context, req *empty.Empty) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ShutdownAgent not implemented")
}

func RegisterAgentServiceServer(s *grpc.Server, srv AgentServiceServer) {
	s.RegisterService(&_AgentService_serviceDesc, srv)
}

func _AgentService_GetGuestInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).GetGuestInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/GetGuestInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).GetGuestInfo(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_GetRouteList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RouteListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).GetRouteList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/GetRouteList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).GetRouteList(ctx, req.(*RouteListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_AddRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RouteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).AddRoute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/AddRoute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).AddRoute(ctx, req.(*RouteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_DelRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RouteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).DelRoute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/DelRoute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).DelRoute(ctx, req.(*RouteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_GetInterfaces_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).GetInterfaces(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/GetInterfaces",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).GetInterfaces(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_SetInterfaceLinkUp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LinkNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).SetInterfaceLinkUp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/SetInterfaceLinkUp",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).SetInterfaceLinkUp(ctx, req.(*LinkNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_SetInterfaceLinkDown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LinkNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).SetInterfaceLinkDown(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/SetInterfaceLinkDown",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).SetInterfaceLinkDown(ctx, req.(*LinkNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_AddIPAddr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IPAddrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).AddIPAddr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/AddIPAddr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).AddIPAddr(ctx, req.(*IPAddrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_DelIPAddr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IPAddrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).DelIPAddr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/DelIPAddr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).DelIPAddr(ctx, req.(*IPAddrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_FreezeFileSystems_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).FreezeFileSystems(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/FreezeFileSystems",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).FreezeFileSystems(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_UnfreezeFileSystems_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).UnfreezeFileSystems(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/UnfreezeFileSystems",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).UnfreezeFileSystems(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_GetFileMD5Hash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).GetFileMD5Hash(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/GetFileMD5Hash",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).GetFileMD5Hash(ctx, req.(*FileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_GetFileStat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FileStatRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).GetFileStat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/GetFileStat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).GetFileStat(ctx, req.(*FileStatRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_SetFileOwner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).SetFileOwner(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/SetFileOwner",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).SetFileOwner(ctx, req.(*FileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_SetFileMode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).SetFileMode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/SetFileMode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).SetFileMode(ctx, req.(*FileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_CreateDir_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).CreateDir(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/CreateDir",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).CreateDir(ctx, req.(*FileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_UploadFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(AgentServiceServer).UploadFile(&agentServiceUploadFileServer{stream})
}

type AgentService_UploadFileServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*UploadFileRequest, error)
	grpc.ServerStream
}

type agentServiceUploadFileServer struct {
	grpc.ServerStream
}

func (x *agentServiceUploadFileServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *agentServiceUploadFileServer) Recv() (*UploadFileRequest, error) {
	m := new(UploadFileRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _AgentService_DownloadFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(FileRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AgentServiceServer).DownloadFile(m, &agentServiceDownloadFileServer{stream})
}

type AgentService_DownloadFileServer interface {
	Send(*FileContent) error
	grpc.ServerStream
}

type agentServiceDownloadFileServer struct {
	grpc.ServerStream
}

func (x *agentServiceDownloadFileServer) Send(m *FileContent) error {
	return x.ServerStream.SendMsg(m)
}

func _AgentService_GetAgentInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).GetAgentInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/GetAgentInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).GetAgentInfo(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgentService_ShutdownAgent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentServiceServer).ShutdownAgent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/agent.AgentService/ShutdownAgent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentServiceServer).ShutdownAgent(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _AgentService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "agent.AgentService",
	HandlerType: (*AgentServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetGuestInfo",
			Handler:    _AgentService_GetGuestInfo_Handler,
		},
		{
			MethodName: "GetRouteList",
			Handler:    _AgentService_GetRouteList_Handler,
		},
		{
			MethodName: "AddRoute",
			Handler:    _AgentService_AddRoute_Handler,
		},
		{
			MethodName: "DelRoute",
			Handler:    _AgentService_DelRoute_Handler,
		},
		{
			MethodName: "GetInterfaces",
			Handler:    _AgentService_GetInterfaces_Handler,
		},
		{
			MethodName: "SetInterfaceLinkUp",
			Handler:    _AgentService_SetInterfaceLinkUp_Handler,
		},
		{
			MethodName: "SetInterfaceLinkDown",
			Handler:    _AgentService_SetInterfaceLinkDown_Handler,
		},
		{
			MethodName: "AddIPAddr",
			Handler:    _AgentService_AddIPAddr_Handler,
		},
		{
			MethodName: "DelIPAddr",
			Handler:    _AgentService_DelIPAddr_Handler,
		},
		{
			MethodName: "FreezeFileSystems",
			Handler:    _AgentService_FreezeFileSystems_Handler,
		},
		{
			MethodName: "UnfreezeFileSystems",
			Handler:    _AgentService_UnfreezeFileSystems_Handler,
		},
		{
			MethodName: "GetFileMD5Hash",
			Handler:    _AgentService_GetFileMD5Hash_Handler,
		},
		{
			MethodName: "GetFileStat",
			Handler:    _AgentService_GetFileStat_Handler,
		},
		{
			MethodName: "SetFileOwner",
			Handler:    _AgentService_SetFileOwner_Handler,
		},
		{
			MethodName: "SetFileMode",
			Handler:    _AgentService_SetFileMode_Handler,
		},
		{
			MethodName: "CreateDir",
			Handler:    _AgentService_CreateDir_Handler,
		},
		{
			MethodName: "GetAgentInfo",
			Handler:    _AgentService_GetAgentInfo_Handler,
		},
		{
			MethodName: "ShutdownAgent",
			Handler:    _AgentService_ShutdownAgent_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "UploadFile",
			Handler:       _AgentService_UploadFile_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "DownloadFile",
			Handler:       _AgentService_DownloadFile_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "agent/agent.proto",
}

func (m *GuestInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GuestInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GuestInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.BlockDevices) > 0 {
		for iNdEx := len(m.BlockDevices) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BlockDevices[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAgent(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Users) > 0 {
		for iNdEx := len(m.Users) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Users[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAgent(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.Swap != nil {
		{
			size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Mem != nil {
		{
			size, err := m.Mem.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Loadavg != nil {
		{
			size, err := m.Loadavg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Uptime != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Uptime))
		i--
		dAtA[i] = 0x10
	}
	if m.Uname != nil {
		{
			size, err := m.Uname.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GuestInfo_Utsname) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GuestInfo_Utsname) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GuestInfo_Utsname) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Domainname) > 0 {
		i -= len(m.Domainname)
		copy(dAtA[i:], m.Domainname)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Domainname)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Machine) > 0 {
		i -= len(m.Machine)
		copy(dAtA[i:], m.Machine)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Machine)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Release) > 0 {
		i -= len(m.Release)
		copy(dAtA[i:], m.Release)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Release)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Nodename) > 0 {
		i -= len(m.Nodename)
		copy(dAtA[i:], m.Nodename)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Nodename)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sysname) > 0 {
		i -= len(m.Sysname)
		copy(dAtA[i:], m.Sysname)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Sysname)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GuestInfo_LoadAverage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GuestInfo_LoadAverage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GuestInfo_LoadAverage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Fifteen != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Fifteen))))
		i--
		dAtA[i] = 0x19
	}
	if m.Five != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Five))))
		i--
		dAtA[i] = 0x11
	}
	if m.One != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.One))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *GuestInfo_MemStat) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GuestInfo_MemStat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GuestInfo_MemStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.FreeTotal != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.FreeTotal))
		i--
		dAtA[i] = 0x28
	}
	if m.Cached != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Cached))
		i--
		dAtA[i] = 0x20
	}
	if m.Buffers != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Buffers))
		i--
		dAtA[i] = 0x18
	}
	if m.Free != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Free))
		i--
		dAtA[i] = 0x10
	}
	if m.Total != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Total))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GuestInfo_SwapStat) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GuestInfo_SwapStat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GuestInfo_SwapStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Free != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Free))
		i--
		dAtA[i] = 0x10
	}
	if m.Total != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Total))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GuestInfo_LoggedUser) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GuestInfo_LoggedUser) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GuestInfo_LoggedUser) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.LoginTime != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.LoginTime))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Host) > 0 {
		i -= len(m.Host)
		copy(dAtA[i:], m.Host)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Host)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Device) > 0 {
		i -= len(m.Device)
		copy(dAtA[i:], m.Device)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Device)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GuestInfo_BlockDevice) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GuestInfo_BlockDevice) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GuestInfo_BlockDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.InodesAvail != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.InodesAvail))
		i--
		dAtA[i] = 0x48
	}
	if m.InodesUsed != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.InodesUsed))
		i--
		dAtA[i] = 0x40
	}
	if m.InodesTotal != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.InodesTotal))
		i--
		dAtA[i] = 0x38
	}
	if m.SizeAvail != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.SizeAvail))
		i--
		dAtA[i] = 0x30
	}
	if m.SizeUsed != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.SizeUsed))
		i--
		dAtA[i] = 0x28
	}
	if m.SizeTotal != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.SizeTotal))
		i--
		dAtA[i] = 0x20
	}
	if len(m.MountPoint) > 0 {
		i -= len(m.MountPoint)
		copy(dAtA[i:], m.MountPoint)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.MountPoint)))
		i--
		dAtA[i] = 0x1a
	}
	if m.IsMounted {
		i--
		if m.IsMounted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AgentInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AgentInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.IsLocked {
		i--
		if m.IsLocked {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RouteListRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RouteListRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RouteListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Family != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Family))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RouteInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RouteInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RouteInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Table != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Table))
		i--
		dAtA[i] = 0x38
	}
	if len(m.Gw) > 0 {
		i -= len(m.Gw)
		copy(dAtA[i:], m.Gw)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Gw)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Src) > 0 {
		i -= len(m.Src)
		copy(dAtA[i:], m.Src)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Src)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Dst) > 0 {
		i -= len(m.Dst)
		copy(dAtA[i:], m.Dst)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Dst)))
		i--
		dAtA[i] = 0x22
	}
	if m.Scope != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Scope))
		i--
		dAtA[i] = 0x18
	}
	if len(m.LinkName) > 0 {
		i -= len(m.LinkName)
		copy(dAtA[i:], m.LinkName)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.LinkName)))
		i--
		dAtA[i] = 0x12
	}
	if m.LinkIndex != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.LinkIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RouteList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RouteList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RouteList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Routes) > 0 {
		for iNdEx := len(m.Routes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Routes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAgent(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RouteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RouteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RouteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Table != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Table))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Gw) > 0 {
		i -= len(m.Gw)
		copy(dAtA[i:], m.Gw)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Gw)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Src) > 0 {
		i -= len(m.Src)
		copy(dAtA[i:], m.Src)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Src)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Dst) > 0 {
		i -= len(m.Dst)
		copy(dAtA[i:], m.Dst)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Dst)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Scope != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Scope))
		i--
		dAtA[i] = 0x10
	}
	if len(m.LinkName) > 0 {
		i -= len(m.LinkName)
		copy(dAtA[i:], m.LinkName)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.LinkName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *InterfaceInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InterfaceInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InterfaceInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Addrs) > 0 {
		for iNdEx := len(m.Addrs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addrs[iNdEx])
			copy(dAtA[i:], m.Addrs[iNdEx])
			i = encodeVarintAgent(dAtA, i, uint64(len(m.Addrs[iNdEx])))
			i--
			dAtA[i] = 0x32
		}
	}
	if m.MTU != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.MTU))
		i--
		dAtA[i] = 0x28
	}
	if m.Flags != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Flags))
		i--
		dAtA[i] = 0x20
	}
	if len(m.HwAddr) > 0 {
		i -= len(m.HwAddr)
		copy(dAtA[i:], m.HwAddr)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.HwAddr)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Index != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *InterfaceList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InterfaceList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InterfaceList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Interfaces) > 0 {
		for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAgent(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *LinkNameRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LinkNameRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LinkNameRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IPAddrRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IPAddrRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IPAddrRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Addr) > 0 {
		i -= len(m.Addr)
		copy(dAtA[i:], m.Addr)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Addr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.LinkName) > 0 {
		i -= len(m.LinkName)
		copy(dAtA[i:], m.LinkName)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.LinkName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FileRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FileRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FileRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Mode != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Group) > 0 {
		i -= len(m.Group)
		copy(dAtA[i:], m.Group)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Group)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FileStatRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FileStatRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FileStatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.WithDirContent {
		i--
		if m.WithDirContent {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FileMD5Hash) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FileMD5Hash) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FileMD5Hash) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FileStat) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FileStat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FileStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SizeBytes != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.SizeBytes))
		i--
		dAtA[i] = 0x30
	}
	if m.Group != nil {
		{
			size, err := m.Group.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Owner != nil {
		{
			size, err := m.Owner.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.IsDir {
		i--
		if m.IsDir {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Mode != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FileStat_Owner) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FileStat_Owner) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FileStat_Owner) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Uid != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Uid))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FileStat_Group) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FileStat_Group) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FileStat_Group) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Gid != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Gid))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FileStatList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FileStatList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FileStatList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Files) > 0 {
		for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Files[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAgent(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *UploadFileRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UploadFileRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UploadFileRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Data != nil {
		{
			size := m.Data.Size()
			i -= size
			if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *UploadFileRequest_Info) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UploadFileRequest_Info) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Info != nil {
		{
			size, err := m.Info.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *UploadFileRequest_ChunkData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UploadFileRequest_ChunkData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChunkData != nil {
		i -= len(m.ChunkData)
		copy(dAtA[i:], m.ChunkData)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.ChunkData)))
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *UploadFileRequest_FileInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UploadFileRequest_FileInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UploadFileRequest_FileInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FileContent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FileContent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FileContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ChunkData) > 0 {
		i -= len(m.ChunkData)
		copy(dAtA[i:], m.ChunkData)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.ChunkData)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintAgent(dAtA []byte, offset int, v uint64) int {
	offset -= sovAgent(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GuestInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uname != nil {
		l = m.Uname.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Uptime != 0 {
		n += 1 + sovAgent(uint64(m.Uptime))
	}
	if m.Loadavg != nil {
		l = m.Loadavg.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Mem != nil {
		l = m.Mem.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Swap != nil {
		l = m.Swap.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if len(m.Users) > 0 {
		for _, e := range m.Users {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if len(m.BlockDevices) > 0 {
		for _, e := range m.BlockDevices {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GuestInfo_Utsname) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sysname)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Nodename)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Release)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Machine)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Domainname)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GuestInfo_LoadAverage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.One != 0 {
		n += 9
	}
	if m.Five != 0 {
		n += 9
	}
	if m.Fifteen != 0 {
		n += 9
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GuestInfo_MemStat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Total != 0 {
		n += 1 + sovAgent(uint64(m.Total))
	}
	if m.Free != 0 {
		n += 1 + sovAgent(uint64(m.Free))
	}
	if m.Buffers != 0 {
		n += 1 + sovAgent(uint64(m.Buffers))
	}
	if m.Cached != 0 {
		n += 1 + sovAgent(uint64(m.Cached))
	}
	if m.FreeTotal != 0 {
		n += 1 + sovAgent(uint64(m.FreeTotal))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GuestInfo_SwapStat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Total != 0 {
		n += 1 + sovAgent(uint64(m.Total))
	}
	if m.Free != 0 {
		n += 1 + sovAgent(uint64(m.Free))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GuestInfo_LoggedUser) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Device)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Host)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.LoginTime != 0 {
		n += 1 + sovAgent(uint64(m.LoginTime))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GuestInfo_BlockDevice) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.IsMounted {
		n += 2
	}
	l = len(m.MountPoint)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.SizeTotal != 0 {
		n += 1 + sovAgent(uint64(m.SizeTotal))
	}
	if m.SizeUsed != 0 {
		n += 1 + sovAgent(uint64(m.SizeUsed))
	}
	if m.SizeAvail != 0 {
		n += 1 + sovAgent(uint64(m.SizeAvail))
	}
	if m.InodesTotal != 0 {
		n += 1 + sovAgent(uint64(m.InodesTotal))
	}
	if m.InodesUsed != 0 {
		n += 1 + sovAgent(uint64(m.InodesUsed))
	}
	if m.InodesAvail != 0 {
		n += 1 + sovAgent(uint64(m.InodesAvail))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AgentInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.IsLocked {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RouteListRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Family != 0 {
		n += 1 + sovAgent(uint64(m.Family))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RouteInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LinkIndex != 0 {
		n += 1 + sovAgent(uint64(m.LinkIndex))
	}
	l = len(m.LinkName)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Scope != 0 {
		n += 1 + sovAgent(uint64(m.Scope))
	}
	l = len(m.Dst)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Src)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Gw)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Table != 0 {
		n += 1 + sovAgent(uint64(m.Table))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RouteList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Routes) > 0 {
		for _, e := range m.Routes {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RouteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LinkName)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Scope != 0 {
		n += 1 + sovAgent(uint64(m.Scope))
	}
	l = len(m.Dst)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Src)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Gw)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Table != 0 {
		n += 1 + sovAgent(uint64(m.Table))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *InterfaceInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovAgent(uint64(m.Index))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.HwAddr)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Flags != 0 {
		n += 1 + sovAgent(uint64(m.Flags))
	}
	if m.MTU != 0 {
		n += 1 + sovAgent(uint64(m.MTU))
	}
	if len(m.Addrs) > 0 {
		for _, s := range m.Addrs {
			l = len(s)
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *InterfaceList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Interfaces) > 0 {
		for _, e := range m.Interfaces {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LinkNameRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *IPAddrRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LinkName)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Addr)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FileRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Group)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovAgent(uint64(m.Mode))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FileStatRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.WithDirContent {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FileMD5Hash) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FileStat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovAgent(uint64(m.Mode))
	}
	if m.IsDir {
		n += 2
	}
	if m.Owner != nil {
		l = m.Owner.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Group != nil {
		l = m.Group.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.SizeBytes != 0 {
		n += 1 + sovAgent(uint64(m.SizeBytes))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FileStat_Owner) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uid != 0 {
		n += 1 + sovAgent(uint64(m.Uid))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FileStat_Group) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Gid != 0 {
		n += 1 + sovAgent(uint64(m.Gid))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FileStatList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Files) > 0 {
		for _, e := range m.Files {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UploadFileRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		n += m.Data.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UploadFileRequest_Info) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Info != nil {
		l = m.Info.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}
func (m *UploadFileRequest_ChunkData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChunkData != nil {
		l = len(m.ChunkData)
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}
func (m *UploadFileRequest_FileInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FileContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChunkData)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovAgent(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozAgent(x uint64) (n int) {
	return sovAgent(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GuestInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GuestInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GuestInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uname", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Uname == nil {
				m.Uname = &GuestInfo_Utsname{}
			}
			if err := m.Uname.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uptime", wireType)
			}
			m.Uptime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uptime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Loadavg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Loadavg == nil {
				m.Loadavg = &GuestInfo_LoadAverage{}
			}
			if err := m.Loadavg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mem", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Mem == nil {
				m.Mem = &GuestInfo_MemStat{}
			}
			if err := m.Mem.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Swap == nil {
				m.Swap = &GuestInfo_SwapStat{}
			}
			if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Users", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Users = append(m.Users, &GuestInfo_LoggedUser{})
			if err := m.Users[len(m.Users)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDevices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockDevices = append(m.BlockDevices, &GuestInfo_BlockDevice{})
			if err := m.BlockDevices[len(m.BlockDevices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GuestInfo_Utsname) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Utsname: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Utsname: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sysname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sysname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodename", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nodename = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Release", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Release = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Machine", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Machine = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domainname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Domainname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GuestInfo_LoadAverage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LoadAverage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LoadAverage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field One", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.One = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Five", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Five = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fifteen", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Fifteen = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GuestInfo_MemStat) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MemStat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MemStat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Free", wireType)
			}
			m.Free = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Free |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Buffers", wireType)
			}
			m.Buffers = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Buffers |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cached", wireType)
			}
			m.Cached = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Cached |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FreeTotal", wireType)
			}
			m.FreeTotal = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FreeTotal |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GuestInfo_SwapStat) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SwapStat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SwapStat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Free", wireType)
			}
			m.Free = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Free |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GuestInfo_LoggedUser) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LoggedUser: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LoggedUser: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Device = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Host = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoginTime", wireType)
			}
			m.LoginTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LoginTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GuestInfo_BlockDevice) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockDevice: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockDevice: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsMounted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsMounted = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MountPoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MountPoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SizeTotal", wireType)
			}
			m.SizeTotal = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SizeTotal |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SizeUsed", wireType)
			}
			m.SizeUsed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SizeUsed |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SizeAvail", wireType)
			}
			m.SizeAvail = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SizeAvail |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InodesTotal", wireType)
			}
			m.InodesTotal = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InodesTotal |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InodesUsed", wireType)
			}
			m.InodesUsed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InodesUsed |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InodesAvail", wireType)
			}
			m.InodesAvail = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InodesAvail |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsLocked", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsLocked = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RouteListRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RouteListRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RouteListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Family", wireType)
			}
			m.Family = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Family |= InetFamily(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RouteInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RouteInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RouteInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkIndex", wireType)
			}
			m.LinkIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LinkIndex |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LinkName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType)
			}
			m.Scope = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Scope |= RouteScope(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dst", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dst = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Src", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Src = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gw", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Gw = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			m.Table = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Table |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RouteList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RouteList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RouteList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Routes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Routes = append(m.Routes, &RouteInfo{})
			if err := m.Routes[len(m.Routes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RouteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RouteRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RouteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LinkName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType)
			}
			m.Scope = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Scope |= RouteScope(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dst", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dst = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Src", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Src = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gw", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Gw = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			m.Table = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Table |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InterfaceInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InterfaceInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InterfaceInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HwAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HwAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType)
			}
			m.Flags = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Flags |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MTU", wireType)
			}
			m.MTU = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MTU |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addrs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addrs = append(m.Addrs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InterfaceList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InterfaceList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InterfaceList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Interfaces = append(m.Interfaces, &InterfaceInfo{})
			if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LinkNameRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LinkNameRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LinkNameRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPAddrRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IPAddrRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPAddrRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LinkName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FileRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Group = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileStatRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FileStatRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileStatRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithDirContent", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.WithDirContent = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileMD5Hash) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FileMD5Hash: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileMD5Hash: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileStat) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FileStat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileStat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsDir", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsDir = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Owner == nil {
				m.Owner = &FileStat_Owner{}
			}
			if err := m.Owner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Group == nil {
				m.Group = &FileStat_Group{}
			}
			if err := m.Group.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SizeBytes", wireType)
			}
			m.SizeBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SizeBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileStat_Owner) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Owner: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Owner: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
			}
			m.Uid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileStat_Group) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Group: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Group: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gid", wireType)
			}
			m.Gid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Gid |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileStatList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FileStatList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileStatList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Files = append(m.Files, &FileStat{})
			if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UploadFileRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UploadFileRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UploadFileRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UploadFileRequest_FileInfo{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &UploadFileRequest_Info{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChunkData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := make([]byte, postIndex-iNdEx)
			copy(v, dAtA[iNdEx:postIndex])
			m.Data = &UploadFileRequest_ChunkData{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UploadFileRequest_FileInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FileInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileContent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FileContent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileContent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChunkData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChunkData = append(m.ChunkData[:0], dAtA[iNdEx:postIndex]...)
			if m.ChunkData == nil {
				m.ChunkData = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipAgent(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthAgent
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupAgent
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthAgent
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthAgent        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAgent          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupAgent = fmt.Errorf("proto: unexpected end of group")
)