Bagaimana saya bisa menjalankan fungsi bash dengan sudo?

Saya memiliki fungsi bash yang didefinisikan dalam bashrc global, yang membutuhkan hak akses root untuk bekerja. Bagaimana saya bisa menjalankannya dengan sudo, mis sudo myfunction. Secara default itu memberikan kesalahan:

sudo: myfunction: perintah tidak ditemukan

Luca dengan ramah menunjuk saya ke pertanyaan ini, inilah pendekatan saya: Perluas fungsi / alias sebelum panggilan ke sudo dan berikan secara keseluruhan ke sudo, tidak perlu file temp.

Dijelaskan di sini di blog saya . Ada banyak penanganan kutipan :-)

# Wrap sudo to handle aliases and functions
# Wout.Mertens@gmail.com
#
# Accepts -x as well as regular sudo options: this expands variables as you not root
#
# Comments and improvements welcome
#
# Installing: source this from your .bashrc and set alias sudo=sudowrap
#  You can also wrap it in a script that changes your terminal color, like so:
#  function setclr() {
#   local t=0               
#   SetTerminalStyle $1                
#   shift
#   "$@"
#   t=$?
#   SetTerminalStyle default
#   return $t
#  }
#  alias sudo="setclr sudo sudowrap"
#  If SetTerminalStyle is a program that interfaces with your terminal to set its
#  color.

# Note: This script only handles one layer of aliases/functions.

# If you prefer to call this function sudo, uncomment the following
# line which will make sure it can be called that
#typeset -f sudo >/dev/null && unset sudo

sudowrap () 
{
    local c="" t="" parse=""
    local -a opt
    #parse sudo args
    OPTIND=1
    i=0
    while getopts xVhlLvkKsHPSb:p:c:a:u: t; do
        if [ "$t" = x ]; then
            parse=true
        else
            opt[$i]="-$t"
            let i++
            if [ "$OPTARG" ]; then
                opt[$i]="$OPTARG"
                let i++
            fi
        fi
    done
    shift $(( $OPTIND - 1 ))
    if [ $# -ge 1 ]; then
        c="$1";
        shift;
        case $(type -t "$c") in 
        "")
            echo No such command "$c"
            return 127
            ;;
        alias)
            c="$(type "$c")"
            # Strip "... is aliased to `...'"
            c="${c#*\`}"
            c="${c%\'}"
            ;;
        function)
            c="$(type "$c")"
            # Strip first line
            c="${c#* is a function}"
            c="$c;\"$c\""
            ;;
        *)
            c="\"$c\""
            ;;
        esac
        if [ -n "$parse" ]; then
            # Quote the rest once, so it gets processed by bash.
            # Done this way so variables can get expanded.
            while [ -n "$1" ]; do
                c="$c \"$1\""
                shift
            done
        else
            # Otherwise, quote the arguments. The echo gets an extra
            # space to prevent echo from parsing arguments like -n
            while [ -n "$1" ]; do
                t="${1//\'/\'\\\'\'}"
                c="$c '$t'"
                shift
            done
        fi
        echo sudo "${opt[@]}" -- bash -xvc \""$c"\" >&2
        command sudo "${opt[@]}" bash -xvc "$c"
    else
        echo sudo "${opt[@]}" >&2
        command sudo "${opt[@]}"
    fi
}
# Allow sudowrap to be used in subshells
export -f sudowrap

Satu kelemahan dari pendekatan ini adalah hanya memperluas fungsi yang Anda panggil, bukan fungsi tambahan yang Anda rujuk dari sana. Pendekatan Kyle mungkin menangani itu lebih baik jika Anda mereferensikan fungsi-fungsi yang dimuat di bashrc Anda (asalkan dijalankan pada bash -cpanggilan).

Anda dapat exportfungsi Anda untuk membuatnya tersedia untuk bash -csubkulit atau skrip tempat Anda ingin menggunakannya.

your_function () { echo 'Hello, World'; }
export -f your_function
bash -c 'your_function'

Edit

Ini berfungsi untuk subshell langsung, tetapi tampaknya sudotidak meneruskan fungsi (hanya variabel). Bahkan menggunakan berbagai kombinasi setenv, env_keepdan meniadakan env_resetsepertinya tidak membantu.

Edit 2

Namun , tampak bahwa su tidak mendukung fungsi diekspor.

your_function () { echo 'Hello, World'; }
export -f your_function
su -c 'your_function'

Mungkin Anda bisa:

function meh() {
    sudo -v
    sudo cat /etc/shadow
}

Ini akan berhasil dan menyelamatkan Anda dari mengetikkan sudo pada commandline.

Jika Anda perlu memanggil fungsi dalam konteks sudo, Anda ingin menggunakan declare:

#!/bin/bash

function hello() {
  echo "Hello, $USER"
}

sudo su another_user -c "$(declare -f hello); hello"

Saya akan mengeksekusi shell baru dengan memiliki sudo mengeksekusi shell itu sendiri, maka fungsinya akan berjalan dengan hak akses root. Misalnya sesuatu seperti:

vim myFunction
#The following three lines go in myFunction file
function mywho {
    sudo whoami
}

sudo bash -c '. /home/kbrandt/myFunction; mywho'
root

Anda bahkan kemudian dapat membuat alias untuk sudo bashsaluran juga.

#!/bin/bash

function smth() {
    echo "{{"
    whoami
    echo "}}"
}

if [ $(whoami) != "root" ]; then
    whoami
    echo "i'm not root"
    sudo $0
else
    smth
fi

Seperti yang ditunjukkan oleh Legolas dalam komentar jawaban Dennis Williamson Anda harus membaca jawaban bmargulies pada pertanyaan serupa yang diposting di stackoverflow.

Mulai dari itu saya menulis fungsi untuk membahas masalah ini, yang pada dasarnya mewujudkan gagasan bmargulies.

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
# EXESUDO
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
#
# Purpose:
# -------------------------------------------------------------------- #
# Execute a function with sudo
#
# Params:
# -------------------------------------------------------------------- #
# $1:   string: name of the function to be executed with sudo
#
# Usage:
# -------------------------------------------------------------------- #
# exesudo "funcname" followed by any param
#
# -------------------------------------------------------------------- #
# Created 01 September 2012              Last Modified 02 September 2012

function exesudo ()
{
    ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ##
    #
    # LOCAL VARIABLES:
    #
    ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ##

    #
    # I use underscores to remember it's been passed
    local _funcname_="$1"

    local params=( "$@" )               ## array containing all params passed here
    local tmpfile="/dev/shm/$RANDOM"    ## temporary file
    local filecontent                   ## content of the temporary file
    local regex                         ## regular expression
    local func                          ## function source


    ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ##
    #
    # MAIN CODE:
    #
    ### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ##

    #
    # WORKING ON PARAMS:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    #
    # Shift the first param (which is the name of the function)
    unset params[0]              ## remove first element
    # params=( "${params[@]}" )     ## repack array


    #
    # WORKING ON THE TEMPORARY FILE:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    content="#!/bin/bash\n\n"

    #
    # Write the params array
    content="${content}params=(\n"

    regex="\s+"
    for param in "${params[@]}"
    do
        if [[ "$param" =~ $regex ]]
            then
                content="${content}\t\"${param}\"\n"
            else
                content="${content}\t${param}\n"
        fi
    done

    content="$content)\n"
    echo -e "$content" > "$tmpfile"

    #
    # Append the function source
    echo "#$( type "$_funcname_" )" >> "$tmpfile"

    #
    # Append the call to the function
    echo -e "\n$_funcname_ \"\${params[@]}\"\n" >> "$tmpfile"


    #
    # DONE: EXECUTE THE TEMPORARY FILE WITH SUDO
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    sudo bash "$tmpfile"
    rm "$tmpfile"
}

Contoh penggunaan:
menjalankan cuplikan berikut

#!/bin/bash

function exesudo ()
{
    # copy here the previous exesudo function !!!
}

test_it_out ()
{
    local params=( "$@" )
    echo "Hello "$( whoami )"!"
    echo "You passed the following params:"
    printf "%s\n" "${params[@]}" ## print array
}

echo "1: calling without sudo"
test_it_out "first" "second"

echo ""
echo "2. calling with sudo"
exesudo test_it_out -n "john done" -s "done"

exit

Akan menghasilkan

1. menelepon tanpa sudo
   Halo namamu!
   Anda melewati params berikut: detik
   pertama
   
   

2. menelepon dengan sudo
   Halo root!
   Anda melewati params berikut:
   -n
   john done
   -s
   foo
   

Jika Anda perlu menggunakan ini dalam shell memanggil fungsi yang didefinisikan dalam bashrc Anda, seperti yang Anda minta, maka Anda harus meletakkan fungsi exesudo sebelumnya pada file bashrc yang sama juga, seperti berikut:

function yourfunc ()
{
echo "Hello "$( whoami )"!"
}
export -f yourfunc

function exesudo ()
{
   # copy here
}
export -f exesudo

Maka Anda harus keluar dan masuk lagi atau menggunakan

source ~/.bashrc

Akhirnya Anda dapat menggunakan exesudo sebagai berikut:

$ yourfunc
Hello yourname!

$ exesudo yourfunc
Hello root!