Lucas' Blog

Olá pessoas, ainda editarei esse post, contudo gostaria de divir uma classe que fiz para executar comandos de SO em java

Um abraço

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

}


Boa noite povo!!

Estou tendo aulas de Programação Orientada a Objetos em Java (lógico que preferiria que fosse Smalltalk ou Ruby, que são mais puramente orientadas a objetos e não precisam daquela carroça da Vm do Java instalada no meu note. Com efeito, tive que me inserir no mundo Sun/Oracle e me adaptar às funções do Java. Durante as aulas foi desenvolvido o conceito de Sockets que viha de encontro a comunicação de dois computadores atraves da rede por meio de aplicativos Java, que rodavam em deteminadas portas de um servidor.

Eu, na minha inocência, achei que tudo funcionaria lindamente no Linux, devido a instalação etc etc e tal. Mas para a minha surpresa, ao colocar o programa para rodar fui acometido por um problema persistente no Debian Squeeze que é a tentativa, por default, de tentar utilizar o endereço IPv6, conflitando assim com o endereço IPv4 geralmente proposto pelos exercicios em geral. Gerando a seguinte mensagem de erro

Network is unreachable

Todavia, há um código para desabilitar tal situação, que volta à opção de IPv4 por default:

sudo sed -i ’s/net.ipv6.bindv6only\ =\ 1/net.ipv6.bindv6only\ =\ 0/’ \

/etc/sysctl.d/bindv6only.conf && sudo invoke-rc.d procps restart

Foi retirado do Heikki Henriksen no site de bugs do debian

http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=560056

Espero que tenha ajudado a todos.

Um abraço

bool estr_binaria(Celula *T){
        if(!T -> dir  && !T -> esq)
                return true;
        if((!T -> dir && T -> esq) || (T -> dir && !T -> esq)
                return false;
        return(estr_binaria(T -> dir) && estr_binaria (T -> esq)
}

Bom galera.. vou postar para vcs o código de Arvore AVL que fiz hj… me baseei no código de arvore binária que eu jah tinha feito… seguem então os codigos

AVL.h

#include 
#include 
#ifndef AVL
#define	AVL

using namespace std;

namespace ED {

    template 
    class AVLTree {
    public:
        AVLTree();
        ~AVLTree();
        //metodos principais
        void insere(Tipo el);
        void percursoEmOrdem();
        void desaloca();
        int tamanho();
        int altura();

    private:
        class Celula {
        public:
            Tipo el;
            Celula *esq, *dir;
            char h;
            char b;
        };
        int height(Celula *x);
        void inorder_Walk(Celula *x);
        void removeCels(Celula *x);
        void balanceia(Celula *&x);
        void atualiza(Celula *&x);
        void rotateLeft(Celula *&x);
        void rotateRight(Celula *&x);
        void desaloca(Celula *x);
        void insere(Celula* &x, Tipo &el);
        Celula *T;
        unsigned int nelem, h;
    };

    //Construtor
    template 
    AVLTree::AVLTree() {
        T = new Celula;
        T->esq = NULL;
        T->dir = NULL;
        nelem = 0;
    }

    //Destrutor
    template 
    AVLTree::~AVLTree() {
        this->desaloca(T);
    }

    //Desaloca a arvore
    template 
    void AVLTree::desaloca() {
        desaloca(T);
    }

    //Desaloca a célula
    template 
    void AVLTree::desaloca(Celula *x) {
            if (x == NULL)
                return;
            else{
              desaloca(x->esq);
              desaloca(x->dir);
              delete x;
              atualiza(x);
              balanceia(x);
            }
    }

    //Balanceamento
    template 
    void AVLTree::balanceia(Celula *&x) {
         if (x->b == 2) {
            if (x->esq->b == -1) rotateLeft(x->esq);
               rotateRight(x);
         }
         else if (x->b == -2) {
              if (x->dir->b == 1) rotateRight(x->dir);
                 rotateLeft(x);
         }
     }

    //Atualização numero altura e balanceamento
    template 
    void AVLTree::atualiza(Celula *&x) {
         unsigned char hesq = x->esq? (x->esq->h) : 0;
         unsigned char hdir = x->dir? (x->dir->h) : 0;
         x->b = hesq - hdir;
         x->h = 1 + (hesq > hdir? hesq : hdir);
    }   

    //Rotação Direita
    template 
    void AVLTree::rotateRight(Celula *&x) {
         Celula *aux = x;
         x = x->esq;
         aux->esq = x->dir;
         x->dir = aux;
         atualiza(aux);
         atualiza(x);
    }

    //Rotação Esquerda
    template 
    void AVLTree::rotateLeft(Celula *&x) {
         Celula *aux = x;
         x = x->dir;
         aux->dir = x->esq;
         x->esq = aux;
         atualiza(aux);
         atualiza(x);
    }

    //Inserção
    template 
    void AVLTree::insere(Tipo el) {
      insere(T, el);
    }

    template 
    void AVLTree::insere(Celula* &x, Tipo &el) {
        if (!x) {
            x = new Celula();
            x->el = el;
            nelem++;
        } else {
            if (x->el >= el) insere(x->esq, el);
            else insere(x->dir, el);
            atualiza(x);
            balanceia(x);
        }
    }

    //Altura árvore
    template
    int AVLTree::altura() {
        return height(T);
    }

    //Altura célula
    template
    int AVLTree::height(Celula *x) {
        int esq, dir;
        if (x == NULL) return 0;
        esq = height(x->esq);
        dir = height(x->dir);
        if (esq > dir)
            return esq + 1;
        else
            return dir + 1;
    }

    //Número de elementos arvore
    template 
    int AVLTree::tamanho() {
        return (nelem);
    }

    //Remanescência BSTree ordenação
    template
    void AVLTree::inorder_Walk(Celula *x) {
        if (x == NULL) return;
        inorder_Walk(x->esq);
        cout << x->el << endl;
        inorder_Walk(x->dir);
    }

    template
    void AVLTree::percursoEmOrdem() {
        this->inorder_Walk(T);
    }

}

#endif

e o main.cpp (que foi o exercicio proposto pelo professor

#include 
#include 
#include "AVL.h"

#define T int

using namespace std;
using namespace ED;

int main(int argc, char** argv) {

    cout << "Arvore AVL."< *avl;
    avl = new AVLTree();

    for(int c=0; c<1023; c++){
      avl->insere(rand());
    }
    cout << "10"<< avl->altura() <desaloca();

    avl = new AVLTree();

    for(int c=0; c<32767; c++){
      avl->insere(rand());
    }
    cout << "15"<< avl->altura() <desaloca();

    avl = new AVLTree();

    for(int c=0; c<1048575; c++){
      avl->insere(rand());
    }
    cout << "20"<< avl->altura() <desaloca();

    avl = new AVLTree();

    for(int c=0; c<4194303; c++){
      avl->insere(rand());
    }
    cout << "25"<< avl->altura() <desaloca();

}

Tive alguns problemas com a questão das chaves de repositórios para utilizar alguns repositórios alternativos. O primeiro problema eu resolvi com esse código

 KEY= ; gpg –keyserver subkeys.pgp.net –recv $KEY ; gpg –export –armor $KEY | sudo apt-key add - 

Onde chave é a chave que aparece no erro
W: GPG error: http://www.site.com/ lenny Release: As assinaturas a seguir não puderam ser verificadas devido à chave pública não estar disponível: NO_PUBKEY EA8E8B2116BA136C

Logo o código seria esse:

 KEY= EA8E8B2116BA136C ; gpg –keyserver subkeys.pgp.net –recv $KEY ; gpg –export –armor $KEY | sudo apt-key add - 

Contudo, tive problemas para mexer no lenny backports e que o subkeys não encontrava tal repositório, no entanto a solução é mais simples do que parece. Basta apenas adicionar um pacote ao Debian que ele já encontra a chave dos repositórios backports

aptitude install debian-backports-keyring

Espero que tenha ajudado!
Um abraço

Bom, o ruby é uma linguagem que boa que nos permite fazer muitas coisas, desde pequenos scripts e programinhas simples como o anterior quanto uma aplicação web mais complexa como o twitter ou o yellowpages

Para trabalhar com esse tipo de aplicação é fundamental que o código seja testado para lhe garantir as suas funcionalidades. Pensando nisso criei um pequeno teste para o programa anterior, utilizando rspec. Peço que para rodar esse teste você intale a gema do rspec com o comando

gem install rspec

Após isso entre na pasta aonde você salvou o código anterior (/home/user/testeruby) e crie um outro arquivo chamado conta_spec.rb e cole o seguinte código

require 'spec'
require 'conta'

describe Conta do

  it 'deve criar uma conta com 1000 de saldo' do
    conta = Conta.new
    conta.saldo.should == 1000
  end

  it 'deve criar uma conta e fazer um deposito de 100 reais' do
    conta = Conta.new
    conta.deposito(100)
    conta.saldo.should == 1100
  end

  it 'deve criar uma conta e fazer uma retirada de 100 reais' do
    conta = Conta.new
    conta.retirada(100)
    conta.saldo.should == 900
  end

  it 'deve dar erro ao fazer uma retirada maior do que o saldo disponivel' do
    conta = Conta.new
    conta.retirada(1100).should == "Erro, saldo menor que a retirada"
  end

end

Agora entre no console e digite o seguinte comando

spec -c ~/testeruby/conta_spec.rb

Pronto! Você acabou de rodar o seu primeiro teste!!!

Esse mês entraram novas pessoas para trabalhar na area de desenvolvimento da UFABC, e eu comecei a lembrar dos meus primeiros contatos com o ruby, ainda sem conhecer o meta-framework rails. Bom irei postar um pequeno código parecido com o que o coordenador do desenvolvimento nos passou durante as primeiras aulas de ruby

Crie uma pasta para vc hospedar seus códigos

mkdir /home/user/testeruby por exemplo

Nesta pasta crie um arquivo conta.rb e copie e cole o codigo abaixo

class Conta

  attr_accessor :saldo

  def initialize
    @saldo = 1000
  end

  def retirada(retirada)
    if retirada > saldo
      return "Erro, saldo menor que a retirada"
    else
      @saldo = @saldo - retirada
      return @saldo
    end
  end

  def deposito(deposito)
    @saldo = @saldo + deposito
    return @saldo
  end

end

Foi um pequeno programa de saques e retiradas de uma suposta conta bancaria. Para brincar com ele basta criar um arquivo conta.rb no desktop, colar o código acima e salvar. Depois abra o konsole e abra a interface ruby irb, apenas digitando ‘irb’ no konsole, a partir daí escreva a seguinte linha de comando:

require '/home/user/testeruby/conta.rb'

caso esteja no linux (não esqueça de trocar user pelo seu usuário na máquina)

Esse codigo irá importar a classe Conta criada no código acima.

A partir daí digite

minhaconta = Conta.new
minhaconta.deposito(10)
minhaconta.retirada(50)
minhaconta.saldo
minhaconta.retirada(5000)
minhaconta.saldo 

e observe o funcionamento do programa. Após isso tente fazer mudanças, adicione novos métodos na classe, desenvolva a criatividade!!!

Um abraço!!

Sou aluno da UFABC e faço aula de Segurança de Dados com o prof° Carlos Kamienski e trabalhamos hoje na aula de firewalls e NAT, com o programa iptables que é nativo nas versões do Linux acima da 2.4.x. Esse programa define as regras para o aceitamento ou não de pacotes.

O que é um firewall?

Um firewall é um dispositivo que funciona como uma parede de fogo, que queima toda conexão entre redes que não lhe é permitida pelas regras  delimitadas. Um uso típico é situá-lo entre uma rede local e a rede Internet, como dispositivo de segurança para evitar que os intrusos possam acessar à informação confidencial.

Um firewall é simplesmente um filtro que controla todas as comunicações que passam de uma rede a outra e em função do que sejam permite ou denega seu passo. Para permitir ou denegar uma comunicação o firewal examina o tipo de serviço ao que corresponde, como podem ser o web, o correio ou o IRC. Dependendo do serviço o firewall decide se o permite ou não. No mais, o firewall examina se a comunicação está entrando ou saindo e dependendo da sua direção pode permití-la ou não.

Deste modo, um firewall pode permitir de uma rede local para a Internet serviços de web, correio e ftp, mas não a IRC que pode ser desnecessário para nosso trabalho. Também podemos configurar os acessos que se fazem desde a Internet para a rede local e podemos denega-los todos ou permitir alguns serviços como o da web, (se é que possuímos um servidor web e queremos que seja acessível pela Internet). Dependendo do firewall que tenhamos também poderemos permitir alguns acessos à rede local desde a Internet se o usuário tiver se autenticado como usuário da rede local.

Um firewall pode ser um dispositivo software ou hardware, ou seja, um aparelhinho que se conecta entre a rede e o cabo da conexão à Internet, ou então um programa que se instala na máquina que tem o modem que conecta com Internet. Inclusive podemos encontrar computadores muito potentes e com softwares específicos que o único que fazem é monitorizar as comunicações entre redes.

O jeito certo “right mode” para fazer o firewall consiste no modo como é feito aqui na UFABC, onde por padrão todos os pacotes são negados, ou seja, caso venha um pacote que não está no conjunto de regras delimitados no iptables, ele os descarta por padrão, evitando assim o uso de portas estranhas e programas com malwares.

Iptables

O Iptables é um programa de firewall nativo nas versões do linux que contém o kernel maior que 2.6.20, e funciona a partir da delimitação de um conjunto de regras, executadas apenas com o acesso de root no sistema. Abaixo segue alguns comandos com uma breve explicação em português :

iptables [-t tabela] comando [regra [regra estendida]] [opção <parametro> [-] alvo]

- t <tabela> / Parâmetro opcional que especifica a tabela. O default é a tabela filter

Comando

Algumas operações com as cadeias:

-N | –new-chain <chain> /  Cria uma cadeia definida pelo usuário
-F | –flush [<chain>] / Apaga conteúdo da cadeia, ou de todas as cadeias se nenhuma for especificada
-X | –delete-chain [<chain>] /  Remove a chain, ou todas as chains se nenhuma for especificada
-P | –policy <chain><policy> /  Define a política padrão de uma das chains pré-definidas INPUT, OUTPUT, FORWARD como ACCEPT ou DROP
-L | –list [<chain>] /  Lista as regras de uma chain, ou de todas as chains se nenhuma for especificada
-h | <comando> -h /  Lista os comandos e opções do iptables, ou se precedida por um comando lista a sintaxe e opçoes do comando

Regra

Algumas regras:

-p ou – protocol <protocol> / Define o protocolo de rede Ex: tcp, udp, or icmp)
-s ou –source <address/mask> / Define o endereço ou a máscara que envia o pacote (Ex: 200.133.70.5)
-d ou –destination <address/mask>/ Define o endereço ou a máscara a quem será enviado o pacote (Ex: 200.133.70.5)

Operações com regras:

-A | –append <chain> / Adiciona uma regra no fim da chain
-I | –insert /  Insere uma regra no início da chain
-D | –delete <chain> <num regra> /  Apaga a regra da chain na posição <num regra>

Exercicio 4
Exercicio 5
Exercicio 6 – parte 1
Exercicio 6 – parte 2

Bom, vou escrever mais uma experiência minha com Linux durante essa semana.

Desde que comecei a usar Linux(há 8 meses) por conta do desenvolvimento em ruby no lugar onde trabalho, tive que aprender a usá-lo(ainda não sou lá um bom usuário, mas jah estou, pouco-a-pouco me virando) na disto Debian versão Lenny , e aprender a instalar plugins e aplicativos para mexer com os sistemas que trabalho e tambem me atender nas horas que não tenho tarefas(coisa rara), onde estou conseguindo criar coisas que me ajudam no desenvolvimento, como uma pequena alteração no plugin do carlos brando de notificação de autoteste, dentre outras coisas, que aparentemente possam parecer insignificantes, mas me ajudam a aprender muitas coisas e facilitam o meu trabalho.

Bom hoje vou falar do Enlightenment, que é uma interface gráfica linux. Tudo começou com o coordenador da parte de desenvolvimento, o Mauricio, que é o unico que não usa nem o KDE nem o Debian (Ele usa gentoo com enlightenment). Desde um 3 meses atrás que eu estou tendo um pouco mais de contato com ele, pois eu sento na mesa ao lado da dele, reparo vez ou outra que a interface enlightenment me parece muito mais funcional do que o próprio KDE, além de eu, particularmente achá-la mais bonita. Bom vou descrever o que fiz para instalar a interface.. foi um processo muito simples e muito rápido

Adicionei os repositórios abaixo no /etc/apt/sources.list

# Enlightement
deb http://packages.enlightenment.org/debian lenny main extras
deb-src http://packages.enlightenment.org/debian lenny main extras
deb http://www.vobcopy.org/mirror/elive/ elive main efl elive

rodei o

# apt-get update

Utilizei o comando abaixo para achar as chaves dos repositorios, substituindo o <chave> pela chave do repositorio

KEY=<chave> ; gpg –keyserver subkeys.pgp.net –recv $KEY ; gpg –export –armor $KEY | sudo apt-key add -

E rodei o comando

# aptitude install e17 e17-data e17-dev

Pronto! Instalei o Enlightenment! Mas ele parece meio inutil a primeira vista, então tive que aprender a configurá-lo

Configurando, bom a primeira coisa que fiz, foi adicionar um atalho para o “executar comando”.

Clique com o botão esquerdo na tela entre no menu Configurações > Settings Panel , ai aparecera uma janela, rode o menu de cima até achar o menu input. Então irá aparecer o sub-menu atalhos do teclado, clique nele, ai vc jah pode configurar a sua interface gráfica do jeito que quiser!!!

Segunda coisa que fiz, adicionar o firefox!

Já possuia o firefox intalado contrudo não conseguia fazer um icone dele que fosse intuitivo

Então entrei novamente na janela de configurações fui ao menu apps, cliquei em nova aplicação, criei a aplicação do firefox, com o executável , nome e icone e depois fui ao aplicativos do Ibar que está no mesmo menu apps e selecionei o aplicativo do firefox no menu esquerdo, cliquei em adicionar e depois em ok e pronto! jah tinha o firefox no menu do Enlightenment heheeh!!!

Bom por enquanto eh soh.. se eu lembrar de algo ainda editarei esse post!!