Tutorial Shell - Parte 3

Nessa terceira parte do tutorial será possível entender como redirecionar a execução de um comando. A execução de um comando uma entrada e dois tipos de saídas:

Entrada padrão é representada por:  <

Saída padrão é representada por: >

E a saída com erro que é representada por: 2>

Então um comando simples que lista os diretórios de modo recursivo como: ls –R

Poderá ser redirecionado para um arquivo de texto onde é possível definir um nome qualquer.

Isso pode ser feito através do comando de redirecionamento:

ls – R > listagem.txt

Um comando simples pode ser usado para exibir o conteúdo do arquivo. Este comando é o: cat

Exemplo:

cat listagem.txt

Um novo arquivo sempre será criado sempre que for executado o: >

Se for necessário adicionar mais alguma coisa ao arquivo criado então deve se usar o comando duplicado: >>

No caso: ls /home >>listagem.txt

Seria acrescentado ao final do arquivo a listagem do diretório /home

O mesmo pode ser feito para a saída de erros caso exista: ls –R 2> erros.txt

Os erros podem ser verificados com o comando: cat erros.txt

Outra opção de visualização seria usar um comando para enumerar as linhas: nl

No caso:  nl erros.txt

Ou usar o comando: more erros.txt

Que vai mostrar por página. No comando more o enter pode auxiliar, assim como a barra de espaços.

Tutorial Shell - Parte 2

O Shell é uma linguagem muito simples de se programar. Os comandos são numerosos, porém os comandos de uso mais básico não são tantos e com poucas linhas de comando já é possível fazer um arquivo em ShellScript que consiste em uma seqüência de comandos num arquivo salvo com a extensão .sh: nomedoarquivo.sh

Serão listados, abaixo, os comandos mais básicos:

 Exibe uma lista do conteúdo do diretório atual: ls

Mostra os arquivos ocultos durante a listagem: ls –a

Traz as permissões dos arquivos:  ls –l

Redundância dos comandos anteriores: ls –La

Usa recursividade (busca sub diretórios): ls -lR

Criar pastas: mkdir nomedapasta

Pode criar mais de uma pasta simultaneamente: mkdir pasta1 pasta2

Cria pastas em subdiretórios caso eles não existam: mkdir pasta3/pasta4

Uso do Parent (-p): mkdir pasta5/pasta6 pasta5/pasta7 –p

Contra barra indica espaço: mkdir pasta\8

Touch cria arquivo ou altera data de modificação: touch novoarquivo.doc

Copia arquivo: cp novoarquivo.doc /tmp/

Indica o destino local: cp /tmp/novoarquivo.doc .

Move arquivo: mv novoarquivo.doc /tmp/novoarquivo

Troca de diretório: cd nomedodiretorio

 cd /nomedodiretorioapartirdaraiz

Acessa diretorio Home: cd ~

Retorna para a pasta anterior: cd –

Busca por parte do nome do comando: apropos cd

Mostra histórico dos comandos executados: history

Tutorial Shell - Parte 1

O Shell é a linguagem nativa dos sistemas *nix mais conhecidos como Linux. A principal característica do Linux é o controle de permissão. Cada arquivo possui um dono que geralmente é o usuário que está conectado no momento da criação do arquivo. Cada usuário, assim como todo o arquivo deve possuir um grupo mesmo que seja um grupo padrão da máquina. Além dos grupos de usuários existe também um super usuário que tem todo o controle da máquina que é conhecido como root. Então, para se manipular um arquivo é preciso que se tenha permissão, caso contrário o arquivo não será acessível. Este quesito eleva o Linux na questão segurança.

Basicamente existem 3 formas de se manipular um arquivo: leitura (r – read), escrita (w – write) e execução (x – execute).

Essas permissões de arquivos são exibidos na seguinte seqüência: proprietário do arquivo, grupo do usuário do arquivo, outros usuários.

 o (other)  – g (group) – a (all)

  Levando em consideração o tipo de permissão:

other (rwx)- group(rwx)- all(rwx)

É possivel visualizar as permissões dos arquivos abrindo um terminal e listando os arquivos através do comando: ls –l

-rwxrwxrwx nomedo arquivo

 drwxrwxrwx nomedodiretório

O d no início indica que é um diretório e não um arquivo. Onde a letra da permissão é substituída por um traço sabe-se a permissão para aquele tipo de evento está bloqueada.

Por exemplo:

 rw- indica a impossibilidade de executar o arquivo pois o x foi substituído por um traço. No entanto, é possível ler(r)  e escrever (w) no arquivo

Um exemplo mais completo

-rw-rw-rw-  indica que nenhum usuário pode executar o arquivo

-rwxrwxrw- indica que terceiros não podem executar o arquivo, porem o dono pode e o grupo tambem

-rwxrwx--- indica que terceiros não possuem nenhuma permissão sobre o arquivo, porem o dono e o grupo possuem

-rwx------ indica que somente o dono possui permissão sobre o arquivo, o grupo e terceiros não possuem nenhuma permissão

Essas permissões podem ser alteradas pelo dono do arquivo e pelo usuário root através do comando chmod

Comando para adicionar permissão de execução ao arquivo: chmod +x nome do arquivo

O rwx podem ser substituídos por um numero da seqüência binária 421 Onde o r=4, w=2 e x=1. Então para se criar uma permissão específica é utilizado a soma entre eles para indicar o tipo de permissão. O mesmo acontece para os três grupos de usuário. Então se eu quiser dar permissão somente de escrita e leitura a soma correspondente seria 6. Assim como para retirar todas as permissões seria zero.

chmod 760 nomedoarquivo

Ao dar o comando ls –l então teremos

-rwxrw---- nomedoarquivo

Onde o 7 representa a permissão do dono, o 6 a permissão do grupo e o 0 a permissão de terceiros.

 

Executando Comando Shell pelo Java - Parte 2

Através do conceito de chamada de execução Shell pelo Java (comando Runtime.exec("nome do comando"); ) construí um aplicativo com uma interface grafica para rodar comandos em Dos e Shell através do Java. Segue o código que deve ser exportado num arquivo jar executável.

import javax.swing.*;

import java.awt.event.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class CordaoUmbilical extends JFrame implements ActionListener {
    /**
     * @since 27/09/2011
     */
    private static final long serialVersionUID = -4400536034133334969L;
    JButton b1;
    JFrame frame;
    JPanel panel;
    JTextArea textArea;
    JTextField textField;
    JScrollPane spane;

    public static void main(String[] args) {
        CordaoUmbilical v = new CordaoUmbilical();
    }

    public CordaoUmbilical() {

        b1 = new JButton("Comando");
        b1.setMnemonic(KeyEvent.VK_A);
        b1.setActionCommand("Run");
        b1.addActionListener(this);
        b1.setToolTipText("Click neste botão para " + "executar o comando");
        frame = new JFrame("Janela de Comando");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        panel = new JPanel();
        textArea = new JTextArea(30, 60);
        spane = new JScrollPane(textArea);
        spane.getHorizontalScrollBar();
        spane.getVerticalScrollBar();
        textField = new JTextField(10);
        panel.add(textField);
        panel.add(b1);
        panel.add(spane);
        frame.add(panel);
        frame.setSize(800, 600);
        frame.setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        String entrada = textField.getText();
        try {
            Process p = Runtime.getRuntime().exec(entrada);
            StringBuffer str = new StringBuffer();
            BufferedReader in = new BufferedReader(new InputStreamReader(
                    p.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                str.append(line + "\n");
            }

            textArea.append(str.toString() + " ");
            textField.selectAll();

        } catch (Exception e2) {

            for (StackTraceElement iterable_element : e2.getStackTrace()) {
                textArea.append(iterable_element.toString() + "\n");
            }
            JOptionPane.showMessageDialog(null, "Digite um comando válido!",
                    "Erro de execução", JOptionPane.ERROR_MESSAGE);
        }

    }

}

Executando Comando Shell pelo Java - Parte 1

Através do conceito de chamada de execução Shell pelo Java (comando Runtime.exec("nome do comando"); )  pode ser feito muita coisa. A sugestão é jogar o código no Eclipse IDE e testar alguns comandos. O próximo passo é construir uma ferramenta.

import java.io.IOException;
import java.io.InputStream;

  public class ShellInJava{
     
      public static void main(String args[]) { 
 
           try { 
              
                Process p = Runtime.getRuntime().exec(new String[] { "ls", "-l", "-a", "-p" }); 
                 
                InputStream in = p.getInputStream(); 
                int b = in.read(); 
                while (b != -1) { 
                    System.out.write(b); 
                    b = in.read(); 
                } 
           } catch (IllegalAccessError e) { 
               e.printStackTrace(); 
           } catch (IOException e) { 
               e.printStackTrace(); 
           } catch (Exception e) { 
               e.printStackTrace(); 
           }
      }  
   }

Socket em Java

No servidor.java coloque o seguinte codigo. O servidor deve rodar primeiro e aguardar o cliente conectar.


import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class Servidor {
    public static void main(String[] args) throws IOException {
       
        ServerSocket servidor = new ServerSocket(15000);
        System.out.println("Porta 15000 aberta");
       
        Socket cliente = servidor.accept();
        System.out.println("Nova conexao com o cliente " +
        cliente.getInetAddress().getHostAddress());
       
        Scanner entrada = new Scanner(cliente.getInputStream());
       
        while(entrada.hasNextLine()) {
            System.out.println(entrada.nextLine());
        }
       
        entrada.close();
        servidor.close();
       
    }
}

No cliente.java o seguinte arquivo deve ser executado:


import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Cliente {
   
    public static void main(String[] args)
        throws UnknownHostException, IOException {

        Socket cliente = new Socket("192.68.1.46", 15000);
        System.out.println(cliente.getInetAddress().getHostAddress());
        System.out.println("O cliente se conectou com o servidor");
       
        Scanner teclado = new Scanner(System.in);
        PrintStream saida = new PrintStream(cliente.getOutputStream());
       
        while(teclado.hasNextLine()) {
            saida.println(teclado.nextLine());
        }
       
        saida.close();
        teclado.close();
   
    }
}


O ideal da conexão com o socket é através do uso de Threads (gerenciador de processamento) pois desta maneira cliente e servidor podem trocar dados através de um duplo socket, sendo um de envio e o outro de transmissão.

Trabalhando com Datas no PHP

A forma mais comum de se tratar datas no PHP é o comando date() que além de capturar a data atual do sistema também faz conversão do tipo de dado do formato Date para um formato em String.

$today = date("F j, Y, g:i a");                 // March 10, 2001, 5:16 pm
$today = date("m.d.y");                         // 03.10.01
$today = date("j, n, Y");                       // 10, 3, 2001
$today = date("Ymd");                           // 20010310
$today = date('h-i-s, j-m-y, it is w Day');     // 05-16-18, 10-03-01, 1631 1618 6 Satpm01
$today = date('\i\t \i\s \t\h\e jS \d\a\y.');   // it is the 10th day.
$today = date("D M j G:i:s T Y");               // Sat Mar 10 17:16:18 MST 2001
$today = date('H:m:s \m \i\s\ \m\o\n\t\h');     // 17:03:18 m is month
$today = date("H:i:s");                         // 17:16:18

echo $today ; // imprime o valor da data

Ou é possível usar a chamada date() direta sobre a data.

O tipo de dado deve ser uma data por isso a funçao strtotime()

echo date("YW", strtotime("2011-01-01"));

Outra opção seria trabalhar com vetores e Strings. Eu uso uma função passando um parametro 0 para formato do banco de dados e parametro 1 para formato de exibição na tela.

function convertedata($dataform, $tipo){

  if ($tipo == 0) {

     $datatrans = explode ("/", $dataform);

     if (strlen($datatrans[1])==1){

       $datatrans[1]="0".$datatrans[1];

     }

     if (strlen($datatrans[0])==1){

       $datatrans[0]="0".$datatrans[0];

     }

     $data = "$datatrans[2]$datatrans[1]$datatrans[0]";

  } elseif ($tipo == 1) {

     $datatrans = explode ("-", $dataform);

     $data = "$datatrans[2]/$datatrans[1]/$datatrans[0]";

  } elseif ($tipo == 2) {

     $datatrans = explode ("%3A", $dataform);

     $data = "$datatrans[0]$datatrans[1]";

  } elseif ($tipo == 3) {

     $datatrans = explode ("-", $dataform);

     $data = "$datatrans[2]/$datatrans[1]/$datatrans[0]";

  }

  return $data;

}