# Copyright (c) 2012-2013 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_EUROSHARE_EU_REGEXP_URL='http://\(www\.\)\?euroshare\.eu/'
MODULE_EUROSHARE_EU_DOWNLOAD_OPTIONS="
AUTH_FREE,b,auth-free,a=USER:PASSWORD,Free account"
MODULE_EUROSHARE_EU_DOWNLOAD_RESUME=no
MODULE_EUROSHARE_EU_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=yes
MODULE_EUROSHARE_EU_DOWNLOAD_SUCCESSIVE_INTERVAL=
MODULE_EUROSHARE_EU_UPLOAD_OPTIONS="
AUTH_FREE,b,auth-free,a=USER:PASSWORD,Free account
DESCRIPTION,d,description,S=DESCRIPTION,Set file description"
MODULE_EUROSHARE_EU_UPLOAD_REMOTE_SUPPORT=no
MODULE_EUROSHARE_EU_DELETE_OPTIONS="
AUTH_FREE,b,auth-free,a=USER:PASSWORD,Free account (mandatory)"
MODULE_EUROSHARE_EU_PROBE_OPTIONS=""
# Static function. Proceed with login (free)
# $1: authentication
# $2: cookie file
# $3: base url
euroshare_eu_login() {
local -r AUTH_FREE=$1
local -r COOKIE_FILE=$2
local -r BASE_URL=$3
local LOGIN_DATA PAGE EMAIL
LOGIN_DATA='login=$USER&password=$PASSWORD+&trvale=1'
PAGE=$(post_login "$AUTH_FREE" "$COOKIE_FILE" "$LOGIN_DATA" \
"$BASE_URL/customer-zone/login/" -L) || return
# Boli ste úspešne prihlásený
match 'Boli ste úspešne prihlásený' "$PAGE" || return $ERR_LOGIN_FAILED
# Odhlásiť (xyz)
EMAIL=$(echo "$PAGE" | parse 'Odhlásiť' 'Odhlásiť (\([^)]\+\))') || return
log_debug "Successfully logged in as member '$EMAIL'"
}
# Output a Euroshare.eu file download URL
# $1: cookie file
# $2: euroshare.eu url
# stdout: real file download link
# file name
euroshare_eu_download() {
local -r COOKIE_FILE=$1
local -r URL=$2
local -r BASE_URL='http://www.euroshare.eu'
local PAGE DL_URL FILE_NAME
# HTML returned uses UTF-8 charset
PAGE=$(curl -c "$COOKI_FILE" "$URL") || return
match 'Soubor nenalezen' "$PAGE" && return $ERR_LINK_DEAD
if [ -n "$AUTH_FREE" ]; then
euroshare_eu_login "$AUTH_FREE" "$COOKIE_FILE" "$BASE_URL" || return
fi
PAGE=$(curl -b "$COOKIE_FILE" "$URL") || return
# STIAHNUŤ SÚBOR FREE
DL_URL=$(echo "$PAGE" | parse_attr 'tlacitko modry velk' href) || return
FILE_NAME=$(echo "$PAGE" | parse_tag '"nazev-souboru"' h1)
FILE_NAME=${FILE_NAME% (*}
echo "$DL_URL"
echo "$FILE_NAME"
}
# Upload a file to Euroshare.eu
# $1: cookie file
# $2: input file (with full path)
# $3: remote filename
# stdout: download link + delete link
euroshare_eu_upload() {
local -r COOKIE_FILE=$1
local -r FILE=$2
local -r DEST_FILE=$3
local -r BASE_URL='http://euroshare.eu'
local -r MAX_SIZE=1610612736 # 1.5GiB
local PAGE SIZE UPLOAD_URL USER_ID FORM_PLAIN
if [ -n "$AUTH_FREE" ]; then
euroshare_eu_login "$AUTH_FREE" "$COOKIE_FILE" "$BASE_URL" || return
fi
SIZE=$(get_filesize "$FILE")
if [ $SIZE -gt $MAX_SIZE ]; then
log_debug "File is bigger than $MAX_SIZE"
return $ERR_SIZE_LIMIT_EXCEEDED
fi
PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL")
# SWFUpload
UPLOAD_URL=$(echo "$PAGE" | parse 'upload_url' ':[[:space:]]*"\([^"]*\)') || return
USER_ID=$(echo "$PAGE" | parse 'post_params' "uID.[[:space:]]*:[[:space:]]*'\([^']*\)") || return
FORM_PLAIN=$(echo "$PAGE" | parse 'post_params' "plain.[[:space:]]*:[[:space:]]*\([^}]*\)") || return
PAGE=$(curl_with_log --user-agent 'Shockwave Flash' \
-F "uID=$USER_ID" \
-F "plain=$FORM_PLAIN" \
-F "Filename=$DEST_FILE" \
--form-string "popis1=$DESCRIPTION" \
-F 'soukromy1=0' \
-F "soubor1=@$FILE;type=application/octet-stream;filename=$DEST_FILE" \
-F 'Upload=Submit Query' \
"$UPLOAD_URL") || return
echo "${PAGE%|*}"
echo "${PAGE#*|}"
}
# Delete a file from Euroshare.eu
# $1: cookie file (unused here)
# $2: euroshare.eu (delete) link
euroshare_eu_delete() {
local -r COOKIE_FILE=$1
local -r URL=$2
local -r BASE_URL='http://www.euroshare.eu'
local PAGE FILE_ID
PAGE=$(curl "$URL") || return
match 'Soubor nenalezen' "$PAGE" && return $ERR_LINK_DEAD
[ -n "$AUTH_FREE" ] || return $ERR_LINK_NEED_PERMISSIONS
# Note: Deletion page does not work, so we use the file manager instead
FILE_ID=$(echo "$URL" | \
parse_quiet . '/delete/[[:alnum:]]\+/\([[:digit:]]\+\)/')
if [ -z "$FILE_ID" ]; then
log_error 'This is not a delete link.'
return $ERR_FATAL
fi
log_debug "File ID: '$FILE_ID'"
euroshare_eu_login "$AUTH_FREE" "$COOKIE_FILE" "$BASE_URL" || return
PAGE=$(curl -b "$COOKIE_FILE" -H 'X-Requested-With: XMLHttpRequest' \
-d "id=item_$FILE_ID" \
"$BASE_URL/ajax/file-manager/file-remove/") || return
if ! match 'Array' "$PAGE"; then
log_error 'Could not delete file. Site updated?'
return $ERR_FATAL
fi
}
# Probe a download URL
# $1: cookie file (unused here)
# $2: zippyshare url
# $3: requested capability list
# stdout: 1 capability per line
euroshare_eu_probe() {
local -r URL=$2
local -r REQ_IN=$3
local JSON FILE_NAME FILE_SIZE FILE_HASH REQ_OUT
# Official API: http://euroshare.eu/euroshare-api/
JSON=$(curl --get -d 'sub=checkfile' -d "file=$URL" -d "file_password=" \
'http://euroshare.eu/euroshare-api/') || return
# ERR: File does not exists.
match '^ERR:' "$JSON" && return $ERR_LINK_DEAD
REQ_OUT=c
if [[ $REQ_IN = *f* ]]; then
FILE_NAME=$(echo "$JSON" | parse_json 'file_name') && \
echo "$FILE_NAME" && REQ_OUT="${REQ_OUT}f"
fi
if [[ $REQ_IN = *s* ]]; then
FILE_SIZE=$(echo "$JSON" | parse_json 'file_size') && \
echo "$FILE_SIZE" && REQ_OUT="${REQ_OUT}s"
fi
if [[ $REQ_IN = *h* ]]; then
FILE_HASH=$(echo "$JSON" | parse_json 'md5_hash') && \
echo "$FILE_HASH" && REQ_OUT="${REQ_OUT}h"
fi
echo $REQ_OUT
}
exoshare.sh 0000664 0000000 0000000 00000021102 13022750457 0013231 0 ustar 00root root 0000000 0000000 # Plowshare exoshare.com module
# Copyright (c) 2011-2015 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_EXOSHARE_REGEXP_URL='https\?://\(www\.\)\?\(exoshare\.com\|multi\.la\)/'
MODULE_EXOSHARE_UPLOAD_OPTIONS="
AUTH,a,auth,a=USER:PASSWORD,User account
INCLUDE,,include,l=LIST,Provide list of host site (comma separated)
SHORT_LINK,,short-link,,Produce short link like http://multi.la/s/XXXXXXXX
COUNT,,count,n=COUNT,Take COUNT mirrors (hosters) from the available list. Default is 12.
API,,api,,Use API to upload file
API_KEY,,api-key,s=API_KEY,Provide API key to use instead of login:pass. Can be used without --api option."
MODULE_EXOSHARE_UPLOAD_REMOTE_SUPPORT=yes
MODULE_EXOSHARE_LIST_OPTIONS=""
MODULE_EXOSHARE_LIST_HAS_SUBFOLDERS=no
# Upload a file to exoshare.com
# $1: cookie file (for account only)
# $2: input file (with full path)
# $3: remote filename
# stdout: exoshare.com download link
exoshare_upload() {
if [ -n "$API" -o -n "$API_KEY" ]; then
if [ -z "$AUTH" -a -z "$API_KEY" ]; then
log_error 'API does not allow anonymous uploads.'
return $ERR_LINK_NEED_PERMISSIONS
fi
if [ -n "$AUTH" -a -n "$API_KEY" ]; then
log_error 'Cannot use --api-key and --auth at the same time.'
return $ERR_BAD_COMMAND_LINE
fi
if [ -n "$COUNT" -o -n "$INCLUDE" ]; then
log_error 'API does not support --count and --include.'
return $ERR_BAD_COMMAND_LINE
fi
if match_remote_url "$FILE"; then
log_error 'API does not support remote upload.'
return $ERR_BAD_COMMAND_LINE
fi
exoshare_upload_api "$@"
else
if [ -n "$COUNT" -a -n "$INCLUDE" ]; then
log_error 'Cannot use --count and --include at the same time.'
return $ERR_BAD_COMMAND_LINE
fi
if (( COUNT > 12 )) || [ "${#INCLUDE[@]}" -gt 12 ]; then
log_error 'You must select 12 hosting sites or less.'
return $ERR_BAD_COMMAND_LINE
fi
exoshare_upload_regular "$@"
fi
}
# Upload a file to exoshare.com using official API
# http://exoshare.com/api.php
# $1: cookie file (not used here)
# $2: input file (with full path)
# $3: remote filename
# stdout: exoshare.com download link
exoshare_upload_api() {
local -r FILE=$2
local -r DEST_FILE=$3
local -r BASE_URL='http://www.exoshare.com'
local PAGE FILE_LINK
if [ -n "$API_KEY" ]; then
PAGE=$(curl_with_log \
-F "key=$API_KEY" \
-F 'submit=Send' \
-F "file_0=@$FILE;filename=$DEST_FILE" \
"$BASE_URL/api/api.php") || return
if match 'Wrong Key !' "$PAGE"; then
log_error 'Wrong API key.'
return $ERR_LOGIN_FAILED
fi
else
local USER PASSWORD
split_auth "$AUTH" USER PASSWORD || return
PAGE=$(curl_with_log \
-F "user=$USER" \
-F "password=$PASSWORD" \
-F "file_0=@$FILE;filename=$DEST_FILE" \
"$BASE_URL/upload.php") || return
if match 'Wrong Username/Password' "$PAGE"; then
return $ERR_LOGIN_FAILED
fi
fi
if ! match '^http://www\.exoshare\.com/download\.php?uid=[A-Z0-9]\+$' "$PAGE"; then
log_error 'Upload failed'
return $ERR_FATAL
fi
FILE_LINK="$PAGE"
if [ -n "$SHORT_LINK" ]; then
replace 'http://www.exoshare.com/download.php?uid=' 'http://multi.la/s/' <<< "$FILE_LINK"
else
echo "$FILE_LINK"
fi
}
# Upload a file to exoshare.com using regular site
# $1: cookie file (for account only)
# $2: input file (with full path)
# $3: remote filename
# stdout: exoshare.com download link
exoshare_upload_regular() {
local -r COOKIE_FILE=$1
local -r FILE=$2
local -r DEST_FILE=$3
local -r BASE_URL='http://www.exoshare.com'
local SITES_COUNT=0
local PAGE FORM_HTML SITES_ALL SITES_SEL FORM_SITES_OPT SITE UPLOAD_RND UPLOAD_ID LINK_SCRIPT UPLOAD_SCRIPT
if [ -n "$AUTH" ]; then
local LOGIN_DATA LOGIN_RESULT LOCATION
LOGIN_DATA='username=$USER&pass=$PASSWORD&submit='
LOGIN_RESULT=$(post_login "$AUTH" "$COOKIE_FILE" "$LOGIN_DATA" \
"$BASE_URL/login.php" -i) || return
LOCATION=$(grep_http_header_location_quiet <<< "$LOGIN_RESULT")
if ! match 'account.php' "$LOCATION"; then
return $ERR_LOGIN_FAILED
fi
fi
PAGE=$(curl "$BASE_URL" -b "$COOKIE_FILE") || return
PAGE=$(break_html_lines <<< "$PAGE")
FORM_HTML=$(grep_form_by_id "$PAGE" 'form_upload') || return
SITES_ALL=$(parse_all_attr 'type="checkbox"' 'name' <<< "$FORM_HTML") || return
LINK_SCRIPT=$(parse 'var path_to_link_script' ' = "\([^"]\+\)' <<< "$PAGE") || return
UPLOAD_SCRIPT=$(parse 'var path_to_upload_script' ' = "\([^"]\+\)' <<< "$PAGE") || return
if match_remote_url "$FILE"; then
REMOTE_FLAG='remote'
fi
if [ -n "$COUNT" ]; then
for SITE in $SITES_ALL; do
(( COUNT-- > 0 )) || break
FORM_SITES_OPT=$FORM_SITES_OPT"-F $SITE$REMOTE_FLAG=on "
done
elif [ "${#INCLUDE[@]}" -gt 0 ]; then
for SITE in "${INCLUDE[@]}"; do
if match "$SITE" "$SITES_ALL"; then
FORM_SITES_OPT=$FORM_SITES_OPT"-F $SITE$REMOTE_FLAG=on "
else
log_error "Host not supported: $SITE, ignoring"
fi
done
else
# Default hosting sites selection
SITES_SEL=$(parse_all_attr 'checked="checked"' 'name' <<< "$FORM_HTML")
for SITE in $SITES_SEL; do
FORM_SITES_OPT=$FORM_SITES_OPT"-F $SITE$REMOTE_FLAG=on "
done
fi
if [ -z "$FORM_SITES_OPT" ]; then
log_error 'Empty site selection. Nowhere to upload!'
SITES_ALL=$(replace_all $'\n' ', ' <<< "$SITES_ALL")
log_debug "Try one of these: $SITES_ALL"
return $ERR_FATAL
fi
UPLOAD_RND=$(random d 13)
PAGE=$(curl -b "$COOKIE_FILE" \
"$BASE_URL/$LINK_SCRIPT?rnd_id=$UPLOAD_RND")
if match 'Error, registering for a free account is required.' "$PAGE"; then
log_error 'Anonymous uploads limit exceeded.'
return $ERR_FATAL
fi
UPLOAD_ID=$(parse 'startUpload' 'startUpload("\([^"]\+\)' <<< "$PAGE") || return
if match_remote_url "$FILE"; then
PAGE=$(curl_with_log \
-b "$COOKIE_FILE" \
-F "url=$FILE" \
-F "newfname=$DEST_FILE" \
$FORM_SITES_OPT \
"$BASE_URL/remote.php") || return
else
PAGE=$(curl_with_log \
-L \
-b "$COOKIE_FILE" \
-F 'mail=' \
$FORM_SITES_OPT \
-F "upfile_0=@$FILE;filename=$DEST_FILE" \
"$BASE_URL$UPLOAD_SCRIPT?upload_id=$UPLOAD_ID") || return
fi
FILE_ID=$(parse 'Your download link is' '?uid=\([A-Z0-9]\+\)' <<< "$PAGE") || return
if [ -n "$SHORT_LINK" ]; then
echo "http://multi.la/s/$FILE_ID"
else
echo "http://exoshare.com/download.php?uid=$FILE_ID"
fi
return 0
}
# List links from a exoshare link
# $1: exoshare link
# $2: recurse subfolders (ignored here)
# stdout: list of links
exoshare_list() {
local -r URL=$1
local -r BASE_URL='http://www.exoshare.com'
local PAGE LINKS NAMES NAME FILE_ID
if match 'multi.la' "$URL"; then
FILE_ID=$(parse . '/s/\([a-zA-Z0-9]\+\)' <<< "$URL") || return
else
FILE_ID=$(parse . 'uid=\([a-zA-Z0-9]\+\)' <<< "$URL") || return
fi
PAGE=$(curl "$URL") || return
NAME=$(parse_tag title <<< "$PAGE")
NAME=${NAME#Exoshare - Download - }
PAGE=$(curl -e "$BASE_URL/download.php?uid=$FILE_ID" \
"$BASE_URL/status.php?uid=$FILE_ID&txt=$NAME") || return
LINKS=$(parse_all_quiet '=.himgdl.*Successv3\.png' 'href="\([^#"][^"]\+\)"' <<< "$PAGE")
[ -n "$LINKS" ] || return $ERR_LINK_DEAD
NAMES=$(parse_all '=.himgdl.*Successv3\.png' '/images/\(.*\)" class.*href="[^#"]' <<< "$PAGE")
[ -n "$NAMES" ] || NAMES=$NAME
list_submit "$LINKS" "$NAMES" || return
}
faststore.sh 0000664 0000000 0000000 00000026342 13022750457 0013440 0 ustar 00root root 0000000 0000000 # Plowshare faststore.org module
# Copyright (c) 2016 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_FASTSTORE_REGEXP_URL='https\?://\(www\.\)\?faststore\.org/'
MODULE_FASTSTORE_DOWNLOAD_OPTIONS="
AUTH,a,auth,a=USER:PASSWORD,User account
LINK_PASSWORD,p,link-password,S=PASSWORD,Used in password-protected files"
MODULE_FASTSTORE_DOWNLOAD_RESUME=yes
MODULE_FASTSTORE_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=no
MODULE_FASTSTORE_DOWNLOAD_SUCCESSIVE_INTERVAL=
MODULE_FASTSTORE_PROBE_OPTIONS=""
# Static function. It automatically get a code from captcha html.
# $1: captcha html
# stdout: code
faststore_captcha() {
local CAPTCHA_HTML=$1
local CAPTCHA_PROPERTIES CAPTCHA_NUMBERS CAPTCHA_LINES VAR1 VAR2 LINE CODE
if ! check_exec 'sort'; then
log_error "'sort' is required but was not found in path."
return $ERR_SYSTEM
fi
CAPTCHA_HTML=$(break_html_lines <<< "$CAPTCHA_HTML" | html_to_utf8) || return
# The captcha code contains numbers that are displayed according to
# CSS padding-left properties. We have to get those property values
# and corresponding numbers, sort according to property values and
# send numbers to the server. So retrieve properties and their numbers.
CAPTCHA_PROPERTIES=$(parse_all . 'left:\([[:digit:]]\+\)px' \
<<< "$CAPTCHA_HTML") || return
CAPTCHA_NUMBERS=$(parse_all_tag 'span' <<< "$CAPTCHA_HTML") || return
# Concatenate two columns (properties and numbers) and
# make ascending sorting according to the properties.
CAPTCHA_LINES=$(while read -r VAR1 && read -r VAR2 <&3; do echo "$VAR1 $VAR2"; done \
<<< "$CAPTCHA_PROPERTIES" 3<<< "$CAPTCHA_NUMBERS") || return
CAPTCHA_LINES=$(while read -r LINE; do echo "$LINE"; done <<< "$CAPTCHA_LINES" \
| sort -n -k1) || return
# Concatenate numbers together in a single variable. This is our code.
CODE=$(parse_all . ".* \(.*\)" <<< "$CAPTCHA_LINES" \
| replace_all $'\n' '') || return
echo $CODE
}
# Static function. Proceed with login
# $1: authentication
# $2: cookie file
# $3: base URL
# stdout: account type ("free" or "premium") on success.
faststore_login() {
local -r AUTH=$1
local -r COOKIE_FILE=$2
local -r BASE_URL=$3
local CV PAGE SESS MSG LOGIN_DATA STATUS NAME TYPE
if CV=$(storage_get 'cookie_file'); then
echo "$CV" >"$COOKIE_FILE"
# Check for expired session.
PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL") || return
if ! match '>My Account<' "$PAGE"; then
storage_set 'cookie_file'
return $ERR_EXPIRED_SESSION
fi
SESS=$(parse_cookie 'xfss' < "$COOKIE_FILE")
log_debug "session (cached): '$SESS'"
MSG='reused login for'
else
local FORM_HTML FORM_RAND CAPTCHA_HTML CODE
PAGE=$(curl "$BASE_URL/login.html") || return
FORM_HTML=$(grep_form_by_name "$PAGE" 'FL') || return
FORM_RAND=$(parse_form_input_by_name 'rand' <<< "$FORM_HTML") || return
# In order to login we have to send to the server a captcha code.
CAPTCHA_HTML=$(parse 'captcha_code' '^\(.*\)$' -1 <<< "$FORM_HTML") || return
CODE=$(faststore_captcha "$CAPTCHA_HTML") || return
LOGIN_DATA='op=login&redirect='$BASE_URL'&rand='$FORM_RAND'&login=$USER&password=$PASSWORD&code='$CODE''
# Before login we have to wait at least 5 seconds, otherwise
# when we login too fast login failed. It's some kind of an internal
# countdown on the server (it's some kind of an anti-bot mechanism).
wait 5 || return
PAGE=$(post_login "$AUTH" "$COOKIE_FILE" "$LOGIN_DATA" "$BASE_URL" -L) || return
# This check will never applied here, because when it's wrong captcha
# then we immediately return from post_login function with error: no
# entry was set (empty cookie file). Nevertheless I leave it with this
# comment for the future. In order to check if it is something wrong
# with a captcha function, please download a file as anonymous user.
if match '>Wrong captcha<' "$PAGE"; then
log_error 'Captcha was not resolved correctly.'
log_error 'The faststore_captcha function not working anymore.'
return $ERR_FATAL
fi
# If successful, two entries are added into cookie file: login and xfss.
STATUS=$(parse_cookie_quiet 'xfss' < "$COOKIE_FILE")
[ -z "$STATUS" ] && return $ERR_LOGIN_FAILED
storage_set 'cookie_file' "$(cat "$COOKIE_FILE")"
SESS=$(parse_cookie 'xfss' < "$COOKIE_FILE")
log_debug "session (new): '$SESS'"
MSG='logged in as'
fi
NAME=$(parse_cookie_quiet 'login' < "$COOKIE_FILE")
if match 'Your are a regular account.' "$PAGE"; then
TYPE='free'
else
TYPE='premium'
fi
log_debug "Successfully $MSG '$TYPE' member '$NAME'"
echo $TYPE
}
# Output a faststore file download URL
# $1: cookie file
# $2: faststore url
# stdout: real file download link
faststore_download() {
local -r COOKIE_FILE=$1
local -r BASE_URL='http://faststore.org'
local URL ACCOUNT PAGE WAIT_TIME PASSWORD_DATA
local FORM_HTML FORM_OP FORM_USR FORM_ID FORM_FNAME FORM_REF
local FORM_METHOD_F FORM_RAND FORM_RAND2 FORM_METHOD_P FORM_DD
# Get a canonical URL for this file.
URL=$(curl -I "$2" | grep_http_header_location_quiet) || return
[ -n "$URL" ] || URL=$2
readonly URL
if [ -n "$AUTH" ]; then
ACCOUNT=$(faststore_login "$AUTH" "$COOKIE_FILE" "$BASE_URL") || return
fi
PAGE=$(curl -b "$COOKIE_FILE" -c "$COOKIE_FILE" "$URL") || return
if match 'File Not Found' "$PAGE"; then
return $ERR_LINK_DEAD
fi
FORM_HTML=$(grep_form_by_order "$PAGE" 1) || return
FORM_OP=$(parse_form_input_by_name 'op' <<< "$FORM_HTML") || return
FORM_USR=$(parse_form_input_by_name_quiet 'usr_login' <<< "$FORM_HTML")
FORM_ID=$(parse_form_input_by_name 'id' <<< "$FORM_HTML") || return
FORM_FNAME=$(parse_form_input_by_name 'fname' <<< "$FORM_HTML") || return
FORM_REF=$(parse_form_input_by_name_quiet 'referer' <<< "$FORM_HTML")
FORM_METHOD_F=$(parse_form_input_by_name_quiet 'method_free' <<< "$FORM_HTML")
PAGE=$(curl -b "$COOKIE_FILE" \
-d "op=$FORM_OP" \
-d "usr_login=$FORM_USR" \
-d "id=$FORM_ID" \
-d "fname=$FORM_FNAME" \
-d "referer=$FORM_REF" \
-d "method_free=$FORM_METHOD_F" \
"$URL") || return
# Warning! You have reached your download limit.
if match '>You have to wait .* till next download' "$PAGE"; then
local HOURS MINS SECS
HOURS=$(parse_quiet '>You have to wait' \
'[^[:digit:]]\([[:digit:]]\+\) hours\?' <<< "$PAGE")
MINS=$(parse_quiet '>You have to wait' \
'[^[:digit:]]\([[:digit:]]\+\) minutes\?' <<< "$PAGE")
SECS=$(parse_quiet '>You have to wait' \
'[^[:digit:]]\([[:digit:]]\+\) seconds\?' <<< "$PAGE")
log_error 'Download limit reached.'
# Note: Always use decimal base instead of octal if there are leading zeros.
echo $(( (( 10#$HOURS * 60 ) + 10#$MINS ) * 60 + 10#$SECS ))
return $ERR_LINK_TEMP_UNAVAILABLE
# Check for premium only files.
elif match '>This file is available for Premium Users only' "$PAGE"; then
log_error 'This file is available for Premium Users only.'
return $ERR_LINK_NEED_PERMISSIONS
# Check for files that need a password.
elif match 'name="password"' "$PAGE"; then
log_debug 'File is password protected.'
if [ -z "$LINK_PASSWORD" ]; then
LINK_PASSWORD=$(prompt_for_password) || return
fi
PASSWORD_DATA="-d password=$(replace_all ' ' '+' <<< "$LINK_PASSWORD")"
fi
FORM_HTML=$(grep_form_by_name "$PAGE" 'F1') || return
FORM_OP=$(parse_form_input_by_name 'op' <<< "$FORM_HTML") || return
FORM_ID=$(parse_form_input_by_name 'id' <<< "$FORM_HTML") || return
FORM_RAND=$(parse_form_input_by_name 'rand' <<< "$FORM_HTML") || return
FORM_RAND2=$(parse_form_input_by_name 'rand2' <<< "$FORM_HTML") || return
FORM_REF=$(parse_form_input_by_name_quiet 'referer' <<< "$FORM_HTML")
FORM_METHOD_F=$(parse_form_input_by_name_quiet 'method_free' <<< "$FORM_HTML")
FORM_METHOD_P=$(parse_form_input_by_name_quiet 'method_premium' <<< "$FORM_HTML")
FORM_DD=$(parse_form_input_by_name 'down_direct' <<< "$FORM_HTML") || return
# We have to get a captcha code and send to the server.
CAPTCHA_HTML=$(parse 'captcha_code' '^\(.*\)$' -1 <<< "$FORM_HTML") || return
CODE=$(faststore_captcha "$CAPTCHA_HTML") || return
WAIT_TIME=$(parse_tag countdown_str span <<< "$PAGE") || return
wait $WAIT_TIME || return
PAGE=$(curl -b "$COOKIE_FILE" \
-d "op=$FORM_OP" \
-d "id=$FORM_ID" \
-d "rand=$FORM_RAND" \
-d "rand2=$FORM_RAND2" \
-d "referer=$FORM_REF" \
-d "method_free=$FORM_METHOD_F" \
-d "method_premium=$FORM_METHOD_P" \
$PASSWORD_DATA \
-d "code=$CODE" \
-d "down_direct=$FORM_DD" \
"$URL") || return
if match '>Wrong captcha<' "$PAGE"; then
log_error 'Captcha was not resolved correctly.'
log_error 'The faststore_captcha function not working anymore.'
return $ERR_FATAL
elif match '>Wrong password<' "$PAGE"; then
log_error 'Wrong password'
return $ERR_LINK_PASSWORD_REQUIRED
fi
parse_attr '>CLICK TO DOWNLOAD<' 'href' <<< "$PAGE" || return
}
# Probe a download URL
# $1: cookie file (unused here)
# $2: faststore url
# $3: requested capability list
# stdout: 1 capability per line
faststore_probe() {
local -r URL=$2
local -r REQ_IN=$3
local -r BASE_URL='http://faststore.org'
local PAGE FILE_SIZE REQ_OUT
# Check a file through a link checker.
PAGE=$(curl \
-d 'op=checkfiles' \
-d "list=$URL" \
"$BASE_URL/?op=checkfiles") || return
if match ">Filename don't match!<" "$PAGE"; then
log_error "Filename don't match!"
return $ERR_FATAL
elif ! match '>Found<' "$PAGE"; then
return $ERR_LINK_DEAD
fi
REQ_OUT=c
if [[ $REQ_IN = *f* ]]; then
# We cannot check a file name through a link
# checker, we have to get it from a file page.
curl "$URL" | parse_form_input_by_name 'fname' && REQ_OUT="${REQ_OUT}f"
fi
if [[ $REQ_IN = *s* ]]; then
FILE_SIZE=$(parse . '>Found\([^<]*\)' <<< "$PAGE") \
&& FILE_SIZE=$(replace 'B' 'iB' <<< $FILE_SIZE) \
&& translate_size "$FILE_SIZE" && REQ_OUT="${REQ_OUT}s"
fi
if [[ $REQ_IN = *i* ]]; then
parse . 'org/\([[:alnum:]]\+\)' <<< "$URL" && REQ_OUT="${REQ_OUT}i"
fi
echo $REQ_OUT
}
fboom_me.sh 0000664 0000000 0000000 00000015344 13022750457 0013211 0 ustar 00root root 0000000 0000000 # Plowshare fboom.me module
# by idleloop , v1.1, Mar 2016
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
#
# (Official API probably similar to: https://github.com/keep2share/api)
MODULE_FBOOM_ME_REGEXP_URL='https\?://\(www\.\)\?fboom.me/'
MODULE_FBOOM_ME_DOWNLOAD_OPTIONS=""
MODULE_FBOOM_ME_DOWNLOAD_RESUME=yes
MODULE_FBOOM_ME_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=no
MODULE_FBOOM_ME_DOWNLOAD_FINAL_LINK_NEEDS_EXTRA=
MODULE_FBOOM_ME_DOWNLOAD_SUCCESSIVE_INTERVAL=
MODULE_FBOOM_ME_PROBE_OPTIONS=""
# Static function. Switch language to english
# $1: cookie file
# $2: base URL
fboom_me_switch_lang() {
curl "$2/site/setLanguage" -b "$1" -c "$1" -d 'language=en' > /dev/null || return
}
# Output an fboom_me file download URL
# $1: cookie file
# $2: fboom_me url
# stdout: real file download link
fboom_me_download() {
local -r COOKIE_FILE=$1
local URL BASE_URL FILE_NAME PRE_URL
local PAGE FORM_HTML FILE_ID WAIT
# get canonical URL and BASE_URL for this file
URL=$(curl -I "$2" | grep_http_header_location_quiet) || return
[ -n "$URL" ] || URL=$2
BASE_URL=${URL%/file*}
readonly URL BASE_URL
fboom_me_switch_lang "$COOKIE_FILE" "$BASE_URL"
PAGE=$(curl -b "$COOKIE_FILE" -c "$COOKIE_FILE" "$URL") || return
# Malformed url
if match 'The system is unable to find the requested action' "$PAGE"; then
log_error 'Invalid or malformed link! Check url.'
return $ERR_LINK_DEAD
fi
# File not found or deleted
if match 'File not found or deleted\|This file is no longer available' "$PAGE"; then
return $ERR_LINK_DEAD
fi
# File only available to premium members
if match 'only for premium members.' "$PAGE"; then
return $ERR_LINK_NEED_PERMISSIONS
fi
FILE_NAME=$(parse 'Download file:' '^[[:blank:]]\+\([^<]\+\)[[:blank:]]\+<' '3' <<< "$PAGE" | \
html_to_utf8) || return
readonly FILE_NAME
FILE_ID=$(parse 'data-slow-id' 'data-slow-id="\([^"]\+\)"' <<< "$PAGE") || return
# request download
PAGE=$(curl -b "$COOKIE_FILE" -d "slow_id=$FILE_ID" \
"$URL") || return
# check for forced delay
WAIT=$(parse_quiet 'Please wait .* to download this file' \
'wait \([[:digit:]:]\+\) to download' <<< "$PAGE")
if [ -n "$WAIT" ]; then
local HOUR MIN SEC
HOUR=${WAIT%%:*}
SEC=${WAIT##*:}
MIN=${WAIT#*:}; MIN=${MIN%:*}
log_error 'Forced delay between downloads.'
# Note: Get rid of leading zeros so numbers will not be considered octal
echo $(( (( ${HOUR#0} * 60 ) + ${MIN#0} ) * 60 + ${SEC#0} ))
return $ERR_LINK_TEMP_UNAVAILABLE
fi
# Free user can't download large files.
if match "Free user can't download large files" "$PAGE"; then
log_error 'Free user cant download large files'
return $ERR_LINK_NEED_PERMISSIONS
fi
# check for and handle CAPTCHA (if any)
if match 'captcha.html' "$PAGE"; then
log_debug 'Captcha found'
local CAPTCHA_URL IMG_FILE
local RESP WORD ID CAPTCHA_DATA
# Get captcha image
CAPTCHA_URL=$(parse_attr ' id="captcha_' 'src' <<< "$PAGE") || return
IMG_FILE=$(create_tempfile '.fboom_me.png') || return
curl -b "$COOKIE_FILE" -o "$IMG_FILE" "$BASE_URL$CAPTCHA_URL" || return
# Solve captcha
# Note: Image is a 260x80 png file containing 6-7 characters
RESP=$(captcha_process "$IMG_FILE" fboom_me 6 7) || return
{ read WORD; read ID; } <<< "$RESP"
rm -f "$IMG_FILE"
CAPTCHA_DATA="-d CaptchaForm%5Bcode%5D=$WORD"
log_debug "Captcha data: $CAPTCHA_DATA"
FILE_ID=$(parse_form_input_by_name 'uniqueId' <<< "$PAGE") || return
PAGE=$(curl -b "$COOKIE_FILE" $CAPTCHA_DATA \
-d 'free=1' -d 'freeDownloadRequest=1' \
-d "uniqueId=$FILE_ID" \
-H 'X-Requested-With: XMLHttpRequest' \
"$URL") || return
if match 'The verification code is incorrect' "$PAGE"; then
log_error 'Wrong captcha'
captcha_nack "$ID"
return $ERR_CAPTCHA
fi
log_debug 'Correct captcha'
captcha_ack "$ID"
# parse wait time
WAIT=$(parse ' id="download-wait-timer"' \
'.*>[[:blank:]]*\([[:digit:]]\+\)' 1 <<< "$PAGE") || return
wait $(( WAIT + 1 )) || return
PAGE=$(curl -b "$COOKIE_FILE" -d "uniqueId=$FILE_ID" \
-d 'free=1' "$URL") || return
PRE_URL=$(parse_attr 'id="temp-link"' 'href' <<< "$PAGE") || return
# direct download without captcha
elif match 'bottomDownloadButton' "$PAGE"; then
PRE_URL=$(parse 'window.location.href' "'\([^']\+\)'" <<< "$PAGE") || return
else
log_error 'Unexpected content. Site updated?'
return $ERR_FATAL
fi
log_debug "Pre-URL: '$PRE_URL'"
PAGE=$(curl --head -b "$COOKIE_FILE" "$BASE_URL$PRE_URL") || return
# output final url + file name
grep_http_header_location <<< "$PAGE" || return
echo "$FILE_NAME"
}
# Probe a download URL
# $1: cookie file (unused here)
# $2: fboom.me url
# $3: requested capability list
# stdout: 1 capability per line
#
# probable API (see this file's header) does not provide an anonymous check-link feature :(
# $ curl --data '{"ids"=["816bef5d35245"]}' http://fboom.me/api/v1/GetFilesInfo
fboom_me_probe() {
local -r URL=$2
local -r REQ_IN=$3
local PAGE REQ_OUT FILE_NAME
PAGE=$(curl --location -b 'language=en' "$URL") || return
# File not found or delete
if match 'File not found or deleted\|This file is no longer available' "$PAGE"; then
return $ERR_LINK_DEAD
fi
REQ_OUT=c
if [[ $REQ_IN = *f* ]]; then
echo "$PAGE" | parse 'Download file:' '^[[:blank:]]\+\([^<]\+\)[[:blank:]]\+<' 3 | \
sed -e 's/[[:space:]]*$//' && \
REQ_OUT="${REQ_OUT}f"
fi
if [[ $REQ_IN = *s* ]]; then
FILE_SIZE=$(parse_tag 'File size:' 'div' <<< "$PAGE") && \
translate_size "${FILE_SIZE#File size: }" && REQ_OUT="${REQ_OUT}s"
fi
if [[ $REQ_IN = *i* ]]; then
parse . 'file/\([[:alnum:]]\+\)/\?' <<< "$URL" && REQ_OUT="${REQ_OUT}i"
fi
echo $REQ_OUT
}
filebin_ca.sh 0000664 0000000 0000000 00000005766 13022750457 0013510 0 ustar 00root root 0000000 0000000 # Plowshare filebin.ca module
# Copyright (c) 2013 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_FILEBIN_CA_REGEXP_URL='https\?://\(www\.\)\?filebin\.ca/[[:alnum:]]\+'
MODULE_FILEBIN_CA_DOWNLOAD_OPTIONS=""
MODULE_FILEBIN_CA_DOWNLOAD_RESUME=yes
MODULE_FILEBIN_CA_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=no
MODULE_FILEBIN_CA_DOWNLOAD_SUCCESSIVE_INTERVAL=
MODULE_FILEBIN_CA_UPLOAD_OPTIONS=""
MODULE_FILEBIN_CA_UPLOAD_REMOTE_SUPPORT=no
MODULE_FILEBIN_CA_PROBE_OPTIONS=""
# Output a filebin.ca file download URL
# $1: cookie file (unused here)
# $2: filebin.ca url
# stdout: real file download link
filebin_ca_download() {
local -r URL=$2
# Nothing to do, links are direct!
echo "$URL"
}
# Upload a file to filebin.ca
# Official sources: https://github.com/slepp/filebin.ca
# $1: cookie file (unused here)
# $2: input file (with full path)
# $3: remote filename
filebin_ca_upload() {
local -r FILE=$2
local -r DESTFILE=$3
local -r BASE_URL='http://filebin.ca/upload.php'
local DATA STATUS
# No API key for now..
DATA=$(curl_with_log \
-F "file=@$FILE;filename=$DESTFILE" \
"$BASE_URL") || return
if [ -z "$DATA" ]; then
log_error 'Remote error: empty result not expected. Server busy?'
return $ERR_LINK_TEMP_UNAVAILABLE
fi
# Result sample:
# status:wjBQjTib7TH
# url:http://filebin.ca/wjBQjTib7TH/foo.zip
STATUS=$(parse '^status:' '^status:\(.*\)' <<< "$DATA") || return
if [ "$STATUS" = 'error' -o "$STATUS" = 'fail' ]; then
log_error 'Remote error'
return $ERR_FATAL
fi
parse '^url:' '^url:\(http://[^[:space:]]\+\)' <<< "$DATA"
}
# Probe a download URL
# $1: cookie file (unused here)
# $2: filebin.ca url
# $3: requested capability list
# stdout: 1 capability per line
filebin_ca_probe() {
local -r URL=$2
local -r REQ_IN=$3
local HEADERS REQ_OUT
# Content-Type: application/octet-stream
# Content-Disposition: attachment; filename="foo"
# Content-length: 123456
HEADERS=$(curl --head "$URL") || return
if match '404 Not Found' "$HEADERS"; then
return $ERR_LINK_DEAD
fi
REQ_OUT=c
if [[ $REQ_IN = *f* ]]; then
grep_http_header_content_disposition <<< "$HEADERS" && REQ_OUT="${REQ_OUT}f"
fi
if [[ $REQ_IN = *s* ]]; then
grep_http_header_content_length <<< "$HEADERS" && REQ_OUT="${REQ_OUT}s"
fi
echo $REQ_OUT
}
filecloud.sh 0000664 0000000 0000000 00000031120 13022750457 0013362 0 ustar 00root root 0000000 0000000 # Plowshare filecloud.io module
# Copyright (c) 2013-2014 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_FILECLOUD_REGEXP_URL='http://\(www\.\)\?filecloud\.io/'
MODULE_FILECLOUD_DOWNLOAD_OPTIONS="
APIKEY,,apikey,s=APIKEY,Account apikey
AUTH,a,auth,a=USER:PASSWORD,User account"
MODULE_FILECLOUD_DOWNLOAD_RESUME=yes
MODULE_FILECLOUD_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=no
MODULE_FILECLOUD_DOWNLOAD_SUCCESSIVE_INTERVAL=
MODULE_FILECLOUD_UPLOAD_OPTIONS="
APIKEY,,apikey,s=APIKEY,Account apikey
AUTH,a,auth,a=USER:PASSWORD,User account
PRIVATE,,private,,Mark file for personal use only
TAGS,,tags,s=TAGS,One or multiple tags for uploaded file (separated with comma)"
MODULE_FILECLOUD_UPLOAD_REMOTE_SUPPORT=no
MODULE_FILECLOUD_LIST_OPTIONS="
APIKEY,,apikey,s=APIKEY,Account apikey
AUTH,a,auth,a=USER:PASSWORD,User account"
MODULE_FILECLOUD_LIST_HAS_SUBFOLDERS=no
MODULE_FILECLOUD_PROBE_OPTIONS=""
# curl wrapper to handle all json requests
# $@: curl arguments
# stdout: JSON content
filecloud_curl_json() {
local PAGE STAT ERROR
PAGE=$(curl "$@") || return
STAT=$(parse_json 'status' <<< "$PAGE") || return
if [ "$STAT" != 'ok' ]; then
ERROR=$(parse_json 'message' <<< "$PAGE") || return
if match 'set as private' "$ERROR" || \
match 'private file' "$ERROR"; then
log_error 'This tag or file is set as private and is only viewable by the owner.'
return $ERR_LINK_NEED_PERMISSIONS
elif match 'no such user' "$ERROR"; then
return $ERR_LOGIN_FAILED
elif match '^no such' "$ERROR"; then
return $ERR_LINK_DEAD
else
log_error "Remote error: $ERROR"
return $ERR_FATAL
fi
fi
echo "$PAGE"
}
# Fetch API key
# Official API: http://code.google.com/p/filecloud/
# $1: authentication data (user:pass)
# stdout: apikey
filecloud_api_fetch_apikey() {
local -r AUTH=$1
local USER PASSWORD PAGE
split_auth "$AUTH" USER PASSWORD || return
PAGE=$(filecloud_curl_json \
-d "username=$USER" \
-d "password=$PASSWORD" \
'https://filecloud.io/api-fetch_apikey.api') || return
parse_json 'akey' <<< "$PAGE" || return
}
# Output a filecloud.io file download URL
# $1: cookie file
# $2: filecloud.io url
# stdout: file download link
filecloud_download() {
local -r COOKIE_FILE=$1
local -r URL=$2
local -r BASE_URL='http://filecloud.io'
local PREMIUM=0
local PAGE UKEY FORM_AB FILE_URL AUTH_COOKIE CAPTCHA_DATA CAPTCHA
local ERROR_CODE MESSAGES ERROR_TEXT
if [ -z "$APIKEY" -a -n "$AUTH" ]; then
APIKEY=$(filecloud_api_fetch_apikey "$AUTH") || return
fi
if [ -n "$APIKEY" ]; then
AUTH_COOKIE="-b auth="$(uri_encode_strict <<< "$APIKEY")
PAGE=$(filecloud_curl_json \
-d "akey=$APIKEY" \
'https://filecloud.io/api-fetch_account_details.api') || return
PREMIUM=$(parse_json 'is_premium' <<< "$PAGE") || return
fi
UKEY=$(parse . '/\([[:alnum:]]\+\)$' <<< "$URL") || return
if [ "$PREMIUM" = 1 ]; then
PAGE=$(filecloud_curl_json \
-d "akey=$APIKEY" \
-d "ukey=$UKEY" \
'https://filecloud.io/api-fetch_download_url.api') || return
FILE_URL=$(parse_json 'download_url' <<< "$PAGE") || return
else
PAGE=$(curl -L $AUTH_COOKIE -c "$COOKIE_FILE" "$URL") || return
ERROR_CODE=$(parse 'var __error' '__error[[:space:]]*=[[:space:]]*\([^;]\+\)' <<< "$PAGE") || return
if [ "$ERROR_CODE" != 0 ]; then
ERROR_MESSAGE=$(parse 'var __error_msg' '__error_msg[[:space:]]*=[[:space:]]*l10n\.\([^;]\+\)' <<< "$PAGE")
if match 'FILES__REMOVED' "$ERROR_MESSAGE" ||
match 'FILES__DOESNT_EXIST' "$ERROR_MESSAGE"; then
return $ERR_LINK_DEAD
elif match 'FILES__PRIVATE_MSG' "$ERROR_MESSAGE"; then
log_error 'This file is set as private and is only viewable by the owner.'
return $ERR_LINK_NEED_PERMISSIONS
else
MESSAGES=$(parse 'var l10n' "jQuery.parseJSON( '\(.*\)' );" <<< "$PAGE") || return
ERROR_TEXT=$(parse_json "$ERROR_MESSAGE" <<< "$MESSAGES") || return
log_error "Remote error: $ERROR_TEXT."
return $ERR_FATAL
fi
fi
FORM_AB=$(parse 'if( __ab == 1 ){var __ab1 = ' 'if( __ab == 1 ){var __ab1 = \([^;]\+\)' <<< "$PAGE") || return
PAGE=$(filecloud_curl_json $AUTH_COOKIE -b "$COOKIE_FILE" \
-d "ukey=$UKEY" \
-d "__ab1=$FORM_AB" \
"$BASE_URL/download-request.json") || return
CAPTCHA=$(parse_json 'captcha' <<< "$PAGE") || return
PAGE=$(curl $AUTH_COOKIE -b "$COOKIE_FILE" "$BASE_URL/download.html") || return
while [ "$CAPTCHA" = 1 ]; do
# captcha=1 on second loop means that previous captcha was wrong
if [ -n "$ID" ]; then
captcha_nack $ID
log_error 'Wrong captcha'
return $ERR_CAPTCHA
fi
local PUBKEY WCI CHALLENGE WORD ID
PUBKEY=$(parse '__recaptcha_public' \
"__recaptcha_public[[:space:]]*=[[:space:]]*'\([[:alnum:]_-.]\+\)" <<< "$PAGE") || return
WCI=$(recaptcha_process $PUBKEY) || return
{ read WORD; read CHALLENGE; read ID; } <<<"$WCI"
CAPTCHA_DATA="-d ctype=recaptcha -d recaptcha_response=$WORD -d recaptcha_challenge=$CHALLENGE"
PAGE=$(filecloud_curl_json $AUTH_COOKIE -b "$COOKIE_FILE" \
-d "ukey=$UKEY" \
-d "__ab1=$FORM_AB" \
$CAPTCHA_DATA \
"$BASE_URL/download-request.json") || return
CAPTCHA=$(parse_json 'captcha' <<< "$PAGE") || return
PAGE=$(curl $AUTH_COOKIE -b "$COOKIE_FILE" "$BASE_URL/download.html") || return
done
# Captcha is optional sometimes
[ -n "$ID" ] && captcha_ack $ID
FILE_URL=$(parse_attr 'downloadBtn' 'href' <<< "$PAGE") || return
fi
echo "$FILE_URL"
}
# Check if specified tag name(s) is valid.
# There cannot be two tags with the same name.
# $1: tag name(s) selected by user
# $2: apikey
# $3: base url
# stdout: tag ID
filecloud_check_tag() {
local NAMES=$1
local -r APIKEY=$(uri_encode_strict <<< "$2")
local -r BASE_URL=$3
local PAGE TAGS_LIST TAGS TAGS_ID
log_debug 'Getting tag IDs...'
PAGE=$(curl -b "auth=$APIKEY" "$BASE_URL/tags-manager.html") || return
TAGS_LIST=$(parse 'var __tagsQueue' "jQuery.parseJSON( '{\(.*\)}' );" <<< "$PAGE") || return
TAGS_LIST=$(replace_all '},' $'},\n' <<< "$TAGS_LIST")
TAGS=$(parse_json 'name' <<< "$TAGS_LIST") || return
while read NAME; do
if ! matchi "^$NAME$" "$TAGS"; then
log_debug "Creating tag: '$NAME'"
PAGE=$(filecloud_curl_json -b "auth=$APIKEY" \
-d "name=$NAME" \
"$BASE_URL/tags-add_p.json") || return
PAGE=$(curl -b "auth=$APIKEY" "$BASE_URL/tags-manager.html") || return
TAGS_LIST=$(parse 'var __tagsQueue' "jQuery.parseJSON( '{\(.*\)}' );" <<< "$PAGE") || return
TAGS_LIST=$(replace_all '},' $'},\n' <<< "$TAGS_LIST")
TAGS=$(parse_json 'name' <<< "$TAGS_LIST") || return
if ! matchi "^$NAME$" "$TAGS"; then
log_error "Could not create tag '$NAME'."
return $ERR_FATAL
fi
fi
TAG_ID=$(parse "\"name\":\"$NAME\"" '"tkey":"\([^"]\+\)' <<< "$TAGS_LIST") || return
TAGS_ID=$TAGS_ID$'\n'$TAG_ID
done <<< "$NAMES"
strip_and_drop_empty_lines "$TAGS_ID"
}
# Upload a file to filecloud.io
# $1: cookie file
# $2: file path or remote url
# $3: remote filename
# stdout: download link
filecloud_upload() {
local -r COOKIE_FILE=$1
local -r FILE=$2
local -r DEST_FILE=$3
local -r MAX_SIZE=10485760000 # 10000 MiB
local -r BASE_URL='http://filecloud.io'
local PAGE UP_URL UKEY TAGS_ID STAT ERROR APIKEY_ENC
[ -n "$AUTH" ] || return $ERR_LINK_NEED_PERMISSIONS
local SZ=$(get_filesize "$FILE")
if [ "$SZ" -gt "$MAX_SIZE" ]; then
log_debug "File is bigger than $MAX_SIZE."
return $ERR_SIZE_LIMIT_EXCEEDED
fi
if [ -z "$APIKEY" -a -n "$AUTH" ]; then
APIKEY=$(filecloud_api_fetch_apikey "$AUTH") || return
fi
if [ -n "$TAGS" ]; then
TAGS=$(replace_all ',' $'\n' <<< "$TAGS")
TAGS=$(strip_and_drop_empty_lines "$TAGS")
TAGS_ID=$(filecloud_check_tag "$TAGS" "$APIKEY" "$BASE_URL") || return
fi
PAGE=$(filecloud_curl_json \
'https://filecloud.io/api-fetch_upload_url.api') || return
UP_URL=$(parse_json 'upload_url' <<< "$PAGE") || return
PAGE=$(curl_with_log \
-F "Filedata=@$FILE;filename=$DESTFILE" \
-F "akey=$APIKEY" \
"$UP_URL") || return
STAT=$(parse_json 'status' <<< "$PAGE") || return
if [ "$STAT" != 'ok' ]; then
ERROR=$(parse_json 'message' <<< "$PAGE") || return
log_error "Upload failed. Remote error: $ERROR."
return $ERR_FATAL
fi
UKEY=$(parse_json 'ukey' <<< "$PAGE") || return
if [ -n "$TAGS" ]; then
log_debug 'Setting tags...'
APIKEY_ENC=$(uri_encode_strict <<< "$APIKEY")
while read TAG_ID_CUR; do
PAGE=$(filecloud_curl_json -b "auth=$APIKEY_ENC" \
-F "ukey=$UKEY" \
-F "tkey=$TAG_ID_CUR" \
"$BASE_URL/tags-add_relation_p.json") || return
done <<< "$TAGS_ID"
fi
if [ -n "$PRIVATE" ]; then
log_debug 'Setting private flag...'
APIKEY_ENC=$(uri_encode_strict <<< "$APIKEY")
PAGE=$(filecloud_curl_json -b "auth=$APIKEY_ENC" \
-F "ukey=$UKEY" \
"$BASE_URL/files-change_atype_p.json") || return
fi
echo "$BASE_URL/$UKEY"
}
# List a filecloud.io tag
# $1: filecloud.io folder link
# $2: recurse subfolders (null string means not selected)
# stdout: list of links
filecloud_list() {
local -r URL=$1
local PAGE ERROR TKEY FILES_LIST NAMES LINKS
TKEY=$(parse . '/_\([[:alnum:]]\+\)$' <<< "$URL") || return
if [ -z "$APIKEY" -a -n "$AUTH" ]; then
APIKEY=$(filecloud_api_fetch_apikey "$AUTH") || return
fi
if [ -n "$APIKEY" ]; then
PAGE=$(filecloud_curl_json \
-d "akey=$APIKEY" \
-d "tkey=$TKEY" \
'https://filecloud.io/api-fetch_tag_details.api') || return
FILES_LIST=$(parse . '"files":\(.*\)},"status"' <<< "$PAGE") || return
else
PAGE=$(curl "$URL") || return
ERROR=$(parse_quiet '' ' \(.*\)$' <<< "$PAGE")
if match 'this tag is set as private' "$ERROR"; then
log_error 'This tag is set as private and is only viewable by the tag owner.'
return $ERR_LINK_NEED_PERMISSIONS
elif match 'no such tag' "$ERROR"; then
return $ERR_LINK_DEAD
elif [ -n "$ERROR" ]; then
log_error "Remote error: $ERROR"
return $ERR_FATAL
fi
FILES_LIST=$(parse 'var __filesQueue' "jQuery.parseJSON( '\(.*\)' );" <<< "$PAGE") || return
fi
NAMES=$(parse_json 'name' 'split' <<< "$FILES_LIST") || return
LINKS=$(parse_json 'url' 'split' <<< "$FILES_LIST") || return
list_submit "$LINKS" "$NAMES" || return
}
# Probe a download URL
# $1: cookie file (unused here)
# $2: filecloud.io url
# $3: requested capability list
# stdout: 1 capability per line
filecloud_probe() {
local -r URL=$2
local -r REQ_IN=$3
local PAGE FILE_SIZE UKEY
UKEY=$(parse . '/\([[:alnum:]]\+\)$' <<< "$URL") || return
PAGE=$(filecloud_curl_json \
-d "ukey=$UKEY" \
'https://filecloud.io/api-check_file.api') || return
REQ_OUT=c
if [[ $REQ_IN = *f* ]]; then
parse_json 'name' <<< "$PAGE" &&
REQ_OUT="${REQ_OUT}f"
fi
if [[ $REQ_IN = *s* ]]; then
FILE_SIZE=$(parse_json 'size' <<< "$PAGE") && \
translate_size "$FILE_SIZE" && REQ_OUT="${REQ_OUT}s"
fi
echo $REQ_OUT
}
filecore.sh 0000664 0000000 0000000 00000013103 13022750457 0013205 0 ustar 00root root 0000000 0000000 # filecore.co.nz module
# Copyright (c) 2014 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_FILECORE_REGEXP_URL='https\?://\(www\.\)\?\(fcore\.eu\|filecore\.co\.nz\)/'
MODULE_FILECORE_DOWNLOAD_OPTIONS="
AUTH_FREE,b,auth-free,a=USER:PASSWORD,Free account"
MODULE_FILECORE_DOWNLOAD_RESUME=yes
MODULE_FILECORE_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=no
MODULE_FILECORE_DOWNLOAD_SUCCESSIVE_INTERVAL=
MODULE_FILECORE_PROBE_OPTIONS=""
# Static function. Proceed with login
# $1: credentials string
# $2: cookie file
# $3: base url
filecore_login() {
local AUTH=$1
local COOKIE_FILE=$2
local BASE_URL=$3
local LOGIN_DATA LOGIN_RESULT NAME ERR
LOGIN_DATA='op=login&redirect=&login=$USER&password=$PASSWORD'
LOGIN_RESULT=$(post_login "$AUTH" "$COOKIE_FILE" "$LOGIN_DATA" "$BASE_URL") || return
# Set-Cookie: login xfss
NAME=$(parse_cookie_quiet 'login' < "$COOKIE_FILE")
if [ -n "$NAME" ]; then
log_debug "Successfully logged in as $NAME member"
return 0
fi
# Try to parse error
ERR=$(parse_tag_quiet 'class="err"' 'font' <<< "$LOGIN_RESULT")
[ -n "$ERR" ] || ERR=$(parse_tag_quiet "class='err'" 'div' <<< "$LOGIN_RESULT")
[ -n "$ERR" ] && log_error "Unexpected remote error: $ERR"
return $ERR_LOGIN_FAILED
}
# Output a filecore file download URL
# $1: cookie file (unused here)
# $2: filecore url
# stdout: real file download link
filecore_download() {
local -r COOKIE_FILE=$1
local -r URL=$2
local -r BASE_URL='http://filecore.co.nz'
local PAGE POST_URL PUBKEY RESP CAPTCHA_DATA ERR
local FORM_HTML FORM_OP FORM_ID FORM_RAND FORM_METHOD_F FORM_METHOD_P FORM_DD FORM_DS
if [ -n "$AUTH_FREE" ]; then
filecore_login "$AUTH_FREE" "$COOKIE_FILE" "$BASE_URL" || return
# Distinguish acount type (free or premium)
#PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL/?op=my_account") || return
fi
# Set-Cookie: fid
PAGE=$(curl --location --include -c "$COOKIE_FILE" -b "$COOKIE_FILE" -b 'lang=english' "$URL") || return
POST_URL=$(grep_http_header_location_quiet <<< "$PAGE" | last_line)
if [ -z "$POST_URL" ]; then
log_error "Unexpected content. Site updated?"
return $ERR_FATAL
fi
log_debug "post url: '$POST_URL'"
# The page you are looking for cannot be found.
if match 'www.filecore.co.nz | 404 - Page Cannot Be Found' "$PAGE"; then
return $ERR_LINK_DEAD
fi
FORM_HTML=$(grep_form_by_name "$PAGE" 'F1') || return
FORM_OP=$(parse_form_input_by_name 'op' <<< "$FORM_HTML") || return
FORM_ID=$(parse_form_input_by_name 'id' <<< "$FORM_HTML") || return
FORM_RAND=$(parse_form_input_by_name 'rand' <<< "$FORM_HTML") || return
FORM_METHOD_F=$(parse_form_input_by_name_quiet 'method_free' <<< "$FORM_HTML")
FORM_METHOD_P=$(parse_form_input_by_name_quiet 'method_premium' <<< "$FORM_HTML")
FORM_DD=$(parse_form_input_by_name 'down_direct' <<< "$FORM_HTML") || return
FORM_DS=$(parse_form_input_by_name 'down_script' <<< "$FORM_HTML") || return
# Check for Captcha
if match 'api\.solvemedia\.com' "$FORM_HTML"; then
log_debug 'Solve Media CAPTCHA found'
PUBKEY='VaxxhFnyEHmhP6jbvTSc0U0t0b8kzzUI'
RESP=$(solvemedia_captcha_process $PUBKEY) || return
{ read CHALL; read ID; } <<< "$RESP"
CAPTCHA_DATA="-d adcopy_challenge=$CHALL -d adcopy_response=none"
# If we reach here, it means that captcha is good
log_debug 'Correct captcha'
captcha_ack "$ID"
fi
PAGE=$(curl -b "$COOKIE_FILE" -b 'lang=english' \
-d "op=$FORM_OP" -d "id=$FORM_ID" -d "rand=$FORM_RAND" \
-d 'referer=' -d "method_free=$FORM_METHOD_F" \
-d "method_premium=$FORM_METHOD_P" $CAPTCHA_DATA \
-d "down_direct=$FORM_DD" -d "down_script=$FORM_DS" \
"$POST_URL") || return
# Get error message, if any
ERR=$(parse_tag_quiet ' ' b <<< "$PAGE" || return
}
# Probe a download URL
# $1: cookie file (unused here)
# $2: filecore url
# $3: requested capability list
# stdout: 1 capability per line
filecore_probe() {
local -r URL=$2
local -r REQ_IN=$3
local PAGE REQ_OUT FILE_SIZE
local -r BASE_URL='http://filecore.co.nz/?op=checkfiles'
PAGE=$(curl -b 'lang=english' --referer "$BASE_URL" \
-d 'op=checkfiles' -d 'process=check' \
--data-urlencode "list=$URL" "$BASE_URL") || return
if match '">Filename don'\''t match!FoundFound\([^<]*\)' <<< "$PAGE") && \
translate_size "$FILE_SIZE" && REQ_OUT="${REQ_OUT}s"
fi
echo $REQ_OUT
}
filedais.sh 0000664 0000000 0000000 00000011046 13022750457 0013201 0 ustar 00root root 0000000 0000000 # Plowshare filedais.com/anafile.com module
# Copyright (c) 2016 Ben Zho
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_FILEDAIS_REGEXP_URL='http://\(www\.\)\?\(filedais\|anafile\)\.com/.\+.html\?'
MODULE_FILEDAIS_DOWNLOAD_OPTIONS=""
MODULE_FILEDAIS_DOWNLOAD_RESUME=yes
MODULE_FILEDAIS_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=no
MODULE_FILEDAIS_DOWNLOAD_SUCCESSIVE_INTERVAL=
MODULE_FILEDAIS_PROBE_OPTIONS=""
# Output a filedais/anafile.com file download URL
# $1: cookie file
# $2: filedais/anafile.com url
# stdout: real file download link
filedais_download() {
local -r COOKIE_FILE=$1
local -r URL=$2
local -r BASE_URL=$(basename_url "$URL")
local PAGE LOCATION WAIT_TIME FILE_URL FORM_HTML
local PHP_URL FILE_ID FILE_NAME FORM_METHOD DANGER_DIV
PAGE=$(curl -L -i -c "$COOKIE_FILE" -b "$COOKIE_FILE" "$URL") || return
if match 'Software error:' "$PAGE"; then
return $ERR_LINK_TEMP_UNAVAILABLE
elif match 'File Not Found' "$PAGE"; then
return $ERR_LINK_DEAD
fi
LOCATION=$(grep_http_header_location_quiet <<< "$PAGE")
if match_remote_url "$LOCATION"; then
PHP_URL=$LOCATION
else
PHP_URL=$BASE_URL$LOCATION
fi
FORM_HTML=$(grep_form_by_order "$PAGE" 1) || return
FILE_ID=$(echo "$FORM_HTML" | parse_form_input_by_name 'id')
FILE_NAME=$(echo "$FORM_HTML" | parse_form_input_by_name 'fname')
FORM_METHOD=$(echo "$FORM_HTML" | parse_form_input_by_name 'method_free')
PAGE=$(curl -i -c "$COOKIE_FILE" -b "$COOKIE_FILE" \
-d 'op=download1' \
-d "id=$FILE_ID" \
-d "fname=$FILE_NAME" \
-d "method_free=$FORM_METHOD" \
$PHP_URL) || return
DANGER_DIV=$(parse_tag_quiet 'class="alert alert-danger"' 'div' <<< "$PAGE")
if [[ -n "$DANGER_DIV" ]]; then
if match 'You have to wait' "$DANGER_DIV"; then
WAIT_TIME=$(parse_quiet . ' ([0-9]+) seconds' <<< "$DANGER_DIV")
if [[ -n "$WAIT_TIME" ]]; then
echo $WAIT_TIME
fi
return $ERR_LINK_TEMP_UNAVAILABLE
else
log_debug "unexpected alert-danger: $DANGER_DIV"
fi
fi
FORM_HTML=$(grep_form_by_order "$PAGE" 1) || return
RAND=$(echo "$FORM_HTML" | parse_form_input_by_name 'rand') || return
WAIT_TIME=$(parse_tag 'Wait' 'span' <<< "$PAGE") || return
wait $WAIT_TIME || return
local PUBKEY WCI CHALLENGE WORD ID
PUBKEY=$(parse '\/recaptcha\/api\/' '?k=\([^"]\+\)' <<< "$PAGE" )
WCI=$(recaptcha_process $PUBKEY) || return
{ read WORD; read CHALLENGE; read ID; } <<< "$WCI"
PAGE=$(curl -i -c "$COOKIE_FILE" -b "$COOKIE_FILE" \
-d 'op=download2' \
-d "id=$FILE_ID" \
-d "referer=$PHP_URL" \
-d "recaptcha_challenge_field=$CHALLENGE" \
-d "recaptcha_response_field=$WORD" \
-d 'down_script=1' \
-d "rand=$RAND" \
-d "method_free=$FORM_METHOD" \
$PHP_URL) || return
if match '>Wrong captcha ' "$PAGE"; then
captcha_nack "$ID"
return $ERR_CAPTCHA
fi
captcha_ack "$ID"
parse_attr 'id="download1"' 'href' <<<"$PAGE"
return 0
}
# # Probe a download URL
# # $1: cookie file
# # $2: filedais.com/anafile.com url
# # $3: requested capability list
# # stdout: 1 capability per line
filedais_probe() {
local -r COOKIE_FILE=$1
local -r URL=$2
local -r REQ_IN=$3
local PAGE REQ_OUT FORM_HTML
PAGE=$(curl -L -c "$COOKIE_FILE" -b "$COOKIE_FILE" "$URL") || return
if matchi '>File Not Found<' "$PAGE"; then
return $ERR_LINK_DEAD
fi
# TODO: use op=checkfiles if we need size
FORM_HTML=$(grep_form_by_order "$PAGE" 1) || return
REQ_OUT='c'
if [[ "$REQ_IN" = *f* ]]; then
parse_form_input_by_name 'fname' <<< "$FORM_HTML" && REQ_OUT="${REQ_OUT}f"
fi
if [[ "$REQ_IN" = *i* ]]; then
parse_form_input_by_name 'id' <<< "$FORM_HTML" && REQ_OUT="${REQ_OUT}i"
fi
echo $REQ_OUT
}
filefactory.sh 0000664 0000000 0000000 00000031237 13022750457 0013734 0 ustar 00root root 0000000 0000000 # Plowshare filefactory.com module
# Copyright (c) 2013-2016 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_FILEFACTORY_REGEXP_URL='http://\(www\.\)\?filefactory\.com/'
MODULE_FILEFACTORY_DOWNLOAD_OPTIONS="
AUTH,a,auth,a=USER:PASSWORD,User account
LINK_PASSWORD,p,link-password,S=PASSWORD,Used in password-protected files"
MODULE_FILEFACTORY_DOWNLOAD_RESUME=no
MODULE_FILEFACTORY_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=no
MODULE_FILEFACTORY_DOWNLOAD_SUCCESSIVE_INTERVAL=
MODULE_FILEFACTORY_UPLOAD_OPTIONS="
AUTH,a,auth,a=USER:PASSWORD,User account
LINK_PASSWORD,p,link-password,S=PASSWORD,Protect a link with a password
FOLDER,,folder,s=FOLDER,Folder to upload files into
ASYNC,,async,,Asynchronous remote upload (only start upload, don't wait for link)
TOEMAIL,,email-to,e=EMAIL, field for notification email"
MODULE_FILEFACTORY_UPLOAD_REMOTE_SUPPORT=yes
MODULE_FILEFACTORY_LIST_OPTIONS=""
MODULE_FILEFACTORY_LIST_HAS_SUBFOLDERS=no
MODULE_FILEFACTORY_PROBE_OPTIONS=""
# Static function. Proceed with login.
# $1: authentication
# $2: cookie file
# $3: base URL
filefactory_login() {
local -r AUTH=$1
local -r COOKIE_FILE=$2
local -r BASE_URL=$3
local LOGIN_DATA LOGIN_RESULT LOCATION
LOGIN_DATA='loginEmail=$USER&loginPassword=$PASSWORD&Submit=Sign In'
LOGIN_RESULT=$(post_login "$AUTH" "$COOKIE_FILE" "$LOGIN_DATA" \
"$BASE_URL/member/signin.php" -i) || return
LOCATION=$(grep_http_header_location_quiet <<< "$LOGIN_RESULT")
if [ "$LOCATION" != '/account/' ]; then
return $ERR_LOGIN_FAILED
fi
}
# Output a filefactory.com file download URL
# $1: cookie file
# $2: filefactory.com url
# stdout: real file download link
filefactory_download() {
local -r COOKIE_FILE=$1
local -r URL=$(replace '://filefactory' '://www.filefactory' <<< "$2")
local -r BASE_URL='http://www.filefactory.com'
local PAGE LOCATION WAIT_TIME FILE_URL
if [ -n "$AUTH" ]; then
filefactory_login "$AUTH" "$COOKIE_FILE" "$BASE_URL" || return
fi
PAGE=$(curl -i -c "$COOKIE_FILE" -b "$COOKIE_FILE" "$URL") || return
LOCATION=$(grep_http_header_location_quiet <<< "$PAGE")
if [ -n "$LOCATION" ]; then
if match '/error\.php?code=25[14]' "$LOCATION"; then
return $ERR_LINK_DEAD
elif match '/error\.php?code=258' "$LOCATION"; then
return $ERR_LINK_NEED_PERMISSIONS
elif match '/error\.php?code=' "$LOCATION"; then
log_error "Remote error code: '${LOCATION:16}'"
return $ERR_FATAL
elif match '/preview/' "$LOCATION"; then
PAGE=$(curl -L -c "$COOKIE_FILE" -b "$COOKIE_FILE" "$URL") || return
fi
fi
if match 'Please enter the password' "$PAGE"; then
log_debug 'File is password protected'
if [ -z "$LINK_PASSWORD" ]; then
LINK_PASSWORD=$(prompt_for_password) || return
PAGE=$(curl -b "$COOKIE_FILE" -L \
-d "password=$LINK_PASSWORD" \
-d 'Submit=Continue' \
"$URL") || return
if match 'The Password entered was incorrect' "$PAGE"; then
return $ERR_LINK_PASSWORD_REQUIRED
fi
fi
fi
# If this an image ?
if match '[[:space:]]id=.image_main.[[:space:]]' "$PAGE"; then
FILE_URL=$(parse_attr 'Download Image' 'href' <<< "$PAGE") || return
else
WAIT_TIME=$(parse_attr 'data-delay' <<< "$PAGE") || return
wait $WAIT_TIME || return
FILE_URL=$(parse_attr 'data-href' <<< "$PAGE") || return
fi
# Redirect to /?code=275 on simultaneous download for non-premium, 1hr download limit
echo $FILE_URL
}
# Upload a file to filefactory.com
# $1: cookie file
# $2: input file (with full path)
# $3: remote filename
# stdout: download link
filefactory_upload() {
local -r COOKIE_FILE=$1
local -r FILE=$2
local -r DEST_FILE=$3
local -r BASE_URL='http://www.filefactory.com'
local -r MAX_SIZE=2097152000 # 2000 MiB
local PAGE AUTH_COOKIE FOLDERS FOLDER_HASH FILE_CODE
[ -n "$AUTH" ] || return $ERR_LINK_NEED_PERMISSIONS
if ! match_remote_url "$FILE"; then
local FILE_SIZE=$(get_filesize "$FILE")
if [ "$FILE_SIZE" -gt "$MAX_SIZE" ]; then
log_debug "File is bigger than $MAX_SIZE"
return $ERR_SIZE_LIMIT_EXCEEDED
fi
fi
filefactory_login "$AUTH" "$COOKIE_FILE" "$BASE_URL" || return
AUTH_COOKIE=$(parse_cookie 'auth' < "$COOKIE_FILE") || return
AUTH_COOKIE=$(uri_decode <<< "$AUTH_COOKIE") || return
if [ -n "$FOLDER" ]; then
log_debug 'Getting folder data...'
PAGE=$(curl -b "$COOKIE_FILE" -G \
-d 'm=getFolders' \
"$BASE_URL/manager2/get.php") || return
FOLDERS=$(parse_json 'title' 'split' <<< "$PAGE") || return
FOLDERS=$(delete_first_line <<< "$FOLDERS")
if ! match "^$FOLDER$" "$FOLDERS"; then
log_debug "Creating folder '$FOLDER'..."
PAGE=$(curl -b "$COOKIE_FILE" \
-H 'X-Requested-With: XMLHttpRequest' \
-d 'func=createFolder' \
-d "name=$FOLDER" \
"$BASE_URL/upload/ajax.php") || return
if ! match 'Your folder was created successfully' "$PAGE"; then
log_error 'Could not create folder'
else
FOLDER_HASH=$(parse_json 'hash' <<< "$PAGE") || return
fi
else
PAGE=$(replace ',"icon"' $',"icon"\n' <<< "$PAGE")
FOLDER_HASH=$(parse "\"title\":\"$FOLDER\"" '"id":"\([^"]\+\)' <<< "$PAGE") || return
fi
log_debug "Folder hash: '$FOLDER_HASH'"
fi
# Upload remote file
if match_remote_url "$FILE"; then
local TRY FILE_STATE LINK_DL
if ! match '^https\?://' "$FILE" && ! match '^ftp://' "$FILE"; then
log_error 'Unsupported protocol for remote upload.'
return $ERR_BAD_COMMAND_LINE
fi
if [ -z "$FOLDER" ]; then
FOLDER_HASH="0"
fi
PAGE=$(curl -b "$COOKIE_FILE" \
-d 'remoteUsername=' \
-d 'remotePassword=' \
-d "folder_name=$FOLDER_HASH" \
-d "remoteList=$FILE" \
-d 'Submit=Upload Files' \
"$BASE_URL/upload/remote.php") || return
if ! match 'The submitted link was successfully added to the remote queue.' "$PAGE"; then
log_error 'Could not set remote upload.'
return $ERR_FATAL
fi
# If this is an async upload, we are done
if [ -n "$ASYNC" ]; then
log_error 'Once remote upload completed, check your account for link.'
return $ERR_ASYNC_REQUEST
fi
TRY=1
while [ "$FILE_STATE" != 'Complete' ]; do
PAGE=$(curl -b "$COOKIE_FILE" \
-H 'X-Requested-With: XMLHttpRequest' \
"$BASE_URL/upload/status/modal.php?type=remote") || return
FILE_STATE=$(parse_attr 'data-sort-value' <<< "$PAGE") || return
[ "$FILE_STATE" = 'Complete' ] && break
if [ "$FILE_STATE" != 'Saving' ] && \
[ "$FILE_STATE" != 'Downloading' ] && \
[ "$FILE_STATE" != 'Pending' ]; then
[ "$FILE_STATE" = 'Failed' ] && log_error 'Upload failed.'
[ "$FILE_STATE" != 'Failed' ] && log_error "Upload failed. Unknown state: '$FILE_STATE'."
return $ERR_FATAL
fi
log_debug "Wait for server to download the file... [$((TRY++))]"
wait 15 || return
done
LINK_DL=$(parse_attr 'Download' 'href' <<< "$PAGE") || return
FILE_CODE=$(parse . '^.*/\([^/]\+\)/$' <<< "$LINK_DL") || return
# Do we need to rename the file?
if [ "$DEST_FILE" != 'dummy' ]; then
log_debug 'Renaming file...'
PAGE=$(curl -b "$COOKIE_FILE" \
-d 'm=editFile' \
-d "h=$FILE_CODE" \
-d "filename=$DEST_FILE" \
-d 'description=' \
"$BASE_URL/manager2/set.php") || return
if [ "$PAGE" != '{"status":"ok"}' ]; then
log_error 'Could not rename file.'
fi
fi
# Upload local file
else
PAGE=$(curl_with_log \
-F "cookie=$AUTH_COOKIE" \
-F "Filedata=@$FILE;filename=$DEST_FILE" \
'http://upload.filefactory.com/upload-beta.php') || return
if ! match '^[[:alnum:]]\+$' "$PAGE"; then
log_error 'Upload failed.'
return $ERR_FATAL
else
FILE_CODE="$PAGE"
fi
if [ -n "$FOLDER" ]; then
log_debug "Moving file to folder '$FOLDER'..."
PAGE=$(curl -b "$COOKIE_FILE" \
-H 'X-Requested-With: XMLHttpRequest' \
-d 'func=moveFiles' \
-d "folder=$FOLDER_HASH" \
-d "files=$FILE_CODE" \
"$BASE_URL/upload/ajax.php") || return
if ! match 'The selected files were moved successfully' "$PAGE"; then
log_error 'Could not move file into folder.'
fi
fi
fi
if [ -n "$LINK_PASSWORD" ]; then
log_debug 'Setting download password...'
PAGE=$(curl -b "$COOKIE_FILE" \
-d "m=setPassword" \
-d "p=$LINK_PASSWORD" \
-d "fi=$FILE_CODE" \
"$BASE_URL/manager2/set.php") || return
if [ "$PAGE" != '{"status":"ok","password":"yes"}' ]; then
log_error 'Could not set password.'
fi
fi
if [ -n "$TOEMAIL" ]; then
log_debug 'Sending link...'
PAGE=$(curl -b "$COOKIE_FILE" \
-d 'm=emailFile' \
-d "h=$FILE_CODE" \
-d "r=$TOEMAIL" \
-d 'message=' \
"$BASE_URL/manager2/set.php") || return
if [ "$PAGE" != '{"status":"ok"}' ]; then
log_error 'Could not send link.'
fi
fi
echo "$BASE_URL/file/$FILE_CODE/"
}
# Probe a download URL
# $1: cookie file (unused here)
# $2: filefactory.com url
# $3: requested capability list
# stdout: 1 capability per line
filefactory_probe() {
local -r URL=$(replace '://filefactory' '://www.filefactory' <<< "$2")
local -r REQ_IN=$3
local PAGE LOCATION FILE_SIZE REQ_OUT
PAGE=$(curl -i "$URL") || return
LOCATION=$(grep_http_header_location_quiet <<< "$PAGE")
REQ_OUT=c
if match '/error.php?code=' "$LOCATION"; then
local CODE=${LOCATION:16}
if [ "$CODE" = '251' ]; then
return $ERR_LINK_DEAD
elif [ "$CODE" = '254' ]; then
return $ERR_LINK_DEAD
elif [ "$CODE" = '258' ]; then
echo $REQ_OUT
return $ERR_LINK_NEED_PERMISSIONS
fi
log_error "Remote error code: '${LOCATION:16}'"
return $ERR_FATAL
fi
# All data is hidden for password protected files
if match 'Please enter the password' "$PAGE"; then
return $REQ_OUT
fi
if [[ $REQ_IN = *f* ]]; then
parse 'file_name' \
' | \([^<]*\)' <<< "$PAGE") \
&& FILE_SIZE=$(replace 'B' 'iB' <<< $FILE_SIZE) \
&& translate_size "$FILE_SIZE" && REQ_OUT="${REQ_OUT}s"
fi
if [[ $REQ_IN = *i* ]]; then
parse . 'net/\([[:alnum:]]\+\)' <<< "$URL" && REQ_OUT="${REQ_OUT}i"
fi
echo $REQ_OUT
}
upstore.sh 0000664 0000000 0000000 00000024135 13022750457 0013125 0 ustar 00root root 0000000 0000000 # Plowshare upstore module
# Copyright (c) 2013-2014 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_UPSTORE_REGEXP_URL='https\?://\(www\.\)\?upsto\(\.re\|re\.net\)/'
MODULE_UPSTORE_DOWNLOAD_OPTIONS="
AUTH,a,auth,a=EMAIL:PASSWORD,User account"
MODULE_UPSTORE_DOWNLOAD_RESUME=no
MODULE_UPSTORE_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=no
MODULE_UPSTORE_DOWNLOAD_SUCCESSIVE_INTERVAL=900
MODULE_UPSTORE_UPLOAD_OPTIONS="
AUTH,a,auth,a=EMAIL:PASSWORD,User account
SHORT_LINK,,short-link,,Produce short link like http://upsto.re/XXXXXX"
MODULE_UPSTORE_UPLOAD_UPLOAD_REMOTE_SUPPORT=no
MODULE_UPSTORE_PROBE_OPTIONS=""
# Static function. Proceed with login
# $1: authentication
# $2: cookie file
# $3: base url
# stdout: account type ("free" or "premium") on success
upstore_login() {
local -r AUTH=$1
local -r COOKIE_FILE=$2
local -r BASE_URL=$3
local LOGIN_DATA PAGE STATUS NAME
LOGIN_DATA='email=$USER&password=$PASSWORD&send=Login'
PAGE=$(post_login "$AUTH" "$COOKIE_FILE" "$LOGIN_DATA" \
"$BASE_URL/account/login/" -b 'lang=en' --location) || return
STATUS=$(parse_cookie_quiet 'usid' < "$COOKIE_FILE")
[ -n "$STATUS" ] || return $ERR_LOGIN_FAILED
# Determine account type and user name
NAME=$(parse '"/account/"' '^[[:space:]]*\(.*\)$' 1 <<< "$PAGE")
if match '="/premium/">renew' "$PAGE"; then
echo 'premium'
else
echo 'free'
fi
log_debug "Successfully logged in as member '$NAME'"
}
# Switch language to english
# $1: cookie file
# $2: base URL
upstore_switch_lang() {
curl -c "$1" -o /dev/null "$2/?lang=en" || return
}
# Output a file URL to download from Upsto.re
# $1: cookie file
# $2: upstore url
# stdout: real file download link
# file name
upstore_download() {
local -r COOKIE_FILE=$1
local -r URL=$2
local -r BASE_URL='https://upstore.net'
local PAGE HASH ERR WAIT JSON
# extract file ID from URL
# http://upstore.net/xyz
# http://upsto.re/xyz
HASH=$(echo "$URL" | parse '' 'upsto[^/]\+/\([[:alnum:]]\+\)') || return
log_debug "File ID: '$HASH'"
upstore_switch_lang "$COOKIE_FILE" "$BASE_URL" || return
if [ -n "$AUTH" ]; then
ACC=$(upstore_login "$AUTH" "$COOKIE_FILE" "$BASE_URL") || return
fi
PAGE=$(curl -b "$COOKIE_FILE" -c "$COOKIE_FILE" -b 'lang=en' "$BASE_URL/$HASH") || return
ERR=$(echo "$PAGE" | parse_tag_quiet 'span class="error"' span) || return
if [ -n "$ERR" ]; then
[ "$ERR" = 'File not found' ] && return $ERR_LINK_DEAD
# File size is larger than 1 GB. Unfortunately, it can be downloaded only with premium
if [[ "$ERR" = 'File size is larger than'* ]]; then
return $ERR_LINK_NEED_PERMISSIONS
fi
log_error "Unexpected remote error: $ERR"
return $ERR_FATAL
fi
if [ -n "$AUTH" -a "$ACC" = 'premium' ]; then
JSON=$(curl -b "$COOKIE_FILE" -b 'lang=en' --referer "$URL" \
-H 'X-Requested-With: XMLHttpRequest' \
-d "hash=$HASH" \
-d 'antispam=' \
-d 'js=1' "$BASE_URL/load/premium/") || return
parse_json 'ok' <<< "$JSON" || return
return 0
fi
PAGE=$(curl -b "$COOKIE_FILE" -d "hash=$HASH" \
-d 'free=Slow+download' "$BASE_URL/$HASH") || return
# Error message is inside or tag
ERR=$(echo "$PAGE" | parse_quiet 'class="error"' '>\([^<]\+\)Download file' 'href' || return
echo "$PAGE" | parse_tag '^[[:space:]]*Download file ' 'b' | html_to_utf8 || return
}
# Upload a file to Upstore.net
# $1: cookie file
# $2: input file (with full path)
# $3: remote filename
upstore_upload() {
local -r COOKIE_FILE=$1
local -r FILE=$2
local -r DEST_FILE=$3
local -r BASE_URL='http://upstore.net'
local PAGE JSON UP_URL FILE_SIZE MAX_SIZE HASH OPT_USER
upstore_switch_lang "$COOKIE_FILE" "$BASE_URL" || return
if [ -n "$AUTH" ]; then
upstore_login "$AUTH" "$COOKIE_FILE" "$BASE_URL" >/dev/null || return
fi
PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL") || return
UP_URL=$(echo "$PAGE" | parse 'script' "'\([^']\+\)',") || return
MAX_SIZE=$(echo "$PAGE" | parse 'sizeLimit' \
'[[:blank:]]\([[:digit:]]\+\),') || return
log_debug "URL: '$UP_URL'"
log_debug "Max size: '$MAX_SIZE'"
# Check file size
SIZE=$(get_filesize "$FILE") || return
if [ $SIZE -gt $MAX_SIZE ]; then
log_debug "File is bigger than $MAX_SIZE"
return $ERR_SIZE_LIMIT_EXCEEDED
fi
if [ -n "$AUTH" ]; then
local USER_ID
USER_ID=$(echo "$PAGE" | parse 'usid' ":[[:blank:]]'\([^']\+\)'") || return
log_debug "User ID: '$USER_ID'"
OPT_USER="-F usid=$USER_ID"
fi
# Note: Uses SWF variant of Uploadify v2.1.4 (jquery.uploadify)
JSON=$(curl_with_log --user-agent 'Shockwave Flash' -b "$COOKIE_FILE" \
-F "Filename=$DEST_FILE" \
-F 'folder=/' \
$OPT_USER \
-F 'fileext=*.*' \
-F "file=@$FILE;type=application/octet-stream;filename=$DEST_FILE" \
-F 'Upload=Submit Query' \
"$UP_URL") || return
HASH=$(echo "$JSON" | parse_json 'hash') || return
if [ -n "$SHORT_LINK" ]; then
echo "http://upsto.re/$HASH"
else
echo "$BASE_URL/$HASH"
fi
}
# Probe a download URL
# $1: cookie file (unused here)
# $2: Upstore url
# $3: requested capability list
# stdout: 1 capability per line
upstore_probe() {
local -r URL=$2
local -r REQ_IN=$3
local PAGE REQ_OUT FILE_SIZE
PAGE=$(curl --location -b 'lang=en' "$URL") || return
match 'File not found' "$PAGE" && return $ERR_LINK_DEAD
REQ_OUT=c
if [[ $REQ_IN = *f* ]]; then
echo "$PAGE" | parse '\([^<]\+\)<' 1 | \
html_to_utf8 && REQ_OUT="${REQ_OUT}f"
fi
if [[ $REQ_IN = *s* ]]; then
FILE_SIZE=$(echo "$PAGE" | parse '.
MODULE_UPTOBOX_REGEXP_URL='https\?://\(www\.\)\?uptobox\.com/'
MODULE_UPTOBOX_DOWNLOAD_OPTIONS="
AUTH,a,auth,a=USER:PASSWORD,User account"
MODULE_UPTOBOX_DOWNLOAD_RESUME=yes
MODULE_UPTOBOX_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=no
MODULE_UPTOBOX_DOWNLOAD_SUCCESSIVE_INTERVAL=
MODULE_UPTOBOX_UPLOAD_OPTIONS="
AUTH,a,auth,a=USER:PASSWORD,User account"
MODULE_UPTOBOX_UPLOAD_REMOTE_SUPPORT=no
MODULE_UPTOBOX_PROBE_OPTIONS=""
# Static function. Proceed with login
# $1: credentials string
# $2: cookie file
# $3: base url
uptobox_login() {
local AUTH=$1
local COOKIE_FILE=$2
local POST_URL="$3/logarithme"
local LOGIN_DATA LOGIN_RESULT SID ERR
LOGIN_DATA='op=login&redirect=&login=$USER&password=$PASSWORD'
LOGIN_RESULT=$(post_login "$AUTH" "$COOKIE_FILE" "$LOGIN_DATA" "$POST_URL") || return
# {"success" : "OK", "msg" : "please wait..."}
# Set-Cookie: xfss
SID=$(parse_cookie_quiet 'xfss' < "$COOKIE_FILE")
if [ -n "$SID" ]; then
log_debug 'Successfully logged in'
return 0
fi
# Try to parse error
ERR=$(parse_tag_quiet 'class="err"' 'font' <<< "$LOGIN_RESULT")
[ -n "$ERR" ] || ERR=$(parse_tag_quiet "class='err'" 'div' <<< "$LOGIN_RESULT")
[ -n "$ERR" ] && log_error "Unexpected remote error: $ERR"
return $ERR_LOGIN_FAILED
}
# Check for and handle "heavy-user captcha"
# $1: full content of initial page
# $2: cookie file
# $3: base url
# stdout: full content of actual download page
uptobox_cloudflare() {
local -r COOKIE_FILE=$2
local -r BASE_URL=$3
local PAGE=$1
# check for captcha
# Attention Required! | CloudFlare
if [[ $(parse_tag 'title' <<< "$PAGE") = *CloudFlare* ]]; then
local -r PUBKEY='6LeT6gcAAAAAAAZ_yDmTMqPH57dJQZdQcu6VFqog'
local WORD CHALLENGE ID RESP FORM FORM_ACTION FORM_ID
log_debug 'Cloudflare captcha found'
FORM=$(grep_form_by_id "$PAGE" 'challenge-form') || return
FORM_ACTION=$(parse_form_action "$FORM") || return
FORM_ID=$(parse_form_input_by_id 'id' <<< "$FORM") || return
RESP=$(recaptcha_process $PUBKEY) || return
{ read WORD; read CHALLENGE; read ID; } <<< "$RESP"
PAGE=$(curl -b "$COOKIE_FILE" -b 'lang=english' \
-d "recaptcha_challenge_field=$CHALLENGE" \
-d "recaptcha_response_field=$WORD" \
-d 'message=' -d "id=$FORM_ID" \
"${BASE_URL}/${FORM_ACTION}") || return
fi
echo "$PAGE"
}
# Output a uptobox file download URL
# $1: cookie file (account only)
# $2: uptobox url
# stdout: real file download link
uptobox_download() {
local -r COOKIE_FILE=$1
local -r URL=$(replace '://www.' '://' <<< "$2")
local -r BASE_URL='http://uptobox.com'
local PAGE WAIT_TIME CODE PREMIUM CAPTCHA_DATA CAPTCHA_ID
local FORM_HTML FORM_OP FORM_USR FORM_ID FORM_FNAME FORM_RAND FORM_METHOD FORM_DD FORM_SZ
if [ -n "$AUTH" ]; then
uptobox_login "$AUTH" "$COOKIE_FILE" 'https://login.uptobox.com' || return
# Distinguish acount type (free or premium)
PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL/?op=my_account") || return
# Opposite is: 'Upgrade to premium';
if match 'Renew premium' "$PAGE"; then
local DIRECT_URL
PREMIUM=1
DIRECT_URL=$(curl -I -b "$COOKIE_FILE" "$URL" | grep_http_header_location_quiet)
if [ -n "$DIRECT_URL" ]; then
echo "$DIRECT_URL"
return 0
fi
PAGE=$(curl -i -b "$COOKIE_FILE" -b 'lang=english' "$URL") || return
else
# Should wait 45s instead of 60s!
PAGE=$(curl -b "$COOKIE_FILE" -b 'lang=english' "$URL") || return
fi
else
PAGE=$(curl -b 'lang=english' "$URL") || return
fi
PAGE=$(uptobox_cloudflare "$PAGE" "$COOKIE_FILE" "$BASE_URL") || return
# To give priority to premium users, you have to wait x minutes, x seconds
if match '>To give priority to premium users, you have to wait' "$PAGE"; then
local MINS
MINS=$(parse_quiet 'you have to wait[[:space:]]' \
'[[:space:]]\([[:digit:]]\+\) minute' <<< "$PAGE") || MINS=60
echo $((MINS*60))
return $ERR_LINK_TEMP_UNAVAILABLE
fi
# The file you were looking for could not be found, sorry for any inconvenience
if matchi 'Maintenance ' "$PAGE"; then
log_error 'Remote error: maintenance'
echo 3600
return $ERR_LINK_TEMP_UNAVAILABLE
fi
# Send (post) form
# FIXME later: fname
FORM_HTML=$(grep_form_by_name "$PAGE" 'F1') || return
FORM_OP=$(parse_form_input_by_name 'op' <<< "$FORM_HTML") || return
FORM_ID=$(parse_form_input_by_name 'id' <<< "$FORM_HTML") || return
FORM_DD=$(parse_form_input_by_name_quiet 'down_direct' <<< "$FORM_HTML")
FORM_RAND=$(parse_form_input_by_name 'rand' <<< "$FORM_HTML") || return
FORM_METHOD=$(parse_form_input_by_name_quiet 'method_free' <<< "$FORM_HTML")
# Handle premium downloads
if [ "$PREMIUM" = '1' ]; then
local FILE_URL
FORM_RAND=$(parse_form_input_by_name 'rand' <<< "$FORM_HTML") || return
PAGE=$(curl -b "$COOKIE_FILE" -b 'lang=english' \
-d "op=$FORM_OP" \
-d "id=$FORM_ID" \
-d "rand=$FORM_RAND" \
-d 'method_free=' \
-d "down_direct=${FORM_DD:+1}" \
-d 'referer=' \
-d "method_premium=$FORM_METHOD" "$URL") || return
# Click here to start your download
FILE_URL=$(parse_attr '/d/' 'href' <<< "$PAGE")
if match_remote_url "$FILE_URL"; then
echo "$FILE_URL"
return 0
fi
fi
# Check for enforced download limits
if match '' "$PAGE"; then
# You have reached the download-limit: 1024 Mb for last 1 days
if match 'reached the download.limit' "$PAGE"; then
echo 3600
return $ERR_LINK_TEMP_UNAVAILABLE
# You have to wait X minutes, Y seconds till next download
# You have to wait Y seconds till next download
elif matchi 'You have to wait' "$PAGE"; then
local HOURS MINS SECS
HOURS=$(parse_quiet '>You have to wait' \
'[[:space:]]\([[:digit:]]\+\) hour' <<< "$PAGE") || HOURS=0
MINS=$(parse_quiet '>You have to wait' \
'[[:space:]]\([[:digit:]]\+\) minute' <<< "$PAGE") || MINS=0
SECS=$(parse '>You have to wait' \
'[[:space:]]\([[:digit:]]\+\) second' 2>/dev/null <<< "$PAGE") || SECS=1
echo $(( HOURS * 3600 + MINS * 60 + SECS ))
return $ERR_LINK_TEMP_UNAVAILABLE
elif match 'Expired download session' "$PAGE"; then
log_error 'Remote error: expired session'
return $ERR_LINK_TEMP_UNAVAILABLE
fi
fi
if match '[^-]Enter code above\|//api\.solvemedia\.com' "$PAGE"; then
local RESP CHALL
RESP=$(solvemedia_captcha_process 'dAlo2UnjILCt709UJOmCZvfUBFxms5vw') || return
{ read CHALL; read CAPTCHA_ID; } <<< "$RESP"
CAPTCHA_DATA="-F adcopy_challenge=$CHALL -F adcopy_response=manual_challenge"
fi
# Is this still needed?
FORM_USR=$(parse_form_input_by_name_quiet 'usr_login' <<< "$FORM_HTML")
WAIT_TIME=$(parse_tag_quiet '[Ww]ait.*seconds' 'span' <<< "$FORM_HTML")
if [ -n "$WAIT_TIME" ]; then
wait $((WAIT_TIME + 1)) || return
fi
PAGE=$(curl -b "$COOKIE_FILE" -b 'lang=english' \
-F "op=$FORM_OP" \
-F "id=$FORM_ID" \
-F "rand=$FORM_RAND" \
${FORM_USR:+"-F usr_login=$FORM_USR"} \
-F "referer=$URL" \
-F "method_free=$FORM_METHOD" \
-F 'method_premium=' \
$CAPTCHA_DATA \
-F "down_direct=$FORM_DD" \
"$URL") || return
# Invalid captcha
if [ -n "$CAPTCHA_DATA" ]; then
if match 'Invalid captcha' "$PAGE"; then
captcha_nack $CAPTCHA_ID
return $ERR_CAPTCHA
else
captcha_ack $CAPTCHA_ID
log_debug 'Correct captcha'
fi
elif match '' "$PAGE"; then
local ERR=$(parse_tag 'class="err">' p <<< "$PAGE")
if match 'Skipped countdown' "$ERR"; then
# Can do a retry
log_debug "Remote error: $ERR"
return $ERR_NETWORK
fi
log_error "Unexpected remote error: $ERR"
return $ERR_FATAL
fi
parse 'start your download' 'href="\([^"]\+\)"' -2 <<< "$PAGE" || return
echo "$FORM_FNAME"
}
# Upload a file to uptobox.com
# $1: cookie file
# $2: input file (with full path)
# $3: remote filename
# stdout: download link + delete link
uptobox_upload() {
local -r COOKIE_FILE=$1
local -r FILE=$2
local -r DESTFILE=$3
local -r BASE_URL='http://uptobox.com'
local PAGE URL UPLOAD_ID USER_TYPE DL_URL DEL_URL
local FORM_HTML FORM_ACTION FORM_UTYPE FORM_TMP_SRV FORM_BUTTON FORM_SESS
local FORM_FN FORM_ST FORM_OP
if [ -n "$AUTH" ]; then
uptobox_login "$AUTH" "$COOKIE_FILE" 'https://login.uptobox.com' || return
fi
PAGE=$(curl -b "$COOKIE_FILE" -b 'lang=english' "$BASE_URL") || return
# "anon", "reg", "prem"
USER_TYPE=$(parse 'var utype' "='\([^']*\)" <<< "$PAGE") || return
log_debug "User type: '$USER_TYPE'"
FORM_HTML=$(grep_form_by_name "$PAGE" 'file') || return
FORM_ACTION=$(parse_form_action <<< "$PAGE") || return
FORM_UTYPE=$(parse_form_input_by_name 'upload_type' <<< "$PAGE") || return
FORM_TMP_SRV=$(parse_form_input_by_name 'srv_tmp_url' <<< "$PAGE") || return
FORM_BUTTON=$(parse_form_input_by_name 'submit_btn' <<< "$PAGE") || return
FORM_SESS=$(parse_form_input_by_name_quiet 'sess_id' <<< "$PAGE")
# xupload.js
UPLOAD_ID=$(random dec 12) || return
PAGE=$(curl_with_log \
-F "upload_type=$FORM_UTYPE" \
-F "sess_id=$FORM_SESS" \
-F "srv_tmp_url=$FORM_TMP_SRV" \
-F "file_1=@$FILE;type=application/octet-stream;filename=$DESTFILE" \
-F 'tos=1' \
-F "submit_btn=$FORM_BUTTON" \
"${FORM_ACTION%%\?*}?X-Progress-ID=${UPLOAD_ID}&upload_id=${UPLOAD_ID}&js_on=1&utype=${USER_TYPE}&upload_type=${FORM_UTYPE}" | break_html_lines) || return
FORM_ACTION=$(parse_form_action <<< "$PAGE") || return
FORM_FN=$(parse_tag "name='fn'" textarea <<< "$PAGE") || return
FORM_ST=$(parse_tag "name='st'" textarea <<< "$PAGE") || return
FORM_OP=$(parse_tag "name='op'" textarea <<< "$PAGE") || return
if [ "$FORM_ST" = 'OK' ]; then
PAGE=$(curl -b 'lang=english' -d "fn=$FORM_FN" -d "st=$FORM_ST" \
-d "op=$FORM_OP" "$FORM_ACTION") || return
# Parse and output download + delete link
parse_attr 'Download File' 'value' <<< "$PAGE" || return
parse_attr 'killcode' 'value' <<< "$PAGE" || return
return 0
fi
log_error "Unexpected status: $FORM_ST"
return $ERR_FATAL
}
# Probe a download URL
# $1: cookie file (unused here)
# $2: uptobox url
# $3: requested capability list
# stdout: 1 capability per line
uptobox_probe() {
local -r URL=$2
local -r REQ_IN=$3
local PAGE REQ_OUT FILE_SIZE
PAGE=$(curl -L -b 'lang=english' "$URL") || return
PAGE=$(uptobox_cloudflare "$PAGE" "$COOKIE_FILE" "$BASE_URL") || return
# Not nice!
# No such file No such user exist File not found
# The file you were looking for could not be found, sorry for any inconvenience
if matchi '.
MODULE_VID_AG_REGEXP_URL='https\?://\(www\.\)\?vid\.ag/'
MODULE_VID_AG_UPLOAD_OPTIONS="
AUTH,a,auth,a=USER:PASSWORD,User account (mandatory)
DESCRIPTION,d,description,S=DESCRIPTION,Set file description
PRIVATE_FILE,,private,,Mark file for personal use only
TAGS,,tags,l=LIST,Provide list of tags (comma separated)
TITLE,,title,s=TITLE,Set file title"
MODULE_VID_AG_UPLOAD_REMOTE_SUPPORT=no
# Static function. Proceed with login
# $1: credentials string
# $2: cookie file
# $3: base url
vid_ag_login() {
local AUTH=$1
local COOKIE_FILE=$2
local BASE_URL=$3
local LOGIN_DATA LOGIN_RESULT NAME ERR
LOGIN_DATA='op=login&redirect=&login=$USER&password=$PASSWORD&btn=Enter'
LOGIN_RESULT=$(post_login "$AUTH" "$COOKIE_FILE" "$LOGIN_DATA" "$BASE_URL") || return
# Set-Cookie: login xfsts
NAME=$(parse_cookie_quiet 'login' < "$COOKIE_FILE")
if [ -n "$NAME" ]; then
log_debug "Successfully logged in as $NAME member"
return 0
fi
return $ERR_LOGIN_FAILED
}
# Upload a file to vidzi.tv
# $1: cookie file
# $2: input file (with full path)
# $3: remote filename
# stdout: download link
vid_ag_upload() {
local -r COOKIE_FILE=$1
local -r FILE=$2
local -r DESTFILE=$3
local -r BASE_URL='http://vid.ag'
local CV PAGE SESS UPLOAD_ID TAGS_STR
local FORM_HTML FORM_ACTION FORM_UTYPE FORM_SESS FORM_SRV_ID FORM_DSK_ID
local FORM_FN FORM_ST FORM_OP
# Check for allowed file extensions
if [ "${DESTFILE##*.}" = "$DESTFILE" ]; then
log_error 'Filename has no extension. It is not allowed by hoster, you must specify video file.'
return $ERR_BAD_COMMAND_LINE
elif ! match '\.\(avi\|mkv\|mpg\|mpeg\|vob\|wmv\|flv\|mp4\|mov\|m2v\|divx\|xvid\|3gp\|webm\|og[vg]\)$' \
"$DESTFILE"; then
log_error '*** File extension is checked by hoster. There is a restricted "allowed list", see hoster.'
log_debug '*** Allowed list (part): 3gp avi divx flv m2v mkv mov mp4 mpeg mpg ogg ogv vob webm wmv.'
return $ERR_BAD_COMMAND_LINE
fi
if CV=$(storage_get 'cookie_file'); then
echo "$CV" >"$COOKIE_FILE"
# Check for expired session
PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL/?op=my_account") || return
if ! match '>\(Username\|Account balance\):<' "$PAGE"; then
log_error 'Expired session, delete cache entry'
storage_set 'cookie_file'
echo 1
return $ERR_LINK_TEMP_UNAVAILABLE
fi
SESS=$(parse_cookie 'xfsts' < "$COOKIE_FILE")
log_debug "session (cached): '$SESS'"
elif [ -n "$AUTH" ]; then
vid_ag_login "$AUTH" "$COOKIE_FILE" "$BASE_URL" || return
storage_set 'cookie_file' "$(cat "$COOKIE_FILE")"
SESS=$(parse_cookie 'xfsts' < "$COOKIE_FILE")
log_debug "session (new): '$SESS'"
else
return $ERR_LINK_NEED_PERMISSIONS
fi
PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL/?op=upload") || return
FORM_HTML=$(grep_form_by_name "$PAGE" 'file') || return
FORM_ACTION=$(parse_form_action <<< "$PAGE") || return
FORM_SESS=$(parse_form_input_by_name_quiet 'sess_id' <<< "$PAGE")
FORM_SRV_ID=$(parse_form_input_by_name 'srv_id' <<< "$PAGE") || return
FORM_DSK_ID=$(parse_form_input_by_name 'disk_id' <<< "$PAGE") || return
FORM_UTYPE=$(parse_form_input_by_name 'utype' <<< "$PAGE") || return
TAGS_STR=''
if [ "${#TAGS[@]}" -gt 0 ]; then
for T in "${TAGS[@]}"; do TAGS_STR="$TAGS_STR,$T"; done
TAGS_STR=${TAGS_STR#,}
log_debug "Using tags: '$(replace_all ',' \'' '\' <<< "$TAGS_STR")'"
fi
if [ -z "$PRIVATE_FILE" ]; then
PRIVATE_FILE=1
else
PRIVATE_FILE=0
fi
UPLOAD_ID=$(random dec 12) || return
PAGE=$(curl_with_log \
-F "utype=$FORM_UTYPE" \
-F "sess_id=$FORM_SESS" \
-F "srv_id=$FORM_SRV_ID" \
-F "disk_id=$FORM_DSK_ID" \
-F "file=@$FILE;filename=$DESTFILE" \
--form-string "file_title=$TITLE" \
--form-string "file_descr=$DESCRIPTION" \
--form-string "tags=$TAGS_STR" \
-F "file_category=0" \
-F "file_public=$PRIVATE_FILE" \
-F 'tos=1' \
"${FORM_ACTION}${UPLOAD_ID}&disk_id=${FORM_DSK_ID}" | break_html_lines) || return
FORM_ACTION=$(parse_form_action <<< "$PAGE") || return
FORM_FN=$(parse_tag "name='fn'" textarea <<< "$PAGE") || return
FORM_ST=$(parse_tag "name='st'" textarea <<< "$PAGE") || return
FORM_OP=$(parse_tag "name='op'" textarea <<< "$PAGE") || return
if [ "$FORM_ST" = 'OK' ]; then
PAGE=$(curl \
-d "fn=$FORM_FN" -d "st=$FORM_ST" -d "op=$FORM_OP" \
"$FORM_ACTION") || return
parse_attr '>File Title:<' 'href' <<< "$PAGE" || return
return 0
fi
log_error "Unexpected status: $FORM_ST"
return $ERR_FATAL
}
videowood_tv.sh 0000664 0000000 0000000 00000011656 13022750457 0014140 0 ustar 00root root 0000000 0000000 # Plowshare videowood.tv module
# Copyright (c) 2016 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_VIDEOWOOD_TV_REGEXP_URL='https\?://\(www\.\)\?videowood\.tv/'
MODULE_VIDEOWOOD_TV_UPLOAD_OPTIONS="
AUTH,a,auth,a=USER:PASSWORD,User account"
MODULE_VIDEOWOOD_TV_UPLOAD_REMOTE_SUPPORT=no
# Static function. Proceed with login
# $1: authentication
# $2: cookie file
# $3: base URL
# stdout: account type ("free") on success or 'expired' to renew session.
videowood_tv_login() {
local -r AUTH=$1
local -r COOKIE_FILE=$2
local -r BASE_URL=$3
local CV LOCATION SESS MSG PAGE CSRF_TOKEN LOGIN_DATA NAME
if CV=$(storage_get 'cookie_file'); then
echo "$CV" >"$COOKIE_FILE"
# Check for expired session.
LOCATION=$(curl -i -b "$COOKIE_FILE" "$BASE_URL/my-videos" \
| grep_http_header_location_quiet) || return
if match "$BASE_URL/login" "$LOCATION"; then
log_error 'Expired session, delete cache entry'
storage_set 'cookie_file'
echo 'expired'
return 0
fi
SESS=$(parse_cookie 'videowood_sess' < "$COOKIE_FILE") || return
log_debug "session (cached): '$SESS'"
MSG='reused login for'
else
PAGE=$(curl -c "$COOKIE_FILE" "$BASE_URL/login") || return
CSRF_TOKEN=$(parse_attr 'name="csrf_token"' 'content' <<< "$PAGE") || return
LOGIN_DATA="_token=$CSRF_TOKEN&username=\$USER&password=\$PASSWORD"
LOCATION=$(post_login "$AUTH" "$COOKIE_FILE" "$LOGIN_DATA" "$BASE_URL/login" \
-i -b "$COOKIE_FILE" | grep_http_header_location_quiet) || return
# If successful, then we should redirected to my-videos.
if ! match "$BASE_URL/my-videos" "$LOCATION"; then
return $ERR_LOGIN_FAILED
fi
storage_set 'cookie_file' "$(cat "$COOKIE_FILE")"
SESS=$(parse_cookie 'videowood_sess' < "$COOKIE_FILE") || return
log_debug "session (new): '$SESS'"
MSG='logged in as'
fi
PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL/my-videos") || return
NAME=$(parse_quiet 'alt="User"' '^\(.*\)$' 2 <<< "$PAGE")
log_debug "Successfully $MSG 'free' member '$NAME'"
echo 'free'
}
# Upload a file to videowood.tv
# $1: cookie file
# $2: input file (with full path)
# $3: remote filename
# stdout: download link
videowood_tv_upload() {
local -r COOKIE_FILE=$1
local -r FILE=$2
local -r DESTFILE=$3
local -r BASE_URL='http://videowood.tv'
local -r UPLOAD_URL='http://upl.videowood.tv'
local SIZE ACCOUNT PAGE UPLOAD_ID JSON STATUS
# Check for allowed file extensions
if [ "${DESTFILE##*.}" = "$DESTFILE" ]; then
log_error 'Filename has no extension. It is not allowed by hoster, you must specify video file.'
return $ERR_BAD_COMMAND_LINE
elif ! match '\.\(avi\|rmvb\|mkv\|flv\|mp4\|wmv\|mpeg\|mpg\|mov\|srt\)$' "$DESTFILE"; then
log_error '*** File extension is checked by hoster. There is a restricted "allowed list", see hoster.'
log_debug '*** Allowed list (part): avi rmvb mkv flv mp4 wmv mpeg mpg mov srt.'
return $ERR_BAD_COMMAND_LINE
fi
# Check for allowed file size
local -r MAX_SIZE=5368709120 # 5GiB
SIZE=$(get_filesize "$FILE")
if [ $SIZE -gt $MAX_SIZE ]; then
log_debug "File is bigger than $MAX_SIZE"
return $ERR_SIZE_LIMIT_EXCEEDED
fi
if [ -n "$AUTH" ]; then
ACCOUNT=$(videowood_tv_login "$AUTH" "$COOKIE_FILE" "$BASE_URL") || return
# Note: If account session is expired then renew it.
[ "$ACCOUNT" = 'expired' ] && echo 1 && return $ERR_LINK_TEMP_UNAVAILABLE
fi
PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL") || return
UPLOAD_ID=$(parse "'upload_id':" "'upload_id':.*'\([^']*\)'" <<< "$PAGE") || return
# Note: The website does an OPTIONS request to $UPLOAD_URL first,
# but without it uploading also works.
JSON=$(curl_with_log \
-F "name=$DESTFILE" \
-F "upload_id=$UPLOAD_ID" \
-F "file=@$FILE;filename=$DESTFILE" \
"$UPLOAD_URL") || return
STATUS=$(parse_json 'OK' <<< "$JSON") || return
if [ "$STATUS" != '1' ]; then
log_error "Unexpected status: $STATUS"
return $ERR_FATAL
fi
JSON=$(curl "$BASE_URL/upload-urls/$UPLOAD_ID?format=json&names=false") || return
parse_json 'url' <<< "$JSON" || return
}
vidzi_tv.sh 0000664 0000000 0000000 00000012525 13022750457 0013262 0 ustar 00root root 0000000 0000000 # Plowshare Vidzi.Tv module
# Copyright (c) 2014 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_VIDZI_TV_REGEXP_URL='https\?://\(www\.\)\?vidzi\.tv/'
MODULE_VIDZI_TV_UPLOAD_OPTIONS="
AUTH,a,auth,a=USER:PASSWORD,User account (mandatory)
DESCRIPTION,d,description,S=DESCRIPTION,Set file description
PRIVATE_FILE,,private,,Mark file for personal use only
TAGS,,tags,l=LIST,Provide list of tags (comma separated)
TITLE,,title,s=TITLE,Set file title"
MODULE_VIDZI_TV_UPLOAD_REMOTE_SUPPORT=no
# Static function. Proceed with login
# $1: credentials string
# $2: cookie file
# $3: base url
vidzi_tv_login() {
local AUTH=$1
local COOKIE_FILE=$2
local BASE_URL=$3
local LOGIN_DATA LOGIN_RESULT NAME ERR
LOGIN_DATA='op=login&redirect=&login=$USER&password=$PASSWORD'
LOGIN_RESULT=$(post_login "$AUTH" "$COOKIE_FILE" "$LOGIN_DATA" "$BASE_URL") || return
# Set-Cookie: login xfsts
NAME=$(parse_cookie_quiet 'login' < "$COOKIE_FILE")
if [ -n "$NAME" ]; then
log_debug "Successfully logged in as $NAME member"
return 0
fi
return $ERR_LOGIN_FAILED
}
# Upload a file to vidzi.tv
# $1: cookie file
# $2: input file (with full path)
# $3: remote filename
# stdout: download link + delete link
vidzi_tv_upload() {
local -r COOKIE_FILE=$1
local -r FILE=$2
local -r DESTFILE=$3
local -r BASE_URL='http://vidzi.tv'
local CV PAGE SESS USER_TYPE UPLOAD_ID TAGS_STR
local FORM_HTML FORM_ACTION FORM_UTYPE FORM_SESS FORM_SRV_TMP FORM_SRV_ID FORM_DSK_ID FORM_BUTTON
local FORM_FN FORM_ST FORM_OP
if CV=$(storage_get 'cookie_file'); then
echo "$CV" >"$COOKIE_FILE"
# Check for expired session
PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL/?op=my_account") || return
if ! match '>\(Username\|Account balance\):<' "$PAGE"; then
log_error 'Expired session, delete cache entry'
storage_set 'cookie_file'
echo 1
return $ERR_LINK_TEMP_UNAVAILABLE
fi
SESS=$(parse_cookie 'xfsts' < "$COOKIE_FILE")
log_debug "session (cached): '$SESS'"
elif [ -n "$AUTH" ]; then
vidzi_tv_login "$AUTH" "$COOKIE_FILE" "$BASE_URL" || return
storage_set 'cookie_file' "$(cat "$COOKIE_FILE")"
SESS=$(parse_cookie 'xfsts' < "$COOKIE_FILE")
log_debug "session (new): '$SESS'"
else
return $ERR_LINK_NEED_PERMISSIONS
fi
PAGE=$(curl -b "$COOKIE_FILE" "$BASE_URL/?op=upload") || return
FORM_HTML=$(grep_form_by_name "$PAGE" 'file') || return
FORM_ACTION=$(parse_form_action <<< "$FORM_HTML") || return
FORM_UTYPE=$(parse_form_input_by_name 'upload_type' <<< "$FORM_HTML") || return
FORM_SESS=$(parse_form_input_by_name_quiet 'sess_id' <<< "$FORM_HTML")
FORM_SRV_TMP=$(parse_form_input_by_name 'srv_tmp_url' <<< "$FORM_HTML") || return
FORM_SRV_ID=$(parse_form_input_by_name 'srv_id' <<< "$FORM_HTML") || return
FORM_DSK_ID=$(parse_form_input_by_name 'disk_id' <<< "$FORM_HTML") || return
FORM_BUTTON=$(parse_form_input_by_name 'submit_btn' <<< "$FORM_HTML") || return
# "reg"
USER_TYPE=$(parse 'var utype' "='\([^']*\)" <<< "$PAGE") || return
log_debug "User type: '$USER_TYPE'"
TAGS_STR=''
if [ "${#TAGS[@]}" -gt 0 ]; then
for T in "${TAGS[@]}"; do TAGS_STR="$TAGS_STR,$T"; done
TAGS_STR=${TAGS_STR#,}
log_debug "Using tags: '$(replace_all ',' \'' '\' <<< "$TAGS_STR")'"
fi
if [ -z "$PRIVATE_FILE" ]; then
PRIVATE_FILE=1
else
PRIVATE_FILE=0
fi
UPLOAD_ID=$(random dec 12) || return
PAGE=$(curl_with_log \
-F "upload_type=$FORM_UTYPE" \
-F "sess_id=$FORM_SESS" \
-F "srv_tmp_url=$FORM_SRV_TMP" \
-F "srv_id=$FORM_SRV_ID" \
-F "disk_id=$FORM_DSK_ID" \
-F "file=@$FILE;filename=$DESTFILE" \
--form-string "file_title=$TITLE" \
--form-string "file_descr=$DESCRIPTION" \
--form-string "tags=$TAGS_STR" \
-F "file_category=0" \
-F "file_public=$PRIVATE_FILE" \
-F 'tos=1' \
--form-string "submit_btn=$FORM_BUTTON" \
"${FORM_ACTION}${UPLOAD_ID}&utype=${USER_TYPE}&disk_id=${FORM_DSK_ID}" | break_html_lines) || return
FORM_ACTION=$(parse_form_action <<< "$PAGE") || return
FORM_FN=$(parse_tag "name='fn'" textarea <<< "$PAGE") || return
FORM_ST=$(parse_tag "name='st'" textarea <<< "$PAGE") || return
FORM_OP=$(parse_tag "name='op'" textarea <<< "$PAGE") || return
if [ "$FORM_ST" = 'OK' ]; then
PAGE=$(curl \
-d "fn=$FORM_FN" -d "st=$FORM_ST" -d "op=$FORM_OP" \
"$FORM_ACTION") || return
parse_attr '>File Title:<' 'href' <<< "$PAGE" || return
return 0
fi
log_error "Unexpected status: $FORM_ST"
return $ERR_FATAL
}
yourvideohost.sh 0000664 0000000 0000000 00000011336 13022750457 0014346 0 ustar 00root root 0000000 0000000 # Plowshare yourvideohost.com module
# Copyright (c) 2014 Plowshare team
#
# This file is part of Plowshare.
#
# Plowshare is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Plowshare is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Plowshare. If not, see .
MODULE_YOURVIDEOHOST_REGEXP_URL='https\?://\(www\.\)\?yourvideohost\.com/'
MODULE_YOURVIDEOHOST_DOWNLOAD_OPTIONS="
AUTH,a,auth,a=USER:PASSWORD,Premium account"
MODULE_YOURVIDEOHOST_DOWNLOAD_RESUME=yes
MODULE_YOURVIDEOHOST_DOWNLOAD_FINAL_LINK_NEEDS_COOKIE=no
MODULE_YOURVIDEOHOST_DOWNLOAD_SUCCESSIVE_INTERVAL=
MODULE_YOURVIDEOHOST_PROBE_OPTIONS=""
# Static function. Proceed with login
# $1: credentials string
# $2: cookie file
# $3: base url
yourvideohost_login() {
local AUTH=$1
local COOKIE_FILE=$2
local BASE_URL=$3
local LOGIN_DATA LOGIN_RESULT NAME ERR
LOGIN_DATA='op=login&redirect=&login=$USER&password=$PASSWORD'
LOGIN_RESULT=$(post_login "$AUTH" "$COOKIE_FILE" "$LOGIN_DATA" "$BASE_URL") || return
# Set-Cookie: login xfsts
NAME=$(parse_cookie_quiet 'login' < "$COOKIE_FILE")
if [ -n "$NAME" ]; then
log_debug "Successfully logged in as $NAME member"
return 0
fi
# Try to parse error
# Incorrect Username or Password
ERR=$(parse_tag_quiet 'class=.err.>' b <<< "$LOGIN_RESULT")
[ -n "$ERR" ] && log_error "Unexpected remote error: $ERR"
return $ERR_LOGIN_FAILED
}
# Output a yourvideohost file download URL
# $1: cookie file (unused here)
# $2: yourvideohost url
# stdout: real file download link
yourvideohost_download() {
local -r COOKIE_FILE=$1
local -r URL=$2
local -r BASE_URL='http://yourvideohost.com'
local PAGE FILE_URL WAIT_TIME JS
local FORM_HTML FORM_OP FORM_ID FORM_USR FORM_REF FORM_FNAME FORM_HASH FORM_SUBMIT
detect_javascript || return
if [ -n "$AUTH" ]; then
yourvideohost_login "$AUTH" "$COOKIE_FILE" "$BASE_URL" || return
else
return $ERR_LINK_NEED_PERMISSIONS
fi
PAGE=$(curl -b "$COOKIE_FILE" -c "$COOKIE_FILE" "$URL") || return
FORM_HTML=$(grep_form_by_order "$PAGE" 1) || return
FORM_OP=$(parse_form_input_by_name 'op' <<< "$FORM_HTML") || return
FORM_ID=$(parse_form_input_by_name 'id' <<< "$FORM_HTML") || return
FORM_USR=$(parse_form_input_by_name_quiet 'usr_login' <<< "$FORM_HTML")
FORM_REF=$(parse_form_input_by_name_quiet 'referer' <<< "$FORM_HTML")
FORM_FNAME=$(parse_form_input_by_name 'fname' <<< "$FORM_HTML") || return
FORM_HASH=$(parse_form_input_by_name 'hash' <<< "$FORM_HTML") || return
FORM_SUBMIT=$(parse_form_input_by_name 'imhuman' <<< "$FORM_HTML") || return
# Wait 3 seconds
WAIT_TIME=$(parse_tag 'countdown_str' 'span' <<< "$PAGE")
wait $((WAIT_TIME)) || return
PAGE=$(curl -b "$COOKIE_FILE" -b 'lang=english' \
-d "op=$FORM_OP" -d "id=$FORM_ID" -d "usr_login=$FORM_USR" \
-d "referer=$FORM_REF" -d "fname=$FORM_FNAME" \
-d "hash=$FORM_HASH" -d "imhuman=$FORM_SUBMIT" \
"$URL") || return
# Obfuscated javascript
# |