Blog do Fábio Lima: Comandos

Este é um script em Shell que simula um cronômetro simples.

O código mostrado aqui é outra tentativa de aprendizado em Shell Linux. Na prática pode não ter utilidade nenhuma, dada sua simplicidade. Mas me ajudou a praticar novos conhecimentos.

Talvez sirva de ajuda pra alguém que também esteja estudando linguagem de terminal.

Código fonte no Pastebin: Clique AQUI

Abaixo o código original. Lembrando que ele pode ser melhor visualizado no Pastebin.

   1.      #!/bin/bash
   2.      #   Cronometro simples feito em Shell.
   3.      #   Script criado apenas para fins de estudo.
   4.      #   Para parar, use um [ctrl] + C.
   5.      #   Autor: Fabio Lima CE
   6.      #   Data: 2009-02-14
   7.       
   8.      #   Inicializacao das variaveis
   9.      SS=0;
  10.      MM=0;
  11.      HH=0;
  12.       
  13.      #   Inicio do 'loop infinito' que atualizara
  14.      # as variaveis a cada segundo.
  15.      #   A condicao 'sleep 1' se encarrega de gerar
  16.      # atrasos de um segundo a cada passagem.
  17.      while (sleep 1)
  18.      do
  19.              #   Testa a quantidade de segundos
  20.              #   Se SS > 59 entao MM++
  21.              if ( test $SS -gt 59)
  22.              then
  23.                      SS=0
  24.                      MM=$(echo "$MM + 1" | bc)
  25.              fi
  26.       
  27.              #   Testa a quantidade de minutos
  28.              #   Se MM > 59 entao HH++
  29.              if (test $MM -gt 59)
  30.              then
  31.                      MM=0
  32.                      HH=$(echo "$HH + 1" | bc)
  33.              fi
  34.       
  35.              #   Testa a quantidade de horas
  36.              #   Se HH > 23 entao Zera todas variaveis
  37.              if (test $HH -gt 23)
  38.              then
  39.                      MM=0
  40.                      HH=0
  41.                      HH=0
  42.              fi
  43.       
  44.              #   Mostra o tempo decorrido depois de atualizado
  45.              #   Opcoes do 'echo':
  46.              #   -n: desabilitar nova linha no final do comando (\n)
  47.              #   -e: habilitar o uso de caracteres de scape (\t, \n, \a \r etc)
  48.              echo -n -e "\rTempo decorrido: $HH h $MM min $SS seg "
  49.       
  50.              #   Acrescenta um segundo
  51.              #   O 'bc' eh uma realiza calculos com inteiros
  52.              SS=$(echo "$SS + 1" | bc)
  53.       
  54.      done

Bateria de Notebooks em Shell Linux

Estou disponibilizando um script para verificação de status de bateria em notebooks.

Esse pequeno programa é escrito para Shell, mais especificamente Bourne Again Shell (Bash). Tive a idéia de fazê-lo para por em prática o que eu tenho estudado sobre a linguagem. A melhor maneira de aprender uma nova linguagem é praticando, não tem outro jeito!

Pra quem gosta de trabalhar em linha de comando esse programinha pode ser muito útil. Pelo menos pra mim está sendo...

Ele pode ser visualizado e baixado no Pastebin AQUI.

O código é este abaixo. Porém ele fica mais legivel no Pastebin.


   1.      #!/bin/bash
   2.      # Bateria: programa de medicao de status da bateria.
   3.      # Autor: Fabio Lima CE
   4.      # Data: 25-12-2009
   5.       
   6.      # Lendo os arquivos de parametros de
   7.      # kernel para obter as informacoes
   8.      # e o status da bateria.
   9.      echo ""
  10.      cat /proc/acpi/battery/BAT1/info  \
  11.      | grep "last full capacity:"      \
  12.      | cut -c26-29                     \
  13.      > /tmp/bat-capacity              
  14.      BATCAP=$(cut -f1 -d" " /tmp/bat-capacity)
  15.      echo "    Ultimo carregamento:       $BATCAP mAh"
  16.       
  17.      cat /proc/acpi/battery/BAT1/state \
  18.      | grep "remaining capacity:"      \
  19.      | cut -c26-29                     \
  20.      > /tmp/bat-remaining
  21.      BATREM=$(cut -f1 -d" " /tmp/bat-remaining)
  22.      echo "    Capacidade atual:          $BATREM mAh"
  23.       
  24.      echo " ($BATREM * 100) / $BATCAP " | bc \
  25.      > /tmp/bat-percent
  26.      BATPER=$(cat /tmp/bat-percent)
  27.       
  28.      echo "    Percentual remanecente:    $BATPER%"
  29.       
  30.      # Simulando uma barra de progresso para
  31.      # mostrar o nivel da bateria.
  32.      # A barra de progresso tera a seguinte aparencia:
  33.      #     Nivel [||||||||||..........]
  34.       
  35.      # Variaveis do tipo string que armazenarao
  36.      # as barras e os pontos da barra de progresso.
  37.      BARRS=
  38.      DOTS=
  39.       
  40.      # Calculando a quantidade de barras
  41.      # e armazenando na variavel BARRS.
  42.      for i in $(seq -s  " " $BATPER)
  43.      do
  44.              if [ $(echo "$i % 4" | bc) -eq 0 ]
  45.              then
  46.                      BARRS=$(echo $BARRS\|)
  47.              fi
  48.      done
  49.       
  50.      # Calculando a quantidade de pontos
  51.      # e armazenando na variavel DOTS.
  52.      for j in $(seq -s " " $(echo "100 - $BATPER" | bc))
  53.      do
  54.              if [ $(echo "$j % 4" | bc) -eq 0 ]
  55.              then
  56.                      DOTS=$(echo $DOTS.)
  57.              fi
  58.      done
  59.       
  60.      # Juntando e mostrando as barras e os pontos.
  61.      # Mostrando a barra de progresso pronta.
  62.      echo ""
  63.      echo "    Nivel: [$BARRS$DOTS]"
  64.      echo ""

sábado, 3 de novembro de 2007

Permissões de Acesso em Linux

Nesta postagem será mostrado como funciona o sistema de permissões em Linux. O esquema de segurança de acesso vem de seus ancestrais Unix, sendo uma forma de evitar que usuários ou grupos tenham acesso indevido a arquivos, diretórios ou aplicativos.

Os tipos de arquivo mais conhecidos são os do tipo diretório e arquivo propriamente dito. Existem outros tipos de arquivo como archive, bloco, soquet etc. Mas nós falaremos apenas dos dois anteriores.

Os diretórios são representados por um 'd', enquanto os arquivos comuns são representados por um traço '-'.

Existem em Linux três níveis de acesso: leitura, gravação e execução. Eles são representados respectivamente pelas letras 'r' (Read), 'w' (Write) e 'x' (eXecute). Essas três letras podem formar até oito combinações diferentes. Cada combinação define o "poder de acesso" que um usuário ou grupo tem sobre um arquivo ou diretório.

Esses níveis de acesso são dados a três tipos de entidade: usuário, grupo, outros. Quando um administrador de sistema vai explicitar as permissões de um arquivo ele deve fornecer o nível de acesso para todas três entidades. Cada entidade vai receber uma combinação de r, w e x.

O comando que é usado para verificação das restrições e permissões dos arquivos de um diretório é: ls -l.

Já o comando que se usa para determinar restrições e permissões de acesso é o chmod, que significa change mode. Esse comando necessita de pelo menos dois argumentos: uma string que descreve o nível de acesso desejado e o nome do arquivo do qual se quer mudar as permissões.

Vejamos um exemplo de listagem de permissões. Foi dado um comando ls -l e o resultado foi o que está abaixo:

Permissões	Itens	Dono	Grupo	Tamanho	Data	Nome
-rwxr--r--	1	josé	cozinha	654	Sep7 12:00	receita_de_bolo.txt
-rw-rw-rw-	1	josé	cozinha	245	Sep8 11:45	receita_de_macarronada.txt
drw-rw----	5	josé	cozinha	4895	Sep15 14:25	receitas_reunidas

Na primeira linha temos o seguinte para o arquivo "receita_de_bolo.txt":

-rwxr--r--: string que descreve o nível de acesso desejado para cada entidade usuária.
'-': O arquivo é do tipo arquivo comum;
'rwx': O usuário dono tem acesso total ao arquivo de receita_de_bolo.txt para ler, escrever e executar(se possível);
'r--': O grupo do dono tem acesso para apenas ler a receita de bolo;
'r--': Os outros usuários têm acesso para apenas ler também.

Iremos nos deter um pouco na string de acesso. É importante saber o que cada caractere diz. O esquema da string é explicado abaixo:

Primeiro caractere (caractere 0):

Se for diretório, usa-se 'd';
Se for arquivo comum, usa-se '-'.
No caso acima trata-se de um arquivo comum, por isso foi usado um traço;

Primeiro grupo de tês caracteres (caracteres de 1 a 3):

Define as permissões do usuário dono do arquivo.
No caso acima: rwx (leitura, gravação e execução)

Segundo grupo de três caracteres (caracteres de 4 a 6):

Define as permissões do grupo de usuários que o dono faz parte.
No caso: r-- (somente leitura). As outras posições são preenchidas com traços.

Terceiro grupo de três caracteres (caracteres de 7 a 9):

Define as permissões para os todos os outros usuários.
No caso: r-- (também somente leitura). Preenchimento com traços para os espaços vasios.

Outros exemplos:

-rw-rw-rw- receita_de_macarronada.txt

-: O arquivo é um arquivo comum.
rw-: O usuário dono poderá ler e escrever, mas não poderá executar (pra quê?).
rw-: O grupo do dono também podera ler e escrever.
rw-: Qualquer outro usuário também poderá ler e escrever.

drw-rw---- receitas_reunidas

d: O arquivo é um diretório;
rw-: O usuário dono poderá ler e escrever, mas não poderá executar (pra quê?).
rw-: O grupo do dono também podera ler e escrever.
---: Os outros usuários não poderão nem ao menos ler.

É possível atribuir acesso de duas maneiras. A mais simples na minha opinião é a que usa o conceito de adicionar e subtrair. Se você quer dar poder de escrita para um grupo de usuários por ,exemplo, o comando é este: chmode g+w receitas_reunidas. Se pelo contrário, você quiser tirar o acesso de gravação, basta dar um chmode g-w receitas_reunidas, com sinal de menos no meio de g e w. É importante agora decorar mais umas letrinhas:

u: usuário;
g: grupo;
o: outros;
a: todos;

Exemplos de configuração de permissão:

chmod u+x => dá ao usuário acesso a execução;
chmod u-w => tira do usuário o acesso a escrita;
chmod u-rwx => tira todo o acesso do usuário;
chmod g+rwx => dá acesso total ao grupo;
chmod ug+rwx => dá acesso total ao usuario e seu grupo;
chmod go-wx => tira acesso de escrita e execução do grupo e de outros usuários;
chmod a+rwx => libera acesso total para todo mundo.

Outra maneira de configurar acesso é utilizando números para simbolizar o nível de acesso de cada entidade usuária. Os níveis vão de 0 (proibição total) a 7 (permissão total). A tabela abaixo descreve cada nível numérico de acesso.

0	`[ --- ]`	proibição total
1	`[ --x ]`	apenas execução
2	`[ -w- ]`	apenas Escrita
3	`[ -wx ]`	escrita e execução
4	`[ r-- ]`	apenas leitura
5	`[ r-x ]`	leitura e execução
6	`[ rw- ]`	leitura e escrita
7	`[ rwx ]`	permissão total

O mesmo chmod é utilizado, com a diferença que não se precisa expecificar a entidade usuária. Como parâmetro é passado uma string de três números de 0 a 7. O primeiro número se refere ao usuário; o segundo, ao grupo; o terceiro aos outros usuários. Exemplos:

chmod 777 receitas_reunidas => dá acesso tota a todos os usuários;
chmod 700 receitas_reunidas => proíbe totalmente o acesso de outros que não sejam o dono;
chmod 660 receitas_reunidas => dá acesso de leitura e escrita para o dono e seu grupo;

Concluímos que não é difícil realizar operações que envolvam restrições de acessos de usuários. Tudo que é exigido do administrador é saber para que serve o chmod e lembrar de algumas letrinhas usadas como argumento para o mesmo.

segunda-feira, 29 de outubro de 2007

Compactando e Descompatando em Linux