vendor/golang.org/x/net/bpf/vm_jump_test.go

   1 // Copyright 2016 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package bpf_test
   6
   7 import (
   8         "testing"
   9
  10         "golang.org/x/net/bpf"
  11 )
  12
  13 func TestVMJumpOne(t *testing.T) {
  14         vm, done, err := testVM(t, []bpf.Instruction{
  15                 bpf.LoadAbsolute{
  16                         Off:  8,
  17                         Size: 1,
  18                 },
  19                 bpf.Jump{
  20                         Skip: 1,
  21                 },
  22                 bpf.RetConstant{
  23                         Val: 0,
  24                 },
  25                 bpf.RetConstant{
  26                         Val: 9,
  27                 },
  28         })
  29         if err != nil {
  30                 t.Fatalf("failed to load BPF program: %v", err)
  31         }
  32         defer done()
  33
  34         out, err := vm.Run([]byte{
  35                 0xff, 0xff, 0xff, 0xff,
  36                 0xff, 0xff, 0xff, 0xff,
  37                 1,
  38         })
  39         if err != nil {
  40                 t.Fatalf("unexpected error while running program: %v", err)
  41         }
  42         if want, got := 1, out; want != got {
  43                 t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
  44                         want, got)
  45         }
  46 }
  47
  48 func TestVMJumpOutOfProgram(t *testing.T) {
  49         _, _, err := testVM(t, []bpf.Instruction{
  50                 bpf.Jump{
  51                         Skip: 1,
  52                 },
  53                 bpf.RetA{},
  54         })
  55         if errStr(err) != "cannot jump 1 instructions; jumping past program bounds" {
  56                 t.Fatalf("unexpected error: %v", err)
  57         }
  58 }
  59
  60 func TestVMJumpIfTrueOutOfProgram(t *testing.T) {
  61         _, _, err := testVM(t, []bpf.Instruction{
  62                 bpf.JumpIf{
  63                         Cond:     bpf.JumpEqual,
  64                         SkipTrue: 2,
  65                 },
  66                 bpf.RetA{},
  67         })
  68         if errStr(err) != "cannot jump 2 instructions in true case; jumping past program bounds" {
  69                 t.Fatalf("unexpected error: %v", err)
  70         }
  71 }
  72
  73 func TestVMJumpIfFalseOutOfProgram(t *testing.T) {
  74         _, _, err := testVM(t, []bpf.Instruction{
  75                 bpf.JumpIf{
  76                         Cond:      bpf.JumpEqual,
  77                         SkipFalse: 3,
  78                 },
  79                 bpf.RetA{},
  80         })
  81         if errStr(err) != "cannot jump 3 instructions in false case; jumping past program bounds" {
  82                 t.Fatalf("unexpected error: %v", err)
  83         }
  84 }
  85
  86 func TestVMJumpIfEqual(t *testing.T) {
  87         vm, done, err := testVM(t, []bpf.Instruction{
  88                 bpf.LoadAbsolute{
  89                         Off:  8,
  90                         Size: 1,
  91                 },
  92                 bpf.JumpIf{
  93                         Cond:     bpf.JumpEqual,
  94                         Val:      1,
  95                         SkipTrue: 1,
  96                 },
  97                 bpf.RetConstant{
  98                         Val: 0,
  99                 },
 100                 bpf.RetConstant{
 101                         Val: 9,
 102                 },
 103         })
 104         if err != nil {
 105                 t.Fatalf("failed to load BPF program: %v", err)
 106         }
 107         defer done()
 108
 109         out, err := vm.Run([]byte{
 110                 0xff, 0xff, 0xff, 0xff,
 111                 0xff, 0xff, 0xff, 0xff,
 112                 1,
 113         })
 114         if err != nil {
 115                 t.Fatalf("unexpected error while running program: %v", err)
 116         }
 117         if want, got := 1, out; want != got {
 118                 t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
 119                         want, got)
 120         }
 121 }
 122
 123 func TestVMJumpIfNotEqual(t *testing.T) {
 124         vm, done, err := testVM(t, []bpf.Instruction{
 125                 bpf.LoadAbsolute{
 126                         Off:  8,
 127                         Size: 1,
 128                 },
 129                 bpf.JumpIf{
 130                         Cond:      bpf.JumpNotEqual,
 131                         Val:       1,
 132                         SkipFalse: 1,
 133                 },
 134                 bpf.RetConstant{
 135                         Val: 0,
 136                 },
 137                 bpf.RetConstant{
 138                         Val: 9,
 139                 },
 140         })
 141         if err != nil {
 142                 t.Fatalf("failed to load BPF program: %v", err)
 143         }
 144         defer done()
 145
 146         out, err := vm.Run([]byte{
 147                 0xff, 0xff, 0xff, 0xff,
 148                 0xff, 0xff, 0xff, 0xff,
 149                 1,
 150         })
 151         if err != nil {
 152                 t.Fatalf("unexpected error while running program: %v", err)
 153         }
 154         if want, got := 1, out; want != got {
 155                 t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
 156                         want, got)
 157         }
 158 }
 159
 160 func TestVMJumpIfGreaterThan(t *testing.T) {
 161         vm, done, err := testVM(t, []bpf.Instruction{
 162                 bpf.LoadAbsolute{
 163                         Off:  8,
 164                         Size: 4,
 165                 },
 166                 bpf.JumpIf{
 167                         Cond:     bpf.JumpGreaterThan,
 168                         Val:      0x00010202,
 169                         SkipTrue: 1,
 170                 },
 171                 bpf.RetConstant{
 172                         Val: 0,
 173                 },
 174                 bpf.RetConstant{
 175                         Val: 12,
 176                 },
 177         })
 178         if err != nil {
 179                 t.Fatalf("failed to load BPF program: %v", err)
 180         }
 181         defer done()
 182
 183         out, err := vm.Run([]byte{
 184                 0xff, 0xff, 0xff, 0xff,
 185                 0xff, 0xff, 0xff, 0xff,
 186                 0, 1, 2, 3,
 187         })
 188         if err != nil {
 189                 t.Fatalf("unexpected error while running program: %v", err)
 190         }
 191         if want, got := 4, out; want != got {
 192                 t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
 193                         want, got)
 194         }
 195 }
 196
 197 func TestVMJumpIfLessThan(t *testing.T) {
 198         vm, done, err := testVM(t, []bpf.Instruction{
 199                 bpf.LoadAbsolute{
 200                         Off:  8,
 201                         Size: 4,
 202                 },
 203                 bpf.JumpIf{
 204                         Cond:     bpf.JumpLessThan,
 205                         Val:      0xff010203,
 206                         SkipTrue: 1,
 207                 },
 208                 bpf.RetConstant{
 209                         Val: 0,
 210                 },
 211                 bpf.RetConstant{
 212                         Val: 12,
 213                 },
 214         })
 215         if err != nil {
 216                 t.Fatalf("failed to load BPF program: %v", err)
 217         }
 218         defer done()
 219
 220         out, err := vm.Run([]byte{
 221                 0xff, 0xff, 0xff, 0xff,
 222                 0xff, 0xff, 0xff, 0xff,
 223                 0, 1, 2, 3,
 224         })
 225         if err != nil {
 226                 t.Fatalf("unexpected error while running program: %v", err)
 227         }
 228         if want, got := 4, out; want != got {
 229                 t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
 230                         want, got)
 231         }
 232 }
 233
 234 func TestVMJumpIfGreaterOrEqual(t *testing.T) {
 235         vm, done, err := testVM(t, []bpf.Instruction{
 236                 bpf.LoadAbsolute{
 237                         Off:  8,
 238                         Size: 4,
 239                 },
 240                 bpf.JumpIf{
 241                         Cond:     bpf.JumpGreaterOrEqual,
 242                         Val:      0x00010203,
 243                         SkipTrue: 1,
 244                 },
 245                 bpf.RetConstant{
 246                         Val: 0,
 247                 },
 248                 bpf.RetConstant{
 249                         Val: 12,
 250                 },
 251         })
 252         if err != nil {
 253                 t.Fatalf("failed to load BPF program: %v", err)
 254         }
 255         defer done()
 256
 257         out, err := vm.Run([]byte{
 258                 0xff, 0xff, 0xff, 0xff,
 259                 0xff, 0xff, 0xff, 0xff,
 260                 0, 1, 2, 3,
 261         })
 262         if err != nil {
 263                 t.Fatalf("unexpected error while running program: %v", err)
 264         }
 265         if want, got := 4, out; want != got {
 266                 t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
 267                         want, got)
 268         }
 269 }
 270
 271 func TestVMJumpIfLessOrEqual(t *testing.T) {
 272         vm, done, err := testVM(t, []bpf.Instruction{
 273                 bpf.LoadAbsolute{
 274                         Off:  8,
 275                         Size: 4,
 276                 },
 277                 bpf.JumpIf{
 278                         Cond:     bpf.JumpLessOrEqual,
 279                         Val:      0xff010203,
 280                         SkipTrue: 1,
 281                 },
 282                 bpf.RetConstant{
 283                         Val: 0,
 284                 },
 285                 bpf.RetConstant{
 286                         Val: 12,
 287                 },
 288         })
 289         if err != nil {
 290                 t.Fatalf("failed to load BPF program: %v", err)
 291         }
 292         defer done()
 293
 294         out, err := vm.Run([]byte{
 295                 0xff, 0xff, 0xff, 0xff,
 296                 0xff, 0xff, 0xff, 0xff,
 297                 0, 1, 2, 3,
 298         })
 299         if err != nil {
 300                 t.Fatalf("unexpected error while running program: %v", err)
 301         }
 302         if want, got := 4, out; want != got {
 303                 t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
 304                         want, got)
 305         }
 306 }
 307
 308 func TestVMJumpIfBitsSet(t *testing.T) {
 309         vm, done, err := testVM(t, []bpf.Instruction{
 310                 bpf.LoadAbsolute{
 311                         Off:  8,
 312                         Size: 2,
 313                 },
 314                 bpf.JumpIf{
 315                         Cond:     bpf.JumpBitsSet,
 316                         Val:      0x1122,
 317                         SkipTrue: 1,
 318                 },
 319                 bpf.RetConstant{
 320                         Val: 0,
 321                 },
 322                 bpf.RetConstant{
 323                         Val: 10,
 324                 },
 325         })
 326         if err != nil {
 327                 t.Fatalf("failed to load BPF program: %v", err)
 328         }
 329         defer done()
 330
 331         out, err := vm.Run([]byte{
 332                 0xff, 0xff, 0xff, 0xff,
 333                 0xff, 0xff, 0xff, 0xff,
 334                 0x01, 0x02,
 335         })
 336         if err != nil {
 337                 t.Fatalf("unexpected error while running program: %v", err)
 338         }
 339         if want, got := 2, out; want != got {
 340                 t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
 341                         want, got)
 342         }
 343 }
 344
 345 func TestVMJumpIfBitsNotSet(t *testing.T) {
 346         vm, done, err := testVM(t, []bpf.Instruction{
 347                 bpf.LoadAbsolute{
 348                         Off:  8,
 349                         Size: 2,
 350                 },
 351                 bpf.JumpIf{
 352                         Cond:     bpf.JumpBitsNotSet,
 353                         Val:      0x1221,
 354                         SkipTrue: 1,
 355                 },
 356                 bpf.RetConstant{
 357                         Val: 0,
 358                 },
 359                 bpf.RetConstant{
 360                         Val: 10,
 361                 },
 362         })
 363         if err != nil {
 364                 t.Fatalf("failed to load BPF program: %v", err)
 365         }
 366         defer done()
 367
 368         out, err := vm.Run([]byte{
 369                 0xff, 0xff, 0xff, 0xff,
 370                 0xff, 0xff, 0xff, 0xff,
 371                 0x01, 0x02,
 372         })
 373         if err != nil {
 374                 t.Fatalf("unexpected error while running program: %v", err)
 375         }
 376         if want, got := 2, out; want != got {
 377                 t.Fatalf("unexpected number of output bytes:\n- want: %d\n-  got: %d",
 378                         want, got)
 379         }
 380 }