mirror of
https://github.com/kiddin9/op-packages.git
synced 2026-11-05 18:44:03 +08:00
641 lines
20 KiB
Bash
Executable File
641 lines
20 KiB
Bash
Executable File
#!/bin/sh
|
|
# ubus RPC module for Quick Actions VLAN tab.
|
|
# Params arrive on stdin as JSON. No positional args.
|
|
|
|
. /usr/share/libubox/jshn.sh
|
|
|
|
VLAN_DIR=/etc/quickactions/vlan
|
|
TPL_DIR=$VLAN_DIR/templates
|
|
GEN_DIR=$VLAN_DIR/generated
|
|
mkdir -p "$VLAN_DIR" "$TPL_DIR" "$GEN_DIR"
|
|
|
|
list_methods() {
|
|
cat <<'EOF'
|
|
{
|
|
"detect": {},
|
|
"preview": { "plan": "string" },
|
|
"apply": { "plan": "string", "safe": "string" },
|
|
"snapshot": { "note": "string" },
|
|
"list_snapshots": {},
|
|
"restore": { "path": "string" },
|
|
"confirm": {},
|
|
"generate_cli": { "plan": "string", "target": "string" },
|
|
"save_template": { "name": "string", "target": "string", "plan": "string", "notes": "string" },
|
|
"list_templates": {},
|
|
"load_template": { "name": "string" },
|
|
"delete_template": { "name": "string" },
|
|
"save_generated": { "name": "string", "target": "string", "content": "string" },
|
|
"list_generated": {},
|
|
"delete_generated": { "name": "string" },
|
|
"lldp_neighbors": {},
|
|
"snmp_query": { "ip": "string", "community": "string" },
|
|
"bridge_vlan_show": {},
|
|
"kernel_ifaces": {},
|
|
"iface_stats": { "ifaces": "string" },
|
|
"ping_test": { "iface": "string", "ip": "string" }
|
|
}
|
|
EOF
|
|
}
|
|
|
|
# read stdin and populate named vars (var=json_key pairs)
|
|
_load() {
|
|
local payload
|
|
payload=$(cat)
|
|
json_load "$payload"
|
|
while [ "$#" -ge 2 ]; do
|
|
eval "$1=\"\$(json_get_var __v '$2'; echo \$__v)\""
|
|
shift 2
|
|
done
|
|
}
|
|
|
|
detect() {
|
|
json_init
|
|
local mode="none"
|
|
uci show network 2>/dev/null | grep -q "\.type='bridge'" && mode="dsa"
|
|
uci show network 2>/dev/null | grep -q "^network\.@switch\[0\]" && mode="swconfig"
|
|
|
|
json_add_string "mode" "$mode"
|
|
|
|
json_add_array "bridges"
|
|
for s in $(uci show network 2>/dev/null | grep "=device$" | cut -d. -f2 | cut -d= -f1); do
|
|
t=$(uci -q get "network.$s.type")
|
|
[ "$t" != "bridge" ] && continue
|
|
name=$(uci -q get "network.$s.name")
|
|
[ -z "$name" ] && name="$s"
|
|
json_add_object
|
|
json_add_string "sid" "$s"
|
|
json_add_string "name" "$name"
|
|
vf=$(uci -q get "network.$s.vlan_filtering")
|
|
json_add_string "vlan_filtering" "${vf:-0}"
|
|
json_close_object
|
|
done
|
|
json_close_array
|
|
|
|
json_add_array "bridge_vlans"
|
|
for s in $(uci show network 2>/dev/null | grep "=bridge-vlan$" | cut -d. -f2 | cut -d= -f1); do
|
|
json_add_object
|
|
json_add_string "sid" "$s"
|
|
json_add_string "device" "$(uci -q get network.$s.device)"
|
|
json_add_string "vlan" "$(uci -q get network.$s.vlan)"
|
|
json_add_string "ports" "$(uci -q get network.$s.ports | tr '\n' ' ')"
|
|
json_close_object
|
|
done
|
|
json_close_array
|
|
|
|
json_add_array "interfaces"
|
|
for s in $(uci show network 2>/dev/null | grep "=interface$" | cut -d. -f2 | cut -d= -f1); do
|
|
json_add_object
|
|
json_add_string "sid" "$s"
|
|
json_add_string "device" "$(uci -q get network.$s.device)"
|
|
json_add_string "proto" "$(uci -q get network.$s.proto)"
|
|
json_add_string "ipaddr" "$(uci -q get network.$s.ipaddr)"
|
|
json_add_string "netmask" "$(uci -q get network.$s.netmask)"
|
|
json_close_object
|
|
done
|
|
json_close_array
|
|
|
|
json_add_array "dhcp"
|
|
for s in $(uci show dhcp 2>/dev/null | grep "=dhcp$" | cut -d. -f2 | cut -d= -f1); do
|
|
json_add_object
|
|
json_add_string "sid" "$s"
|
|
json_add_string "interface" "$(uci -q get dhcp.$s.interface)"
|
|
json_add_string "start" "$(uci -q get dhcp.$s.start)"
|
|
json_add_string "limit" "$(uci -q get dhcp.$s.limit)"
|
|
json_close_object
|
|
done
|
|
json_close_array
|
|
|
|
json_add_array "zones"
|
|
local i=0
|
|
while true; do
|
|
local name
|
|
name=$(uci -q get "firewall.@zone[$i].name")
|
|
[ -z "$name" ] && break
|
|
json_add_object
|
|
json_add_string "name" "$name"
|
|
json_add_string "network" "$(uci -q get firewall.@zone[$i].network | tr '\n' ' ')"
|
|
json_add_string "input" "$(uci -q get firewall.@zone[$i].input)"
|
|
json_add_string "output" "$(uci -q get firewall.@zone[$i].output)"
|
|
json_add_string "forward" "$(uci -q get firewall.@zone[$i].forward)"
|
|
json_close_object
|
|
i=$((i + 1))
|
|
done
|
|
json_close_array
|
|
|
|
json_add_array "wifi"
|
|
for s in $(uci show wireless 2>/dev/null | grep "=wifi-iface$" | cut -d. -f2 | cut -d= -f1); do
|
|
json_add_object
|
|
json_add_string "sid" "$s"
|
|
json_add_string "device" "$(uci -q get wireless.$s.device)"
|
|
json_add_string "mode" "$(uci -q get wireless.$s.mode)"
|
|
json_add_string "ssid" "$(uci -q get wireless.$s.ssid)"
|
|
json_add_string "network" "$(uci -q get wireless.$s.network)"
|
|
json_close_object
|
|
done
|
|
json_close_array
|
|
|
|
json_add_array "easymesh"
|
|
for iface in /sys/class/net/bat0.*; do
|
|
[ -e "$iface" ] || continue
|
|
json_add_string "" "$(basename "$iface")"
|
|
done
|
|
json_close_array
|
|
|
|
json_add_string "kernel" "$(uname -r)"
|
|
json_add_string "mem_mb" "$(awk '/MemTotal/ {print int($2/1024)}' /proc/meminfo 2>/dev/null)"
|
|
json_add_string "hostname" "$(cat /proc/sys/kernel/hostname 2>/dev/null)"
|
|
json_dump
|
|
}
|
|
|
|
kernel_ifaces() {
|
|
json_init
|
|
json_add_array "ifaces"
|
|
for d in /sys/class/net/*; do
|
|
[ -e "$d" ] || continue
|
|
local n
|
|
n=$(basename "$d")
|
|
case "$n" in
|
|
lo|sit*|ip6tnl*|gre*|gretap*|erspan*|ifb*|veth*) continue ;;
|
|
esac
|
|
local up
|
|
up="0"; [ "$(cat "$d/operstate" 2>/dev/null)" = "up" ] && up="1"
|
|
json_add_object
|
|
json_add_string "name" "$n"
|
|
json_add_int "up" "$up"
|
|
json_close_object
|
|
done
|
|
json_close_array
|
|
json_dump
|
|
}
|
|
|
|
preview() {
|
|
local plan
|
|
_load plan plan
|
|
[ -z "$plan" ] && { json_init; json_add_string "error" "no plan"; json_dump; return; }
|
|
echo "$plan" > "$VLAN_DIR/last-plan.json"
|
|
local out
|
|
out=$(
|
|
python3 - <<'PYPREVIEW' 2>&1
|
|
import json
|
|
plan = json.load(open("/etc/quickactions/vlan/last-plan.json"))
|
|
lines = []
|
|
for v in plan.get("vlans", []):
|
|
lines.append("network.%s=bridge-vlan device=%s vlan=%s" % (
|
|
v.get("sid","vlan"), v.get("bridge",""), v.get("vlan","")))
|
|
for i in plan.get("interfaces", []):
|
|
lines.append("network.%s=interface device=%s proto=%s ip=%s" % (
|
|
i.get("name",""), i.get("device",""), i.get("proto",""), i.get("ipaddr","")))
|
|
print("\n".join(lines))
|
|
PYPREVIEW
|
|
)
|
|
json_init
|
|
json_add_string "diff" "$out"
|
|
json_dump
|
|
}
|
|
|
|
apply() {
|
|
local plan safe
|
|
_load plan plan safe safe
|
|
[ -z "$plan" ] && { json_init; json_add_string "error" "no plan"; json_dump; return; }
|
|
[ -z "$safe" ] && safe="0"
|
|
|
|
local ts
|
|
ts=$(date +%Y%m%d-%H%M%S)
|
|
cp /etc/config/network "$VLAN_DIR/network.bak.$ts" 2>/dev/null
|
|
echo "auto before apply" > "$VLAN_DIR/network.bak.$ts.note"
|
|
|
|
echo "$plan" > "$VLAN_DIR/last-plan.json"
|
|
|
|
if ! command -v python3 >/dev/null 2>&1; then
|
|
json_init
|
|
json_add_string "error" "python3 required for VLAN apply"
|
|
json_dump
|
|
return
|
|
fi
|
|
|
|
python3 - <<'PYAPPLY'
|
|
import json, subprocess
|
|
plan = json.load(open("/etc/quickactions/vlan/last-plan.json"))
|
|
|
|
def uci(*args):
|
|
try:
|
|
subprocess.run(["uci"] + list(args), check=True, capture_output=True)
|
|
except subprocess.CalledProcessError:
|
|
return False
|
|
return True
|
|
|
|
for v in plan.get("vlans", []):
|
|
name = v.get("sid") or ("vlan_%s_%s" % (v.get("bridge","br-lan"), v.get("vlan","0")))
|
|
uci("set", "network.%s=bridge-vlan" % name)
|
|
uci("set", "network.%s.device=%s" % (name, v.get("bridge","")))
|
|
uci("set", "network.%s.vlan=%s" % (name, v.get("vlan","")))
|
|
for p in v.get("tagged", []):
|
|
uci("add_list", "network.%s.ports=%s:t" % (name, p))
|
|
for p in v.get("untagged", []):
|
|
uci("add_list", "network.%s.ports=%s:u*" % (name, p))
|
|
|
|
for i in plan.get("interfaces", []):
|
|
n = i.get("name","")
|
|
if not n: continue
|
|
uci("set", "network.%s=interface" % n)
|
|
uci("set", "network.%s.device=%s" % (n, i.get("device","")))
|
|
uci("set", "network.%s.proto=%s" % (n, i.get("proto","static")))
|
|
if i.get("ipaddr"): uci("set", "network.%s.ipaddr=%s" % (n, i["ipaddr"]))
|
|
if i.get("netmask"): uci("set", "network.%s.netmask=%s" % (n, i["netmask"]))
|
|
|
|
for d in plan.get("dhcp", []):
|
|
n = d.get("name","")
|
|
if not n: continue
|
|
uci("set", "dhcp.%s=dhcp" % n)
|
|
uci("set", "dhcp.%s.interface=%s" % (n, d.get("interface","")))
|
|
uci("set", "dhcp.%s.start=%s" % (n, d.get("start","100")))
|
|
uci("set", "dhcp.%s.limit=%s" % (n, d.get("limit","150")))
|
|
uci("set", "dhcp.%s.leasetime=%s" % (n, d.get("leasetime","12h")))
|
|
|
|
for z in plan.get("zones", []):
|
|
n = z.get("name","")
|
|
if not n: continue
|
|
exists = subprocess.run(["uci","-q","get","firewall.%s" % n], capture_output=True).returncode == 0
|
|
if not exists:
|
|
uci("set", "firewall.%s=zone" % n)
|
|
uci("set", "firewall.%s.name=%s" % (n, n))
|
|
for net in z.get("network", []):
|
|
uci("add_list", "firewall.%s.network=%s" % (n, net))
|
|
uci("set", "firewall.%s.input=%s" % (n, z.get("input","REJECT")))
|
|
uci("set", "firewall.%s.output=%s" % (n, z.get("output","ACCEPT")))
|
|
uci("set", "firewall.%s.forward=%s" % (n, z.get("forward","REJECT")))
|
|
|
|
subprocess.run(["uci","commit","network"])
|
|
subprocess.run(["uci","commit","dhcp"])
|
|
subprocess.run(["uci","commit","firewall"])
|
|
PYAPPLY
|
|
|
|
if [ "$safe" = "1" ]; then
|
|
local now deadline
|
|
now=$(date +%s)
|
|
deadline=$((now + 90))
|
|
echo "$deadline" > "$VLAN_DIR/pending_rollback"
|
|
( sleep 90
|
|
if [ -f "$VLAN_DIR/pending_rollback" ]; then
|
|
dl=$(cat "$VLAN_DIR/pending_rollback" 2>/dev/null)
|
|
if [ "$dl" = "$deadline" ]; then
|
|
cp "$VLAN_DIR/network.bak.$ts" /etc/config/network
|
|
uci commit network
|
|
/etc/init.d/network reload
|
|
rm -f "$VLAN_DIR/pending_rollback"
|
|
fi
|
|
fi ) >/dev/null 2>&1 &
|
|
fi
|
|
|
|
/etc/init.d/network reload >/dev/null 2>&1
|
|
sleep 2
|
|
|
|
json_init
|
|
json_add_boolean "ok" 1
|
|
json_add_string "snapshot" "$VLAN_DIR/network.bak.$ts"
|
|
[ "$safe" = "1" ] && json_add_int "rollback_in" 90
|
|
json_dump
|
|
}
|
|
|
|
snapshot() {
|
|
local note
|
|
_load note note
|
|
[ -z "$note" ] && note="manual"
|
|
local ts path
|
|
ts=$(date +%Y%m%d-%H%M%S)
|
|
path="$VLAN_DIR/network.bak.$ts"
|
|
cp /etc/config/network "$path" 2>/dev/null || { json_init; json_add_string "error" "cp failed"; json_dump; return; }
|
|
echo "$note" > "$path.note" 2>/dev/null
|
|
ls -1t $VLAN_DIR/network.bak.* 2>/dev/null | grep -v '\.note$' | tail -n +21 | while read -r old; do
|
|
rm -f "$old" "$old.note"
|
|
done
|
|
json_init
|
|
json_add_string "path" "$path"
|
|
json_add_string "ts" "$ts"
|
|
json_dump
|
|
}
|
|
|
|
list_snapshots() {
|
|
json_init
|
|
json_add_array "snapshots"
|
|
for f in $(ls -1t $VLAN_DIR/network.bak.* 2>/dev/null | grep -v '\.note$'); do
|
|
[ -f "$f" ] || continue
|
|
local sz note
|
|
sz=$(wc -c < "$f" 2>/dev/null)
|
|
note=""
|
|
[ -f "$f.note" ] && note=$(cat "$f.note" 2>/dev/null)
|
|
json_add_object
|
|
json_add_string "path" "$f"
|
|
json_add_string "size" "${sz:-0}"
|
|
json_add_string "note" "$note"
|
|
json_close_object
|
|
done
|
|
json_close_array
|
|
json_add_string "pending" "$(cat $VLAN_DIR/pending_rollback 2>/dev/null)"
|
|
json_dump
|
|
}
|
|
|
|
restore() {
|
|
local path
|
|
_load path path
|
|
[ -z "$path" ] || [ ! -f "$path" ] && { json_init; json_add_string "error" "bad path"; json_dump; return; }
|
|
cp "$path" /etc/config/network
|
|
uci commit network
|
|
/etc/init.d/network reload >/dev/null 2>&1
|
|
json_init
|
|
json_add_boolean "ok" 1
|
|
json_dump
|
|
}
|
|
|
|
confirm() {
|
|
rm -f "$VLAN_DIR/pending_rollback"
|
|
json_init
|
|
json_add_boolean "ok" 1
|
|
json_dump
|
|
}
|
|
|
|
generate_cli() {
|
|
local plan target
|
|
_load plan plan target target
|
|
[ -z "$target" ] && target="generic"
|
|
echo "$plan" > "$VLAN_DIR/last-plan.json"
|
|
local out
|
|
out=$(
|
|
python3 - <<PYGEN
|
|
import json
|
|
plan = json.load(open("/etc/quickactions/vlan/last-plan.json"))
|
|
target = "$target"
|
|
out = []
|
|
|
|
if target == "mikrotik":
|
|
bridge = plan["vlans"][0].get("bridge","bridge1") if plan.get("vlans") else "bridge1"
|
|
pvid = {}
|
|
for v in plan.get("vlans", []):
|
|
for p in v.get("untagged", []):
|
|
pvid[p] = v.get("vlan")
|
|
out.append("/interface bridge")
|
|
out.append("add name=%s vlan-filtering=yes" % bridge)
|
|
out.append("/interface bridge port")
|
|
for p, vid in pvid.items():
|
|
out.append("add bridge=%s interface=%s pvid=%s" % (bridge, p, vid))
|
|
out.append("/interface bridge vlan")
|
|
for v in plan.get("vlans", []):
|
|
t = ",".join(v.get("tagged",[]))
|
|
u = ",".join(v.get("untagged",[]))
|
|
parts = ["bridge=%s" % bridge, "vlan-ids=%s" % v.get("vlan","")]
|
|
if t: parts.append("tagged=%s" % t)
|
|
if u: parts.append("untagged=%s" % u)
|
|
out.append("add " + " ".join(parts))
|
|
|
|
elif target == "cisco":
|
|
for v in plan.get("vlans", []):
|
|
out.append("vlan %s" % v.get("vlan",""))
|
|
out.append(" name VLAN_%s" % v.get("vlan",""))
|
|
out.append("!")
|
|
trunks = set()
|
|
for v in plan.get("vlans", []):
|
|
for p in v.get("tagged", []):
|
|
trunks.add(p)
|
|
for p in sorted(trunks):
|
|
out.append("interface %s" % p)
|
|
out.append(" switchport trunk encapsulation dot1q")
|
|
out.append(" switchport mode trunk")
|
|
allowed = []
|
|
for v in plan.get("vlans", []):
|
|
if p in v.get("tagged", []):
|
|
allowed.append(str(v.get("vlan")))
|
|
out.append(" switchport trunk allowed vlan %s" % ",".join(allowed))
|
|
out.append("!")
|
|
for v in plan.get("vlans", []):
|
|
for p in v.get("untagged", []):
|
|
out.append("interface %s" % p)
|
|
out.append(" switchport mode access")
|
|
out.append(" switchport access vlan %s" % v.get("vlan",""))
|
|
out.append("!")
|
|
|
|
elif target == "edgeos":
|
|
for v in plan.get("vlans", []):
|
|
vid = v.get("vlan","")
|
|
for p in v.get("tagged", []):
|
|
out.append("set interfaces ethernet %s vif %s description VLAN_%s" % (p, vid, vid))
|
|
for p in v.get("untagged", []):
|
|
out.append("set interfaces ethernet %s description VLAN_%s" % (p, vid))
|
|
out.append("set interfaces ethernet %s pvid %s" % (p, vid))
|
|
|
|
else:
|
|
out.append("VLAN Ports (T=tagged, U=untagged)")
|
|
for v in plan.get("vlans", []):
|
|
plist = []
|
|
for p in v.get("tagged", []): plist.append("%s T" % p)
|
|
for p in v.get("untagged", []): plist.append("%s U" % p)
|
|
out.append("%-5s %s" % (v.get("vlan",""), ", ".join(plist)))
|
|
|
|
print("\n".join(out))
|
|
PYGEN
|
|
)
|
|
json_init
|
|
json_add_string "cli" "$out"
|
|
json_add_string "target" "$target"
|
|
json_dump
|
|
}
|
|
|
|
save_template() {
|
|
local name target plan notes
|
|
_load name name target target plan plan notes notes
|
|
[ -z "$name" ] && { json_init; json_add_string "error" "name required"; json_dump; return; }
|
|
local fname
|
|
fname=$(echo "$name" | tr -c 'a-zA-Z0-9._-' '_')
|
|
printf '%s\n' "$plan" > "$TPL_DIR/$fname.json"
|
|
printf '{"target":"%s","notes":"%s"}\n' "$target" "$notes" > "$TPL_DIR/$fname.meta"
|
|
json_init
|
|
json_add_string "name" "$fname"
|
|
json_dump
|
|
}
|
|
|
|
list_templates() {
|
|
json_init
|
|
json_add_array "templates"
|
|
for f in $TPL_DIR/*.json; do
|
|
[ -f "$f" ] || continue
|
|
local b meta
|
|
b=$(basename "$f" .json)
|
|
meta="{}"
|
|
[ -f "$TPL_DIR/$b.meta" ] && meta=$(cat "$TPL_DIR/$b.meta")
|
|
json_add_object
|
|
json_add_string "name" "$b"
|
|
json_add_string "meta" "$meta"
|
|
json_close_object
|
|
done
|
|
json_close_array
|
|
json_dump
|
|
}
|
|
|
|
load_template() {
|
|
local name
|
|
_load name name
|
|
local fname
|
|
fname=$(echo "$name" | tr -c 'a-zA-Z0-9._-' '_')
|
|
if [ ! -f "$TPL_DIR/$fname.json" ]; then
|
|
json_init; json_add_string "error" "not found"; json_dump; return
|
|
fi
|
|
json_init
|
|
json_add_string "plan" "$(cat "$TPL_DIR/$fname.json")"
|
|
[ -f "$TPL_DIR/$fname.meta" ] && json_add_string "meta" "$(cat "$TPL_DIR/$fname.meta")"
|
|
json_dump
|
|
}
|
|
|
|
delete_template() {
|
|
local name
|
|
_load name name
|
|
local fname
|
|
fname=$(echo "$name" | tr -c 'a-zA-Z0-9._-' '_')
|
|
rm -f "$TPL_DIR/$fname.json" "$TPL_DIR/$fname.meta"
|
|
json_init; json_add_boolean "ok" 1; json_dump
|
|
}
|
|
|
|
save_generated() {
|
|
local name target content
|
|
_load name name target target content content
|
|
[ -z "$name" ] && name="gen-$(date +%s)"
|
|
local fname
|
|
fname=$(echo "$name" | tr -c 'a-zA-Z0-9._-' '_')
|
|
printf '%s\n' "$content" > "$GEN_DIR/$fname.txt"
|
|
echo "$target" > "$GEN_DIR/$fname.target"
|
|
ls -1t $GEN_DIR/*.txt 2>/dev/null | tail -n +51 | while read -r old; do
|
|
rm -f "$old" "$old.target"
|
|
done
|
|
json_init; json_add_string "name" "$fname"; json_dump
|
|
}
|
|
|
|
list_generated() {
|
|
json_init
|
|
json_add_array "generated"
|
|
for f in $GEN_DIR/*.txt; do
|
|
[ -f "$f" ] || continue
|
|
local b tgt
|
|
b=$(basename "$f" .txt)
|
|
tgt=""
|
|
[ -f "$GEN_DIR/$b.target" ] && tgt=$(cat "$GEN_DIR/$b.target")
|
|
json_add_object
|
|
json_add_string "name" "$b"
|
|
json_add_string "target" "$tgt"
|
|
json_close_object
|
|
done
|
|
json_close_array
|
|
json_dump
|
|
}
|
|
|
|
delete_generated() {
|
|
local name
|
|
_load name name
|
|
local fname
|
|
fname=$(echo "$name" | tr -c 'a-zA-Z0-9._-' '_')
|
|
rm -f "$GEN_DIR/$fname.txt" "$GEN_DIR/$fname.target"
|
|
json_init; json_add_boolean "ok" 1; json_dump
|
|
}
|
|
|
|
lldp_neighbors() {
|
|
if ! command -v lldpcli >/dev/null 2>&1; then
|
|
json_init; json_add_string "error" "lldpcli not installed"; json_dump; return
|
|
fi
|
|
local out
|
|
out=$(lldpcli show neighbors 2>&1)
|
|
json_init
|
|
json_add_string "output" "$out"
|
|
json_dump
|
|
}
|
|
|
|
snmp_query() {
|
|
local ip community
|
|
_load ip ip community community
|
|
[ -z "$community" ] && community="public"
|
|
if ! command -v snmpwalk >/dev/null 2>&1; then
|
|
json_init; json_add_string "error" "snmpwalk not installed"; json_dump; return
|
|
fi
|
|
local out
|
|
out=$(snmpwalk -v2c -c "$community" -t 3 -r 1 "$ip" 1.3.6.1.2.1.17.7.1.4.3.1.2 2>&1)
|
|
json_init
|
|
json_add_string "ip" "$ip"
|
|
json_add_string "output" "$out"
|
|
json_dump
|
|
}
|
|
|
|
bridge_vlan_show() {
|
|
local out
|
|
out=$(bridge vlan show 2>&1)
|
|
json_init
|
|
json_add_string "output" "$out"
|
|
json_dump
|
|
}
|
|
|
|
iface_stats() {
|
|
local ifaces
|
|
_load ifaces ifaces
|
|
json_init
|
|
json_add_array "stats"
|
|
for i in $ifaces; do
|
|
[ -d "/sys/class/net/$i" ] || continue
|
|
local rx tx
|
|
rx=$(cat /sys/class/net/$i/statistics/rx_bytes 2>/dev/null)
|
|
tx=$(cat /sys/class/net/$i/statistics/tx_bytes 2>/dev/null)
|
|
json_add_object
|
|
json_add_string "iface" "$i"
|
|
json_add_int "rx" "${rx:-0}"
|
|
json_add_int "tx" "${tx:-0}"
|
|
json_close_object
|
|
done
|
|
json_close_array
|
|
json_dump
|
|
}
|
|
|
|
ping_test() {
|
|
local iface ip
|
|
_load iface iface ip ip
|
|
[ -z "$iface" ] && { json_init; json_add_string "error" "missing iface"; json_dump; return; }
|
|
[ -z "$ip" ] && { json_init; json_add_string "error" "missing ip"; json_dump; return; }
|
|
local out rc
|
|
out=$(ping -I "$iface" -c 3 -W 3 "$ip" 2>&1)
|
|
rc=$?
|
|
json_init
|
|
json_add_string "output" "$out"
|
|
json_add_int "exit_code" "$rc"
|
|
json_dump
|
|
}
|
|
|
|
call_method() {
|
|
local method="$1"
|
|
case "$method" in
|
|
detect) detect ;;
|
|
preview) preview ;;
|
|
apply) apply ;;
|
|
snapshot) snapshot ;;
|
|
list_snapshots) list_snapshots ;;
|
|
restore) restore ;;
|
|
confirm) confirm ;;
|
|
generate_cli) generate_cli ;;
|
|
save_template) save_template ;;
|
|
list_templates) list_templates ;;
|
|
load_template) load_template ;;
|
|
delete_template) delete_template ;;
|
|
save_generated) save_generated ;;
|
|
list_generated) list_generated ;;
|
|
delete_generated) delete_generated ;;
|
|
lldp_neighbors) lldp_neighbors ;;
|
|
snmp_query) snmp_query ;;
|
|
bridge_vlan_show) bridge_vlan_show ;;
|
|
kernel_ifaces) kernel_ifaces ;;
|
|
iface_stats) iface_stats ;;
|
|
ping_test) ping_test ;;
|
|
*) cat >/dev/null
|
|
json_init
|
|
json_add_string "error" "unknown_method"
|
|
json_dump ;;
|
|
esac
|
|
}
|
|
|
|
case "$1" in
|
|
list) list_methods ;;
|
|
call) call_method "$2" ;;
|
|
*) echo '{"error":"usage"}' ;;
|
|
esac
|