“♦: comando não encontrado” em tty após o login


24

Eu tenho esse problema após atualizar o Lubuntu de 12.10 para 13.04.

Eu pressionar Ctrl+ Alt+ 1, digite login, senha, esperar dois segundos e obter: ♦: command not found". Após esta mensagem, posso digitar comandos sem problemas, mas o que é?

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

Meu .bashrcarquivo é:

# ~/.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\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
else
    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
fi
unset color_prompt force_color_prompt

# If this is an xterm set the title to user@host:dir
case "$TERM" in
xterm*|rxvt*)
    PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\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

Meu .profilearquivo é:

# ~/.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

O arquivo /etc/profileestá aqui: http://paste.ubuntu.com/5781361/


1
Qual é a saída de echo $PATH? ( Edite -o em sua pergunta e responda).
Seth

1
Você pode enviar seus arquivos ~ / .bashrc e ~ / .profile para paste.ubuntu.com e publicar os links?
Eric Carvalho

Para referência futura, a forma é chamada de "diamante".
user98085

Adicionado echo $PATHà minha pergunta.
Vitaly Zdanevich 18/06/2013

Se você usar aspas simples em torno da variável de caminho no seu '.bashrc', isso poderá causar esse problema.
Phyatt #

Respostas:


28

Solução alternativa

Primeiro, acho que você se refere a quando você entra em tty1 - Ctrl+ Alt+F1 .

Agora, acho que está acontecendo o que você disse mais provavelmente porque você tem um caractere estranho como ♦ ( caractere de diamante ou distintivo especial para um moderador askubuntu ) ~/.bashrcou ~/.profilearquivo ou outro arquivo que contém vários comandos de inicialização.

Como você pode ver na próxima imagem, editei o ~/.bashrcarquivo colocando o caractere ♦ em uma única linha. Como resultado, quando abro o terminal, obtém o problema descrito por você:

terminal

Está acontecendo o mesmo quando eu entro em tty1 com Ctrl+Alt + F1.

Arquivos que contêm inicialização comandos quando um shell é invocado: /etc/profile, /etc/bashrc, ~/.bash_login, ~/.profile, ~/.bashrc, ~/.bash_aliasese talvez outros. Consulte Arquivos de inicialização do Shell .

Para verificar rapidamente se um desses arquivos tem algo errado, você pode usar o sourcecomando Por exemplo:

source ~/.bashrc

perfil de origem

Solução final

Após inspecionar /etc/profileem http://paste.ubuntu.com/5781361/ , descobri que na linha 31 há "Substituição da direita para a esquerda" -‮ caractere unicode. Basta abrir o /etc/profilearquivo com sudo -H gedit /etc/profile, certifique-se de excluir esse caractere estranho e o problema desaparecerá.

arquivo de perfil

Como diversão, em HTML, por exemplo, se você inserir esse caractere unicode usando o código decimal (‮ ) na frente de uma linha, veja o que está acontecendo:

Este texto está em inglês árabe!

Outra solução mais generalizada

Vamos encontrar o comando exato que está causando o erro usando uma " armadilha " ".

Primeiro, temos que criar um novo arquivo de script no ~/bindiretório, vamos chamá-lo lib.trap.sh( gedit ~/bin/lib.trap.sh), com o seguinte dentro:

lib_name='trap'

lib_version=20130620
#changed from lib_version=20121026 found it at /programming//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=( "$@" )
    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

Agora, a única coisa que você precisa fazer é colocar a próxima linha no início do arquivo /etc/profile( sudo -H gedit /etc/profile):

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

Mude <user_name>com o seu nome de usuário. Assim, todos os arquivos que contêm comandos de inicialização quando um shell é chamado passarão pela "armadilha".

Para testar se há um comando errado, /etc/profilepor exemplo, execute os seguintes comandos do terminal:

fonte do bash / etc / profile

Se algo estiver errado, como neste caso, o resultado será:

armadilha

Portanto, agora sabemos com certeza que existe um problema ( command not found) no /etc/profilearquivo na linha 32 (não está na linha 31 como acima, porque inserimos uma nova linha no início do arquivo).

Muito obrigado a Luca Borrione por seu script desta resposta que me ajudou a concluir esta solução generalizada.


Adicionado código de .bashrce .profilepara a pergunta - não consigo encontrar ♦ aqui.
Vitaly Zdanevich

1
@VitalyZdanevich Você deve verificar todos os arquivos que contêm inicialização comandos ( .bash_aliases, .pam_environment, etc.) para somenthing dentro estranho, não necessariamente exatamente esse caráter.
Radu Rădeanu

2
Sim, o problema está na linha 31 de /etc/profile. Você tem algo muito estranho lá. Apenas apague everithing entre fie JAVA_HOME, depois pressione um ou dois 'Enter' e tudo ficará bem depois. Modifique o arquivo comsudo gedit /etc/profile
Radu Rădeanu

1
@RyanLoremIpsum Não, tenho certeza. O OP tinha colado lá, não me :)
Radu Rădeanu

1
Ótimo! Eu limpo essas duas linhas transparentes /etc/profile. Bolsa estranha.
Vitaly Zdanevich

5

Para depurar os scripts de inicialização do bash, execute o seguinte (depois de efetuar login no console virtual).

PS4='+ $BASH_SOURCE:$LINENO:' bash -xlic ''

O acima executado executa o bash no modo interativo ( -i) login ( -l), o mesmo que o loginprograma quando você faz login em um console virtual. -c ''torna sair imediatamente após a execução através dos scripts de inicialização, e o -xe PS4=...torna a saída de cada comando, antes de executar eles, juntamente com o número nome do arquivo e linha do comando. Isso deve ajudar a determinar qual linha de qual arquivo esse comando inválido reside.

Em uma nota lateral, ♦ é o símbolo que a fonte padrão do console virtual usa para imprimir caracteres para os quais não possui um símbolo.


1

Ao pesquisar seus arquivos de inicialização, pode ser útil procurar o hexadecimal usado para gerar o ♦. O código hexadecimal para ♦ é 2666, de acordo com o caractere Unicode 'BLACK DIAMOND SUIT' . Nota: Há pelo menos um outro código hexadecimal, 25C6, que produz o mesmo símbolo ou aparência semelhante. Veja os resultados da pesquisa para "diamante". Pesquisa de caracteres Unicode

Talvez algo parecido \u2666esteja em um dos scripts. No Manual de Referência do Bash para eco - "\ uhhhh o caractere Unicode (ISO / IEC 10646) cujo valor é o valor hexadecimal HHHH (um a quatro dígitos hexadecimais)"

Depende da codificação de caracteres usada, portanto, você deve procurar primeiro as mais prováveis. echo $LC_CTYPEdeve retornar a codificação de caracteres usada pelo seu shell. Consulte Como obter a codificação de caracteres do terminal


-1 porque in ~/.bash_historysão armazenados os comandos executados interativos no PS1.
Radu Rădeanu

Obrigado por confirmar. Eu o removi. Eu deveria ter acrescentado o resto como um comentário à sua resposta, Radu?
iyrin

Ah, eu não entendo - o que preciso fazer? Onde estão os arquivos de inicialização do Lubuntu? Tentei pesquisar por texto completo \u2666e ♦ no Catfish (pesquisa Lubuntu) - nada. Eu semeio history- nada. Eu vejo essa mensagem apenas em tty somente após o login. Depois que echo $LC_CTYPEeu chegar a linha vazia.
Vitaly Zdanevich

A execução localedeve mostrar o LC_CTYPE. locale
iyrin

Experimente a resposta de Radu antes desta! Se restringirmos o conjunto de caracteres usado em seu tty, você poderá procurar a ocorrência do código de caractere correspondente para o diamante sólido. Essa pesquisa seria infrutífera se a descoberta da RLO de Radu fosse a causa.
iyrin

0

Escreva o caminho completo para uma ferramenta conhecida que permitirá editar seu arquivo bashrc, juntamente com o caminho completo para o arquivo bashrc.

/bin/nano /home/username/.bashrc

Encontre qualquer abuso para sua PATHvariável e comente. É provável que ao tentar adicionar algo ao seu caminho, ele tenha sido citado em vez de duplo.

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

Copie seu .bashrc em uma ferramenta como https://www.shellcheck.net/ para ver se você tem algum problema evidente com o uso do bash.

Espero que ajude.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.