ls colors: por que algumas das minhas fontes são pretas e outras verdes na saída ls

Fiz upload de alguns arquivos de fonte para a AWS (executando o Amazon Linux) e os movi para o /usr/share/fontsdiretório usando um cpcomando em .ebextensions.

Quando faço o SSH do meu Mac e uso ls -a, vejo alguns arquivos com cores diferentes - um conjunto de arquivos de fonte é preto enquanto outros são verdes. Estou curioso para saber o que causou isso e se isso criará algum problema para o meu código .

De outra resposta no AskUbuntu , encontrei essa chave sobre como interpretar essas cores. Não consigo entender por que um .ttf seria executável ou por que um conjunto de .ttfs seria reconhecido e não outro.

Azul: Diretório

Verde: arquivo de dados executável ou reconhecido

Sky Blue: arquivo vinculado

Amarelo com fundo preto: dispositivo

Rosa: arquivo de imagem gráfica

Vermelho: arquivo morto

Todos esses arquivos foram baixados para um Mac a partir de vários sites de fontes antes do upload.

ls -linformará definitivamente se um arquivo é executável ou não. Eu não acho que haja algum grande mistério aqui. Você baixou arquivos de várias fontes, cada uma das quais pode ter bits de permissão diferentes definidos por um motivo ou outro. ^* Se você não gosta de ver alguns com cores e outros sem tentar chmod -x *.ttf... os arquivos de fonte não precisam do conjunto de bits executável.

* _{Como o comentário altamente votado de Matteo Italia, que deve ser preservado, diz: Muito provavelmente eles foram copiados de um volume FAT ou NTFS, que não armazena o bit executável, por isso são montados por padrão para que todos os arquivos tenham o bit executável definido. .}

Parece que o lscomando que você está executando é um alias parals --color

homem sl

--color [= WHEN] colorir a saída; WHEN pode ser 'sempre' (padrão se omitido), 'automático' ou 'nunca'; mais informações abaixo

Você pode verificá-lo executando a origem ls:

• Usando aspas:

  "ls" -a

• Usando o caminho completo (por exemplo, se o lslocal estiver /bin/ls) e veja se ele mostra as cores ou não:

  / bin / ls -a

Nota: a execução ls -lamostrará os detalhes dos arquivos e você poderá ver os detalhes completos de cada arquivo, o que permitirá verificar com a saída esperada dels --color

A cor indica que o arquivo está marcado como "executável" *

Os bits de permissão executável (um para usuário, um para grupo, um para outro) significa que se o nome do arquivo for passado para uma das chamadas do sistema exec, o kernel irá adiante e tentará executá-lo.

A convenção é que apenas os arquivos que realmente devem ser executados têm o conjunto de bits executável. No entanto, ao mover / copiar arquivos, especialmente em um ambiente multiplataforma, é fácil obter ou perder inadvertidamente os bits executáveis.

Os arquivos armazenados em um sistema de arquivos que não suporta permissões unix (fat, ntfs etc.) provavelmente aparecerão no sistema como executáveis. Mover ou copiar esses arquivos para um sistema de arquivos unix usando uma ferramenta que preserva permissões preservará esses bits executáveis.

Por outro lado, o uso de ferramentas para mover arquivos que não podem preservar permissões ou são usados ​​com a opção de preservar permissões desmarcadas provavelmente fará com que a cópia não seja marcada como executável, mesmo que o original estivesse.

Portanto, depois de serem movidos por uma variedade de plataformas usando uma variedade de ferramentas, os bits de permissão executáveis ​​podem terminar em um estado bastante arbitrário.

* Não tenho 100% de certeza de como ls lida com o caso em que alguns, mas não todos os bits executáveis, estão definidos.

Como as respostas anteriores disseram, a coloração é para indicar se os arquivos são considerados executáveis ​​ou não.

A permissão "execute" (= bit) no Linux e na maioria dos outros Unixes tem um significado para arquivos e outro para diretórios.

Para diretórios, se você tiver permissão para executar, poderá ver seu conteúdo. Caso contrário, não será possível fazer o cd no diretório nem listar arquivos nele, mesmo que você tenha acesso de leitura e gravação ao diretório.

Para arquivos regulares (ao contrário dos arquivos de dispositivo e outros tipos especiais de arquivos Unix), o bit de execução significa que, se você usar o nome do arquivo na linha de comando, o sistema operacional (ou mais precisamente: shell) tentará "executar" ou executar o arquivo como um comando. Por outro lado, se você não tiver permissão de execução no arquivo, não poderá executá-lo na linha de comando.

Portanto, se você, por exemplo, remover a permissão x de todos os usuários no arquivo / bin / cat (que é um comando Unix), você ou qualquer outra pessoa e qualquer programa que tentar usar o comando "cat" falhará.

Esses são os comandos do SO, como "cat" e "grep", que possuem arquivos executáveis ​​normalmente em / * / bin / diretórios - / bin, / usr / bin, / sbin, / usr / sbin etc.

E então pode haver scripts interpretados não compilados, que são escritos em alguma linguagem de programação, como Python ou shell scripts (basicamente, comandos que você escreve como se fossem da linha de comando quando estiver no servidor).

Agora, quando você define o bit de execução no arquivo de script (por exemplo, arquivo foobar) e tenta executá-lo pelo seu shell: "./foobar", o shell tenta analisar o arquivo e encontrar o programa correto para passar o script para.

Isso é feito pelo shell, tentando ler a primeira linha do arquivo e localizando a notação "shebang" de qual programa ele deve executar.

Portanto, se o seu foobar era um arquivo de texto com a primeira linha como esta:

#!/usr/bin/python

Então o shell tentaria executar o comando /usr/bin/python foobar:, basicamente invocando o interpretador python e passando o nome do seu arquivo foobar para ele como um script Python.

Se o shell não encontrar essa primeira linha no seu arquivo, ele tentará executar o próprio foobar como se contivesse comandos do shell.

Se o arquivo com bit executável não contiver comandos válidos do shell, o shell simplesmente reclamará.

Então é isso que aconteceria, se você tiver arquivos TTF com o bit exec definido e tentar executá-lo na linha de comando:

$./FreeMonoOblique.ttf
-bash: ./FreeMonoOblique.ttf: cannot execute binary file: Exec format error
$

Portanto, para fontes, é provavelmente mais limpo, se o bit exec não estiver definido, mas realmente não mudar nada.

PS Apenas algumas informações estranhas. Se você remover o bit de execução em algum comando ou script, ele ainda poderá ser passado para qualquer outro programa como argumento. Se esse outro programa sabe, como executar seu comando, sua remoção do bit exec realmente não importa. Por exemplo, o script foobar Python ainda seria executado pelo interpretador Python, se você simplesmente fizesse na linha de comando:

$python foobar

ao invés de

$./foobar

O mesmo acontece com o exemplo dos comandos do sistema, como "cat". Se você remover o bit exec de "cat", ainda poderá passá-lo para uma nova instância do shell para execução:

$sh -c 'cat myfile'

funcionará, mesmo se você tiver removido o bit exec do gato e

$cat myfile

não.