kittykat/mad
1
2
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
mad/.audit/mad-audit-tor_curl-details.log
kittykat 270e378e08
# 2025.03.30 - [ranoz] Fix to handle new cookie requirements 
# 2025.03.28 - [up_ranoz] Fix to handle new cookie requirements
# 2025.03.28 - [up_anonfileio] Add anonfile.io as upload host
# 2025.03.28 - [anonfileio] Add anonfile.io as download host
# 2025.03.25 - [up_ranoz] Disable MAD randomized extension on uploads (7z block disabled)
# 2025.03.21 - [mad] Update random user agents 2025.03
# 2025.03.20 - [jira hosts] Update 3 jira hosts (retention and maxsize)
# 2025.03.16 - [torup] Fix torup cookies
# 2025.03.15 - [1fichier] Get new node prior to cdn download (greater possibility of a faster node)
# 2025.03.10 - [uploadscloud] Add uploadscloud.com as download host
2025-04-01 07:09:17 +00:00

3674 lines
247 KiB
Text
Executable file
Raw Permalink Blame History

DateTime: 25.03.30
Files:
./hosts/1fichier.sh
./hosts/9saves.sh
./hosts/acid.sh
./hosts/anarchaserver.sh
./hosts/anonfile.sh
./hosts/anonfileio.sh
./hosts/anonsharing.sh
./hosts/archived/nekofile.sh
./hosts/ateasystems.sh
./hosts/bedrive.sh
./hosts/biteblob.sh
./hosts/blackcloud_onion.sh
./hosts/bowfile.sh
./hosts/click.sh
./hosts/cyssoux.sh
./hosts/dailyuploads.sh
./hosts/dashfile.sh
./hosts/dataupload.sh
./hosts/dbree.sh
./hosts/depotkaz.sh
./hosts/desiupload.sh
./hosts/dictvm.sh
./hosts/discreetshare.sh
./hosts/dosya.sh
./hosts/downloadgg.sh
./hosts/eddowding.sh
./hosts/eternalhosting.sh
./hosts/euromussels.sh
./hosts/examples/ExampleNewHost.sh
./hosts/examples/up_example.sh
./hosts/familleflender.sh
./hosts/fileblade.sh
./hosts/fileditch.sh
./hosts/filedoge.sh
./hosts/filedot.sh
./hosts/filehaus.sh
./hosts/filesquid.sh
./hosts/firestorage.sh
./hosts/free4e.sh
./hosts/freesocial.sh
./hosts/gagneux.sh
./hosts/gofile.sh
./hosts/harrault.sh
./hosts/herbolistique.sh
./hosts/hexload.sh
./hosts/innocent.sh
./hosts/isupload.sh
./hosts/kraken.sh
./hosts/lainsafe.sh
./hosts/lainsafe_onion.sh
./hosts/linxx.sh
./hosts/mediafire.sh
./hosts/moocloud.sh
./hosts/nantes.sh
./hosts/netlib.sh
./hosts/nippy.sh
./hosts/nofile.sh
./hosts/offshorecat.sh
./hosts/oshi.sh
./hosts/pixeldrain.sh
./hosts/quax.sh
./hosts/ramsgaard.sh
./hosts/ranoz.sh
./hosts/sendnow.sh
./hosts/sendspace.sh
./hosts/shareonline.sh
./hosts/skrepr.sh
./hosts/soyjak.sh
./hosts/syspro.sh
./hosts/tempfileme.sh
./hosts/tempsh.sh
./hosts/torup.sh
./hosts/turboonion.sh
./hosts/up2share.sh
./hosts/uploadbay.sh
./hosts/uploadee.sh
./hosts/uploadev.sh
./hosts/uploadflix.sh
./hosts/uploadhive.sh
./hosts/uploadscloud.sh
./hosts/up_1fichier.sh
./hosts/up_acid.sh
./hosts/up_anarchaserver.sh
./hosts/up_anonfile.sh
./hosts/up_anonfileio.sh
./hosts/up_anonsharing.sh
./hosts/up_ateasystems.sh
./hosts/up_axfc.sh
./hosts/up_bedrive.sh
./hosts/up_bowfile.sh
./hosts/up_cyssoux.sh
./hosts/up_dailyuploads.sh
./hosts/up_dashfile.sh
./hosts/up_dataupload.sh
./hosts/up_dbree.sh
./hosts/up_depotkaz.sh
./hosts/up_dictvm.sh
./hosts/up_dosya.sh
./hosts/up_eddowding.sh
./hosts/up_euromussels.sh
./hosts/up_familleflender.sh
./hosts/up_fileblade.sh
./hosts/up_fileditch.sh
./hosts/up_filehaus.sh
./hosts/up_fileland.sh
./hosts/up_filesquid.sh
./hosts/up_fireget.sh
./hosts/up_firestorage.sh
./hosts/up_free4e.sh
./hosts/up_freesocial.sh
./hosts/up_gagneux.sh
./hosts/up_gofile.sh
./hosts/up_harrault.sh
./hosts/up_herbolistique.sh
./hosts/up_hexload.sh
./hosts/up_innocent.sh
./hosts/up_isupload.sh
./hosts/up_kouploader.sh
./hosts/up_kraken.sh
./hosts/up_lainsafe.sh
./hosts/up_linxx.sh
./hosts/up_moocloud.sh
./hosts/up_nantes.sh
./hosts/up_netlib.sh
./hosts/up_nippy.sh
./hosts/up_nofile.sh
./hosts/up_offshorecat.sh
./hosts/up_oshi.sh
./hosts/up_pixeldrain.sh
./hosts/up_quax.sh
./hosts/up_ramsgaard.sh
./hosts/up_ranoz.sh
./hosts/up_sendnow.sh
./hosts/up_sendspace.sh
./hosts/up_shareonline.sh
./hosts/up_skrepr.sh
./hosts/up_soyjak.sh
./hosts/up_syspro.sh
./hosts/up_tempfileme.sh
./hosts/up_tempsh.sh
./hosts/up_torup.sh
./hosts/up_turboonion.sh
./hosts/up_uploadbay.sh
./hosts/up_uploadee.sh
./hosts/up_uploadev.sh
./hosts/up_uploadflix.sh
./hosts/up_uploadhive.sh
./hosts/up_uploadraja.sh
./hosts/up_uwabaki.sh
./hosts/up_yolobit.sh
./hosts/uwabaki.sh
./hosts/yolobit.sh
./hosts/youdbox.sh
./mad.sh
./plugins/AutoResetAndRetryDownloads.sh
./plugins/CatnapCtrlC.sh
./plugins/SkipUrlsInDownloadsCompletedTxt.sh
./plugins/examples/ExampleAddNewFuncAndCallOnSuccessfulDownload.sh
./plugins/examples/ExamplesMainHooks.sh
./plugins/ocr_captcha.sh
./plugins/pjscloud.sh
MAD Audit of tor_curl (+10 lines after): (grep "tor_curl")
_________________________________________________________________________
./hosts/1fichier.sh:48: PAGE=$(tor_curl_request --insecure --max-time "$ConnectTimeout" -s "${remote_url}")
./hosts/1fichier.sh:49: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/1fichier.sh:50: debugHtml "${remote_url##*/?}" "prechk$y" "${PAGE}"
./hosts/1fichier.sh:51: fi
./hosts/1fichier.sh:52: file_information=$(grep -oP '(?<=<td class="normal">)[^<]*?(?=</td>)' <<< "${PAGE}")
./hosts/1fichier.sh:53: size=$(echo "${file_information}" | tail -n 1)
./hosts/1fichier.sh:54: filename=$(echo "${file_information}" | head -n 1)
./hosts/1fichier.sh:55: if [[ ! "$filename_override" == "" ]] ; then
./hosts/1fichier.sh:56: filename="$filename_override"
./hosts/1fichier.sh:57: fi
./hosts/1fichier.sh:58: filename=$(sanitize_file_or_folder_name "${filename}")
--
./hosts/1fichier.sh:160: cdn_request=$(tor_curl_request --insecure -s -L -b "${fich_cookie_jar}" -c "${fich_cookie_jar}" -F "submit=Download" -F "pass=${fich_user_provided_password}" -F "adz=${fich_adz_parameter}" "${remote_url}")
./hosts/1fichier.sh:161: target_file_link=$(echo "$cdn_request" | grep -A 2 '<div style="width:600px;height:80px;margin:auto;text-align:center;vertical-align:middle">' | grep -oP '<a href="\K[^"]+')
./hosts/1fichier.sh:162: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/1fichier.sh:163: debugHtml "${remote_url##*/?}" "fich_cdn${num_attempt}_1" "target_file_link: ${target_file_link}"$'\n'"${cdn_request}"
./hosts/1fichier.sh:164: fi
./hosts/1fichier.sh:165: rm -f "${fich_cookie_jar}"
./hosts/1fichier.sh:166: if ! grep -Eqi "https://" <<< "${target_file_link}" > /dev/null ; then
./hosts/1fichier.sh:167: if $is_password_protected; then
./hosts/1fichier.sh:168: echo -e "${RED}ERROR: Incorrect password${NC}\nSince this download required a password, you might have copied it incorrectly?"
./hosts/1fichier.sh:169: passwordProtectedDownload "${remote_url}"
./hosts/1fichier.sh:170: exitDownloadError=true
--
./hosts/1fichier.sh:194: file_header=$(tor_curl_request --insecure -sSIL -e "${remote_url}" "${target_file_link}")
./hosts/1fichier.sh:195: file_size_bytes=$(grep -oPi '(?<=content-length: ).*' <<< "$file_header")
./hosts/1fichier.sh:196: file_size_bytes=${file_size_bytes//[$'\t\r\n']}
./hosts/1fichier.sh:197: download_inflight_path="${WorkDir}/.inflight/"
./hosts/1fichier.sh:198: completed_location="${WorkDir}/downloads/"
./hosts/1fichier.sh:199: file_path="${download_inflight_path}${filename}"
./hosts/1fichier.sh:200: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/1fichier.sh:201: debugHtml "${remote_url##*/?}" "fich_savehead${num_attempt}_${j}" "target_file_link: ${target_file_link}"$'\n'"${file_header}"
./hosts/1fichier.sh:202: fi
./hosts/1fichier.sh:203: if [[ -z "$file_header" ]] || [[ -z "$file_size_bytes" ]]; then
./hosts/1fichier.sh:204: continue
--
./hosts/1fichier.sh:262: tor_curl_request --insecure -e "${remote_url}" "${target_file_link}" -C - -o "${file_path}"
./hosts/1fichier.sh:263: rm -f "$flockDownload";
./hosts/1fichier.sh:264: received_file_size=0
./hosts/1fichier.sh:265: if [[ -f "$file_path" ]] ; then
./hosts/1fichier.sh:266: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/1fichier.sh:267: fi
./hosts/1fichier.sh:268: if [[ "${received_file_size}" -ne "${file_size_bytes}" ]]; then
./hosts/1fichier.sh:269: echo -e "${RED}ERROR: Size mismatch after downloading${NC}\nPerhaps you or 1fichier lost connection for a while?"
./hosts/1fichier.sh:270: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/1fichier.sh:271: droppedSizeBadDownload "${remote_url}" "${filename}" "${received_file_size}"
./hosts/1fichier.sh:272: fi
--
./hosts/1fichier.sh:355: PAGE=$(tor_curl_request --insecure --max-time "$ConnectTimeout" -c "${fich_cookie_jar}" -s "${remote_url}")
./hosts/1fichier.sh:356: if [[ -z ${PAGE} ]]; then
./hosts/1fichier.sh:357: rm -f "${fich_cookie_jar}"
./hosts/1fichier.sh:358: continue
./hosts/1fichier.sh:359: fi
./hosts/1fichier.sh:360: if grep -Eqi '<span style="color:red">Warning !</span>|<span style="color:red">Attention !</span>' <<< "${PAGE}"; then
./hosts/1fichier.sh:361: rm -f "${fich_cookie_jar}"
./hosts/1fichier.sh:362: continue
./hosts/1fichier.sh:363: else
./hosts/1fichier.sh:364: fich_adz_parameter=$(grep -oPi 'name="adz" value="\K[^"]+' <<< "${PAGE}")
./hosts/1fichier.sh:365: if [[ $fich_adz_parameter ]]; then
--
./hosts/9saves.sh:90: response=$(tor_curl_request --insecure -L -s -b "${ns_cookie_jar}" -c "${ns_cookie_jar}" "$remote_url")
./hosts/9saves.sh:91: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/9saves.sh:92: debugHtml "${remote_url##*/}" "ns_dwnpage$i" "${response}"
./hosts/9saves.sh:93: fi
./hosts/9saves.sh:94: if [[ -z $response ]] ; then
./hosts/9saves.sh:95: if [[ $i == $maxfetchretries ]] ; then
./hosts/9saves.sh:96: rm -f "${ns_cookie_jar}";
./hosts/9saves.sh:97: printf "\\n"
./hosts/9saves.sh:98: echo -e "${RED}| Failed to extract post link.${NC}"
./hosts/9saves.sh:99: warnAndRetryUnknownError=true
./hosts/9saves.sh:100: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/9saves.sh:139: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/9saves.sh:140: -b "${ns_cookie_jar}" -c "${ns_cookie_jar}" \
./hosts/9saves.sh:141: --data "$form_data" "https://9saves.com/")
./hosts/9saves.sh:142: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/9saves.sh:143: debugHtml "${remote_url##*/}" "ns_post" "form_data: ${form_data}"$'\n'"${response}"
./hosts/9saves.sh:144: fi
./hosts/9saves.sh:145: if [[ -z $response ]] ; then
./hosts/9saves.sh:146: rm -f "${ns_cookie_jar}";
./hosts/9saves.sh:147: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/9saves.sh:148: warnAndRetryUnknownError=true
./hosts/9saves.sh:149: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/9saves.sh:188: file_header=$(tor_curl_request --insecure --head -L -s -b "${ns_cookie_jar}" -c "${ns_cookie_jar}" "$download_url")
./hosts/9saves.sh:189: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/9saves.sh:190: debugHtml "${remote_url##*/}" "ns_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/9saves.sh:191: fi
./hosts/9saves.sh:192: if [[ -z $file_header ]] ; then
./hosts/9saves.sh:193: if [[ $j == $maxfetchretries ]] ; then
./hosts/9saves.sh:194: rm -f "${ns_cookie_jar}";
./hosts/9saves.sh:195: printf "\\n"
./hosts/9saves.sh:196: echo -e "${RED}| Failed to extract file info.${NC}"
./hosts/9saves.sh:197: warnAndRetryUnknownError=true
./hosts/9saves.sh:198: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/9saves.sh:292: tor_curl_request --insecure \
./hosts/9saves.sh:293: -b "${ns_cookie_jar}" --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/9saves.sh:294: "$download_url" \
./hosts/9saves.sh:295: --continue-at - --output "$file_path"
./hosts/9saves.sh:296: else
./hosts/9saves.sh:297: tor_curl_request --insecure \
./hosts/9saves.sh:298: -b "${ns_cookie_jar}" \
./hosts/9saves.sh:299: "$download_url" \
./hosts/9saves.sh:300: --continue-at - --output "$file_path"
./hosts/9saves.sh:301: fi
./hosts/9saves.sh:302: else
./hosts/9saves.sh:303: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/9saves.sh:304: tor_curl_request --insecure \
./hosts/9saves.sh:305: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/9saves.sh:306: -b "${ns_cookie_jar}" \
./hosts/9saves.sh:307: -H "User-Agent: $RandomUA" \
./hosts/9saves.sh:308: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/9saves.sh:309: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/9saves.sh:310: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/9saves.sh:311: -H "Connection: keep-alive" \
./hosts/9saves.sh:312: -H "Cookie: lng=eng" \
./hosts/9saves.sh:313: -H "Upgrade-Insecure-Requests: 1" \
./hosts/9saves.sh:314: -H "Sec-Fetch-Dest: document" \
--
./hosts/9saves.sh:321: tor_curl_request --insecure \
./hosts/9saves.sh:322: -b "${ns_cookie_jar}" \
./hosts/9saves.sh:323: -H "User-Agent: $RandomUA" \
./hosts/9saves.sh:324: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/9saves.sh:325: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/9saves.sh:326: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/9saves.sh:327: -H "Connection: keep-alive" \
./hosts/9saves.sh:328: -H "Cookie: lng=eng" \
./hosts/9saves.sh:329: -H "Upgrade-Insecure-Requests: 1" \
./hosts/9saves.sh:330: -H "Sec-Fetch-Dest: document" \
./hosts/9saves.sh:331: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/anonfile.sh:96: response=$(tor_curl_request --insecure -L -s -b "${anon_cookie_jar}" -c "${anon_cookie_jar}" \
./hosts/anonfile.sh:97: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/anonfile.sh:98: "$fixed_url")
./hosts/anonfile.sh:99: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/anonfile.sh:100: debugHtml "${remote_url##*/}" "anon_fetch$i" "${response}"
./hosts/anonfile.sh:101: fi
./hosts/anonfile.sh:102: if [[ -z $response ]] ; then
./hosts/anonfile.sh:103: rm -f "${anon_cookie_jar}";
./hosts/anonfile.sh:104: if [[ $i == $maxfetchretries ]] ; then
./hosts/anonfile.sh:105: printf "\\n"
./hosts/anonfile.sh:106: echo -e "${RED}| Failed to extract download link [1]${NC}"
--
./hosts/anonfile.sh:186: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/anonfile.sh:187: -b "${anon_cookie_jar}" -c "${anon_cookie_jar}" \
./hosts/anonfile.sh:188: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/anonfile.sh:189: --data "$form_data" "$fixed_url")
./hosts/anonfile.sh:190: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/anonfile.sh:191: debugHtml "${remote_url##*/}" "anon_post1_$i" "${response}"
./hosts/anonfile.sh:192: fi
./hosts/anonfile.sh:193: if [[ -z $response ]] ; then
./hosts/anonfile.sh:194: rm -f "${anon_cookie_jar}";
./hosts/anonfile.sh:195: if [[ $i == $maxfetchretries ]] ; then
./hosts/anonfile.sh:196: printf "\\n"
--
./hosts/anonfile.sh:240: tor_curl_request --insecure -s "$captcha_img_url" --output "$tmp_captcha_img"
./hosts/anonfile.sh:241: captcha_ocr_output=$(CaptchaOcrImageTesseract "$tmp_captcha_img" "NUMBERONLY" "ContrastStretch_5x90,Brightness_130")
./hosts/anonfile.sh:242: if [[ "${DebugPluginsEnabled}" == "true" ]]; then
./hosts/anonfile.sh:243: printf "\\n"
./hosts/anonfile.sh:244: echo -e "$captcha_ocr_output"
./hosts/anonfile.sh:245: fi
./hosts/anonfile.sh:246: captcha_code=$(grep -oP -m 1 "(?<=\[CAPTCHA_CODE\:).*?(?=\])" <<< "$captcha_ocr_output")
./hosts/anonfile.sh:247: rm -f "$tmp_captcha_img"
./hosts/anonfile.sh:248: rm -f "$captcha_ocr_output"
./hosts/anonfile.sh:249: local caplength=${#captcha_code}
./hosts/anonfile.sh:250: if [[ -z "$captcha_code" ]] || ((caplength != 4)) ; then
--
./hosts/anonfile.sh:340: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/anonfile.sh:341: -b "${anon_cookie_jar}" -c "${anon_cookie_jar}" \
./hosts/anonfile.sh:342: --data "$form_data" "$fixed_url")
./hosts/anonfile.sh:343: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/anonfile.sh:344: debugHtml "${remote_url##*/}" "anon_post2_$i" "url: ${fixed_url}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/anonfile.sh:345: fi
./hosts/anonfile.sh:346: if [[ -z $response ]] ; then
./hosts/anonfile.sh:347: if [[ $i == $maxfetchretries ]] ; then
./hosts/anonfile.sh:348: rm -f "${anon_cookie_jar}";
./hosts/anonfile.sh:349: printf "\\n"
./hosts/anonfile.sh:350: echo -e "${RED}| Failed to extract download link [3].${NC}"
--
./hosts/anonfile.sh:519: tor_curl_request --insecure \
./hosts/anonfile.sh:520: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/anonfile.sh:521: -b "${anon_cookie_jar}" -c "${anon_cookie_jar}" \
./hosts/anonfile.sh:522: --referer "${fixed_url}" \
./hosts/anonfile.sh:523: "$download_url" --output "$file_path"
./hosts/anonfile.sh:524: else
./hosts/anonfile.sh:525: tor_curl_request --insecure \
./hosts/anonfile.sh:526: -b "${anon_cookie_jar}" -c "${anon_cookie_jar}" \
./hosts/anonfile.sh:527: --referer "${fixed_url}" \
./hosts/anonfile.sh:528: "$download_url" --output "$file_path"
./hosts/anonfile.sh:529: fi
./hosts/anonfile.sh:530: else
./hosts/anonfile.sh:531: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/anonfile.sh:532: tor_curl_request --insecure \
./hosts/anonfile.sh:533: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/anonfile.sh:534: -H "User-Agent: $RandomUA" \
./hosts/anonfile.sh:535: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/anonfile.sh:536: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/anonfile.sh:537: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/anonfile.sh:538: -H "Connection: keep-alive" \
./hosts/anonfile.sh:539: -H "Cookie: lng=eng" \
./hosts/anonfile.sh:540: -H "Upgrade-Insecure-Requests: 1" \
./hosts/anonfile.sh:541: -H "Sec-Fetch-Dest: document" \
./hosts/anonfile.sh:542: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/anonfile.sh:549: tor_curl_request --insecure \
./hosts/anonfile.sh:550: -H "User-Agent: $RandomUA" \
./hosts/anonfile.sh:551: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/anonfile.sh:552: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/anonfile.sh:553: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/anonfile.sh:554: -H "Connection: keep-alive" \
./hosts/anonfile.sh:555: -H "Cookie: lng=eng" \
./hosts/anonfile.sh:556: -H "Upgrade-Insecure-Requests: 1" \
./hosts/anonfile.sh:557: -H "Sec-Fetch-Dest: document" \
./hosts/anonfile.sh:558: -H "Sec-Fetch-Mode: navigate" \
./hosts/anonfile.sh:559: -H "Sec-Fetch-Site: same-origin" \
--
./hosts/anonsharing.sh:91: response=$(tor_curl_request --insecure -i -s \
./hosts/anonsharing.sh:92: -b "${ansh_cookie_jar}" -c "${ansh_cookie_jar}" \
./hosts/anonsharing.sh:93: -F "u=$fileid" \
./hosts/anonsharing.sh:94: -F "p=true" \
./hosts/anonsharing.sh:95: "https://anonsharing.com/account/ajax/file_details")
./hosts/anonsharing.sh:96: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/anonsharing.sh:97: debugHtml "${remote_url##*/}" "ansh_postfileinfo$i" "${response}"
./hosts/anonsharing.sh:98: fi
./hosts/anonsharing.sh:99: if [[ -z $response ]] ; then
./hosts/anonsharing.sh:100: rm -f "${ansh_cookie_jar}";
./hosts/anonsharing.sh:101: if [[ $i == $maxfetchretries ]] ; then
--
./hosts/anonsharing.sh:150: file_header=$(tor_curl_request --insecure --head -L -i -s \
./hosts/anonsharing.sh:151: -b "${ansh_cookie_jar}" -c "${ansh_cookie_jar}" \
./hosts/anonsharing.sh:152: "$download_url")
./hosts/anonsharing.sh:153: else
./hosts/anonsharing.sh:154: echo -e "${GREEN}# Fetching file info…${NC}"
./hosts/anonsharing.sh:155: ansh_host="${download_url/https:\/\//}"
./hosts/anonsharing.sh:156: ansh_host="${ansh_host%%\/*}"
./hosts/anonsharing.sh:157: rm -f "${WorkDir}/.temp/directhead"
./hosts/anonsharing.sh:158: file_header=$(tor_curl_request --insecure --head -H "Connection: keep-alive" -s -i \
./hosts/anonsharing.sh:159: -H "Host: $ansh_host" \
./hosts/anonsharing.sh:160: "$download_url" |
./hosts/anonsharing.sh:161: tee "${WorkDir}/.temp/directhead" &
./hosts/anonsharing.sh:162: sleep 6
./hosts/anonsharing.sh:163: [ -s "${WorkDir}/.temp/directhead" ]
./hosts/anonsharing.sh:164: kill $! 2>/dev/null
./hosts/anonsharing.sh:165: )
./hosts/anonsharing.sh:166: if [[ ! -f "${WorkDir}/.flocks/${remote_url//[^a-zA-Z0-9]/}" ]]; then
./hosts/anonsharing.sh:167: touch "${WorkDir}/.flocks/${remote_url//[^a-zA-Z0-9]/}"
./hosts/anonsharing.sh:168: fi
--
./hosts/anonsharing.sh:273: tor_curl_request --insecure --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --output "$file_path"
./hosts/anonsharing.sh:274: else
./hosts/anonsharing.sh:275: tor_curl_request --insecure "$download_url" --output "$file_path"
./hosts/anonsharing.sh:276: fi
./hosts/anonsharing.sh:277: received_file_size=0
./hosts/anonsharing.sh:278: if [[ -f "$file_path" ]] ; then
./hosts/anonsharing.sh:279: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/anonsharing.sh:280: fi
./hosts/anonsharing.sh:281: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/anonsharing.sh:282: containsHtml=false
./hosts/anonsharing.sh:283: else
./hosts/anonsharing.sh:284: containsHtml=true
./hosts/anonsharing.sh:285: fi
--
./hosts/ateasystems.sh:88: response=$(tor_curl_request --insecure -L -s "$remote_url")
./hosts/ateasystems.sh:89: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/ateasystems.sh:90: debugHtml "${remote_url##*/}" "atea_fetch$i" "${response}"
./hosts/ateasystems.sh:91: fi
./hosts/ateasystems.sh:92: if [[ -z $response ]] ; then
./hosts/ateasystems.sh:93: if [[ $i == $maxfetchretries ]] ; then
./hosts/ateasystems.sh:94: printf "\\n"
./hosts/ateasystems.sh:95: echo -e "${RED}| Failed to extract download link [1]${NC}"
./hosts/ateasystems.sh:96: warnAndRetryUnknownError=true
./hosts/ateasystems.sh:97: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/ateasystems.sh:98: failedRetryDownload "${remote_url}" "Failed to extract download link [1]" ""
--
./hosts/ateasystems.sh:220: tor_curl_request --insecure \
./hosts/ateasystems.sh:221: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/ateasystems.sh:222: --data "$form_data" "$post_action" \
./hosts/ateasystems.sh:223: --output "$file_path" --output "$file_path"
./hosts/ateasystems.sh:224: else
./hosts/ateasystems.sh:225: tor_curl_request --insecure \
./hosts/ateasystems.sh:226: --data "$form_data" "$post_action" \
./hosts/ateasystems.sh:227: --output "$file_path" --output "$file_path"
./hosts/ateasystems.sh:228: fi
./hosts/ateasystems.sh:229: else
./hosts/ateasystems.sh:230: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/ateasystems.sh:231: tor_curl_request --insecure \
./hosts/ateasystems.sh:232: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/ateasystems.sh:233: -H "User-Agent: $RandomUA" \
./hosts/ateasystems.sh:234: --data "$form_data" "$post_action" \
./hosts/ateasystems.sh:235: --output "$file_path" --output "$file_path"
./hosts/ateasystems.sh:236: else
./hosts/ateasystems.sh:237: tor_curl_request --insecure \
./hosts/ateasystems.sh:238: -H "User-Agent: $RandomUA" \
./hosts/ateasystems.sh:239: --data "$form_data" "$post_action" \
./hosts/ateasystems.sh:240: --output "$file_path" --output "$file_path"
./hosts/ateasystems.sh:241: fi
./hosts/ateasystems.sh:242: fi
./hosts/ateasystems.sh:243: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - 0))" ; then
./hosts/ateasystems.sh:244: containsHtml=false
./hosts/ateasystems.sh:245: else
./hosts/ateasystems.sh:246: containsHtml=true
./hosts/ateasystems.sh:247: fi
--
./hosts/bedrive.sh:90: response=$(tor_curl_request --insecure -L -s \
./hosts/bedrive.sh:91: -b "${bd_cookie_jar}" -c "${bd_cookie_jar}" \
./hosts/bedrive.sh:92: "$remote_url")
./hosts/bedrive.sh:93: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/bedrive.sh:94: debugHtml "${remote_url##*/}" "bd_fetch$i" "${response}"
./hosts/bedrive.sh:95: fi
./hosts/bedrive.sh:96: if [[ -z $response ]] ; then
./hosts/bedrive.sh:97: rm -f "${bd_cookie_jar}";
./hosts/bedrive.sh:98: if [[ $i == $maxfetchretries ]] ; then
./hosts/bedrive.sh:99: printf "\\n"
./hosts/bedrive.sh:100: echo -e "${RED}| Failed to extract download link.${NC}"
--
./hosts/bedrive.sh:149: file_header=$(tor_curl_request --insecure --head -L -i -s \
./hosts/bedrive.sh:150: -b "${bd_cookie_jar}" -c "${bd_cookie_jar}" \
./hosts/bedrive.sh:151: "$download_url")
./hosts/bedrive.sh:152: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/bedrive.sh:153: debugHtml "${remote_url##*/}" "bd_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/bedrive.sh:154: fi
./hosts/bedrive.sh:155: if [[ -z $file_header ]] ; then
./hosts/bedrive.sh:156: if [[ $j == $maxfetchretries ]] ; then
./hosts/bedrive.sh:157: rm -f "${bd_cookie_jar}";
./hosts/bedrive.sh:158: printf "\\n"
./hosts/bedrive.sh:159: echo -e "${RED}| Failed to extract file info.${NC}"
--
./hosts/bedrive.sh:272: tor_curl_request --insecure -L -G --no-alpn \
./hosts/bedrive.sh:273: -b "${bd_cookie_jar}" -c "${bd_cookie_jar}" --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/bedrive.sh:274: --referer "$remote_url" "$download_url" \
./hosts/bedrive.sh:275: --continue-at - --output "$file_path"
./hosts/bedrive.sh:276: else
./hosts/bedrive.sh:277: tor_curl_request --insecure -L -G --no-alpn \
./hosts/bedrive.sh:278: -b "${bd_cookie_jar}" -c "${bd_cookie_jar}" \
./hosts/bedrive.sh:279: --referer "$remote_url" "$download_url" \
./hosts/bedrive.sh:280: --continue-at - --output "$file_path"
./hosts/bedrive.sh:281: fi
./hosts/bedrive.sh:282: else
./hosts/bedrive.sh:283: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/bedrive.sh:284: tor_curl_request --insecure -L -G --no-alpn \
./hosts/bedrive.sh:285: -b "${bd_cookie_jar}" -c "${bd_cookie_jar}" --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/bedrive.sh:286: -H "User-Agent: $RandomUA" \
./hosts/bedrive.sh:287: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/bedrive.sh:288: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/bedrive.sh:289: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/bedrive.sh:290: -H "Connection: keep-alive" \
./hosts/bedrive.sh:291: -H "Cookie: lng=eng" \
./hosts/bedrive.sh:292: -H "Upgrade-Insecure-Requests: 1" \
./hosts/bedrive.sh:293: -H "Sec-Fetch-Dest: document" \
./hosts/bedrive.sh:294: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/bedrive.sh:300: tor_curl_request --insecure -L -G --no-alpn \
./hosts/bedrive.sh:301: -b "${bd_cookie_jar}" -c "${bd_cookie_jar}" \
./hosts/bedrive.sh:302: -H "User-Agent: $RandomUA" \
./hosts/bedrive.sh:303: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/bedrive.sh:304: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/bedrive.sh:305: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/bedrive.sh:306: -H "Connection: keep-alive" \
./hosts/bedrive.sh:307: -H "Cookie: lng=eng" \
./hosts/bedrive.sh:308: -H "Upgrade-Insecure-Requests: 1" \
./hosts/bedrive.sh:309: -H "Sec-Fetch-Dest: document" \
./hosts/bedrive.sh:310: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/biteblob.sh:96: response=$(tor_curl_request --insecure -L -s "${fixed_url}")
./hosts/biteblob.sh:97: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/biteblob.sh:98: debugHtml "${remote_url##*/}" "bite_dwnpage$j" "url: $fixed_url"$'\n'"${response}"
./hosts/biteblob.sh:99: fi
./hosts/biteblob.sh:100: if [[ -z $response ]] ; then
./hosts/biteblob.sh:101: if [[ $j == $maxfetchretries ]] ; then
./hosts/biteblob.sh:102: printf "\\n"
./hosts/biteblob.sh:103: echo -e "${RED}| Failed to extract download link${NC}"
./hosts/biteblob.sh:104: warnAndRetryUnknownError=true
./hosts/biteblob.sh:105: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/biteblob.sh:106: failedRetryDownload "${remote_url}" "" ""
--
./hosts/biteblob.sh:144: file_header=$(tor_curl_request --insecure --head -L -s "$download_url")
./hosts/biteblob.sh:145: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/biteblob.sh:146: debugHtml "${remote_url##*/}" "bite_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/biteblob.sh:147: fi
./hosts/biteblob.sh:148: if [[ -z $file_header ]] ; then
./hosts/biteblob.sh:149: if [[ $j == $maxfetchretries ]] ; then
./hosts/biteblob.sh:150: printf "\\n"
./hosts/biteblob.sh:151: echo -e "${RED}| Failed to extract file info.${NC}"
./hosts/biteblob.sh:152: warnAndRetryUnknownError=true
./hosts/biteblob.sh:153: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/biteblob.sh:154: failedRetryDownload "${remote_url}" "" ""
--
./hosts/biteblob.sh:227: tor_curl_request --insecure --referer "$file_url" "$download_url" --output "$file_path"
./hosts/biteblob.sh:228: rc=$?
./hosts/biteblob.sh:229: if ((rc != 0 )) ; then
./hosts/biteblob.sh:230: printf "${RED}Download Failed (bad exit status).${NC}"
./hosts/biteblob.sh:231: if [[ -f ${file_path} ]]; then
./hosts/biteblob.sh:232: printf "${YELLOW} Partial removed...${NC}"
./hosts/biteblob.sh:233: printf "\n\n"
./hosts/biteblob.sh:234: rm -f "${file_path}"
./hosts/biteblob.sh:235: else
./hosts/biteblob.sh:236: printf "\n\n"
./hosts/biteblob.sh:237: fi
--
./hosts/biteblob.sh:284: tor_curl_request --insecure --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/biteblob.sh:285: else
./hosts/biteblob.sh:286: tor_curl_request --insecure --referer "$file_url" "$download_url" --continue-at - --output "$file_path"
./hosts/biteblob.sh:287: fi
./hosts/biteblob.sh:288: received_file_size=0
./hosts/biteblob.sh:289: if [[ -f "$file_path" ]] ; then
./hosts/biteblob.sh:290: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/biteblob.sh:291: fi
./hosts/biteblob.sh:292: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/biteblob.sh:293: containsHtml=false
./hosts/biteblob.sh:294: else
./hosts/biteblob.sh:295: containsHtml=true
./hosts/biteblob.sh:296: fi
--
./hosts/bowfile.sh:91: response=$(tor_curl_request --insecure -L -s -b "${bow_cookie_jar}" -c "${bow_cookie_jar}" \
./hosts/bowfile.sh:92: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/bowfile.sh:93: "$fixed_url")
./hosts/bowfile.sh:94: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/bowfile.sh:95: debugHtml "${remote_url##*/}" "bow_fetch$i" "${response}"
./hosts/bowfile.sh:96: fi
./hosts/bowfile.sh:97: if [[ -z $response ]] ; then
./hosts/bowfile.sh:98: rm -f "${bow_cookie_jar}";
./hosts/bowfile.sh:99: if [[ $i == $maxfetchretries ]] ; then
./hosts/bowfile.sh:100: printf "\\n"
./hosts/bowfile.sh:101: echo -e "${RED}| Failed to extract token link [1].${NC}"
--
./hosts/bowfile.sh:143: response=$(tor_curl_request --insecure -s --head \
./hosts/bowfile.sh:144: -b "${bow_cookie_jar}" -c "${bow_cookie_jar}" \
./hosts/bowfile.sh:145: -H "Host: bowfile.com" \
./hosts/bowfile.sh:146: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/bowfile.sh:147: "$download_url")
./hosts/bowfile.sh:148: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/bowfile.sh:149: debugHtml "${remote_url##*/}" "bow_downurl" "download_url: ${download_url}"$'\n'"${response}"
./hosts/bowfile.sh:150: fi
./hosts/bowfile.sh:151: if [[ -z $response ]] ; then
./hosts/bowfile.sh:152: rm -f "${bow_cookie_jar}";
./hosts/bowfile.sh:153: printf "\\n"
--
./hosts/bowfile.sh:182: file_header=$(tor_curl_request --insecure -L -sS -i --head \
./hosts/bowfile.sh:183: -H "Host: $fshost" \
./hosts/bowfile.sh:184: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/bowfile.sh:185: "$download_url")
./hosts/bowfile.sh:186: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/bowfile.sh:187: debugHtml "${remote_url##*/}" "bow_head$j" "download_url: ${download_url}"$'\n'"download_token: ${dltoken}"$'\n'"${file_header}"
./hosts/bowfile.sh:188: fi
./hosts/bowfile.sh:189: if [[ -z $file_header ]] ; then
./hosts/bowfile.sh:190: if [[ $j == $maxfetchretries ]] ; then
./hosts/bowfile.sh:191: printf "\\n"
./hosts/bowfile.sh:192: echo -e "${RED}| Failed to extract file info${NC}"
--
./hosts/bowfile.sh:299: tor_curl_request --insecure -L \
./hosts/bowfile.sh:300: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/bowfile.sh:301: -H "Host: $fshost" \
./hosts/bowfile.sh:302: --referer "https://bowfile.com/" \
./hosts/bowfile.sh:303: "$download_url" --continue-at - --output "$file_path"
./hosts/bowfile.sh:304: else
./hosts/bowfile.sh:305: tor_curl_request --insecure -L \
./hosts/bowfile.sh:306: -H "Host: $fshost" \
./hosts/bowfile.sh:307: --referer "https://bowfile.com/" \
./hosts/bowfile.sh:308: "$download_url" --continue-at - --output "$file_path"
./hosts/bowfile.sh:309: fi
./hosts/bowfile.sh:310: else
./hosts/bowfile.sh:311: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/bowfile.sh:312: tor_curl_request --insecure -L \
./hosts/bowfile.sh:313: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/bowfile.sh:314: -H "Host: $fshost" \
./hosts/bowfile.sh:315: -H "User-Agent: $RandomUA" \
./hosts/bowfile.sh:316: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/bowfile.sh:317: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/bowfile.sh:318: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/bowfile.sh:319: -H "Connection: keep-alive" \
./hosts/bowfile.sh:320: -H "Cookie: lng=eng" \
./hosts/bowfile.sh:321: -H "Upgrade-Insecure-Requests: 1" \
./hosts/bowfile.sh:322: -H "Sec-Fetch-Dest: document" \
--
./hosts/bowfile.sh:329: tor_curl_request --insecure -L \
./hosts/bowfile.sh:330: -H "Host: $fshost" \
./hosts/bowfile.sh:331: -H "User-Agent: $RandomUA" \
./hosts/bowfile.sh:332: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/bowfile.sh:333: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/bowfile.sh:334: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/bowfile.sh:335: -H "Connection: keep-alive" \
./hosts/bowfile.sh:336: -H "Cookie: lng=eng" \
./hosts/bowfile.sh:337: -H "Upgrade-Insecure-Requests: 1" \
./hosts/bowfile.sh:338: -H "Sec-Fetch-Dest: document" \
./hosts/bowfile.sh:339: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/click.sh:143: response=$(tor_curl_request --insecure -L -s -b "${click_cookie_jar}" -c "${click_cookie_jar}" \
./hosts/click.sh:144: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/click.sh:145: "$fixed_url")
./hosts/click.sh:146: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/click.sh:147: debugHtml "${remote_url##*/}" "click_fetch$i" "${response}"
./hosts/click.sh:148: fi
./hosts/click.sh:149: if [[ -z $response ]] ; then
./hosts/click.sh:150: rm -f "${click_cookie_jar}";
./hosts/click.sh:151: if [[ $i == $maxfetchretries ]] ; then
./hosts/click.sh:152: printf "\\n"
./hosts/click.sh:153: echo -e "${RED}| Failed to extract download link [1].${NC}"
--
./hosts/click.sh:226: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/click.sh:227: -b "${click_cookie_jar}" -c "${click_cookie_jar}" \
./hosts/click.sh:228: --data "$form_data" "$fixed_url")
./hosts/click.sh:229: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/click.sh:230: debugHtml "${remote_url##*/}" "click_post1_$i" "url: ${fixed_url}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/click.sh:231: fi
./hosts/click.sh:232: if [[ -z $response ]] ; then
./hosts/click.sh:233: if [[ $i == $maxfetchretries ]] ; then
./hosts/click.sh:234: rm -f "${click_cookie_jar}";
./hosts/click.sh:235: printf "\\n"
./hosts/click.sh:236: echo -e "${RED}| Failed to extract download link [2].${NC}"
--
./hosts/click.sh:345: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/click.sh:346: -b "${click_cookie_jar}" -c "${click_cookie_jar}" \
./hosts/click.sh:347: --data "$form_data" "$fixed_url")
./hosts/click.sh:348: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/click.sh:349: debugHtml "${remote_url##*/}" "click_post2_$i" "url: ${fixed_url}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/click.sh:350: fi
./hosts/click.sh:351: if [[ -z $response ]] ; then
./hosts/click.sh:352: if [[ $i == $maxfetchretries ]] ; then
./hosts/click.sh:353: rm -f "${click_cookie_jar}";
./hosts/click.sh:354: printf "\\n"
./hosts/click.sh:355: echo -e "${RED}| Failed to extract download link [3].${NC}"
--
./hosts/click.sh:434: file_header=$(tor_curl_request --insecure -L --head -s --referer "${fixed_url}" "$download_url")
./hosts/click.sh:435: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/click.sh:436: debugHtml "${remote_url##*/}" "click_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/click.sh:437: fi
./hosts/click.sh:438: if [[ -z $file_header ]] ; then
./hosts/click.sh:439: if [[ $j == $maxfetchretries ]] ; then
./hosts/click.sh:440: rm -f "${click_cookie_jar}";
./hosts/click.sh:441: printf "\\n"
./hosts/click.sh:442: echo -e "${RED}| Failed to extract file info${NC}"
./hosts/click.sh:443: warnAndRetryUnknownError=true
./hosts/click.sh:444: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/click.sh:535: tor_curl_request --insecure \
./hosts/click.sh:536: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/click.sh:537: -b "${click_cookie_jar}" -c "${click_cookie_jar}" \
./hosts/click.sh:538: -H "Host: $click_host" \
./hosts/click.sh:539: --referer "$post_referer" \
./hosts/click.sh:540: "$download_url" --continue-at - --output "$file_path"
./hosts/click.sh:541: else
./hosts/click.sh:542: tor_curl_request --insecure \
./hosts/click.sh:543: -b "${click_cookie_jar}" -c "${click_cookie_jar}" \
./hosts/click.sh:544: -H "Host: $click_host" \
./hosts/click.sh:545: --referer "$post_referer" \
./hosts/click.sh:546: "$download_url" --continue-at - --output "$file_path"
./hosts/click.sh:547: fi
./hosts/click.sh:548: else
./hosts/click.sh:549: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/click.sh:550: tor_curl_request --insecure \
./hosts/click.sh:551: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/click.sh:552: -b "${click_cookie_jar}" -c "${click_cookie_jar}" \
./hosts/click.sh:553: -H "Host: $click_host" \
./hosts/click.sh:554: -H "User-Agent: $RandomUA" \
./hosts/click.sh:555: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/click.sh:556: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/click.sh:557: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/click.sh:558: -H "Connection: keep-alive" \
./hosts/click.sh:559: -H "Cookie: lng=eng" \
./hosts/click.sh:560: -H "Upgrade-Insecure-Requests: 1" \
--
./hosts/click.sh:568: tor_curl_request --insecure \
./hosts/click.sh:569: -b "${click_cookie_jar}" -c "${click_cookie_jar}" \
./hosts/click.sh:570: -H "Host: $click_host" \
./hosts/click.sh:571: -H "User-Agent: $RandomUA" \
./hosts/click.sh:572: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/click.sh:573: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/click.sh:574: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/click.sh:575: -H "Connection: keep-alive" \
./hosts/click.sh:576: -H "Cookie: lng=eng" \
./hosts/click.sh:577: -H "Upgrade-Insecure-Requests: 1" \
./hosts/click.sh:578: -H "Sec-Fetch-Dest: document" \
--
./hosts/dailyuploads.sh:97: response=$(tor_curl_request --insecure -L -s -b "${daily_cookie_jar}" -c "${daily_cookie_jar}" \
./hosts/dailyuploads.sh:98: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/dailyuploads.sh:99: "$fixed_url")
./hosts/dailyuploads.sh:100: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dailyuploads.sh:101: debugHtml "${remote_url##*/}" "daily_fetch$i" "${response}"
./hosts/dailyuploads.sh:102: fi
./hosts/dailyuploads.sh:103: if [[ -z $response ]] ; then
./hosts/dailyuploads.sh:104: rm -f "${daily_cookie_jar}";
./hosts/dailyuploads.sh:105: if [[ $i == $maxfetchretries ]] ; then
./hosts/dailyuploads.sh:106: printf "\\n"
./hosts/dailyuploads.sh:107: echo -e "${RED}| Failed to extract download link [1].${NC}"
--
./hosts/dailyuploads.sh:139: tor_curl_request --insecure -s "$captcha_img_url" --output "$tmp_captcha_img"
./hosts/dailyuploads.sh:140: captcha_ocr_output=$(CaptchaOcrImageTesseract "$tmp_captcha_img" "NUMBERONLY" "ContrastStretch_5x90,Brightness_130")
./hosts/dailyuploads.sh:141: if [[ "${DebugPluginsEnabled}" == "true" ]]; then
./hosts/dailyuploads.sh:142: printf "\\n"
./hosts/dailyuploads.sh:143: echo -e "$captcha_ocr_output"
./hosts/dailyuploads.sh:144: fi
./hosts/dailyuploads.sh:145: captcha_code=$(grep -oP -m 1 "(?<=\[CAPTCHA_CODE\:).*?(?=\])" <<< "$captcha_ocr_output")
./hosts/dailyuploads.sh:146: rm -f "$tmp_captcha_img"
./hosts/dailyuploads.sh:147: rm -f "$captcha_ocr_output"
./hosts/dailyuploads.sh:148: local caplength=${#captcha_code}
./hosts/dailyuploads.sh:149: if [[ -z "$captcha_code" ]] || ((caplength != 4)) ; then
--
./hosts/dailyuploads.sh:286: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/dailyuploads.sh:287: -b "${daily_cookie_jar}" -c "${daily_cookie_jar}" \
./hosts/dailyuploads.sh:288: --data "$form_data" "$fixed_url")
./hosts/dailyuploads.sh:289: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dailyuploads.sh:290: debugHtml "${remote_url##*/}" "daily_post2_$i" "url: ${fixed_url}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/dailyuploads.sh:291: fi
./hosts/dailyuploads.sh:292: fi
./hosts/dailyuploads.sh:293: if [[ -z $response ]] ; then
./hosts/dailyuploads.sh:294: if [[ $i == $maxfetchretries ]] ; then
./hosts/dailyuploads.sh:295: rm -f "${daily_cookie_jar}";
./hosts/dailyuploads.sh:296: printf "\\n"
--
./hosts/dailyuploads.sh:392: file_header=$(tor_curl_request -i -s --head \
./hosts/dailyuploads.sh:393: -b "${daily_cookie_jar}" -c "${daily_cookie_jar}" \
./hosts/dailyuploads.sh:394: --referer "${fixed_url}" \
./hosts/dailyuploads.sh:395: "$download_url")
./hosts/dailyuploads.sh:396: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dailyuploads.sh:397: debugHtml "${remote_url##*/}" "daily_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/dailyuploads.sh:398: fi
./hosts/dailyuploads.sh:399: if [[ -z $file_header ]] ; then
./hosts/dailyuploads.sh:400: if [[ $j == $maxfetchretries ]] ; then
./hosts/dailyuploads.sh:401: rm -f "${daily_cookie_jar}";
./hosts/dailyuploads.sh:402: printf "\\n"
--
./hosts/dailyuploads.sh:498: tor_curl_request --insecure \
./hosts/dailyuploads.sh:499: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/dailyuploads.sh:500: -b "${daily_cookie_jar}" -c "${daily_cookie_jar}" \
./hosts/dailyuploads.sh:501: --referer "${fixed_url}" \
./hosts/dailyuploads.sh:502: "$download_url" --continue-at - --output "$file_path"
./hosts/dailyuploads.sh:503: else
./hosts/dailyuploads.sh:504: tor_curl_request --insecure \
./hosts/dailyuploads.sh:505: -b "${daily_cookie_jar}" -c "${daily_cookie_jar}" \
./hosts/dailyuploads.sh:506: --referer "${fixed_url}" \
./hosts/dailyuploads.sh:507: "$download_url" --continue-at - --output "$file_path"
./hosts/dailyuploads.sh:508: fi
./hosts/dailyuploads.sh:509: else
./hosts/dailyuploads.sh:510: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/dailyuploads.sh:511: tor_curl_request --insecure \
./hosts/dailyuploads.sh:512: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/dailyuploads.sh:513: -H "User-Agent: $RandomUA" \
./hosts/dailyuploads.sh:514: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/dailyuploads.sh:515: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/dailyuploads.sh:516: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/dailyuploads.sh:517: -H "Connection: keep-alive" \
./hosts/dailyuploads.sh:518: -H "Cookie: lng=eng" \
./hosts/dailyuploads.sh:519: -H "Upgrade-Insecure-Requests: 1" \
./hosts/dailyuploads.sh:520: -H "Sec-Fetch-Dest: document" \
./hosts/dailyuploads.sh:521: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/dailyuploads.sh:528: tor_curl_request --insecure \
./hosts/dailyuploads.sh:529: -H "User-Agent: $RandomUA" \
./hosts/dailyuploads.sh:530: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/dailyuploads.sh:531: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/dailyuploads.sh:532: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/dailyuploads.sh:533: -H "Connection: keep-alive" \
./hosts/dailyuploads.sh:534: -H "Cookie: lng=eng" \
./hosts/dailyuploads.sh:535: -H "Upgrade-Insecure-Requests: 1" \
./hosts/dailyuploads.sh:536: -H "Sec-Fetch-Dest: document" \
./hosts/dailyuploads.sh:537: -H "Sec-Fetch-Mode: navigate" \
./hosts/dailyuploads.sh:538: -H "Sec-Fetch-Site: same-origin" \
--
./hosts/dashfile.sh:90: response=$(tor_curl_request --insecure -L -s -b "${dash_cookie_jar}" -c "${dash_cookie_jar}" \
./hosts/dashfile.sh:91: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/dashfile.sh:92: "$remote_url")
./hosts/dashfile.sh:93: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dashfile.sh:94: debugHtml "${remote_url##*/}" "dash_fetch$i" "${response}"
./hosts/dashfile.sh:95: fi
./hosts/dashfile.sh:96: if [[ -z $response ]] ; then
./hosts/dashfile.sh:97: rm -f "${dash_cookie_jar}";
./hosts/dashfile.sh:98: if [[ $i == $maxfetchretries ]] ; then
./hosts/dashfile.sh:99: printf "\\n"
./hosts/dashfile.sh:100: echo -e "${RED}| Failed to extract download link [1]${NC}"
--
./hosts/dashfile.sh:177: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/dashfile.sh:178: -b "${dash_cookie_jar}" -c "${dash_cookie_jar}" \
./hosts/dashfile.sh:179: --data "$form_data" "$remote_url")
./hosts/dashfile.sh:180: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dashfile.sh:181: debugHtml "${remote_url##*/}" "dash_post1_$i" "url: ${remote_url}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/dashfile.sh:182: fi
./hosts/dashfile.sh:183: if [[ -z $response ]] ; then
./hosts/dashfile.sh:184: if [[ $i == $maxfetchretries ]] ; then
./hosts/dashfile.sh:185: rm -f "${dash_cookie_jar}";
./hosts/dashfile.sh:186: printf "\\n"
./hosts/dashfile.sh:187: echo -e "${RED}| Failed to extract download link [4]${NC}"
--
./hosts/dashfile.sh:308: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/dashfile.sh:309: -b "${dash_cookie_jar}" -c "${dash_cookie_jar}" \
./hosts/dashfile.sh:310: --data "$form_data" "$remote_url")
./hosts/dashfile.sh:311: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dashfile.sh:312: debugHtml "${remote_url##*/}" "dash_post2_$i" "url: ${remote_url}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/dashfile.sh:313: fi
./hosts/dashfile.sh:314: if [[ -z $response ]] ; then
./hosts/dashfile.sh:315: if [[ $i == $maxfetchretries ]] ; then
./hosts/dashfile.sh:316: rm -f "${dash_cookie_jar}";
./hosts/dashfile.sh:317: printf "\\n"
./hosts/dashfile.sh:318: echo -e "${RED}| Failed to extract download link [7]${NC}"
--
./hosts/dashfile.sh:397: file_header=$(tor_curl_request --insecure -L --head -s --referer "${fixed_url}" "$download_url")
./hosts/dashfile.sh:398: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dashfile.sh:399: debugHtml "${remote_url##*/}" "dash_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/dashfile.sh:400: fi
./hosts/dashfile.sh:401: if [[ -z $file_header ]] ; then
./hosts/dashfile.sh:402: if [[ $j == $maxfetchretries ]] ; then
./hosts/dashfile.sh:403: rm -f "${dash_cookie_jar}";
./hosts/dashfile.sh:404: printf "\\n"
./hosts/dashfile.sh:405: echo -e "${RED}| Failed to extract file info${NC}"
./hosts/dashfile.sh:406: warnAndRetryUnknownError=true
./hosts/dashfile.sh:407: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/dashfile.sh:497: tor_curl_request --insecure \
./hosts/dashfile.sh:498: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/dashfile.sh:499: -b "${dash_cookie_jar}" -c "${dash_cookie_jar}" \
./hosts/dashfile.sh:500: "$download_url" --continue-at - --output "$file_path"
./hosts/dashfile.sh:501: else
./hosts/dashfile.sh:502: tor_curl_request --insecure \
./hosts/dashfile.sh:503: -b "${dash_cookie_jar}" -c "${dash_cookie_jar}" \
./hosts/dashfile.sh:504: "$download_url" --continue-at - --output "$file_path"
./hosts/dashfile.sh:505: fi
./hosts/dashfile.sh:506: else
./hosts/dashfile.sh:507: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/dashfile.sh:508: tor_curl_request --insecure \
./hosts/dashfile.sh:509: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/dashfile.sh:510: -b "${dash_cookie_jar}" -c "${dash_cookie_jar}" \
./hosts/dashfile.sh:511: -H "User-Agent: $RandomUA" \
./hosts/dashfile.sh:512: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/dashfile.sh:513: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/dashfile.sh:514: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/dashfile.sh:515: -H "Connection: keep-alive" \
./hosts/dashfile.sh:516: -H "Cookie: lng=eng" \
./hosts/dashfile.sh:517: -H "Upgrade-Insecure-Requests: 1" \
./hosts/dashfile.sh:518: -H "Sec-Fetch-Dest: document" \
--
./hosts/dashfile.sh:524: tor_curl_request --insecure \
./hosts/dashfile.sh:525: -b "${dash_cookie_jar}" -c "${dash_cookie_jar}" \
./hosts/dashfile.sh:526: -H "User-Agent: $RandomUA" \
./hosts/dashfile.sh:527: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/dashfile.sh:528: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/dashfile.sh:529: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/dashfile.sh:530: -H "Connection: keep-alive" \
./hosts/dashfile.sh:531: -H "Cookie: lng=eng" \
./hosts/dashfile.sh:532: -H "Upgrade-Insecure-Requests: 1" \
./hosts/dashfile.sh:533: -H "Sec-Fetch-Dest: document" \
./hosts/dashfile.sh:534: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/dataupload.sh:90: response=$(tor_curl_request --insecure -L -s -b "${dup_cookie_jar}" -c "${dup_cookie_jar}" "$remote_url")
./hosts/dataupload.sh:91: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dataupload.sh:92: debugHtml "${remote_url##*/}" "dup_dwnpage$i" "${response}"
./hosts/dataupload.sh:93: fi
./hosts/dataupload.sh:94: if [[ -z $response ]] ; then
./hosts/dataupload.sh:95: rm -f "${dup_cookie_jar}";
./hosts/dataupload.sh:96: if [[ $i == $maxfetchretries ]] ; then
./hosts/dataupload.sh:97: printf "\\n"
./hosts/dataupload.sh:98: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/dataupload.sh:99: warnAndRetryUnknownError=true
./hosts/dataupload.sh:100: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/dataupload.sh:166: response=$(tor_curl_request --insecure -svo. -X POST \
./hosts/dataupload.sh:167: -b "${dup_cookie_jar}" -c "${dup_cookie_jar}" \
./hosts/dataupload.sh:168: --data-raw "$form_data" "$post_action" 2>&1)
./hosts/dataupload.sh:169: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dataupload.sh:170: debugHtml "${remote_url##*/}" "dup_post" "post_action: ${post_action}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/dataupload.sh:171: fi
./hosts/dataupload.sh:172: if [[ -z $response ]] ; then
./hosts/dataupload.sh:173: if [[ $i == $maxfetchretries ]] ; then
./hosts/dataupload.sh:174: rm -f "${dup_cookie_jar}";
./hosts/dataupload.sh:175: printf "\\n"
./hosts/dataupload.sh:176: echo -e "${RED}| Failed to extract download link [3].${NC}"
--
./hosts/dataupload.sh:234: file_header=$(tor_curl_request --insecure -L --head -s "$download_url")
./hosts/dataupload.sh:235: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dataupload.sh:236: debugHtml "${remote_url##*/}" "dup_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/dataupload.sh:237: fi
./hosts/dataupload.sh:238: if [[ -z $file_header ]] ; then
./hosts/dataupload.sh:239: if [[ $j == $maxfetchretries ]] ; then
./hosts/dataupload.sh:240: rm -f "${dup_cookie_jar}";
./hosts/dataupload.sh:241: printf "\\n"
./hosts/dataupload.sh:242: echo -e "${RED}| Failed to extract file info [1]${NC}"
./hosts/dataupload.sh:243: warnAndRetryUnknownError=true
./hosts/dataupload.sh:244: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/dataupload.sh:351: tor_curl_request --insecure \
./hosts/dataupload.sh:352: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/dataupload.sh:353: -b "${dup_cookie_jar}" -c "${dup_cookie_jar}" \
./hosts/dataupload.sh:354: -H "Host: dataupload.net" \
./hosts/dataupload.sh:355: "$download_url" --continue-at - --output "$file_path"
./hosts/dataupload.sh:356: else
./hosts/dataupload.sh:357: tor_curl_request --insecure \
./hosts/dataupload.sh:358: -b "${dup_cookie_jar}" -c "${dup_cookie_jar}" \
./hosts/dataupload.sh:359: -H "Host: dataupload.net" \
./hosts/dataupload.sh:360: "$download_url" --continue-at - --output "$file_path"
./hosts/dataupload.sh:361: fi
./hosts/dataupload.sh:362: else
./hosts/dataupload.sh:363: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/dataupload.sh:364: tor_curl_request --insecure \
./hosts/dataupload.sh:365: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/dataupload.sh:366: -b "${dup_cookie_jar}" -c "${dup_cookie_jar}" \
./hosts/dataupload.sh:367: -H "Host: dataupload.net" \
./hosts/dataupload.sh:368: -H "User-Agent: $RandomUA" \
./hosts/dataupload.sh:369: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/dataupload.sh:370: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/dataupload.sh:371: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/dataupload.sh:372: -H "Connection: keep-alive" \
./hosts/dataupload.sh:373: -H "Cookie: lng=eng" \
./hosts/dataupload.sh:374: -H "Upgrade-Insecure-Requests: 1" \
--
./hosts/dataupload.sh:381: tor_curl_request --insecure \
./hosts/dataupload.sh:382: -b "${dup_cookie_jar}" -c "${dup_cookie_jar}" \
./hosts/dataupload.sh:383: -H "Host: dataupload.net" \
./hosts/dataupload.sh:384: -H "User-Agent: $RandomUA" \
./hosts/dataupload.sh:385: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/dataupload.sh:386: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/dataupload.sh:387: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/dataupload.sh:388: -H "Connection: keep-alive" \
./hosts/dataupload.sh:389: -H "Cookie: lng=eng" \
./hosts/dataupload.sh:390: -H "Upgrade-Insecure-Requests: 1" \
./hosts/dataupload.sh:391: -H "Sec-Fetch-Dest: document" \
--
./hosts/desiupload.sh:90: response=$(tor_curl_request --insecure -L -s -b "${desi_cookie_jar}" -c "${desi_cookie_jar}" "$remote_url")
./hosts/desiupload.sh:91: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/desiupload.sh:92: debugHtml "${remote_url##*/}" "desi_fetch$i" "${response}"
./hosts/desiupload.sh:93: fi
./hosts/desiupload.sh:94: if [[ -z $response ]] ; then
./hosts/desiupload.sh:95: rm -f "${desi_cookie_jar}";
./hosts/desiupload.sh:96: if [[ $i == $maxfetchretries ]] ; then
./hosts/desiupload.sh:97: printf "\\n"
./hosts/desiupload.sh:98: echo -e "${RED}| Failed to extract download link [1]${NC}"
./hosts/desiupload.sh:99: warnAndRetryUnknownError=true
./hosts/desiupload.sh:100: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/desiupload.sh:202: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/desiupload.sh:203: -b "${desi_cookie_jar}" -c "${desi_cookie_jar}" \
./hosts/desiupload.sh:204: --data "$form_data" "$remote_url")
./hosts/desiupload.sh:205: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/desiupload.sh:206: debugHtml "${remote_url##*/}" "desi_post_$i" "url: ${remote_url}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/desiupload.sh:207: fi
./hosts/desiupload.sh:208: if [[ -z $response ]] ; then
./hosts/desiupload.sh:209: if [[ $i == $maxfetchretries ]] ; then
./hosts/desiupload.sh:210: rm -f "${desi_cookie_jar}";
./hosts/desiupload.sh:211: printf "\\n"
./hosts/desiupload.sh:212: echo -e "${RED}| Failed to extract download link [7]${NC}"
--
./hosts/desiupload.sh:306: file_header=$(tor_curl_request --insecure -L --head -s --referer "${fixed_url}" "$download_url")
./hosts/desiupload.sh:307: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/desiupload.sh:308: debugHtml "${remote_url##*/}" "desi_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/desiupload.sh:309: fi
./hosts/desiupload.sh:310: if [[ -z $file_header ]] ; then
./hosts/desiupload.sh:311: if [[ $j == $maxfetchretries ]] ; then
./hosts/desiupload.sh:312: rm -f "${desi_cookie_jar}";
./hosts/desiupload.sh:313: printf "\\n"
./hosts/desiupload.sh:314: echo -e "${RED}| Failed to extract file info${NC}"
./hosts/desiupload.sh:315: warnAndRetryUnknownError=true
./hosts/desiupload.sh:316: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/desiupload.sh:406: tor_curl_request --insecure \
./hosts/desiupload.sh:407: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/desiupload.sh:408: -b "${desi_cookie_jar}" -c "${desi_cookie_jar}" \
./hosts/desiupload.sh:409: "$download_url" --continue-at - --output "$file_path"
./hosts/desiupload.sh:410: else
./hosts/desiupload.sh:411: tor_curl_request --insecure \
./hosts/desiupload.sh:412: -b "${desi_cookie_jar}" -c "${desi_cookie_jar}" \
./hosts/desiupload.sh:413: "$download_url" --continue-at - --output "$file_path"
./hosts/desiupload.sh:414: fi
./hosts/desiupload.sh:415: else
./hosts/desiupload.sh:416: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/desiupload.sh:417: tor_curl_request --insecure \
./hosts/desiupload.sh:418: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/desiupload.sh:419: -b "${desi_cookie_jar}" -c "${desi_cookie_jar}" \
./hosts/desiupload.sh:420: -H "User-Agent: $RandomUA" \
./hosts/desiupload.sh:421: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/desiupload.sh:422: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/desiupload.sh:423: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/desiupload.sh:424: -H "Connection: keep-alive" \
./hosts/desiupload.sh:425: -H "Cookie: lng=eng" \
./hosts/desiupload.sh:426: -H "Upgrade-Insecure-Requests: 1" \
./hosts/desiupload.sh:427: -H "Sec-Fetch-Dest: document" \
--
./hosts/desiupload.sh:433: tor_curl_request --insecure \
./hosts/desiupload.sh:434: -b "${desi_cookie_jar}" -c "${desi_cookie_jar}" \
./hosts/desiupload.sh:435: -H "User-Agent: $RandomUA" \
./hosts/desiupload.sh:436: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/desiupload.sh:437: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/desiupload.sh:438: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/desiupload.sh:439: -H "Connection: keep-alive" \
./hosts/desiupload.sh:440: -H "Cookie: lng=eng" \
./hosts/desiupload.sh:441: -H "Upgrade-Insecure-Requests: 1" \
./hosts/desiupload.sh:442: -H "Sec-Fetch-Dest: document" \
./hosts/desiupload.sh:443: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/dosya.sh:109: PAGE=$(tor_curl_request --insecure --max-time "$ConnectTimeout" -L -s \
./hosts/dosya.sh:110: -c "${dosya_cookie_jar}" \
./hosts/dosya.sh:111: "${remote_url}")
./hosts/dosya.sh:112: else
./hosts/dosya.sh:113: PAGE=$(tor_curl_request --insecure --max-time "$ConnectTimeout" -L -s \
./hosts/dosya.sh:114: -H "User-Agent: $RandomUA" \
./hosts/dosya.sh:115: -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8' \
./hosts/dosya.sh:116: -H 'Accept-Language: en-US,en;q=0.5' \
./hosts/dosya.sh:117: -H 'Accept-Encoding: gzip, deflate, br' -H 'Connection: keep-alive' -H 'Upgrade-Insecure-Requests: 1' \
./hosts/dosya.sh:118: -H 'Sec-Fetch-Dest: document' -H 'Sec-Fetch-Mode: navigate' -H 'Sec-Fetch-Site: none' -H 'Sec-Fetch-User: ?1' \
./hosts/dosya.sh:119: -c "${dosya_cookie_jar}" \
./hosts/dosya.sh:120: "${remote_url}")
./hosts/dosya.sh:121: fi
./hosts/dosya.sh:122: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/dosya.sh:123: debugHtml "${remote_url##*/}" "dos_fetch_$i" "remote_url: ${remote_url}"$'\n'"User-Agent: $RandomUA"$'\n'"${PAGE}"
--
./hosts/dosya.sh:173: file_header=$(tor_curl_request_extended --insecure --head -L -s \
./hosts/dosya.sh:174: -H "Cookie: filehosting=$cookie_filehosting" \
./hosts/dosya.sh:175: -H "Host: www.dosyaupload.com" \
./hosts/dosya.sh:176: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/dosya.sh:177: -b "${dosya_cookie_jar}" -c "${dosya_cookie_jar}" "$dos_url")
./hosts/dosya.sh:178: else
./hosts/dosya.sh:179: file_header=$(tor_curl_request_extended --insecure --head -L -s \
./hosts/dosya.sh:180: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/dosya.sh:181: -H "User-Agent: $RandomUA" \
./hosts/dosya.sh:182: -H "Cookie: filehosting=$cookie_filehosting" \
./hosts/dosya.sh:183: -H "Host: www.dosyaupload.com" \
./hosts/dosya.sh:184: -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8' \
./hosts/dosya.sh:185: -H 'Accept-Language: en-US,en;q=0.5' \
./hosts/dosya.sh:186: -H 'Accept-Encoding: gzip, deflate, br' \
./hosts/dosya.sh:187: -H 'Connection: keep-alive' -H 'Upgrade-Insecure-Requests: 1' \
./hosts/dosya.sh:188: -H 'Sec-Fetch-Dest: document' -H 'Sec-Fetch-Mode: navigate' -H 'Sec-Fetch-Site: none' -H 'Sec-Fetch-User: ?1' \
./hosts/dosya.sh:189: -b "${dosya_cookie_jar}" -c "${dosya_cookie_jar}" "$dos_url")
--
./hosts/dosya.sh:402: tor_curl_request -L -G --insecure \
./hosts/dosya.sh:403: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/jxl,image/webp,*/*;q=0.8" \
./hosts/dosya.sh:404: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/dosya.sh:405: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/dosya.sh:406: -H "Connection: keep-alive" \
./hosts/dosya.sh:407: -H "Upgrade-Insecure-Requests: 1" \
./hosts/dosya.sh:408: -H "Sec-Fetch-Dest: document" \
./hosts/dosya.sh:409: -H "Sec-Fetch-Mode: navigate" \
./hosts/dosya.sh:410: -H "Sec-Fetch-Site: none" \
./hosts/dosya.sh:411: -H "Sec-Fetch-User: ?1" \
./hosts/dosya.sh:412: -H "DNT: 1" \
--
./hosts/dosya.sh:417: tor_curl_request -L -G --insecure \
./hosts/dosya.sh:418: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/jxl,image/webp,*/*;q=0.8" \
./hosts/dosya.sh:419: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/dosya.sh:420: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/dosya.sh:421: -H "Connection: keep-alive" \
./hosts/dosya.sh:422: -H "Upgrade-Insecure-Requests: 1" \
./hosts/dosya.sh:423: -H "Sec-Fetch-Dest: document" \
./hosts/dosya.sh:424: -H "Sec-Fetch-Mode: navigate" \
./hosts/dosya.sh:425: -H "Sec-Fetch-Site: none" \
./hosts/dosya.sh:426: -H "Sec-Fetch-User: ?1" \
./hosts/dosya.sh:427: -H "DNT: 1" \
--
./hosts/downloadgg.sh:90: response=$(tor_curl_request --insecure -L -s -b "${dgg_cookie_jar}" -c "${dgg_cookie_jar}" "$remote_url")
./hosts/downloadgg.sh:91: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/downloadgg.sh:92: debugHtml "${remote_url##*/}" "dgg_dwnpage$i" "${response}"
./hosts/downloadgg.sh:93: fi
./hosts/downloadgg.sh:94: if [[ -z $response ]] ; then
./hosts/downloadgg.sh:95: rm -f "${dgg_cookie_jar}";
./hosts/downloadgg.sh:96: if [[ $i == $maxfetchretries ]] ; then
./hosts/downloadgg.sh:97: printf "\\n"
./hosts/downloadgg.sh:98: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/downloadgg.sh:99: warnAndRetryUnknownError=true
./hosts/downloadgg.sh:100: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/downloadgg.sh:169: response=$(tor_curl_request --insecure -svo. -X POST \
./hosts/downloadgg.sh:170: -b "${dgg_cookie_jar}" -c "${dgg_cookie_jar}" \
./hosts/downloadgg.sh:171: --data-raw "$form_data" "$post_action" 2>&1)
./hosts/downloadgg.sh:172: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/downloadgg.sh:173: debugHtml "${remote_url##*/}" "dgg_post" "post_action: ${post_action}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/downloadgg.sh:174: fi
./hosts/downloadgg.sh:175: if [[ -z $response ]] ; then
./hosts/downloadgg.sh:176: echo -e "${RED}| Failed to extract download link${NC}"
./hosts/downloadgg.sh:177: warnAndRetryUnknownError=true
./hosts/downloadgg.sh:178: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/downloadgg.sh:179: rm -f "${dgg_cookie_jar}";
--
./hosts/downloadgg.sh:257: tor_curl_request --insecure -X POST \
./hosts/downloadgg.sh:258: -b "${dgg_cookie_jar}" -c "${dgg_cookie_jar}" --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/downloadgg.sh:259: -H "Host: download.gg" \
./hosts/downloadgg.sh:260: -H "Origin: https://download.gg" \
./hosts/downloadgg.sh:261: --referer "$remote_url" \
./hosts/downloadgg.sh:262: --data "$form_data" "$post_action" \
./hosts/downloadgg.sh:263: --output "$file_path"
./hosts/downloadgg.sh:264: else
./hosts/downloadgg.sh:265: tor_curl_request --insecure -X POST \
./hosts/downloadgg.sh:266: -b "${dgg_cookie_jar}" -c "${dgg_cookie_jar}" \
./hosts/downloadgg.sh:267: -H "Host: download.gg" \
./hosts/downloadgg.sh:268: -H "Origin: https://download.gg" \
./hosts/downloadgg.sh:269: --referer "$remote_url" \
./hosts/downloadgg.sh:270: --data "$form_data" "$post_action" \
./hosts/downloadgg.sh:271: --output "$file_path"
./hosts/downloadgg.sh:272: fi
./hosts/downloadgg.sh:273: else
./hosts/downloadgg.sh:274: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/downloadgg.sh:275: tor_curl_request --insecure -X POST \
./hosts/downloadgg.sh:276: -b "${dgg_cookie_jar}" -c "${dgg_cookie_jar}" --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/downloadgg.sh:277: -H "Host: download.gg" \
./hosts/downloadgg.sh:278: -H "Origin: https://download.gg" \
./hosts/downloadgg.sh:279: -H "User-Agent: $RandomUA" \
./hosts/downloadgg.sh:280: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/downloadgg.sh:281: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/downloadgg.sh:282: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/downloadgg.sh:283: -H "Connection: keep-alive" \
./hosts/downloadgg.sh:284: -H "Cookie: lng=eng" \
./hosts/downloadgg.sh:285: -H "Upgrade-Insecure-Requests: 1" \
--
./hosts/downloadgg.sh:294: tor_curl_request --insecure -X POST \
./hosts/downloadgg.sh:295: -b "${dgg_cookie_jar}" -c "${dgg_cookie_jar}" \
./hosts/downloadgg.sh:296: -H "Host: download.gg" \
./hosts/downloadgg.sh:297: -H "Origin: https://download.gg" \
./hosts/downloadgg.sh:298: -H "User-Agent: $RandomUA" \
./hosts/downloadgg.sh:299: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/downloadgg.sh:300: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/downloadgg.sh:301: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/downloadgg.sh:302: -H "Connection: keep-alive" \
./hosts/downloadgg.sh:303: -H "Cookie: lng=eng" \
./hosts/downloadgg.sh:304: -H "Upgrade-Insecure-Requests: 1" \
--
./hosts/examples/ExampleNewHost.sh:102: file_header=$(tor_curl_request --insecure -L --head -s --referer "${remote_url//\.org/\.cc}" "$download_url")
./hosts/examples/ExampleNewHost.sh:103: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/examples/ExampleNewHost.sh:104: debugHtml "${remote_url##*/}" "fh_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/examples/ExampleNewHost.sh:105: fi
./hosts/examples/ExampleNewHost.sh:106: if [[ ! -z "$file_header" ]] ; then
./hosts/examples/ExampleNewHost.sh:107: if grep -Eqi '404 Not Found' <<< "${file_header}" ; then
./hosts/examples/ExampleNewHost.sh:108: if [[ $j == $maxfetchretries ]] ; then
./hosts/examples/ExampleNewHost.sh:109: printf "\\n"
./hosts/examples/ExampleNewHost.sh:110: echo -e "${RED}| The file has been removed (404).${NC}"
./hosts/examples/ExampleNewHost.sh:111: removedDownload "${remote_url}"
./hosts/examples/ExampleNewHost.sh:112: exitDownloadNotAvailable=true
--
./hosts/examples/ExampleNewHost.sh:199: tor_curl_request --insecure --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval --referer "$download_url" "$download_url" --continue-at - --output "$file_path"
./hosts/examples/ExampleNewHost.sh:200: else
./hosts/examples/ExampleNewHost.sh:201: tor_curl_request --insecure --referer "$download_url" "$download_url" --continue-at - --output "$file_path"
./hosts/examples/ExampleNewHost.sh:202: fi
./hosts/examples/ExampleNewHost.sh:203: received_file_size=0
./hosts/examples/ExampleNewHost.sh:204: if [[ -f "$file_path" ]] ; then
./hosts/examples/ExampleNewHost.sh:205: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/examples/ExampleNewHost.sh:206: fi
./hosts/examples/ExampleNewHost.sh:207: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/examples/ExampleNewHost.sh:208: containsHtml=false
./hosts/examples/ExampleNewHost.sh:209: else
./hosts/examples/ExampleNewHost.sh:210: containsHtml=true
./hosts/examples/ExampleNewHost.sh:211: fi
--
./hosts/examples/up_example.sh:112: response=$(tor_curl_upload --insecure \
./hosts/examples/up_example.sh:113: -F "files[]=@${arrFiles[@]}" \
./hosts/examples/up_example.sh:114: -F "expire=129600" \
./hosts/examples/up_example.sh:115: -F "autodestroy=0" \
./hosts/examples/up_example.sh:116: -F "randomizefn=0" \
./hosts/examples/up_example.sh:117: -F "shorturl=0" \
./hosts/examples/up_example.sh:118: "${PostUrlHost}")
./hosts/examples/up_example.sh:119: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/examples/up_example.sh:120: debugHtml "${remote_url##*/}" "${_hostCode}_dwnpage$j" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/examples/up_example.sh:121: fi
./hosts/examples/up_example.sh:122: successUpload "$pline" "${filepath}" "${_hostCode}" "${filesize}" "${downloadLink}" "{$responseHtml}"
--
./hosts/fileblade.sh:90: response=$(tor_curl_request --insecure -L -s -b "${fb_cookie_jar}" -c "${fb_cookie_jar}" "$remote_url")
./hosts/fileblade.sh:91: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/fileblade.sh:92: debugHtml "${remote_url##*/}" "fb_dwnpage$i" "${response}"
./hosts/fileblade.sh:93: fi
./hosts/fileblade.sh:94: if [[ -z $response ]] ; then
./hosts/fileblade.sh:95: rm -f "${fb_cookie_jar}";
./hosts/fileblade.sh:96: if [[ $i == $maxfetchretries ]] ; then
./hosts/fileblade.sh:97: printf "\\n"
./hosts/fileblade.sh:98: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/fileblade.sh:99: warnAndRetryUnknownError=true
./hosts/fileblade.sh:100: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/fileblade.sh:165: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/fileblade.sh:166: -b "${fb_cookie_jar}" -c "${fb_cookie_jar}" \
./hosts/fileblade.sh:167: --data "$form_data" "$post_action")
./hosts/fileblade.sh:168: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/fileblade.sh:169: debugHtml "${remote_url##*/}" "fb_post(1)" "post_action: ${post_action}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/fileblade.sh:170: fi
./hosts/fileblade.sh:171: if [[ -z $response ]] ; then
./hosts/fileblade.sh:172: if [[ $i == $maxfetchretries ]] ; then
./hosts/fileblade.sh:173: rm -f "${fb_cookie_jar}";
./hosts/fileblade.sh:174: printf "\\n"
./hosts/fileblade.sh:175: echo -e "${RED}| Failed to extract download link [3]${NC}"
--
./hosts/fileblade.sh:281: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/fileblade.sh:282: -b "${fb_cookie_jar}" -c "${fb_cookie_jar}" \
./hosts/fileblade.sh:283: --data "$form_data" "$post_action")
./hosts/fileblade.sh:284: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/fileblade.sh:285: debugHtml "${remote_url##*/}" "fb_post(2)" "post_action: ${post_action}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/fileblade.sh:286: fi
./hosts/fileblade.sh:287: if [[ -z $response ]] ; then
./hosts/fileblade.sh:288: if [[ $i == $maxfetchretries ]] ; then
./hosts/fileblade.sh:289: rm -f "${fb_cookie_jar}";
./hosts/fileblade.sh:290: printf "\\n"
./hosts/fileblade.sh:291: echo -e "${RED}| Failed to extract download link [4].${NC}"
--
./hosts/fileblade.sh:335: file_header=$(tor_curl_request --insecure -L --head -s "$download_url")
./hosts/fileblade.sh:336: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/fileblade.sh:337: debugHtml "${remote_url##*/}" "fb_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/fileblade.sh:338: fi
./hosts/fileblade.sh:339: if [[ -z $file_header ]] ; then
./hosts/fileblade.sh:340: if [[ $j == $maxfetchretries ]] ; then
./hosts/fileblade.sh:341: rm -f "${fb_cookie_jar}";
./hosts/fileblade.sh:342: printf "\\n"
./hosts/fileblade.sh:343: echo -e "${RED}| Failed to extract file info [1]${NC}"
./hosts/fileblade.sh:344: warnAndRetryUnknownError=true
./hosts/fileblade.sh:345: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/fileblade.sh:452: tor_curl_request --insecure -L \
./hosts/fileblade.sh:453: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/fileblade.sh:454: "$download_url" --continue-at - --output "$file_path"
./hosts/fileblade.sh:455: else
./hosts/fileblade.sh:456: tor_curl_request --insecure -L \
./hosts/fileblade.sh:457: "$download_url" --continue-at - --output "$file_path"
./hosts/fileblade.sh:458: fi
./hosts/fileblade.sh:459: else
./hosts/fileblade.sh:460: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/fileblade.sh:461: tor_curl_request --insecure \
./hosts/fileblade.sh:462: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/fileblade.sh:463: -H "User-Agent: $RandomUA" \
./hosts/fileblade.sh:464: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/fileblade.sh:465: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/fileblade.sh:466: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/fileblade.sh:467: -H "Connection: keep-alive" \
./hosts/fileblade.sh:468: -H "Cookie: lng=eng" \
./hosts/fileblade.sh:469: -H "Upgrade-Insecure-Requests: 1" \
./hosts/fileblade.sh:470: -H "Sec-Fetch-Dest: document" \
./hosts/fileblade.sh:471: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/fileblade.sh:476: tor_curl_request --insecure \
./hosts/fileblade.sh:477: -H "User-Agent: $RandomUA" \
./hosts/fileblade.sh:478: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/fileblade.sh:479: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/fileblade.sh:480: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/fileblade.sh:481: -H "Connection: keep-alive" \
./hosts/fileblade.sh:482: -H "Cookie: lng=eng" \
./hosts/fileblade.sh:483: -H "Upgrade-Insecure-Requests: 1" \
./hosts/fileblade.sh:484: -H "Sec-Fetch-Dest: document" \
./hosts/fileblade.sh:485: -H "Sec-Fetch-Mode: navigate" \
./hosts/fileblade.sh:486: -H "Sec-Fetch-Site: same-origin" \
--
./hosts/fileditch.sh:96: file_header=$(tor_curl_request --insecure --head -L -s "$download_url")
./hosts/fileditch.sh:97: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/fileditch.sh:98: debugHtml "${remote_url##*/}" "fd_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/fileditch.sh:99: fi
./hosts/fileditch.sh:100: if [[ ! -z "$file_header" ]] ; then
./hosts/fileditch.sh:101: if grep -Eqi '404 Not Found' <<< "${file_header}" ; then
./hosts/fileditch.sh:102: echo -e "${RED}| The file has been removed (404).${NC}"
./hosts/fileditch.sh:103: removedDownload "${remote_url}"
./hosts/fileditch.sh:104: exitDownloadNotAvailable=true
./hosts/fileditch.sh:105: return 1
./hosts/fileditch.sh:106: fi
--
./hosts/fileditch.sh:187: tor_curl_request --insecure --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/fileditch.sh:188: else
./hosts/fileditch.sh:189: tor_curl_request --insecure "$download_url" --continue-at - --output "$file_path"
./hosts/fileditch.sh:190: fi
./hosts/fileditch.sh:191: received_file_size=0
./hosts/fileditch.sh:192: if [[ -f "$file_path" ]] ; then
./hosts/fileditch.sh:193: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/fileditch.sh:194: fi
./hosts/fileditch.sh:195: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/fileditch.sh:196: containsHtml=false
./hosts/fileditch.sh:197: else
./hosts/fileditch.sh:198: containsHtml=true
./hosts/fileditch.sh:199: fi
--
./hosts/filedot.sh:112: PAGE=$(tor_curl_request --insecure --max-time "$ConnectTimeout" -L -s \
./hosts/filedot.sh:113: -H "User-Agent: $RandomUA" \
./hosts/filedot.sh:114: -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8' \
./hosts/filedot.sh:115: -H 'Accept-Language: en-US,en;q=0.5' \
./hosts/filedot.sh:116: -H 'Accept-Encoding: gzip, deflate, br' -H 'Connection: keep-alive' -H 'Upgrade-Insecure-Requests: 1' \
./hosts/filedot.sh:117: -H 'Sec-Fetch-Dest: document' -H 'Sec-Fetch-Mode: navigate' -H 'Sec-Fetch-Site: none' -H 'Sec-Fetch-User: ?1' \
./hosts/filedot.sh:118: -c "${fdot_cookie_jar}" \
./hosts/filedot.sh:119: "https://filedot.to/login.html")
./hosts/filedot.sh:120: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/filedot.sh:121: debugHtml "${remote_url##*/}" "fdot_login_$a" "${PAGE}"
./hosts/filedot.sh:122: fi
--
./hosts/filedot.sh:153: resp_login=$(tor_curl_request --insecure -L -s \
./hosts/filedot.sh:154: -H "Host: filedot.to" \
./hosts/filedot.sh:155: -H "User-Agent: $RandomUA" \
./hosts/filedot.sh:156: -H "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/filedot.sh:157: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/filedot.sh:158: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/filedot.sh:159: -H "Content-Type: application/x-www-form-urlencoded" \
./hosts/filedot.sh:160: -H "Origin: https://filedot.to" \
./hosts/filedot.sh:161: -H "Connection: keep-alive" \
./hosts/filedot.sh:162: -H "Referer: https://filedot.to/login.html" \
./hosts/filedot.sh:163: -H "DNT: 1" \
--
./hosts/filedot.sh:241: response=$(tor_curl_request --insecure -L -s \
./hosts/filedot.sh:242: -H "Host: filedot.to" \
./hosts/filedot.sh:243: -H "User-Agent: $RandomUA" \
./hosts/filedot.sh:244: -H "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/filedot.sh:245: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/filedot.sh:246: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/filedot.sh:247: -H "Content-Type: application/x-www-form-urlencoded" \
./hosts/filedot.sh:248: -H "Origin: https://filedot.to" \
./hosts/filedot.sh:249: -H "Connection: keep-alive" \
./hosts/filedot.sh:250: -H "Referer: https://filedot.to/login.html" \
./hosts/filedot.sh:251: -H "DNT: 1" \
--
./hosts/filedot.sh:321: response=$(tor_curl_request --insecure -L -s \
./hosts/filedot.sh:322: -H "Host: filedot.to" \
./hosts/filedot.sh:323: -H "User-Agent: $RandomUA" \
./hosts/filedot.sh:324: -H "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/filedot.sh:325: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/filedot.sh:326: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/filedot.sh:327: -H "Content-Type: application/x-www-form-urlencoded" \
./hosts/filedot.sh:328: -H "Origin: https://filedot.to" \
./hosts/filedot.sh:329: -H "Connection: keep-alive" \
./hosts/filedot.sh:330: -H "Referer: $remote_url" \
./hosts/filedot.sh:331: -H "DNT: 1" \
--
./hosts/filedot.sh:407: file_header=$(tor_curl_request --insecure -L --head -s --referer "${fixed_url}" "$download_url")
./hosts/filedot.sh:408: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/filedot.sh:409: debugHtml "${remote_url##*/}" "fdot_head_$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/filedot.sh:410: fi
./hosts/filedot.sh:411: if [[ -z $file_header ]] ; then
./hosts/filedot.sh:412: if [[ $j == $maxfetchretries ]] ; then
./hosts/filedot.sh:413: printf "\\n"
./hosts/filedot.sh:414: echo -e "${RED}| Failed to extract file info [1]${NC}"
./hosts/filedot.sh:415: warnAndRetryUnknownError=true
./hosts/filedot.sh:416: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/filedot.sh:417: failedRetryDownload "${remote_url}" "Failed to extract file info [1]" ""
--
./hosts/filedot.sh:500: tor_curl_request --insecure -L -G --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/filedot.sh:501: else
./hosts/filedot.sh:502: tor_curl_request --insecure -L -G "$download_url" --continue-at - --output "$file_path"
./hosts/filedot.sh:503: fi
./hosts/filedot.sh:504: received_file_size=0
./hosts/filedot.sh:505: if [[ -f "$file_path" ]] ; then
./hosts/filedot.sh:506: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/filedot.sh:507: fi
./hosts/filedot.sh:508: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/filedot.sh:509: containsHtml=false
./hosts/filedot.sh:510: else
./hosts/filedot.sh:511: containsHtml=true
./hosts/filedot.sh:512: fi
--
./hosts/filehaus.sh:101: file_header=$(tor_curl_request_extended --insecure -L --head -s --referer "${remote_url//\.org/\.cc}" "$download_url")
./hosts/filehaus.sh:102: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/filehaus.sh:103: debugHtml "${remote_url##*/}" "fh_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/filehaus.sh:104: fi
./hosts/filehaus.sh:105: if [[ ! -z "$file_header" ]] ; then
./hosts/filehaus.sh:106: if grep -Eqi '404 Not Found' <<< "${file_header}" ; then
./hosts/filehaus.sh:107: printf "\\n"
./hosts/filehaus.sh:108: echo -e "${RED}| The file has been removed (404).${NC}"
./hosts/filehaus.sh:109: removedDownload "${remote_url}"
./hosts/filehaus.sh:110: exitDownloadNotAvailable=true
./hosts/filehaus.sh:111: return 1
--
./hosts/filehaus.sh:191: tor_curl_request_extended --insecure --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval --referer "$download_url" "$download_url" --continue-at - --output "$file_path"
./hosts/filehaus.sh:192: else
./hosts/filehaus.sh:193: tor_curl_request_extended --insecure --referer "$download_url" "$download_url" --continue-at - --output "$file_path"
./hosts/filehaus.sh:194: fi
./hosts/filehaus.sh:195: received_file_size=0
./hosts/filehaus.sh:196: if [[ -f "$file_path" ]] ; then
./hosts/filehaus.sh:197: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/filehaus.sh:198: fi
./hosts/filehaus.sh:199: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/filehaus.sh:200: containsHtml=false
./hosts/filehaus.sh:201: else
./hosts/filehaus.sh:202: containsHtml=true
./hosts/filehaus.sh:203: fi
--
./hosts/firestorage.sh:98: response=$(tor_curl_request --insecure -L -s "${fixed_url}")
./hosts/firestorage.sh:99: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/firestorage.sh:100: debugHtml "${remote_url##*/}" "fs_${fetchnum}fetch_$j" "fixed_url: ${fixed_url}"$'\n'"${response}"
./hosts/firestorage.sh:101: fi
./hosts/firestorage.sh:102: if [[ -z $response ]] ; then
./hosts/firestorage.sh:103: if [[ $j == $maxfetchretries ]] ; then
./hosts/firestorage.sh:104: printf "\\n"
./hosts/firestorage.sh:105: echo -e "${RED}| Failed to extract link.${NC}"
./hosts/firestorage.sh:106: warnAndRetryUnknownError=true
./hosts/firestorage.sh:107: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/firestorage.sh:108: failedRetryDownload "${remote_url}" "" ""
--
./hosts/firestorage.sh:226: file_header=$(tor_curl_request --insecure -L --head -s --referer "${fixed_url}" "$download_url")
./hosts/firestorage.sh:227: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/firestorage.sh:228: debugHtml "${remote_url##*/}" "fs_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/firestorage.sh:229: fi
./hosts/firestorage.sh:230: if [[ -z $file_header ]] ; then
./hosts/firestorage.sh:231: if [[ $j == $maxfetchretries ]] ; then
./hosts/firestorage.sh:232: printf "\\n"
./hosts/firestorage.sh:233: echo -e "${RED}| Failed to extract file info${NC}"
./hosts/firestorage.sh:234: warnAndRetryUnknownError=true
./hosts/firestorage.sh:235: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/firestorage.sh:236: failedRetryDownload "${remote_url}" "" ""
--
./hosts/firestorage.sh:335: tor_curl_request --insecure -L -G --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/firestorage.sh:336: else
./hosts/firestorage.sh:337: tor_curl_request --insecure -L -G "$download_url" --continue-at - --output "$file_path"
./hosts/firestorage.sh:338: fi
./hosts/firestorage.sh:339: received_file_size=0
./hosts/firestorage.sh:340: if [[ -f "$file_path" ]] ; then
./hosts/firestorage.sh:341: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/firestorage.sh:342: fi
./hosts/firestorage.sh:343: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/firestorage.sh:344: containsHtml=false
./hosts/firestorage.sh:345: else
./hosts/firestorage.sh:346: containsHtml=true
./hosts/firestorage.sh:347: fi
--
./hosts/gofile.sh:97: response=$(tor_curl_request --insecure -s -X POST \
./hosts/gofile.sh:98: -H "User-Agent: $RandomUA" \
./hosts/gofile.sh:99: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/gofile.sh:100: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/gofile.sh:101: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/gofile.sh:102: -H "Connection: keep-alive" \
./hosts/gofile.sh:103: -H "Upgrade-Insecure-Requests: 1" \
./hosts/gofile.sh:104: -H "Sec-Fetch-Dest: document" \
./hosts/gofile.sh:105: -H "Sec-Fetch-Mode: navigate" \
./hosts/gofile.sh:106: -H "Sec-Fetch-Site: none" \
./hosts/gofile.sh:107: -H "Sec-Fetch-User: ?1" \
--
./hosts/gofile.sh:170: response=$(tor_curl_request --insecure -G -L -s \
./hosts/gofile.sh:171: -b "${gofile_cookie_jar}" -c "${gofile_cookie_jar}" \
./hosts/gofile.sh:172: -H "User-Agent: $RandomUA" \
./hosts/gofile.sh:173: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/gofile.sh:174: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/gofile.sh:175: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/gofile.sh:176: -H "Connection: keep-alive" \
./hosts/gofile.sh:177: -H "Upgrade-Insecure-Requests: 1" \
./hosts/gofile.sh:178: -H "Sec-Fetch-Dest: document" \
./hosts/gofile.sh:179: -H "Sec-Fetch-Mode: navigate" \
./hosts/gofile.sh:180: -H "Sec-Fetch-Site: none" \
--
./hosts/gofile.sh:258: file_header=$(tor_curl_request --insecure -L --head -s \
./hosts/gofile.sh:259: -b "${gofile_cookie_jar}" -c "${gofile_cookie_jar}" \
./hosts/gofile.sh:260: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/gofile.sh:261: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/gofile.sh:262: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/gofile.sh:263: -H "Connection: keep-alive" \
./hosts/gofile.sh:264: -H "Upgrade-Insecure-Requests: 1" \
./hosts/gofile.sh:265: -H "Sec-Fetch-Dest: document" \
./hosts/gofile.sh:266: -H "Sec-Fetch-Mode: navigate" \
./hosts/gofile.sh:267: -H "Sec-Fetch-Site: none" \
./hosts/gofile.sh:268: -H "Sec-Fetch-User: ?1" \
--
./hosts/gofile.sh:393: tor_curl_request --insecure -G --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/gofile.sh:394: -b "${gofile_cookie_jar}" -c "${gofile_cookie_jar}" \
./hosts/gofile.sh:395: -H "User-Agent: $RandomUA" \
./hosts/gofile.sh:396: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/gofile.sh:397: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/gofile.sh:398: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/gofile.sh:399: -H "Connection: keep-alive" \
./hosts/gofile.sh:400: -H "Upgrade-Insecure-Requests: 1" \
./hosts/gofile.sh:401: -H "Sec-Fetch-Dest: document" \
./hosts/gofile.sh:402: -H "Sec-Fetch-Mode: navigate" \
./hosts/gofile.sh:403: -H "Sec-Fetch-Site: none" \
--
./hosts/gofile.sh:407: tor_curl_request --insecure -G \
./hosts/gofile.sh:408: -b "${gofile_cookie_jar}" -c "${gofile_cookie_jar}" \
./hosts/gofile.sh:409: -H "User-Agent: $RandomUA" \
./hosts/gofile.sh:410: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/gofile.sh:411: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/gofile.sh:412: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/gofile.sh:413: -H "Connection: keep-alive" \
./hosts/gofile.sh:414: -H "Upgrade-Insecure-Requests: 1" \
./hosts/gofile.sh:415: -H "Sec-Fetch-Dest: document" \
./hosts/gofile.sh:416: -H "Sec-Fetch-Mode: navigate" \
./hosts/gofile.sh:417: -H "Sec-Fetch-Site: none" \
--
./hosts/hexload.sh:108: response=$(tor_curl_request --insecure -s --data "$form_data" "https://hexload.com/download")
./hosts/hexload.sh:109: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/hexload.sh:110: debugHtml "${remote_url##*/}" "hex_dwnpage$j" "form_data: ${form_data}"$'\n'"${response}"
./hosts/hexload.sh:111: fi
./hosts/hexload.sh:112: fi
./hosts/hexload.sh:113: else
./hosts/hexload.sh:114: if [[ "$hexUseDownload" == "download2" ]]; then
./hosts/hexload.sh:115: form_data="op=download1&id=${file_id}&rand=&usr_login=&fname=&ajax=1&method_free=1&dataType=json"
./hosts/hexload.sh:116: response=$(tor_curl_request --insecure -s --data "$form_data" "https://hexload.com/download")
./hosts/hexload.sh:117: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/hexload.sh:118: debugHtml "${remote_url##*/}" "hex_dwnpage$j" "form_data: ${form_data}"$'\n'"${response}"
./hosts/hexload.sh:119: fi
./hosts/hexload.sh:120: else
./hosts/hexload.sh:121: form_data="op=download2&id=${file_id}&rand=&usr_login=&fname=&ajax=1&method_free=1&dataType=json"
./hosts/hexload.sh:122: response=$(tor_curl_request --insecure -s --data "$form_data" "https://hexload.com/download")
./hosts/hexload.sh:123: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/hexload.sh:124: debugHtml "${remote_url##*/}" "hex_dwnpage$j" "form_data: ${form_data}"$'\n'"${response}"
./hosts/hexload.sh:125: fi
./hosts/hexload.sh:126: fi
./hosts/hexload.sh:127: fi
./hosts/hexload.sh:128: filename=$(echo "$response" | grep -oPi '(?<="file_name":")[^"]+(?=")' | base64 --decode)
./hosts/hexload.sh:129: download_url=$(echo "$response" | grep -oPi '(?<="link":")[^"]+(?=")' | base64 --decode)
./hosts/hexload.sh:130: download_url=$(urlencode_spaces "$download_url")
./hosts/hexload.sh:131: if grep -Eqi "Sorry, you have been blocked" <<< "$response"; then
./hosts/hexload.sh:132: if ((j == hexmaxfetchfileretries)) ; then
--
./hosts/hexload.sh:254: file_header=$(tor_curl_request --insecure --head -L -s --referer "$file_url" "$download_url")
./hosts/hexload.sh:255: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/hexload.sh:256: debugHtml "${remote_url##*/}" "hex_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/hexload.sh:257: fi
./hosts/hexload.sh:258: if ! grep -Eqi 'HTTP/2 200|HTTP/1.1 200|200 OK' <<< $file_header ; then
./hosts/hexload.sh:259: if ((j < hexmaxfetchfileretries)); then
./hosts/hexload.sh:260: continue
./hosts/hexload.sh:261: else
./hosts/hexload.sh:262: printf "\\n"
./hosts/hexload.sh:263: echo -e "${RED}| Bad header response…${NC}"
./hosts/hexload.sh:264: exitDownloadError=true
--
./hosts/hexload.sh:321: tor_curl_request --insecure --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval --referer "$file_url" "$download_url" --continue-at - --output "$file_path"
./hosts/hexload.sh:322: else
./hosts/hexload.sh:323: tor_curl_request --insecure --referer "$file_url" "$download_url" --continue-at - --output "$file_path"
./hosts/hexload.sh:324: fi
./hosts/hexload.sh:325: received_file_size=0
./hosts/hexload.sh:326: if [[ -f "$file_path" ]] ; then
./hosts/hexload.sh:327: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/hexload.sh:328: fi
./hosts/hexload.sh:329: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/hexload.sh:330: containsHtml=false
./hosts/hexload.sh:331: else
./hosts/hexload.sh:332: containsHtml=true
./hosts/hexload.sh:333: fi
--
./hosts/innocent.sh:97: file_header=$(tor_curl_request_extended --insecure --head -L -s "$download_url")
./hosts/innocent.sh:98: elif ((j % 2 == 0)); then
./hosts/innocent.sh:99: printf "| Retrieving Head (Get): attempt #$j"
./hosts/innocent.sh:100: file_header=$(tor_curl_request --insecure -m 16 -s -D - -o /dev/null \
./hosts/innocent.sh:101: -H "Connection: keep-alive" \
./hosts/innocent.sh:102: -w 'EffectiveUrl=%{url_effective}' \
./hosts/innocent.sh:103: "$download_url")
./hosts/innocent.sh:104: elif ((j % 3 == 0)); then
./hosts/innocent.sh:105: printf "| Retrieving Head (hack): attempt #$j"
./hosts/innocent.sh:106: rm -f "${WorkDir}/.temp/directhead"
./hosts/innocent.sh:107: file_header=$(tor_curl_request --insecure --head -H "Connection: keep-alive" -L -s -i "$download_url" |
./hosts/innocent.sh:108: tee "${WorkDir}/.temp/directhead" &
./hosts/innocent.sh:109: sleep 6
./hosts/innocent.sh:110: [ -s "${WorkDir}/.temp/directhead" ]
./hosts/innocent.sh:111: kill $! 2>/dev/null
./hosts/innocent.sh:112: )
./hosts/innocent.sh:113: if [[ ! -f "${WorkDir}/.flocks/${remote_url//[^a-zA-Z0-9]/}" ]]; then
./hosts/innocent.sh:114: touch "${WorkDir}/.flocks/${remote_url//[^a-zA-Z0-9]/}"
./hosts/innocent.sh:115: fi
./hosts/innocent.sh:116: rm -f "${WorkDir}/.temp/directhead"
./hosts/innocent.sh:117: else
--
./hosts/innocent.sh:119: file_header=$(tor_curl_request --insecure --head -L -s "$download_url")
./hosts/innocent.sh:120: fi
./hosts/innocent.sh:121: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/innocent.sh:122: debugHtml "${remote_url##*/}" "inno_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/innocent.sh:123: fi
./hosts/innocent.sh:124: if [[ ! -z "$file_header" ]] ; then
./hosts/innocent.sh:125: if grep -Eqi '404 Not Found' <<< "${file_header}" ; then
./hosts/innocent.sh:126: printf "\\n"
./hosts/innocent.sh:127: echo -e "${RED}| Not Found (404). The file has been removed.${NC}"
./hosts/innocent.sh:128: removedDownload "${remote_url}"
./hosts/innocent.sh:129: exitDownloadNotAvailable=true
--
./hosts/innocent.sh:211: tor_curl_request_extended --insecure "$download_url" --continue-at - --output "$file_path"
./hosts/innocent.sh:212: else
./hosts/innocent.sh:213: echo -e "${BLUE}| No Resume Fetch${NC}"
./hosts/innocent.sh:214: tor_curl_request_extended --insecure "$download_url" --output "$file_path"
./hosts/innocent.sh:215: fi
./hosts/innocent.sh:216: received_file_size=0
./hosts/innocent.sh:217: if [[ -f "$file_path" ]] ; then
./hosts/innocent.sh:218: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/innocent.sh:219: fi
./hosts/innocent.sh:220: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/innocent.sh:221: containsHtml=false
./hosts/innocent.sh:222: else
./hosts/innocent.sh:223: containsHtml=true
./hosts/innocent.sh:224: fi
--
./hosts/isupload.sh:90: response=$(tor_curl_request_extended --insecure -L -s -b "${isup_cookie_jar}" -c "${isup_cookie_jar}" "$remote_url")
./hosts/isupload.sh:91: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/isupload.sh:92: debugHtml "${remote_url##*/}" "isup_dwnpage$i" "${response}"
./hosts/isupload.sh:93: fi
./hosts/isupload.sh:94: if [[ -z $response ]] ; then
./hosts/isupload.sh:95: rm -f "${isup_cookie_jar}";
./hosts/isupload.sh:96: if [[ $i == $maxfetchretries ]] ; then
./hosts/isupload.sh:97: printf "\\n"
./hosts/isupload.sh:98: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/isupload.sh:99: warnAndRetryUnknownError=true
./hosts/isupload.sh:100: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/isupload.sh:164: response=$(tor_curl_request_extended --insecure -L -s -X POST \
./hosts/isupload.sh:165: -b "${isup_cookie_jar}" -c "${isup_cookie_jar}" \
./hosts/isupload.sh:166: --data "$form_data" "$post_action")
./hosts/isupload.sh:167: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/isupload.sh:168: debugHtml "${remote_url##*/}" "isup_post" "post_action: ${post_action}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/isupload.sh:169: fi
./hosts/isupload.sh:170: if [[ -z $response ]] ; then
./hosts/isupload.sh:171: if [[ $i == $maxfetchretries ]] ; then
./hosts/isupload.sh:172: rm -f "${isup_cookie_jar}";
./hosts/isupload.sh:173: printf "\\n"
./hosts/isupload.sh:174: echo -e "${RED}| Failed to extract download link [3].${NC}"
--
./hosts/isupload.sh:241: file_header=$(tor_curl_request --insecure -m 8 -s -D - -o /dev/null \
./hosts/isupload.sh:242: -H "Connection: keep-alive" \
./hosts/isupload.sh:243: -w 'EffectiveUrl=%{url_effective}' \
./hosts/isupload.sh:244: "$download_url")
./hosts/isupload.sh:245: elif ((j % 2 == 0)); then
./hosts/isupload.sh:246: printf "| Retrieving Head: attempt #$j"
./hosts/isupload.sh:247: file_header=$(tor_curl_request --insecure --head -L -s "$download_url")
./hosts/isupload.sh:248: elif ((j % 3 == 0)); then
./hosts/isupload.sh:249: printf "| Retrieving Head (hack): attempt #$j"
./hosts/isupload.sh:250: rm -f "${WorkDir}/.temp/directhead"
./hosts/isupload.sh:251: file_header=$(tor_curl_request --insecure --head -H "Connection: keep-alive" -L -s -i "$download_url" |
./hosts/isupload.sh:252: tee "${WorkDir}/.temp/directhead" &
./hosts/isupload.sh:253: sleep 6
./hosts/isupload.sh:254: [ -s "${WorkDir}/.temp/directhead" ]
./hosts/isupload.sh:255: kill $! 2>/dev/null
./hosts/isupload.sh:256: )
./hosts/isupload.sh:257: if [[ ! -f "${WorkDir}/.flocks/${remote_url//[^a-zA-Z0-9]/}" ]]; then
./hosts/isupload.sh:258: touch "${WorkDir}/.flocks/${remote_url//[^a-zA-Z0-9]/}"
./hosts/isupload.sh:259: fi
./hosts/isupload.sh:260: rm -f "${WorkDir}/.temp/directhead"
./hosts/isupload.sh:261: else
--
./hosts/isupload.sh:263: file_header=$(tor_curl_request_extended --insecure --head -L -s "$download_url")
./hosts/isupload.sh:264: fi
./hosts/isupload.sh:265: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/isupload.sh:266: debugHtml "${remote_url##*/}" "isup_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/isupload.sh:267: fi
./hosts/isupload.sh:268: if [[ ! -z "$file_header" ]] ; then
./hosts/isupload.sh:269: if grep -Eqi '404 Not Found|' <<< "${file_header}" ; then
./hosts/isupload.sh:270: printf "\\n"
./hosts/isupload.sh:271: echo -e "${RED}| Not Found (404). The file has been removed.${NC}"
./hosts/isupload.sh:272: removedDownload "${remote_url}"
./hosts/isupload.sh:273: exitDownloadNotAvailable=true
--
./hosts/isupload.sh:355: tor_curl_request_extended --insecure -L "$download_url" --output "$file_path"
./hosts/isupload.sh:356: rc=$?
./hosts/isupload.sh:357: if ((rc != 0 )) ; then
./hosts/isupload.sh:358: printf "${RED}Download Failed (bad exit status).${NC}"
./hosts/isupload.sh:359: if [[ -f ${file_path} ]]; then
./hosts/isupload.sh:360: printf "${YELLOW} Partial removed...${NC}"
./hosts/isupload.sh:361: printf "\n\n"
./hosts/isupload.sh:362: rm -f "${file_path}"
./hosts/isupload.sh:363: else
./hosts/isupload.sh:364: printf "\n\n"
./hosts/isupload.sh:365: fi
--
./hosts/isupload.sh:403: tor_curl_request_extended --insecure -L --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/isupload.sh:404: else
./hosts/isupload.sh:405: tor_curl_request_extended --insecure -L "$download_url" --continue-at - --output "$file_path"
./hosts/isupload.sh:406: fi
./hosts/isupload.sh:407: received_file_size=0
./hosts/isupload.sh:408: if [[ -f "$file_path" ]] ; then
./hosts/isupload.sh:409: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/isupload.sh:410: fi
./hosts/isupload.sh:411: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/isupload.sh:412: containsHtml=false
./hosts/isupload.sh:413: else
./hosts/isupload.sh:414: containsHtml=true
./hosts/isupload.sh:415: fi
--
./hosts/kraken.sh:104: PAGE=$(tor_curl_request --insecure --max-time "$ConnectTimeout" -s -L -c "${kraken_cookie_jar}" "${fixed_url}")
./hosts/kraken.sh:105: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/kraken.sh:106: debugHtml "${krak_id}" "kraken_token${num_attempt}_$i" "url: ${fixed_url}"$'\n'"krakenid: ${krak_id}"$'\n'"${PAGE}"
./hosts/kraken.sh:107: fi
./hosts/kraken.sh:108: if grep -Eqi 'sendFormCaptcha()' <<< "${PAGE}"; then
./hosts/kraken.sh:109: rm -f "$kraken_cookie_jar";
./hosts/kraken.sh:110: printf "\n"
./hosts/kraken.sh:111: echo -e "${RED}| Captcha required (Recaptcha)${NC}"
./hosts/kraken.sh:112: exitDownloadError=true
./hosts/kraken.sh:113: failedRetryDownload "${remote_url}" "Captcha required (Recaptcha)" ""
./hosts/kraken.sh:114: return 1
--
./hosts/kraken.sh:169: down_request=$(tor_curl_request --insecure -L -s -b "${kraken_cookie_jar}" -c "${kraken_cookie_jar}" -F "token=${kraken_token}" "${kraken_action}")
./hosts/kraken.sh:170: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/kraken.sh:171: debugHtml "${krak_id}" "kraken_url${num_attempt}_1" "action: ${kraken_action}, token: ${kraken_token}"$'\n'"${down_request}"
./hosts/kraken.sh:172: fi
./hosts/kraken.sh:173: if ! grep -Eqi '"status":"ok"' <<< "${down_request}"; then
./hosts/kraken.sh:174: echo -e "${RED}| Failed to get download url${NC}"
./hosts/kraken.sh:175: rm -f "$kraken_cookie_jar";
./hosts/kraken.sh:176: return 1
./hosts/kraken.sh:177: else
./hosts/kraken.sh:178: kraken_url=$(grep -oP '"url":"\K[^"]+' <<< "${down_request}")
./hosts/kraken.sh:179: download_url=${kraken_url//\\/}
--
./hosts/kraken.sh:186: file_header=$(tor_curl_request --insecure --head -L -s -b "${kraken_cookie_jar}" -c "${kraken_cookie_jar}" --referer "$kraken_action" "$download_url")
./hosts/kraken.sh:187: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/kraken.sh:188: debugHtml "${krak_id}" "kraken_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/kraken.sh:189: fi
./hosts/kraken.sh:190: rm -f "$kraken_cookie_jar";
./hosts/kraken.sh:191: if [[ ! -z "$file_header" ]] ; then
./hosts/kraken.sh:192: if grep -Eqi '404 Not Found' <<< "${file_header}" ; then
./hosts/kraken.sh:193: echo -e "${RED}| The file has been removed (404).${NC}"
./hosts/kraken.sh:194: removedDownload "${remote_url}"
./hosts/kraken.sh:195: exitDownloadNotAvailable=true
./hosts/kraken.sh:196: return 1
--
./hosts/kraken.sh:286: tor_curl_request --insecure --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval --referer "$kraken_action" "$download_url" --continue-at - --output "$file_path"
./hosts/kraken.sh:287: else
./hosts/kraken.sh:288: tor_curl_request --insecure --referer "$kraken_action" "$download_url" --continue-at - --output "$file_path"
./hosts/kraken.sh:289: fi
./hosts/kraken.sh:290: received_file_size=0
./hosts/kraken.sh:291: if [[ -f "$file_path" ]] ; then
./hosts/kraken.sh:292: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/kraken.sh:293: fi
./hosts/kraken.sh:294: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/kraken.sh:295: containsHtml=false
./hosts/kraken.sh:296: else
./hosts/kraken.sh:297: containsHtml=true
./hosts/kraken.sh:298: fi
--
./hosts/mediafire.sh:94: response=$(tor_curl_request --insecure -L -s \
./hosts/mediafire.sh:95: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/mediafire.sh:96: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/mediafire.sh:97: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/mediafire.sh:98: -H "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7" \
./hosts/mediafire.sh:99: -H "Connection: keep-alive" \
./hosts/mediafire.sh:100: -H "Upgrade-Insecure-Requests: 1" \
./hosts/mediafire.sh:101: -H "Sec-Fetch-Dest: document" \
./hosts/mediafire.sh:102: -H "Sec-Fetch-Mode: navigate" \
./hosts/mediafire.sh:103: -H "Sec-Fetch-Site: none" \
./hosts/mediafire.sh:104: -H "Sec-Fetch-User: ?1" \
--
./hosts/mediafire.sh:157: file_header=$(tor_curl_request --insecure -L --head -s \
./hosts/mediafire.sh:158: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/mediafire.sh:159: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/mediafire.sh:160: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/mediafire.sh:161: -H "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7" \
./hosts/mediafire.sh:162: -H "Connection: keep-alive" \
./hosts/mediafire.sh:163: -H "Upgrade-Insecure-Requests: 1" \
./hosts/mediafire.sh:164: -H "Sec-Fetch-Dest: document" \
./hosts/mediafire.sh:165: -H "Sec-Fetch-Mode: navigate" \
./hosts/mediafire.sh:166: -H "Sec-Fetch-Site: none" \
./hosts/mediafire.sh:167: -H "Sec-Fetch-User: ?1" \
--
./hosts/mediafire.sh:276: tor_curl_request_extended --insecure "$download_url" --continue-at - --output "$file_path"
./hosts/mediafire.sh:277: else
./hosts/mediafire.sh:278: echo -e "${BLUE}| No Resume Fetch${NC}"
./hosts/mediafire.sh:279: tor_curl_request_extended --insecure "$download_url" --output "$file_path"
./hosts/mediafire.sh:280: fi
./hosts/mediafire.sh:281: received_file_size=0
./hosts/mediafire.sh:282: if [[ -f "$file_path" ]] ; then
./hosts/mediafire.sh:283: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/mediafire.sh:284: fi
./hosts/mediafire.sh:285: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/mediafire.sh:286: containsHtml=false
./hosts/mediafire.sh:287: else
./hosts/mediafire.sh:288: containsHtml=true
./hosts/mediafire.sh:289: fi
--
./hosts/nippy.sh:119: response=$(tor_curl_request --insecure -L -s -b "${nippy_cookie_jar}" -c "${nippy_cookie_jar}" "$fixed_url")
./hosts/nippy.sh:120: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/nippy.sh:121: debugHtml "${remote_url##*/}" "nippy_dwnpage$i" "fixed_url: ${fixed_url}"$'\n'"${response}"
./hosts/nippy.sh:122: fi
./hosts/nippy.sh:123: if [[ -z $response ]] ; then
./hosts/nippy.sh:124: rm -f "${nippy_cookie_jar}";
./hosts/nippy.sh:125: if [[ $i == $maxfetchretries ]] ; then
./hosts/nippy.sh:126: printf "\\n"
./hosts/nippy.sh:127: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/nippy.sh:128: warnAndRetryUnknownError=true
./hosts/nippy.sh:129: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/nippy.sh:188: file_header=$(tor_curl_request --insecure -L --head -s \
./hosts/nippy.sh:189: -b "${nippy_cookie_jar}" -c "${nippy_cookie_jar}" \
./hosts/nippy.sh:190: "$download_url")
./hosts/nippy.sh:191: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/nippy.sh:192: debugHtml "${remote_url##*/}" "nippy_head$j" "FileInfoUrl: ${download_url}"$'\n'"${file_header}"
./hosts/nippy.sh:193: fi
./hosts/nippy.sh:194: if [[ -z $file_header ]] ; then
./hosts/nippy.sh:195: if [[ $j == $maxfetchretries ]] ; then
./hosts/nippy.sh:196: rm -f "${nippy_cookie_jar}";
./hosts/nippy.sh:197: printf "\\n"
./hosts/nippy.sh:198: echo -e "${RED}| Failed to extract file info${NC}"
--
./hosts/nippy.sh:299: tor_curl_request --insecure -L --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/nippy.sh:300: "$download_url" --continue-at - --output "$file_path"
./hosts/nippy.sh:301: else
./hosts/nippy.sh:302: tor_curl_request --insecure -L "$download_url" --continue-at - --output "$file_path"
./hosts/nippy.sh:303: fi
./hosts/nippy.sh:304: received_file_size=0
./hosts/nippy.sh:305: if [[ -f "$file_path" ]] ; then
./hosts/nippy.sh:306: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/nippy.sh:307: fi
./hosts/nippy.sh:308: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/nippy.sh:309: containsHtml=false
./hosts/nippy.sh:310: else
./hosts/nippy.sh:311: containsHtml=true
./hosts/nippy.sh:312: fi
--
./hosts/oshi.sh:107: file_header=$(tor_curl_request --insecure --head -L -s --referer "$remote_url" "$download_url")
./hosts/oshi.sh:108: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/oshi.sh:109: debugHtml "${remote_url##*/}" "oshi_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/oshi.sh:110: fi
./hosts/oshi.sh:111: if [[ ! -z "$file_header" ]] ; then
./hosts/oshi.sh:112: if grep -Eqi '404 Not Found' <<< "${file_header}" ; then
./hosts/oshi.sh:113: echo -e "${RED}| O shi-, (404). The file has been removed.${NC}"
./hosts/oshi.sh:114: removedDownload "${remote_url}"
./hosts/oshi.sh:115: exitDownloadNotAvailable=true
./hosts/oshi.sh:116: return 1
./hosts/oshi.sh:117: fi
--
./hosts/oshi.sh:201: tor_curl_request --insecure -L --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval --referer "$file_url" "$download_url" --continue-at - --output "$file_path"
./hosts/oshi.sh:202: else
./hosts/oshi.sh:203: tor_curl_request --insecure -L --referer "$file_url" "$download_url" --continue-at - --output "$file_path"
./hosts/oshi.sh:204: fi
./hosts/oshi.sh:205: received_file_size=0
./hosts/oshi.sh:206: if [[ -f "$file_path" ]] ; then
./hosts/oshi.sh:207: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/oshi.sh:208: fi
./hosts/oshi.sh:209: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/oshi.sh:210: containsHtml=false
./hosts/oshi.sh:211: else
./hosts/oshi.sh:212: containsHtml=true
./hosts/oshi.sh:213: fi
--
./hosts/pixeldrain.sh:94: response=$(tor_curl_request --insecure -L -s "https://pixeldrain.com/u/$fileid")
./hosts/pixeldrain.sh:95: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/pixeldrain.sh:96: debugHtml "${remote_url##*/}" "pd_fetch$i" "$response"
./hosts/pixeldrain.sh:97: fi
./hosts/pixeldrain.sh:98: if [[ ! -z "$response" ]] ; then
./hosts/pixeldrain.sh:99: if grep -q -Eq '"views":' <<< "$response"; then
./hosts/pixeldrain.sh:100: pdpreviews=$(grep -o -P '(?<="views":).+?(?=,")' <<< "$response")
./hosts/pixeldrain.sh:101: fi
./hosts/pixeldrain.sh:102: if grep -i -Eq "You have reached the maximum number of open download connections" <<< "$response"; then
./hosts/pixeldrain.sh:103: if ((i >= 5)) ; then
./hosts/pixeldrain.sh:104: printf "\\n"
--
./hosts/pixeldrain.sh:259: file_header=$(tor_curl_request --insecure --head -L -s --referer "$file_url" "$pdheadurl")
./hosts/pixeldrain.sh:260: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/pixeldrain.sh:261: debugHtml "${remote_url##*/}" "pd_head$i" "url: ${pdheadurl}"$'\n'"${file_header}"
./hosts/pixeldrain.sh:262: fi
./hosts/pixeldrain.sh:263: if ! grep -Eqi 'HTTP/2 200|HTTP/1.1 200|200 OK' <<< $file_header ; then
./hosts/pixeldrain.sh:264: if ((i < 6)); then
./hosts/pixeldrain.sh:265: continue
./hosts/pixeldrain.sh:266: else
./hosts/pixeldrain.sh:267: echo -e "${YELLOW}| Filesize not found.${NC}"
./hosts/pixeldrain.sh:268: return 1
./hosts/pixeldrain.sh:269: fi
--
./hosts/pixeldrain.sh:327: tor_curl_request --insecure \
./hosts/pixeldrain.sh:328: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/pixeldrain.sh:329: --referer "$file_url" "$download_url" --continue-at - --output "$file_path"
./hosts/pixeldrain.sh:330: else
./hosts/pixeldrain.sh:331: tor_curl_request --insecure \
./hosts/pixeldrain.sh:332: --referer "$file_url" "$download_url" --continue-at - --output "$file_path"
./hosts/pixeldrain.sh:333: fi
./hosts/pixeldrain.sh:334: else
./hosts/pixeldrain.sh:335: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/pixeldrain.sh:336: tor_curl_request --insecure \
./hosts/pixeldrain.sh:337: -H "User-Agent: $RandomUA" \
./hosts/pixeldrain.sh:338: -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8' \
./hosts/pixeldrain.sh:339: -H 'Accept-Language: en-US,en;q=0.5' -H 'Accept-Encoding: gzip, deflate, br' \
./hosts/pixeldrain.sh:340: -H 'Connection: keep-alive' -H 'Upgrade-Insecure-Requests: 1' -H 'Sec-Fetch-Dest: document' \
./hosts/pixeldrain.sh:341: -H 'Sec-Fetch-Mode: navigate' -H 'Sec-Fetch-Site: none' -H 'Sec-Fetch-User: ?1' \
./hosts/pixeldrain.sh:342: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/pixeldrain.sh:343: --referer "$file_url" "$download_url" --continue-at - --output "$file_path"
./hosts/pixeldrain.sh:344: else
./hosts/pixeldrain.sh:345: tor_curl_request --insecure \
./hosts/pixeldrain.sh:346: -H "User-Agent: $RandomUA" \
./hosts/pixeldrain.sh:347: -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8' \
./hosts/pixeldrain.sh:348: -H 'Accept-Language: en-US,en;q=0.5' -H 'Accept-Encoding: gzip, deflate, br' \
./hosts/pixeldrain.sh:349: -H 'Connection: keep-alive' -H 'Upgrade-Insecure-Requests: 1' -H 'Sec-Fetch-Dest: document' \
./hosts/pixeldrain.sh:350: -H 'Sec-Fetch-Mode: navigate' -H 'Sec-Fetch-Site: none' -H 'Sec-Fetch-User: ?1' \
./hosts/pixeldrain.sh:351: --referer "$file_url" "$download_url" --continue-at - --output "$file_path"
./hosts/pixeldrain.sh:352: fi
./hosts/pixeldrain.sh:353: fi
./hosts/pixeldrain.sh:354: received_file_size=0
./hosts/pixeldrain.sh:355: if [[ -f "$file_path" ]] ; then
--
./hosts/quax.sh:85: file_header=$(tor_curl_request --insecure --head -L -s "$download_url")
./hosts/quax.sh:86: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/quax.sh:87: debugHtml "${remote_url##*/}" "qx_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/quax.sh:88: fi
./hosts/quax.sh:89: if [[ ! -z "$file_header" ]] ; then
./hosts/quax.sh:90: if grep -Eqi '404 Not Found|HTTP.* 404' <<< "${file_header}" ; then
./hosts/quax.sh:91: echo -e "${RED}| The file has been removed (404).${NC}"
./hosts/quax.sh:92: removedDownload "${remote_url}"
./hosts/quax.sh:93: exitDownloadNotAvailable=true
./hosts/quax.sh:94: return 1
./hosts/quax.sh:95: fi
--
./hosts/quax.sh:176: tor_curl_request --insecure --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/quax.sh:177: else
./hosts/quax.sh:178: tor_curl_request --insecure "$download_url" --continue-at - --output "$file_path"
./hosts/quax.sh:179: fi
./hosts/quax.sh:180: received_file_size=0
./hosts/quax.sh:181: if [[ -f "$file_path" ]] ; then
./hosts/quax.sh:182: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/quax.sh:183: fi
./hosts/quax.sh:184: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/quax.sh:185: containsHtml=false
./hosts/quax.sh:186: else
./hosts/quax.sh:187: containsHtml=true
./hosts/quax.sh:188: fi
--
./hosts/ranoz.sh:92: response=$(tor_curl_request --insecure -L -i -s \
./hosts/ranoz.sh:93: -b "${rz_cookie_jar}" -c "${rz_cookie_jar}" \
./hosts/ranoz.sh:94: "$remote_url")
./hosts/ranoz.sh:95: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/ranoz.sh:96: debugHtml "${remote_url##*/}" "rz_fetch$i" "${response}"
./hosts/ranoz.sh:97: fi
./hosts/ranoz.sh:98: if [[ -z $response ]] ; then
./hosts/ranoz.sh:99: if [[ $i == $maxfetchretries ]] ; then
./hosts/ranoz.sh:100: rm -f "${rz_cookie_jar}";
./hosts/ranoz.sh:101: printf "\\n"
./hosts/ranoz.sh:102: echo -e "${RED}| Failed to extract download url [1]${NC}"
--
./hosts/ranoz.sh:168: file_header=$(tor_curl_request --insecure --head -L -i -s \
./hosts/ranoz.sh:169: -b "${rz_cookie_jar}" -c "${rz_cookie_jar}" \
./hosts/ranoz.sh:170: "$download_url")
./hosts/ranoz.sh:171: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/ranoz.sh:172: debugHtml "${remote_url##*/}" "rz_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/ranoz.sh:173: fi
./hosts/ranoz.sh:174: if [[ -z $file_header ]] ; then
./hosts/ranoz.sh:175: if [[ $j == $maxfetchretries ]] ; then
./hosts/ranoz.sh:176: rm -f "${rz_cookie_jar}";
./hosts/ranoz.sh:177: printf "\\n"
./hosts/ranoz.sh:178: echo -e "${RED}| Failed to extract file info${NC}"
--
./hosts/ranoz.sh:283: tor_curl_request --insecure -L -G --no-alpn \
./hosts/ranoz.sh:284: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/ranoz.sh:285: "$download_url" --continue-at - --output "$file_path"
./hosts/ranoz.sh:286: else
./hosts/ranoz.sh:287: tor_curl_request --insecure -L -G --no-alpn \
./hosts/ranoz.sh:288: "$download_url" --continue-at - --output "$file_path"
./hosts/ranoz.sh:289: fi
./hosts/ranoz.sh:290: else
./hosts/ranoz.sh:291: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/ranoz.sh:292: tor_curl_request --insecure -L -G --no-alpn \
./hosts/ranoz.sh:293: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/ranoz.sh:294: -H "User-Agent: $RandomUA" \
./hosts/ranoz.sh:295: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/ranoz.sh:296: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/ranoz.sh:297: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/ranoz.sh:298: -H "Connection: keep-alive" \
./hosts/ranoz.sh:299: -H "Cookie: lng=eng" \
./hosts/ranoz.sh:300: -H "Upgrade-Insecure-Requests: 1" \
./hosts/ranoz.sh:301: -H "Sec-Fetch-Dest: document" \
./hosts/ranoz.sh:302: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/ranoz.sh:307: tor_curl_request --insecure -L -G --no-alpn \
./hosts/ranoz.sh:308: -H "User-Agent: $RandomUA" \
./hosts/ranoz.sh:309: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/ranoz.sh:310: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/ranoz.sh:311: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/ranoz.sh:312: -H "Connection: keep-alive" \
./hosts/ranoz.sh:313: -H "Cookie: lng=eng" \
./hosts/ranoz.sh:314: -H "Upgrade-Insecure-Requests: 1" \
./hosts/ranoz.sh:315: -H "Sec-Fetch-Dest: document" \
./hosts/ranoz.sh:316: -H "Sec-Fetch-Mode: navigate" \
./hosts/ranoz.sh:317: -H "Sec-Fetch-Site: same-origin" \
--
./hosts/sendnow.sh:89: response=$(tor_curl_request --insecure -L -s -b "${snow_cookie_jar}" -c "${snow_cookie_jar}" "$remote_url")
./hosts/sendnow.sh:90: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/sendnow.sh:91: debugHtml "${remote_url##*/}" "snow_dwnpage$i" "${response}"
./hosts/sendnow.sh:92: fi
./hosts/sendnow.sh:93: if [[ -z $response ]] ; then
./hosts/sendnow.sh:94: printf " ."
./hosts/sendnow.sh:95: rm -f "${snow_cookie_jar}";
./hosts/sendnow.sh:96: if [[ $i == $maxfetchretries ]] ; then
./hosts/sendnow.sh:97: printf "\\n"
./hosts/sendnow.sh:98: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/sendnow.sh:99: warnAndRetryUnknownError=true
--
./hosts/sendnow.sh:162: response=$(tor_curl_request --insecure -L -svo. -X POST \
./hosts/sendnow.sh:163: -b "${snow_cookie_jar}" -c "${snow_cookie_jar}" \
./hosts/sendnow.sh:164: --data-raw "$form_data" "$remote_url" 2>&1)
./hosts/sendnow.sh:165: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/sendnow.sh:166: debugHtml "${remote_url##*/}" "snow_post" "post_action: ${post_action}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/sendnow.sh:167: fi
./hosts/sendnow.sh:168: if [[ -z $response ]] ; then
./hosts/sendnow.sh:169: echo -e "${RED}| Failed to extract download link [2]${NC}"
./hosts/sendnow.sh:170: warnAndRetryUnknownError=true
./hosts/sendnow.sh:171: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/sendnow.sh:172: rm -f "${snow_cookie_jar}";
--
./hosts/sendnow.sh:206: file_header=$(tor_curl_request_extended --insecure --head -Lis \
./hosts/sendnow.sh:207: -H "Host: $fshost" \
./hosts/sendnow.sh:208: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
./hosts/sendnow.sh:209: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/sendnow.sh:210: -H "Accept-Encoding: gzip, deflate, br, zstd" \
./hosts/sendnow.sh:211: -H "Referer: https://send.now/" \
./hosts/sendnow.sh:212: -H "Sec-GPC: 1" \
./hosts/sendnow.sh:213: -H "Connection: keep-alive" \
./hosts/sendnow.sh:214: -H "Upgrade-Insecure-Requests: 1" \
./hosts/sendnow.sh:215: -H "Sec-Fetch-Dest: document" \
./hosts/sendnow.sh:216: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/sendnow.sh:329: tor_curl_request_extended --insecure -L --no-alpn \
./hosts/sendnow.sh:330: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/sendnow.sh:331: -H "Host: $fshost" \
./hosts/sendnow.sh:332: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
./hosts/sendnow.sh:333: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/sendnow.sh:334: -H "Accept-Encoding: gzip, deflate, br, zstd" \
./hosts/sendnow.sh:335: -H "Referer: https://send.now/" \
./hosts/sendnow.sh:336: -H "Sec-GPC: 1" \
./hosts/sendnow.sh:337: -H "Connection: keep-alive" \
./hosts/sendnow.sh:338: -H "Upgrade-Insecure-Requests: 1" \
./hosts/sendnow.sh:339: -H "Sec-Fetch-Dest: document" \
--
./hosts/sendnow.sh:347: tor_curl_request --insecure -L --no-alpn \
./hosts/sendnow.sh:348: -H "Host: $fshost" \
./hosts/sendnow.sh:349: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
./hosts/sendnow.sh:350: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/sendnow.sh:351: -H "Accept-Encoding: gzip, deflate, br, zstd" \
./hosts/sendnow.sh:352: -H "Referer: https://send.now/" \
./hosts/sendnow.sh:353: -H "Sec-GPC: 1" \
./hosts/sendnow.sh:354: -H "Connection: keep-alive" \
./hosts/sendnow.sh:355: -H "Upgrade-Insecure-Requests: 1" \
./hosts/sendnow.sh:356: -H "Sec-Fetch-Dest: document" \
./hosts/sendnow.sh:357: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/sendnow.sh:366: tor_curl_request --insecure -L --no-alpn \
./hosts/sendnow.sh:367: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/sendnow.sh:368: -H "User-Agent: $RandomUA" \
./hosts/sendnow.sh:369: -H "Host: $fshost" \
./hosts/sendnow.sh:370: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
./hosts/sendnow.sh:371: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/sendnow.sh:372: -H "Accept-Encoding: gzip, deflate, br, zstd" \
./hosts/sendnow.sh:373: -H "Referer: https://send.now/" \
./hosts/sendnow.sh:374: -H "Sec-GPC: 1" \
./hosts/sendnow.sh:375: -H "Connection: keep-alive" \
./hosts/sendnow.sh:376: -H "Upgrade-Insecure-Requests: 1" \
--
./hosts/sendnow.sh:385: tor_curl_request --insecure -L --no-alpn \
./hosts/sendnow.sh:386: -H "User-Agent: $RandomUA" \
./hosts/sendnow.sh:387: -H "Host: $fshost" \
./hosts/sendnow.sh:388: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
./hosts/sendnow.sh:389: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/sendnow.sh:390: -H "Accept-Encoding: gzip, deflate, br, zstd" \
./hosts/sendnow.sh:391: -H "Referer: https://send.now/" \
./hosts/sendnow.sh:392: -H "Sec-GPC: 1" \
./hosts/sendnow.sh:393: -H "Connection: keep-alive" \
./hosts/sendnow.sh:394: -H "Upgrade-Insecure-Requests: 1" \
./hosts/sendnow.sh:395: -H "Sec-Fetch-Dest: document" \
--
./hosts/sendspace.sh:90: response=$(tor_curl_request --insecure -L -s -b "${ss_cookie_jar}" -c "${ss_cookie_jar}" "$remote_url")
./hosts/sendspace.sh:91: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/sendspace.sh:92: debugHtml "${remote_url##*/}" "ss_dwnpage$i" "${response}"
./hosts/sendspace.sh:93: fi
./hosts/sendspace.sh:94: if [[ -z $response ]] ; then
./hosts/sendspace.sh:95: rm -f "${ss_cookie_jar}";
./hosts/sendspace.sh:96: if [[ $i == $maxfetchretries ]] ; then
./hosts/sendspace.sh:97: printf "\\n"
./hosts/sendspace.sh:98: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/sendspace.sh:99: warnAndRetryUnknownError=true
./hosts/sendspace.sh:100: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/sendspace.sh:157: file_header=$(tor_curl_request --insecure -L --head -s \
./hosts/sendspace.sh:158: -b "${ss_cookie_jar}" -c "${ss_cookie_jar}" \
./hosts/sendspace.sh:159: "$download_url" | tr -d '\0')
./hosts/sendspace.sh:160: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/sendspace.sh:161: debugHtml "${remote_url##*/}" "ss_head$j" "FileInfoUrl: ${download_url}"$'\n'"${file_header}"
./hosts/sendspace.sh:162: fi
./hosts/sendspace.sh:163: if [[ -z $file_header ]] ; then
./hosts/sendspace.sh:164: if ((j == maxfetchretries)) ; then
./hosts/sendspace.sh:165: rm -f "${ss_cookie_jar}";
./hosts/sendspace.sh:166: printf "\\n"
./hosts/sendspace.sh:167: echo -e "${RED}| Failed to extract file info [1]${NC}"
--
./hosts/sendspace.sh:275: tor_curl_request --insecure --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/sendspace.sh:276: else
./hosts/sendspace.sh:277: tor_curl_request --insecure "$download_url" --continue-at - --output "$file_path"
./hosts/sendspace.sh:278: fi
./hosts/sendspace.sh:279: else
./hosts/sendspace.sh:280: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/sendspace.sh:281: tor_curl_request --insecure --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/sendspace.sh:282: -H "User-Agent: $RandomUA" \
./hosts/sendspace.sh:283: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/sendspace.sh:284: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/sendspace.sh:285: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/sendspace.sh:286: -H "Connection: keep-alive" \
./hosts/sendspace.sh:287: -H "Cookie: lng=eng" \
./hosts/sendspace.sh:288: -H "Upgrade-Insecure-Requests: 1" \
./hosts/sendspace.sh:289: -H "Sec-Fetch-Dest: document" \
./hosts/sendspace.sh:290: -H "Sec-Fetch-Mode: navigate" \
./hosts/sendspace.sh:291: -H "Sec-Fetch-Site: same-origin" \
--
./hosts/sendspace.sh:296: tor_curl_request --insecure \
./hosts/sendspace.sh:297: -H "User-Agent: $RandomUA" \
./hosts/sendspace.sh:298: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/sendspace.sh:299: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/sendspace.sh:300: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/sendspace.sh:301: -H "Connection: keep-alive" \
./hosts/sendspace.sh:302: -H "Cookie: lng=eng" \
./hosts/sendspace.sh:303: -H "Upgrade-Insecure-Requests: 1" \
./hosts/sendspace.sh:304: -H "Sec-Fetch-Dest: document" \
./hosts/sendspace.sh:305: -H "Sec-Fetch-Mode: navigate" \
./hosts/sendspace.sh:306: -H "Sec-Fetch-Site: same-origin" \
--
./hosts/syspro.sh:88: response=$(tor_curl_request --insecure -L -s "$remote_url")
./hosts/syspro.sh:89: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/syspro.sh:90: debugHtml "${remote_url##*/}" "sysp_fetch$i" "${response}"
./hosts/syspro.sh:91: fi
./hosts/syspro.sh:92: if [[ -z $response ]] ; then
./hosts/syspro.sh:93: if [[ $i == $maxfetchretries ]] ; then
./hosts/syspro.sh:94: printf "\\n"
./hosts/syspro.sh:95: echo -e "${RED}| Failed to extract download link [1]${NC}"
./hosts/syspro.sh:96: warnAndRetryUnknownError=true
./hosts/syspro.sh:97: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/syspro.sh:98: failedRetryDownload "${remote_url}" "Failed to extract download link [1]" ""
--
./hosts/syspro.sh:188: tor_curl_request --insecure -L \
./hosts/syspro.sh:189: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/syspro.sh:190: --data "$form_data" "$post_action" \
./hosts/syspro.sh:191: --output "$file_path" --output "$file_path"
./hosts/syspro.sh:192: else
./hosts/syspro.sh:193: tor_curl_request --insecure \
./hosts/syspro.sh:194: --data "$form_data" "$post_action" \
./hosts/syspro.sh:195: --output "$file_path" --output "$file_path"
./hosts/syspro.sh:196: fi
./hosts/syspro.sh:197: else
./hosts/syspro.sh:198: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/syspro.sh:199: tor_curl_request --insecure -L \
./hosts/syspro.sh:200: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/syspro.sh:201: -H "User-Agent: $RandomUA" \
./hosts/syspro.sh:202: --data "$form_data" "$post_action" \
./hosts/syspro.sh:203: --output "$file_path" --output "$file_path"
./hosts/syspro.sh:204: else
./hosts/syspro.sh:205: tor_curl_request --insecure -L \
./hosts/syspro.sh:206: -H "User-Agent: $RandomUA" \
./hosts/syspro.sh:207: --data "$form_data" "$post_action" \
./hosts/syspro.sh:208: --output "$file_path" --output "$file_path"
./hosts/syspro.sh:209: fi
./hosts/syspro.sh:210: fi
./hosts/syspro.sh:211: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/syspro.sh:212: containsHtml=false
./hosts/syspro.sh:213: else
./hosts/syspro.sh:214: containsHtml=true
./hosts/syspro.sh:215: fi
--
./hosts/tempfileme.sh:89: response=$(tor_curl_request --insecure -L -s "$remote_url")
./hosts/tempfileme.sh:90: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/tempfileme.sh:91: debugHtml "${remote_url##*/}" "tmpme_fetch$j" "${response}"
./hosts/tempfileme.sh:92: fi
./hosts/tempfileme.sh:93: if [[ -z $response ]] ; then
./hosts/tempfileme.sh:94: if [[ $j == $maxfetchretries ]] ; then
./hosts/tempfileme.sh:95: printf "\\n"
./hosts/tempfileme.sh:96: echo -e "${RED}| Failed to extract download link${NC}"
./hosts/tempfileme.sh:97: warnAndRetryUnknownError=true
./hosts/tempfileme.sh:98: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/tempfileme.sh:99: failedRetryDownload "${remote_url}" "Failed to extract download link" ""
--
./hosts/tempfileme.sh:170: file_header=$(tor_curl_request --insecure -L --head -s --referer "${remote_url}" "$download_url")
./hosts/tempfileme.sh:171: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/tempfileme.sh:172: debugHtml "${remote_url##*/}" "tmpme_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/tempfileme.sh:173: fi
./hosts/tempfileme.sh:174: if [[ ! -z "$file_header" ]] ; then
./hosts/tempfileme.sh:175: if grep -Eqi 'HTTP.* 404|Not Found' <<< "${file_header}" ; then
./hosts/tempfileme.sh:176: if [[ $j == $maxfetchretries ]] ; then
./hosts/tempfileme.sh:177: printf "\\n"
./hosts/tempfileme.sh:178: echo -e "${RED}| The file has been removed (404).${NC}"
./hosts/tempfileme.sh:179: removedDownload "${remote_url}"
./hosts/tempfileme.sh:180: exitDownloadNotAvailable=true
--
./hosts/tempfileme.sh:300: tor_curl_request --insecure -L \
./hosts/tempfileme.sh:301: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/tempfileme.sh:302: --referer "${remote_url}" \
./hosts/tempfileme.sh:303: "$download_url" --continue-at - --output "$file_path"
./hosts/tempfileme.sh:304: else
./hosts/tempfileme.sh:305: tor_curl_request --insecure -L \
./hosts/tempfileme.sh:306: --referer "${remote_url}" \
./hosts/tempfileme.sh:307: "$download_url" --continue-at - --output "$file_path"
./hosts/tempfileme.sh:308: fi
./hosts/tempfileme.sh:309: else
./hosts/tempfileme.sh:310: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/tempfileme.sh:311: tor_curl_request --insecure -L \
./hosts/tempfileme.sh:312: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/tempfileme.sh:313: -H "User-Agent: $RandomUA" \
./hosts/tempfileme.sh:314: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/tempfileme.sh:315: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/tempfileme.sh:316: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/tempfileme.sh:317: -H "Connection: keep-alive" \
./hosts/tempfileme.sh:318: -H "Upgrade-Insecure-Requests: 1" \
./hosts/tempfileme.sh:319: -H "Sec-Fetch-Dest: document" \
./hosts/tempfileme.sh:320: -H "Sec-Fetch-Mode: navigate" \
./hosts/tempfileme.sh:321: -H "Sec-Fetch-Site: same-origin" \
--
./hosts/tempfileme.sh:326: tor_curl_request --insecure -L \
./hosts/tempfileme.sh:327: -H "User-Agent: $RandomUA" \
./hosts/tempfileme.sh:328: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/tempfileme.sh:329: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/tempfileme.sh:330: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/tempfileme.sh:331: -H "Connection: keep-alive" \
./hosts/tempfileme.sh:332: -H "Upgrade-Insecure-Requests: 1" \
./hosts/tempfileme.sh:333: -H "Sec-Fetch-Dest: document" \
./hosts/tempfileme.sh:334: -H "Sec-Fetch-Mode: navigate" \
./hosts/tempfileme.sh:335: -H "Sec-Fetch-Site: same-origin" \
./hosts/tempfileme.sh:336: -H "Sec-Fetch-User: ?1" \
--
./hosts/tempsh.sh:88: file_header=$(tor_curl_request --insecure -s -D - -o /dev/null -X POST \
./hosts/tempsh.sh:89: -H "Connection: keep-alive" \
./hosts/tempsh.sh:90: -w 'EffectiveUrl=%{url_effective}' \
./hosts/tempsh.sh:91: "$download_url")
./hosts/tempsh.sh:92: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/tempsh.sh:93: debugHtml "${remote_url##*/}" "tmpsh_posthead" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/tempsh.sh:94: fi
./hosts/tempsh.sh:95: if [[ -z $file_header ]] ; then
./hosts/tempsh.sh:96: if [[ $j == $maxfetchretries ]] ; then
./hosts/tempsh.sh:97: printf "\\n"
./hosts/tempsh.sh:98: echo -e "${RED}| Failed to extract file info [1]${NC}"
--
./hosts/tempsh.sh:227: tor_curl_request --insecure -X POST \
./hosts/tempsh.sh:228: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/tempsh.sh:229: "$download_url" --continue-at - --output "$file_path"
./hosts/tempsh.sh:230: else
./hosts/tempsh.sh:231: tor_curl_request --insecure -X POST \
./hosts/tempsh.sh:232: "$download_url" --continue-at - --output "$file_path"
./hosts/tempsh.sh:233: fi
./hosts/tempsh.sh:234: else
./hosts/tempsh.sh:235: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/tempsh.sh:236: tor_curl_request --insecure -X POST \
./hosts/tempsh.sh:237: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/tempsh.sh:238: -H "User-Agent: $RandomUA" \
./hosts/tempsh.sh:239: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/tempsh.sh:240: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/tempsh.sh:241: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/tempsh.sh:242: -H "Connection: keep-alive" \
./hosts/tempsh.sh:243: -H "Upgrade-Insecure-Requests: 1" \
./hosts/tempsh.sh:244: -H "Sec-Fetch-Dest: document" \
./hosts/tempsh.sh:245: -H "Sec-Fetch-Mode: navigate" \
./hosts/tempsh.sh:246: -H "Sec-Fetch-Site: same-origin" \
--
./hosts/tempsh.sh:250: tor_curl_request --insecure -X POST \
./hosts/tempsh.sh:251: -H "User-Agent: $RandomUA" \
./hosts/tempsh.sh:252: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/tempsh.sh:253: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/tempsh.sh:254: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/tempsh.sh:255: -H "Connection: keep-alive" \
./hosts/tempsh.sh:256: -H "Upgrade-Insecure-Requests: 1" \
./hosts/tempsh.sh:257: -H "Sec-Fetch-Dest: document" \
./hosts/tempsh.sh:258: -H "Sec-Fetch-Mode: navigate" \
./hosts/tempsh.sh:259: -H "Sec-Fetch-Site: same-origin" \
./hosts/tempsh.sh:260: -H "Sec-Fetch-User: ?1" \
--
./hosts/torup.sh:92: response=$(tor_curl_request --insecure -L -s \
./hosts/torup.sh:93: -b "${torp_cookie_jar}" -c "${torp_cookie_jar}" \
./hosts/torup.sh:94: "$fixed_url")
./hosts/torup.sh:95: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/torup.sh:96: debugHtml "${remote_url##*/}" "torp_fetch$i" "${response}"
./hosts/torup.sh:97: fi
./hosts/torup.sh:98: if [[ -z $response ]] ; then
./hosts/torup.sh:99: rm -f "${torp_cookie_jar}";
./hosts/torup.sh:100: if [[ $i == $maxfetchretries ]] ; then
./hosts/torup.sh:101: printf "\\n"
./hosts/torup.sh:102: echo -e "${RED}| Failed to extract download url [1]${NC}"
--
./hosts/torup.sh:194: tor_curl_request --insecure -L -G --no-alpn \
./hosts/torup.sh:195: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/torup.sh:196: -b "${torp_cookie_jar}" -c "${torp_cookie_jar}" \
./hosts/torup.sh:197: -H "Host: ktgzpea2b76u7fgemiibp4a76onyybo4fw5gbsagtm6jrjzmgivppyyd.onion" \
./hosts/torup.sh:198: -H "Referer: $fixed_url" \
./hosts/torup.sh:199: "$download_url" --output "$file_path"
./hosts/torup.sh:200: else
./hosts/torup.sh:201: tor_curl_request --insecure -L -G --no-alpn \
./hosts/torup.sh:202: -b "${torp_cookie_jar}" -c "${torp_cookie_jar}" \
./hosts/torup.sh:203: -H "Host: ktgzpea2b76u7fgemiibp4a76onyybo4fw5gbsagtm6jrjzmgivppyyd.onion" \
./hosts/torup.sh:204: -H "Referer: $fixed_url" \
./hosts/torup.sh:205: "$download_url" --output "$file_path"
./hosts/torup.sh:206: fi
./hosts/torup.sh:207: else
./hosts/torup.sh:208: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/torup.sh:209: tor_curl_request --insecure -L -G --no-alpn \
./hosts/torup.sh:210: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/torup.sh:211: -H "User-Agent: $RandomUA" \
./hosts/torup.sh:212: -H "Host: ktgzpea2b76u7fgemiibp4a76onyybo4fw5gbsagtm6jrjzmgivppyyd.onion" \
./hosts/torup.sh:213: -H "Referer: $fixed_url" \
./hosts/torup.sh:214: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/torup.sh:215: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/torup.sh:216: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/torup.sh:217: -H "Connection: keep-alive" \
./hosts/torup.sh:218: -H "Upgrade-Insecure-Requests: 1" \
./hosts/torup.sh:219: -H "Sec-Fetch-Dest: document" \
--
./hosts/torup.sh:226: tor_curl_request --insecure -L -G --no-alpn \
./hosts/torup.sh:227: -H "User-Agent: $RandomUA" \
./hosts/torup.sh:228: -H "Host: ktgzpea2b76u7fgemiibp4a76onyybo4fw5gbsagtm6jrjzmgivppyyd.onion" \
./hosts/torup.sh:229: -H "Referer: $fixed_url" \
./hosts/torup.sh:230: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/torup.sh:231: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/torup.sh:232: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/torup.sh:233: -H "Connection: keep-alive" \
./hosts/torup.sh:234: -H "Upgrade-Insecure-Requests: 1" \
./hosts/torup.sh:235: -H "Sec-Fetch-Dest: document" \
./hosts/torup.sh:236: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/up2share.sh:91: response=$(tor_curl_request --insecure -L -s -b "${up2share_cookie_jar}" -c "${up2share_cookie_jar}" \
./hosts/up2share.sh:92: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/up2share.sh:93: "$fixed_url")
./hosts/up2share.sh:94: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up2share.sh:95: debugHtml "${remote_url##*/}" "up2share_fetch$i" "${response}"
./hosts/up2share.sh:96: fi
./hosts/up2share.sh:97: if [[ -z $response ]] ; then
./hosts/up2share.sh:98: rm -f "${up2share_cookie_jar}";
./hosts/up2share.sh:99: if [[ $i == $maxfetchretries ]] ; then
./hosts/up2share.sh:100: printf "\\n"
./hosts/up2share.sh:101: echo -e "${RED}| Failed to extract token link [1].${NC}"
--
./hosts/up2share.sh:144: response=$(tor_curl_request --insecure -L -s -b "${up2share_cookie_jar}" -c "${up2share_cookie_jar}" \
./hosts/up2share.sh:145: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/up2share.sh:146: "$download_url")
./hosts/up2share.sh:147: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up2share.sh:148: debugHtml "${remote_url##*/}" "up2share_down$i" "${response}"
./hosts/up2share.sh:149: fi
./hosts/up2share.sh:150: if [[ -z $response ]] ; then
./hosts/up2share.sh:151: rm -f "${up2share_cookie_jar}";
./hosts/up2share.sh:152: if [[ $i == $maxfetchretries ]] ; then
./hosts/up2share.sh:153: printf "\\n"
./hosts/up2share.sh:154: echo -e "${RED}| Failed to extract download link [1].${NC}"
--
./hosts/up2share.sh:195: file_header=$(tor_curl_request --insecure -L -s --head \
./hosts/up2share.sh:196: -b "${up2share_cookie_jar}" -c "${up2share_cookie_jar}" \
./hosts/up2share.sh:197: --referer "https://up2sha.re/" "$download_url")
./hosts/up2share.sh:198: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up2share.sh:199: debugHtml "${remote_url##*/}" "up2share_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/up2share.sh:200: fi
./hosts/up2share.sh:201: if [[ -z $file_header ]] ; then
./hosts/up2share.sh:202: if [[ $j == $maxfetchretries ]] ; then
./hosts/up2share.sh:203: rm -f "${up2share_cookie_jar}";
./hosts/up2share.sh:204: printf "\\n"
./hosts/up2share.sh:205: echo -e "${RED}| Failed to extract file info${NC}"
--
./hosts/up2share.sh:314: tor_curl_request --insecure -L \
./hosts/up2share.sh:315: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/up2share.sh:316: -b "${up2share_cookie_jar}" -c "${up2share_cookie_jar}" \
./hosts/up2share.sh:317: -H "Host: up2sha.re" \
./hosts/up2share.sh:318: --referer "https://up2sha.re/" \
./hosts/up2share.sh:319: "$download_url" --continue-at - --output "$file_path"
./hosts/up2share.sh:320: else
./hosts/up2share.sh:321: tor_curl_request --insecure -L \
./hosts/up2share.sh:322: -b "${up2share_cookie_jar}" -c "${up2share_cookie_jar}" \
./hosts/up2share.sh:323: -H "Host: up2sha.re" \
./hosts/up2share.sh:324: --referer "https://up2sha.re/" \
./hosts/up2share.sh:325: "$download_url" --continue-at - --output "$file_path"
./hosts/up2share.sh:326: fi
./hosts/up2share.sh:327: else
./hosts/up2share.sh:328: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/up2share.sh:329: tor_curl_request --insecure -L \
./hosts/up2share.sh:330: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/up2share.sh:331: -b "${up2share_cookie_jar}" -c "${up2share_cookie_jar}" \
./hosts/up2share.sh:332: -H "Host: up2sha.re" \
./hosts/up2share.sh:333: -H "User-Agent: $RandomUA" \
./hosts/up2share.sh:334: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/up2share.sh:335: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/up2share.sh:336: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/up2share.sh:337: -H "Connection: keep-alive" \
./hosts/up2share.sh:338: -H "Cookie: lng=eng" \
./hosts/up2share.sh:339: -H "Upgrade-Insecure-Requests: 1" \
--
./hosts/up2share.sh:347: tor_curl_request --insecure -L \
./hosts/up2share.sh:348: -b "${up2share_cookie_jar}" -c "${up2share_cookie_jar}" \
./hosts/up2share.sh:349: -H "Host: up2sha.re" \
./hosts/up2share.sh:350: -H "User-Agent: $RandomUA" \
./hosts/up2share.sh:351: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/up2share.sh:352: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/up2share.sh:353: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/up2share.sh:354: -H "Connection: keep-alive" \
./hosts/up2share.sh:355: -H "Cookie: lng=eng" \
./hosts/up2share.sh:356: -H "Upgrade-Insecure-Requests: 1" \
./hosts/up2share.sh:357: -H "Sec-Fetch-Dest: document" \
--
./hosts/uploadee.sh:90: response=$(tor_curl_request --insecure -L -s "$remote_url")
./hosts/uploadee.sh:91: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadee.sh:92: debugHtml "${remote_url##*/}" "upee_dwnpage$i" "${response}"
./hosts/uploadee.sh:93: fi
./hosts/uploadee.sh:94: if [[ -z $response ]] ; then
./hosts/uploadee.sh:95: rm -f "${upee_cookie_jar}";
./hosts/uploadee.sh:96: if [[ $i == $maxfetchretries ]] ; then
./hosts/uploadee.sh:97: printf "\\n"
./hosts/uploadee.sh:98: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/uploadee.sh:99: warnAndRetryUnknownError=true
./hosts/uploadee.sh:100: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/uploadee.sh:143: file_header=$(tor_curl_request --insecure --head -L -s -b "${upee_cookie_jar}" -c "${upee_cookie_jar}" --referer "$remote_url" "$download_url")
./hosts/uploadee.sh:144: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadee.sh:145: debugHtml "${remote_url##*/}" "upee_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/uploadee.sh:146: fi
./hosts/uploadee.sh:147: if [[ -z $file_header ]] ; then
./hosts/uploadee.sh:148: if [[ $j == $maxfetchretries ]] ; then
./hosts/uploadee.sh:149: rm -f "${upee_cookie_jar}";
./hosts/uploadee.sh:150: printf "\\n"
./hosts/uploadee.sh:151: echo -e "${RED}| Failed to extract file info.${NC}"
./hosts/uploadee.sh:152: warnAndRetryUnknownError=true
./hosts/uploadee.sh:153: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/uploadee.sh:251: tor_curl_request --insecure -L -G --no-alpn \
./hosts/uploadee.sh:252: -b "${upee_cookie_jar}" -c "${upee_cookie_jar}" --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/uploadee.sh:253: -H "Host: www.upload.ee" \
./hosts/uploadee.sh:254: --referer "$remote_url" "$download_url" \
./hosts/uploadee.sh:255: --continue-at - --output "$file_path"
./hosts/uploadee.sh:256: else
./hosts/uploadee.sh:257: tor_curl_request --insecure -L -G --no-alpn \
./hosts/uploadee.sh:258: -b "${upee_cookie_jar}" -c "${upee_cookie_jar}" \
./hosts/uploadee.sh:259: -H "Host: www.upload.ee" \
./hosts/uploadee.sh:260: --referer "$remote_url" "$download_url" \
./hosts/uploadee.sh:261: --continue-at - --output "$file_path"
./hosts/uploadee.sh:262: fi
./hosts/uploadee.sh:263: else
./hosts/uploadee.sh:264: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/uploadee.sh:265: tor_curl_request --insecure -L -G --no-alpn \
./hosts/uploadee.sh:266: -b "${upee_cookie_jar}" -c "${upee_cookie_jar}" --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/uploadee.sh:267: -H "Host: www.upload.ee" \
./hosts/uploadee.sh:268: -H "User-Agent: $RandomUA" \
./hosts/uploadee.sh:269: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/uploadee.sh:270: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/uploadee.sh:271: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/uploadee.sh:272: -H "Connection: keep-alive" \
./hosts/uploadee.sh:273: -H "Cookie: lng=eng" \
./hosts/uploadee.sh:274: -H "Upgrade-Insecure-Requests: 1" \
./hosts/uploadee.sh:275: -H "Sec-Fetch-Dest: document" \
--
./hosts/uploadee.sh:282: tor_curl_request --insecure -L -G --no-alpn \
./hosts/uploadee.sh:283: -b "${upee_cookie_jar}" -c "${upee_cookie_jar}" \
./hosts/uploadee.sh:284: -H "Host: www.upload.ee" \
./hosts/uploadee.sh:285: -H "User-Agent: $RandomUA" \
./hosts/uploadee.sh:286: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/uploadee.sh:287: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/uploadee.sh:288: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/uploadee.sh:289: -H "Connection: keep-alive" \
./hosts/uploadee.sh:290: -H "Cookie: lng=eng" \
./hosts/uploadee.sh:291: -H "Upgrade-Insecure-Requests: 1" \
./hosts/uploadee.sh:292: -H "Sec-Fetch-Dest: document" \
--
./hosts/uploadev.sh:91: response=$(tor_curl_request --insecure -L -s -b "${upev_cookie_jar}" -c "${upev_cookie_jar}" \
./hosts/uploadev.sh:92: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/uploadev.sh:93: "$fixed_url")
./hosts/uploadev.sh:94: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadev.sh:95: debugHtml "${remote_url##*/}" "upev_fetch$i" "${response}"
./hosts/uploadev.sh:96: fi
./hosts/uploadev.sh:97: if [[ -z $response ]] ; then
./hosts/uploadev.sh:98: rm -f "${upev_cookie_jar}";
./hosts/uploadev.sh:99: if [[ $i == $maxfetchretries ]] ; then
./hosts/uploadev.sh:100: printf "\\n"
./hosts/uploadev.sh:101: echo -e "${RED}| Failed to extract download link [1]${NC}"
--
./hosts/uploadev.sh:181: response=$(tor_curl_request --insecure -L -s -X POST \
./hosts/uploadev.sh:182: -b "${upev_cookie_jar}" -c "${upev_cookie_jar}" \
./hosts/uploadev.sh:183: --data "$form_data" "$fixed_url")
./hosts/uploadev.sh:184: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadev.sh:185: debugHtml "${remote_url##*/}" "upev_post2_$i" "url: ${fixed_url}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/uploadev.sh:186: fi
./hosts/uploadev.sh:187: if [[ -z $response ]] ; then
./hosts/uploadev.sh:188: if [[ $i == $maxfetchretries ]] ; then
./hosts/uploadev.sh:189: rm -f "${upev_cookie_jar}";
./hosts/uploadev.sh:190: printf "\\n"
./hosts/uploadev.sh:191: echo -e "${RED}| Failed to extract download link [4]${NC}"
--
./hosts/uploadev.sh:268: file_header=$(tor_curl_request --insecure -L --head -s "$download_url")
./hosts/uploadev.sh:269: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadev.sh:270: debugHtml "${remote_url##*/}" "upev_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/uploadev.sh:271: fi
./hosts/uploadev.sh:272: if [[ -z $file_header ]] ; then
./hosts/uploadev.sh:273: if [[ $j == $maxfetchretries ]] ; then
./hosts/uploadev.sh:274: rm -f "${upev_cookie_jar}";
./hosts/uploadev.sh:275: printf "\\n"
./hosts/uploadev.sh:276: echo -e "${RED}| Failed to extract file info [1]${NC}"
./hosts/uploadev.sh:277: warnAndRetryUnknownError=true
./hosts/uploadev.sh:278: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/uploadev.sh:369: tor_curl_request --insecure -L \
./hosts/uploadev.sh:370: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/uploadev.sh:371: -b "${upev_cookie_jar}" -c "${upev_cookie_jar}" \
./hosts/uploadev.sh:372: "$download_url" --continue-at - --output "$file_path"
./hosts/uploadev.sh:373: else
./hosts/uploadev.sh:374: tor_curl_request --insecure -L \
./hosts/uploadev.sh:375: -b "${upev_cookie_jar}" -c "${upev_cookie_jar}" \
./hosts/uploadev.sh:376: "$download_url" --continue-at - --output "$file_path"
./hosts/uploadev.sh:377: fi
./hosts/uploadev.sh:378: else
./hosts/uploadev.sh:379: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./hosts/uploadev.sh:380: tor_curl_request --insecure -L \
./hosts/uploadev.sh:381: --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval \
./hosts/uploadev.sh:382: -b "${upev_cookie_jar}" -c "${upev_cookie_jar}" \
./hosts/uploadev.sh:383: -H "User-Agent: $RandomUA" \
./hosts/uploadev.sh:384: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/uploadev.sh:385: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/uploadev.sh:386: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/uploadev.sh:387: -H "Connection: keep-alive" \
./hosts/uploadev.sh:388: -H "Cookie: lng=eng" \
./hosts/uploadev.sh:389: -H "Upgrade-Insecure-Requests: 1" \
./hosts/uploadev.sh:390: -H "Sec-Fetch-Dest: document" \
--
./hosts/uploadev.sh:396: tor_curl_request --insecure -L \
./hosts/uploadev.sh:397: -b "${upev_cookie_jar}" -c "${upev_cookie_jar}" \
./hosts/uploadev.sh:398: -H "User-Agent: $RandomUA" \
./hosts/uploadev.sh:399: -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8" \
./hosts/uploadev.sh:400: -H "Accept-Language: en-US,en;q=0.5" \
./hosts/uploadev.sh:401: -H "Accept-Encoding: gzip, deflate, br" \
./hosts/uploadev.sh:402: -H "Connection: keep-alive" \
./hosts/uploadev.sh:403: -H "Cookie: lng=eng" \
./hosts/uploadev.sh:404: -H "Upgrade-Insecure-Requests: 1" \
./hosts/uploadev.sh:405: -H "Sec-Fetch-Dest: document" \
./hosts/uploadev.sh:406: -H "Sec-Fetch-Mode: navigate" \
--
./hosts/uploadflix.sh:97: response=$(tor_curl_request --insecure -L -s "${fixed_url}")
./hosts/uploadflix.sh:98: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadflix.sh:99: debugHtml "${remote_url##*/}" "uflix_dwnpage$j" "${response}"
./hosts/uploadflix.sh:100: fi
./hosts/uploadflix.sh:101: if [[ -z $response ]] ; then
./hosts/uploadflix.sh:102: if [[ $j == $maxfetchretries ]] ; then
./hosts/uploadflix.sh:103: printf "\\n"
./hosts/uploadflix.sh:104: echo -e "${RED}| Failed to extract post link.${NC}"
./hosts/uploadflix.sh:105: warnAndRetryUnknownError=true
./hosts/uploadflix.sh:106: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/uploadflix.sh:107: failedRetryDownload "${remote_url}" "" ""
--
./hosts/uploadflix.sh:150: response=$(tor_curl_request --insecure -L -s -X POST --data "$form_data" "${fixed_url}")
./hosts/uploadflix.sh:151: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadflix.sh:152: debugHtml "${remote_url##*/}" "uflix_post" "form_data: ${form_data}"$'\n'"${response}"
./hosts/uploadflix.sh:153: fi
./hosts/uploadflix.sh:154: if [[ -z $response ]] ; then
./hosts/uploadflix.sh:155: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/uploadflix.sh:156: warnAndRetryUnknownError=true
./hosts/uploadflix.sh:157: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/uploadflix.sh:158: failedRetryDownload "${remote_url}" "" ""
./hosts/uploadflix.sh:159: fi
./hosts/uploadflix.sh:160: return 1
--
./hosts/uploadflix.sh:192: file_header=$(tor_curl_request --insecure -L --head -s --referer "${fixed_url}" "${download_url}")
./hosts/uploadflix.sh:193: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadflix.sh:194: debugHtml "${remote_url##*/}" "uflix_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/uploadflix.sh:195: fi
./hosts/uploadflix.sh:196: if [[ -z $file_header ]] ; then
./hosts/uploadflix.sh:197: if [[ $j == $maxfetchretries ]] ; then
./hosts/uploadflix.sh:198: printf "\\n"
./hosts/uploadflix.sh:199: echo -e "${RED}| Failed to extract file info.${NC}"
./hosts/uploadflix.sh:200: warnAndRetryUnknownError=true
./hosts/uploadflix.sh:201: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/uploadflix.sh:202: failedRetryDownload "${remote_url}" "" ""
--
./hosts/uploadflix.sh:286: tor_curl_request --insecure -L -G --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/uploadflix.sh:287: else
./hosts/uploadflix.sh:288: tor_curl_request --insecure -L -G "$download_url" --continue-at - --output "$file_path"
./hosts/uploadflix.sh:289: fi
./hosts/uploadflix.sh:290: received_file_size=0
./hosts/uploadflix.sh:291: if [[ -f "$file_path" ]] ; then
./hosts/uploadflix.sh:292: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/uploadflix.sh:293: fi
./hosts/uploadflix.sh:294: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/uploadflix.sh:295: containsHtml=false
./hosts/uploadflix.sh:296: else
./hosts/uploadflix.sh:297: containsHtml=true
./hosts/uploadflix.sh:298: fi
--
./hosts/uploadhive.sh:88: response=$(tor_curl_request --insecure -L -s "$remote_url")
./hosts/uploadhive.sh:89: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadhive.sh:90: debugHtml "${remote_url##*/}" "uhive_dwnpage$j" "${response}"
./hosts/uploadhive.sh:91: fi
./hosts/uploadhive.sh:92: if [[ -z $response ]] ; then
./hosts/uploadhive.sh:93: if [[ $j == $maxfetchretries ]] ; then
./hosts/uploadhive.sh:94: printf "\\n"
./hosts/uploadhive.sh:95: echo -e "${RED}| Failed to extract post link.${NC}"
./hosts/uploadhive.sh:96: warnAndRetryUnknownError=true
./hosts/uploadhive.sh:97: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/uploadhive.sh:98: failedRetryDownload "${remote_url}" "" ""
--
./hosts/uploadhive.sh:135: response=$(tor_curl_request --insecure -L -s -X POST --data "$form_data" "$remote_url" --connect-to uploadhive.com::172.67.130.243)
./hosts/uploadhive.sh:136: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadhive.sh:137: debugHtml "${remote_url##*/}" "uhive_post" "${response}"
./hosts/uploadhive.sh:138: fi
./hosts/uploadhive.sh:139: if [[ -z $response ]] ; then
./hosts/uploadhive.sh:140: echo -e "${RED}| Failed to extract download link [1]${NC}"
./hosts/uploadhive.sh:141: warnAndRetryUnknownError=true
./hosts/uploadhive.sh:142: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/uploadhive.sh:143: failedRetryDownload "${remote_url}" "Failed to extract download link [1]" ""
./hosts/uploadhive.sh:144: fi
./hosts/uploadhive.sh:145: return 1
--
./hosts/uploadhive.sh:249: tor_curl_request --insecure -L -G --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/uploadhive.sh:250: else
./hosts/uploadhive.sh:251: tor_curl_request --insecure -L -G "$download_url" --continue-at - --output "$file_path"
./hosts/uploadhive.sh:252: fi
./hosts/uploadhive.sh:253: received_file_size=0
./hosts/uploadhive.sh:254: if [[ -f "$file_path" ]] ; then
./hosts/uploadhive.sh:255: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/uploadhive.sh:256: fi
./hosts/uploadhive.sh:257: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/uploadhive.sh:258: containsHtml=false
./hosts/uploadhive.sh:259: else
./hosts/uploadhive.sh:260: containsHtml=true
./hosts/uploadhive.sh:261: fi
--
./hosts/uploadscloud.sh:90: response=$(tor_curl_request --insecure -L -s -b "${upsc_cookie_jar}" -c "${upsc_cookie_jar}" "$remote_url")
./hosts/uploadscloud.sh:91: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadscloud.sh:92: debugHtml "${remote_url##*/}" "upsc_dwnpage$i" "${response}"
./hosts/uploadscloud.sh:93: fi
./hosts/uploadscloud.sh:94: if [[ -z $response ]] ; then
./hosts/uploadscloud.sh:95: rm -f "${upsc_cookie_jar}";
./hosts/uploadscloud.sh:96: if [[ $i == $maxfetchretries ]] ; then
./hosts/uploadscloud.sh:97: printf "\\n"
./hosts/uploadscloud.sh:98: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/uploadscloud.sh:99: warnAndRetryUnknownError=true
./hosts/uploadscloud.sh:100: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/uploadscloud.sh:142: response=$(tor_curl_request --insecure -svo. -X POST \
./hosts/uploadscloud.sh:143: -b "${upsc_cookie_jar}" -c "${upsc_cookie_jar}" \
./hosts/uploadscloud.sh:144: --data-raw "$form_data" "$remote_url" 2>&1)
./hosts/uploadscloud.sh:145: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadscloud.sh:146: debugHtml "${remote_url##*/}" "upsc_post" "post_action: ${post_action}"$'\n'"form_data: ${form_data}"$'\n'"${response}"
./hosts/uploadscloud.sh:147: fi
./hosts/uploadscloud.sh:148: if [[ -z $response ]] ; then
./hosts/uploadscloud.sh:149: echo -e "${RED}| Failed to extract download link [1]${NC}"
./hosts/uploadscloud.sh:150: warnAndRetryUnknownError=true
./hosts/uploadscloud.sh:151: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/uploadscloud.sh:152: rm -f "${upsc_cookie_jar}";
--
./hosts/uploadscloud.sh:183: file_header=$(tor_curl_request --insecure --head -L -s -b "${upsc_cookie_jar}" -c "${upsc_cookie_jar}" --referer "$remote_url" "$download_url")
./hosts/uploadscloud.sh:184: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/uploadscloud.sh:185: debugHtml "${remote_url##*/}" "upsc_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/uploadscloud.sh:186: fi
./hosts/uploadscloud.sh:187: if [[ -z $file_header ]] ; then
./hosts/uploadscloud.sh:188: if [[ $j == $maxfetchretries ]] ; then
./hosts/uploadscloud.sh:189: rm -f "${upsc_cookie_jar}";
./hosts/uploadscloud.sh:190: printf "\\n"
./hosts/uploadscloud.sh:191: echo -e "${RED}| Failed to extract file info.${NC}"
./hosts/uploadscloud.sh:192: warnAndRetryUnknownError=true
./hosts/uploadscloud.sh:193: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/uploadscloud.sh:306: tor_curl_request --insecure -L -G --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/uploadscloud.sh:307: else
./hosts/uploadscloud.sh:308: tor_curl_request --insecure -L -G "$download_url" --continue-at - --output "$file_path"
./hosts/uploadscloud.sh:309: fi
./hosts/uploadscloud.sh:310: received_file_size=0
./hosts/uploadscloud.sh:311: if [[ -f "$file_path" ]] ; then
./hosts/uploadscloud.sh:312: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/uploadscloud.sh:313: fi
./hosts/uploadscloud.sh:314: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/uploadscloud.sh:315: containsHtml=false
./hosts/uploadscloud.sh:316: else
./hosts/uploadscloud.sh:317: containsHtml=true
./hosts/uploadscloud.sh:318: fi
--
./hosts/up_1fichier.sh:107: response=$(tor_curl_request --insecure -L -s "https://1fichier.com/")
./hosts/up_1fichier.sh:108: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_1fichier.sh:109: debugHtml "${filepath##*/}" "${_hostCode}_up_getid_$i" "url: https://1fichier.com/"$'\n'"${response}"
./hosts/up_1fichier.sh:110: fi
./hosts/up_1fichier.sh:111: if [[ -z $response ]] ; then
./hosts/up_1fichier.sh:112: if [[ $i == $maxfetchretries ]] ; then
./hosts/up_1fichier.sh:113: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/up_1fichier.sh:114: printf "\\n"
./hosts/up_1fichier.sh:115: echo -e "${RED}| Upload failed. (GetId [1])${NC}"
./hosts/up_1fichier.sh:116: failedUpload "$pline" "${filepath}" "${_hostCode}" "Failed to upload file" "No Response (GetId [1])"
./hosts/up_1fichier.sh:117: exitUploadError=true
--
./hosts/up_1fichier.sh:180: response=$(tor_curl_upload --insecure -L \
./hosts/up_1fichier.sh:181: -F "file[]=@${arrFiles[@]}" \
./hosts/up_1fichier.sh:182: -F "send_ssl=on" \
./hosts/up_1fichier.sh:183: -F "domain=0" \
./hosts/up_1fichier.sh:184: -F "mail=" \
./hosts/up_1fichier.sh:185: -F "dpass=" \
./hosts/up_1fichier.sh:186: -F "user=" \
./hosts/up_1fichier.sh:187: -F "mails=" \
./hosts/up_1fichier.sh:188: -F "message=" \
./hosts/up_1fichier.sh:189: "${PostUrlHost}")
./hosts/up_1fichier.sh:190: if [[ "${DebugAllEnabled}" == "true" ]] ; then
--
./hosts/up_anonfile.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_anonfile.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_anonfile.sh:104: -F "sess_id=" \
./hosts/up_anonfile.sh:105: -F "utype=anon" \
./hosts/up_anonfile.sh:106: -F "file_descr=" \
./hosts/up_anonfile.sh:107: -F "file_public=1" \
./hosts/up_anonfile.sh:108: -F "link_rcpt=" \
./hosts/up_anonfile.sh:109: -F "link_pass=" \
./hosts/up_anonfile.sh:110: -F "to_folder=" \
./hosts/up_anonfile.sh:111: -F "upload=Start upload" \
./hosts/up_anonfile.sh:112: -F "keepalive=1" \
--
./hosts/up_anonfileio.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_anonfileio.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_anonfileio.sh:104: -F "keepalive=1" \
./hosts/up_anonfileio.sh:105: -F "file=@${filepath}" \
./hosts/up_anonfileio.sh:106: "${PostUrlHost}")
./hosts/up_anonfileio.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_anonfileio.sh:108: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_anonfileio.sh:109: fi
./hosts/up_anonfileio.sh:110: if grep -Eqi '"success":true,"code":"' <<< "${response}" ; then
./hosts/up_anonfileio.sh:111: hash=$(grep -oPi -m 1 '(?<="code":").*?(?=".*$)' <<< "$response")
./hosts/up_anonfileio.sh:112: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_anonsharing.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_anonsharing.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_anonsharing.sh:104: -F "files[]=@${arrFiles[@]}" \
./hosts/up_anonsharing.sh:105: "${PostUrlHost}")
./hosts/up_anonsharing.sh:106: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_anonsharing.sh:107: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_anonsharing.sh:108: fi
./hosts/up_anonsharing.sh:109: if grep -Eqi '"error":null,"url":"https:\\/\\/anonsharing.com\\/' <<< "${response}" ; then
./hosts/up_anonsharing.sh:110: fileid=$(grep -oPi '(?<=","file_id":").*?(?=".*$)' <<< "$response")
./hosts/up_anonsharing.sh:111: filesize=$(GetFileSize "$filepath" "false")
./hosts/up_anonsharing.sh:112: downloadLink="https://anonsharing.com/fileid=${fileid}"
--
./hosts/up_ateasystems.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_ateasystems.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_ateasystems.sh:104: -F "tos=" \
./hosts/up_ateasystems.sh:105: -F "file_0_descr=" \
./hosts/up_ateasystems.sh:106: -F "link_pass=" \
./hosts/up_ateasystems.sh:107: -F "file_0=@${filepath}" \
./hosts/up_ateasystems.sh:108: "${PostUrlHost}")
./hosts/up_ateasystems.sh:109: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_ateasystems.sh:110: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_ateasystems.sh:111: fi
./hosts/up_ateasystems.sh:112: if grep -Eqi "Location: https://share\.ateasystems\.com/share/\?\&filename\=" <<< "${response}" ; then
--
./hosts/up_axfc.sh:109: response=$(tor_curl_request --insecure -L -s -b "${axfc_cookie_jar}" -c "${axfc_cookie_jar}" "$fixed_url")
./hosts/up_axfc.sh:110: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_axfc.sh:111: debugHtml "${filepath##*/}" "axfc_fetch$i" "${response}"
./hosts/up_axfc.sh:112: fi
./hosts/up_axfc.sh:113: if [[ -z $response ]] ; then
./hosts/up_axfc.sh:114: rm -f "${axfc_cookie_jar}";
./hosts/up_axfc.sh:115: if [[ $i == $maxfetchretries ]] ; then
./hosts/up_axfc.sh:116: printf "\\n"
./hosts/up_axfc.sh:117: echo -e "${RED}| Failed to start an upload [1]${NC}"
./hosts/up_axfc.sh:118: warnAndRetryUnknownError=true
./hosts/up_axfc.sh:119: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/up_axfc.sh:136: response=$(tor_curl_upload --insecure -L -s -X POST \
./hosts/up_axfc.sh:137: -H 'Referer: https://www.axfc.net/u/post_m.pl' \
./hosts/up_axfc.sh:138: -H 'Content-Type: application/x-www-form-urlencoded' \
./hosts/up_axfc.sh:139: -H 'Origin: https://www.axfc.net' \
./hosts/up_axfc.sh:140: -H 'Connection: keep-alive' \
./hosts/up_axfc.sh:141: -b "${axfc_cookie_jar}" -c "${axfc_cookie_jar}" \
./hosts/up_axfc.sh:142: --data-raw "method=upload&ext=ext&filename=1&comment=&address=&delpass=$randelkey&keyword=1234&count=&term=0&term_y=2024&term_mon=10&term_d=1&term_h=15&term_min=0&term_s=0&term_ps=&term_mp=3600" \
./hosts/up_axfc.sh:143: -w "\n\nHTTP_CODE: %{http_code}\nEFFECTIVE_URL: %{url_effective}\n" \
./hosts/up_axfc.sh:144: "$fixed_url")
./hosts/up_axfc.sh:145: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_axfc.sh:146: debugHtml "${filepath##*/}" "axfc_ticket$i" "${response}"
--
./hosts/up_axfc.sh:184: response=$(tor_curl_upload --insecure -L -i -X POST \
./hosts/up_axfc.sh:185: -H "Content-Type: multipart/form-data" \
./hosts/up_axfc.sh:186: -H 'Connection: keep-alive' \
./hosts/up_axfc.sh:187: -F "filedata=@$filepath" \
./hosts/up_axfc.sh:188: -b "${axfc_cookie_jar}" -c "${axfc_cookie_jar}" \
./hosts/up_axfc.sh:189: "$PostUrlHost")
./hosts/up_axfc.sh:190: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_axfc.sh:191: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_axfc.sh:192: fi
./hosts/up_axfc.sh:193: response_ascii=$(mconvert_utf8_to_ascii "$response")
./hosts/up_axfc.sh:194: if [[ "${DebugAllEnabled}" == "true" ]] ; then
--
./hosts/up_bedrive.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_bedrive.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_bedrive.sh:104: -F "time=month" \
./hosts/up_bedrive.sh:105: -F "files[]=@${arrFiles[@]}" \
./hosts/up_bedrive.sh:106: "${PostUrlHost}")
./hosts/up_bedrive.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_bedrive.sh:108: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_bedrive.sh:109: fi
./hosts/up_bedrive.sh:110: if grep -Eqi '"error":null,"url":"https:\\/\\/bedrive.ru\\/' <<< "${response}" ; then
./hosts/up_bedrive.sh:111: hash=$(grep -oPi '(?<="url":"https:\\/\\/bedrive.ru\\/).*?(?=".*$)' <<< "$response")
./hosts/up_bedrive.sh:112: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_bowfile.sh:108: response=$(tor_curl_request --insecure -L -i \
./hosts/up_bowfile.sh:109: -H "Content-Type: multipart/form-data" \
./hosts/up_bowfile.sh:110: -F "files[]=@$filepath" \
./hosts/up_bowfile.sh:111: "${PostUrlHost}")
./hosts/up_bowfile.sh:112: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_bowfile.sh:113: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_bowfile.sh:114: fi
./hosts/up_bowfile.sh:115: if grep -Eqi '"error":null,"url":"https:\\/\\/bowfile.com\\/' <<< "${response}" ; then
./hosts/up_bowfile.sh:116: url=$(grep -oPi '(?<="url":"https:\\/\\/bowfile.com\\/).*?(?=")' <<< "$response")
./hosts/up_bowfile.sh:117: hash=$(grep -oPi '(?<="short_url":").*?(?=")' <<< "$response")
./hosts/up_bowfile.sh:118: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_dailyuploads.sh:109: response=$(tor_curl_upload --insecure -i \
./hosts/up_dailyuploads.sh:110: -H "Content-Type: multipart/form-data" \
./hosts/up_dailyuploads.sh:111: -F "sess_id=" \
./hosts/up_dailyuploads.sh:112: -F "utype=anon" \
./hosts/up_dailyuploads.sh:113: -F "link_rcpt=" \
./hosts/up_dailyuploads.sh:114: -F "link_pass=" \
./hosts/up_dailyuploads.sh:115: -F "to_folder=" \
./hosts/up_dailyuploads.sh:116: -F "file_descr=" \
./hosts/up_dailyuploads.sh:117: -F "file_public=1" \
./hosts/up_dailyuploads.sh:118: -F "file_0=@$filepath" \
./hosts/up_dailyuploads.sh:119: "${PostUrlHost}")
--
./hosts/up_dashfile.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_dashfile.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_dashfile.sh:104: -F "sess_id=" \
./hosts/up_dashfile.sh:105: -F "utype=anon" \
./hosts/up_dashfile.sh:106: -F "file_descr=" \
./hosts/up_dashfile.sh:107: -F "file_public=1" \
./hosts/up_dashfile.sh:108: -F "link_rcpt=" \
./hosts/up_dashfile.sh:109: -F "link_pass=" \
./hosts/up_dashfile.sh:110: -F "to_folder=" \
./hosts/up_dashfile.sh:111: -F "upload=Start upload" \
./hosts/up_dashfile.sh:112: -F "keepalive=1" \
--
./hosts/up_dataupload.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_dataupload.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_dataupload.sh:104: -F "sess_id=" \
./hosts/up_dataupload.sh:105: -F "file_descr=" \
./hosts/up_dataupload.sh:106: -F "file_public=" \
./hosts/up_dataupload.sh:107: -F "link_rcpt=" \
./hosts/up_dataupload.sh:108: -F "link_pass=" \
./hosts/up_dataupload.sh:109: -F "to_folder=" \
./hosts/up_dataupload.sh:110: -F "keepalive=1" \
./hosts/up_dataupload.sh:111: -F "file_0=@${filepath}" \
./hosts/up_dataupload.sh:112: "${PostUrlHost}")
--
./hosts/up_dbree.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_dbree.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_dbree.sh:104: -F "file[]=@${arrFiles[@]}" \
./hosts/up_dbree.sh:105: -F "upload=Upload" \
./hosts/up_dbree.sh:106: "${PostUrlHost}")
./hosts/up_dbree.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_dbree.sh:108: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_dbree.sh:109: fi
./hosts/up_dbree.sh:110: if grep -Eqi 'URL: <a href=' <<< "${response}" ; then
./hosts/up_dbree.sh:111: url=$(grep -oPi '(?<=<a href='"'"').*?(?='"'"')' <<< "$response")
./hosts/up_dbree.sh:112: hash=$(grep -oPi '(?<=/v/).*?(?=$)' <<< "$url")
--
./hosts/up_dosya.sh:107: response=$(tor_curl_upload --insecure -L -i \
./hosts/up_dosya.sh:108: -H "Content-Type: multipart/form-data" \
./hosts/up_dosya.sh:109: -F "files[]=@$filepath" \
./hosts/up_dosya.sh:110: "${PostUrlHost}")
./hosts/up_dosya.sh:111: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_dosya.sh:112: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_dosya.sh:113: fi
./hosts/up_dosya.sh:114: if grep -Eqi '"error":null,"url":"' <<< "${response}" ; then
./hosts/up_dosya.sh:115: url=$(grep -oPi '(?<="url":").*?(?=")' <<< "$response")
./hosts/up_dosya.sh:116: hash=$(grep -oPi '(?<="file_id":").*?(?=")' <<< "$response")
./hosts/up_dosya.sh:117: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_fileblade.sh:104: response=$(tor_curl_upload --insecure -i \
./hosts/up_fileblade.sh:105: -H "Content-Type: multipart/form-data" \
./hosts/up_fileblade.sh:106: -F "sess_id=" \
./hosts/up_fileblade.sh:107: -F "utype=anon" \
./hosts/up_fileblade.sh:108: -F "file_descr=" \
./hosts/up_fileblade.sh:109: -F "file_public=1" \
./hosts/up_fileblade.sh:110: -F "link_rcpt=" \
./hosts/up_fileblade.sh:111: -F "link_pass=" \
./hosts/up_fileblade.sh:112: -F "to_folder=" \
./hosts/up_fileblade.sh:113: -F "upload=Start upload" \
./hosts/up_fileblade.sh:114: -F "keepalive=1" \
--
./hosts/up_fileditch.sh:107: response=$(tor_curl_upload --insecure -i -L \
./hosts/up_fileditch.sh:108: -H "Content-Type: multipart/form-data" \
./hosts/up_fileditch.sh:109: -F "files[]=@${arrFiles[@]}" \
./hosts/up_fileditch.sh:110: "${PostUrlHost}")
./hosts/up_fileditch.sh:111: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_fileditch.sh:112: debugHtml "${filepath##*/}" "${_hostCode}_upload_$j" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_fileditch.sh:113: fi
./hosts/up_fileditch.sh:114: if grep -Eqi '<abbr title="Tor">Why we block tor</abbr>' <<< "${response}" ; then
./hosts/up_fileditch.sh:115: if ((j >= 20)); then
./hosts/up_fileditch.sh:116: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/up_fileditch.sh:117: printf "\\n"
--
./hosts/up_filehaus.sh:106: response=$(tor_curl_upload --insecure -i \
./hosts/up_filehaus.sh:107: -H "Content-Type: multipart/form-data" \
./hosts/up_filehaus.sh:108: -F "file=@$filepath" \
./hosts/up_filehaus.sh:109: -F "submit=Upload" \
./hosts/up_filehaus.sh:110: "${PostUrlHost}")
./hosts/up_filehaus.sh:111: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_filehaus.sh:112: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_filehaus.sh:113: fi
./hosts/up_filehaus.sh:114: if grep -Eqi 'HTTP/.* 200|https://cdn' <<< "${response}" ; then
./hosts/up_filehaus.sh:115: url=$(grep -oPi '(?<=https://).*(?=\.filehaus\.su).*?(?=$)' <<< "$response")
./hosts/up_filehaus.sh:116: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_fileland.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_fileland.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_fileland.sh:104: -F "sess_id=" \
./hosts/up_fileland.sh:105: -F "utype=anon" \
./hosts/up_fileland.sh:106: -F "file_descr=" \
./hosts/up_fileland.sh:107: -F "file_public=1" \
./hosts/up_fileland.sh:108: -F "link_rcpt=" \
./hosts/up_fileland.sh:109: -F "link_pass=" \
./hosts/up_fileland.sh:110: -F "to_folder=" \
./hosts/up_fileland.sh:111: -F "upload=Start upload" \
./hosts/up_fileland.sh:112: -F "keepalive=1" \
--
./hosts/up_fireget.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_fireget.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_fireget.sh:104: -H "Host: fireget.com" \
./hosts/up_fireget.sh:105: -F "sess_id=" \
./hosts/up_fireget.sh:106: -F "srv_tmp_url=" \
./hosts/up_fireget.sh:107: -F "link_rcpt=" \
./hosts/up_fireget.sh:108: -F "link_pass=" \
./hosts/up_fireget.sh:109: -F "tos=1" \
./hosts/up_fireget.sh:110: -F "submit_btn=Upload!" \
./hosts/up_fireget.sh:111: -F "upload_type=file" \
./hosts/up_fireget.sh:112: -F "file_1=@${filepath}" \
--
./hosts/up_firestorage.sh:113: response=$(tor_curl_upload --insecure -i \
./hosts/up_firestorage.sh:114: -H "Content-Type: multipart/form-data" \
./hosts/up_firestorage.sh:115: -F "jqueryupload=1" \
./hosts/up_firestorage.sh:116: -F "exp=0" \
./hosts/up_firestorage.sh:117: -F "Filename=@$filepath" \
./hosts/up_firestorage.sh:118: "${PostUrlHost}")
./hosts/up_firestorage.sh:119: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_firestorage.sh:120: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_firestorage.sh:121: fi
./hosts/up_firestorage.sh:122: dec_response=$(urldecode "$response")
./hosts/up_firestorage.sh:123: if grep -Eqi '<a href="http://firestorage.jp/download/' <<< "${dec_response}" ; then
--
./hosts/up_gofile.sh:102: response=$(tor_curl_request --insecure -L -s "https://api.gofile.io/servers")
./hosts/up_gofile.sh:103: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_gofile.sh:104: debugHtml "${remote_url##*/}" "${_hostCode}_store" "${response}"
./hosts/up_gofile.sh:105: fi
./hosts/up_gofile.sh:106: if [[ ! -z "$response" ]] ; then
./hosts/up_gofile.sh:107: if grep -Eqi '"status":"ok","data":{"servers":' <<< "${response}" ; then
./hosts/up_gofile.sh:108: gofileStoreServer=$(grep -oPi '(?<="servers":\[{"name":").*?(?=")' <<< "${response}")
./hosts/up_gofile.sh:109: echo -e "${GREEN}|${NC} Found: ${BLUE}$gofileStoreServer${NC}"
./hosts/up_gofile.sh:110: else
./hosts/up_gofile.sh:111: echo -e "${YELLOW}|${NC} Using default: ${YELLOW}$gofileStoreServer${NC}"
./hosts/up_gofile.sh:112: fi
--
./hosts/up_gofile.sh:121: response=$(tor_curl_upload --insecure -i \
./hosts/up_gofile.sh:122: -H "Content-Type: multipart/form-data" \
./hosts/up_gofile.sh:123: -F "sess_id=" \
./hosts/up_gofile.sh:124: -F "utype=anon" \
./hosts/up_gofile.sh:125: -F "mode=" \
./hosts/up_gofile.sh:126: -F "file_public=" \
./hosts/up_gofile.sh:127: -F "link_rcpt=" \
./hosts/up_gofile.sh:128: -F "link_pass=" \
./hosts/up_gofile.sh:129: -F "to_folder=" \
./hosts/up_gofile.sh:130: -F "keepalive=1" \
./hosts/up_gofile.sh:131: -F "file=@$filepath" \
--
./hosts/up_hexload.sh:109: response=$(tor_curl_upload --insecure -i \
./hosts/up_hexload.sh:110: -H "Content-Type: multipart/form-data" \
./hosts/up_hexload.sh:111: -F "sess_id=" \
./hosts/up_hexload.sh:112: -F "utype=anon" \
./hosts/up_hexload.sh:113: -F "mode=" \
./hosts/up_hexload.sh:114: -F "file_public=" \
./hosts/up_hexload.sh:115: -F "link_rcpt=" \
./hosts/up_hexload.sh:116: -F "link_pass=" \
./hosts/up_hexload.sh:117: -F "to_folder=" \
./hosts/up_hexload.sh:118: -F "keepalive=1" \
./hosts/up_hexload.sh:119: -F "file_0=@$filepath" \
--
./hosts/up_innocent.sh:99: response=$(tor_curl_upload --insecure -D - -o /dev/null \
./hosts/up_innocent.sh:100: -H "Host: innocent5z4fg2kdd4y6q4emu5nfybfiyr2mbp7s5pwllf6sqqhqdwyd.onion" \
./hosts/up_innocent.sh:101: -H "Referer: http://innocent5z4fg2kdd4y6q4emu5nfybfiyr2mbp7s5pwllf6sqqhqdwyd.onion.tor.my/" \
./hosts/up_innocent.sh:102: -H "Origin: http://innocent5z4fg2kdd4y6q4emu5nfybfiyr2mbp7s5pwllf6sqqhqdwyd.onion" \
./hosts/up_innocent.sh:103: -F "file=@${filepath}" \
./hosts/up_innocent.sh:104: "${PostUrlHost}")
./hosts/up_innocent.sh:105: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_innocent.sh:106: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_innocent.sh:107: fi
./hosts/up_innocent.sh:108: if grep -Eqi 'Location: \?uploaded=' <<< "${response}" ; then
./hosts/up_innocent.sh:109: url=$(grep -oPi '(?<=Location: ).*?(?=$)' <<< "$response")
--
./hosts/up_isupload.sh:104: response=$(tor_curl_upload --insecure -i \
./hosts/up_isupload.sh:105: -H "Content-Type: multipart/form-data" \
./hosts/up_isupload.sh:106: -F "sess_id=" \
./hosts/up_isupload.sh:107: -F "utype=anon" \
./hosts/up_isupload.sh:108: -F "file_descr=" \
./hosts/up_isupload.sh:109: -F "file_public=1" \
./hosts/up_isupload.sh:110: -F "link_rcpt=" \
./hosts/up_isupload.sh:111: -F "link_pass=" \
./hosts/up_isupload.sh:112: -F "to_folder=" \
./hosts/up_isupload.sh:113: -F "upload=Start upload" \
./hosts/up_isupload.sh:114: -F "keepalive=1" \
--
./hosts/up_kouploader.sh:108: response=$(tor_curl_request --insecure -L -s -b "${ko_cookie_jar}" -c "${ko_cookie_jar}" "$PostUrlHost")
./hosts/up_kouploader.sh:109: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_kouploader.sh:110: debugHtml "${filepath##*/}" "ko_fetch$i" "${response}"
./hosts/up_kouploader.sh:111: fi
./hosts/up_kouploader.sh:112: if [[ -z $response ]] ; then
./hosts/up_kouploader.sh:113: rm -f "${ko_cookie_jar}";
./hosts/up_kouploader.sh:114: if [[ $i == $maxfetchretries ]] ; then
./hosts/up_kouploader.sh:115: printf "\\n"
./hosts/up_kouploader.sh:116: echo -e "${RED}| Failed to start an upload [1]${NC}"
./hosts/up_kouploader.sh:117: warnAndRetryUnknownError=true
./hosts/up_kouploader.sh:118: if [[ "${finalAttempt}" == "true" ]] ; then
--
./hosts/up_kouploader.sh:132: response=$(tor_curl_upload --insecure -L -i \
./hosts/up_kouploader.sh:133: -H "Content-Type: multipart/form-data" \
./hosts/up_kouploader.sh:134: -H "Connection: keep-alive" \
./hosts/up_kouploader.sh:135: -F "com=$RANDOM" \
./hosts/up_kouploader.sh:136: -F "dlkey=1234" \
./hosts/up_kouploader.sh:137: -F "delkey=$randelkey" \
./hosts/up_kouploader.sh:138: -F "bin=true" \
./hosts/up_kouploader.sh:139: -F "file=@${filepath}" \
./hosts/up_kouploader.sh:140: -b "${ko_cookie_jar}" -c "${ko_cookie_jar}" \
./hosts/up_kouploader.sh:141: "${PostUrlHost}")
./hosts/up_kouploader.sh:142: if [[ "${DebugAllEnabled}" == "true" ]] ; then
--
./hosts/up_kraken.sh:115: response=$(tor_curl_upload --insecure -i \
./hosts/up_kraken.sh:116: -H "Content-Type: multipart/form-data" \
./hosts/up_kraken.sh:117: -F "files[]=@${arrFiles[@]}" \
./hosts/up_kraken.sh:118: "${PostUrlHost}")
./hosts/up_kraken.sh:119: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_kraken.sh:120: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_kraken.sh:121: fi
./hosts/up_kraken.sh:122: if grep -Eqi '"error":""' <<< "${response}" ; then
./hosts/up_kraken.sh:123: url=$(grep -oPi '(?<="url":").*?(?=")' <<< "$response")
./hosts/up_kraken.sh:124: hash=$(grep -oPi '(?<="hash":").*?(?=")' <<< "$response")
./hosts/up_kraken.sh:125: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_lainsafe.sh:112: response=$(tor_curl_upload --insecure -i \
./hosts/up_lainsafe.sh:113: -H "Content-Type: multipart/form-data" \
./hosts/up_lainsafe.sh:114: -F "files[]=@${arrFiles[@]}" \
./hosts/up_lainsafe.sh:115: "${PostUrlHost}")
./hosts/up_lainsafe.sh:116: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_lainsafe.sh:117: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_lainsafe.sh:118: fi
./hosts/up_lainsafe.sh:119: if [[ -z $response ]] || grep -Eqi 'HTTP/2 403|403 Forbidden' <<< "${response}" ; then
./hosts/up_lainsafe.sh:120: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/up_lainsafe.sh:121: err=$(grep -oPi '(?<=HTTP/).*?(?=$)' <<< "$response")
./hosts/up_lainsafe.sh:122: printf "\\n"
--
./hosts/up_nippy.sh:125: response=$(tor_curl_upload --insecure -i \
./hosts/up_nippy.sh:126: -H "Content-Type: multipart/form-data" \
./hosts/up_nippy.sh:127: -F "file[]=@${arrFiles[@]}" \
./hosts/up_nippy.sh:128: -F "upload=Upload" \
./hosts/up_nippy.sh:129: "${PostUrlHost}")
./hosts/up_nippy.sh:130: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_nippy.sh:131: debugHtml "${filepath##*/}" "${_hostCode}(${index})_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_nippy.sh:132: fi
./hosts/up_nippy.sh:133: if grep -Eqi 'URL: <a href=' <<< "${response}" ; then
./hosts/up_nippy.sh:134: url=$(grep -oPi '(?<=<a href='"'"').*?(?='"'"')' <<< "$response")
./hosts/up_nippy.sh:135: hash=$(grep -oPi '(?<=/v/).*?(?=$)' <<< "$url")
--
./hosts/up_nofile.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_nofile.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_nofile.sh:104: -F "file[]=@${arrFiles[@]}" \
./hosts/up_nofile.sh:105: -F "upload=Upload" \
./hosts/up_nofile.sh:106: "${PostUrlHost}")
./hosts/up_nofile.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_nofile.sh:108: debugHtml "${filepath##*/}" "${_hostCode}(${index})_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_nofile.sh:109: fi
./hosts/up_nofile.sh:110: if grep -Eqi 'URL: <a href=' <<< "${response}" ; then
./hosts/up_nofile.sh:111: url=$(grep -oPi '(?<=<a href='"'"').*?(?='"'"')' <<< "$response")
./hosts/up_nofile.sh:112: hash=$(grep -oPi '(?<=/v/).*?(?=$)' <<< "$url")
--
./hosts/up_offshorecat.sh:104: response=$(tor_curl_upload --insecure -i \
./hosts/up_offshorecat.sh:105: -H "Content-Type: multipart/form-data" \
./hosts/up_offshorecat.sh:106: -H "x-api-key: $apikey" \
./hosts/up_offshorecat.sh:107: -F "files[]=@$filepath" \
./hosts/up_offshorecat.sh:108: "${PostUrlHost}")
./hosts/up_offshorecat.sh:109: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_offshorecat.sh:110: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_offshorecat.sh:111: fi
./hosts/up_offshorecat.sh:112: if grep -Eqi '"url":"https://files.offshore.cat/' <<< "${response}" ; then
./hosts/up_offshorecat.sh:113: hash=$(grep -oPi '(?<="url":"https://files.offshore.cat/).*?(?=".*$)' <<< "$response")
./hosts/up_offshorecat.sh:114: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_oshi.sh:110: response=$(tor_curl_upload --insecure \
./hosts/up_oshi.sh:111: -F "files[]=@${arrFiles[@]}" \
./hosts/up_oshi.sh:112: -F "expire=129600" \
./hosts/up_oshi.sh:113: -F "autodestroy=0" \
./hosts/up_oshi.sh:114: -F "randomizefn=0" \
./hosts/up_oshi.sh:115: -F "shorturl=0" \
./hosts/up_oshi.sh:116: "${PostUrlHost}")
./hosts/up_oshi.sh:117: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_oshi.sh:118: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_oshi.sh:119: fi
./hosts/up_oshi.sh:120: if grep -Eqi '^DL: ' <<< "${response}" ; then
--
./hosts/up_pixeldrain.sh:112: response=$(tor_curl_upload --insecure -X PUT \
./hosts/up_pixeldrain.sh:113: -u :"$apikey" "${PostUrlHost}" -T "${filepath}")
./hosts/up_pixeldrain.sh:114: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_pixeldrain.sh:115: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"apikey: ${apikey}"$'\n'"${response}"
./hosts/up_pixeldrain.sh:116: fi
./hosts/up_pixeldrain.sh:117: if grep -Eqi '"success":false,"value":"ip_banned"' <<< "$response"; then
./hosts/up_pixeldrain.sh:118: echo -e "${YELLOW}Banned IP${NC} (retry)..."
./hosts/up_pixeldrain.sh:119: continue
./hosts/up_pixeldrain.sh:120: elif grep -Eqi '"success":false' <<< "$response"; then
./hosts/up_pixeldrain.sh:121: echo -e "${YELLOW}Unexpected response${NC} (retry)..."
./hosts/up_pixeldrain.sh:122: continue
--
./hosts/up_quax.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_quax.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_quax.sh:104: -H "expiry=-1" \
./hosts/up_quax.sh:105: -F "files[]=@${arrFiles[@]}" \
./hosts/up_quax.sh:106: "${PostUrlHost}")
./hosts/up_quax.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_quax.sh:108: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_quax.sh:109: fi
./hosts/up_quax.sh:110: if grep -Eqi '"success": true,' <<< "${response}" ; then
./hosts/up_quax.sh:111: url=$(grep -oPi '(?<="url": ").*?(?=".*$)' <<< "$response")
./hosts/up_quax.sh:112: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_ranoz.sh:133: response=$(tor_curl_upload --insecure -L -i -s \
./hosts/up_ranoz.sh:134: -b "${up_rz_cookie_jar}" -c "${up_rz_cookie_jar}" \
./hosts/up_ranoz.sh:135: "$PrePostUrl")
./hosts/up_ranoz.sh:136: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_ranoz.sh:137: debugHtml "${filepath##*/}" "${_hostCode}_prepost" "prepost_url: ${PrePostUrl}"$'\n'"${response}"
./hosts/up_ranoz.sh:138: fi
./hosts/up_ranoz.sh:139: trap "rm -f ${UploadTicket}; rm -f ${up_rz_cookie_jar}; echo ""; tput cnorm; exit" 0 1 2 3 6 15
./hosts/up_ranoz.sh:140: response=$(tor_curl_upload --insecure -Lis \
./hosts/up_ranoz.sh:141: "$PostUrlHost" \
./hosts/up_ranoz.sh:142: -b "${up_rz_cookie_jar}" -c "${up_rz_cookie_jar}" \
./hosts/up_ranoz.sh:143: -H "Content-Type: application/json" \
./hosts/up_ranoz.sh:144: -d "{ \
./hosts/up_ranoz.sh:145: \"filename\": \"$tmpfilename\", \
./hosts/up_ranoz.sh:146: \"size\": $fsize}")
./hosts/up_ranoz.sh:147: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_ranoz.sh:148: debugHtml "${filepath##*/}" "${_hostCode}_ticket" "post_url: ${PostUrlHost}"$'\n'"data: ${filepath}, ${fsize}"$'\n'"${response}"
./hosts/up_ranoz.sh:149: fi
./hosts/up_ranoz.sh:150: if grep -Eqi '"upload_url":"https://' <<< "$response" ; then
--
./hosts/up_ranoz.sh:169: response=$(tor_curl_upload --insecure -i -X PUT \
./hosts/up_ranoz.sh:170: "${PostUrlHost}" \
./hosts/up_ranoz.sh:171: --upload-file "$filepath" \
./hosts/up_ranoz.sh:172: -b "${up_rz_cookie_jar}" -c "${up_rz_cookie_jar}" \
./hosts/up_ranoz.sh:173: -H "Content-Length: $fsize")
./hosts/up_ranoz.sh:174: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_ranoz.sh:175: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_ranoz.sh:176: fi
./hosts/up_ranoz.sh:177: rm -f ${up_rz_cookie_jar};
./hosts/up_ranoz.sh:178: if grep -Eqi 'HTTP/.* 200' <<< "${response}" ; then
./hosts/up_ranoz.sh:179: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_sendnow.sh:101: response=$(tor_curl_request --insecure -L -s 'https://send.now/upload')
./hosts/up_sendnow.sh:102: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_sendnow.sh:103: debugHtml "${filepath##*/}" "${_hostCode}_fetch" "${response}"
./hosts/up_sendnow.sh:104: fi
./hosts/up_sendnow.sh:105: if grep -Eqi "Your IP has been banned|you are banned" <<< "$response"; then
./hosts/up_sendnow.sh:106: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/up_sendnow.sh:107: printf "\\n"
./hosts/up_sendnow.sh:108: echo -e "${RED}| Failed to upload file: Ip blocked or banned${NC}"
./hosts/up_sendnow.sh:109: failedRetryUpload "$pline" "${filepath}" "${_hostCode}" "Failed to upload file" "Ip blocked or banned"
./hosts/up_sendnow.sh:110: exitUploadError=true
./hosts/up_sendnow.sh:111: return 1
--
./hosts/up_sendnow.sh:138: response=$(tor_curl_upload --insecure -i \
./hosts/up_sendnow.sh:139: -H "Content-Type: multipart/form-data" \
./hosts/up_sendnow.sh:140: -F "sess_id=" \
./hosts/up_sendnow.sh:141: -F "utype=anon" \
./hosts/up_sendnow.sh:142: -F "file_descr=" \
./hosts/up_sendnow.sh:143: -F "file_public=1" \
./hosts/up_sendnow.sh:144: -F "link_rcpt=" \
./hosts/up_sendnow.sh:145: -F "link_pass=" \
./hosts/up_sendnow.sh:146: -F "to_folder=" \
./hosts/up_sendnow.sh:147: -F "upload=Start upload" \
./hosts/up_sendnow.sh:148: -F "keepalive=1" \
--
./hosts/up_sendspace.sh:106: response=$(tor_curl_request --insecure -L -s -b "${ss_cookie_jar}" -c "${ss_cookie_jar}" "https://sendspace.com")
./hosts/up_sendspace.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_sendspace.sh:108: debugHtml "${remote_url##*/}" "${_hostCode}_upload_fetch$i" "${response}"
./hosts/up_sendspace.sh:109: fi
./hosts/up_sendspace.sh:110: if [[ -z $response ]] ; then
./hosts/up_sendspace.sh:111: rm -f "${ss_cookie_jar}";
./hosts/up_sendspace.sh:112: if [[ $i == $maxfetchretries ]] ; then
./hosts/up_sendspace.sh:113: printf "\\n"
./hosts/up_sendspace.sh:114: echo -e "${RED}| Failed to extract download upload info${NC}"
./hosts/up_sendspace.sh:115: failedRetryUpload "$pline" "${filepath}" "${_hostCode}" "Failed to upload file." "No response"
./hosts/up_sendspace.sh:116: exitUploadError=true
--
./hosts/up_sendspace.sh:160: response=$(tor_curl_upload --insecure -i -L \
./hosts/up_sendspace.sh:161: -H "Content-Type: multipart/form-data" \
./hosts/up_sendspace.sh:162: -F "terms=1" \
./hosts/up_sendspace.sh:163: -F "utype=anon" \
./hosts/up_sendspace.sh:164: -F "signature=$post_sig" \
./hosts/up_sendspace.sh:165: -F "file[]=" \
./hosts/up_sendspace.sh:166: -F "upload_file[]=@$filepath" \
./hosts/up_sendspace.sh:167: -b "${ss_cookie_jar}" -c "${ss_cookie_jar}" \
./hosts/up_sendspace.sh:168: "${PostUrlHost}")
./hosts/up_sendspace.sh:169: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_sendspace.sh:170: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
--
./hosts/up_shareonline.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_shareonline.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_shareonline.sh:104: -F "file[]=@${arrFiles[@]}" \
./hosts/up_shareonline.sh:105: -F "upload=Upload" \
./hosts/up_shareonline.sh:106: "${PostUrlHost}")
./hosts/up_shareonline.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_shareonline.sh:108: debugHtml "${filepath##*/}" "${_hostCode}(${index})_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_shareonline.sh:109: fi
./hosts/up_shareonline.sh:110: if grep -Eqi 'URL: <a href=' <<< "${response}" ; then
./hosts/up_shareonline.sh:111: url=$(grep -oPi '(?<=<a href='"'"').*?(?='"'"')' <<< "$response")
./hosts/up_shareonline.sh:112: hash=$(grep -oPi '(?<=/v/).*?(?=$)' <<< "$url")
--
./hosts/up_syspro.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_syspro.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_syspro.sh:104: -F "tos=" \
./hosts/up_syspro.sh:105: -F "link_rcpt=" \
./hosts/up_syspro.sh:106: -F "link_pass=" \
./hosts/up_syspro.sh:107: -F "file_1=@${filepath}" \
./hosts/up_syspro.sh:108: "${PostUrlHost}")
./hosts/up_syspro.sh:109: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_syspro.sh:110: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_syspro.sh:111: fi
./hosts/up_syspro.sh:112: if grep -Eqi "Location: http://share\.syspro\.com\.br/" <<< "${response}" ; then
--
./hosts/up_tempfileme.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_tempfileme.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_tempfileme.sh:104: -F "files=@$filepath" \
./hosts/up_tempfileme.sh:105: "${PostUrlHost}")
./hosts/up_tempfileme.sh:106: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_tempfileme.sh:107: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_tempfileme.sh:108: fi
./hosts/up_tempfileme.sh:109: if grep -Eqi 'HTTP/.* 200' <<< "${response}" ; then
./hosts/up_tempfileme.sh:110: url=$(grep -oPi '(?<=\{"links":\[").*?(?="\])' <<< "$response")
./hosts/up_tempfileme.sh:111: filesize=$(GetFileSize "$filepath" "false")
./hosts/up_tempfileme.sh:112: downloadLink=$url
--
./hosts/up_tempsh.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_tempsh.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_tempsh.sh:104: -F "submit=Upload!" \
./hosts/up_tempsh.sh:105: -F "file=@$filepath" \
./hosts/up_tempsh.sh:106: "${PostUrlHost}")
./hosts/up_tempsh.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_tempsh.sh:108: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_tempsh.sh:109: fi
./hosts/up_tempsh.sh:110: if grep -Eqi 'HTTP/.* 200' <<< "${response}" ; then
./hosts/up_tempsh.sh:111: hash=$(grep -oPi '(?<=http://temp.sh/).*?(?=$)' <<< "$response")
./hosts/up_tempsh.sh:112: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_torup.sh:109: response=$(tor_curl_request --insecure -L -s -b "${torp_cookie_jar}" -c "${torp_cookie_jar}" \
./hosts/up_torup.sh:110: "http://ktgzpea2b76u7fgemiibp4a76onyybo4fw5gbsagtm6jrjzmgivppyyd.onion")
./hosts/up_torup.sh:111: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_torup.sh:112: debugHtml "${filepath##*/}" "torp_fetch$i" "${response}"
./hosts/up_torup.sh:113: fi
./hosts/up_torup.sh:114: if [[ -z $response ]] ; then
./hosts/up_torup.sh:115: rm -f "${torp_cookie_jar}";
./hosts/up_torup.sh:116: if [[ $i == $maxfetchretries ]] ; then
./hosts/up_torup.sh:117: printf "\\n"
./hosts/up_torup.sh:118: echo -e "${RED}| Failed to start an upload [1]${NC}"
./hosts/up_torup.sh:119: warnAndRetryUnknownError=true
--
./hosts/up_torup.sh:149: response=$(tor_curl_upload --insecure -i \
./hosts/up_torup.sh:150: -H "Content-Type: multipart/form-data" \
./hosts/up_torup.sh:151: -H "Referer: http://ktgzpea2b76u7fgemiibp4a76onyybo4fw5gbsagtm6jrjzmgivppyyd.onion.tor.my/" \
./hosts/up_torup.sh:152: -H "Origin: http://ktgzpea2b76u7fgemiibp4a76onyybo4fw5gbsagtm6jrjzmgivppyyd.onion" \
./hosts/up_torup.sh:153: -F "gorilla.csrf.Token=$csrf_token" \
./hosts/up_torup.sh:154: -F "file_type=free" \
./hosts/up_torup.sh:155: -F "file=@${filepath}" \
./hosts/up_torup.sh:156: -b "${torp_cookie_jar}" -c "${torp_cookie_jar}" \
./hosts/up_torup.sh:157: "${PostUrlHost}")
./hosts/up_torup.sh:158: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_torup.sh:159: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"csrf_token: ${csrf_token}"$'\n'"${response}"
--
./hosts/up_turboonion.sh:99: response=$(tor_curl_upload --insecure \
./hosts/up_turboonion.sh:100: -F "files=@${arrFiles[@]}" \
./hosts/up_turboonion.sh:101: -F "options[isOldName]=false" \
./hosts/up_turboonion.sh:102: -F "options[isPreview]=true" \
./hosts/up_turboonion.sh:103: -F "options[isAutoDelete]=false" \
./hosts/up_turboonion.sh:104: -F "options[isPassword]=false" \
./hosts/up_turboonion.sh:105: -F "options[password]=" \
./hosts/up_turboonion.sh:106: -F "options[autoDeleteOption]=" \
./hosts/up_turboonion.sh:107: -F "options[deleteTime]=1542" \
./hosts/up_turboonion.sh:108: -F "options[description]=" \
./hosts/up_turboonion.sh:109: -F "options[maxDownloads]=0" \
--
./hosts/up_uploadbay.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_uploadbay.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_uploadbay.sh:104: -H "expiry=-1" \
./hosts/up_uploadbay.sh:105: -F "fileToUpload=@${filepath}" \
./hosts/up_uploadbay.sh:106: "${PostUrlHost}")
./hosts/up_uploadbay.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_uploadbay.sh:108: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_uploadbay.sh:109: fi
./hosts/up_uploadbay.sh:110: if grep -Eqi "class='file one' href='https://uploadbay.net/uploads/" <<< "${response}" ; then
./hosts/up_uploadbay.sh:111: url=$(grep -oPi '(?<=href='"'"').*?(?='"'"'.*$)' <<< "$response")
./hosts/up_uploadbay.sh:112: filesize=$(GetFileSize "$filepath" "false")
--
./hosts/up_uploadee.sh:106: response=$(tor_curl_request --insecure -L -s "https://www.upload.ee/ubr_link_upload.php")
./hosts/up_uploadee.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_uploadee.sh:108: debugHtml "${filepath##*/}" "${_hostCode}_up_getid_$i" "url: https://www.upload.ee/ubr_link_upload.php"$'\n'"${response}"
./hosts/up_uploadee.sh:109: fi
./hosts/up_uploadee.sh:110: if [[ -z $response ]] ; then
./hosts/up_uploadee.sh:111: if [[ $i == $maxfetchretries ]] ; then
./hosts/up_uploadee.sh:112: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/up_uploadee.sh:113: printf "\\n"
./hosts/up_uploadee.sh:114: echo -e "${RED}| Upload failed. (GetId [1])${NC}"
./hosts/up_uploadee.sh:115: failedUpload "$pline" "${filepath}" "${_hostCode}" "Failed to upload file" "No Response (GetId [1])"
./hosts/up_uploadee.sh:116: exitUploadError=true
--
./hosts/up_uploadee.sh:176: response=$(tor_curl_upload --insecure -i -L \
./hosts/up_uploadee.sh:177: -H "Content-Type: multipart/form-data" \
./hosts/up_uploadee.sh:178: -F "upfile_0=@$filepath" \
./hosts/up_uploadee.sh:179: "${PostUrlHost}")
./hosts/up_uploadee.sh:180: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_uploadee.sh:181: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_uploadee.sh:182: fi
./hosts/up_uploadee.sh:183: if grep -Eqi 'File successfully uploaded!!' <<< "${response}" ; then
./hosts/up_uploadee.sh:184: url=$(grep -oPi '(?<=View file:\<br /\>\<a href\=").*?(?=".*$)' <<< "$response")
./hosts/up_uploadee.sh:185: filesize=$(GetFileSize "$filepath" "false")
./hosts/up_uploadee.sh:186: downloadLink="$url"
--
./hosts/up_uploadev.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_uploadev.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_uploadev.sh:104: -F "sess_id=" \
./hosts/up_uploadev.sh:105: -F "utype=anon" \
./hosts/up_uploadev.sh:106: -F "file_descr=" \
./hosts/up_uploadev.sh:107: -F "file_public=" \
./hosts/up_uploadev.sh:108: -F "link_rcpt=" \
./hosts/up_uploadev.sh:109: -F "link_pass=" \
./hosts/up_uploadev.sh:110: -F "to_folder=" \
./hosts/up_uploadev.sh:111: -F "file_0=@$filepath" \
./hosts/up_uploadev.sh:112: "${PostUrlHost}")
--
./hosts/up_uploadflix.sh:106: response=$(tor_curl_upload --insecure -i \
./hosts/up_uploadflix.sh:107: -H "Content-Type: multipart/form-data" \
./hosts/up_uploadflix.sh:108: -F "sess_id=" \
./hosts/up_uploadflix.sh:109: -F "utype=anon" \
./hosts/up_uploadflix.sh:110: -F "file_descr=" \
./hosts/up_uploadflix.sh:111: -F "file_public=1" \
./hosts/up_uploadflix.sh:112: -F "link_rcpt=" \
./hosts/up_uploadflix.sh:113: -F "link_pass=" \
./hosts/up_uploadflix.sh:114: -F "to_folder=" \
./hosts/up_uploadflix.sh:115: -F "upload=Start upload" \
./hosts/up_uploadflix.sh:116: -F "keepalive=1" \
--
./hosts/up_uploadhive.sh:131: response=$(tor_curl_upload --insecure -i \
./hosts/up_uploadhive.sh:132: -H "Content-Type: multipart/form-data" \
./hosts/up_uploadhive.sh:133: -F "sess_id=" \
./hosts/up_uploadhive.sh:134: -F "utype=anon" \
./hosts/up_uploadhive.sh:135: -F "link_rcpt=" \
./hosts/up_uploadhive.sh:136: -F "link_pass=" \
./hosts/up_uploadhive.sh:137: -F "to_folder=" \
./hosts/up_uploadhive.sh:138: -F "file_descr=" \
./hosts/up_uploadhive.sh:139: -F "file_public=1" \
./hosts/up_uploadhive.sh:140: -F "upload=Start upload" \
./hosts/up_uploadhive.sh:141: -F "file_0=@$tmpfilepath" \
--
./hosts/up_uploadraja.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_uploadraja.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_uploadraja.sh:104: -F "file_descr=" \
./hosts/up_uploadraja.sh:105: -F "file_public=" \
./hosts/up_uploadraja.sh:106: -F "link_rcpt=" \
./hosts/up_uploadraja.sh:107: -F "link_pass=" \
./hosts/up_uploadraja.sh:108: -F "to_folder=" \
./hosts/up_uploadraja.sh:109: -F "keepalive=1" \
./hosts/up_uploadraja.sh:110: -F "upload=Start upload" \
./hosts/up_uploadraja.sh:111: -F "file_0=@${filepath}" \
./hosts/up_uploadraja.sh:112: "${PostUrlHost}")
--
./hosts/up_uwabaki.sh:102: response=$(tor_curl_upload --insecure -i -L \
./hosts/up_uwabaki.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_uwabaki.sh:104: -F "formatted=true" \
./hosts/up_uwabaki.sh:105: -F "encryption=off" \
./hosts/up_uwabaki.sh:106: -F "files[]=@$filepath" \
./hosts/up_uwabaki.sh:107: "${PostUrlHost}")
./hosts/up_uwabaki.sh:108: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_uwabaki.sh:109: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_uwabaki.sh:110: fi
./hosts/up_uwabaki.sh:111: if grep -Eqi 'File uploaded: <a href="https://files.uwabaki.party/' <<< "${response}" ; then
./hosts/up_uwabaki.sh:112: url=$(grep -oPi '(?<=File uploaded: <a href=").*?(?=">.*$)' <<< "$response")
--
./hosts/up_yolobit.sh:102: response=$(tor_curl_upload --insecure -i \
./hosts/up_yolobit.sh:103: -H "Content-Type: multipart/form-data" \
./hosts/up_yolobit.sh:104: -F "file[]=@${arrFiles[@]}" \
./hosts/up_yolobit.sh:105: -F "upload=Upload" \
./hosts/up_yolobit.sh:106: "${PostUrlHost}")
./hosts/up_yolobit.sh:107: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/up_yolobit.sh:108: debugHtml "${filepath##*/}" "${_hostCode}(${index})_upload" "post_url: ${PostUrlHost}"$'\n'"${response}"
./hosts/up_yolobit.sh:109: fi
./hosts/up_yolobit.sh:110: if grep -Eqi 'URL: <a href=' <<< "${response}" ; then
./hosts/up_yolobit.sh:111: url=$(grep -oPi '(?<=<a href='"'"').*?(?='"'"')' <<< "$response")
./hosts/up_yolobit.sh:112: hash=$(grep -oPi '(?<=/v/).*?(?=$)' <<< "$url")
--
./hosts/youdbox.sh:95: response=$(tor_curl_request --insecure -L -i -s "${fixed_url}")
./hosts/youdbox.sh:96: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/youdbox.sh:97: debugHtml "${remote_url##*/}" "youd_dwnpage$j" "${response}"
./hosts/youdbox.sh:98: fi
./hosts/youdbox.sh:99: if [[ -z $response ]] ; then
./hosts/youdbox.sh:100: if [[ $j == $maxfetchretries ]] ; then
./hosts/youdbox.sh:101: printf "\\n"
./hosts/youdbox.sh:102: echo -e "${RED}| Failed to extract post link.${NC}"
./hosts/youdbox.sh:103: warnAndRetryUnknownError=true
./hosts/youdbox.sh:104: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/youdbox.sh:105: failedRetryDownload "${remote_url}" "" ""
--
./hosts/youdbox.sh:141: response=$(tor_curl_request --insecure -L -s -X POST --data "$form_data" "${fixed_url}")
./hosts/youdbox.sh:142: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/youdbox.sh:143: debugHtml "${remote_url##*/}" "youd_post" "${response}"
./hosts/youdbox.sh:144: fi
./hosts/youdbox.sh:145: if [[ -z $response ]] ; then
./hosts/youdbox.sh:146: echo -e "${RED}| Failed to extract download link.${NC}"
./hosts/youdbox.sh:147: warnAndRetryUnknownError=true
./hosts/youdbox.sh:148: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/youdbox.sh:149: failedRetryDownload "${remote_url}" "" ""
./hosts/youdbox.sh:150: fi
./hosts/youdbox.sh:151: return 1
--
./hosts/youdbox.sh:183: file_header=$(tor_curl_request --insecure -L --head -s --referer "${fixed_url}" "$download_url")
./hosts/youdbox.sh:184: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./hosts/youdbox.sh:185: debugHtml "${remote_url##*/}" "youd_head$j" "download_url: ${download_url}"$'\n'"${file_header}"
./hosts/youdbox.sh:186: fi
./hosts/youdbox.sh:187: if [[ -z $file_header ]] ; then
./hosts/youdbox.sh:188: if [[ $j == $maxfetchretries ]] ; then
./hosts/youdbox.sh:189: printf "\\n"
./hosts/youdbox.sh:190: echo -e "${RED}| Failed to extract file info.${NC}"
./hosts/youdbox.sh:191: warnAndRetryUnknownError=true
./hosts/youdbox.sh:192: if [[ "${finalAttempt}" == "true" ]] ; then
./hosts/youdbox.sh:193: failedRetryDownload "${remote_url}" "" ""
--
./hosts/youdbox.sh:276: tor_curl_request --insecure -L -G --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./hosts/youdbox.sh:277: else
./hosts/youdbox.sh:278: tor_curl_request --insecure -L -G "$download_url" --continue-at - --output "$file_path"
./hosts/youdbox.sh:279: fi
./hosts/youdbox.sh:280: received_file_size=0
./hosts/youdbox.sh:281: if [[ -f "$file_path" ]] ; then
./hosts/youdbox.sh:282: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./hosts/youdbox.sh:283: fi
./hosts/youdbox.sh:284: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./hosts/youdbox.sh:285: containsHtml=false
./hosts/youdbox.sh:286: else
./hosts/youdbox.sh:287: containsHtml=true
./hosts/youdbox.sh:288: fi
--
./mad.sh:367:tor_curl_request() {
./mad.sh:368: if [[ "${UseTorCurlImpersonate}" == "true" ]]; then
./mad.sh:369: "${curl_impersonate[@]}" --proxy "socks5h://${tor_identity}@${TorIp}:${torPort}" -4 --connect-timeout ${ConnectTimeout} --compressed --globoff "$@"
./mad.sh:370: else
./mad.sh:371: curl --proxy "socks5h://${tor_identity}@${TorIp}:${torPort}" -4 --connect-timeout ${ConnectTimeout} --compressed --globoff "$@"
./mad.sh:372: fi
./mad.sh:373:}
./mad.sh:374:tor_curl_request_extended() {
./mad.sh:375: randomtimeout=$((30 + RANDOM % (60 - 30)))
./mad.sh:376: if [[ "${UseTorCurlImpersonate}" == "true" ]]; then
./mad.sh:377: "${curl_impersonate[@]}" --proxy "socks5h://${tor_identity}@${TorIp}:${torPort}" -4 --connect-timeout $randomtimeout --compressed --globoff "$@"
./mad.sh:378: else
./mad.sh:379: curl --proxy "socks5h://${tor_identity}@${TorIp}:${torPort}" -4 --connect-timeout $randomtimeout --compressed --globoff "$@"
./mad.sh:380: fi
./mad.sh:381:}
./mad.sh:382:tor_curl_upload() {
./mad.sh:383: if [[ "${UseTorCurlImpersonate}" == "true" ]]; then
./mad.sh:384: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./mad.sh:385: "${curl_impersonate[@]}" --proxy "socks5h://${tor_identity}@${TorIp}:${torPort}" -4 --expect100-timeout 10 --connect-timeout ${ConnectTimeoutUpload} --speed-limit $UploadSpeedMin --speed-time $UploadTimeoutInterval --compressed --globoff "$@"
./mad.sh:386: else
./mad.sh:387: "${curl_impersonate[@]}" --proxy "socks5h://${tor_identity}@${TorIp}:${torPort}" -4 --expect100-timeout 10 --connect-timeout ${ConnectTimeoutUpload} --compressed --globoff "$@"
./mad.sh:388: fi
./mad.sh:389: else
./mad.sh:390: if [[ "${RateMonitorEnabled}" == "true" ]]; then
./mad.sh:391: curl --proxy "socks5h://${tor_identity}@${TorIp}:${torPort}" -4 --expect100-timeout 10 --connect-timeout ${ConnectTimeoutUpload} --speed-limit $UploadSpeedMin --speed-time $UploadTimeoutInterval -H 'User-Agent: Mozilla/5.0 (Windows NT 10.0; rv:109.0) Gecko/20100101 Firefox/115.0' -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8' -H 'Accept-Language: en-US,en;q=0.5' -H 'Accept-Encoding: gzip, deflate, br' -H 'Origin: null' -H 'Connection: keep-alive' -H 'Upgrade-Insecure-Requests: 1' -H 'Sec-Fetch-Dest: document' -H 'Sec-Fetch-Mode: navigate' -H 'Sec-Fetch-Site: cross-site' -H 'Sec-Fetch-User: ?1' -H 'TE: trailers' --compressed --globoff "$@"
./mad.sh:392: else
--
./mad.sh:1437: response=$(tor_curl_request --insecure -L -s https://github.com/lwthiker/curl-impersonate/releases/latest)
./mad.sh:1438: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./mad.sh:1439: debugHtml "github" "lbf_inst_curlimp$j" "$response"
./mad.sh:1440: fi
./mad.sh:1441: if [[ ! -z "$response" ]]; then
./mad.sh:1442: latestTag=$(grep -oPi -m 1 '(?<=/curl-impersonate/releases/tag/).*?(?=")' <<< "$response")
./mad.sh:1443: latestBinaryDate=$(grep -oPi -m 1 '(?<=<relative-time class="no-wrap" prefix="" datetime=").*?(?=T)' <<< "$response")
./mad.sh:1444: break
./mad.sh:1445: fi
./mad.sh:1446: done
./mad.sh:1447: if [[ -z $latestTag ]]; then
--
./mad.sh:1457: file_header=$(tor_curl_request --insecure --head -Ls "$download_url")
./mad.sh:1458: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./mad.sh:1459: debugHtml "github" "head_inst_curlimp$j" "${file_header}"
./mad.sh:1460: fi
./mad.sh:1461: if ! grep -Eqi 'HTTP/2 200|HTTP/1.1 200|200 OK' <<< $file_header ; then
./mad.sh:1462: if ((j == 8)) ; then
./mad.sh:1463: return 1
./mad.sh:1464: else
./mad.sh:1465: continue
./mad.sh:1466: fi
./mad.sh:1467: fi
--
./mad.sh:1507: tor_curl_request --insecure -L "$download_url" --continue-at - --output "$file_path"
./mad.sh:1508: received_file_size=0
./mad.sh:1509: if [[ -f "$file_path" ]] ; then
./mad.sh:1510: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./mad.sh:1511: fi
./mad.sh:1512: if ((received_file_size == file_size_bytes)) ; then
./mad.sh:1513: break
./mad.sh:1514: elif ((received_file_size < file_size_bytes)) ; then
./mad.sh:1515: if ((j >= MaxDownloadRetries)) ; then
./mad.sh:1516: echo -e "${RED}| FAILED: Size mismatch after downloading${NC}"
./mad.sh:1517: exit 1
--
./mad.sh:1560: response=$(tor_curl_request --insecure -L -s https://github.com/lexiforest/curl-impersonate/releases/latest)
./mad.sh:1561: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./mad.sh:1562: debugHtml "github" "lbf_inst_curlimp$j" "$response"
./mad.sh:1563: fi
./mad.sh:1564: if [[ ! -z "$response" ]]; then
./mad.sh:1565: latestTag=$(grep -oPi -m 1 '(?<=/curl-impersonate/releases/tag/).*?(?=")' <<< "$response")
./mad.sh:1566: latestBinaryDate=$(grep -oPi -m 1 '(?<=<relative-time class="no-wrap" prefix="" datetime=").*?(?=T)' <<< "$response")
./mad.sh:1567: break
./mad.sh:1568: fi
./mad.sh:1569: done
./mad.sh:1570: if [[ -z $latestTag ]]; then
--
./mad.sh:1580: file_header=$(tor_curl_request --insecure --head -Ls "$download_url")
./mad.sh:1581: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./mad.sh:1582: debugHtml "github" "head_inst_curlimp$j" "${file_header}"
./mad.sh:1583: fi
./mad.sh:1584: if ! grep -Eqi 'HTTP/2 200|HTTP/1.1 200|200 OK' <<< $file_header ; then
./mad.sh:1585: if ((j == 8)) ; then
./mad.sh:1586: return 1
./mad.sh:1587: else
./mad.sh:1588: continue
./mad.sh:1589: fi
./mad.sh:1590: fi
--
./mad.sh:1630: tor_curl_request --insecure -L "$download_url" --continue-at - --output "$file_path"
./mad.sh:1631: received_file_size=0
./mad.sh:1632: if [[ -f "$file_path" ]] ; then
./mad.sh:1633: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./mad.sh:1634: fi
./mad.sh:1635: if ((received_file_size == file_size_bytes)) ; then
./mad.sh:1636: break
./mad.sh:1637: elif ((received_file_size < file_size_bytes)) ; then
./mad.sh:1638: if ((j >= MaxDownloadRetries)) ; then
./mad.sh:1639: echo -e "${RED}| FAILED: Size mismatch after downloading${NC}"
./mad.sh:1640: exit 1
--
./mad.sh:1835: maud_torcurl=$(grep -n -vxE '[[:blank:]]*([#].*)?' $fil | grep -A 12 --color='always' -Ei 'tor_curl')
./mad.sh:1836: echo -e "Files:"
./mad.sh:1837: echo -e "${BLUE}${fil}${NC}"
./mad.sh:1838: echo -e ""
./mad.sh:1839: echo -e ""
./mad.sh:1840: echo -e "${PINK}MAD Audit of http lines:${NC} (${GREEN}grep \"http:\" or \"https:\"${NC})"
./mad.sh:1841: echo -e "_________________________________________________________________________"
./mad.sh:1842: echo -e "$maud_http"
./mad.sh:1843: echo -e ""
./mad.sh:1844: echo -e "${PINK}MAD Audit of curl:${NC} (${GREEN}grep \"curl\"${NC})"
./mad.sh:1845: echo -e "_________________________________________________________________________"
--
./mad.sh:1848: echo -e "${PINK}MAD Audit of tor_curl (+12 lines after):${NC} (${GREEN}grep \"tor_curl\"${NC})"
./mad.sh:1849: echo -e "_________________________________________________________________________"
./mad.sh:1850: echo -e "$maud_torcurl"
./mad.sh:1851: echo -e ""
./mad.sh:1852: echo -e ""
./mad.sh:1853: done
./mad.sh:1854: else
./mad.sh:1855: cd "$ScriptDir"
./mad.sh:1856: readarray -d $'' arrFiles < <(find . -name "*.sh" -printf '%p\n' | sort -Vk1)
./mad.sh:1857: cd "$WorkDir"
./mad.sh:1858: readarray -d $'' arrFiles2 < <(find . -name "*.sh" -printf '%p\n' | sort -Vk1)
--
./mad.sh:1863: maud_torcurl=$(grep -n -vxE '[[:blank:]]*([#].*)?' $fil | grep -A 12 --color='always' -Ei 'tor_curl')
./mad.sh:1864: echo -e "Files:"
./mad.sh:1865: echo -e "${BLUE}${fil}${NC}"
./mad.sh:1866: echo -e ""
./mad.sh:1867: echo -e ""
./mad.sh:1868: echo -e "${PINK}MAD Audit of http lines:${NC} (${GREEN}grep \"http:\" or \"https:\"${NC})"
./mad.sh:1869: echo -e "_________________________________________________________________________"
./mad.sh:1870: echo -e "$maud_http"
./mad.sh:1871: echo -e ""
./mad.sh:1872: echo -e "${PINK}MAD Audit of curl:${NC} (${GREEN}grep \"curl \"${NC})"
./mad.sh:1873: echo -e "_________________________________________________________________________"
--
./mad.sh:1876: echo -e "${PINK}MAD Audit of tor_curl (+12 lines after):${NC} (${GREEN}grep \"tor_curl\"${NC})"
./mad.sh:1877: echo -e "_________________________________________________________________________"
./mad.sh:1878: echo -e "$maud_torcurl"
./mad.sh:1879: echo -e ""
./mad.sh:1880: done
./mad.sh:1881: for fil in "${arrFiles2[@]}";
./mad.sh:1882: do
./mad.sh:1883: maud_http=$(grep -n -vxE '[[:blank:]]*([#].*)?' $fil | grep --color='always' -Ei '(http|https):')
./mad.sh:1884: maud_curl=$(grep -n -vxE '[[:blank:]]*([#].*)?' $fil | grep --color='always' -Ei 'curl')
./mad.sh:1885: maud_torcurl=$(grep -n -vxE '[[:blank:]]*([#].*)?' $fil | grep -A 12 --color='always' -Ei 'tor_curl')
./mad.sh:1886: echo -e "Files:"
./mad.sh:1887: echo -e "${BLUE}${fil}${NC}"
./mad.sh:1888: echo -e ""
./mad.sh:1889: echo -e ""
./mad.sh:1890: echo -e "${PINK}MAD Audit of http lines:${NC} (${GREEN}grep \"http:\" or \"https:\"${NC})"
./mad.sh:1891: echo -e "_________________________________________________________________________"
./mad.sh:1892: echo -e "$maud_http"
./mad.sh:1893: echo -e ""
./mad.sh:1894: echo -e "${PINK}MAD Audit of curl:${NC} (${GREEN}grep \"curl\"${NC})"
./mad.sh:1895: echo -e "_________________________________________________________________________"
--
./mad.sh:1898: echo -e "${PINK}MAD Audit of tor_curl (+12 lines after):${NC} (${GREEN}grep \"tor_curl\"${NC})"
./mad.sh:1899: echo -e "_________________________________________________________________________"
./mad.sh:1900: echo -e "$maud_torcurl"
./mad.sh:1901: echo -e ""
./mad.sh:1902: done
./mad.sh:1903: fi
./mad.sh:1904:}
./mad.sh:1905:madStatus() {
./mad.sh:1906: local InputFile="$1"
./mad.sh:1907: if [[ "$arg1" == "status" ]] ; then
./mad.sh:1908: clear
--
./mad.sh:3231: file_header=$(tor_curl_request --insecure -m 8 -s -D - -o /dev/null \
./mad.sh:3232: -H "Connection: keep-alive" \
./mad.sh:3233: -w 'EffectiveUrl=%{url_effective}' \
./mad.sh:3234: "$download_url")
./mad.sh:3235: else
./mad.sh:3236: printf "| Retrieving Head: attempt #$j"
./mad.sh:3237: rm -f "${WorkDir}/.temp/directhead"
./mad.sh:3238: file_header=$(tor_curl_request --insecure --head -H "Connection: keep-alive" -L -s -i "$download_url" |
./mad.sh:3239: tee "${WorkDir}/.temp/directhead" &
./mad.sh:3240: sleep 6
./mad.sh:3241: [ -s "${WorkDir}/.temp/directhead" ]
./mad.sh:3242: kill $! 2>/dev/null
./mad.sh:3243: )
./mad.sh:3244: if [[ ! -f "${WorkDir}/.flocks/${remote_url//[^a-zA-Z0-9]/}" ]]; then
./mad.sh:3245: touch "${WorkDir}/.flocks/${remote_url//[^a-zA-Z0-9]/}"
./mad.sh:3246: fi
./mad.sh:3247: rm -f "${WorkDir}/.temp/directhead"
./mad.sh:3248: fi
--
./mad.sh:3375: tor_curl_request --insecure -L --referer "$file_url" "$download_url" --output "$file_path"
./mad.sh:3376: rc=$?
./mad.sh:3377: if ((rc != 0 )) ; then
./mad.sh:3378: printf "${RED}Download Failed (bad exit status).${NC}"
./mad.sh:3379: if [[ -f ${file_path} ]]; then
./mad.sh:3380: printf "${YELLOW} Partial removed...${NC}"
./mad.sh:3381: printf "\n\n"
./mad.sh:3382: rm -f "${file_path}"
./mad.sh:3383: else
./mad.sh:3384: printf "\n\n"
./mad.sh:3385: fi
--
./mad.sh:3432: tor_curl_request --insecure -L --speed-limit $DownloadSpeedMin --speed-time $DownloadTimeoutInterval "$download_url" --continue-at - --output "$file_path"
./mad.sh:3433: else
./mad.sh:3434: tor_curl_request --insecure -L --referer "$file_url" "$download_url" --continue-at - --output "$file_path"
./mad.sh:3435: fi
./mad.sh:3436: received_file_size=0
./mad.sh:3437: if [[ -f "$file_path" ]] ; then
./mad.sh:3438: received_file_size=$(stat --format="%s" "$file_path" | tr -d '[:space:]')
./mad.sh:3439: fi
./mad.sh:3440: if CheckNoHtml "$remote_url" "$filename" "$file_path" "$((received_file_size - pd_presize))" ; then
./mad.sh:3441: containsHtml=false
./mad.sh:3442: else
./mad.sh:3443: containsHtml=true
./mad.sh:3444: fi
--
./mad.sh:3632: response=$(tor_curl_upload --insecure -i \
./mad.sh:3633: -H "Content-Type: multipart/form-data" \
./mad.sh:3634: -F "key=" \
./mad.sh:3635: -F "time=$jira_timeval" \
./mad.sh:3636: -F "file=@${filepath}" \
./mad.sh:3637: "${jira_PostUrlHost}")
./mad.sh:3638: else
./mad.sh:3639: response=$(tor_curl_upload --insecure -i \
./mad.sh:3640: -H "Content-Type: multipart/form-data" \
./mad.sh:3641: -F "key=" \
./mad.sh:3642: -F "time=$jira_timeval" \
./mad.sh:3643: -F "files[]=@${arrFiles[@]}" \
./mad.sh:3644: "${jira_PostUrlHost}")
./mad.sh:3645: fi
./mad.sh:3646: if [[ "${DebugAllEnabled}" == "true" ]] ; then
./mad.sh:3647: debugHtml "${filepath##*/}" "${_hostCode}_upload" "post_url: ${jira_PostUrlHost}"$'\n'"${response}"
./mad.sh:3648: fi
./mad.sh:3649: if grep -Eqi ' 200 ' <<< "${response}" ; then
Reference in a new issue View git blame Copy permalink