Add OpenWrt remote hub

This commit is contained in:
kzolotarev95 committed 2026-06-29 02:14:50 +04:00
1 parent 48cba62f21
commit 38a92b0b1f
19 files changed
+2080 -2123

No files matched your search

-693
View File
@@ -1,693 +0,0 @@
#!/bin/sh
VERSION="1.0.0"
FORMAT="owrt-full-backup-v1"
DEFAULT_OUTPUT_DIR="/tmp"
WORKDIR=""
log() {
printf '%s\n' "$*" >&2
}
warn() {
printf 'ВНИМАНИЕ: %s\n' "$*" >&2
}
die() {
printf 'ОШИБКА: %s\n' "$*" >&2
exit 1
}
cleanup() {
if [ -n "$WORKDIR" ] && [ -d "$WORKDIR" ]; then
rm -rf "$WORKDIR"
fi
}
trap cleanup EXIT INT TERM
usage() {
cat <<'EOF'
Использование:
owrt-full-backup create [options]
owrt-full-backup restore <archive.tar.gz> [options]
owrt-full-backup inspect <archive.tar.gz>
owrt-full-backup help
Опции создания:
-o, --output-dir DIR Папка для итогового архива
-n, --name NAME Имя архива без .tar.gz
--no-overlay Не добавлять снимок /overlay/upper
--include-rom Добавить read-only снимок /rom
--firmware-image FILE Скопировать sysupgrade-образ в архив
--include-raw-mtd Добавить dump разделов /dev/mtd*
Опции восстановления:
--yes Не спрашивать подтверждение
--no-configs Не восстанавливать sysupgrade config backup
--no-packages Не переустанавливать пакеты из списка
--overlay Восстановить снимок /overlay/upper в /
--flash-firmware Прошить firmware image из архива через sysupgrade
Примеры:
owrt-full-backup create -o /mnt/usb
owrt-full-backup create -o /mnt/usb --firmware-image /tmp/openwrt.bin
owrt-full-backup restore /mnt/usb/router-backup.tar.gz --yes
EOF
}
need_cmd() {
command -v "$1" >/dev/null 2>&1 || die "нужная команда не найдена: $1"
}
make_workdir() {
local base
base="${1:-${TMPDIR:-/tmp}}"
[ -d "$base" ] || base="${TMPDIR:-/tmp}"
WORKDIR="$(mktemp -d "$base/owrt-full-backup.XXXXXX" 2>/dev/null || true)"
if [ -z "$WORKDIR" ] || [ ! -d "$WORKDIR" ]; then
WORKDIR="$base/owrt-full-backup.$$"
mkdir -p "$WORKDIR" || die "не удалось создать временную папку: $WORKDIR"
fi
}
abs_path() {
local path
path="$1"
if command -v readlink >/dev/null 2>&1; then
readlink -f "$path" 2>/dev/null && return
fi
(cd "$path" 2>/dev/null && pwd -P) || printf '%s\n' "$path"
}
is_tmp_path() {
local path
path="$(abs_path "$1")"
case "$path" in
/tmp|/tmp/*) return 0 ;;
*) return 1 ;;
esac
}
uci_get() {
local key default value
key="$1"
default="$2"
if command -v uci >/dev/null 2>&1; then
value="$(uci -q get "fullbackup.main.$key" 2>/dev/null || true)"
if [ -n "$value" ]; then
printf '%s' "$value"
return
fi
fi
printf '%s' "$default"
}
copy_if_exists() {
local src dst
src="$1"
dst="$2"
if [ -e "$src" ]; then
cp -p "$src" "$dst" 2>/dev/null || cp "$src" "$dst" 2>/dev/null || true
fi
}
sanitize() {
printf '%s' "$1" | tr -cs 'A-Za-z0-9._-' '_'
}
hostname_safe() {
local name
name="$(hostname 2>/dev/null || printf 'openwrt')"
sanitize "$name"
}
board_name() {
if [ -r /tmp/sysinfo/board_name ]; then
cat /tmp/sysinfo/board_name
return
fi
if [ -r /etc/openwrt_release ]; then
(
. /etc/openwrt_release 2>/dev/null
printf '%s' "${DISTRIB_TARGET:-openwrt}"
)
return
fi
printf 'openwrt'
}
release_text() {
if [ -r /etc/openwrt_release ]; then
(
. /etc/openwrt_release 2>/dev/null
printf '%s %s' "${DISTRIB_ID:-OpenWrt}" "${DISTRIB_RELEASE:-unknown}"
)
return
fi
printf 'OpenWrt unknown'
}
write_command_output() {
local out
out="$1"
shift
"$@" >"$out" 2>"$out.err" || true
if [ ! -s "$out.err" ]; then
rm -f "$out.err"
fi
}
validate_tar_paths() {
local archive label
archive="$1"
label="$2"
if tar -tzf "$archive" | grep -Eq '(^/|(^|/)\.\.(/|$))'; then
die "$label содержит небезопасные пути"
fi
}
create_metadata() {
local meta packages firmware
meta="$WORKDIR/meta"
packages="$WORKDIR/packages"
firmware="$WORKDIR/firmware"
mkdir -p "$meta" "$packages" "$firmware"
cat >"$WORKDIR/MANIFEST" <<EOF
format=$FORMAT
tool_version=$VERSION
created_at_utc=$(date -u '+%Y-%m-%dT%H:%M:%SZ' 2>/dev/null || date)
hostname=$(hostname 2>/dev/null || printf 'openwrt')
board=$(board_name)
release=$(release_text)
kernel=$(uname -a 2>/dev/null || true)
EOF
copy_if_exists /etc/openwrt_release "$meta/openwrt_release"
copy_if_exists /etc/openwrt_version "$meta/openwrt_version"
copy_if_exists /etc/board.json "$meta/board.json"
copy_if_exists /etc/sysupgrade.conf "$meta/sysupgrade.conf"
copy_if_exists /proc/mtd "$meta/proc-mtd.txt"
copy_if_exists /proc/partitions "$meta/proc-partitions.txt"
write_command_output "$meta/uname.txt" uname -a
write_command_output "$meta/mounts.txt" mount
write_command_output "$meta/df-h.txt" df -h
if command -v ubus >/dev/null 2>&1; then
write_command_output "$meta/system-board.json" ubus call system board
fi
if command -v uci >/dev/null 2>&1; then
write_command_output "$meta/uci-show.txt" uci show
fi
if command -v opkg >/dev/null 2>&1; then
write_command_output "$packages/installed.txt" opkg list-installed
write_command_output "$packages/print-architecture.txt" opkg print-architecture
write_command_output "$packages/changed-conffiles.txt" opkg list-changed-conffiles
copy_if_exists /usr/lib/opkg/status "$packages/opkg-status"
else
printf 'opkg недоступен на этой системе.\n' >"$packages/installed.txt"
fi
cat >"$firmware/README.txt" <<'EOF'
OpenWrt обычно не хранит исходный sysupgrade-образ на роутере.
Используй --firmware-image /path/to/openwrt-sysupgrade.bin при создании
бэкапа, если хочешь добавить в архив прошиваемый firmware image.
Raw MTD dumps можно добавить через --include-raw-mtd, но они завязаны на
конкретное железо и разметку flash. Прошивка таких dump на другом устройстве
или другой разметке может окончательно сломать роутер.
EOF
}
create_sysupgrade_backup() {
if command -v sysupgrade >/dev/null 2>&1; then
if sysupgrade -b "$WORKDIR/config-backup.tar.gz" >/dev/null 2>"$WORKDIR/meta/sysupgrade-backup.err"; then
rm -f "$WORKDIR/meta/sysupgrade-backup.err"
else
warn "sysupgrade config backup не сработал; делаю fallback-снимок /etc"
tar -czf "$WORKDIR/config-backup.tar.gz" -C / etc 2>"$WORKDIR/meta/etc-backup.err" || die "не удалось создать config backup"
fi
sysupgrade -l >"$WORKDIR/meta/sysupgrade-file-list.txt" 2>/dev/null || true
else
warn "команда sysupgrade не найдена; делаю tar-снимок /etc"
tar -czf "$WORKDIR/config-backup.tar.gz" -C / etc 2>"$WORKDIR/meta/etc-backup.err" || die "не удалось создать config backup"
fi
}
create_overlay_snapshot() {
if [ ! -d /overlay/upper ]; then
printf 'Папка /overlay/upper на этой системе не найдена.\n' >"$WORKDIR/overlay-upper.README.txt"
return
fi
if tar -czf "$WORKDIR/overlay-upper.tar.gz" -C /overlay/upper . 2>"$WORKDIR/meta/overlay-upper.err"; then
rm -f "$WORKDIR/meta/overlay-upper.err"
else
warn "снимок overlay не получился; бэкап продолжится без него"
rm -f "$WORKDIR/overlay-upper.tar.gz"
fi
}
create_rom_snapshot() {
if [ ! -d /rom ]; then
printf 'Папка /rom на этой системе не найдена.\n' >"$WORKDIR/rom-rootfs.README.txt"
return
fi
if tar -czf "$WORKDIR/rom-rootfs.tar.gz" -C /rom . 2>"$WORKDIR/meta/rom-rootfs.err"; then
rm -f "$WORKDIR/meta/rom-rootfs.err"
else
warn "снимок ROM rootfs не получился; бэкап продолжится без него"
rm -f "$WORKDIR/rom-rootfs.tar.gz"
fi
}
copy_firmware_image() {
local image base
image="$1"
[ -n "$image" ] || return
[ -r "$image" ] || die "firmware image недоступен для чтения: $image"
base="$(basename "$image")"
mkdir -p "$WORKDIR/firmware"
cp "$image" "$WORKDIR/firmware/$base" || die "не удалось скопировать firmware image"
if command -v sha256sum >/dev/null 2>&1; then
(
cd "$WORKDIR/firmware" && sha256sum "$base" >"$base.sha256"
) || true
fi
printf '%s\n' "$base" >"$WORKDIR/firmware/IMAGE"
}
dump_raw_mtd() {
local raw line dev name safe out
if [ ! -r /proc/mtd ]; then
warn "/proc/mtd недоступен; raw MTD dump пропущен"
return
fi
raw="$WORKDIR/raw-mtd"
mkdir -p "$raw"
cp /proc/mtd "$raw/proc-mtd.txt" 2>/dev/null || true
while IFS= read -r line; do
case "$line" in
mtd*:*)
dev="${line%%:*}"
name="$(printf '%s\n' "$line" | sed 's/.*"\(.*\)".*/\1/')"
safe="$(sanitize "$name")"
if [ -e "/dev/$dev" ]; then
log "Сохраняю /dev/$dev ($name)"
out="$raw/$dev-$safe.bin"
if dd if="/dev/$dev" of="$out" bs=64k 2>"$raw/$dev-$safe.dd.log"; then
:
else
rm -f "$out"
warn "не удалось сохранить /dev/$dev"
fi
fi
;;
esac
done </proc/mtd
}
prune_old_backups() {
local output_dir keep_days
output_dir="$1"
keep_days="$2"
case "$keep_days" in
''|0) return ;;
esac
case "$keep_days" in
*[!0-9]*)
warn "keep_days должен быть числом; очистка пропущена"
return
;;
esac
find "$output_dir" -type f -name '*-owrt-full-backup.tar.gz' -mtime "+$keep_days" -exec rm -f {} \; 2>/dev/null || true
find "$output_dir" -type f -name '*-owrt-full-backup.tar.gz.sha256' -mtime "+$keep_days" -exec rm -f {} \; 2>/dev/null || true
}
cmd_create() {
local output_dir name include_overlay include_rom include_raw_mtd firmware_image timestamp host board archive keep_days
output_dir="$(uci_get output_dir "$DEFAULT_OUTPUT_DIR")"
include_overlay="$(uci_get include_overlay 1)"
include_rom="$(uci_get include_rom 0)"
include_raw_mtd="$(uci_get include_raw_mtd 0)"
keep_days="$(uci_get keep_days 0)"
name=""
firmware_image=""
while [ $# -gt 0 ]; do
case "$1" in
-o|--output-dir)
[ $# -ge 2 ] || die "$1 требует папку"
output_dir="$2"
shift 2
;;
-n|--name)
[ $# -ge 2 ] || die "$1 требует имя"
name="$2"
shift 2
;;
--no-overlay)
include_overlay=0
shift
;;
--include-rom)
include_rom=1
shift
;;
--firmware-image)
[ $# -ge 2 ] || die "$1 требует файл"
firmware_image="$2"
shift 2
;;
--include-raw-mtd)
include_raw_mtd=1
shift
;;
-h|--help)
usage
exit 0
;;
*)
die "неизвестная опция create: $1"
;;
esac
done
need_cmd tar
need_cmd gzip
mkdir -p "$output_dir" || die "не удалось создать папку для архива: $output_dir"
if [ "$include_raw_mtd" = "1" ] && is_tmp_path "$output_dir"; then
die "raw MTD dump нельзя сохранять в /tmp: там обычно мало RAM. Укажи USB/диск, например /mnt/usb, или отключи raw MTD dump."
fi
make_workdir "$output_dir"
timestamp="$(date '+%Y%m%d-%H%M%S' 2>/dev/null || date '+%s')"
host="$(hostname_safe)"
board="$(sanitize "$(board_name)")"
if [ -z "$name" ]; then
name="$host-$board-$timestamp-owrt-full-backup"
fi
archive="$output_dir/$name.tar.gz"
log "Готовлю временную папку для бэкапа"
create_metadata
create_sysupgrade_backup
if [ "$include_overlay" = "1" ]; then
log "Добавляю снимок overlay"
create_overlay_snapshot
else
printf 'Снимок overlay отключен опцией.\n' >"$WORKDIR/overlay-upper.README.txt"
fi
if [ "$include_rom" = "1" ]; then
log "Добавляю снимок ROM rootfs"
create_rom_snapshot
else
printf 'Снимок ROM rootfs отключен опцией.\n' >"$WORKDIR/rom-rootfs.README.txt"
fi
copy_firmware_image "$firmware_image"
if [ "$include_raw_mtd" = "1" ]; then
warn "raw MTD dumps завязаны на конкретное устройство и могут быть очень большими"
dump_raw_mtd
fi
if tar -czf "$archive" -C "$WORKDIR" .; then
:
else
die "не удалось создать архив: $archive"
fi
if command -v sha256sum >/dev/null 2>&1; then
sha256sum "$archive" >"$archive.sha256" 2>/dev/null || true
fi
prune_old_backups "$output_dir" "$keep_days"
log "Бэкап создан: $archive"
if [ -f "$archive.sha256" ]; then
log "Checksum создан: $archive.sha256"
fi
}
extract_archive() {
local archive
archive="$1"
[ -r "$archive" ] || die "архив недоступен для чтения: $archive"
need_cmd tar
need_cmd gzip
validate_tar_paths "$archive" "archive"
make_workdir
tar -xzf "$archive" -C "$WORKDIR" || die "не удалось распаковать архив"
[ -r "$WORKDIR/MANIFEST" ] || die "в архиве нет MANIFEST"
grep -q "^format=$FORMAT" "$WORKDIR/MANIFEST" || die "неподдерживаемый формат бэкапа"
}
show_manifest_summary() {
local count
if [ -r "$WORKDIR/MANIFEST" ]; then
sed -n '1,40p' "$WORKDIR/MANIFEST"
fi
if [ -r "$WORKDIR/packages/installed.txt" ]; then
count="$(grep -c ' - ' "$WORKDIR/packages/installed.txt" 2>/dev/null)"
[ -n "$count" ] || count=0
printf 'installed_packages_count=%s\n' "$count"
fi
if [ -r "$WORKDIR/firmware/IMAGE" ]; then
printf 'firmware_image=%s\n' "$(cat "$WORKDIR/firmware/IMAGE")"
else
printf 'firmware_image=not_included\n'
fi
if [ -r "$WORKDIR/overlay-upper.tar.gz" ]; then
printf 'overlay_snapshot=included\n'
else
printf 'overlay_snapshot=not_included\n'
fi
if [ -r "$WORKDIR/rom-rootfs.tar.gz" ]; then
printf 'rom_rootfs_snapshot=included\n'
else
printf 'rom_rootfs_snapshot=not_included\n'
fi
if [ -d "$WORKDIR/raw-mtd" ]; then
printf 'raw_mtd=included\n'
else
printf 'raw_mtd=not_included\n'
fi
}
confirm_restore() {
local yes answer
yes="$1"
if [ "$yes" = "1" ]; then
return
fi
printf 'Это изменит файлы на OpenWrt-устройстве. Введи "yes" для продолжения: ' >&2
read -r answer
[ "$answer" = "yes" ] || die "восстановление отменено"
}
restore_configs() {
if [ ! -r "$WORKDIR/config-backup.tar.gz" ]; then
warn "config-backup.tar.gz не найден; восстановление настроек пропущено"
return
fi
log "Восстанавливаю config backup"
validate_tar_paths "$WORKDIR/config-backup.tar.gz" "config backup"
tar -xzpf "$WORKDIR/config-backup.tar.gz" -C / || die "восстановление настроек не удалось"
}
restore_packages() {
local installed line pkg failed
installed="$WORKDIR/packages/installed.txt"
[ -r "$installed" ] || {
warn "список пакетов не найден; восстановление пакетов пропущено"
return
}
if ! command -v opkg >/dev/null 2>&1; then
warn "opkg не найден; восстановление пакетов пропущено"
return
fi
log "Обновляю списки пакетов"
opkg update || warn "opkg update не сработал; установка пакетов все равно будет попробована"
failed=0
while IFS= read -r line; do
case "$line" in
*' - '*)
pkg="${line%% - *}"
;;
*)
continue
;;
esac
if opkg status "$pkg" 2>/dev/null | grep -q '^Status:.* installed'; then
continue
fi
log "Устанавливаю пакет: $pkg"
if ! opkg install "$pkg"; then
warn "не удалось установить пакет: $pkg"
failed=1
fi
done <"$installed"
if [ "$failed" = "1" ]; then
warn "часть пакетов не установилась; проверь совместимость feeds с этой версией OpenWrt"
fi
}
restore_overlay() {
if [ ! -r "$WORKDIR/overlay-upper.tar.gz" ]; then
warn "снимок overlay не найден; восстановление overlay пропущено"
return
fi
warn "overlay лучше восстанавливать на том же устройстве и той же версии OpenWrt"
log "Восстанавливаю overlay snapshot в /"
validate_tar_paths "$WORKDIR/overlay-upper.tar.gz" "overlay snapshot"
tar -xzpf "$WORKDIR/overlay-upper.tar.gz" -C / || die "восстановление overlay не удалось"
}
flash_firmware() {
local image_name image_path
[ -r "$WORKDIR/firmware/IMAGE" ] || die "в архиве нет firmware image"
image_name="$(cat "$WORKDIR/firmware/IMAGE")"
case "$image_name" in
*/*|../*|*/../*|..)
die "имя firmware image небезопасно"
;;
esac
image_path="$WORKDIR/firmware/$image_name"
[ -r "$image_path" ] || die "firmware image указан в архиве, но файл отсутствует: $image_name"
command -v sysupgrade >/dev/null 2>&1 || die "команда sysupgrade не найдена"
warn "sysupgrade прошьет firmware и перезагрузит устройство"
sysupgrade "$image_path"
}
cmd_restore() {
local archive yes do_configs do_packages do_overlay do_flash
[ $# -ge 1 ] || die "restore требует путь к архиву"
archive="$1"
shift
yes=0
do_configs=1
do_packages=1
do_overlay=0
do_flash=0
while [ $# -gt 0 ]; do
case "$1" in
--yes)
yes=1
shift
;;
--no-configs)
do_configs=0
shift
;;
--no-packages)
do_packages=0
shift
;;
--overlay)
do_overlay=1
shift
;;
--flash-firmware)
do_flash=1
shift
;;
-h|--help)
usage
exit 0
;;
*)
die "неизвестная опция restore: $1"
;;
esac
done
extract_archive "$archive"
show_manifest_summary >&2
confirm_restore "$yes"
if [ "$do_flash" = "1" ]; then
flash_firmware
return
fi
if [ "$do_configs" = "1" ]; then
restore_configs
fi
if [ "$do_packages" = "1" ]; then
restore_packages
fi
if [ "$do_overlay" = "1" ]; then
restore_overlay
fi
log "Восстановление завершено. Рекомендуется перезагрузка."
}
cmd_inspect() {
[ $# -ge 1 ] || die "inspect требует путь к архиву"
extract_archive "$1"
show_manifest_summary
}
main() {
local cmd
cmd="${1:-help}"
case "$cmd" in
create)
shift
cmd_create "$@"
;;
restore)
shift
cmd_restore "$@"
;;
inspect)
shift
cmd_inspect "$@"
;;
help|-h|--help)
usage
;;
*)
die "неизвестная команда: $cmd"
;;
esac
}
main "$@"
-278
View File
@@ -1,278 +0,0 @@
#!/usr/bin/ucode
'use strict';
import * as fs from 'fs';
const default_dir = ARGV[0] || '/tmp';
const content_type = getenv('CONTENT_TYPE') || '';
let input_available = +getenv('CONTENT_LENGTH') || 0;
let input = fs.fdopen(0, 'r');
let output = fs.fdopen(1, 'w');
let error = fs.fdopen(2, 'w');
let pending = '';
let target_tmp = null;
function cleanup() {
if (target_tmp)
fs.unlink(target_tmp);
}
function fail(message) {
cleanup();
error.write('ОШИБКА: ' + message + '\n');
exit(1);
}
function ok(message) {
output.write(message + '\n');
}
function valid_path(path) {
return type(path) == 'string' && match(path, /^\/[A-Za-z0-9._\/-]+$/);
}
function safe_filename(name) {
name = name != null ? '' + name : '';
name = replace(name, /\\/g, '/');
name = fs.basename(name);
return replace(name, /[^A-Za-z0-9._-]/g, '_');
}
function trim_crlf(line) {
line = line != null ? '' + line : '';
line = replace(line, /\r\n$/, '');
return replace(line, /\n$/, '');
}
function append_array(array, value) {
array[length(array)] = value;
}
function concat_array(array, separator) {
let result = '';
for (let i = 0; i < length(array); i++) {
if (i > 0)
result += separator;
result += array[i];
}
return result;
}
function read_from_stdin(size) {
if (input_available <= 0)
return null;
size = size != null ? size : 8192;
let chunk = input.read(min(input_available, size, 8192));
if (chunk == null) {
input_available = 0;
return null;
}
input_available -= length(chunk);
return chunk;
}
function read_line() {
while (true) {
let pos = index(pending, '\n');
if (pos != null && pos >= 0) {
let line = substr(pending, 0, pos + 1);
pending = substr(pending, pos + 1);
return line;
}
let chunk = read_from_stdin(1024);
if (chunk == null) {
if (length(pending) > 0) {
let line = pending;
pending = '';
return line;
}
return null;
}
pending += chunk;
}
}
let boundary_match = match(content_type, /boundary="?([^";]+)"?/);
let boundary = boundary_match ? boundary_match[1] : null;
if (!boundary)
fail('multipart boundary не найден');
if (input_available <= 0)
fail('пустой upload');
const marker = '--' + boundary;
const delimiter = '\r\n' + marker;
let first_line = trim_crlf(read_line());
if (first_line != marker)
fail('multipart boundary не найден в теле запроса');
function read_headers() {
let headers = [];
while (true) {
let line = read_line();
if (line == null)
fail('не удалось прочитать заголовки upload');
line = trim_crlf(line);
if (line == '')
break;
append_array(headers, line);
}
return concat_array(headers, '\n');
}
function read_part(out, max_text) {
let keep = length(delimiter) + 4;
let buffer = '';
let text = [];
let text_size = 0;
let part_size = 0;
function consume(data) {
if (data == null || length(data) == 0)
return;
part_size += length(data);
if (out) {
out.write(data);
return;
}
text_size += length(data);
max_text = max_text != null ? max_text : 4096;
if (text_size > max_text)
fail('поле формы слишком большое');
append_array(text, data);
}
while (true) {
let chunk;
if (length(pending) > 0) {
chunk = pending;
pending = '';
}
else {
chunk = read_from_stdin(8192);
}
if (chunk == null)
fail('не найден конец multipart upload');
buffer += chunk;
let start_pos = index(buffer, delimiter);
if (start_pos != null && start_pos >= 0) {
consume(substr(buffer, 0, start_pos));
let after = start_pos + length(delimiter);
let final = false;
if (substr(buffer, after, 2) == '--') {
final = true;
after += 2;
}
if (substr(buffer, after, 2) == '\r\n')
after += 2;
pending = substr(buffer, after);
return [ final, concat_array(text, ''), part_size ];
}
if (length(buffer) > keep) {
consume(substr(buffer, 0, length(buffer) - keep));
buffer = substr(buffer, length(buffer) - keep);
}
}
}
let upload_dir = default_dir;
let saved_path = null;
let saved_size = 0;
let final = false;
while (!final) {
let headers = read_headers();
let disposition_match = match(headers, /[Cc]ontent-[Dd]isposition:\s*([^\n]+)/);
let disposition = disposition_match ? disposition_match[1] : null;
let name_match = disposition ? match(disposition, /name="([^"]+)"/) : null;
let filename_match = disposition ? match(disposition, /filename="([^"]*)"/) : null;
let name = name_match ? name_match[1] : null;
let filename = filename_match ? filename_match[1] : null;
if (name == 'upload_dir' && filename == null) {
let part = read_part(null, 4096);
final = part[0];
upload_dir = part[1] != null ? '' + part[1] : '';
upload_dir = replace(upload_dir, /[\r\n]/g, '');
}
else if (name == 'archive' && filename != null && filename != '') {
if (!valid_path(upload_dir))
fail('неверная папка для загрузки: ' + upload_dir);
let file_name = safe_filename(filename);
if (!file_name)
fail('файл архива не выбран');
if (!match(file_name, /\.tar\.gz$/))
fail('можно загружать только архивы .tar.gz');
fs.mkdir(upload_dir, 0755);
let target = replace(upload_dir, /\/+$/, '') + '/' + file_name;
target_tmp = target + '.uploading.' + time() + '.' + input_available;
let out = fs.open(target_tmp, 'w', 384);
if (!out)
fail('не удалось открыть файл для записи: ' + target);
let part = read_part(out, 0);
final = part[0];
saved_size = part[2];
out.close();
if (saved_size <= 0)
fail('файл пустой');
if (!fs.rename(target_tmp, target))
fail('не удалось сохранить файл: ' + target);
target_tmp = null;
saved_path = target;
}
else {
let part = read_part(null, 1024);
final = part[0];
}
}
if (!saved_path)
fail('файл архива не выбран');
ok('Архив загружен: ' + saved_path);
ok('Размер: ' + saved_size + ' байт');
+428
View File
@@ -0,0 +1,428 @@
#!/bin/sh
CONFIG="owrtremote"
SECTION="main"
log() {
printf '%s\n' "$*" >&2
}
die() {
printf 'ОШИБКА: %s\n' "$*" >&2
exit 1
}
usage() {
cat <<'EOF'
Использование:
owrt-remote status
owrt-remote doctor
owrt-remote render-client [--stdout]
owrt-remote run
owrt-remote heartbeat
owrt-remote heartbeat-loop
Настройки лежат в /etc/config/owrtremote.
EOF
}
uci_get() {
local key default value
key="$1"
default="$2"
value="$(uci -q get "$CONFIG.$SECTION.$key" 2>/dev/null || true)"
[ -n "$value" ] && {
printf '%s' "$value"
return
}
printf '%s' "$default"
}
truthy() {
case "$1" in
1|yes|true|on|enabled) return 0 ;;
*) return 1 ;;
esac
}
json_escape() {
printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g; s/ /\\t/g'
}
json_string() {
printf '"%s"' "$(json_escape "$1")"
}
safe_num() {
case "$1" in
''|*[!0-9]*) printf '%s' "$2" ;;
*) printf '%s' "$1" ;;
esac
}
safe_id() {
printf '%s' "$1" | tr -cs 'A-Za-z0-9._-' '-'
}
host_model() {
if [ -r /tmp/sysinfo/model ]; then
cat /tmp/sysinfo/model
return
fi
if [ -r /proc/device-tree/model ]; then
tr -d '\000' </proc/device-tree/model
return
fi
printf 'OpenWrt router'
}
board_name() {
if [ -r /tmp/sysinfo/board_name ]; then
cat /tmp/sysinfo/board_name
return
fi
printf 'unknown'
}
release_text() {
if [ -r /etc/openwrt_release ]; then
(
. /etc/openwrt_release 2>/dev/null
printf '%s %s' "${DISTRIB_ID:-OpenWrt}" "${DISTRIB_RELEASE:-unknown}"
)
return
fi
printf 'OpenWrt unknown'
}
uptime_seconds() {
if [ -r /proc/uptime ]; then
cut -d. -f1 /proc/uptime
return
fi
printf '0'
}
load_text() {
if [ -r /proc/loadavg ]; then
awk '{print $1" "$2" "$3}' /proc/loadavg
return
fi
printf '0 0 0'
}
memory_text() {
if [ -r /proc/meminfo ]; then
awk '
/^MemTotal:/ { total=$2 }
/^MemAvailable:/ { avail=$2 }
/^MemFree:/ && avail=="" { avail=$2 }
END {
if (total == "") total = 0
if (avail == "") avail = 0
printf "%s/%s kB", avail, total
}
' /proc/meminfo
return
fi
printf '0/0 kB'
}
ps_all() {
ps w 2>/dev/null || ps 2>/dev/null || true
}
xray_running() {
local config
config="$(uci_get xray_config /etc/xray/owrt-remote-client.json)"
ps_all | grep '[x]ray' | grep -F "$config" >/dev/null 2>&1
}
service_enabled() {
/etc/init.d/owrt-remote enabled >/dev/null 2>&1
}
render_client_config() {
local out stdout router_id vps_host vps_port uuid encryption flow reverse_tag admin_host admin_port xray_config
stdout="0"
if [ "${1:-}" = "--stdout" ]; then
stdout="1"
fi
router_id="$(safe_id "$(uci_get router_id main)")"
vps_host="$(uci_get vps_host '')"
vps_port="$(safe_num "$(uci_get vps_port 8443)" 8443)"
uuid="$(uci_get vless_uuid '')"
encryption="$(uci_get vless_encryption none)"
flow="$(uci_get vless_flow '')"
reverse_tag="$(safe_id "$(uci_get reverse_tag reverse-in)")"
admin_host="$(uci_get admin_host 127.0.0.1)"
admin_port="$(safe_num "$(uci_get admin_port 80)" 80)"
xray_config="$(uci_get xray_config /etc/xray/owrt-remote-client.json)"
[ -n "$vps_host" ] || die "vps_host пустой"
[ -n "$uuid" ] || die "vless_uuid пустой"
out="${TMPDIR:-/tmp}/owrt-remote-client.$$"
cat >"$out" <<EOF
{
"log": {
"loglevel": "warning"
},
"inbounds": [],
"outbounds": [
{
"tag": "router-admin",
"protocol": "freedom",
"settings": {
"redirect": "$(json_escape "$admin_host"):$admin_port",
"finalRules": [
{
"action": "allow",
"network": "tcp",
"ip": "$(json_escape "$admin_host")",
"port": "$admin_port"
}
]
}
},
{
"tag": "$(json_escape "$reverse_tag")",
"protocol": "vless",
"settings": {
"address": "$(json_escape "$vps_host")",
"port": $vps_port,
"id": "$(json_escape "$uuid")",
"encryption": "$(json_escape "$encryption")",
"flow": "$(json_escape "$flow")",
"reverse": {
"tag": "$(json_escape "$reverse_tag")"
}
},
"streamSettings": {
"network": "tcp",
"security": "none"
}
}
],
"routing": {
"rules": [
{
"inboundTag": [
"$(json_escape "$reverse_tag")"
],
"outboundTag": "router-admin"
}
]
},
"remarks": "OpenWrt Remote client for $(json_escape "$router_id")"
}
EOF
if [ "$stdout" = "1" ]; then
cat "$out"
rm -f "$out"
return
fi
mkdir -p "$(dirname "$xray_config")"
cp "$out" "$xray_config"
chmod 0600 "$xray_config"
rm -f "$out"
printf '%s\n' "$xray_config"
}
run_xray() {
local enabled xray_bin xray_config
enabled="$(uci_get enabled 0)"
truthy "$enabled" || die "сервис выключен: включи option enabled '1'"
xray_bin="$(uci_get xray_bin /usr/bin/xray)"
xray_config="$(render_client_config)"
[ -x "$xray_bin" ] || die "xray не найден или не исполняемый: $xray_bin"
if "$xray_bin" help 2>/dev/null | grep -q 'run'; then
exec "$xray_bin" run -config "$xray_config"
fi
exec "$xray_bin" -config "$xray_config"
}
heartbeat_json() {
local router_id router_name role public_url hub_url xray_state service_state
router_id="$(safe_id "$(uci_get router_id main)")"
router_name="$(uci_get router_name "$router_id")"
role="$(uci_get role node)"
public_url="$(uci_get public_url '')"
hub_url="$(uci_get hub_url '')"
if xray_running; then
xray_state="running"
else
xray_state="stopped"
fi
if service_enabled; then
service_state="enabled"
else
service_state="disabled"
fi
cat <<EOF
{
"id": $(json_string "$router_id"),
"name": $(json_string "$router_name"),
"role": $(json_string "$role"),
"model": $(json_string "$(host_model)"),
"board": $(json_string "$(board_name)"),
"release": $(json_string "$(release_text)"),
"hostname": $(json_string "$(hostname 2>/dev/null || printf openwrt)"),
"public_url": $(json_string "$public_url"),
"admin_host": $(json_string "$(uci_get admin_host 127.0.0.1)"),
"admin_port": $(safe_num "$(uci_get admin_port 80)" 80),
"hub_url": $(json_string "$hub_url"),
"uptime": $(safe_num "$(uptime_seconds)" 0),
"load": $(json_string "$(load_text)"),
"memory": $(json_string "$(memory_text)"),
"xray": $(json_string "$xray_state"),
"service": $(json_string "$service_state")
}
EOF
}
post_json() {
local url token file
url="$1"
token="$2"
file="$3"
if command -v uclient-fetch >/dev/null 2>&1; then
uclient-fetch -q -O - \
--header="Authorization: Bearer $token" \
--header="Content-Type: application/json" \
--post-file="$file" "$url"
return
fi
if command -v wget >/dev/null 2>&1; then
wget -q -O - \
--header="Authorization: Bearer $token" \
--header="Content-Type: application/json" \
--post-file="$file" "$url"
return
fi
if command -v curl >/dev/null 2>&1; then
curl -fsS \
-H "Authorization: Bearer $token" \
-H "Content-Type: application/json" \
--data-binary "@$file" "$url"
return
fi
die "для heartbeat нужен uclient-fetch, wget или curl"
}
send_heartbeat() {
local hub_url token endpoint tmp
hub_url="$(uci_get hub_url '')"
token="$(uci_get hub_token '')"
[ -n "$hub_url" ] || die "hub_url пустой"
[ -n "$token" ] || die "hub_token пустой"
endpoint="${hub_url%/}/api/heartbeat"
tmp="${TMPDIR:-/tmp}/owrt-remote-heartbeat.$$"
heartbeat_json >"$tmp"
post_json "$endpoint" "$token" "$tmp"
rm -f "$tmp"
}
heartbeat_loop() {
local interval
interval="$(safe_num "$(uci_get heartbeat_interval 30)" 30)"
[ "$interval" -lt 10 ] && interval=10
while :; do
send_heartbeat >/dev/null 2>&1 || true
sleep "$interval"
done
}
status() {
printf 'router_id: %s\n' "$(uci_get router_id main)"
printf 'router_name: %s\n' "$(uci_get router_name '')"
printf 'enabled: %s\n' "$(uci_get enabled 0)"
printf 'hub_url: %s\n' "$(uci_get hub_url '')"
printf 'vps_host: %s\n' "$(uci_get vps_host '')"
printf 'vps_port: %s\n' "$(uci_get vps_port 8443)"
printf 'xray_bin: %s\n' "$(uci_get xray_bin /usr/bin/xray)"
printf 'xray_config: %s\n' "$(uci_get xray_config /etc/xray/owrt-remote-client.json)"
if xray_running; then
printf 'xray_state: running\n'
else
printf 'xray_state: stopped\n'
fi
if service_enabled; then
printf 'service: enabled\n'
else
printf 'service: disabled\n'
fi
}
doctor() {
local ok xray_bin
ok=1
xray_bin="$(uci_get xray_bin /usr/bin/xray)"
[ -x "$xray_bin" ] || {
log "нет Xray: $xray_bin"
ok=0
}
[ -n "$(uci_get hub_url '')" ] || {
log "hub_url пустой"
ok=0
}
[ -n "$(uci_get hub_token '')" ] || {
log "hub_token пустой"
ok=0
}
[ -n "$(uci_get vps_host '')" ] || {
log "vps_host пустой"
ok=0
}
[ -n "$(uci_get vless_uuid '')" ] || {
log "vless_uuid пустой"
ok=0
}
if [ "$ok" = "1" ]; then
printf '%s\n' "OK: конфиг выглядит готовым"
else
exit 1
fi
}
cmd="${1:-help}"
shift || true
case "$cmd" in
help|-h|--help)
usage
;;
status)
status
;;
doctor)
doctor
;;
render-client)
render_client_config "$@"
;;
run)
run_xray
;;
heartbeat)
send_heartbeat
;;
heartbeat-loop)
heartbeat_loop
;;
*)
usage >&2
exit 2
;;
esac
@@ -1,18 +0,0 @@
{
"admin/services/owrt-full-backup": {
"title": "OpenWrt Full Backup",
"order": 90,
"action": {
"type": "view",
"path": "owrt_full_backup"
},
"depends": {
"acl": [
"luci-app-owrt-full-backup"
],
"fs": {
"/www/cgi-bin/owrt-full-backup": "executable"
}
}
}
}
@@ -0,0 +1,19 @@
{
"admin/services/owrt-remote": {
"title": "OpenWrt Remote",
"order": 91,
"action": {
"type": "view",
"path": "owrt_remote"
},
"depends": {
"acl": [
"luci-app-owrt-remote"
],
"fs": {
"/www/cgi-bin/owrt-remote": "executable"
}
}
}
}
@@ -1,17 +0,0 @@
{
"luci-app-owrt-full-backup": {
"description": "Grant access to OpenWrt Full Backup LuCI helper",
"read": {
"ubus": {
"file": [
"read"
]
},
"file": {
"/etc/owrt-full-backup/web.key": [
"read"
]
}
}
}
}
@@ -0,0 +1,18 @@
{
"luci-app-owrt-remote": {
"description": "Grant access to OpenWrt Remote LuCI helper",
"read": {
"ubus": {
"file": [
"read"
]
},
"file": {
"/etc/owrt-remote/web.key": [
"read"
]
}
}
}
}