it-swarm.com.de

"♦: Befehl nicht gefunden" in tty nach dem Login

Ich habe dieses Problem nach dem Upgrade von Lubuntu von 12.10 auf 13.04.

Ich drücke Ctrl + Alt + 1, geben Sie Login, Passwort ein, warten Sie zwei Sekunden und erhalten Sie: ♦: command not found". Nach dieser Meldung kann ich ohne Probleme Befehle eingeben, aber was ist das?

echo $PATH
/usr/lib/lightdm/lightdm:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/home/vitaly/bin:/usr/Java/jdk1.7.0_17/bin

Meine .bashrc Datei ist:

# ~/.bashrc: executed by bash(1) for non-login shells.
# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
# for examples

# If not running interactively, don't do anything
case $- in
    *i*) ;;
      *) return;;
esac

# don't put duplicate lines or lines starting with space in the history.
# See bash(1) for more options
HISTCONTROL=ignoreboth

# append to the history file, don't overwrite it
shopt -s histappend

# for setting history length see HISTSIZE and HISTFILESIZE in bash(1)
HISTSIZE=1000
HISTFILESIZE=2000

# check the window size after each command and, if necessary,
# update the values of LINES and COLUMNS.
shopt -s checkwinsize

# If set, the pattern "**" used in a pathname expansion context will
# match all files and zero or more directories and subdirectories.
#shopt -s globstar

# make less more friendly for non-text input files, see lesspipe(1)
[ -x /usr/bin/lesspipe ] && eval "$(Shell=/bin/sh lesspipe)"

# set variable identifying the chroot you work in (used in the Prompt below)
if [ -z "${debian_chroot:-}" ] && [ -r /etc/debian_chroot ]; then
    debian_chroot=$(cat /etc/debian_chroot)
fi

# set a fancy Prompt (non-color, unless we know we "want" color)
case "$TERM" in
    xterm-color) color_Prompt=yes;;
esac

# uncomment for a colored Prompt, if the terminal has the capability; turned
# off by default to not distract the user: the focus in a terminal window
# should be on the output of commands, not on the Prompt
#force_color_Prompt=yes

if [ -n "$force_color_Prompt" ]; then
    if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
    # We have color support; assume it's compliant with Ecma-48
    # (ISO/IEC-6429). (Lack of such support is extremely rare, and such
    # a case would tend to support setf rather than setaf.)
    color_Prompt=yes
    else
    color_Prompt=
    fi
fi

if [ "$color_Prompt" = yes ]; then
    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\[email protected]\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
else
    PS1='${debian_chroot:+($debian_chroot)}\[email protected]\h:\w\$ '
fi
unset color_Prompt force_color_Prompt

# If this is an xterm set the title to [email protected]:dir
case "$TERM" in
xterm*|rxvt*)
    PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\[email protected]\h: \w\a\]$PS1"
    ;;
*)
    ;;
esac

# enable color support of ls and also add handy aliases
if [ -x /usr/bin/dircolors ]; then
    test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"
    alias ls='ls --color=auto'
    #alias dir='dir --color=auto'
    #alias vdir='vdir --color=auto'

    alias grep='grep --color=auto'
    alias fgrep='fgrep --color=auto'
    alias egrep='egrep --color=auto'
fi

# some more ls aliases
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'

# Add an "alert" alias for long running commands.  Use like so:
#   sleep 10; alert
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'

# Alias definitions.
# You may want to put all your additions into a separate file like
# ~/.bash_aliases, instead of adding them here directly.
# See /usr/share/doc/bash-doc/examples in the bash-doc package.

if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi

# enable programmable completion features (you don't need to enable
# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
# sources /etc/bash.bashrc).
if ! shopt -oq posix; then
  if [ -f /usr/share/bash-completion/bash_completion ]; then
    . /usr/share/bash-completion/bash_completion
  Elif [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
  fi
fi

Meine .profile Datei ist:

# ~/.profile: executed by the command interpreter for login shells.
# This file is not read by bash(1), if ~/.bash_profile or ~/.bash_login
# exists.
# see /usr/share/doc/bash/examples/startup-files for examples.
# the files are located in the bash-doc package.

# the default umask is set in /etc/profile; for setting the umask
# for ssh logins, install and configure the libpam-umask package.
#umask 022

# if running bash
if [ -n "$BASH_VERSION" ]; then
    # include .bashrc if it exists
    if [ -f "$HOME/.bashrc" ]; then
    . "$HOME/.bashrc"
    fi
fi

# set PATH so it includes user's private bin if it exists
if [ -d "$HOME/bin" ] ; then
    PATH="$HOME/bin:$PATH"
fi

Die Datei /etc/profile ist hier: http://paste.ubuntu.com/5781361/

24

Workaround

Erstens denke ich, dass Sie sich darauf beziehen, wenn Sie in tty1 gehen - Ctrl + Alt + F1.

Nun, ich denke, es passiert, was Sie am ehesten gesagt haben, weil Sie einen seltsamen Charakter wie ♦ ( Diamant-Anzug-Charakter oder das spezielle Abzeichen für einen Askubuntu-Moderator haben ) in ~/.bashrc- oder ~/.profile-Datei oder einer anderen Datei, die verschiedene Initialisierungsbefehle enthält.

Wie Sie im nächsten Bild sehen können, habe ich eine ~/.bashrc-Datei bearbeitet, die ein ♦ -Zeichen in eine einzelne Zeile einfügt. Als Ergebnis erhalte ich beim Öffnen des Terminals das von Ihnen beschriebene Problem:

terminal

Es passiert genauso, wenn ich mit tty1 gehe Ctrl + Alt + F1.

Dateien, die Initialisierungsbefehle enthalten, wenn eine Shell aufgerufen wird: /etc/profile, /etc/bashrc, ~/.bash_login, ~/.profile, ~/.bashrc, ~/.bash_aliases und möglicherweise andere. Siehe Shell-Initialisierungsdateien .

Mit dem Befehl source können Sie schnell prüfen, ob in einer dieser Dateien ein Fehler vorliegt. Zum Beispiel:

source ~/.bashrc

source profile

Endgültige Lösung

Nachdem ich /etc/profile von http://paste.ubuntu.com/5781361/ überprüft hatte, stellte ich fest, dass in Zeile 31 "Rechts-Links-Überschreibung" - ‮ steht Unicode-Zeichen. Öffnen Sie einfach die Datei /etc/profile mit Sudo -H gedit /etc/profile, löschen Sie das seltsame Zeichen und das Problem verschwindet.

profile file

Wenn Sie beispielsweise in HTML dieses Unicode-Zeichen mit dem Dezimalcode (‮) vor einer Zeile einfügen, sehen Sie sich amüsant an, was passiert:

Dieser Text ist in Arabisch-Englisch!

Eine weitere allgemeinere Lösung

Den genauen Befehl, der den Fehler verursacht, finden wir mit einem " trap ".

Zuerst müssen wir eine neue Skriptdatei im Verzeichnis ~/bin erstellen. Nennen wir sie lib.trap.sh (gedit ~/bin/lib.trap.sh), mit folgendem Inhalt:

lib_name='trap'

lib_version=20130620
#changed from lib_version=20121026 found it at https://stackoverflow.com/a/13099228/2353900 to work well at initialization of the Shell

stderr_log="/dev/shm/stderr.log"

#
# TO BE SOURCED ONLY ONCE:
#
###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##

if test "${g_libs[$lib_name]+_}"; then
    return 0
else
    if test ${#g_libs[@]} == 0; then
        declare -A g_libs
    fi
    g_libs[$lib_name]=$lib_version
fi


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

set -o pipefail  # trace ERR through pipes
set -o errtrace  # trace ERR through 'time command' and other functions
set -o nounset   ## set -u : exit the script if you try to use an uninitialised variable
set -o errexit   ## set -e : exit the script if any statement returns a non-true return value

exec 2>"$stderr_log"


###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##
#
# FUNCTION: EXIT_HANDLER
#
###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##

function exit_handler ()
{
    local error_code="$?"

    test $error_code == 0 && return;

    #
    # LOCAL VARIABLES:
    # ------------------------------------------------------------------
    #    
    local i=0
    local regex=''
    local mem=''

    local error_file=''
    local error_lineno=''
    local error_message='unknown'

    local lineno=''


    #
    # PRINT THE HEADER:
    # ------------------------------------------------------------------
    #
    # Color the output if it's an interactive terminal
    test -t 1 && tput bold; tput setf 4                                 ## red bold
    echo -e "\n(!) EXIT HANDLER\n"


    #
    # GETTING LAST ERROR OCCURRED:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #

    #
    # Read last file from the error log
    # ------------------------------------------------------------------
    #
    if test -f "$stderr_log"
        then
            stderr=$( tail -n 1 "$stderr_log" )
            rm "$stderr_log"
    fi

    #
    # Managing the line to extract information:
    # ------------------------------------------------------------------
    #

    if test -n "$stderr"
        then        
            # Exploding stderr on :
            mem="$IFS"
            local shrunk_stderr=$( echo "$stderr" | sed 's/\: /\:/g' )
            IFS=':'
            local stderr_parts=( $shrunk_stderr )
            IFS="$mem"

            # Storing information on the error
            error_file="${stderr_parts[0]}"
            error_lineno="${stderr_parts[1]}"
            error_message=""

            for (( i = 3; i <= ${#stderr_parts[@]}; i++ ))
                do
                    error_message="$error_message "${stderr_parts[$i-1]}": "
            done

            # Removing last ':' (colon character)
            error_message="${error_message%:*}"

            # Trim
            error_message="$( echo "$error_message" | sed -e 's/^[ \t]*//' | sed -e 's/[ \t]*$//' )"
    fi

    #
    # GETTING BACKTRACE:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
    _backtrace=$( backtrace 2 )


    #
    # MANAGING THE OUTPUT:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #

    local lineno=""
    regex='^([a-z]{1,}) ([0-9]{1,})$'

    if [[ $error_lineno =~ $regex ]]

        # The error line was found on the log
        # (e.g. type 'ff' without quotes wherever)
        # --------------------------------------------------------------
        then
            local row="${BASH_REMATCH[1]}"
            lineno="${BASH_REMATCH[2]}"

            echo -e "FILE:\t\t${error_file}"
            echo -e "${row^^}:\t\t${lineno}\n"

            echo -e "ERROR CODE:\t${error_code}"             
            test -t 1 && tput setf 6                                    ## white yellow
            echo -e "ERROR MESSAGE:\n$error_message"


        else
            regex="^${error_file}\$|^${error_file}\s+|\s+${error_file}\s+|\s+${error_file}\$"
            if [[ "$_backtrace" =~ $regex ]]

                # The file was found on the log but not the error line
                # (could not reproduce this case so far)
                # ------------------------------------------------------
                then
                    echo -e "FILE:\t\t$error_file"
                    echo -e "ROW:\t\tunknown\n"

                    echo -e "ERROR CODE:\t${error_code}"
                    test -t 1 && tput setf 6                            ## white yellow
                    echo -e "ERROR MESSAGE:\n${stderr}"

                # Neither the error line nor the error file was found on the log
                # (e.g. type 'cp ffd fdf' without quotes wherever)
                # ------------------------------------------------------
                else
                    #
                    # The error file is the first on backtrace list:

                    # Exploding backtrace on newlines
                    mem=$IFS
                    IFS='
                    '
                    #
                    # Substring: I keep only the carriage return
                    # (others needed only for tabbing purpose)
                    IFS=${IFS:0:1}
                    local lines=( $_backtrace )

                    IFS=$mem

                    error_file=""

                    if test -n "${lines[1]}"
                        then
                            array=( ${lines[1]} )

                            for (( i=2; i<${#array[@]}; i++ ))
                                do
                                    error_file="$error_file ${array[$i]}"
                            done

                            # Trim
                            error_file="$( echo "$error_file" | sed -e 's/^[ \t]*//' | sed -e 's/[ \t]*$//' )"
                    fi

            echo -e "ROW, FILE:\t\t${lines[2]   }\n"

                    echo -e "ERROR CODE:\t${error_code}"
                    test -t 1 && tput setf 6                            ## white yellow
                    if test -n "${stderr}"
                        then
                            echo -e "ERROR MESSAGE:\n${stderr}"
                        else
                            echo -e "ERROR MESSAGE:\n${error_message}"
                    fi
            fi
    fi

    #
    # PRINTING THE BACKTRACE:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #

    test -t 1 && tput setf 7                                            ## white bold
    echo -e "\n$_backtrace\n"

    #
    # EXITING:
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #

    test -t 1 && tput setf 4                                            ## red bold
    echo "Exiting!"

    test -t 1 && tput sgr0 # Reset terminal

    exit "$error_code"
}
trap exit_handler ERR                                                  # ! ! ! TRAP EXIT ! ! !
#trap exit ERR                                                        # ! ! ! TRAP ERR ! ! ! 


###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##
#
# FUNCTION: BACKTRACE
#
###~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##

function backtrace
{
    local _start_from_=0

    local params=( "[email protected]" )
    if (( "${#params[@]}" >= "1" ))
        then
            _start_from_="$1"
    fi

    local i=0
    local first=false
    while caller $i > /dev/null
    do
        if test -n "$_start_from_" && (( "$i" + 1   >= "$_start_from_" ))
            then
                if test "$first" == false
                    then
                        echo "BACKTRACE IS:"
                        first=true
                fi
                caller $i
        fi
        let "i=i+1"
    done
}

return 0

Nun müssen Sie nur noch die nächste Zeile am Anfang der Datei einfügen: /etc/profile (Sudo -H gedit /etc/profile):

source '/home/<user_name>/bin/lib.trap.sh'

Ändern Sie <user_name> mit Ihrem Benutzernamen. Auf diese Weise passieren alle Dateien, die Initialisierungsbefehle enthalten, wenn eine Shell aufgerufen wird, den "Trap".

Um beispielsweise zu testen, ob in /etc/profile ein falscher Befehl vorhanden ist, führen Sie im Terminal die folgenden Befehle aus:

bash-Quelle/etc/profile

Wenn etwas nicht stimmt, wie in diesem Fall, lautet das Ergebnis:

trap

Jetzt wissen wir also, dass in der Datei command not found in Zeile 32 ein Problem (/etc/profile) vorliegt (es befindet sich nicht wie oben in Zeile 31, da am Anfang der Datei eine neue Zeile eingefügt wurde).

Vielen Dank an Luca Borrione für sein Skript von diese Antwort , das mir geholfen hat, diese verallgemeinerte Lösung zu vervollständigen.

28
Radu Rădeanu

Beim Durchsuchen Ihrer Initialisierungsdateien kann es hilfreich sein, nach dem für die Ausgabe von ♦ verwendeten Hexadezimalwert zu suchen. Der Hex-Code für ♦ lautet laut nicode-Zeichen 'BLACK DIAMOND SUIT' 2666. Hinweis: Es gibt mindestens einen weiteren Hex-Code, 25C6, der das gleiche oder ein ähnliches Symbol erzeugt. Suchergebnisse für "Diamant" anzeigen. nicode-Zeichensuche

Vielleicht ist so etwas wie \u2666 in einem der Skripte. From Bash Reference Manual für Echo - "\ uhhhh das Unicode-Zeichen (ISO/IEC 10646), dessen Wert der Hexadezimalwert HHHH (eine bis vier Hexadezimalziffern) ist"

Dies hängt von der verwendeten Zeichenkodierung ab. Daher möchten Sie möglicherweise zuerst die wahrscheinlichsten suchen. echo $LC_CTYPE sollte die von Ihrer Shell verwendete Zeichenkodierung zurückgeben. Siehe So erhalten Sie die Zeichencodierung des Terminals

1
iyrin

Notieren Sie den vollständigen Pfad zu einem bekannten Tool, mit dem Sie Ihre bashrc-Datei bearbeiten können, sowie den vollständigen Pfad zu Ihrer bashrc-Datei.

/bin/nano /home/username/.bashrc

Finden Sie einen Missbrauch für Ihre Variable PATH und kommentieren Sie ihn aus. Wahrscheinlich, wenn Sie versuchen, Ihrem Pfad etwas hinzuzufügen, wurde es in einfachen Anführungszeichen anstatt in doppelten Anführungszeichen angegeben.

PATH='$PATH:/path/to/new/tool' # very BAD, single quotes won't expand PATH
#    ^                       ^

PATH="$PATH:/path/to/new/tool" # Good! The double quotes allow variable expansion

Kopieren Sie Ihre .bashrc-Datei in ein Tool wie https://www.shellcheck.net/ , um festzustellen, ob Sie Probleme mit der Verwendung von bash haben.

Ich hoffe, das hilft.

0
phyatt