about summary refs log blame commit diff stats
path: root/src/bindings/libseccomp.nim
blob: 81a6e96993131e7a73af79c95edf3cc7c9e03c55 (plain) (tree)
















































                                                                           
import std/macros

const seccomp = (proc(): string =
  let res = staticExec("pkg-config --libs --silence-errors libseccomp")
  if res == "":
    error("Couldn't find libseccomp on your computer!  Please install " &
      "libseccomp (e.g. apt install libseccomp-dev), or build with " &
      "`make CHA_DANGER_DISABLE_SANDBOX=1'.")
  return res
)()

type
  scmp_filter_ctx* = distinct pointer

  scmp_datum_t* = uint64

  scmp_compare* {.size: sizeof(cint).} = enum
    N_SCMP_CMP_MIN = 0
    SCMP_CMP_NE = 1 # not equal
    SCMP_CMP_LT = 2 # less than
    SCMP_CMP_LE = 3 # less than or equal
    SCMP_CMP_EQ = 4 # equal
    SCMP_CMP_GE = 5 # greater than or equal
    SCMP_CMP_GT = 6 # greater than
    SCMP_CMP_MASKED_EQ = 7 # masked equality

  scmp_arg_cmp* = object
    arg*: cuint
    op*: scmp_compare
    datum_a*: scmp_datum_t
    datum_b*: scmp_datum_t

{.push importc.}
{.passl: seccomp.}

const SCMP_ACT_KILL_PROCESS* = 0x80000000u32
const SCMP_ACT_ALLOW* = 0x7FFF0000u32
const SCMP_ACT_TRAP* = 0x00030000u32

proc seccomp_init*(def_action: uint32): scmp_filter_ctx
proc seccomp_reset*(ctx: scmp_filter_ctx; def_action: uint32): cint
proc seccomp_syscall_resolve_name*(name: cstring): cint
proc seccomp_syscall_resolve_name_rewrite*(name: cstring): cint
proc seccomp_rule_add*(ctx: scmp_filter_ctx; action: uint32; syscall: cint;
  arg_cnt: cuint): cint {.varargs.}
proc seccomp_load*(ctx: scmp_filter_ctx): cint
proc seccomp_release*(ctx: scmp_filter_ctx)

{.pop.}
class='alt'>
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89


               
                     




















                                          
                        

                                        



                            
                                           





                           



                          

                                      



                                      

                                                               

                                                                  
                                                            






                                              



                           

                            



                                    
                                               


                                         
                           
                         

         

                                                                   

                                                                          
                                                                 

 
                                
                         
 
package widgets

import (
	"sync/atomic"
	"time"

	"github.com/gdamore/tcell"

	"git.sr.ht/~sircmpwn/aerc2/lib/ui"
)

var (
	frames = []string{
		"[..]    ",
		" [..]   ",
		"  [..]  ",
		"   [..] ",
		"    [..]",
		"   [..] ",
		"  [..]  ",
		" [..]   ",
	}
)

type Spinner struct {
	ui.Invalidatable
	frame int64 // access via atomic
	stop  chan struct{}
}

func NewSpinner() *Spinner {
	spinner := Spinner{
		stop:  make(chan struct{}),
		frame: -1,
	}
	return &spinner
}

func (s *Spinner) Start() {
	if s.IsRunning() {
		return
	}

	atomic.StoreInt64(&s.frame, 0)

	go func() {
		for {
			select {
			case <-s.stop:
				atomic.StoreInt64(&s.frame, -1)
				s.stop <- struct{}{}
				return
			case <-time.After(200 * time.Millisecond):
				atomic.AddInt64(&s.frame, 1)
				s.Invalidate()
			}
		}
	}()
}

func (s *Spinner) Stop() {
	if !s.IsRunning() {
		return
	}

	s.stop <- struct{}{}
	<-s.stop
	s.Invalidate()
}

func (s *Spinner) IsRunning() bool {
	return atomic.LoadInt64(&s.frame) != -1
}

func (s *Spinner) Draw(ctx *ui.Context) {
	if !s.IsRunning() {
		s.Start()
	}

	cur := int(atomic.LoadInt64(&s.frame) % int64(len(frames)))

	ctx.Fill(0, 0, ctx.Width(), ctx.Height(), ' ', tcell.StyleDefault)
	col := ctx.Width()/2 - len(frames[0])/2 + 1
	ctx.Printf(col, 0, tcell.StyleDefault, "%s", frames[cur])
}

func (s *Spinner) Invalidate() {
	s.DoInvalidate(s)
}