telegram-bot-bash/bashbot.sh

1093 lines
38 KiB
Bash
Raw Normal View History

#!/bin/bash
2019-04-24 08:07:46 +00:00
# file: bashbot.sh
# do not edit, this file will be overwritten on update
2015-07-10 05:43:08 +00:00
# bashbot, the Telegram bot written in bash.
2019-04-01 10:52:25 +00:00
# Written by Drew (@topkecleon) and Daniil Gentili (@danogentili), KayM (@gnadelwartz).
# Also contributed: JuanPotato, BigNerd95, TiagoDanin, iicc1.
# https://github.com/topkecleon/telegram-bot-bash
# Depends on JSON.sh (http://github.com/dominictarr/JSON.sh) (MIT/Apache),
2015-07-10 05:43:08 +00:00
# This file is public domain in the USA and all free countries.
# Elsewhere, consider it to be WTFPLv2. (wtfpl.net/txt/copying)
#
#### $$VERSION$$ v0.98-dev-26-g8991cc9
2019-04-01 10:52:25 +00:00
#
# Exit Codes:
# - 0 sucess (hopefully)
# - 1 can't change to dir
2019-04-12 09:27:20 +00:00
# - 2 can't write to tmp, count or token
# - 3 user / command / file not found
2019-04-01 10:52:25 +00:00
# - 4 unkown command
# - 5 cannot connect to telegram bot
# - 6 mandatory module not found
# shellcheck disable=SC2140,SC2031,SC2120,SC1091
2019-03-22 16:47:36 +00:00
# are we runnig in a terminal?
if [ -t 1 ] && [ -n "$TERM" ]; then
CLEAR='clear'
RED='\e[31m'
GREEN='\e[32m'
ORANGE='\e[35m'
2020-05-18 12:57:53 +00:00
GREY='\e[1;30m'
NC='\e[0m'
fi
2020-05-14 19:31:52 +00:00
# some important helper functions
# returns true if command exist
_exists() {
[ "$(LC_ALL=C type -t "${1}")" = "file" ]
2020-05-14 19:31:52 +00:00
}
# execute function if exists
_exec_if_function() {
2020-06-15 07:09:08 +00:00
[ "$(LC_ALL=C type -t "${1}")" != "function" ] && return 1
"$@"
2020-05-14 19:31:52 +00:00
}
# returns true if function exist
_is_function() {
[ "$(LC_ALL=C type -t "${1}")" = "function" ]
}
# round $1 in international notation! , returns float with $2 decimal digits
# if $2 is not fiven or is not a positive number, it's set to zero
_round_float() {
local digit="${2}"; [[ "${2}" =~ ^[0-9]+$ ]] || digit="0"
LC_ALL=C printf "%.${digit}f" "${1}"
2020-05-14 19:31:52 +00:00
}
setConfigKey() {
[[ "$1" =~ ^[-a-zA-Z0-9,._]+$ ]] || return 3
printf '["%s"]\t"%s"\n' "${1//,/\",\"}" "${2//\"/\\\"}" >>"${BOTDATABASE}.jssh"
}
2020-06-15 07:09:08 +00:00
declare -A BASHBOTCONFIG
2020-06-12 19:18:32 +00:00
getConfigKey() {
[[ "$1" =~ ^[-a-zA-Z0-9,._]+$ ]] || return 3
2020-06-15 07:09:08 +00:00
# cache if aupdateArray exists, else read from file
_exec_if_function jssh_updateArray_async "BASHBOTCONFIG" "${BOTDATABASE}" && printf '%s' "${BASHBOTCONFIG[${1}]}" && return
2020-06-13 16:40:34 +00:00
[ -r "${BOTDATABASE}.jssh" ] && sed -n 's/\["'"$1"'"\]\t*"\(.*\)"/\1/p' <"${BOTDATABASE}.jssh" | tail -n 1
2020-06-12 19:18:32 +00:00
}
2020-05-14 19:31:52 +00:00
2020-06-15 07:09:08 +00:00
2019-04-23 11:07:20 +00:00
# get location and name of bashbot.sh
SCRIPT="$0"
REALME="${BASH_SOURCE[0]}"
SCRIPTDIR="$(dirname "${REALME}")"
RUNDIR="$(dirname "$0")"
MODULEDIR="${SCRIPTDIR}/modules"
2020-05-14 17:47:37 +00:00
# adjust locations based on source and real name
if [ "${SCRIPT}" != "${REALME}" ] || [ "$1" = "source" ]; then
SOURCE="yes"
fi
2019-05-23 10:26:53 +00:00
if [ -n "$BASHBOT_HOME" ]; then
2019-05-23 10:26:53 +00:00
SCRIPTDIR="$BASHBOT_HOME"
else
BASHBOT_HOME="${SCRIPTDIR}"
2019-05-23 10:26:53 +00:00
fi
[ -z "${BASHBOT_ETC}" ] && BASHBOT_ETC="$BASHBOT_HOME"
[ -z "${BASHBOT_VAR}" ] && BASHBOT_VAR="$BASHBOT_HOME"
2019-05-23 10:26:53 +00:00
2020-06-06 07:21:56 +00:00
ADDONDIR="${BASHBOT_ETC:-.}/addons"
2019-04-23 16:11:24 +00:00
RUNUSER="${USER}" # USER is overwritten by bashbot array
2019-03-31 10:52:11 +00:00
# OK everthing setup, lest start
if [ "${SOURCE}" != "yes" ] && [ -z "$BASHBOT_HOME" ] && ! cd "${RUNDIR}" ; then
2019-04-23 11:07:20 +00:00
echo -e "${RED}ERROR: Can't change to ${RUNDIR} ...${NC}"
2019-03-31 10:52:11 +00:00
exit 1
2019-05-31 20:33:59 +00:00
else
RUNDIR="."
2019-03-31 10:52:11 +00:00
fi
2019-03-22 16:47:36 +00:00
if [ ! -w "." ]; then
2019-04-23 11:07:20 +00:00
echo -e "${ORANGE}WARNING: ${RUNDIR} is not writeable!${NC}"
2019-03-22 16:47:36 +00:00
ls -ld .
fi
# Setup and check environment if BOTTOKEN is NOT set
2020-06-12 19:18:32 +00:00
BOTDATABASE="${BASHBOT_ETC:-.}/botconfig"
2019-04-23 11:07:20 +00:00
TOKENFILE="${BASHBOT_ETC:-.}/token"
BOTADMIN="${BASHBOT_ETC:-.}/botadmin"
BOTACL="${BASHBOT_ETC:-.}/botacl"
DATADIR="${BASHBOT_VAR:-.}/data-bot-bash"
BLOCKEDFILE="${BASHBOT_VAR:-.}/blocked"
COUNTFILE="${BASHBOT_VAR:-.}/count"
LOGDIR="${RUNDIR:-.}/logs"
if [ ! -d "${LOGDIR}" ] || [ ! -w "${LOGDIR}" ]; then
LOGDIR="${RUNDIR:-.}"
fi
2020-06-12 19:18:32 +00:00
DEBUGLOG="${LOGDIR}/DEBUG.log"
ERRORLOG="${LOGDIR}/ERROR.log"
2020-06-12 19:18:32 +00:00
UPDATELOG="${LOGDIR}/UPDATE.log"
# we assume everthing is already set up correctly if we have TOKEN
2020-05-14 19:31:52 +00:00
if [ -z "${BOTTOKEN}" ]; then
2020-06-12 19:18:32 +00:00
# DATABASE does not exist, create
[ ! -f "${BOTDATABASE}.jssh" ] &&
printf '["bot_config_key"]\t"config_key_value"\n' >"${BOTDATABASE}.jssh"
# BOTTOKEN empty read ask user
if [ -z "$(getConfigKey "bottoken")" ]; then
2020-06-12 19:18:32 +00:00
# convert old token
if [ -r "${TOKENFILE}" ]; then
token="$(< "${TOKENFILE}")"
2020-06-12 19:18:32 +00:00
# no old token avalible ask user
elif [ -z "${CLEAR}" ] && [ "$1" != "init" ]; then
2020-05-14 17:47:37 +00:00
echo "Running headless, set BOTTOKEN or run ${SCRIPT} init first!"
2019-04-12 09:27:20 +00:00
exit 2
else
${CLEAR}
echo -e "${RED}TOKEN MISSING.${NC}"
echo -e "${ORANGE}PLEASE WRITE YOUR TOKEN HERE OR PRESS CTRL+C TO ABORT${NC}"
read -r token
fi
[ -n "${token}" ] && printf '["bottoken"]\t"%s"\n' "${token}" >> "${BOTDATABASE}.jssh"
fi
2020-05-18 12:57:53 +00:00
# setup botadmin file
if [ -z "$(getConfigKey "botadmin")" ]; then
# convert old token
if [ -r "${BOTADMIN}" ]; then
admin="$(< "${BOTADMIN}")"
elif [ -z "${CLEAR}" ]; then
2019-04-12 09:27:20 +00:00
echo "Running headless, set botadmin to AUTO MODE!"
else
${CLEAR}
echo -e "${RED}BOTADMIN MISSING.${NC}"
2019-04-12 09:27:20 +00:00
echo -e "${ORANGE}PLEASE WRITE YOUR TELEGRAM ID HERE OR ENTER '?'${NC}"
echo -e "${ORANGE}TO MAKE FIRST USER TYPING '/start' TO BOTADMIN${NC}"
read -r admin
fi
[ -z "${admin}" ] && admin='?'
printf '["botadmin"]\t"%s"\n' "${admin}" >> "${BOTDATABASE}.jssh"
fi
# setup botacl file
if [ ! -f "${BOTACL}" ]; then
2019-04-12 11:14:33 +00:00
echo -e "${ORANGE}Create empty ${BOTACL} file.${NC}"
printf '\n' >"${BOTACL}"
fi
# setup data dir file
if [ ! -d "${DATADIR}" ]; then
2019-05-28 18:44:40 +00:00
mkdir "${DATADIR}"
elif [ ! -w "${DATADIR}" ]; then
2019-05-28 18:44:40 +00:00
echo -e "${RED}ERROR: Can't write to ${DATADIR}!.${NC}"
ls -ld "${DATADIR}"
2019-04-01 10:52:25 +00:00
exit 2
fi
# setup count file
if [ ! -f "${COUNTFILE}.jssh" ]; then
2020-06-10 06:20:48 +00:00
printf '["counted_user_chat_id"]\t"num_messages_seen"\n' > "${COUNTFILE}.jssh"
# convert old file on creation
if [ -r "${COUNTFILE}" ];then
sed 's/COUNT/\[\"/;s/$/\"\]\t\"1\"/' < "${COUNTFILE}" >> "${COUNTFILE}.jssh"
fi
elif [ ! -w "${COUNTFILE}.jssh" ]; then
2019-04-20 14:26:16 +00:00
echo -e "${RED}ERROR: Can't write to ${COUNTFILE}!.${NC}"
ls -l "${COUNTFILE}.jssh"
2019-04-01 10:52:25 +00:00
exit 2
fi
# setup blocked file
if [ ! -f "${BLOCKEDFILE}.jssh" ]; then
2020-06-10 06:20:48 +00:00
printf '["blocked_user_or_chat_id"]\t"name and reason"\n' >"${BLOCKEDFILE}.jssh"
fi
2019-03-22 16:47:36 +00:00
fi
2020-06-12 19:18:32 +00:00
# read BOTTOKEN from bot database if not set
[ -z "${BOTTOKEN}" ] && BOTTOKEN="$(getConfigKey "bottoken")"
2020-05-19 12:58:29 +00:00
# BOTTOKEN format checks
if [[ ! "${BOTTOKEN}" =~ ^[0-9]{8,10}:[a-zA-Z0-9_-]{35}$ ]]; then
echo -e "${ORANGE}Warning, your bottoken may incorrect. it should have the following format:${NC}"
echo -e "${GREY}123456789${RED}:${GREY}Aa-Zz_0Aa-Zz_1Aa-Zz_2Aa-Zz_3Aa-Zz_4${ORANGE} => ${NC}\c"
echo -e "${GREY}8-10 digits${RED}:${GREY}35 alnum characters + '_-'${NC}"
echo -e "${ORANGE}Your current token is: '${GREY}^$(cat -ve <<<"${BOTTOKEN//:/${RED}:${GREY}}")${ORANGE}'${NC}"
[[ ! "${BOTTOKEN}" =~ ^[0-9]{8,10}: ]] &&\
echo -e "${ORANGE}Possible problem in the digits part, len is $(($(wc -c <<<"${BOTTOKEN%:*}")-1))${NC}"
[[ ! "${BOTTOKEN}" =~ :[a-zA-Z0-9_-]{35}$ ]] &&\
echo -e "${ORANGE}Posilbe problem in the charatcers part, len is $(($(wc -c <<<"${BOTTOKEN#*:}")-1))${NC}"
2020-05-18 12:57:53 +00:00
fi
2019-03-22 16:47:36 +00:00
2020-05-20 14:38:56 +00:00
##################
# here we start with the real stuff
2020-06-11 06:33:59 +00:00
BASHBOT_RETRY="" # retry by default
2019-04-12 18:49:58 +00:00
2020-06-10 06:20:48 +00:00
URL="${BASHBOT_URL:-https://api.telegram.org/bot}${BOTTOKEN}"
2019-04-12 18:49:58 +00:00
ME_URL=$URL'/getMe'
UPD_URL=$URL'/getUpdates?offset='
2019-04-26 11:19:34 +00:00
GETFILE_URL=$URL'/getFile'
2019-04-23 16:11:24 +00:00
2020-06-12 19:18:32 +00:00
#################
# BASHBOT COMMON functions
2019-05-28 19:12:02 +00:00
declare -rx SCRIPT SCRIPTDIR MODULEDIR RUNDIR ADDONDIR TOKENFILE BOTADMIN BOTACL DATADIR COUNTFILE
declare -rx BOTTOKEN URL ME_URL UPD_URL GETFILE_URL
2019-05-28 18:50:19 +00:00
declare -ax CMD
2020-05-14 11:04:57 +00:00
declare -Ax UPD BOTSENT USER MESSAGE URLS CONTACT LOCATION CHAT FORWARD REPLYTO VENUE iQUERY SERVICE NEWMEMBER
2019-05-28 18:50:19 +00:00
export res CAPTION
2019-04-12 18:49:58 +00:00
2019-05-26 19:25:01 +00:00
##################
# read commamds file if we are not sourced
2019-05-10 09:33:41 +00:00
COMMANDS="${BASHBOT_ETC:-.}/commands.sh"
if [ "${SOURCE}" != "yes" ]; then
2019-05-10 09:33:41 +00:00
if [ ! -f "${COMMANDS}" ] || [ ! -r "${COMMANDS}" ]; then
echo -e "${RED}ERROR: ${COMMANDS} does not exist or is not readable!.${NC}"
ls -l "${COMMANDS}"
exit 3
fi
fi
2020-06-10 12:02:29 +00:00
# shellcheck source=./commands.sh
[ -r "${COMMANDS}" ] && source "${COMMANDS}" "source"
2019-05-10 09:33:41 +00:00
2020-06-10 06:20:48 +00:00
###############
# load modules
for modules in "${MODULEDIR:-.}"/*.sh ; do
# shellcheck source=./modules/aliases.sh
if ! _is_function "$(basename "${modules}")" && [ -r "${modules}" ]; then source "${modules}" "source"; fi
done
#####################
# BASHBOT INTERNAL functions
#
2020-06-12 19:18:32 +00:00
# do we have BSD sed
if ! sed '1ia' </dev/null 2>/dev/null; then
echo -e "${ORANGE}Warning: You may run on a BSD style system without gnu utils ...${NC}"
fi
2020-06-10 06:20:48 +00:00
#jsonDB is now mandatory
if ! _is_function jssh_newDB ; then
echo -e "${RED}ERROR: Mandatory module jsonDB is missing or not readable!"
exit 6
fi
2020-06-12 19:18:32 +00:00
2019-05-28 18:44:40 +00:00
# $1 URL, $2 filename in DATADIR
# outputs final filename
download() {
local empty="no.file" file="${2:-${empty}}"
if [[ "$file" = *"/"* ]] || [[ "$file" = "."* ]]; then file="${empty}"; fi
2019-05-28 18:44:40 +00:00
while [ -f "${DATADIR:-.}/${file}" ] ; do file="$RAMDOM-${file}"; done
getJson "$1" >"${DATADIR:-.}/${file}" || return
printf '%s\n' "${DATADIR:-.}/${file}"
}
# $1 postfix, e.g. chatid
# $2 prefix, back- or startbot-
procname(){
printf '%s\n' "$2${ME}_$1"
}
# $1 sting to search for proramm incl. parameters
# retruns a list of PIDs of all current bot proceeses matching $1
proclist() {
# shellcheck disable=SC2009
ps -fu "${UID}" | grep -F "$1" | grep -v ' grep'| grep -F "${ME}" | sed 's/\s\+/\t/g' | cut -f 2
}
# $1 sting to search for proramm to kill
killallproc() {
local procid; procid="$(proclist "$1")"
if [ -n "${procid}" ] ; then
# shellcheck disable=SC2046
kill $(proclist "$1")
sleep 1
procid="$(proclist "$1")"
# shellcheck disable=SC2046
[ -n "${procid}" ] && kill $(proclist -9 "$1")
fi
}
2019-05-28 19:12:02 +00:00
declare -xr DELETE_URL=$URL'/deleteMessage'
delete_message() {
sendJson "${1}" '"message_id": '"${2}"'' "${DELETE_URL}"
}
get_file() {
[ -z "$1" ] && return
sendJson "" '"file_id": "'"${1}"'"' "${GETFILE_URL}"
printf '%s\n' "${URL}"/"$(JsonGetString <<< "${res}" '"result","file_path"')"
}
# curl is preffered, but may not availible on ebedded systems
TIMEOUT="${BASHBOT_TIMEOUT}"
[[ "$TIMEOUT" =~ ^[0-9]+$ ]] || TIMEOUT="20"
if [ -z "${BASHBOT_WGET}" ] && _exists curl ; then
2020-06-07 17:06:02 +00:00
[ -z "${BASHBOT_CURL}" ] && BASHBOT_CURL="curl"
# simple curl or wget call, output to stdout
getJson(){
# shellcheck disable=SC2086
2020-06-07 17:06:02 +00:00
"${BASHBOT_CURL}" -sL -k ${BASHBOT_CURL_ARGS} -m "${TIMEOUT}" "$1"
}
# usage: sendJson "chat" "JSON" "URL"
sendJson(){
2019-04-26 10:26:34 +00:00
local chat="";
[ -n "${1}" ] && chat='"chat_id":'"${1}"','
# shellcheck disable=SC2086
2020-06-07 17:06:02 +00:00
res="$("${BASHBOT_CURL}" -s -k ${BASHBOT_CURL_ARGS} -m "${TIMEOUT}"\
-d '{'"${chat} $(iconv -f utf-8 -t utf-8 -c <<<$2)"'}' -X POST "${3}" \
-H "Content-Type: application/json" | "${JSONSHFILE}" -s -b -n 2>/dev/null )"
sendJsonResult "${res}" "sendJson (curl)" "$@"
}
2019-05-20 15:26:21 +00:00
#$1 Chat, $2 what , $3 file, $4 URL, $5 caption
sendUpload() {
[ "$#" -lt 4 ] && return
if [ -n "$5" ]; then
# shellcheck disable=SC2086
2020-06-07 17:06:02 +00:00
res="$("${BASHBOT_CURL}" -s -k ${BASHBOT_CURL_ARGS} "$4" -F "chat_id=$1"\
2020-06-12 19:18:32 +00:00
-F "$2=@$3;${3##*/}" -F "caption=$5" | "${JSONSHFILE}" -s -b -n 2>/dev/null )"
2019-05-20 15:26:21 +00:00
else
# shellcheck disable=SC2086
2020-06-07 17:06:02 +00:00
res="$("${BASHBOT_CURL}" -s -k ${BASHBOT_CURL_ARGS} "$4" -F "chat_id=$1"\
2020-06-12 19:18:32 +00:00
-F "$2=@$3;${3##*/}" | "${JSONSHFILE}" -s -b -n 2>/dev/null )"
2019-05-20 15:26:21 +00:00
fi
sendJsonResult "${res}" "sendUpload (curl)" "$@"
2019-05-20 15:26:21 +00:00
}
else
# simple curl or wget call outputs result to stdout
getJson(){
# shellcheck disable=SC2086
2019-06-19 09:56:31 +00:00
wget --no-check-certificate -t 2 -T "${TIMEOUT}" ${BASHBOT_WGET_ARGS} -qO - "$1"
}
# usage: sendJson "chat" "JSON" "URL"
sendJson(){
local chat="";
[ -n "${1}" ] && chat='"chat_id":'"${1}"','
# shellcheck disable=SC2086
2020-05-14 11:04:57 +00:00
res="$(wget --no-check-certificate -t 2 -T "${TIMEOUT}" ${BASHBOT_WGET_ARGS} -qO - --post-data='{'"${chat} $(iconv -f utf-8 -t utf-8 -c <<<$2)"'}' \
--header='Content-Type:application/json' "${3}" | "${JSONSHFILE}" -s -b -n 2>/dev/null )"
sendJsonResult "${res}" "sendJson (wget)" "$@"
}
2019-05-20 15:26:21 +00:00
sendUpload() {
printf "%s: %s\n" "$(date)" "Sorry, wget does not support file upload\n" >>"${ERRORLOG}"
2019-05-20 15:26:21 +00:00
BOTSENT[OK]="false"
[ "${SOURCE}" != "yes" ] && [ -n "${BASHBOT_EVENT_SEND[*]}" ] && event_send "upload" "$@" &
2019-05-20 15:26:21 +00:00
}
fi
2020-06-08 19:47:36 +00:00
# retry sendJson
# $1 function $2 sleep $3 ... $n arguments
2020-06-08 19:47:36 +00:00
sendJsonRetry(){
local retry="${1}"; shift
[[ "${1}" =~ ^\ *[0-9.]+\ *$ ]] && sleep "${1}"; shift
2020-06-10 16:52:26 +00:00
printf "%s: RETRY %s %s %s\n" "$(date)" "${retry}" "${1}" "${2:0:60}"
2020-06-08 19:47:36 +00:00
case "${retry}" in
'sendJson'*)
sendJson "$@"
;;
'sendUpload'*)
sendUpload "$@"
;;
*)
2020-06-10 13:56:34 +00:00
printf "%s: Error: unknown function %s, cannot retry\n" "$(date)" "${retry}"
return
2020-06-08 19:47:36 +00:00
;;
esac
2020-06-10 16:52:26 +00:00
[ "${BOTSENT[OK]}" = "true" ] && printf "%s: Retry OK: %s %s %s\n" "$(date)" "${retry}" "${1}" "${2:0:60}"
2020-06-10 13:56:34 +00:00
} >>"${ERRORLOG}"
2020-06-08 19:47:36 +00:00
# process sendJson result
# stdout is written to ERROR.log
# $1 result $2 function $3 .. $n original arguments, $3 is Chat_id
sendJsonResult(){
2020-06-08 18:51:15 +00:00
BOTSENT=( )
BOTSENT[OK]="$(JsonGetLine '"ok"' <<< "${1}")"
if [ "${BOTSENT[OK]}" = "true" ]; then
2020-06-08 18:51:15 +00:00
BOTSENT[ID]="$(JsonGetValue '"result","message_id"' <<< "${1}")"
2020-06-10 16:26:51 +00:00
[ -n "${BASHBOT_EVENT_SEND[*]}" ] && event_send "send" "${@:3}"
return
2020-06-08 18:51:15 +00:00
# hot path everthing OK!
else
2020-06-08 18:51:15 +00:00
# oops something went wrong!
if [ "${res}" != "" ]; then
2020-06-09 20:54:09 +00:00
BOTSENT[ERROR]="$(JsonGetValue '"error_code"' <<< "${1}")"
2020-06-08 18:51:15 +00:00
BOTSENT[DESCRIPTION]="$(JsonGetString '"description"' <<< "${1}")"
BOTSENT[RETRY]="$(JsonGetValue '"parameters","retry_after"' <<< "${1}")"
else
BOTSENT[ERROR]="999"
BOTSENT[DESCRIPTION]="Send to telegram not possible, timeout/broken/no connection"
fi
2020-06-08 18:51:15 +00:00
# log error
2020-06-10 16:26:51 +00:00
printf "%s: RESULT=%s FUNC=%s CHAT[ID]=%s ERROR=%s DESC=%s ACTION=%s\n" "$(date)"\
2020-06-10 16:52:26 +00:00
"${BOTSENT[OK]}" "${2}" "${3}" "${BOTSENT[ERROR]}" "${BOTSENT[DESCRIPTION]}" "${4:0:60}"
2020-06-09 10:27:28 +00:00
# warm path, do not retry on error, also if we use wegt
2020-06-11 06:33:59 +00:00
[ -n "${BASHBOT_RETRY}${BASHBOT_WGET}" ] && return
2020-06-08 19:47:36 +00:00
# OK, we can retry sendJson, let's see what's failed
2020-06-08 19:47:36 +00:00
# throttled, telegram say we send to much messages
2020-06-08 18:51:15 +00:00
if [ -n "${BOTSENT[RETRY]}" ]; then
2020-06-11 06:33:59 +00:00
BASHBOT_RETRY="$(( BOTSENT[RETRY]++ ))"
printf "Retry %s in %s seconds ...\n" "${2}" "${BASHBOT_RETRY}"
sendJsonRetry "${2}" "${BASHBOT_RETRY}" "${@:3}"
unset BASHBOT_RETRY
return
2020-06-08 18:51:15 +00:00
fi
2020-06-08 19:47:36 +00:00
# timeout, failed connection or blocked
2020-06-08 18:51:15 +00:00
if [ "${BOTSENT[ERROR]}" == "999" ];then
# check if default curl and args are OK
if ! curl -sL -k -m 2 "${URL}" >/dev/null 2>&1 ; then
2020-06-10 16:26:51 +00:00
printf "%s: BASHBOT IP Adress is blocked!\n" "$(date)"
# user provided function to recover or notify block
if _exec_if_function bashbotBlockRecover; then
2020-06-11 06:33:59 +00:00
BASHBOT_RETRY="2"
2020-06-10 16:52:26 +00:00
printf "bashbotBlockRecover returned true, retry %s ...\n" "${2}"
2020-06-11 06:33:59 +00:00
sendJsonRetry "${2}" "${BASHBOT_RETRY}" "${@:3}"
unset BASHBOT_RETRY
fi
2020-06-08 18:51:15 +00:00
return
fi
# are not blocked, default curl and args are working
2020-06-09 10:27:28 +00:00
if [ -n "${BASHBOT_CURL_ARGS}" ] || [ "${BASHBOT_CURL}" != "curl" ]; then
2020-06-10 16:26:51 +00:00
printf "Problem with \"%s %s\"? retry %s with default config ...\n"\
"${BASHBOT_CURL}" "${BASHBOT_CURL_ARGS}" "${2}"
2020-06-11 06:33:59 +00:00
BASHBOT_RETRY="2"; BASHBOT_CURL="curl"; BASHBOT_CURL_ARGS=""
sendJsonRetry "${2}" "${BASHBOT_RETRY}" "${@:3}"
unset BASHBOT_RETRY
2020-06-08 18:51:15 +00:00
fi
fi
fi
} >>"${ERRORLOG}"
# escape / remove text charaters for json strings, eg. " -> \"
# $1 string
# output escaped string
JsonEscape(){
2020-06-15 12:16:14 +00:00
sed 's/\([-"`´,§$%&/(){}#@!?*.\t]\)/\\\1/g' <<< "$1"
}
# convert common telegram entities to JSON
# title caption description markup inlinekeyboard
title2Json(){
local title caption desc markup keyboard
[ -n "$1" ] && title=',"title":"'$(JsonEscape "$1")'"'
[ -n "$2" ] && caption=',"caption":"'$(JsonEscape "$2")'"'
[ -n "$3" ] && desc=',"description":"'$(JsonEscape "$3")'"'
[ -n "$4" ] && markup=',"parse_mode":"'"$4"'"'
[ -n "$5" ] && keyboard=',"reply_markup":"'$(JsonEscape "$5")'"'
printf '%s\n' "${title}${caption}${desc}${markup}${keyboard}"
}
# get bot name
getBotName() {
getJson "$ME_URL" | "${JSONSHFILE}" -s -b -n 2>/dev/null | JsonGetString '"result","username"'
2016-01-06 16:11:56 +00:00
}
2019-05-14 15:56:23 +00:00
# pure bash implementaion, done by KayM (@gnadelwartz)
# see https://stackoverflow.com/a/55666449/9381171
JsonDecode() {
local out="$1" remain="" U=""
local regexp='(.*)\\u[dD]([0-9a-fA-F]{3})\\u[dD]([0-9a-fA-F]{3})(.*)'
while [[ "${out}" =~ $regexp ]] ; do
2019-05-14 15:56:23 +00:00
U=$(( ( (0xd${BASH_REMATCH[2]} & 0x3ff) <<10 ) | ( 0xd${BASH_REMATCH[3]} & 0x3ff ) + 0x10000 ))
remain="$(printf '\\U%8.8x' "${U}")${BASH_REMATCH[4]}${remain}"
out="${BASH_REMATCH[1]}"
done
# this echo must stay for correct decoding!
echo -e "${out}${remain}"
2019-05-14 15:56:23 +00:00
}
JsonGetString() {
sed -n -e '0,/\['"$1"'\]/ s/\['"$1"'\][ \t]"\(.*\)"$/\1/p'
}
JsonGetLine() {
sed -n -e '0,/\['"$1"'\]/ s/\['"$1"'\][ \t]//p'
}
JsonGetValue() {
sed -n -e '0,/\['"$1"'\]/ s/\['"$1"'\][ \t]\([0-9.,]*\).*/\1/p'
2019-04-23 18:37:15 +00:00
}
################
# processing of updates starts here
process_updates() {
local max num debug="$1"
max="$(sed <<< "${UPDATE}" '/\["result",[0-9]*\]/!d' | tail -1 | sed 's/\["result",//g;s/\].*//g')"
2019-05-27 12:30:21 +00:00
Json2Array 'UPD' <<<"${UPDATE}"
for ((num=0; num<=max; num++)); do
process_client "$num" "${debug}"
done
}
2019-04-21 11:45:51 +00:00
process_client() {
local num="$1" debug="$2"
2020-06-11 09:32:52 +00:00
CMD=( ); iQUERY=( ); MESSAGE=()
iQUERY[ID]="${UPD["result",${num},"inline_query","id"]}"
CHAT[ID]="${UPD["result",${num},"message","chat","id"]}"
USER[ID]="${UPD["result",${num},"message","from","id"]}"
2020-06-11 09:32:52 +00:00
# log message on debug
[[ -n "${debug}" ]] && printf "\n%s: New Message ==========\n%s\n" "$(date)" "$UPDATE" >>"${LOGDIR}/MESSAGE.log"
# check for uers / groups to ignore
2020-06-15 08:42:36 +00:00
jssh_updateArray_async "BASHBOTBLOCKED" "${BLOCKEDFILE}"
[ -n "${USER[ID]}" ] && [[ -n "${BASHBOTBLOCKED[${USER[ID]}]}" || -n "${BASHBOTBLOCKED[${CHAT[ID]}]}" ]] && return
# process per message type
if [ -z "${iQUERY[ID]}" ]; then
process_message "${num}" "${debug}"
2020-06-12 19:18:32 +00:00
printf "%s: update received FROM=%s CHAT=%s CMD=%s\n" "$(date)" "${USER[USERNAME]:0:20} (${USER[ID]})"\
"${CHAT[USERNAME]:0:20}${CHAT[TITLE]:0:30} (${CHAT[ID]})"\
"${MESSAGE:0:30}${CAPTION:0:30}${URLS[*]:0:30}" >>"${UPDATELOG}"
2019-05-02 10:33:10 +00:00
else
process_inline "${num}" "${debug}"
2020-06-12 19:18:32 +00:00
printf "%s: iQuery received FROM=%s iQUERY=%s\n" "$(date)"\
"${iQUERY[USERNAME]:0:20} (${iQUERY[USER_ID]})" "${iQUERY[0]}" >>"${UPDATELOG}"
2019-05-02 10:33:10 +00:00
fi
2019-05-25 17:31:20 +00:00
#####
# process inline and message events
# first classic commnad dispatcher
# shellcheck source=./commands.sh
2019-05-25 17:31:20 +00:00
source "${COMMANDS}" "${debug}" &
# then all registered addons
if [ -z "${iQUERY[ID]}" ]; then
2019-05-25 17:31:20 +00:00
event_message "${debug}"
2019-05-26 15:40:51 +00:00
else
event_inline "${debug}"
2019-05-25 17:31:20 +00:00
fi
# last count users
jssh_countKeyDB_async "${CHAT[ID]}" "${COUNTFILE}"
2019-05-25 17:31:20 +00:00
}
2019-06-05 08:45:04 +00:00
declare -Ax BASBOT_EVENT_INLINE BASBOT_EVENT_MESSAGE BASHBOT_EVENT_CMD BASBOT_EVENT_REPLY BASBOT_EVENT_FORWARD BASHBOT_EVENT_SEND
declare -Ax BASBOT_EVENT_CONTACT BASBOT_EVENT_LOCATION BASBOT_EVENT_FILE BASHBOT_EVENT_TEXT BASHBOT_EVENT_TIMER BASHBOT_BLOCKED
2019-05-29 11:49:05 +00:00
2019-05-29 15:33:31 +00:00
start_timer(){
# send alarm every ~60 s
while :; do
sleep 59.5
kill -ALRM $$
done;
}
2019-06-04 16:04:52 +00:00
EVENT_SEND="0"
event_send() {
# max recursion level 5 to avoid fork bombs
(( EVENT_SEND++ )); [ "$EVENT_SEND" -gt "5" ] && return
# shellcheck disable=SC2153
for key in "${!BASHBOT_EVENT_SEND[@]}"
do
_exec_if_function "${BASHBOT_EVENT_SEND[${key}]}" "$@"
done
}
2019-05-29 11:49:05 +00:00
EVENT_TIMER="0"
event_timer() {
2019-06-03 18:34:43 +00:00
local key timer debug="$1"
2019-06-01 10:41:12 +00:00
(( EVENT_TIMER++ ))
2019-05-29 11:49:05 +00:00
# shellcheck disable=SC2153
2019-06-03 18:34:43 +00:00
for key in "${!BASHBOT_EVENT_TIMER[@]}"
2019-05-29 11:49:05 +00:00
do
2019-06-03 18:34:43 +00:00
timer="${key##*,}"
2019-06-01 10:41:12 +00:00
[[ ! "$timer" =~ ^-*[1-9][0-9]*$ ]] && continue
2019-05-29 11:49:05 +00:00
if [ "$(( EVENT_TIMER % timer ))" = "0" ]; then
2019-06-03 18:34:43 +00:00
_exec_if_function "${BASHBOT_EVENT_TIMER[${key}]}" "timer" "${key}" "${debug}"
2019-05-29 11:49:05 +00:00
[ "$(( EVENT_TIMER % timer ))" -lt "0" ] && \
2019-06-03 18:34:43 +00:00
unset BASHBOT_EVENT_TIMER["${key}"]
2019-05-29 11:49:05 +00:00
fi
done
}
2019-05-27 10:27:09 +00:00
2019-05-25 17:31:20 +00:00
event_inline() {
2019-06-03 18:34:43 +00:00
local key debug="$1"
2019-05-25 17:31:20 +00:00
# shellcheck disable=SC2153
2019-06-03 18:34:43 +00:00
for key in "${!BASHBOT_EVENT_INLINE[@]}"
2019-05-25 17:31:20 +00:00
do
2019-06-03 18:34:43 +00:00
_exec_if_function "${BASHBOT_EVENT_INLINE[${key}]}" "inline" "${key}" "${debug}"
2019-05-25 17:31:20 +00:00
done
}
event_message() {
2019-06-03 18:34:43 +00:00
local key debug="$1"
2019-05-25 17:31:20 +00:00
# ${MESSAEG[*]} event_message
# shellcheck disable=SC2153
2019-06-03 18:34:43 +00:00
for key in "${!BASHBOT_EVENT_MESSAGE[@]}"
2019-05-25 17:31:20 +00:00
do
2019-06-03 18:34:43 +00:00
_exec_if_function "${BASHBOT_EVENT_MESSAGE[${key}]}" "messsage" "${key}" "${debug}"
2019-05-25 17:31:20 +00:00
done
2019-05-27 10:27:09 +00:00
# ${TEXT[*]} event_text
if [ -n "${MESSAGE[0]}" ]; then
2019-05-27 10:27:09 +00:00
# shellcheck disable=SC2153
2019-06-03 18:34:43 +00:00
for key in "${!BASHBOT_EVENT_TEXT[@]}"
2019-05-27 10:27:09 +00:00
do
2019-06-03 18:34:43 +00:00
_exec_if_function "${BASHBOT_EVENT_TEXT[${key}]}" "text" "${key}" "${debug}"
2019-05-27 10:27:09 +00:00
done
# ${CMD[*]} event_cmd
if [ -n "${CMD[0]}" ]; then
2019-05-27 10:27:09 +00:00
# shellcheck disable=SC2153
2019-06-03 18:34:43 +00:00
for key in "${!BASHBOT_EVENT_CMD[@]}"
2019-05-27 10:27:09 +00:00
do
2019-06-03 18:34:43 +00:00
_exec_if_function "${BASHBOT_EVENT_CMD[${key}]}" "command" "${key}" "${debug}"
2019-05-27 10:27:09 +00:00
done
fi
fi
2019-05-25 17:31:20 +00:00
# ${REPLYTO[*]} event_replyto
if [ -n "${REPLYTO[UID]}" ]; then
2019-05-25 17:31:20 +00:00
# shellcheck disable=SC2153
2019-06-03 18:34:43 +00:00
for key in "${!BASHBOT_EVENT_REPLYTO[@]}"
2019-05-25 17:31:20 +00:00
do
2019-06-03 18:34:43 +00:00
_exec_if_function "${BASHBOT_EVENT_REPLYTO[${key}]}" "replyto" "${key}" "${debug}"
2019-05-25 17:31:20 +00:00
done
fi
# ${FORWARD[*]} event_forward
if [ -n "${FORWARD[UID]}" ]; then
2019-05-25 17:31:20 +00:00
# shellcheck disable=SC2153
2019-06-03 18:34:43 +00:00
for key in "${!BASHBOT_EVENT_FORWARD[@]}"
2019-05-25 17:31:20 +00:00
do
2019-06-03 18:34:43 +00:00
_exec_if_function && "${BASHBOT_EVENT_FORWARD[${key}]}" "forward" "${key}" "${debug}"
2019-05-25 17:31:20 +00:00
done
fi
# ${CONTACT[*]} event_contact
if [ -n "${CONTACT[FIRST_NAME]}" ]; then
2019-05-25 17:31:20 +00:00
# shellcheck disable=SC2153
2019-06-03 18:34:43 +00:00
for key in "${!BASHBOT_EVENT_CONTACT[@]}"
2019-05-25 17:31:20 +00:00
do
2019-06-03 18:34:43 +00:00
_exec_if_function "${BASHBOT_EVENT_CONTACT[${key}]}" "contact" "${key}" "${debug}"
2019-05-25 17:31:20 +00:00
done
fi
# ${VENUE[*]} event_location
# ${LOCALTION[*]} event_location
if [ -n "${LOCATION[LONGITUDE]}" ] || [ -n "${VENUE[TITLE]}" ]; then
2019-05-25 17:31:20 +00:00
# shellcheck disable=SC2153
2019-06-03 18:34:43 +00:00
for key in "${!BASHBOT_EVENT_LOCATION[@]}"
2019-05-25 17:31:20 +00:00
do
2019-06-03 18:34:43 +00:00
_exec_if_function "${BASHBOT_EVENT_LOCATION[${key}]}" "location" "${key}" "${debug}"
2019-05-25 17:31:20 +00:00
done
fi
# ${URLS[*]} event_file
# NOTE: compare again #URLS -1 blanks!
if [[ "${URLS[*]}" != " " ]]; then
2019-05-25 17:31:20 +00:00
# shellcheck disable=SC2153
2019-06-03 18:34:43 +00:00
for key in "${!BASHBOT_EVENT_FILE[@]}"
2019-05-25 17:31:20 +00:00
do
2019-06-03 18:34:43 +00:00
_exec_if_function "${BASHBOT_EVENT_FILE[${key}]}" "file" "${key}" "${debug}"
2019-05-25 17:31:20 +00:00
done
fi
2019-04-21 11:45:51 +00:00
}
process_inline() {
local num="${1}"
2019-05-22 16:43:20 +00:00
iQUERY[0]="$(JsonDecode "${UPD["result",${num},"inline_query","query"]}")"
iQUERY[USER_ID]="${UPD["result",${num},"inline_query","from","id"]}"
iQUERY[FIRST_NAME]="$(JsonDecode "${UPD["result",${num},"inline_query","from","first_name"]}")"
iQUERY[LAST_NAME]="$(JsonDecode "${UPD["result",${num},"inline_query","from","last_name"]}")"
iQUERY[USERNAME]="$(JsonDecode "${UPD["result",${num},"inline_query","from","username"]}")"
}
2019-04-21 11:45:51 +00:00
process_message() {
local num="$1"
# Message
2020-06-12 19:18:32 +00:00
MESSAGE[0]="$(JsonDecode "${UPD["result",${num},"message","text"]}" | sed 's#\\/#/#g')"
2019-05-22 16:43:20 +00:00
MESSAGE[ID]="${UPD["result",${num},"message","message_id"]}"
# Chat ID is now parsed when update isreceived
#CHAT[ID]="${UPD["result",${num},"message","chat","id"]}"
2019-05-22 16:43:20 +00:00
CHAT[LAST_NAME]="$(JsonDecode "${UPD["result",${num},"message","chat","last_name"]}")"
CHAT[FIRST_NAME]="$(JsonDecode "${UPD["result",${num},"message","chat","first_name"]}")"
CHAT[USERNAME]="$(JsonDecode "${UPD["result",${num},"message","chat","username"]}")"
2020-06-13 09:05:28 +00:00
# set real name as username if empty
2020-06-14 07:10:43 +00:00
[ -z "${CHAT[USERNAME]}" ] && CHAT[USERNAME]="${CHAT[FIRST_NAME]} ${CHAT[LAST_NAME]}"
2019-05-22 16:43:20 +00:00
CHAT[TITLE]="$(JsonDecode "${UPD["result",${num},"message","chat","title"]}")"
CHAT[TYPE]="$(JsonDecode "${UPD["result",${num},"message","chat","type"]}")"
CHAT[ALL_ADMIN]="${UPD["result",${num},"message","chat","all_members_are_administrators"]}"
# user ID is now parsed when update isreceived
#USER[ID]="${UPD["result",${num},"message","from","id"]}"
2019-05-22 16:43:20 +00:00
USER[FIRST_NAME]="$(JsonDecode "${UPD["result",${num},"message","from","first_name"]}")"
USER[LAST_NAME]="$(JsonDecode "${UPD["result",${num},"message","from","last_name"]}")"
USER[USERNAME]="$(JsonDecode "${UPD["result",${num},"message","from","username"]}")"
# set real name as username if empty
[ -z "${USER[USERNAME]}" ] && USER[USERNAME]="${USER[FIRST_NAME]} ${USER[LAST_NAME]}"
2016-01-17 16:46:24 +00:00
# in reply to message from
REPLYTO=( )
if grep -qs -e '\["result",'"${num}"',"message","reply_to_message"' <<<"${UPDATE}"; then
REPLYTO[UID]="${UPD["result",${num},"message","reply_to_message","from","id"]}"
2019-05-22 16:43:20 +00:00
REPLYTO[0]="$(JsonDecode "${UPD["result",${num},"message","reply_to_message","text"]}")"
REPLYTO[ID]="${UPD["result",${num},"message","reply_to_message","message_id"]}"
REPLYTO[FIRST_NAME]="$(JsonDecode "${UPD["result",${num},"message","reply_to_message","from","first_name"]}")"
REPLYTO[LAST_NAME]="$(JsonDecode "${UPD["result",${num},"message","reply_to_message","from","last_name"]}")"
REPLYTO[USERNAME]="$(JsonDecode "${UPD["result",${num},"message","reply_to_message","from","username"]}")"
fi
# forwarded message from
FORWARD=( )
if grep -qs -e '\["result",'"${num}"',"message","forward_from"' <<<"${UPDATE}"; then
FORWARD[UID]="${UPD["result",${num},"message","forward_from","id"]}"
FORWARD[ID]="${MESSAGE[ID]}" # same as message ID
2019-05-22 16:43:20 +00:00
FORWARD[FIRST_NAME]="$(JsonDecode "${UPD["result",${num},"message","forward_from","first_name"]}")"
FORWARD[LAST_NAME]="$(JsonDecode "${UPD["result",${num},"message","forward_from","last_name"]}")"
FORWARD[USERNAME]="$(JsonDecode "${UPD["result",${num},"message","forward_from","username"]}")"
fi
2020-06-14 07:10:43 +00:00
# get file URL from telegram
URLS=()
2020-06-14 07:10:43 +00:00
if grep -qs -e '\["result",'"${num}"',"message",".*,"file_id"\]' <<<"${UPDATE}"; then
URLS[AUDIO]="$(get_file "${UPD["result",${num},"message","audio","file_id"]}")"
URLS[DOCUMENT]="$(get_file "${UPD["result",${num},"message","document","file_id"]}")"
URLS[PHOTO]="$(get_file "${UPD["result",${num},"message","photo",0,"file_id"]}")"
URLS[STICKER]="$(get_file "${UPD["result",${num},"message","sticker","file_id"]}")"
URLS[VIDEO]="$(get_file "${UPD["result",${num},"message","video","file_id"]}")"
URLS[VOICE]="$(get_file "${UPD["result",${num},"message","voice","file_id"]}")"
fi
2016-01-17 16:46:24 +00:00
# Contact
CONTACT=( )
if grep -qs -e '\["result",'"${num}"',"message","contact"' <<<"${UPDATE}"; then
CONTACT[FIRST_NAME]="$(JsonDecode "${UPD["result",${num},"message","contact","first_name"]}")"
2019-05-22 16:43:20 +00:00
CONTACT[USER_ID]="$(JsonDecode "${UPD["result",${num},"message","contact","user_id"]}")"
CONTACT[LAST_NAME]="$(JsonDecode "${UPD["result",${num},"message","contact","last_name"]}")"
CONTACT[NUMBER]="${UPD["result",${num},"message","contact","phone_number"]}"
CONTACT[VCARD]="$(JsonGetString '"result",'"${num}"',"message","contact","vcard"' <<<"${UPDATE}")"
2019-05-22 08:01:39 +00:00
fi
2019-04-23 17:00:17 +00:00
# vunue
VENUE=( )
if grep -qs -e '\["result",'"${num}"',"message","contact"' <<<"${UPDATE}"; then
VENUE[TITLE]="$(JsonDecode "${UPD["result",${num},"message","venue","title"]}")"
2019-05-22 16:43:20 +00:00
VENUE[ADDRESS]="$(JsonDecode "${UPD["result",${num},"message","venue","address"]}")"
VENUE[LONGITUDE]="${UPD["result",${num},"message","venue","location","longitude"]}"
VENUE[LATITUDE]="${UPD["result",${num},"message","venue","location","latitude"]}"
VENUE[FOURSQUARE]="${UPD["result",${num},"message","venue","foursquare_id"]}"
2019-05-22 08:01:39 +00:00
fi
2016-01-17 16:46:24 +00:00
# Caption
2019-05-22 16:43:20 +00:00
CAPTION="$(JsonDecode "${UPD["result",${num},"message","caption"]}")"
2016-01-17 16:46:24 +00:00
# Location
2019-05-22 16:43:20 +00:00
LOCATION[LONGITUDE]="${UPD["result",${num},"message","location","longitude"]}"
LOCATION[LATITUDE]="${UPD["result",${num},"message","location","latitude"]}"
2019-05-25 15:02:25 +00:00
2020-05-14 11:04:57 +00:00
# service messages
SERVICE=( ); NEWMEMBER=( )
if grep -qs -e '\["result",'"${num}"',"message","new_chat_member' <<<"${UPDATE}"; then
SERVICE[NEWMEMBER]="${UPD["result",${num},"message","new_chat_member","id"]}"
2020-05-14 11:04:57 +00:00
NEWMEMBER[ID]="${SERVICE[NEWMEMBER]}"
2020-06-13 09:05:28 +00:00
NEWMEMBER[FIRST_NAME]="${UPD["result",${num},"message","new_chat_member","first_name"]}"
NEWMEMBER[LAST_NAME]="${UPD["result",${num},"message","new_chat_member","last_name"]}"
2020-05-14 11:04:57 +00:00
NEWMEMBER[USERNAME]="${UPD["result",${num},"message","new_chat_member","username"]}"
NEWMEMBER[ISBOT]="${UPD["result",${num},"message","new_chat_member","is_bot"]}"
2020-06-13 09:05:28 +00:00
MESSAGE[0]="/new_chat_member ${NEWMEMBER[USERNAME]:=${NEWMEMBER[FIRST_NAME]} ${NEWMEMBER[LAST_NAME]}}"
2020-05-14 11:04:57 +00:00
fi
if grep -qs -e '\["result",'"${num}"',"message","left_chat_member' <<<"${UPDATE}"; then
SERVICE[LEFTMEMBER]="${UPD["result",${num},"message","left_chat_member","id"]}"
LEFTMEMBER[ID]="${SERVICE[LEFTMEBER]}"
LEFTMEMBER[FIRST_NAME]="${UPD["result",${num},"message","left_chat_member","first_name"]}"
LEFTMEMBER[LAST_NAME]="${UPD["result",${num},"message","left_chat_member","last_name"]}"
2020-06-13 17:57:24 +00:00
LEFTMEBER[USERNAME]="${UPD["result",${num},"message","left_chat_member","username"]}"
LEFTMEMBER[ISBOT]="${UPD["result",${num},"message","left_chat_member","is_bot"]}"
2020-06-13 17:57:24 +00:00
MESSAGE[0]="/left_chat_member ${LEFTMEMBER[USERNAME]:=${LEFTMEMBER[FIRST_NAME]} ${LEFTMEMBER[LAST_NAME]}}"
fi
2020-05-14 11:04:57 +00:00
SERVICE[NEWTILE]="${UPD["result",${num},"message","new_chat_title"]}"
SERVICE[NEWPHOTO]="${UPD["result",${num},"message","new_chat_photo"]}"
SERVICE[PINNED]="${UPD["result",${num},"message","pinned_message"]}"
# set SSERVICE to yes if a service message was received
2020-05-14 13:02:17 +00:00
[[ "${SERVICE[*]}" =~ ^[[:blank:]]+$ ]] || SERVICE[0]="yes"
2020-05-14 11:04:57 +00:00
2019-05-27 10:27:09 +00:00
# split message in command and args
2019-06-01 10:41:12 +00:00
CMD=( )
2020-05-14 11:04:57 +00:00
if [[ "${MESSAGE[0]}" == "/"* ]]; then
2019-05-27 10:27:09 +00:00
set -f; unset IFS
# shellcheck disable=SC2206
CMD=( ${MESSAGE[0]} )
2019-05-30 19:08:39 +00:00
CMD[0]="${CMD[0]%%@*}"
2019-05-27 10:27:09 +00:00
set +f
fi
}
#########################
2019-04-22 19:05:52 +00:00
# main get updates loop, should never terminate
2020-06-15 08:42:36 +00:00
declare -A BASHBOTBLOCKED
2019-04-22 19:05:52 +00:00
start_bot() {
2020-06-15 06:39:52 +00:00
local ADMIN DEBUG OFFSET=0
2020-06-09 12:46:45 +00:00
# adaptive sleep deafults
local nextsleep="100" :
2020-06-09 14:51:50 +00:00
local stepsleep="${BASHBOT_SLEEP_STEP:-100}"
local maxsleep="${BASHBOT_SLEEP:-5000}"
2020-06-14 07:10:43 +00:00
# startup message
DEBUG="$(date): Start BASHBOT updates in Mode \"${1:-normal}\" =========="
2020-06-14 07:10:43 +00:00
printf "%s\n" "${DEBUG}" >>"${UPDATELOG}"
2020-06-09 12:46:45 +00:00
# redirect to Debug.log
2020-06-14 11:57:36 +00:00
[[ "${1}" == *"debug" ]] && exec &>>"${DEBUGLOG}"
printf "%s\n" "${DEBUG}"; DEBUG="${1}"
2020-06-14 07:10:43 +00:00
[[ "${DEBUG}" == "xdebug"* ]] && set -x
#cleaup old pipes and empty logfiles
2019-05-28 18:44:40 +00:00
find "${DATADIR}" -type p -delete
find "${DATADIR}" -size 0 -name "*.log" -delete
2019-05-25 17:31:20 +00:00
# load addons on startup
2019-12-07 12:25:50 +00:00
for addons in "${ADDONDIR:-.}"/*.sh ; do
2019-05-25 17:31:20 +00:00
# shellcheck source=./modules/aliases.sh
[ -r "${addons}" ] && source "${addons}" "startbot" "${DEBUG}"
done
2020-05-14 11:04:57 +00:00
# shellcheck source=./commands.sh
source "${COMMANDS}" "startbot"
2019-05-29 15:33:31 +00:00
# start timer events
2020-06-09 14:51:50 +00:00
if [ -n "${BASHBOT_START_TIMER}" ] ; then
2019-05-29 15:33:31 +00:00
# shellcheck disable=SC2064
trap "event_timer $DEBUG" ALRM
start_timer &
# shellcheck disable=SC2064
trap "kill -9 $!; exit" EXIT INT HUP TERM QUIT
fi
# cleanup countfile on startup
2020-06-10 07:48:37 +00:00
jssh_deleteKeyDB "CLEAN_COUNTER_DATABASE_ON_STARTUP" "${COUNTFILE}"
2020-06-11 10:37:36 +00:00
[ -f "${COUNTFILE}.jssh.flock" ] && rm -f "${COUNTFILE}.jssh.flock"
jssh_deleteKeyDB "CLEAN_BOT_DATABASE_ON_STARTUP" "${BOTDATABASE}"
[ -f "${BOTDATABASE}.jssh.flock" ] && rm -f "${BOTDATABASE}.jssh.flock"
2020-06-15 08:42:36 +00:00
jssh_readDB_async "BASHBOTBLOCKED" "${BLOCKEDFILE}"
2020-06-15 06:39:52 +00:00
# inform botadmin about start
ADMIN="$(getConfigKey "botadmin")"
[ "${ADMIN}" -gt 4 ] && send_normal_message "${ADMIN}" "Bot $(getConfigKey "botname") started ..." &
##########
# bot is ready, start processing updates ...
while true; do
2020-06-09 12:46:45 +00:00
# adaptive sleep in ms rounded to next 0.1 s
2020-06-10 13:56:34 +00:00
sleep "$(_round_float "${nextsleep}e-3" "1")"
2020-06-09 12:46:45 +00:00
# get next update
UPDATE="$(getJson "$UPD_URL$OFFSET" 2>/dev/null | "${JSONSHFILE}" -s -b -n 2>/dev/null | iconv -f utf-8 -t utf-8 -c)"
2020-06-09 12:46:45 +00:00
# did we ge an responsn0r
if [ -n "${UPDATE}" ]; then
# we got something, do processing
2020-06-12 19:18:32 +00:00
[ "${OFFSET}" = "-999" ] && [ "${nextsleep}" -gt "$((maxsleep*2))" ] &&\
printf "%s: Recovered from timeout/broken/no connection, continue with telegram updates\n"\
"$(date)" >>"${ERRORLOG}"
2020-06-09 12:46:45 +00:00
# escape bash $ expansion bug
2020-06-12 08:00:52 +00:00
((nextsleep+= stepsleep , nextsleep= nextsleep>maxsleep ?maxsleep:nextsleep))
2020-06-09 12:46:45 +00:00
UPDATE="${UPDATE//$/\\$}"
# Offset
OFFSET="$(grep <<< "${UPDATE}" '\["result",[0-9]*,"update_id"\]' | tail -1 | cut -f 2)"
((OFFSET++))
if [ "$OFFSET" != "1" ]; then
nextsleep="100"
process_updates "${DEBUG}"
fi
else
# ups, something bad happend, wait maxsleep*10
(( nextsleep=nextsleep*2 , nextsleep= nextsleep>maxsleep*10 ?maxsleep*10:nextsleep ))
[ "${OFFSET}" = "-999" ] &&\
printf "%s: Repeated timeout/broken/no connection on telegram update, sleep %ds\n"\
"$(date)" "$(_round_float "${nextsleep}e-3")" >>"${ERRORLOG}"
OFFSET="-999"
2019-04-22 19:05:52 +00:00
fi
done
}
# initialize bot environment, user and permissions
bot_init() {
2020-06-08 14:04:45 +00:00
[ -n "${BASHBOT_HOME}" ] && cd "${BASHBOT_HOME}" || exit 1
2019-05-25 17:31:20 +00:00
local DEBUG="$1"
# upgrade from old version
2019-04-23 16:11:24 +00:00
local OLDTMP="${BASHBOT_VAR:-.}/tmp-bot-bash"
2019-05-28 18:44:40 +00:00
[ -d "${OLDTMP}" ] && { mv -n "${OLDTMP}/"* "${DATADIR}"; rmdir "${OLDTMP}"; }
2020-05-14 17:47:37 +00:00
# no more existing modules
[ -f "modules/inline.sh" ] && rm -f "modules/inline.sh"
2019-05-25 17:31:20 +00:00
# load addons on startup
2019-12-07 12:25:50 +00:00
for addons in "${ADDONDIR:-.}"/*.sh ; do
2019-05-25 17:31:20 +00:00
# shellcheck source=./modules/aliases.sh
[ -r "${addons}" ] && source "${addons}" "init" "${DEBUG}"
done
#setup bashbot
[[ "${UID}" -eq "0" ]] && RUNUSER="nobody"
2019-04-22 19:05:52 +00:00
echo -n "Enter User to run basbot [$RUNUSER]: "
read -r TOUSER
[ -z "$TOUSER" ] && TOUSER="$RUNUSER"
if ! id "$TOUSER" &>/dev/null; then
2019-04-22 19:05:52 +00:00
echo -e "${RED}User \"$TOUSER\" not found!${NC}"
exit 3
else
# shellcheck disable=SC2009
oldbot="$(ps -fu "$TOUSER" | grep startbot | grep -v -e 'grep' -e '\-startbot' )"
[ -n "${oldbot}" ] && \
echo -e "${ORANGE}Warning: At least one not upgraded TMUX bot is running! You must stop it with kill command:${NC}\\n${oldbot}"
2019-04-22 19:05:52 +00:00
echo "Adjusting user \"${TOUSER}\" files and permissions ..."
[ -w "bashbot.rc" ] && sed -i '/^[# ]*runas=/ s/runas=.*$/runas="'$TOUSER'"/' "bashbot.rc"
2019-04-22 19:05:52 +00:00
chown -R "$TOUSER" . ./*
chmod 711 .
chmod -R o-w ./*
chmod -R u+w "${COUNTFILE}"* "${BLOCKEDFILE}"* "${DATADIR}" "${BOTADMIN}" "${LOGDIR}/"*.log 2>/dev/null
chmod -R o-r,o-w "${COUNTFILE}"* "${BLOCKEDFILE}"* "${DATADIR}" "${TOKENFILE}" "${BOTADMIN}" "${BOTACL}" 2>/dev/null
2019-06-03 14:05:02 +00:00
# jsshDB must writeable by owner
find . -name '*.jssh' -exec chmod u+w \{\} +
2019-04-22 19:05:52 +00:00
fi
2020-06-10 06:20:48 +00:00
# show result
ls -l
2019-04-22 19:05:52 +00:00
}
2019-05-26 15:03:58 +00:00
if ! _is_function send_message ; then
echo -e "${RED}ERROR: send_message is not availible, did you deactivate ${MODULEDIR}/sendMessage.sh?${NC}"
exit 1
fi
JSONSHFILE="${BASHBOT_JSONSH:-${SCRIPTDIR}/JSON.sh/JSON.sh}"
[[ "${JSONSHFILE}" != *"/JSON.sh" ]] && echo -e "${RED}ERROR: \"${JSONSHFILE}\" ends not with \"JSONS.sh\".${NC}" && exit 3
if [ ! -f "${JSONSHFILE}" ]; then
echo "Seems to be first run, Downloading ${JSONSHFILE}..."
2020-06-10 06:20:48 +00:00
[ "${SCRIPTDIR}/JSON.sh/JSON.sh" = "${JSONSHFILE}" ] &&\
mkdir "${SCRIPTDIR}/JSON.sh" 2>/dev/null && chmod +w "${SCRIPTDIR}/JSON.sh"
getJson "https://cdn.jsdelivr.net/gh/dominictarr/JSON.sh/JSON.sh" >"${JSONSHFILE}"
chmod +x "${JSONSHFILE}"
fi
2016-03-20 21:34:55 +00:00
# source the script with source as param to use functions in other scripts
2019-04-20 14:26:16 +00:00
# do not execute if read from other scripts
if [ "${SOURCE}" != "yes" ]; then
2019-04-22 19:05:52 +00:00
##############
# internal options only for use from bashbot and developers
2019-04-20 14:26:16 +00:00
case "$1" in
2020-06-12 19:18:32 +00:00
# all these commands need the botname and a working connection
"botname"|"outproc"|"start"*|"stop"*|"kill"*|"resume"*|"suspend"*|"status")
2020-06-12 19:18:32 +00:00
ME="$(getBotName)"
if [ -n "${ME}" ]; then
# ok we have a connection an got botname, save it
[ -n "${CLEAR}" ] && echo -e "${GREY}Bottoken is valid ...${NC}"
2020-06-12 19:18:32 +00:00
jssh_updateKeyDB "botname" "${ME}" "${BOTDATABASE}"
rm -f "${BOTDATABASE}.jssh.flock"
else
echo -e "${GREY}Info: Can't get Botname from Telegram, try cached one ...${NC}"
ME="$(getConfigKey "botname")"
if [ -z "$ME" ]; then
echo -e "${RED}ERROR: No cached botname, can't continue! ...${NC}"
exit 1
fi
fi
[ -n "${CLEAR}" ] && printf "Bot Name: %s\n" "${ME}"
2020-06-12 19:18:32 +00:00
SESSION="${ME:-_bot}-startbot"
BOTPID="$(proclist "${SESSION}")"
[ "$1" = "botname" ] && exit
;;&
2020-06-12 19:18:32 +00:00
# used to send output of backgrond and interactive to chats
"outproc") # $2 chat_id $3 identifier of job, internal use only!
[ -z "$3" ] && echo "No job identifier" && exit 3
[ -z "$2" ] && echo "No chat to send to" && exit 3
2020-06-12 19:18:32 +00:00
# read until terminated
2019-05-19 15:31:55 +00:00
while read -r line ;do
[ -n "$line" ] && send_message "$2" "$line"
2019-05-18 18:25:18 +00:00
done
2020-06-12 19:18:32 +00:00
# cleanup datadir, keep logfile if not empty
2019-05-28 18:44:40 +00:00
rm -f -r "${DATADIR:-.}/$3"
[ -s "${DATADIR:-.}/$3.log" ] || rm -f "${DATADIR:-.}/$3.log"
2019-04-22 19:05:52 +00:00
exit
;;
2020-06-12 19:18:32 +00:00
# finally starts the read update loop, internal use only1
2019-04-22 19:05:52 +00:00
"startbot" )
2019-04-22 19:50:38 +00:00
start_bot "$2"
2019-04-22 19:05:52 +00:00
exit
;;
2020-06-12 19:18:32 +00:00
# run after every update to update files and adjust permissions
"init")
2019-05-25 17:31:20 +00:00
bot_init "$2"
2019-04-22 19:05:52 +00:00
exit
;;
2020-06-12 19:18:32 +00:00
# print usage sats
"count") echo -e "${RED}Command ${GREY}count${RED} is deprecated, use ${GREY}stats{$RED}instead.${NC}";&
"stats")
declare -A STATS
jssh_readDB_async "STATS" "${COUNTFILE}"
for MSG in ${!STATS[*]}
do
[[ ! "${MSG}" =~ ^[0-9-]*$ ]] && continue
(( USERS++ ))
done
for MSG in ${STATS[*]}
do
(( MESSAGES+=MSG ))
done
echo "A total of ${MESSAGES} messages from ${USERS} users are processed."
exit
;;
2020-06-12 19:18:32 +00:00
# sedn message to all users
'broadcast')
declare -A SENDALL
shift
jssh_readDB_async "SENDALL" "${COUNTFILE}"
echo -e "Sending broadcast message to all users \c"
for MSG in ${!SENDALL[*]}
do
[[ ! "${MSG}" =~ ^[0-9-]*$ ]] && continue
(( USERS++ ))
if [ -n "$*" ]; then
send_message "${MSG}" "$*"
echo -e ".\c"
sleep 0.1
fi
done
echo -e "\nMessage \"$*\" sent to ${USERS} users."
exit
;;
2020-06-12 19:18:32 +00:00
# does what is says
"status")
if [ -n "${BOTPID}" ]; then
echo -e "${GREEN}Bot is running with UID ${RUNUSER}.${NC}"
exit
else
echo -e "${ORANGE}No Bot running with UID ${RUNUSER}.${NC}"
exit 5
fi
;;
2020-06-12 19:18:32 +00:00
# start bot as background jod and check if bot is running
2016-04-17 12:13:28 +00:00
"start")
# shellcheck disable=SC2086
[ -n "${BOTPID}" ] && kill ${BOTPID}
nohup "$SCRIPT" "startbot" "$2" "${SESSION}" &>/dev/null &
2020-06-12 19:18:32 +00:00
printf "Session Name: %s\n" "${SESSION}"
sleep 1
if [ -n "$(proclist "${SESSION}")" ]; then
echo -e "${GREEN}Bot started successfully.${NC}"
else
echo -e "${RED}An error occurred while starting the bot.${NC}"
exit 5
fi
2016-04-17 12:13:28 +00:00
;;
2020-06-12 19:18:32 +00:00
# does what it says
"kill") echo -e "${RED}Command ${GREY}kill${RED} is deprecated, use ${GREY}stop{$RED}instead.${NC}";&
2020-06-12 19:18:32 +00:00
"stop")
if [ -n "${BOTPID}" ]; then
# shellcheck disable=SC2086
if kill ${BOTPID}; then
# inform botadmin about stop
ADMIN="$(getConfigKey "botadmin")"
[ "${ADMIN}" -gt 4 ] && send_normal_message "${ADMIN}" "Bot $(getConfigKey "botname") stopped ..." &
echo -e "${GREEN}OK. Bot stopped successfully.${NC}"
else
echo -e "${RED}An error occured while stopping bot.${NC}"
exit 5
fi
else
echo -e "${ORANGE}No Bot running with UID ${RUNUSER}.${NC}"
fi
exit
2019-03-25 10:15:07 +00:00
;;
2020-06-12 19:18:32 +00:00
# suspend, resume or kill backgrund jobs
"suspendb"*|"resumeb"*|"killb"*)
_is_function job_control || { echo -e "${RED}Module background is not availible!${NC}"; exit 3; }
job_control "$1"
;;
2016-04-17 12:13:28 +00:00
"help")
2019-04-09 11:41:38 +00:00
less "README.txt"
2019-04-01 10:52:25 +00:00
exit
;;
*)
2020-06-12 19:18:32 +00:00
echo -e "${RED}${REALME##*/}: unknown command${NC}"
echo -e "${ORANGE}Available commands: ${GREY}start, stop, status, stats, broadcast, help, suspendback, resumeback, killback${NC}"
exit 4
2016-04-17 12:13:28 +00:00
;;
2019-04-20 14:26:16 +00:00
esac
2019-04-20 14:26:16 +00:00
# warn if root
if [[ "${UID}" -eq "0" ]] ; then
echo -e "\\n${ORANGE}WARNING: ${SCRIPT} was started as ROOT (UID 0)!${NC}"
echo -e "${ORANGE}You are at HIGH RISK when running a Telegram BOT with root privilegs!${NC}"
2019-04-20 14:26:16 +00:00
fi
fi # end source