Archive for the "TI" Category

[Arquitetura de Computadores] Datas de Práticas Avaliativas e Projetos

1ª Avaliação – 18 de outubro de 2016 calendario2

2ª Avaliação / Projeto – 13 de dezembro de 2016

Avaliação Final – 04 de janeiro de 2017

Linux Foundation mata o GNU

images.duckduckgo.comColaboração: Anahuac Gil

Data de Publicação: 21 de dezembro de 2015

Acontecimentos recentes precisam acionar todos os alarmes do ativismo cibernético. O golpe final está muito próximo. O algoz é a Linux Foundation e a vítima é o GNU. O plano tem se baseado na repetição incansável de que o sistema operacional livre, que é um marco tecnológico, se chama Linux, nasce em 1991 e se baseia nos conceitos revolucionários do Open Source. E onde está o GNU que nasceu uma década antes? Não sou eu quem está fazendo uma acusação leviana, é a própria Linux Foundation quem o diz em seu documentário “O mundo sem Linux” [1]. Trata-se de uma animação em seis episódios, feita com primor e precisão cirúrgica para convencer até os velhos ativistas de que o GNU nunca existiu.

Qualquer pessoa que não conhecer a história toda e vir esse documentário da Linux Foundation terá certeza absoluta que tudo começou em 1991 e não saberá nem que um dia existiu o GNU.

A força da repetição, levada a uma escala global é impossível de deter. Nobres significados já foram subvertidos antes, como o termo “hacker” que virou sinônimo de bandido digital pelo simples interesse de colocar todos, os bandidos e os questionadores, no mesmo balaio. Questionar, aprender, testar, compartilhar e colocar o “status quo” em uma posição incômoda não é crime. Mas incomoda. O mesmo acontece com a marca Linux, sendo repetida a exaustão para remover os conceitos ideológicos que o GNU carrega em si. Matar o GNU é matar a contraposição provocada pela liberdade do código. Foi exatamente com o objetivo de eliminar esse incômodo que a OSI foi criada.

Mas esse é um enredo bem conhecido e, infelizmente, ignorado pela maioria dos envolvidos em tecnologia. É como se eliminar o GNU fosse algo “cool”, bacana, legal, simples. Quantas vezes tive que ouvir que dizer “GNU/Linux” era difícil, e que ajudava mais na aceitação do novato dizer apenas Linux. Bom, hora de assumir sua parcela de culpa na tentativa de extinção do GNU.

Alerta vermelho!

A Linux Foundation diz que a Microsoft será uma grande parceira

Como assim? Simples: no pensamento OSI o que realmente importa é o acesso ao código, no limite necessário, para melhorar os meios de produção de tecnologia. Mais rápido, eficiente, com mais qualidade e muito mais barato. Trata-se de um modelo de negócios e se a Microsoft aderir a esse modelo, que mal há? Não acredita? Leia matéria original direto da linux.com [2]

O Linux não é Open Source

O que dirá Software Livre então? Nem pensar! O professor Rodolfo Pilar deixa isso muito claro neste artigo que ele mesmo intitulou de “El kernel Linux no es libre” [3]. É um texto pequeno, frio e calculista. Ele baixa o Linux. olha os fontes e encontra código não livre. Simples e preciso. Nenhum lero-lero ideológico. Não deixe de conferir.

O que mais você precisa para perceber que se não fizermos algo o GNU será extinto? Se não agirmos rápido permitiremos que os valores difundidos pela FSF e pelo GNU, de que o acesso ao código deve empoderar os usuários para inverter a relação entre esses e os produtores de tecnologia, serão suplantados pela outra ideologia, que defende o acesso ao código como um pilar para meios de produção mais eficientes.

Perceba que não se tratam de ações isoladas e desconexas. Fica cada vez mais evidente que é uma ação deliberada para extinguir o Software Livre, suplantando-o pelo Open Source. Uma pesquisa rápida demonstrará que o termo “Open” tem sido usado mundialmente como sinônimo de “livre”. Mas não significam a mesma coisa, não tem o mesmo peso ideológico, não se baseiam nas mesmas premissas e não reagem na sociedade da mesma forma. Open/Aberto defende meios de produção e Free/Livre buscam mudar a sociedade em busca de um Mundo melhor. Como o “status quo” não tem interesse em mudanças que alterem as relações de poder, então o Open/Aberto é estimulado como uma versão mais suave de liberdade. Assim, subitamente parece que o mundo todo aderiu ao “Open”: Open Mind, Open Data, Open Office, Open House e por ai vai.

Que fique claro: algo aberto não é necessariamente livre. E é exatamente dessa dubiedade que o “status quo” se alimenta. Vende liberdade, mas fornece prisões.

O que fazer?

Algumas ações são mais simples que outras, mas todas são possíveis e qualquer uma delas, mesmo que seja uma só, fará toda a diferença. Lembre-se que sua participação é fundamental.

  • Diga somente GNU! Não se refira mais ao sistema operacional como Linux. Minha sugestão é que você sequer diga GNU/Linux. Mesmo que você não concorde plenamente, neste momento, ajuda muito se fizermos um esforço para reforçar o GNU. Estamos tentando virar o jogo, lembra? E depende muito apenas de você e de cada um de nós. Por que? Oras, porque quando você disser GNU, o desavisado não saberá ao que você se refere e essa é a oportunidade para falar sobre liberdade, compartilhamento que revoluciona e como essa ação tem o poder de transformar a sociedade. Linux? Isso é só mais um programa de computador que nem sequer é livre.
  • Não use mais o Tux. Adote outros mascotes para referenciar seu apreço pelo Software Livre. O Tux é o logo do Linux. Linux não é livre. Portanto esqueça o Tux. A fauna do Software Livre é imensa e com certeza você vai encontrar um outro animal que lhe agrade. Na dúvida, opte pelo próprio GNU.
  • Não use Linux. Existe um conjunto de distribuições GNU [4] que não usam Linux: Trisquel, Parábola e gNewSense são alguns exemplos. Esses sistemas operacionais usam um kernel chamado linux-libre [5], um Linux “desentuxicado” e mantido pela FSFLA, que funciona em qualquer outra distribuição, inclusive Debian, Fedora e openSuse.

É claro que a lista poderia ser muito mais longa, mas se você se comprometer a fazer apenas uma delas, podemos reverter o cenário e evitar a extinção do GNU.

Seja um “Amigo do GNU”, seja #maisGNU!!!

Saudações Livres!

Links do texto

Expandindo o espaço do Linux Fedora 20 usando LVM

Um dos grandes problemas de quem trabalha com administração de sistemas é utilizar corretamente o espaço dos servidores. Por vezes criamos uma máquina virtual, alocamos um espaço e quando vemos este já está insuficiente para a quantidade de dados que está sendo gerado. Esta semana aconteceu isso no SIEP. Estamos passando por algumas modificações estruturais e percebemos que a antiga máquina servidora que tínhamos estava caindo aos pedaços. Surgiu a possibilidade de colocar tudo em um lugar novo, mas não sabíamos ao certo de quanto espaço precisaríamos. Chutamos 20 GB, porém com o passar dos dias percebemos que este espaço não era suficiente e que precisaríamos de pelo menos 40 GB. Percebi que a máquina foi feita com o VMWare e que poderíamos aumentar o espaço justamente por se tratar de um sistema que utiliza o LVM. Solicitei ao Administrador de Redes do IFPE que aumentasse o espaço pelo gerente do VMWare. Depois disso quando reiniciamos a máquina a mesma ainda estava com 20 GB, que para aumentar o espaço necessário seria necessário fazer algumas modificações:

É necessário fazer seu sistema reconhecer o espaço adicional, para isso siga os passos abaixo:

Acesse seu servidor via SSH, digite usuário e senha e execute a sequência de comandos abaixo como usuário root (Em negrito preto são os comandos que vocês devem digitar no shell):

Primeiro temos de criar uma partição com o novo espaço gerado:

# fdisk /dev/sda

Na linha abaixo digite ‘n’, para inserir uma nova partição.

Comando (m para ajuda)':' n 

Na linha abaixo digite ‘p’ e pressione Enter, para adicionar uma partição primária

Comando - ação
e   estendida
p   partição primária (1-4)
Comando (m para ajuda): p 

Em número da partição, digite 3 e pressione Enter;

Número da partição (1-4): 3 

Pressione Enter para default para o primeiro e último cilindro (os números de cilindro podem variar);

Primeiro cilindro (6528-13054, default 6528): 'Pressione Enter'
Using default value 6528
Last cilindro, +cilindros or +size{K,M,G} (6528-13054, default 13054): 'Pressione Enter'
Using default value 13054

Digite p para visualizar a nova partição criada, geralmente a última é a criada para adicionar ao LVM, no caso “sda3”. Anote essa partição, pois será necessário informar posteriormente ao LVM a nova partição criada;

Dispositivo Boot      Start         End      Blocks 	  Id   System
/dev/sda1   *          	 1             13         104391   	  83   Linux
/dev/sda2              	14           6527     52323705     8e   Linux LVM
/dev/sda3            	6528       7744     9775552+     83   Linux

Digite w para salvar e aplicar as alterações no disco;

A tabela de partições foi alterada
Chamando ioctl() para reler tabela de partições.
WARNING: Re-reading the partition table failed with error 16: Dispositivo ou recurso está ocupado.
The kernel still uses the old table.
The new table will be used at the next reboot.
Sincronizando discos.

Nota: Surgirá uma mensagem de Warning, avisando que as alterações só serão aplicados ao reiniciar o computador.

Em seguida reinicie o servidor com o comando ‘reboot’ para o sistema reconhecer as novas partições;

 # reboot 

Depois de reiniciado o sistema, acesse-o pelo shell como nos comandos a seguir:

$ su -
Password:
Last login: <date> on pts/0
# fdisk -l

O comando acima, mostra quais as partições disponíveis no nosso sistema. Será mostrado algo como:

Disk /dev/sda: 40 GiB, 42949672960 bytes, 83886080 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

Disklabel type: dos
Disk identifier: '0x00004b1f'
Device Boot Start End Blocks Id System

/dev/sda1 * 2048 1026047 512000 83 Linux
/dev/sda2 1026048 41943039 20458496 8e Linux LVM
/dev/sda3 41943040 83886079 20971520 83 Linux

Disk /dev/mapper/fedora_siep-swap: 2 GiB, 2147483648 bytes, 4194304 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk /dev/mapper/fedora_siep-root: 17.5 GiB, 18798870528 bytes, 36716544 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

No nosso caso o novo espaço que o Administrador de Redes criou é o /dev/sda3 que está sem uso. Então temos de fazer o sistema linux reconhecer o mesmo.

Será necessário adicionar as partições ao LVM, para isso execute os comandos abaixo:

Crie a nova partição no LVM executando o comando abaixo:

# pvcreate /dev/sda3
Physical volume "/dev/sda3" successfully created

Colete o nome do VG Name ao qual será adicionado a nova partição com o comando vgdisplay:

# vgdisplay 
  --- Volume group ---
  VG Name               fedora_siep
  System ID             
  Format                lvm2
  Metadata Areas        1
  Metadata Sequence No  3
  VG Access             read/write
  VG Status             resizable
  MAX LV                0
  Cur LV                2
  Open LV               2
  Max PV                0
  Cur PV                1
  Act PV                1
  VG Size               19.51 GiB
  PE Size               4.00 MiB
  Total PE              4994
  Alloc PE / Size       4994 / 19.51 GiB
  Free  PE / Size       0 / 0   
  VG UUID               LvqqfR-UAo5-2YJd-K6Rv-eZ2q-qDnU-2tJEGK

Anote o nome do VolumeGroup ou VG Name, possivelmente será lvm1, mas no nosso caso é fedora_siep

Agora expanda o Volume fedora_siep adicionando o sda3:

# vgextend fedora_siep /dev/sda3
Volume group "fedora_siep" successfully extended

fedora_siep é o volume que deseja expandir, o 3 é o numero da partição criada)

Liste os volumes lógicos para identificar o volume a ser expandido com o comando lvscan:

# lvscan
ACTIVE            '/dev/fedora_siep/root' [17.51 GiB] inherit
ACTIVE            '/dev/fedora_siep/swap' [2.00 GiB] inherit

Estendemos o volume lógico da LVM com o valor disponibilizado pelo Administrador de Rede:

# lvextend -l +100%FREE /dev/fedora_siep/root
Extending logical volume root to 37.50 GiB
Logical volume root successfully resized

(assumindo que o VG se chama fedora_siep e o volume lógico a ser expandido se chama root, o -l +100%FREE deve ser usado para usar todo o espaço disponível para expansão)

Redimensionamos o sistema de arquivos da partição /lvm/root:

# resize2fs /dev/fedora_siep/root
resize2fs 1.42.8 (20-Jun-2013)
Filesystem at /dev/fedora_siep/root is mounted on /; on-line resizing required
old_desc_blocks = 2, new_desc_blocks = 3
The filesystem on /dev/fedora_siep/root is now 9831424 blocks long.

Reinicie o servidor novamente para finalizar o processo;

# reboot

Após o sistema ser carregado novamente, o espaço expandido no disco será reconhecido e já poderá ser utilizado. Para verificar utilize o comando df:

$ df -h
Filesystem                    Size  Used Avail Use% Mounted on
/dev/mapper/fedora_siep-root   37G  6,3G   29G  18% /
devtmpfs                      992M     0  992M   0% /dev
tmpfs                        1002M     0 1002M   0% /dev/shm
tmpfs                        1002M  712K 1001M   1% /run
tmpfs                        1002M     0 1002M   0% /sys/fs/cgroup
tmpfs                        1002M  8,0K 1002M   1% /tmp
/dev/sda1                     477M  115M  334M  26% /boot

Observações sobre TCC

Alunos de TCC I e TCC II. Prestem atenção as normas do TCC do Instituto. Alguns alunos estiveram me procurando dizendo que podem apresentar o trabalho o dia que quiser. Só que não é bem assim. Segundo as normas do TCC:

Art. 38 – A nota final do TCC deverá ser a média aritmética das notas atribuídas ao estudante pelos membros da Banca Examinadora.
§1º- Numa escala de 0,0 (zero) a 10,0 (dez), o estudante estará aprovado no componente curricular TCC, se obtiver nota mínima igual a 7,0 (sete), sendo essa aferida pela Banca Examinadora.
§2º – O estudante reprovado na apresentação ou defesa do TCC, deverá retornar às orientações desse componente curricular e terá o prazo de um semestre letivo para apresentar o seu novo trabalho, devendo, para isso, matricular-se novamente no componente curricular TCC.
Vejam que o parágrafo 2  deixa bem claro que o aluno não aprovado em TCC deverá fazer novamente o componente curricular. Por isso que a nota da segunda avaliação de TCC II é a nota da apresentação. Fica sem sentido o aluno ser aprovado na cadeira de TCC II e depois o mesmo é reprovado na apresentação. Eu teria de voltar atrás na digitação das notas e colocar a nota do aluno da apresentação. O aluno terá de ser reprovado! Caso o aluno não apresente a versão final à coordenação para defesa ainda no período de aula, fica muito difícil eu digitar as notas fora do prazo estipulado pelo Q-Acadêmico. Caso algum aluno deseje apresentar fora do período que foi acertado na cadeira, entre em contato comigo para que eu faça um memorando à Direção de Ensino, informando sobre o ocorrido e que a responsabilidade da nota é do orientador deste e não mais a minha pessoa. Ficando desta forma, eu me redimo de qualquer responsabilidade por qualquer problema que tenha.

Erro do Adobe em sistemas 64 bits

Novos sistemas, novos erros… Estou cansado de testar sistemas e encontrar erros. Desta vez é quando você termina de instalar o Adobe para linux e aparece a seguinte mensagem:

error while loading shared libraries: libgdk_pixbuf_xlib-2.0.so.0: cannot open shared object file: No such file or directory

Isso ocorre por conta do software ser de 32 bits e as bibliotecas para esta plataforma não vem instalado por padrão. Para consertar execute:

sudo aptitude install ia32-libs

O que aconteceu com meu “Recent Items” / “Documentos Recentes” no Windows 8?

Recentemente por conselho de meu amigo Helmut Kemper, acabei por formatar meu computador e instalar o Windows 8. Primeiro que precisava verificar na vera o uso do recurso do UEFI que já existia no meu notebook, e segundo porque o meu Windows 7 só funcionava se executasse o sistema em modo de Administrador. Fiz um script do RegEdit que resolve este problema, que o mesmo pode ser baixado aqui. Mas resolvi começar de novo. O que é engraçado que o computador inicializa de forma super rápida! Já que não deve ter que carregar tudo na inicialização. Embora de certa forma alguns controladores são inicializados no momento de apresentação da tela de logon. Usando o computador hoje percebi que os “Documentos Recentes” sumiu, já que não tem mais o menu iniciar. A solução: Criei um atalho para itens recentes na área de trabalho do windows.

Procedimentos:

1 – Clicar com o botão direto do mouse na área de trabalho e escolha Novo –> Atalho…

2 – Colocar o caminho C:\Users\<usuário>\Recent 

O nome <usuário> é o nome do seu login do windows. No meu caso é Anderson. Deve ficar como na figura abaixo:

atalho

3 – Clique em Avançar, coloque um nome. No caso coloquei o nome de “Documentos Recentes” e depois em Finalizar.

Irá aparecer um ícone como a seguir:

icone

Pronto! Quando você abrir Clicar no Atalho, os seus documentos abertos recentemente irá aparecer.

Ponteiros e Referências em CPP

A coisa que mais me deixa irritado quando ministro aula com as turmas mais avançadas aqui de SI é que os alunos ainda não consegue entender o conceito correto de ponteiro. Muitas vezes por conta da preguiça, que só lembram do assunto quando tem disciplina, ou outras vezes por conta da falta de problemas reais para tentar conseguir visualizar o conceito. Por essa razão segue um pequeno (pequeno mesmo!) sobre o uso de ponteiros. Quem tiver dúvida aconselho a comprar esse livro, ou esse, ou busca algo na Internet.

O desenvolvimento de softwares na linguagem de programação C++, um recurso muito utilizado e poderoso dá aos programadores a possibilidade de manipular contextos de memória utilizando ponteiros e referências.

Tal recurso pode agir como uma espada de dois gumes. Se bem utilizado, trará poder de processamento no uso da memória disponível, mas se mal utilizado, poderá trazer consequências desastrosas para a aplicação, ou pior, trazer consequências desastrosas no pós desenvolvimento, no período de implantação do software.

A manipulação da memória é uma ação que exige atenção e cuidado no desenvolvimento de sistemas, isto faz a diferença entre o sucesso e o fracasso da aplicação, aproveitando ao máximo os recursos disponíveis de hardware e software.

Nesta postagem vamos aprender a criar, manipular e remover da memória os ponteiros e as referências.

Ponteiros

Um ponteiro nada mais é do que uma variável que armazena um endereço de memória.

Mas, o que é a memória ?

A memória do computador ou memória RAM (Random Access Memory), nada mais é do que um espaço físico de armazenamento de dados temporários, de uso do sistemas de computadores. Ela possui setores que armazenam dados, estes que são declarados em uma aplicação como variáveis, ponteiros, referencias e outros recursos do software.

O consumo dos dados na memória, varia de acordo com o seu tipo de dados (int, char, long …), sendo que na declaração de um ponteiro também é declarado o seu tipo, vejamos:

#include ‹iostream›
#include ‹stdio.h› 

using namespace std;

int main(argc, char *argv[]){
    unsigned int address_number = 3560;
    unsigned int *p_value = &address_number;

    cout << *p_value << endl;

    return 0;
}

Repare que no código acima a declaração do ponteiro “p_value” recebe o endereço da variavel “address_number” pelo operador de referência “&”, em seguida o valor apontado por “p_value” é apresentado em tela. Repare ainda que a exibição do valor contido na variavel “address_number” é exibido pelo ponteiro “p_value“, devemos observar que para exibir o valor apontado por um ponteiro é necessário a utilização do operador “*” antes do nome do ponteiro.

A memória do computador possui endereços que podem variar de arquitetura para arquitetura, conhecimento no qual não é necessário no momento, devemos nos ater apenas que um ponteiro irá armazenar este endereço e que ele pode variar de acordo com a disponibilidade da memória livre.

Vejamos abaixo uma demonstração do endereço de memória:

#include ‹iostream›
#include ‹stdio.h›

using namespace std;

int main(argc, char *argv[]){
    unsigned int address_number = 3560;
    unsigned int *p_value = &address_number;

    cout << p_value << endl;

    return 0;
}

Operador new

O operador new, aloca memória para a aplicação de acordo com  a disponibilidade da memória livre e a tipagem de dados.

Utilizando o operador “new” a aplicação irá receber um endereço de memória em caso de sucesso, mas se algo der errado a solicitação de alocação de memória irá obter um valor nulo (NULL). Por isso é crucial que a cada pedido de alocação de memória, o desenvolvedor verifique tal disponibilidade para não causar danos a aplicação.

Abaixo vejamos a utilização do operador:

unsigned int *pvalue;
pvalue = new unsigned int;

ou

unsigned int *pvalue = new unsigned int;

Operador delete

O operador delete, devolve a memória alocada pelo operador “new“, podendo está ser solicitada novamente, de acordo com as necessidades da aplicação.

Abaixo vejamos a utilização do operador:

unsigned int *pvalue = new unsigned int;
*pvalue = 3572;

delete pvalue;

Uma observação muito importante é que após utilizar o operador delete para um ponteiro, apenas estamos dizendo para o compilador devolver a memória para a área disponível, mas isto não remove o endereço de memória armazenado pelo ponteiro.

Então, uma boa prática de desenvolvimento seria, após utilizar o operador delete para devolver a memória requisitada, atribuir a constante NULL para o ponteiro.

Se por engano uma segunda chamada ao operador delete for efetuada para desalocar o ponteiro para a memória, está ação resultaria na quebra do sistema. Logo atribuir a constante NULL para o ponteiro desalocado, remove a referência ao endereço de memória existente como seu valor, o que evita o compilador efetuar uma tentativa de desalocação de memória para uma área já removida da aplicação.

Referências

Uma referência é um nome alternativo(Alias) para uma variável declarada no sistema. Recurso no qual é muito utilizado na passagem de parâmetros para funções.

A utilização da referência, se dá, com a colocação do operador “&” na declaração da variável, após o tipo de dados e antes da declaração do nome, vejamos:

#include ‹iostream›
#include ‹stdio.h›

using namespace std;

int main(int argc, char *argv[]){
    unsigned int x = 20;
    unsigned int &ref = x;

    cout << "valor: " << ref << endl;
    cout << "Endereco de memoria da variavel x: " << &x << endl;
    cout << "Endereco de memoria da variavel p: " << &ref << endl;

    return 0;
}

Reparem que no código acima, a declaração da variável ref possui o “&” (e comercial) antes do seu nome. Podemos ainda verificar que pref possui o mesmo endereço da variável referenciada.

Nas postagens seguintes desta série veremos mais sobre os ponteiros e as referências, utilizando-as em funções, objetos e métodos de classes. Recurso imprescindível para uma aplicação em C++.

[Shell] Tipos de controle e testes

Uma das principais dificuldades para quem trabalha com Shell Script no Linux é a quantidade de tipos de controles e testes nas estruturas de loop e repetição. Segue uma lista dos principais:

Comparações entre números

 
  -eq : igual a
  -ne : diferente de
  -gt : maior que
  -ge : maior ou igual a
  -lt : menor que
  -le : menor ou igual a
  -a : AND binário (bit a bit)
  -o : OR binário (bit a bit)

Comparações entre strings usando []

 
  = : igual a
  != : diferente de
  -z : string de tamanho zero

Comparações entre strings usando Shell scripts

 
  = : maior ou igual a (lexicográfico)

Associações entre condições

 
  && : AND lógico
  || : OR lógico

Os operadores de teste em arquivos permitem verificar propriedades de entradas no sistema de arquivos. Eles são usados na forma -op, onde op corresponde ao teste desejado. Os principais testes são:

 
    e : a entrada existe
    r : a entrada pode ser lida
    w : a entrada pode ser escrita
    O : o usuário é o proprietário da entrada
    s : tem tamanho maior que zero
    f : é um arquivo normal
    d : é um diretório
    L : é um link simbólico
    b : é um dispositivo orientado a bloco
    c : é um dispositivo orientado a caracatere
    p : é um named pipe (fifo)
    S : é um socket special file
    u : tem o bit SUID habilitado
    g : tem o bit SGID habilitado
    G : grupo da entrada é o mesmo do proprietário
    k : o stick bit está habilitado
    x : a entrada pode ser executada
    nt : Verifica se um arquivo é mais novo que outro
    ot : Verifica se um arquivo é mais velho que outro
    ef : Verifica se é o mesmo arquivo (link)

Segue um exemplo:

 
arquivo='/etc/passwd' 

if [ -e $arquivo ] 
then 
   if [ -f $arquivo ] 
   then 
      if [ -r $arquivo ] 
      then 
         source $arquivo 
      else 
         echo "Nao posso ler o arquivo $arquivo"
      fi 
   else 
      echo "$arquivo não é um arquivo normal"
   fi 
else 
   echo "$arquivo não existe"
fi

 

[OPORTUNIDADE] Grupo Neoenergia

Queridos estudantes! Está disponível no link de oportunidades. Mais uma vaga de estágio. Os interessados podem se candidatar com mais informações disponíveis no banner baixo ou clicanod aqui.

Jogos de Linux

Quer jogar no Linux com qualidade? Acesse o site do PenguSpy. Aconselho dois jogos, o Beats of Rage, que lembra muito o antigo Street of Rage do Genesis = Mega Drive com os personagens do King of Fighters, aí me baixo vai um vídeo do mesmo:

E o outro jogo bem legal é o Spiral Knights que lembra bastante o jogo Zelda do Nintendinho.