#
# Common functions used by pktgen scripts
#  - Depending on bash 3 (or higher) syntax
#
# Author: Jesper Dangaaard Brouer
# License: GPL

## -- General shell logging cmds --
proc err {
    var exitcode = $1
    shift
    echo "ERROR: $ifsjoin(Argv)" > !2
    exit $exitcode
}

proc warn {
    echo "WARN : $ifsjoin(Argv)" > !2
}

proc info {
    if [[ -n "$VERBOSE" ]] {
	echo "INFO : $ifsjoin(Argv)" > !2
    }
}

## -- Pktgen proc config commands -- ##
export PROC_DIR=/proc/net/pktgen
#
# Three different shell functions for configuring the different
# components of pktgen:
#   pg_ctrl(), pg_thread() and pg_set().
#
# These functions correspond to pktgens different components.
# * pg_ctrl()   control "pgctrl" (/proc/net/pktgen/pgctrl)
# * pg_thread() control the kernel threads and binding to devices
# * pg_set()    control setup of individual devices
proc pg_ctrl {
    var proc_file = '"pgctrl'"
    proc_cmd $(proc_file) @Argv
}

proc pg_thread {
    var thread = $1
    var proc_file = ""kpktgend_$(thread)""
    shift
    proc_cmd $(proc_file) @Argv
}

proc pg_set {
    var dev = $1
    var proc_file = $dev
    shift
    proc_cmd $(proc_file) @Argv
}

# More generic replacement for pgset(), that does not depend on global
# variable for proc file.
proc proc_cmd {
    var result = ''
    var proc_file = $1
    # after shift, the remaining args are contained in $@
    shift
    var proc_ctrl = "$(PROC_DIR)/$proc_file"
    if [[ ! -e "$proc_ctrl" ]] {
	err 3 "proc file:$proc_ctrl does not exists (dev added to thread?)"
    } else {
	if [[ ! -w "$proc_ctrl" ]] {
	    err 4 "proc file:$proc_ctrl not writable, not root?!"
	}
    }

    if [[ "$DEBUG" == "yes" ]] {
	echo "cmd: $ifsjoin(Argv) > $proc_ctrl"
    }
    # Quoting of "$@" is important for space expansion
    echo @Argv > $proc_ctrl
    var status = $Status

    result := $[grep "Result: OK:" $proc_ctrl]
    # Due to pgctrl, cannot use exit code $? from grep
    if [[ "$result" == "" ]] {
	grep "Result:" $proc_ctrl > !2
    }
    if (( $status != 0 )) {
	err 5 "Write error($status) occurred cmd: \"$ifsjoin(Argv) > $proc_ctrl\""
    }
}

# Old obsolete "pgset" function, with slightly improved err handling
proc pgset {
    var result = ''

    if [[ "$DEBUG" == "yes" ]] {
	echo "cmd: $1 > $PGDEV"
    }
    echo $1 > $PGDEV
    var status = $Status

    result := $[cat $PGDEV | fgrep "Result: OK:]
    if [[ "$result" == "" ]] {
         cat $PGDEV | fgrep Result:
    }
    if (( $status != 0 )) {
	err 5 "Write error($status) occurred cmd: \"$1 > $PGDEV\""
    }
}

## -- General shell tricks --

proc root_check_run_with_sudo {
    # Trick so, program can be run as normal user, will just use "sudo"
    #  call as root_check_run_as_sudo "$@"
    if test $EUID -ne 0 {
	if test -x $0 { # Directly executable use sudo
	    info "Not root, running with sudo"
            sudo $0 @Argv
            exit $Status
	}
	err 4 "cannot perform sudo run of $0"
    }
}
(CommandList
  children: [
    (FuncDef
      name: err
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:exitcode)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [33]
                )
              ]
              spids: [31]
            )
            (C {(shift)})
            (SimpleCommand
              words: [{(echo)} {(DQ ("ERROR: ") ($ VSub_At "$@"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[47])]
            )
            (C {(exit)} {($ VSub_Name "$exitcode")})
          ]
          spids: [28]
        )
      spids: [22 27]
    )
    (FuncDef
      name: warn
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(echo)} {(DQ ("WARN : ") ($ VSub_At "$@"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[74])]
            )
          ]
          spids: [64]
        )
      spids: [58 63]
    )
    (FuncDef
      name: info
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_Name "$VERBOSE"))})
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ("INFO : ") ($ VSub_At "$@"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[112])]
                    )
                  ]
                  spids: [-1 102]
                )
              ]
              spids: [-1 116]
            )
          ]
          spids: [86]
        )
      spids: [80 85]
    )
    (C {(export)} {(Lit_VarLike "PROC_DIR=") (/proc/net/pktgen)})
    (FuncDef
      name: pg_ctrl
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:proc_file)
                  op: Equal
                  rhs: {(DQ (pgctrl))}
                  spids: [167]
                )
              ]
              spids: [165]
            )
            (C {(proc_cmd)} {(${ VSub_Name proc_file)} {(DQ ($ VSub_At "$@"))})
          ]
          spids: [162]
        )
      spids: [156 161]
    )
    (FuncDef
      name: pg_thread
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:thread)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [197]
                )
              ]
              spids: [195]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:proc_file)
                  op: Equal
                  rhs: {(DQ (kpktgend_) (${ VSub_Name thread))}
                  spids: [203]
                )
              ]
              spids: [201]
            )
            (C {(shift)})
            (C {(proc_cmd)} {(${ VSub_Name proc_file)} {(DQ ($ VSub_At "$@"))})
          ]
          spids: [192]
        )
      spids: [186 191]
    )
    (FuncDef
      name: pg_set
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:dev)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [239]
                )
              ]
              spids: [237]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:proc_file)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$dev"))}
                  spids: [245]
                )
              ]
              spids: [243]
            )
            (C {(shift)})
            (C {(proc_cmd)} {(${ VSub_Name proc_file)} {(DQ ($ VSub_At "$@"))})
          ]
          spids: [234]
        )
      spids: [228 233]
    )
    (FuncDef
      name: proc_cmd
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:result) op:Equal spids:[284])]
              spids: [282]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:proc_file)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [289]
                )
              ]
              spids: [287]
            )
            (C {(shift)})
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:proc_ctrl)
                  op: Equal
                  rhs: {(${ VSub_Name PROC_DIR) (/) ($ VSub_Name "$proc_file")}
                  spids: [302]
                )
              ]
              spids: [300]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (LogicalNot
                              child: 
                                (BoolUnary
                                  op_id: BoolUnary_e
                                  child: {(DQ ($ VSub_Name "$proc_ctrl"))}
                                )
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(err)} {(3)} 
                      {
                        (DQ ("proc file:") ($ VSub_Name "$proc_ctrl") 
                          (" does not exists (dev added to thread?)")
                        )
                      }
                    )
                  ]
                  spids: [-1 325]
                )
              ]
              else_action: [
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (DBracket
                              expr: 
                                (LogicalNot
                                  child: 
                                    (BoolUnary
                                      op_id: BoolUnary_w
                                      child: {(DQ ($ VSub_Name "$proc_ctrl"))}
                                    )
                                )
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (C {(err)} {(4)} 
                          {
                            (DQ ("proc file:") ($ VSub_Name "$proc_ctrl") (" not writable, not root?!"))
                          }
                        )
                      ]
                      spids: [-1 357]
                    )
                  ]
                  spids: [-1 371]
                )
              ]
              spids: [339 374]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(DQ ($ VSub_Name "$DEBUG"))}
                              right: {(DQ (yes))}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ ("cmd: ") ($ VSub_At "$@") (" > ") ($ VSub_Name "$proc_ctrl"))})
                  ]
                  spids: [-1 395]
                )
              ]
              spids: [-1 408]
            )
            (SimpleCommand
              words: [{(echo)} {(DQ ($ VSub_At "$@"))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$proc_ctrl"))}
                  spids: [421]
                )
              ]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:status)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [430]
                )
              ]
              spids: [428]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:result)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(grep)} {(DQ ("Result: OK:"))} {($ VSub_Name "$proc_ctrl")})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [436 444]
                      )
                    }
                  spids: [435]
                )
              ]
              spids: [435]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(DQ ($ VSub_Name "$result"))}
                              right: {(DQ )}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(grep)} {(DQ ("Result:"))} {($ VSub_Name "$proc_ctrl")}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[478])]
                    )
                  ]
                  spids: [-1 467]
                )
              ]
              spids: [-1 482]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DParen
                          child: 
                            (ArithBinary
                              op_id: Arith_NEqual
                              left: (ArithWord w:{($ VSub_Name "$status")})
                              right: (ArithWord w:{(Lit_Digits 0)})
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(err)} {(5)} 
                      {
                        (DQ ("Write error(") ($ VSub_Name "$status") (") occurred cmd: ") 
                          (EscapedLiteralPart
                            token: <Lit_EscapedChar "\\\"">
                          ) ($ VSub_At "$@") (" > ") ($ VSub_Name "$proc_ctrl") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                        )
                      }
                    )
                  ]
                  spids: [-1 499]
                )
              ]
              spids: [-1 518]
            )
          ]
          spids: [279]
        )
      spids: [273 278]
    )
    (FuncDef
      name: pgset
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:result) op:Equal spids:[537])]
              spids: [535]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(DQ ($ VSub_Name "$DEBUG"))}
                              right: {(DQ (yes))}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ ("cmd: ") ($ VSub_Number "$1") (" > ") ($ VSub_Name "$PGDEV"))})
                  ]
                  spids: [-1 558]
                )
              ]
              spids: [-1 571]
            )
            (SimpleCommand
              words: [{(echo)} {($ VSub_Number "$1")}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {($ VSub_Name "$PGDEV")}
                  spids: [578]
                )
              ]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:status)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [585]
                )
              ]
              spids: [583]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:result)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(cat)} {($ VSub_Name "$PGDEV")})
                                  (C {(fgrep)} {(DQ ("Result: OK:"))})
                                ]
                                negated: False
                              )
                            ]
                          )
                        left_token: <Left_Backtick "`">
                        spids: [591 603]
                      )
                    }
                  spids: [590]
                )
              ]
              spids: [590]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(DQ ($ VSub_Name "$result"))}
                              right: {(DQ )}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Pipeline
                      children: [
                        (C {(cat)} {($ VSub_Name "$PGDEV")})
                        (C {(fgrep)} {(Result) (Lit_Other ":")})
                      ]
                      negated: False
                    )
                  ]
                  spids: [-1 622]
                )
              ]
              spids: [-1 637]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DParen
                          child: 
                            (ArithBinary
                              op_id: Arith_NEqual
                              left: (ArithWord w:{($ VSub_Name "$status")})
                              right: (ArithWord w:{(Lit_Digits 0)})
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(err)} {(5)} 
                      {
                        (DQ ("Write error(") ($ VSub_Name "$status") (") occurred cmd: ") 
                          (EscapedLiteralPart
                            token: <Lit_EscapedChar "\\\"">
                          ) ($ VSub_Number "$1") (" > ") ($ VSub_Name "$PGDEV") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                        )
                      }
                    )
                  ]
                  spids: [-1 654]
                )
              ]
              spids: [-1 673]
            )
          ]
          spids: [532]
        )
      spids: [526 531]
    )
    (FuncDef
      name: root_check_run_with_sudo
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$EUID"))} {(-ne)} {(0)} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-x)} {($ VSub_Number "$0")} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(info)} {(DQ ("Not root, running with sudo"))})
                            (C {(sudo)} {(DQ ($ VSub_Number "$0"))} {(DQ ($ VSub_At "$@"))})
                            (C {(exit)} {($ VSub_QMark "$?")})
                          ]
                          spids: [-1 728]
                        )
                      ]
                      spids: [-1 757]
                    )
                    (C {(err)} {(4)} {(DQ ("cannot perform sudo run of ") ($ VSub_Number "$0"))})
                  ]
                  spids: [-1 714]
                )
              ]
              spids: [-1 770]
            )
          ]
          spids: [688]
        )
      spids: [682 687]
    )
  ]
)