File rsnapshot-backup-scripts.spec of Package rsnapshot-backup-scripts

Overview Repositories Revisions Requests Users Attributes Meta

File rsnapshot-backup-scripts.spec of Package rsnapshot-backup-scripts

Name: rsnapshot-backup-scripts
Version: 3
Release: 0
Summary: Scripts for rsnapshot
License: GPL-2.0
Group: Productivity/Archiving/Backup
Obsoletes: %name-rsyncd
BuildArch: noarch
BuildRequires: sysuser-tools
#
%define user_syncthing syncthing
#
%define pkg_dir %_datadir/%name
#
# backup
%define nas_ip [fe80::201:2eff:fe94:56bd%%uplink]
%define rsync_port 4
%define rsync_connect %{nas_ip}:%{rsync_port}
# backup modules
%define priv_backup_rsync_module for-backup-priv
%define priv_backup_remote rsync://%{rsync_connect}/%{priv_backup_rsync_module}
%define priv_backup_local nas/%{priv_backup_rsync_module}
#
%define data_backup_rsync_module for-backup-data
%define data_backup_remote rsync://%{rsync_connect}/%{data_backup_rsync_module}
%define data_backup_local nas/%{data_backup_rsync_module}
#
##
#
# nas
%define nas_dir %{pkg_dir}/nas
%define nas_rsyncd_conf %{nas_dir}/rsyncd.conf
%define nas_rsyncd_service_name %name-nas.service
%define nas_rsyncd_service_path %_unitdir/%{nas_rsyncd_service_name}
%define nas_dovecot_service_name dovecot-android.service
%define nas_wlan0_service_name %name-wlan0.service
# nas modules
%define priv_nas_rsyncd_mount_name private
%define priv_nas_rsyncd_mount_path /%{priv_nas_rsyncd_mount_name}
%define priv_nas_rsyncd_pre  %{nas_dir}/rsyncd-pre-xfer.priv.sh
%define priv_nas_rsyncd_post %{nas_dir}/rsyncd-post-xfer.priv.sh
%define priv_nas_rsyncd_inotify %_rundir/%name.nas_rsyncd.priv.${RSYNC_PID}
#
%define data_nas_rsyncd_mount_name data
%define data_nas_rsyncd_mount_path /%{data_nas_rsyncd_mount_name}
%define data_nas_rsyncd_pre  %{nas_dir}/rsyncd-pre-xfer.data.sh
%define data_nas_rsyncd_post %{nas_dir}/rsyncd-post-xfer.data.sh
%define data_nas_rsyncd_inotify %_rundir/%name.nas_rsyncd.data.${RSYNC_PID}

# backup
%define backup_dir %{pkg_dir}/backup
%define backup_rsnapshot_mount_name private
%define backup_rsnapshot_mount_path /%{backup_rsnapshot_mount_name}
%define backup_rsnapshot_unit %name-backup
%define backup_rsnapshot_service_name %{backup_rsnapshot_unit}.service
%define backup_rsnapshot_service_path %_unitdir/%{backup_rsnapshot_service_name}
%define backup_rsnapshot_timer_name %{backup_rsnapshot_unit}.timer
%define backup_rsnapshot_timer_path %_unitdir/%{backup_rsnapshot_timer_name}
%define backup_rsnapshot_wrapper %{backup_dir}/rsnapshot_wrapper
%define backup_rsnapshot_config_file %{backup_dir}/rsnapshot.config.txt
%define backup_rsnapshot_config_rsync_include %{backup_dir}/rsnapshot.rsync_include.txt
%define backup_rsnapshot_config_rsync_exclude %{backup_dir}/rsnapshot.rsync_exclude.txt
%define backup_rsnapshot_config_rsync_postexec %{backup_dir}/rsnapshot.postexec.sh
%define backup_rsnapshot_pid %_rundir/%name.pid

# wlan
%define conf_dir %_datadir/%name-wlan
%define interface wlan0
%define priv_net 192.168.123
%define ip_address %{priv_net}.1
%define hostapd_ssid %name
%define hostapd_conf %{conf_dir}/hostapd.conf
%define hostapd_accept %{conf_dir}/hostapd.accept
%define hostapd_deny %{conf_dir}/hostapd.deny
%define hostapd_service_name %name-hostapd.service
%define hostapd_service_path %_unitdir/%{hostapd_service_name}
%define ip_address_service_name %name-ip-address-%{interface}.service
%define ip_address_service_path %_unitdir/%{ip_address_service_name}
%define ip_address_forward_masq_script %{conf_dir}/masq-forward.sh
%define dnsmasq_conf %{conf_dir}/dnsmasq.conf
%define dnsmasq_service_name %name-dnsmasq.service
%define dnsmasq_service_path %_unitdir/%{dnsmasq_service_name}
%define wlan_service_name %name-%{interface}.service
%define wlan_service_path %_unitdir/%{wlan_service_name}
#

%description
Cron scripts for rsnapshot, and config file.

%package -n system-user-%user_syncthing
Summary:        System user %user_syncthing
%?sysusers_requires

%description -n system-user-%user_syncthing
System user %user_syncthing

%package nas
Summary: Config for nas system
Group: Productivity/Archiving/Backup
Conflicts: %name-backup
Requires(pre):  system-user-%user_syncthing = %version-%release
Requires(pre): %name = %version-%release
Requires: %name = %version-%release
Requires: crda
Requires: dnsmasq-olh
Requires: hostapd
Requires: inotify-tools
Requires: iptables
Requires: kernel-default-extra
Requires: rsync
Requires: syncthing
%description nas

%package backup
Summary: Config for backup system
Group: Productivity/Archiving/Backup
Conflicts: %name-nas
Requires(pre): %name = %version-%release
Requires: %name = %version-%release
Requires: time
Requires: rsync
Requires: rsnapshot
%description backup

%prep
%setup -q -c -T

%build

%install
mkdir -vp %buildroot%_sbindir
pushd %buildroot
mkdir -vp .%_unitdir
mkdir -vp .%{conf_dir}
mkdir -vp .%{pkg_dir}
#
mkdir -vp .%_sysctldir
tee .%_sysctldir/%name.conf <<_EOF_
net.core.rmem_max = 2500000
_EOF_
#
# nas
#
mkdir -vp .%{nas_dir}
#
tee .%{nas_rsyncd_conf} <<'__EO_CONF__'
gid = users
read only = true
use chroot = true
transfer logging = true
log format = %%h %%o %%f %%l %%b
log file = /var/log/%name-nas-rsyncd.log
pid file = %_rundir/%name-nas-rsyncd.pid
port = %{rsync_port}
slp refresh = 300
use slp = false
reverse lookup = false

[%{priv_backup_rsync_module}]
	uid = 0
	gid = 0
	path = %{priv_nas_rsyncd_mount_path}
	comment = a comment
	numeric ids = true
	read only = true
	dont compress = true
	pre-xfer exec = %{priv_nas_rsyncd_pre}
	post-xfer exec = %{priv_nas_rsyncd_post}
[%{data_backup_rsync_module}]
	uid = 0
	gid = 0
	path = %{data_nas_rsyncd_mount_path}
	comment = a comment
	numeric ids = true
	read only = true
	dont compress = true
	pre-xfer exec = %{data_nas_rsyncd_pre}
	post-xfer exec = %{data_nas_rsyncd_post}
__EO_CONF__
#
tee .%{priv_nas_rsyncd_pre} <<'__EOS__'
#!/bin/bash
what='shutdown:sleep:idle:handle-power-key:handle-suspend-key:handle-hibernate-key:handle-lid-switch'
inotify="%{priv_nas_rsyncd_inotify}"
if test -d '%{priv_nas_rsyncd_mount_path}'
then
  if pushd '%{priv_nas_rsyncd_mount_path}' > /dev/null
  then
    stat_root="`stat -c '%%D' /`"
    stat_backup="`stat -c '%%D' .`"
    if test -n "${stat_root}" && test -n "${stat_backup}" && test "${stat_root}" != "${stat_backup}"
    then
      bash -c "cd / >> '${inotify}' ; exec $(type -P systemd-inhibit) --mode=block --what=${what} '--who=${0} from %name' '--why=${inotify}' -- '$(type -P inotifywait)' --quiet --quiet --timeout 0 '${inotify}'" < /dev/null &> /dev/null &
      exit 0
    fi
  fi
fi
echo '%{priv_nas_rsyncd_mount_path} missing'
exit 1
__EOS__
chmod -v 544 .%{priv_nas_rsyncd_pre}
#
tee .%{priv_nas_rsyncd_post} <<'__EOS__'
#!/bin/bash
rm -f "%{priv_nas_rsyncd_inotify}"
exit 0
__EOS__
chmod -v 544 .%{priv_nas_rsyncd_post}
#
tee .%{data_nas_rsyncd_pre} <<'__EOS__'
#!/bin/bash
what='shutdown:sleep:idle:handle-power-key:handle-suspend-key:handle-hibernate-key:handle-lid-switch'
inotify="%{data_nas_rsyncd_inotify}"
if test -d '%{data_nas_rsyncd_mount_path}'
then
  if pushd '%{data_nas_rsyncd_mount_path}' > /dev/null
  then
    stat_root="`stat -c '%%D' /`"
    stat_backup="`stat -c '%%D' .`"
    if test -n "${stat_root}" && test -n "${stat_backup}" && test "${stat_root}" != "${stat_backup}"
    then
      bash -c "cd / >> '${inotify}' ; exec $(type -P systemd-inhibit) --mode=block --what=${what} '--who=${0} from %name' '--why=${inotify}' -- '$(type -P inotifywait)' --quiet --quiet --timeout 0 '${inotify}'" < /dev/null &> /dev/null &
      exit 0
    fi
  fi
fi
echo '%{data_nas_rsyncd_mount_path} missing'
exit 1
__EOS__
chmod -v 544 .%{data_nas_rsyncd_pre}
#
tee .%{data_nas_rsyncd_post} <<'__EOS__'
#!/bin/bash
rm -f "%{data_nas_rsyncd_inotify}"
exit 0
__EOS__
chmod -v 544 .%{data_nas_rsyncd_post}
#
##
#
mkdir -vp .$(dirname %{nas_rsyncd_service_path})
tee .%{nas_rsyncd_service_path} <<'__EO_CONF__'
[Unit]
Description=rsyncd for %name-nas
After=network.target

[Service]
ExecStart=%_sbindir/rsyncd --daemon --no-detach --config=%{nas_rsyncd_conf}
IOSchedulingClass=idle
CPUSchedulingPolicy=batch
PrivateTmp=true

[Install]
WantedBy=multi-user.target
__EO_CONF__
#
pushd .%_sbindir
tee olh-start-nas <<'__EOS__'
#!/bin/bash
set -ex
env -i %_bindir/systemctl start systemd-cryptsetup@cr_%{priv_nas_rsyncd_mount_name}.service
env -i %_bindir/systemctl start %{priv_nas_rsyncd_mount_name}.mount
ls -la %{priv_nas_rsyncd_mount_path}/
ls -la %{data_nas_rsyncd_mount_path}/
env -i %_bindir/systemctl start %{nas_rsyncd_service_name}
env -i %_bindir/systemctl start %{nas_dovecot_service_name}
env -i %_bindir/systemctl start %{nas_wlan0_service_name}
env -i %_bindir/systemctl start syncthing@%{user_syncthing}.service
__EOS__
popd
#
# backup
#
mkdir -vp .%{backup_dir}
#
tee .%{backup_rsnapshot_service_path} <<'__EO_CONF__'
[Unit]
Description=rsyncd for %name-backup
After=network.target

[Service]
ExecStart=%_bindir/systemd-inhibit --mode=block '--who=%{backup_rsnapshot_wrapper} from %name' '--why=Isso' %{backup_rsnapshot_wrapper}
IOSchedulingClass=idle
CPUSchedulingPolicy=batch
PrivateTmp=true

[Install]
WantedBy=multi-user.target
__EO_CONF__
#
tee .%{backup_rsnapshot_timer_path} <<'__EO_CONF__'
[Unit]
Description=timer for %name-backup
After=network.target

[Timer]
OnUnitActiveSec=60m
OnBootSec=2s
__EO_CONF__
#
tee .%{backup_rsnapshot_wrapper} <<'__EOW__'
#!/bin/bash
LOCK_BASEDIR=/dev/shm/.%name
t=$(mktemp --tmpdir=/dev/shm)
trap 'rm -f "${t}"' EXIT
#

_setlockfd()
{
    local i
    for ((i = 0; i < ${#_lockdict}; i++))
    do [ -z "${_lockdict[$i]}" -o "${_lockdict[$i]}" = "$1" ] && break
    done
    _lockdict[$i]="$1"
    let _lockfd=200+i
    _lockfile="$LOCK_BASEDIR/$1"
}

claim_lock()
{
    mkdir -p "$LOCK_BASEDIR"
    _setlockfd $1
    while true; do
        eval "exec $_lockfd<>$_lockfile"
        flock -x $_lockfd || return $?

_fd_inum=`stat -L -c '%%i' /proc/self/fd/$_lockfd`
        _file_inum=`sh -c "stat -c '%%i' $_lockfile || true"`
        if [ x$_fd_inum = x$_file_inum ]; then break; fi
        eval "exec $_lockfd<&-"
    done
}

release_lock()
{
    _setlockfd $1
    rm "$_lockfile"
}

do_rsnapshot() {
      local cfg="$1"
      local interval=$2

echo "running $interval"
      "$(type -P time)" -f 'runtime was %E' \
      "$(type -P nice)" -n 19 \
      "$(type -P ionice)" -c 3 \
      "$(type -P rsnapshot)" -x -c "${cfg}" ${interval}
}

do_work()
{
        local cfg="$1"
        local interval_name
        local rc
        local -i interval_cnt=0
        local -i j=0
        local -i num
        local -i interval_num
        local -i num_per_interval
        local -a backup
        #
        #
        grep -w ^interval "$cfg" > $t
        while read config name count rest
        do
                backup[$num]="$name.$count"
                num=$((++num))
        done < $t

interval_num="${#backup[@]}"
        interval_cnt=0
        while test $interval_cnt -lt $interval_num
        do
                interval_name=${backup[$interval_cnt]%%.*}
                num_per_interval=${backup[$interval_cnt]##*.}
                last_run=Lastrun.$interval_cnt.$interval_name

cd '%{backup_rsnapshot_mount_path}'
                if test ! -d $last_run
                then
                        mkdir $last_run
                fi

interval_done=true
                j=1
                while test $j -lt $num_per_interval
                do
                        if test -d $last_run/$j
                        then
                                : $(( j++ ))
                                continue
                        fi
                        mkdir $last_run/$j
                        interval_done=false
                        break
                done
                do_rsnapshot "$cfg" $interval_name
                rc=$?
                if test "$rc" != "0"
                then
                        touch "%{backup_rsnapshot_mount_path}/last.$interval_name.fail"
                        return $rc
                fi
                touch "%{backup_rsnapshot_mount_path}/last.$interval_name"
                if test "$interval_done" = "false"
                then
                        break
                fi
                rm -rf $last_run
                mkdir $last_run
                : $(( interval_cnt++ ))
        done
        return 0
}
#
if test -d '%{backup_rsnapshot_mount_path}' && rsync '%{priv_backup_remote}'
then
  if pushd '%{backup_rsnapshot_mount_path}' > /dev/null
  then
    stat_root="`stat -c '%%D' /`"
    stat_backup="`stat -c '%%D' .`"
    if test -n "${stat_root}" && test -n "${stat_backup}" && test "${stat_root}" != "${stat_backup}"
    then
      claim_lock rsnapshot_pid_lock
      echo "claimed rsnapshot_pid_lock"
      do_work %{backup_rsnapshot_config_file}
      release_lock rsnapshot_pid_lock
      echo "released rsnapshot_pid_lock"
      popd > /dev/null
      (
      sync
      sync
      ) < /dev/null > /dev/null &
    fi
  fi
fi
__EOW__
chmod -v 744 .%{backup_rsnapshot_wrapper}
#
mkdir -vp .%{config_dir}
tee .%{backup_rsnapshot_config_rsync_include} <<'__EO_INCLUDE__'
__EO_INCLUDE__
#
tee .%{backup_rsnapshot_config_rsync_exclude} <<'__EO_EXCLUDE__'
.gvfs/
*~
.*~
.*.~
.cache/
.config/pulse/
.fetchmail.pid
.config/nautilus/desktop-metadata
.local/share/gnome-shell/application_state
.local/share/gvfs-metadata
.local/share/xorg/Xorg.0.log
.local/share/xorg/Xorg.0.log.old
.lesshst
.osc_cookiejar
.viminfo
.xsession-errors-:0
.xsession-errors
.xsession-errors.old
fetchmail.log
unison.log
NetworkManager/system-connections/Auto en0
firefox/*/_CACHE_CLEAN_
firefox/*/lock
firefox/*/*.sqlite-shm
firefox/*/Cache/
firefox/*/safebrowsing/
firefox/*/thumbnails/
thunderbird/*/Cache
.thunderbird/*/ImapMail/*/*.msf
.claws-mail/*.bak
.claws-mail/*_history
.claws-mail/*.log
.claws-mail/*.tmpl
.claws-mail/*/*.bak
.claws-mail/imapcache/
.claws-mail/mimetmp/
.claws-mail/newscache/
.claws-mail/tagsdb/
.claws-mail/tmp/
__EO_EXCLUDE__
#
tee .%{backup_rsnapshot_config_rsync_postexec} <<'__EO_POSTEXEC__'
#!/bin/bash
debug=
if test -e /dev/shm/%name.postexec.debug
then
	exec > /dev/shm/postexec.debug.$PPID.$$.txt
	exec 2>&1
	pwd
	env
	ps faxww
	debug="--verbose"
fi
unset LANG
unset ${!LC_*}
prog=$0
old=hourly.1
new=hourly.0
links=1
jobs=1
cmd=
do_find() {
	cd '%{backup_rsnapshot_mount_path}'
	if test -d "${old}"
	then
		if pushd "${new}" > /dev/null
		then
			if test "${links}" = "ignore"
			then
				links=
			else
				links="-links ${links}"
			fi
			if test "${jobs}" = "ignore"
			then
				jobs=
			else
				jobs="--max-procs=${jobs}"
			fi
			find -type f ${links} -print0 | sort -z | xargs --no-run-if-empty --null --max-args=123 ${jobs} "${prog}" --old "${old}" --new "${new}" --compare --
			popd > /dev/null
		fi
	fi
}

do_compare() {
	local f
	for f
	do
		if test -f "../${old}/${f}" && test -f "${f}"
		then
			if test ` stat -c %%i "../${old}/${f}" ` = ` stat -c %%i "${f}" `
			then
				continue
			fi
			if cmp -s "../${old}/${f}" "${f}"
			then
				touch -r "${f}" "../${old}/${f}"
				chown ${debug} "--reference=${f}" "../${old}/${f}"
				chmod ${debug} "--reference=${f}" "../${old}/${f}"
				ln    ${debug}  --force "../${old}/${f}" "${f}"
			fi
		fi
	done
}
until test $# = 0
do
	case "$1" in
		--old)
		old="$2"
		shift 2
		;;
		--new)
		new="$2"
		shift 2
		;;
		--links)
		links="$2"
		shift 2
		;;
		--jobs)
		jobs="$2"
		shift 2
		;;
		--compare)
		shift
		cmd=compare
		;;
		--find)
		shift
		cmd=find
		;;
		--)
		shift
		case "${cmd}" in
			compare) do_compare "$@" ; exit 0 ;;
			find) do_find ; exit 0 ;;
			*) exit 1 ;;
		esac
		;;
		*)
		exit 1
		;;
	esac
done
if test "${cmd}" = "find"
then
	do_find
	exit 0
fi
exit 1
__EO_POSTEXEC__
chmod -v 544 .%{backup_rsnapshot_config_rsync_postexec}
#
tee .%{backup_rsnapshot_config_file} <<'__EO_CONF__'
config_version	1.2
snapshot_root	%{backup_rsnapshot_mount_path}
cmd_postexec	%{backup_rsnapshot_config_rsync_postexec} --find
no_create_root	1
cmd_cp		/bin/cp
cmd_rm		/bin/rm
cmd_rsync	/usr/bin/rsync
cmd_logger	/bin/logger
cmd_du		/usr/bin/du
cmd_rsnapshot_diff	/usr/bin/rsnapshot-diff
interval	hourly	24
interval	daily	7
interval	weekly	4
interval	monthly	12
interval	yearly	12
verbose		2
loglevel	3
logfile	/var/log/rsnapshot
lockfile	%{backup_rsnapshot_pid}
rsync_long_args	--sparse --hard-links --delete --numeric-ids --relative --delete-excluded
one_fs		1
include_file	%{backup_rsnapshot_config_rsync_include}
exclude_file	%{backup_rsnapshot_config_rsync_exclude}
link_dest	1
use_lazy_deletes	1

backup	%{priv_backup_remote}	%{priv_backup_local}
backup	%{data_backup_remote}	%{data_backup_local}
__EO_CONF__
#
pushd .%_sbindir
tee olh-start-backup <<'__EOS__'
#!/bin/bash
set -ex
env -i %_bindir/systemctl start systemd-cryptsetup@cr_%{backup_rsnapshot_mount_name}.service
env -i %_bindir/systemctl start %{backup_rsnapshot_mount_name}.mount
ls -la %{backup_rsnapshot_mount_path}/
env -i %_bindir/systemctl start %{backup_rsnapshot_timer_name}
__EOS__
popd
#

# wlan
tee .%{hostapd_accept} <<'__EOC__'
__EOC__
tee .%{hostapd_deny} <<'__EOC__'
__EOC__
tee .%{hostapd_conf} <<'__EOC__'
accept_mac_file=%{hostapd_accept}
auth_algs=1
channel=7
deny_mac_file=%{hostapd_deny}
hw_mode=g
ignore_broadcast_ssid=0
interface=%{interface}
macaddr_acl=0
rsn_pairwise=CCMP
ssid=%{hostapd_ssid}
wmm_enabled=0
wpa=2
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
wpa_psk_file=%_rundir/%name-hostapd.wpa_psk
__EOC__
#
tee .%{hostapd_service_path} <<'__EOC__'
[Unit]
Description=hostapd for %name
After=remote-fs.target
After=network.target

[Service]
PIDFile=%_rundir/%name-hostapd.pid
ExecStartPre=-%_bindir/rm -fv '%_rundir/%name-hostapd.conf' '%_rundir/%name-hostapd.wpa_psk'
ExecStartPre=-%_bindir/sh -c "cat '%{hostapd_conf}'                  >> '%_rundir/%name-hostapd.conf'"
ExecStartPre=-%_bindir/sh -c "echo ssid=$HOSTNAME                    >> '%_rundir/%name-hostapd.conf'"
ExecStartPre=-%_bindir/sh -c "echo wpa_passphrase=$HOSTNAME$HOSTNAME >> '%_rundir/%name-hostapd.conf'"
ExecStartPre=-%_bindir/sh -c "cat '/etc/%name.hostapd.conf'        >> '%_rundir/%name-hostapd.conf'"
ExecStartPre=-%_bindir/sh -c "cat '/etc/%name.hostapd.wpa_psk'     >> '%_rundir/%name-hostapd.wpa_psk'"
ExecStart=%_sbindir/hostapd -P %_rundir/%name-hostapd.pid %_rundir/%name-hostapd.conf
ExecReload=/bin/kill -HUP $MAINPID

[Install]
WantedBy=multi-user.target
__EOC__
#
tee .%{ip_address_service_path} <<'__EOC__'
[Unit]
Description=ip address on %{interface} for %name
After=network.target
After=remote-fs.target
After=%{hostapd_service_name}

[Service]
Type=oneshot
RemainAfterExit=true
ExecStartPre=%_bindir/sh -c "echo 1 > '/proc/sys/net/ipv6/conf/%{interface}/disable_ipv6'"
ExecStart=%_sbindir/ip addr add '%{ip_address}/24' dev '%{interface}'
ExecStartPost=%{ip_address_forward_masq_script} '%{interface}' enable
ExecStop=%_sbindir/ip addr del '%{ip_address}/24' dev '%{interface}'
ExecStopPost=%{ip_address_forward_masq_script} '%{interface}' disable

[Install]
WantedBy=multi-user.target
__EOC__
#
tee .%{ip_address_forward_masq_script} <<'__EOS__'
#!/bin/bash
set -e
read td < <(mktemp --directory --tmpdir=/dev/shm .XXX)
trap "rm -rf '${td}'" EXIT
t_route4="${td}/r4"
#
LAN_interface="$1"
command="$2"
#
gateway_ip4=
gateway_slash_something=
gateway_interface=

#
fn() {
	local fwd=$1
	local cmd=$2

echo "${fwd}" > "/proc/sys/net/ipv4/conf/${LAN_interface}/forwarding"
	echo "${fwd}" > "/proc/sys/net/ipv4/conf/${gateway_interface}/forwarding"

iptables --table filter \
		"${cmd}" FORWARD \
		--in-interface "${LAN_interface}" \
		--destination "${gateway_slash_something}" \
		--jump REJECT \
		--reject-with=icmp-net-prohibited
	iptables --table nat \
		"${cmd}" POSTROUTING \
		--out-interface "${gateway_interface}" \
		--jump MASQUERADE
	iptables "${cmd}" FORWARD \
		--in-interface "${LAN_interface}" \
		--jump ACCEPT
}
ip -4 route show > "${t_route4}"

# get default gateway
while read
do
	set -- ${REPLY}
	case "$1" in
	default)
		shift
		while test $# -gt 0
		do
			: $*
			case "$1" in
			dev) gateway_interface=$2 ; shift ;;
			proto) shift ;;
			scope) shift ;;
			src) shift ;;
			via) gateway_ip4=$2 ; shift ;;
			*) echo >&2 "Unhandled $*" ;;
			esac
			shift
		done

echo "gateway: ${gateway_ip4} on ${gateway_interface}"
		break
	;;
	esac
done < "${t_route4}"
# sanity check
if test -z "${gateway_interface}"
then
	echo >&2 "Could not get interface which is connected to the gateway"
	exit 1
fi

# get slash-something on gateway_interface
while read
do
	set -- ${REPLY}
	case "$1" in
	default) ;;
	*)
		gateway_net=
		found_dev=
		found_scope=
		slash_something=$1
		shift
		while test $# -gt 0
		do
			: $*
			case "$1" in
			dev)
				test "${2}" = "${gateway_interface}" && found_dev=$2
				shift
				;;
			proto) shift ;;
			scope)
				test "${2}" = 'link' && found_scope=$2
				shift
				;;
			src) shift ;;
			via) shift ;;
			*) echo >&2 "Unhandled $1" ;;
			esac
			shift
		done
		if test -n "${found_dev}" && test -n "${found_scope}"
		then
			gateway_slash_something=${slash_something}
			echo "uplink network: ${slash_something} on ${found_dev}"
			break
		fi
	;;
	esac
done < "${t_route4}"

# get slash-something on LAN_interface
while read
do
	set -- ${REPLY}
	case "$1" in
	default) ;;
	*)
		gateway_net=
		found_dev=
		found_scope=
		slash_something=$1
		shift
		while test $# -gt 0
		do
			: $*
			case "$1" in
			dev)
				test "${2}" = "${LAN_interface}" && found_dev=$2
				shift
				;;
			proto) shift ;;
			scope)
				test "${2}" = 'link' && found_scope=$2
				shift
				;;
			src) shift ;;
			via) shift ;;
			*) echo >&2 "Unhandled $1" ;;
			esac
			shift
		done
		if test -n "${found_dev}" && test -n "${found_scope}"
		then
			echo "LAN network: ${slash_something} on ${found_dev}"
			break
		fi
	;;
	esac
done < "${t_route4}"
#
case "${command}" in
enable)  fn '1' '-A' ;;
disable) fn '0' '-D' ;;
*) echo >&2 "Unknown commands: $*" ; exit 1 ;;
esac
__EOS__
#
tee .%{dnsmasq_conf} <<'__EOC__'
no-hosts
bind-interfaces
listen-address=%{ip_address}
dhcp-range=%{priv_net}.111,%{priv_net}.222
dhcp-leasefile=%_rundir/%name.dnsmasq.leasefile
dhcp-ignore-names
dhcp-authoritative
log-async=123
log-dhcp
log-facility=%_rundir/%name.dnsmasq.log.txt
log-queries
server=127.0.0.1
__EOC__
#
tee .%{dnsmasq_service_path} <<'__EOC__'
[Unit]
Description=dnsmasq for %name
After=remote-fs.target
After=network.target
After=%{hostapd_service_name}
After=%{ip_address_service_name}

[Service]
ExecStartPre=-%_bindir/rm -fv '%_rundir/%name-dnsmasq.conf'
ExecStartPre=-%_bindir/sh -c 'cat %{dnsmasq_conf}                                         >> %_rundir/%name-dnsmasq.conf'
ExecStartPre=-%_bindir/sh -c 'echo interface-name=$HOSTNAME,%{interface}                  >> %_rundir/%name-dnsmasq.conf'
ExecStartPre=-%_bindir/sh -c 'echo synth-domain=%{interface},%{priv_net}.0/24,$HOSTNAME-* >> %_rundir/%name-dnsmasq.conf'
ExecStart=%_sbindir/dnsmasq --keep-in-foreground --conf-file=%_rundir/%name-dnsmasq.conf
ExecReload=/bin/kill -HUP $MAINPID

[Install]
WantedBy=multi-user.target
__EOC__
#
tee .%{wlan_service_path} <<'__EOC__'
[Unit]
Description=%name
After=network-online.target
After=network.target
After=remote-fs.target

Requires=%{hostapd_service_name}
After=%{hostapd_service_name}
Requires=%{ip_address_service_name}
After=%{ip_address_service_name}
Requires=%{dnsmasq_service_name}
After=%{dnsmasq_service_name}

[Service]
Type=oneshot
RemainAfterExit=true
ExecStart=%_sbindir/ip -oneline address show dev %{interface}

[Install]
WantedBy=multi-user.target
__EOC__
#
#
#
popd
#
suc='system-user-%user_syncthing.conf'
tee "${suc}" <<'_EOC_'
g %user_syncthing 55  -
u %user_syncthing 55  "%user_syncthing for %priv_nas_rsyncd_mount_path"  %priv_nas_rsyncd_mount_path/%user_syncthing /bin/bash
_EOC_
mkdir -p '%buildroot%_sysusersdir'
cp -aviLt "$_" "${suc}"
%sysusers_generate_pre "${suc}" system-user-%user_syncthing

%pre -n system-user-%user_syncthing -f system-user-%user_syncthing.pre
%files -n system-user-%user_syncthing
%_sysusersdir/*.conf

%files
%dir %{pkg_dir}

%files nas
%config %{nas_dir}
%attr(544,root,root) %config %_sbindir/olh-start-nas
%config %{nas_rsyncd_service_path}
%config(noreplace) %{wlan_service_path}
%config(noreplace) %{dnsmasq_service_path}
%config(noreplace) %{ip_address_service_path}
%attr(544,root,root) %config(noreplace) %{ip_address_forward_masq_script}
%config(noreplace) %{hostapd_service_path}
%config(noreplace) %{conf_dir}
%config(noreplace) %_sysctldir

%files backup
%config %{backup_dir}
%attr(544,root,root) %config %_sbindir/olh-start-backup
%config %{backup_rsnapshot_service_path}
%config %{backup_rsnapshot_timer_path}

Places

File rsnapshot-backup-scripts.spec of Package rsnapshot-backup-scripts

Places