Arquivo

Archive for the ‘PHP’ Category

XML na Infraestrutura da Internet

Jewish law prohibited farmers from harvesting every last item from their fields.
If something was missed in the first pass, they were to leave it for the poor to harvest.
This was called gleaning. Gleaning provides a metaphor for good writing and teaching.
Don’t explain everything in complete detail. Leave something for the reader or student to harvest on their own.
From John Cook => https://plus.google.com/u/0/+JohnCook/posts/4UpWuws59oU

 

Introdução

 

Tenho insistido na ideia da aplicação de Web Semântica na Infraestrutura da Internet. Durante o, ainda em desenvolvimento desta ideia, uma questão parece evidente: o domínio da Infraestrutura da Internet é enorme e inexplorado sob a ótica da Web Semântica! Basta uma olhada na Figura 1, uma representação simplificada e parcial deste domínio, na qual, os principais agentes aparecem com algumas relações básicas. Tais agentes são os produtores das informações, isto é, dados que são produzidos e guardados em repositórios, geralmente, no formato texto com uma estrutura mínima. Há um texto em inglês, Preliminaries essays to research in Semantic Web applied to Internet Infrastructure, disponível em PDF, no qual, entre outras coisas, esclarece como os administradores de Sistemas Autônomos consomem estes dados, através de ferramentas orientadas a este fim. No “Preliminaries essays…”, a localização de alguns dos repositórios está representado em um cenário mais abrangente.

 

VisaoEntrelaçadaIPv6

Figura 1. Representação simplificada e parcial do domínio da Infraestrutura da Internet.

 

Ao procurar fixar o cenário, a maneira de pensar varia do geral para o particular e muitas vezes, também, do particular para o geral. Uma troca, sem limites usando refinamentos sucessivos, tanto no pensamento “top->down” como no “bottom->up”. Neste vai e vem da forma de pensar, o Mapa de Conceito4, exerce um papel fundamental, já que sua característica principal é a facilidade de representar o domínio do problema (ou do conhecimento), visualmente, simplificado e, direto. Existem vários mapas de conceito disponíveis, nos quais incluem os mapas mentais, que também fazem um bom trabalho. Neste texto, usamos o CMaps8 descrito sob o ponto de vista de suas aplicações. A Figura 1 e muitas outras que seguem foram, também produzidas, no CMaps.

Além das preocupações com o tamanho do domínio, a ausência de um vocabulário direto e aplicável ao domínio há outras. Entre estas outras, a linguagem para representar e permitir fácil acesso aos repositórios é um dos aspectos mais importantes. A base para tratar as aplicações de Web Semântica está na eXtensible Markup Language (XML), definida em [6] e é sobre ela que trataremos neste primeiro artigo.

 

A XML e a aplicação na delegação de IPv6

 

Sistemas Autônomos6 na Internet são identificados por um número denominado ASN (Autonomous System Number). Este número é controlado e distribuído pelo IANA (Internet Assigned Numbers Authority). A IANA (http://www.iana.org/about) é um departamento do ICANN (Internet Corporation for Assigned Names and Numbers). A IANA, também controla a distribuição de números IPv4 e IPv6, entre outras funções. O mecanismo de distribuição do IANA é do tipo atacado, isto é, ela distribui os números de AS, IPv4 e IPv6 para os RIR (Regional Internet Register), que por sua vez distribuem para os NIR (National Internet Register) ou diretamente para os interessados, quando não existir um NIR. Os RIRs são em número de cinco, cada um responsável por uma região do mundo (http://www.iana.org/numbers). Os RIRs são: AfriNIC, APNIC, ARIN, LACNIC e RIPE NCC. A IANA está, também, intimamente conectado com o IETF9. ICANN, IANA, IETF, números IPv4, números IPv6, números de ASes, RIRs, NIRs, Empresas, Instituições, Países, Pessoas e muitas outras coisas são parte dos “conceitos” associados ao domínio Infraestrutura da Internet, ou em outras palavras, ao vocabulário do domínio.

Para a aplicação da XML trabalharemos sobre um sub-domínio da representação exibida na Figura 1 (em laranja). Com o CMaps obtemos facilmente a derivação que pode ser vista na Figura 2.

 

DetalheIPv6

Figura 2. Detalhe da destinação de um bloco IPv6.

 

A representação fala por si mesmo. Em resumo, uma Empresa (digamos, um provedor) recebe um bloco de IPv6 sobre o qual estamos interessados. De posse deste bloco, um /32, o provedor planeja e designa sub-blocos a seus clientes e/ou usuários. Partindo da premissa de que a empresa tem muitos clientes, há necessidade de se criar um repositório do recurso (bloco IPv6) recebido, juntamente com as informações a ele associadas. Sobre este repositório uma série de operações conhecidas devem estar disponíveis. Uma abstração deste repositório e suas relações podem ser vistos na Figura 3.

 

RepositorioAbstrato

Figura 3. Representação abstrata de um repositório de registro de designação IPv6 e suas respectivas operações.

 

A abstração indica que o tal repositório pode ser, desde folhas de papel até um local (digital), onde se pode usar processos mais so fisticados, que tenham, por exemplo, um gerenciador de banco de dados relacional (digamos, MySQL). Vamos eliminar as soluções trabalhosas, como as folhas de papel, para procurar alternativas mais apropriadas sob o ponto de vista do acesso ao repositório e proporcionais a expectativa de tamanho deste repositório.

Faremos uma incursão sobre as soluções tradicionais, para depois seguirmos as técnicas que envolvem Web Semântica, nosso objetivo neste texto. Passemos, então, à descrição do contexto do problema desejado, com alguns detalhes importantes descobertos no planejamento.

 

Planejamento da distribuição de um bloco /32

 

Então, o provedor recebeu, do Registro.br, um bloco IPv6, que iremos supor como sendo o bloco dddd:dd00::/32. Depois de ler o artigo “Preparing an IPv6 Address”5 e o RFC 59321, cuidadosamente planejou a sua distribuição. Ele trabalhou tendo em mãos o Guia didático de Endereçamento IPv6. Assim, os números envolvidos tornaram fáceis de encontrar.

Ele dividiu este /32 em 65.536 blocos /48. Em seguida, achou adequado separar os primeiros 32.768 blocos para uso futuro e passou a pensar na segunda metade. Insistente reservou a primeira metade deste conjunto de blocos /48 (16.384), também, para uso futuro e passou a pensar sobre a divisão dos outros 16.384, da segunda metade, para que fosse distribuida a seus Clientes. O provedor calculou que na sequência deste conjunto de /48s, ele teria 1.024 x 16 blocos /48. Chamou cada um destes /48 de Disponibilidades e montou o seguinte esquema de distribuição:

  • Disponibilidade 0: dddd:dd00:c000::/48 a dddd:dd00:c00f::/48
    • dddd:dd00:c000::/48 ) Uso interno
    • dddd:dd00:c001::/48 ) Liberado
    • dddd:dd00:c00f::/48 ) Liberado
  • Disponibilidade 1: dddd:dd00:c010::/48 a dddd:dd00:c01f::/48
    • dddd:dd00:c010::/48 ) Cliente/Localidade 1
    • dddd:dd00:c011::/48 ) Liberado
    • dddd:dd00:c01f::/48 ) Liberado
  • Disponibilidade 2: dddd:dd00:c020::/48 a dddd:dd00:c02f::/48
    • dddd:dd00:c020::/48 ) Cliente/Localidade 2
    • dddd:dd00:c021::/48 ) Liberado
    • dddd:dd00:c02f::/48 ) Liberado
  • Disponibilidade 3: dddd:dd00:c030::/48 a dddd:dd00:c03f::/48
    • dddd:dd00:c030::/48 ) Cliente/Localidade 3
    • dddd:dd00:c031::/48 ) Liberado
    • dddd:dd00:c03f::/48 ) Liberado
  • 

  • Disponibilidades 4 ate 511
  • Disponibilidade 512: dddd:dd00:c2f0::/48 a dddd:dd00:c2 ::/48
    • dddd:dd00:c2f0::/48 ) Cliente/Localidade 512
    • dddd:dd00:c2f1::/48 ) Liberado
    • dddd:dd00:c2 ::/48 ) Liberado
  • 

  • Disponibilidades 513 ate 1022
  • Disponibilidade 1023: dddd:dd00: f0::/48 a dddd:dd00: ::/48
    • dddd:dd00: f0::/48 ) Cliente/Localidade 1023
    • dddd:dd00: f1::/48 ) Liberado
    • dddd:dd00: ::/48 ) Liberado

Quando esta divisão foi feita, o provedor tinha em mente o RFC 61773, não deixando de pensar que um de seus clientes poderia dividir o bloco /48 em /56 ou /60. Indo um pouco mais além fez recomendações para que seus clientes distribuíssem a seus usuarios, blocos /64. Como em cada /48 estão disponveis 65.536 redes /64, ele fez as seguintes recomendacões a seus Clientes:

    

  • Usar o primeiro bloco /64 para Loopback.
  • 

  • Deixar pelo menos 15 redes contíguas ao /64 designado (da mesma forma que o /48, acima).
  • 

  • Avaliar o uso de su fíxos relativamente fáceis de lembrar, para a rede interna (por exemplo: CA5A, FACA, …).

Tudo isto está mostrado gráfi camente na Figura 4, onde P é o prefixo dddd:dd00 e, h, i, j são dígitos hexadecimais dentro dos limites escolhidos. Por outro lado, a base de um planejamento em Infraestrutura da Internet é a topologia. Neste caso usamos a topologia da Figura 2.8 do texto Topologias, Interconexões e Protocolos.

E assim, a divisão do IPv6 deixou de ser um problema. Agora, a questão é identifi car uma maneira de como controlar as informações relacionadas com a designação dos IPv6 aos Clientes. Sem dúvida, qualquer solução envolve um local de armazenamento das informações, isto é, um repositório para os dados. A visão mais abstrata capaz de ilustrar tal ambiente, onde pessoas (usuários) possuem acesso, é a mostrada na Figura 3.

 

DivisaoIPv6

Figura 4. Representando o plano de divisão do bloco /32, graficamente.

 

Construindo o repositório com a XML

 

XML é uma linguagem livre. São poucas as restrições (sintáticas!) sobre ela. Desta forma, o estilo, a experiência e a criatividade individuais determinam a estrutura do repositório. Para este texto, o repositório em XML foi proposto como abaixo, de forma parcial e resumida:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<empresaX>
  <designacao_ipv6>
    <ip prefixo="dddd:dd00::" masc="/32">
      <ip prefixo="dddd:dd00::" masc="/48">
        <designado_para>Livre</designado_para>
      </ip>
      <!-- ... -->
      <ip prefixo="dddd:dd00:8::" masc="/48">
        <ip prefixo="dddd:dd00:8000::" masc="/48">
          <designado_para>Livre</designado_para>
        </ip>
        <!-- ... -->
        <ip prefixo="dddd:dd00:c000::" masc="/48">
          <designado_para>Livre</designado_para>
        </ip>
        <!-- ... -->
        <!-- 
            Grupo dos /48 designados 
        -->
        <ip prefixo="dddd:dd00:c001::" masc="/48">
          <designado_para>Livre</designado_para>
        </ip>
        <ip prefixo="dddd:dd00:c002::" masc="/48">
          <designado_para>Livre</designado_para>
        </ip>
        <ip prefixo="dddd:dd00:c003::" masc="/48">
          <designado_para>Livre</designado_para>
        </ip>
        <!-- ... -->
        <ip prefixo="dddd:dd00:c010::" masc="/48">      
          <designado_para>Localidade 1</designado_para>
          <fone>12-3922-xxxx</fone>
          <responsavel_t>Julião Braga</responsavel_t>
          <email>juliao AT SPAMFREE braga DOT eti DOT br</email>
          <comentarios>Utilizado na rede Interna</comentarios>        
          <ip prefixo="dddd:dd00:c010:0000::" masc="/64">
            <designado_para>Loopback</designado_para>
            <fone>12-3922-xxxx</fone>
            <responsavel_t>Julião Braga</responsavel_t>
            <email>juliao AT SPAMFREE braga DOT eti DOT br</email>
            <comentarios>Borda da Localidade 1</comentarios>          
          </ip>
          <ip prefixo="dddd:dd00:c010:0001::" masc="/64">
            <designado_para>Cliente 1</designado_para>
            <fone>37-xxxx-xxxx</fone>
            <responsavel_t>Fulano de Tal</responsavel_t>
            <email>nome AT SPAMFREE exemplo DOT com DOT br</email>
            <comentarios>Cliente do Provedor</comentarios>          
          </ip>
          <!-- ... -->
          <ip prefixo="dddd:dd00:c010:CA5A:" masc="/64">
            <designado_para>Rede Local</designado_para>
            <fone>12-3922-xxxx</fone>
            <responsavel_t>Julião Braga</responsavel_t>
            <email>juliao AT SPAMFREE braga DOT eti DOT br</email>
            <comentarios>Utilizado na rede local</comentarios>   
          </ip>
          <!-- ... -->
        </ip>
        <!-- ... -->
        <ip prefixo="dddd:dd00:c020::" masc="/48">      
          <designado_para>Localidade 2</designado_para>
          <fone>12-3922-xxxx</fone>
          <responsavel_t>Julião Braga</responsavel_t>
          <email>juliao AT SPAMFREE braga DOT eti DOT br</email>
          <comentarios>Utilizado na rede Interna</comentarios>        
          <ip prefixo="dddd:dd00:c020:0000::" masc="/64">
            <designado_para>Loopback</designado_para>
            <fone>12-3922-xxxx</fone>
            <responsavel_t>Julião Braga</responsavel_t>
            <email>juliao AT SPAMFREE braga DOT eti DOT br</email>
            <comentarios>Borda da Localidade 2</comentarios> 
          </ip>
          <!-- ... -->
        </ip>
      </ip>
    </ip>
  </designacao_ipv6>
</empresaX>

Pode-se concluir que o repositório tende-se a tornar muito grande. Entretanto, a partir da escolha inicial da estrutura (ou conjunto de marcadores), da XML, o processo é repetitivo, o que facilita o trabalho. As linguagens de programação (qualquer uma e em especial JavaScript) estão preparadas para trabalhar de maneira trivial sobre repositórios XML, o que facilitaria em muito as operações desejadas (Figura 3). Da mesma forma, os navegadores, imediatamente, representam de forma estruturada um arquivo XML, como pode ser visto na Figura 5.

 

XMLnoChrome

Figura 5. Repositório XML exibido no Chrome.

 

Não se pode esquecer que a W3C possui um recurso para validar um texto XML, bastante útil, que pode ser usado em Markup Validation Service.

Por outro lado, um banco de dados (repositório) XML possui uma organização hierárquica, como mostra a Figura 6.

 

XML-hierarquia

Figura 6. Organização hierárquica de um repositório XML.

 

A eficiência sobre um repositório com tais características depende não somente da hierarquia (ou arranjo dos marcadores) mas, também, do sistema de gerenciamento (programa) do repositório. Durante a etapa de programação, eventualmente, a hierarquia poderá ser aperfeiçoada.

 

Aperfeiçoando as ideias e, o projeto

 

Suponhamos que a ideia de um repositório XML para controlar as designações de IPv6 de um provedor tenha sido um sucesso. A notícia se espalha e um habilidoso programador, digamos, o Pedro Paulo (nosso programador fictício preferido…) resolve desenvolver um repositório para:

  • Atender a vários provedores e,
  • Controlar IPv6 e IPv4

Em uma primeira tentativa, a organização do repositório poderia ter a seguinte organização

 

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<repositorioIP>
    <empresaX>
        <blocoipv6 prefixo="dddd:dd00::" mascara="32" />
        <blocoipv4 prefixo="192.168.0.0/20" mascara="20" />
        <cliente id="201311281745">
            <nome></nome>
            <responsaveltecnico></responsaveltecnico>
            <fonenoc></fonenoc>
            <endereco>
                <logradouro></logradouro>
                <numero></numero>
                <complemento></complemento>
                <bairro></bairro>
                <cep></cep>
                <cidade></cidade>
                <estado></estado>
            </endereco>
            <ipv6designado></ipv6designado>
            <ipv4designado></ipv4designado>
            <observacoes></observacoes>
        </cliente>  
    
    </empresaX>
    
    <empresaY>
        <blocoipv6 prefixo="dddd:dd06::" mascara="32" />
        <blocoipv4 prefixo="192.168.16.0/20" mascara="20" />
        <cliente id="201311281754">
            <nome></nome>
            <responsaveltecnico></responsaveltecnico>
            <fonenoc></fonenoc>
            <endereco>
                <logradouro></logradouro>
                <numero></numero>
                <complemento></complemento>
                <bairro></bairro>
                <cep></cep>
                <cidade></cidade>
                <estado></estado>
            </endereco>
            <ipv6designado></ipv6designado>
            <ipv4designado></ipv4designado>
            <observacoes></observacoes>
        </cliente>  
    
    </empresaY>
</repositorioIP>

 

Este segundo modelo altera a hierarquia do primeiro. O componente mais importante do repositório é o marcador <cliente>, mas exige-se que os blocos delegados de IPv6 e IPv4 estejam presentes, mas dando liberdade em relação à presença dos marcadores debaixo do marcador mais importante. Uma visão mas agradável é a do navegador, mostrada na Figura 7, logo abaixo.

 

XML-RepositorioPedroPaulo

Figura 7. O novo repositório exibido no Chrome.

 

Ou, mais agradável ainda, a visão gráfica da hierarquia mostrada na Figura 8.

 

XML-hierarquia-PedroPaulo

Figura 8. Visão gráfica da hierarquia do segundo modelo (Pedro Paulo).

 

Embora imediado é oportuno observar, que a Figura 8 representa uma árvore (estrutura de dados). Navegar nesta árvore é um processo eficiente. Por exemplo, se procuramos pelas informações da Empresa 1, basta seguir os ramos abaixo dela, ignorando o restante dos nós à sua direita. Ou seja, qualquer operação a ser feita sobre o repositório (indicadas pela Figura 3) é estritamente localizada, portanto, muitíssimo eficiente.

Há, contudo, uma questão importunando ao Pedro Paulo. Os nomes dos marcadores de cada empresa / provedor são os mesmos e isto pode causar problemas de consistência ou de conflitos. Se o repositório fosse controlado à mão (por um ser humano), certamente poderíamos trocar um marcador, sem perceber, já que eles são idênticos. Mesmo desenvolvendo procedimentos para manipular automaticamente o repositório, a inconsistência prevalecerá. A linguagem XML possui na sua especificação, um mecanismo importante para garantir a consistência dos marcadores. É a técnica denominada espaço de nomes (do inglês, namespaces). Falaremos sobre ela em seguida, mas uma ótima introdução ao conceito pode ser visto em XML Namespaces.

 

Espaço de nomes em XML

 

O objetivo do espaço de nomes em XML é eliminar conflitos entre marcadores ou, em outras palavras, estabelecer a unicidade dos marcadores. Isto é feito através do atributo xmlns que distinguirá os prefixos a serem usados nos marcadores. O formato deste atributo é, xmlns:prefixo=”URI” colocado(s) no marcador inicial (raiz). URI (Uniform Resource Identifier) é uma cadeia de caracteres que identifica um Recurso da Internet. A URL (Uniform Resource Locator), usualmente usado por nós é um caso particular da URI. Na XML, a URI é simplesmente a caracterização da unicidade e não transporta nenhuma informação adicional.

Nos artigos seguintes veremos um papel mais preponderante do espaço de nomes. Por hora, o segundo modelo do repositório proposto e, a Figura 9, ilustram como ele se transforma, ao usar espaço de nomes, que comparando com a Figura 7 torna-se o entendimento imediatamente intuitivo.

 

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<repositorioIP 
    xmlns:x="http://ws.org.br/empresa/X"
    xmlns:y="http://ws.org.br/empresa/Y">
    
    <x:empresa>
        <x:blocoipv6 prefixo="dddd:dd00::" mascara="32" />
        <x:blocoipv4 prefixo="192.168.0.0/20" mascara="20" />
        <x:cliente id="201311281745">
            <x:nome></x:nome>
            <x:responsaveltecnico></x:responsaveltecnico>
            <x:fonenoc></x:fonenoc>
            <x:endereco>
                <x:logradouro></x:logradouro>
                <x:numero></x:numero>
                <x:complemento></x:complemento>
                <x:bairro></x:bairro>
                <x:cep></x:cep>
                <x:cidade></x:cidade>
                <x:estado></x:estado>
            </x:endereco>
            <x:ipv6designado></x:ipv6designado>
            <x:ipv4designado></x:ipv4designado>
            <x:observacoes></x:observacoes>
        </x:cliente>  
    
    </x:empresa>
    
    <y:empresa>
        <y:blocoipv6 prefixo="dddd:dd06::" mascara="32" />
        <y:blocoipv4 prefixo="192.168.16.0/20" mascara="20" />
        <y:cliente id="201311281754">
            <y:nome></y:nome>
            <y:responsaveltecnico></y:responsaveltecnico>
            <y:fonenoc></y:fonenoc>
            <y:endereco>
                <y:logradouro></y:logradouro>
                <y:numero></y:numero>
                <y:complemento></y:complemento>
                <y:bairro></y:bairro>
                <y:cep></y:cep>
                <y:cidade></y:cidade>
                <y:estado></y:estado>
            </y:endereco>
            <y:ipv6designado></y:ipv6designado>
            <y:ipv4designado></y:ipv4designado>
            <y:observacoes></y:observacoes>
        </y:cliente>  
    
    </y:empresa>
</repositorioIP>

 

Olhando um pouco mais atentamente a XML acima, surge uma questão sobre a qual vale a pena pensar: será que o atributo id, incluído nos marcadores <cliente> faz sentido diante da presença do espaço de nomes?

 

XML-NS-RepositorioPedroPaulo

Figura 9. O segundo modelo, com a unicidade dos marcadores garantida pelo espaço de nomes, visto pelo Chrome.

 

Considerações finais

 

Nada foi dito no artigo sobre as técnicas de programação para manipular repositórios em XML. Foge do escopo do texto, que se preocupou em mostrar algumas facilidades para planejar o uso dos recursos de numeração (IPv6 / IPv4) e a alternativa de estrutura-los em um repositório usando XML. A XML é uma linguagem orientada, principalmente, ao entendimento computador-computador (ou melhor, programa-programa), muito embora ela seja acessível a humanos. Dada à sua forma livre de expressão, presta-se a inúmeras aplicações úteis, como a do exemplo, documentar a distribuição de IPv6.

Sob o ponto de vista da Web Semântica, a XML é muito restrita para a necessária expressividade semântica, apesar de ser a base para as alternativas que serão abordadas nos próximos textos.

 

Referências

  1. S. Kawamura amd M. Kawashima. A Recommendation for IPv6 Address Text Representation. RFC5952. December 2008. Disponível em: http://www.rfc-editor.org/rfc/rfc5952.txt. Acessado em 02/10/2013.
  2. IHMC. Cmap tools. http://ftp.ihmc.us/. Acessado em 02/10/2013.
  3. T. Narten and G. Huston ant L. Roberts. IPv6 Address Assignment to End Sites, March 2011. RFC6117.
  4. Joseph D. Novak and D. Bob Gowin. Learning how to learn. Cambridge University Press, Cambridge, UK, 1 edition, 1984.
  5. SurfNet. Preparing an IPv6 Address Plan. Disponível em: https://www.ripe.net/lir-services/training/material/IPv6-for-LIRs-Training-Course/IPv6_addr_plan4.pdf. Acessado em: 02/10/2013.
  6. BRAY, T. et al. Extensible Markup Language (XML) 1.0 (Fifth Edition). W3C, 26 November 2008. Disponivel em: http://www.w3.org/TR/REC-xml/. Acesso em: 22 maio 2013.
  7. BRAGA, J. Sistemas Autonomos, Empresas Autônomas. Infraestrutura da Internet, 03 mar. 2006. Disponivel em: https://ii.blog.br/2006/03/03/sistemas-autonomos-empresas-autonomas/. Acesso em: 22 maio 2013.
  8. CAÑAS, A. J. et al. A Summary of Literature Pertaining to the Use of Concept Mapping Techniques and Technologies for Education and Performance Support. The Institute for Human and Machine Cognition. Pensacola, FL: The Chief of Naval Education and Training. 2003. p. 108.
  9. BRAGA, J. A ISOC, o IETF e a infraestrutura da Internet. Infraestrutura da Internet, 03 Janeiro 2013. Disponivel em: https://ii.blog.br/2013/01/03/a-isoc-o-ietf-e-a-infraestrutura-da-infraestrutura-da-internet/. Acesso em: 22 maio 2013.

Anúncios

Soquetes: PHP, IPv6 e inseguridade

 

Introdução

 

Soquete é um recurso muito interessante e bastante usado pelos programadores mais experientes. Soquete é usado quando se deseja conexão entre equipamentos por diversas razões, como por exemplo, se a expectativa é o controle mais refinado da comunicação entre sistemas operacionais diferentes. Este texto mostra algumas preocupações a serem levadas em conta quando a linguagem é o PHP. Tais preocupações devem induzir ao leitor, no final, que a programação do soquete, em si é razoavelmente simples. Mas a programação da aplicação é difícil.

 

Soquetes e o conceito Cliente-Servidor

 

O modelo Cliente-Servidor é inerente ao uso de soquetes. Os diagramas que apresentam os soquetes sempre são formais. Um bom exemplo pode ser visto em [1], onde há uma abstração do relacionamento entre o Cliente e o Servidor usando soquetes. Um diagrama mais refinado é mostrado na figura abaixo.

 

 

Um exemplo de um servidor completo, que aceita telnet, pode ser visto no sítio do PHP, em [2]. Um texto muito interessante, completo e exaustivamente discutido, com exemplos na linguagem C está em [3].

Um problema que ocorreu no exemplo do sítio do PHP, [2], em IPv4, foi o aparecimento de alguns caracteres adicionais, nos 5 primeiros textos que o Cliente enviava para o Servidor. Não consegui resposta para o problema, mas algumas pessoas diziam que se referia ao protocolo do telnet. Mas não apresentavam solução. No primeiro texto do Cliente para o Servidor, este prefixava algo como ÿþÿþ ÿþÿþ’ÿü e, outros caracteres eram adicionados, diminuindo o tamanho, até o quinto texto. A partir do sexto texto, não aparecia mais. A solução encontrada, foi usar a função substr para obter o texto original com base no caracter 22. Tal posição foi encontrada via algumas tentativas/erro.

Em IPv6, este problema não ocorreu. O tratamento IPv6 no PHP (soquete) precisa ser explicitado, no primeiro parâmetro da função socket_create(AF_INET6, SOCK_STREAM, SOL_TCP). Para IPv4, retira-se o 6. Fora a indiossincrasia do IPv4, tudo funcionou conforme o figurino. No final fiquei imaginando se o amadurecimento no desenvolvimento do IPv6 e seus aplicativos (do sistema) refletia estabilidade maior do que o IPv4. Pura conjectura, claro.

Programar o soque é simples, portanto. Há muita ajuda na Internet e googladas procurando por PHP irão trazer resultados interessantes. Mas, programar a aplicação do soquete é uma tarefa difícil. Quem tiver IPv6, pode testar o protótipo, bastanto usar o comando abaixo:

telnet -6 peony.pegasus.com.br 10000

Só irá funcionar, em IPv6! Tudo o que for digitado, exceto os resultados dos comandos descritos na “ajuda”, retornam ao Cliente.

 

Qual a dificuldade no desenvolvimento de programas e/ou aplicações usando soquetes?

 

Muitas!! O exemplo, que pode ser visto pelo telnet acima, é muito simples porque lida com a necessidade de conhecimento da linguagem PHP e as funções disponíveis para os soquetes. É uma questão de treino. A resposta à entrada meu ip, por exemplo, depende de uma função especial, socket_getpeername. Fora as questões abstratas dos manuais deve-se aprender o local onde ela será colocada e de como pode-se evitar a sua execução repetitiva, já que o servidor de soquete sobrevive dentro de alguns do…while(true). No exemplo em pauta foi usado o artifício da numeração das linhas de entrada. A criatividade pode nos remeter a outras soluções.

Por outro lado, a linguagem de entrada é demasiadamente simples e se encaixa no mais baixo nível da hierarquia das linguagens: uma linguagem regular. Além disso, a aplicação do exemplo, isto é, o Servidor usa uma regra básica de somente executar o que reconhece previamente (já que são poucos e bem definidos comandos), repassando de volta ao Cliente a entrada que ela não consegue interpretar. Contudo, uma aplicação, via de regra, tende a complicar o meio de campo participando daquele conjunto indesejável, da indecidibilidade. Há uma linha de pesquisa muito interessante, denominada “A ciência da inseguridade”, nomeada pelo Len Sassaman (morto prematuramente aos 31 anos), Meredith L Patterson, Sergey Bratus e outros. Vale a pena um atento olhar no sítio desta turma, em [4], para garantir que nossas preocupações estejam sólidas em relação aos problemas que ocorrem quando se deseja programar de forma segura. Este mesmo grupo expõe uma questão bastante convincente: protocolos são tão complexos (aka, BGP), que verificar se diferentes implementações atendem às especificações originais é um problema indecidível.

Por fim, se o Servidor for mais complexo no sentido de precisar de reconhecer muitos comandos ou de uma linguagem mais complexa, algumas regras serão observadas, até por recomendação do pessoal do projeto LANGSEC, como por exemplo garantir que o “reconhecedor” da entrada seja gerado por uma gramática, preferencialmente regular ou no máximo, livre de contexto (visível na Hierarquia de Chomsky, mostrada na figura abaixo). Além de outras recomendações, evidentemente!

Classificação de gramáticas formais, segundo Chomsky.

 

Referências

 


1. Wikipedia. Berkeley sockets. Wikipedia. [Online] [Citado em: 02 de março de 2012.] http://en.wikipedia.org/wiki/Berkeley_sockets.
2. The PHP Group. Sockets. PHP. [Online] [Citado em: 1 de março de 2012.] http://www.php.net/manual/en/book.sockets.php.
3. Hacking, Jon Erickson. Hacking. [trad.] Marcelo Madeira e Henriqueta Grubba. 1. São Paulo : Digerati Books, 2009. ISBN 978-85-60480-30-2.
4. Sassaman, Len, Patterson, Meredith L. e Bratus, Sergey. LANGSEC: Language-theoretic Security. [Online] http://langsec.org.

Meu ambiente de trabalho

Introdução

O tempo anda escasso, ultimamente. O de todo mundo, pelo que parece. Estou com dois artigos na agulha, um deles a continuação do último, sobre a conexão aos PTTs em IPv4 e IPv6. O outro é sobre um ano “quase” sabático, que me dei de presente, a partir de março de 2011. O ano “quase” sabático obrigou-me a preparar adequadamente o ambiente de trabalho. E vou descrevê-lo, por pura curiosidade, organização das idéias e reconher que, nas entrelinhas, será útil para muita gente. O bloque tem a vantagem de você escrever o que desejar para que leiam as pessoas que desejarem ler. No passado, chamávamos de “livre arbítrio”. Hoje seria mais prudente chamar de “escolha pessoal”. Geralmente, a “escolha pessoal” é baseada, EMHO, no conjunto de informações que um ser humano possui em sua cabeça, adquirida ao longo dos anos. Mas, o conjunto é complementado pela manipulação que o ser humano fez e faz, sistematicamente, do conhecimento adquirido. É uma questão um pouco mais complicada, pois vê-se, no dia-a-dia e na história, que este conjunto de conhecimento pode ser usado para o bem e para o mal.

O comentário da “escolha” aparece, a propósito de uma opinião que vi em um dos artigos do Silvio Meira onde, no debate alguém diz que uma pessoa é míope porque decide usar o Facebook. Em linhas gerais, justificou a miopia, pelo fato de que usar o Facebook está tornando mais rico o seu criador. É uma observação, a meu ver, sem propósito. Mas, trata-se de uma opinião. Não é possível preocupar-se com uma opinião (quando ela não é técnica), que você simplesmente não concorda. Minha escolha nestes casos é o da relevância. Se a opinião não técnica não for relevante ou não contribuir para o enriquecimento de minhas próximas escolhas, ignoro-a, no sentido de não participar do debate. Prefiro a visão shakesperiana: “A vida é uma simples sombra que passa (…); é uma história contada por um idiota, cheia de ruído e de furor e que nada significa”. Por outro lado, não acho que a história da miopia acima, qualifique um idiota. Pessoalmente, aperfeiçoei meu conhecimento, com a abordagem da opinião e na simples leitura. Sempre acontece, mesmo que inusitada.

Os recursos físicos

Tenho um “notebook” Dell Vostro 1320, com 8 GRam e um HD de 230 Gbytes. Localmente, tenho um “desktop” Intel Core 2 duo com 8 GRam e 2 HDs de 520 Gbytes. Remotamente, tenho uma outra máquina semelhante a este “desktop”. Para a Internet uso a Net com 10M de banda, que chega a 800 Kbps, medidos no SIMET do Nic.br. Para mim, a Net é uma provedora de serviços, no mínimo, irresponsável! Conectado à Net tenho um Mikrotik em uma máquina simples, com HD em “flash”, já há muitos anos.

No meu “notebook” tenho o Windows 7 Professional, em IPv4 e IPv6. O IPv6 é um túnel com a HE, que faço via anúncio de um /48 através do AS de minha empresa. Eventualmente, ativo uma VPN com um dos roteadores apropriados. Assim, consigo manter minhas configurações originais, onde estiver, em qualquer parte do mundo. Se não tenho Internet, mas há disponibilidade de celular, uso-a via meu iPhone. Complementarmente, tenho um “tablet” Samsung 8.1, que suporta alguns casos extremos e usado muito para leitura dos trabalhos em .pdf. Este conjunto de facilidades me satisfaz plenamente, no quesito de interconexão á Internet, que é o componente fundamental de trabalho e, via de regra, não me deixa ocioso, exceto quando for minha escolha. Fico ocioso, sempre, quando estou com meu neto querido.

As outras facilidade

Naturalmente, minhas maiores facilidades estão no “notebook”. Eis algumas delas:

  • Thunderbird: meu atual cliente de correio eletrônico. Não é meu preferido, infelizmente, mas dá para o gasto. Ele tem uma facilidade muito interessante que é o uso do PGP.
  • Browsers: Tenho quase todos, Chrome, Firefox, Explorer e Safari. Meu preferido é o Chrome. Antes era o Firefox, mas ultimamente com muitos problemas. Explorer só para alguns bancos, que não respeitam escolhas de seus clientes. Safari uso muito pouco, principalmente em testes de desenvolvimento.
  • Putty: minha principal ferramenta de ssh. É também, uma das mais importantes ferramentas de trabalho. Tenho outros, como o SCP, mas uso pouco.
  • Zope/Plone/Zeo: Uso pouco, no “notebook”. Somente para segurança de outros servidores, os quais uso muito.
  • Warftp: Insubstituível servidor de ftp. Entre outras funções ele é o principal componente de integração com o “tablet”. E, naturalmente, como integrador com os outros servidores.
  • PHPDesigner: Depois de muitos anos, há 5 uso-o preferencialmente. Está instalada, a versão 8. Não somente os programas em PHP, mas também, com editor de outras linguagens com C, Java e Perl, particularmente.
  • Wamp: Aplicação fantástica e simples, que implementa os servidores de MySQL, PHP, Apache em suas diversas versões, o que é muitíssimo útil.
  • Clientes para o MySQL: Tenho instalado o MuSQL Workbench, o MySQL Administrator e o MySQL-Front. Cada um com sua utilidade.
  • MikTex: Ferramenta preferida para os textos que preciso escrever em Latex. Ando me afastando um pouco do Latex e preferindo o Word. O Word é muito mais fácil para lidar, nos textos técnicos. O Latex é cansativo gerando muita perda de tempo na procura de compatibilidades. Mas, é insubstituível em alguns casos.
  • Office: Ótima ferramenta, pois domino-a. Além do Word sou usuário permanente do PowerPoint. Como não sou especialista em imagens, uso-o como intermediário para o aperfeiçoamento do que preciso, no Adobe Photoshop.
  • Adobe Photoshop: Para quem entende, deve ser uma maravilhosa ferramenta. Para mim resolve milhares de problemas relacionado com figuras, imagens, etc., que preciso no dia-a-dia.
  • eyeBean: Meu “softphone” preferido para testes e uso do FaleOK. Hoje tenho-o instalado no iPhone, também, e uso-o para receber e fazer chamadas via o FaleOK. Tenho números fixos em algumas cidades.
  • Wireshark: Eventualmente uso-o para avaliações e diagnósticos de problemas em redes. Pouca atividade, mas uma fantástica ferramenta, quando necessária.
  • Camtasia: Este e outros recursos estão associados a um Bamboo da Wacon, plugado em uma das USBs do “notebook”.
  • Enterprise Architect: Minha principal ferramenta de projetos e apoio ao desenvolvimento de idéias. Indescritível, os recursos disponíveis! É complexa e ao longo do tempo pode aperfeiçoar o uso.
  • FileZilla: Cliente preferido para ftp. Fica aberto o tempo todo no “notebook”.
  • Adobe Acrobat X: É um software de apoio. Usei-o muito quando meu orientador solicitou que os textos fossem feitos em Word e eu os fazia em Latex. Não entendi muito bem a razão dessa preferência já que existe hoje, o Adobe Reader X. Tal exigência, fez-me mudar em definitivo para o Word. No final, a mudança foi melhor e mais prática.
  • Skype: Há muito abandonei o MSN pelo Skype. Este é muito mais confortável e estável (pelo menos era, na época da escolha). Só uso o Skype para me comunicar com outros Skypes. Telefonia prefiro o FaleOK, muito mais flexível…
  • Segurança: Tenho vários anti-vírus e uso intensivamente o “firewall” do Windows 7.
  • VMWare: Ferramenta versátil e simples para criação de máquinas virtuais. Não fosse o VMWare não sei como poderia criar ambientes de testes, verificação de comportamento e integração (usualmente, em rede), de diferentes sistemas operacionais, tais como: Windows, Mikrotik, BSDs, Linux, etc. Cada um deles nas suas diversas versões.
  • CygWin: Ah! Grande achado! Tornou muito mais fácil lidar com o Windows, ao sair fora do “prompt”. Bem mais fácil!! Não se pode prescindir do CygWin, principalmente se você desenvolve com o apoio de “framework”, no Windows. Para se ter um exemplo, as duas figuras abaixo mostram o whois no CygWin e no Windows, respectivamente:

    Também, um recurso bastante valioso é o servidor sshd. Não tem preço!!

Finalmente, para ilustrar, eis a barra de tarefas do “notebook”:


Nos servidores local e remoto uso o FreeBSD (versão 9). Ambos possuem Apache2, MySQL5 e PHP5. Em ambos, como no “notebook” está instalado o Zope/Plone/Zeo. O Zeo admite perfeita integração entre os três, o que me deixa despreocupado em relação à segurança dos dados. No Plone local, mantenho toda e qualquer documentação de todos os servidores sob minha responsabilidade. Incluo todos os trabalhos em .pdf que mantenho em minha bibliografia no Word. Senhas (codificadas), IPs, v4 e v6 (uso a flecha para documentar), informações pessoais, agenda, etc., etc. O Plone é algo, também indescritível. Uso o Zope desde que ele apareceu pela primeira vez.

O servidor remoto tem um DNS escondido (Bind), que é “master” para um “master”, de um conjunto de outros servidores de dominio (autoritativos). Como recursivo, uso o Unbound no servidor local e em um outro servidor remoto.

Conclusão

O “notebook” tem suportado com altivez a demanda sobre ele. É claro que 16 GRam, no mínimo, com um processado I5 ou I7 seria o desejável. É o que provavelmente acontecerá em breve, espero. De resto estou muito feliz com meu ambiente, cuja foto parcial do local, segue abaixo!


Uma classe PHP-MySQL usando mysqli:__constructor e __destructor

 

Introdução

Programar é uma tarefa difícil. Difícil e trabalhosa. É uma arte, que exige experiência, dedicação, conhecimento, habilidade, criatividade, etc. O presente texto mostra, aos interessados, como preparar uma classe para manipular tabelas em bases de dados.

Há três recomendações para tornar a difícil arte, menos traumática:

  1. Refinamentos sucessivos
  2. Programação estruturada
  3. Programação Orientada a Objetos

Além das recomendações acima, a disciplina e o conhecimento das técnicas associadas a linguagens específicas são fundamentais. E as ferramentas, finalmente. Para base de dados uso o MySQL Workench e o MySQL Administator. Para editar os programas em PHP, uso o PHPDezigner e o Enterprise Architect para modelar meus projetos de desenvolvimento, em UML (Unified Modeling Language). Uso UML, também, para modelagem de negócios e modelagem de topologias de redes, de longa distância ou complexas, sobre as quais aplica-se os protocolos BGP, OSPF, RIP e associados (MPLS, por exemplo). A UML é ótima para modelar, inclusive, os componentes dinâmicos envolvidos em tais protocolos. Falo sobre tais ferramentas não porque sejam as melhores. As melhores ferramentas são aquelas com as quais você projeta e desenvolve seu estilo, de forma gratificante.

O principal objetivo deste trabalho é o desenvolvimento de programação orientada a objetos, em PHP. Usaremos o método direto, onde a didática tem valor significativo. Não é um texto para programadores muito experientes. É um texto para os iniciantes ou aqueles experientes interessados no aperfeiçoamento pessoal.

Construção da classe

Inicio as classes, usualmente, com três componentes: a propriedade (variável) que irá identificar o número de instâncias abertas, e os métodos construtor e destrutor. O método construtor conta as instâncias. E, um pequeno programa serve para testar cada etapa do processo de refinamento sucessivo. Eis a primeira versão, abaixo:

<?php
// Versão 1
class BancodeDados extends mysqli {
    
    static $idBancodeDados = 0;
    
    /**
     * Construtor:
     * 
     * 1. Conta o número de instâncias.
    */
    
    public function __construct() {
        self::$idBancodeDados++;        
    }
    
    public function __destruct() {
        --self::$idBancodeDados;
    }
}

Eis o teste e respectivo resultado:

<?php
// Versão 1
require_once ('../includes/funcoesgerais.phpm');
require_once ('../includes/db.phpm');

$db_faleok = new db();
echo "
Instâncias abertas: " . BancodeDados::$idBancodeDados; $db_faleok1 = new db(); echo "
Instâncias abertas: " . BancodeDados::$idBancodeDados; ?> Instâncias abertas: 1 Instâncias abertas: 2

O interessante a observar acima são os seguintes pontos:

  • A propriedade estática $idBancodeDados é incrementada no método __construtor, que como sabemos é executado na criação de uma instância da classe BancodeDados.
  • Uma propriedade estática é referenciada externamente como NomedaClasse::$NomedaPropriedade, pois ela pertence à própria classe.
  • A classe BancodeDados, herda métodos e funções da classe msqli, do PHP, uma vez que estamos usando extends mysqli, na sua declaração.
  • É bom lembrar, que o método __constructor não pode retornar valores. Esta noção será muito útil mais à frente. Entretanto pode-se observar que o exemplo acima ele altera o valor de uma propriedade estática, isto é, $idBancodeDados, que é como se fosse uma variável global.
  • O trecho:
    /**
     * Construtor:
     *
     * 1. Conta o número de instâncias.
    */
    

    é a documentação da classe. Como uso o phpdoc esta tarefa torna-se, em particular, muito importante.

Não se pode esquecer do registro de atividades. Foi construída uma classe chamada Mensagens que possui dois métodos. Um método exibe uma mensagem na tela, como acima, e o outro, grava a mensagem em um arquivo de “log”. Embora a classe Mensagens não seja exibida aqui (assim como outras que não a classe BancodeDados), o contexto a deixa claro. Eis como fica a versão 2 e seu resultado:

<?php
$db_faleok1 = new BancodeDados();
Mensagem = "Instâncias abertas: " . BancodeDados::$idBancodeDados;
$msg->Exibe();
$msg->LogFaleOK();

$db_faleok2 = new BancodeDados();
$msg->Mensagem = "Instâncias abertas: " . BancodeDados::$idBancodeDados;
$msg->Exibe();
$msg->LogFaleOK();

?>

20120121 11:55:43 - Instâncias abertas: 1
20120121 11:55:43 - Instâncias abertas: 2

As observações sobre a Versão 2 do teste são:

  • Aperfeiçoamos o nome das instâncias da classe BancodeDados, dando mais consistência visual ($db_faleok1 e $db_faleok2).
  • A mensagem é exibida com a data. Fica mais claro o exemplo, além do fato de que elas estão sendo registradas no “log”, para eventuais acessos futuros.

Melhor ficaria, se a saída fosse aperfeiçoada, como a versão 3 do teste:

<?php
Mensagem = "Teste da classe db, Versão 3";
$msg->Exibe();

$db_faleok1 = new BancodeDados();
$msg->Mensagem = "Instâncias abertas: " . BancodeDados::$idBancodeDados;
$msg->Exibe();
$msg->LogFaleOK();

$db_faleok2 = new BancodeDados();
$msg->Mensagem = "Instâncias abertas: " . BancodeDados::$idBancodeDados;
$msg->Exibe();
$msg->LogFaleOK();

?>

20120121 12:09:30 - Teste da classe db, Versão 3
20120121 12:09:30 - Instâncias abertas: 1
20120121 12:09:30 - Instâncias abertas: 2

O método direto exige algumas anotações sobre a Versão 3 do teste:

  • Retiramos o comentário // Teste x do início e deixamos somente na mensagem a ser exibida na tela. Evitamos duas alterações de versões.
  • A mensagem da versão só é exibida na tela. Não é registrada no “log”.
  • Já percebe-se que o método construtor executa, imediatamente, ao se definir uma instância da classe. Mas, não temos noção do momento no qual o método destrutor é executado. Geralmente é depois que o programa principal termina (no nosso caso, o testegeral.php), ou logo depois da execução de algumas instruções após a última instrução que atua sobre a instância de uma classe.

A fim de fixar bem a questão do destrutor, abaixo está a versão 2, da classe, na qual adicionamos comentários e alteramos o método __destruct incluindo dois comandos. O primeiro, subtraindo 1 da propriedade estática $idInstanciaDB, pois ela representa o número de instâncias. Destruir significa, também, não possuir nenhuma instância! Incluímos uma saída na tela, para imprimir o momento da destruição e somente mostramos os trechos importantes:

<?php

      .
      .
      .
class db extends mysqli {
    
    static $idBancodeDados = 0;
      .
      .
      .    
    public function __construct() {
        self::$idBancodeDados++;
    }
    
    public function __destruct() {
        --self::$idBancodeDados;
        echo '
Executou a destrutora as ' . date("Ymd H:i:s"); } } Mensagem = "Teste da classe db, Versão 4"; $msg->Exibe(); $db_faleok1 = new BancodeDados(); $msg->Mensagem = "Instâncias abertas: " . BancodeDados::$idBancodeDados; $msg->Exibe(); $msg->LogFaleOK(); $db_faleok2 = new BancodeDados(); $msg->Mensagem = "Instâncias abertas: " . BancodeDados::$idBancodeDados; $msg->Exibe(); $msg->LogFaleOK(); ?> 20120121 17:19:01 - Teste da classe db, Versão 4 20120121 17:19:01 - Instâncias abertas: 1 20120121 17:19:01 - Instâncias abertas: 2 Executou a destrutora as 20120121 17:19:01 Executou a destrutora as 20120121 17:19:01

Os comentários sobre o código acima:

  • Duas instâncias foram abertas, portanto, duas execuções de destrutores.
  • Os métodos destrutores foram executados em algum momento após o término do programa.

A versão final, completa e bem ilustrativa seria:

<?php

/**
 *  @author     JB 
 *  @version    2.0 (última revisão: Janeiro 18, 2012)
 *  @copyright  (c) 2005-2012 Julião Braga
 *  @license    No licence
 *  @package    Banco de dados
 *
 * 
 * Classe BandodeDados:
 * 
 */

class BancodeDados extends mysqli {
    
    static $idBancodeDados = 0;
    
    public $nome_da_base;
    
    /**
     * Construtor:
     * 
     * 
    */
    
    public function __construct() {
        self::$idBancodeDados++;        
    }
    
    public function __destruct() {
        --self::$idBancodeDados;    
    }
}

?>

Mensagem = "Teste da classe BancodeDados, Versão 4";
$msg->Exibe();

$db_faleok1 = new BancodeDados();
$db_faleok2 = new BancodeDados();

$msg->Mensagem = "1 Instâncias abertas: " . BancodeDados::$idBancodeDados;
$msg->Exibe();
$msg->LogFaleOK();

$db_faleok1 = NULL;

$msg->Mensagem = "2 Instâncias abertas: " . BancodeDados::$idBancodeDados;
$msg->Exibe();
$msg->LogFaleOK();

$db_faleok2 = NULL;

$msg->Mensagem = "3 Instâncias abertas: " . BancodeDados::$idBancodeDados;
$msg->Exibe();
$msg->LogFaleOK();
?>

20120122 14:20:25 - Teste da classe db, Versão 4
20120122 14:20:25 - 1 Instâncias abertas: 2
20120122 14:20:25 - 2 Instâncias abertas: 1
20120122 14:20:25 - 3 Instâncias abertas: 0

Eis as observações sobre o código acima:

  • A forma de executar o destrutor, para uma determinada instância da classe é: $nome_da_Instância->NULL;.
  • Executar ou não o destrutor é uma decisão do programador. Se o programador gosta de exercer o controle total sobre seu código, então ele mesmo destrói.

 

O próximo método

Uma questão aparece, imediatamente está relacionada com o velho dilema: “quem veio primeiro? O ovo ou a galinha? No nosso contexto:

  1. As informações sobre Bases de Dados remotas, geralmente são repassadas e há alguma dificuldade para alterar a senha original. Mas, o desejável, sob o ponto de vista da segurança é que a senha não seja conhecida nem mesmo pelo usuário da base. Em outras palavras, não se deseja ver a senha ou, na melhor das hipóteses, o menor número de pessoas deveriam ver a senha.
  2. Neste sentido, a senha pode ser complicada e deverá ser gerada automaticamente pela classe e alterada automaticamente pela classe, preferencialmente.
  3. Na mesma linha de raciocínio, as informações deveriam ser incluídas pela classe, devidamente criptografada, como é o desejo inicial.

Assim, o próximo método a ser criado é o insereDB, cujo objetivo é inserir na base as informações que serão passadas pelo usuário da classe. Eis o cabeçalho de tal método:

public function insereBD($nomeBD, $usuarioBD, $senhaBD, $hostBD, $portaBD, $descricaoBD, $email_criadorBD) {

// corpo do método
}

Os primeiros cinco parâmetros são autoexplicativos. O parâmetro $descricaoDB é uma descrição sucinta da base de dados e o parâmetro $email_criadorBD identifica o e-mail do “dono” da base, que será usado, para contato automático, em oportunidades sensíveis à segurança. O código abaixo é o refinamento preliminar, que antecederia o tratamento dos dados entrantes e a inclusão na tabela:

class BancodeDados extends mysqli {
    
    static $idBancodeDados = 0;
    static $BancodeDadosAbertos = array();
    
    private $_cripto;
    
    private $_caracteres;
    private $_maximo;
    private $_passwd;
    private $_nome; 
    private $_usuario;
    private $_senha;
    private $_host;
    private $_porta;
    private $_descricao;
    private $_email_criador;
    private $_senha_alternativa;
    private $_senha_alternativaBD;
    
    private $_bd;
    
    /**
     * Construtor:
     * 
     * 1. Verifica se o banco de dados já existe
     * 2. Se não existir cria, sem popular
     * 3. Se existir, abre
     * 4. {@usa: throw new DBConnectException($this->connect_error, $this->connect_errno);}
     *    para cobrir exceções
     * 
    */
    
    public function __construct() {
        self::$idBancodeDados++; 
                       
    }
    
    /**
        *   @author      JB 
        *   @version     1.0 (última revisão: Janeiro 18, 2012)
        *   @copyright   (c) 2005 - 2012 Julião Braga
        *   @license     No licence
        *   @package     funcoesgerais.phpn
        *   @nome        criaDB($nomeBD) 
        *   @funcao      Cria dados criptografados na tabela `basesdedados` da base faleok
        * 
        *   @Colunas:
        *       id_bd: INT
        *       nome_bd: VARCHAR
        *       usuario_bd: VARCHAR
        *       senha_bd: VARCHAR
        *       host_bd: VARCHAR
        *       porta_bd: VARCHAR
        *       descricao_bd: VARCHAR
        *       email_criador_bd: VARCHAR
        *       senha_alternativa: VARCHAR
        * 
    */
    public function insereBD($nomeBD, 
                             $usuarioBD, 
                             $senhaBD, 
                             $hostBD, 
                             $portaBD, 
                             $descricaoBD, 
                             $email_criadorBD) {
        
        $this->_cripto        = new cripto; 
        
        $this->_caracteres = 'abcdxywzABCDZYWZ0123456789@#*'; 

        $this->_maximo = strlen($this->_caracteres)-1;  
        $this->passwd = null; 
        mt_srand(make_seed()); 
        for($i=0; $i passwd .= $this->_caracteres{mt_rand(0, $this->_maximo)}; 
        }
        $this->_senha_alternativaBD = $this->passwd;
        
        $this->_nome          = $this->_cripto->encrypt($nomeBD); 
        $this->_usuario       = $this->_cripto->encrypt($usuarioBD);
        $this->_senha         = $this->_cripto->encrypt($senhaBD);
        //$this->_senha_alternativaBD = base_convert(mt_rand() , 10 , 16);
        $this->_host          = $this->_cripto->encrypt($hostBD);
        $this->_porta         = $this->_cripto->encrypt($portaBD);
        $this->_descricao     = $this->_cripto->encrypt($descricaoBD);
        $this->_email_criador = $this->_cripto->encrypt($email_criadorBD);
        $this->_senha_alternativa = $this->_cripto->encrypt($this->_senha_alternativaBD);
        
        // Tratamento dos dados
        
        echo "Aqui entra o código para imprimir o resultado apresentado na figura, logo abaixo";
            
        self::$BancodeDadosAbertos[self::$idBancodeDados] = $this->_cripto->decrypt($this->_nome);
        echo '
Indice do vetor de BancodeDadosAbertos: ' . self::$idBancodeDados . "...pre..."; print_r(self::$BancodeDadosAbertos); echo ".../pre..."; return true; } /** * * listaBDs() */ public function listaBDs() { return $bds; } public function __destruct() { --self::$idBancodeDados; //$this->_bd->close(); } } function make_seed() { list($usec, $sec) = explode(' ', microtime()); return (float) $sec + ((float) $usec * 100000); } <?php require_once ($_SERVER['DOCUMENT_ROOT'] . "faleok/includes/funcoesgerais.phpm"); $bd_faleok = new BancodeDados(); $nomeBD = "nomedoBD"; $usuarioBD = "usuarioautorizado"; $senhaBD = "teste"; $hostBD = "127.0.0.1"; $portaBD = "3306"; $descricaoBD = "BD de teste"; $email_criadorBD = 'usuario@exemplo.com.br'; echo '
Retorno do método; ' . $bd_faleok->insereBD($nomeBD, $usuarioBD, $senhaBD, $hostBD, $portaBD, $descricaoBD, $email_criadorBD); ?>

O resultado do programa acima pode ser visto na figura abaixo:


 

Os comentários são os seguintes:

  1. Uma outra propriedade estática foi incluída motivada pelo interesse em saber, para efeitos de gerenciamento e eficiência, quais as bases estão abertas em um determinado instante. É um “array” e sua atribuição é feita dentro do método insereBD:
    static $BancodeDadosAbertos = array();
    

    Já é possível antever um método listaDB, lembrado no códito, que informaria quais as bases abertas até o momento.

  2. Insistentemente, declaramos propriedades. Sempre que possível escondendo informações para outros componentes (encapsulamento), através do uso de private.
  3. A senha alternativa, isto é, aquela desconhecida de todos é gerada aleatoriamente, e com 15 caracteres, já que o ser humano não a manipula. Os algoritmos para isto estão disponíveis na Internet. Para aumentar a dificuldade, além dos 15 caracteres foi seguida a sugestão de usar um “alimentador” (‘make_seed’), para a função ‘mt_rand’, disponível no sítio do PHP. A função ‘make_seed’ está isolada no programa principal para, oportunamente, definir seu destino.

%d blogueiros gostam disto: