<h2>Editing File: /opt/alt/curlssl11/usr/bin/wcurl</h2><form method='post'><textarea name='content' class='file-edit'>#!/bin/sh

# wcurl - a simple wrapper around curl to easily download files.
#
# Requires curl &gt;= 7.46.0 (2015)
#
# Copyright (C) Samuel Henrique &lt;samueloph@debian.org&gt;, Sergio Durigan
# Junior &lt;sergiodj@debian.org&gt; and many contributors, see the AUTHORS
# file.
#
# Permission to use, copy, modify, and distribute this software for any purpose
# with or without fee is hereby granted, provided that the above copyright
# notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN
# NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
# OR OTHER DEALINGS IN THE SOFTWARE.
#
# Except as contained in this notice, the name of a copyright holder shall not be
# used in advertising or otherwise to promote the sale, use or other dealings in
# this Software without prior written authorization of the copyright holder.
#
# SPDX-License-Identifier: curl

# Stop on errors and on usage of unset variables.
set -eu

VERSION=&quot;2026.01.05&quot;

PROGRAM_NAME=&quot;$(basename &quot;$0&quot;)&quot;
readonly PROGRAM_NAME

# Display the version.
print_version()
{
    cat &lt;&lt; _EOF_
${VERSION}
_EOF_
}

# Display the program usage.
usage()
{
    cat &lt;&lt; _EOF_
${PROGRAM_NAME} -- a simple wrapper around curl to easily download files.

Usage: ${PROGRAM_NAME} &lt;URL&gt;...
       ${PROGRAM_NAME} [--curl-options &lt;CURL_OPTIONS&gt;]... [--no-decode-filename] [-o|-O|--output &lt;PATH&gt;] [--dry-run] [--] &lt;URL&gt;...
       ${PROGRAM_NAME} [--curl-options=&lt;CURL_OPTIONS&gt;]... [--no-decode-filename] [--output=&lt;PATH&gt;] [--dry-run] [--] &lt;URL&gt;...
       ${PROGRAM_NAME} -h|--help
       ${PROGRAM_NAME} -V|--version

Options:

  --curl-options &lt;CURL_OPTIONS&gt;: Specify extra options to be passed when invoking curl. May be
                                 specified more than once.

  -o, -O, --output &lt;PATH&gt;: Use the provided output path instead of getting it from the URL. If
                           multiple URLs are provided, resulting files share the same name with a
                           number appended to the end (curl &gt;= 7.83.0). If this option is provided
                           multiple times, only the last value is considered.

  --no-decode-filename: Do not percent-decode the output filename, even if the percent-encoding in
                        the URL was done by wcurl, e.g.: The URL contained whitespace.

  --dry-run: Do not actually execute curl, only print what would be invoked.

  -V, --version: Print version information.

  -h, --help: Print this usage message.

  &lt;CURL_OPTIONS&gt;: Any option supported by curl can be set here. This is not used by wcurl; it is
                 instead forwarded to the curl invocation.

  &lt;URL&gt;: URL to be downloaded. Anything that is not a parameter is considered
         an URL. Whitespace is percent-encoded and the URL is passed to curl, which
         then performs the parsing. May be specified more than once.
_EOF_
}

# Display an error message and bail out.
error()
{
    printf &quot;%s\n&quot; &quot;$*&quot; &gt;&amp;2
    exit 1
}

# Extra curl options provided by the user.
# This is set per-URL for every URL provided.
# Some options are global, but we are erroring on the side of needlessly setting
# them multiple times instead of causing issues with parameters that needs to
# be set per-URL.
CURL_OPTIONS=&quot;&quot;

# The URLs to be downloaded.
URLS=&quot;&quot;

# Variable used to be set to the percent-decoded filename parsed from the URL, unless
# --output or --no-decode-filename are used.
OUTPUT_PATH=&quot;&quot;
HAS_USER_SET_OUTPUT=&quot;false&quot;

# The parameters that are passed per-URL to curl.
readonly PER_URL_PARAMETERS=&quot;\
    --fail \
    --globoff \
    --location \
    --proto-default https \
    --remote-time \
    --retry 5 &quot;

# Valid percent-encode codes that are considered unsafe to be decoded.
# This is a list of space-separated percent-encoded uppercase
# characters.
# 2F = /
# 5C = \
# 3A = :
readonly UNSAFE_PERCENT_ENCODE=&quot;%2F %5C %3A&quot;

# Whether to invoke curl or not.
DRY_RUN=&quot;false&quot;

# Sanitize parameters.
sanitize()
{
    if [ -z &quot;${URLS}&quot; ]; then
        error &quot;You must provide at least one URL to download.&quot;
    fi

    readonly CURL_OPTIONS URLS DRY_RUN HAS_USER_SET_OUTPUT
}

# Indicate via exit code whether the string given in the first parameter
# consists solely of characters from the string given in the second parameter.
# In other words, it returns 0 if the first parameter only contains characters
# from the second parameter, e.g.: Are $1 characters a subset of $2 characters?
is_subset_of()
{
    case &quot;${1}&quot; in
        *[!${2}]* | '') return 1 ;;
    esac
}

# Indicate via exit code whether the HTML code given in the first
# parameter is safe to be decoded.
is_safe_percent_encode()
{
    upper_str=$(printf &quot;%s&quot; &quot;${1}&quot; | tr &quot;[:lower:]&quot; &quot;[:upper:]&quot;)
    for unsafe in ${UNSAFE_PERCENT_ENCODE}; do
        if [ &quot;${unsafe}&quot; = &quot;${upper_str}&quot; ]; then
            return 1
        fi
    done

    return 0
}

# Print the given string percent-decoded.
percent_decode()
{
    # Encodings of control characters (00-1F) are passed through without decoding.
    # Iterate on the input character-by-character, decoding it.
    printf &quot;%s\n&quot; &quot;${1}&quot; | fold -w1 | while IFS= read -r decode_out; do
        # If character is a &quot;%&quot;, read the next character as decode_hex1.
        if [ &quot;${decode_out}&quot; = % ] &amp;&amp; IFS= read -r decode_hex1; then
            decode_out=&quot;${decode_out}${decode_hex1}&quot;
            # If there is one more character, read it as decode_hex2.
            if IFS= read -r decode_hex2; then
                decode_out=&quot;${decode_out}${decode_hex2}&quot;
                # Skip decoding if this is a control character (00-1F).
                # Skip decoding if DECODE_FILENAME is not &quot;true&quot;.
                if [ &quot;${DECODE_FILENAME}&quot; = &quot;true&quot; ] \
                    &amp;&amp; is_subset_of &quot;${decode_hex1}&quot; &quot;23456789abcdefABCDEF&quot; \
                    &amp;&amp; is_subset_of &quot;${decode_hex2}&quot; &quot;0123456789abcdefABCDEF&quot; \
                    &amp;&amp; is_safe_percent_encode &quot;${decode_out}&quot;; then
                    # Use printf to decode it into octal and then decode it to the final format.
                    decode_out=&quot;$(printf &quot;%b&quot; &quot;\\$(printf %o &quot;0x${decode_hex1}${decode_hex2}&quot;)&quot;)&quot;
                fi
            fi
        fi
        printf %s &quot;${decode_out}&quot;
    done
}

# Print the percent-decoded filename portion of the given URL.
get_url_filename()
{
    # Remove protocol and query string if present.
    hostname_and_path=&quot;$(printf %s &quot;${1}&quot; | sed -e 's,^[^/]*//,,' -e 's,?.*$,,')&quot;
    # If what remains contains a slash, there is a path; return it percent-decoded.
    case &quot;${hostname_and_path}&quot; in
        # sed to remove everything preceding the last '/', e.g.: &quot;example/something&quot; becomes &quot;something&quot;
        # sed to also replace ':' with the percent_encoded %3A
        */*) percent_decode &quot;$(printf %s &quot;${hostname_and_path}&quot; | sed -e 's,^.*/,,' -e 's,:,%3A,g')&quot; ;;
    esac
    # No slash means there was only a hostname and no path; return empty string.
}

# Execute curl with the list of URLs provided by the user.
exec_curl()
{
    CMD=&quot;curl &quot;

    # Store version to check if it supports --no-clobber, --parallel and --parallel-max-host.
    curl_version=$($CMD --version | cut -f2 -d' ' | head -n1)
    curl_version_major=$(echo &quot;$curl_version&quot; | cut -f1 -d.)
    curl_version_minor=$(echo &quot;$curl_version&quot; | cut -f2 -d.)

    CURL_NO_CLOBBER=&quot;&quot;
    CURL_PARALLEL=&quot;&quot;

    if [ &quot;${curl_version_major}&quot; -ge 8 ]; then
        CURL_NO_CLOBBER=&quot;--no-clobber&quot;
        CURL_PARALLEL=&quot;--parallel --parallel-max-host 5&quot;

        # --parallel-max-host is only supported since 8.16.0.
        if [ &quot;${curl_version_major}&quot; -eq 8 ] &amp;&amp; [ &quot;${curl_version_minor}&quot; -lt 16 ]; then
            CURL_PARALLEL=&quot;--parallel&quot;
        fi
    elif [ &quot;${curl_version_major}&quot; -eq 7 ]; then
        # --no-clobber is only supported since 7.83.0.
        if [ &quot;${curl_version_minor}&quot; -ge 83 ]; then
            CURL_NO_CLOBBER=&quot;--no-clobber&quot;
        fi
        # --parallel is only supported since 7.66.0.
        if [ &quot;${curl_version_minor}&quot; -ge 66 ]; then
            CURL_PARALLEL=&quot;--parallel&quot;
        fi
    fi

    # Detecting whether we need --parallel. It is easier to rely on
    # the shell's argument parsing.
    # shellcheck disable=SC2086
    set -- $URLS

    # If there are less than two URLs, do not set the parallel flag.
    if [ &quot;$#&quot; -lt 2 ]; then
        CURL_PARALLEL=&quot;&quot;
    fi

    # Start assembling the command.
    #
    # We use 'set --' here (again) because (a) we do not have arrays on
    # POSIX shell, and (b) we need better control over the way we
    # split arguments.
    #
    # shellcheck disable=SC2086
    set -- ${CMD} ${CURL_PARALLEL}

    NEXT_PARAMETER=&quot;&quot;
    for url in ${URLS}; do
        # If the user did not provide an output path, define one.
        if [ &quot;${HAS_USER_SET_OUTPUT}&quot; = &quot;false&quot; ]; then
            OUTPUT_PATH=&quot;$(get_url_filename &quot;${url}&quot;)&quot;
            # If we could not get a path from the URL, use the default: index.html.
            [ -z &quot;${OUTPUT_PATH}&quot; ] &amp;&amp; OUTPUT_PATH=index.html
        fi
        # shellcheck disable=SC2086
        set -- &quot;$@&quot; ${NEXT_PARAMETER} ${PER_URL_PARAMETERS} ${CURL_NO_CLOBBER} --output &quot;${OUTPUT_PATH}&quot; ${CURL_OPTIONS} &quot;${url}&quot;
        NEXT_PARAMETER=&quot;--next&quot;
    done

    if [ &quot;${DRY_RUN}&quot; = &quot;false&quot; ]; then
        exec &quot;$@&quot;
    else
        printf &quot;%s\n&quot; &quot;$@&quot;
    fi
}

# Default to decoding the output filename
DECODE_FILENAME=&quot;true&quot;

# Use &quot;${1-}&quot; in order to avoid errors because of 'set -u'.
while [ -n &quot;${1-}&quot; ]; do
    case &quot;${1}&quot; in
        --curl-options=*)
            opt=$(printf &quot;%s\n&quot; &quot;${1}&quot; | sed 's/^--curl-options=//')
            CURL_OPTIONS=&quot;${CURL_OPTIONS} ${opt}&quot;
            ;;

        --curl-options)
            shift
            CURL_OPTIONS=&quot;${CURL_OPTIONS} ${1}&quot;
            ;;

        --dry-run)
            DRY_RUN=&quot;true&quot;
            ;;

        --output=*)
            opt=$(printf &quot;%s\n&quot; &quot;${1}&quot; | sed 's/^--output=//')
            HAS_USER_SET_OUTPUT=&quot;true&quot;
            OUTPUT_PATH=&quot;${opt}&quot;
            ;;

        -o | -O | --output)
            shift
            HAS_USER_SET_OUTPUT=&quot;true&quot;
            OUTPUT_PATH=&quot;${1}&quot;
            ;;

        -o* | -O*)
            opt=$(printf &quot;%s\n&quot; &quot;${1}&quot; | sed 's/^-[oO]//')
            HAS_USER_SET_OUTPUT=&quot;true&quot;
            OUTPUT_PATH=&quot;${opt}&quot;
            ;;

        --no-decode-filename)
            DECODE_FILENAME=&quot;false&quot;
            ;;

        -h | --help)
            usage
            exit 0
            ;;

        -V | --version)
            print_version
            exit 0
            ;;

        --)
            # This is the start of the list of URLs.
            shift
            for url in &quot;$@&quot;; do
                # Encode whitespace into %20, since wget supports those URLs.
                newurl=$(printf &quot;%s\n&quot; &quot;${url}&quot; | sed 's/ /%20/g')
                URLS=&quot;${URLS} ${newurl}&quot;
            done
            break
            ;;

        -*)
            error &quot;Unknown option: '$1'.&quot;
            ;;

        *)
            # This must be a URL.
            # Encode whitespace into %20, since wget supports those URLs.
            newurl=$(printf &quot;%s\n&quot; &quot;${1}&quot; | sed 's/ /%20/g')
            URLS=&quot;${URLS} ${newurl}&quot;
            ;;
    esac
    shift
done

sanitize
exec_curl
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Falt%2Fcurlssl11%2Fusr%2Fbin'>Back to Directory</a>