Convert sandbox_bpf_unittest.cc to use bpf_dsl

sandbox/linux/bpf_dsl/bpf_dsl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sandbox/linux/bpf_dsl/bpf_dsl.h"
 
 #include <errno.h>
 
 #include <limits>
 
@@ skipping 31 matching lines @@
   }
 
  private:
   virtual ~ErrorResultExprImpl() {}
 
   int err_;
 
   DISALLOW_COPY_AND_ASSIGN(ErrorResultExprImpl);
 };
 
+class KillResultExprImpl : public internal::ResultExprImpl {
+ public:
+  explicit KillResultExprImpl(const char* msg) : msg_(msg) { DCHECK(msg_); }
+
+  virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
+    return sb->Kill(msg_);
+  }
+
+ private:
+  virtual ~KillResultExprImpl() {}
+
+  const char* msg_;
+
+  DISALLOW_COPY_AND_ASSIGN(KillResultExprImpl);
+};
+
+class TraceResultExprImpl : public internal::ResultExprImpl {
+ public:
+  TraceResultExprImpl(uint16_t aux) : aux_(aux) {}
+
+  virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
+    return ErrorCode(ErrorCode::ERR_TRACE + aux_);
+  }
+
+ private:
+  virtual ~TraceResultExprImpl() {}
+
+  uint16_t aux_;
+
+  DISALLOW_COPY_AND_ASSIGN(TraceResultExprImpl);
+};
+
 class TrapResultExprImpl : public internal::ResultExprImpl {
  public:
-  TrapResultExprImpl(Trap::TrapFnc func, void* arg) : func_(func), arg_(arg) {
+  TrapResultExprImpl(Trap::TrapFnc func, const void* arg)
+      : func_(func), arg_(arg) {
     DCHECK(func_);
   }
 
   virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
     return sb->Trap(func_, arg_);
   }
 
  private:
   virtual ~TrapResultExprImpl() {}
 
   Trap::TrapFnc func_;
-  void* arg_;
+  const void* arg_;
 
   DISALLOW_COPY_AND_ASSIGN(TrapResultExprImpl);
 };
 
+class UnsafeTrapResultExprImpl : public internal::ResultExprImpl {
+ public:
+  UnsafeTrapResultExprImpl(Trap::TrapFnc func, const void* arg)
+      : func_(func), arg_(arg) {
+    DCHECK(func_);
+  }
+
+  virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
+    return sb->UnsafeTrap(func_, arg_);
+  }
+
+ private:
+  virtual ~UnsafeTrapResultExprImpl() {}
+
+  Trap::TrapFnc func_;
+  const void* arg_;
+
+  DISALLOW_COPY_AND_ASSIGN(UnsafeTrapResultExprImpl);
+};
+
 class IfThenResultExprImpl : public internal::ResultExprImpl {
  public:
   IfThenResultExprImpl(const BoolExpr& cond,
                        const ResultExpr& then_result,
                        const ResultExpr& else_result)
       : cond_(cond), then_result_(then_result), else_result_(else_result) {}
 
   virtual ErrorCode Compile(SandboxBPF* sb) const OVERRIDE {
     return cond_->Compile(
         sb, then_result_->Compile(sb), else_result_->Compile(sb));
@@ skipping 140 matching lines @@
 }  // namespace internal
 
 ResultExpr Allow() {
   return ResultExpr(new const AllowResultExprImpl());
 }
 
 ResultExpr Error(int err) {
   return ResultExpr(new const ErrorResultExprImpl(err));
 }
 
-ResultExpr Trap(Trap::TrapFnc trap_func, void* aux) {
+ResultExpr Kill(const char* msg) {
+  return ResultExpr(new const KillResultExprImpl(msg));
+}
+
+ResultExpr Trace(uint16_t aux) {
+  return ResultExpr(new const TraceResultExprImpl(aux));
+}
+
+ResultExpr Trap(Trap::TrapFnc trap_func, const void* aux) {
   return ResultExpr(new const TrapResultExprImpl(trap_func, aux));
 }
 
+ResultExpr UnsafeTrap(Trap::TrapFnc trap_func, const void* aux) {
+  return ResultExpr(new const UnsafeTrapResultExprImpl(trap_func, aux));
+}
+
 BoolExpr BoolConst(bool value) {
   return BoolExpr(new const ConstBoolExprImpl(value));
 }
 
 BoolExpr operator!(const BoolExpr& cond) {
   return BoolExpr(new const NegateBoolExprImpl(cond));
 }
 
 BoolExpr operator&&(const BoolExpr& lhs, const BoolExpr& rhs) {
   return BoolExpr(new const AndBoolExprImpl(lhs, rhs));
@@ skipping 59 matching lines @@
 
 ErrorCode SandboxBPFDSLPolicy::EvaluateSyscall(SandboxBPF* sb,
                                                int sysno) const {
   return EvaluateSyscall(sysno)->Compile(sb);
 }
 
 ErrorCode SandboxBPFDSLPolicy::InvalidSyscall(SandboxBPF* sb) const {
   return InvalidSyscall()->Compile(sb);
 }
 
-ResultExpr SandboxBPFDSLPolicy::Trap(Trap::TrapFnc trap_func, void* aux) {
+ResultExpr SandboxBPFDSLPolicy::Trap(Trap::TrapFnc trap_func, const void* aux) {
   return bpf_dsl::Trap(trap_func, aux);
 }
 
 }  // namespace bpf_dsl
 }  // namespace sandbox