#!/bin/sh
#
# /etc/rc.d/rc.vanguards-annode
#
# vanguards instance for annode's tor-data Tor, which runs inside the
# annode network namespace with ControlPort 20051 bound to 127.0.0.1
# *inside that netns*. Runs in every netmode (strict, open, clearnet),
# because tor-data runs in every mode.
#
# We locate the tor-data process via its cgroup (/annode/tor) and enter
# its network namespace with nsenter, so vanguards can reach 20051 on
# that netns' loopback. The process owner is `annode`, so vanguards
# runs as annode and reads annode's cookie file without any permission
# gymnastics on ~annode.

VANGUARDS_BIN="/usr/local/bin/vanguards"
VANGUARDS_STATE="/var/lib/vanguards/annode/annode.state"
VANGUARDS_PID="/run/vanguards/annode/annode.pid"
VANGUARDS_LOG="/var/log/vanguards/annode/annode.log"
VANGUARDS_USER="annode"
CONTROL_PORT="20051"

# Where tor-data's process lives. Override in /etc/netmode.conf-style
# setups if the cgroup path ever changes.
ANNODE_TOR_CGROUP_PROCS="${ANNODE_TOR_CGROUP_PROCS:-/sys/fs/cgroup/annode/tor/cgroup.procs}"

# ---------------------------------------------------------------------------
# Find a live pid in the annode/tor cgroup. That pid's network namespace
# is the one tor-data is listening in; any live pid in the cgroup will do,
# because the cgroup is a leaf under the netns.
# ---------------------------------------------------------------------------
find_annode_pid() {
  [ -r "$ANNODE_TOR_CGROUP_PROCS" ] || return 1
  local p
  while read -r p; do
    [ -n "$p" ] || continue
    if kill -0 "$p" 2>/dev/null; then
      echo "$p"
      return 0
    fi
  done < "$ANNODE_TOR_CGROUP_PROCS"
  return 1
}

# Match only the annode instance: it's the only vanguards launched with
# --control_port 20051. (The system instance uses --config /etc/vanguards.)
find_pid() {
  pgrep -u "$VANGUARDS_USER" -f \
    "vanguards[.]py.*--control_port $CONTROL_PORT" 2>/dev/null | head -1
}

vanguards_start() {
  if [ ! -x "$VANGUARDS_BIN" ]; then
    echo "ERROR: $VANGUARDS_BIN not found or not executable." >&2
    return 1
  fi

  local annode_pid
  annode_pid=$(find_annode_pid)
  if [ -z "$annode_pid" ]; then
    echo "vanguards-annode: no live pid in $ANNODE_TOR_CGROUP_PROCS;" \
         "is tor-data running?" >&2
    return 1
  fi

  local pid
  pid=$(find_pid)
  if [ -n "$pid" ]; then
    echo "$pid" > "$VANGUARDS_PID"
    echo "vanguards-annode already running (pid $pid)."
    return 0
  fi

  mkdir -p "$(dirname $VANGUARDS_PID)" "$(dirname $VANGUARDS_STATE)" \
           "$(dirname $VANGUARDS_LOG)"
  chown "$VANGUARDS_USER:$VANGUARDS_USER" \
    "$(dirname $VANGUARDS_PID)" "$(dirname $VANGUARDS_STATE)" \
    "$(dirname $VANGUARDS_LOG)" 2>/dev/null
  touch "$VANGUARDS_LOG"
  chown "$VANGUARDS_USER:$VANGUARDS_USER" "$VANGUARDS_LOG" 2>/dev/null
  chmod 0640 "$VANGUARDS_LOG"

  echo "Starting vanguards-annode (netns of pid $annode_pid, port $CONTROL_PORT)..."

  nohup nsenter -t "$annode_pid" -n \
    su -s /bin/sh -c \
      "exec $VANGUARDS_BIN --control_port $CONTROL_PORT \
         --state $VANGUARDS_STATE" \
      "$VANGUARDS_USER" \
    3>&- 4>&- 5>&- 6>&- 7>&- 8>&- 9>&- \
    >> "$VANGUARDS_LOG" 2>&1 < /dev/null &

  # Poll up to 10s. Launch chain is:
  #   nohup -> nsenter -> su (PAM) -> sh -> exec python3 -> import stem
  # which easily exceeds 2s on first invocation.
  local i=0
  while [ "$i" -lt 10 ]; do
    pid=$(find_pid)
    [ -n "$pid" ] && break
    sleep 1
    i=$((i + 1))
  done

  if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
    echo "$pid" > "$VANGUARDS_PID"
    echo "vanguards-annode started (pid $pid)."
    return 0
  fi

  {
    echo "vanguards-annode failed to start; check $VANGUARDS_LOG"
    echo "  log size:   $(wc -c < "$VANGUARDS_LOG" 2>/dev/null || echo unknown) bytes"
    echo "  state dir:  $(ls -ld "$(dirname "$VANGUARDS_STATE")" 2>&1 || true)"
  } >&2
  return 1
}

vanguards_stop() {
  local pid
  pid=$(cat "$VANGUARDS_PID" 2>/dev/null)
  [ -z "$pid" ] && pid=$(find_pid)

  if [ -z "$pid" ]; then
    echo "vanguards-annode is not running."
    rm -f "$VANGUARDS_PID"
    return 0
  fi

  echo "Stopping vanguards-annode (pid $pid)..."
  kill "$pid" 2>/dev/null
  local i=0
  while [ "$i" -lt 5 ] && kill -0 "$pid" 2>/dev/null; do
    sleep 1
    i=$((i + 1))
  done
  kill -0 "$pid" 2>/dev/null && kill -9 "$pid" 2>/dev/null

  rm -f "$VANGUARDS_PID"
}

vanguards_restart() { vanguards_stop; vanguards_start; }

vanguards_status() {
  local pid
  pid=$(cat "$VANGUARDS_PID" 2>/dev/null)
  [ -z "$pid" ] && pid=$(find_pid)
  if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
    echo "vanguards-annode is running (pid $pid)."
    return 0
  else
    echo "vanguards-annode is not running."
    return 1
  fi
}

case "$1" in
  start)   vanguards_start   ;;
  stop)    vanguards_stop    ;;
  restart) vanguards_restart ;;
  status)  vanguards_status  ;;
  *) echo "Usage: $0 {start|stop|restart|status}"; exit 1 ;;
esac

exit 0