Skarllot's Blog

Configurações de /proc/sys/net/ipv4/route

Fabrício Godoy — Tue, 07 Sep 2010 01:46:08 +0000

Vou falar um pouco das configurações de roteamento disponíveis em /proc/sys/net/ipv4/route.

error_burst: Define, em interrupções de timer, o tempo máximo contabilizado para exibir uma mensagem. O valor predefinido corresponde a 5 segundos.

error_cost: Define, em interrupções de timer, o tempo mínimo para exibir uma mensagem. O valor predefinido corresponde a 1 segundo.

Os valores predefinidos de error_burst e error_cost limitam a uma mensagem a cada 5 segundos.

flush: Escrever nesse arquivo faz com que o cache de roteamento seja descartado.

gc_elasticity: É usado para definir o tamanho médio da lista de rotas, quando excedido a coleta de lixo na tabela de rotas se torna muito agressiva. (ver)

gc_interval: Define, em segundos, o intervalo entre coletas lixo na tabela de rotas. Existe uma recomendação para que a coleta não seja muito frequente pois é muito pesada (ver).

gc_min_interval: Obsoleto, usar gc_min_interval_ms. (ver)

gc_min_interval_ms: Define, em milissegundos, o intervalo mínimo entre coletas (ver). Predefinido em 500 milissegundos.

gc_thresh: Define a quantidade mínima de rotas para que rotas comecem a ser descartadas na coleta de rotas. (ver)

gc_timeout: Define, em segundos, o tempo máximo que uma rota é mantida. A rota é descartada mesmo se está em uso (ver). Predefinido em 300 segundos.

max_size: Define o número máximo de rotas a serem mantidas. As rotas mais antigas serão descartadas quando o número máximo é alcançado.

min_adv_mss: Define, em bytes, a quantidade mínima de dados pode ser enviada em um segmento (ver). Predefinido em 256 bytes.

min_pmtu: Define, em bytes, o valor mínimo de PMTU permitido. Se o valor descoberto for menor então o valor mínimo definido aqui prevalece. (ver) Predefinido em 552 bytes.

mtu_expires: Define, em segundos, o tempo que o PMTU de uma rota é mantido em cache (ver). Predefinido em 600 segundos.

redirect_load: Define um tempo mínimo entre tentativas de redirecionamentos ICMP, por rota. (ver)

redirect_number: Define o número máximo de redirecionamentos ICMP ignorados, por rota. (ver, ver)

redirect_silence: Define, em interrupções de timer, o tempo máximo de espera por um redirecionamento ICMP. Após esse tempo é enviada um novo redirecionamento, mesmo que o mesmo tenha sido ignorado por causa de redirect_load ou redirect_number. Predefinido em 20,48 segundos.

secret_interval: Define, em segundos, o intervalo entre descarregamento de cache. Predefinido em 600 segundos.

As informações encontradas aqui podem estar incorretas, pois se baseiam em minhas conclusões.

Referências:

Documentação do sistema de arquivos /proc: http://www.linuxinsight.com/proc_sys_net_ipv4_route.html
Configurações do kernel obscuras: http://lartc.org/howto/lartc.kernel.obscure.html
Determinando a quantidade de interrupções de timer: http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1005802
PMTU: http://www.netheaven.com/pmtu.html

Dividir um PDF com página dupla em dois

Fabrício Godoy — Sun, 18 Jul 2010 02:47:27 +0000

Abaixo publico um código Perl que divide verticalmente cada página em duas páginas.
Um caminho para o arquivo PDF deve ser fornecido como argumento e o arquivo dividido será criado no mesmo local.

Instale o PDF-API2 (pacote libpdf-api2-perl no Debian/Ubuntu ou perl-PDF-API2 no RHEL/CentOS/Fedora).

Arquivo split_pdf.pl:

#!/usr/bin/env perl

use strict; use warnings;

use PDF::API2;

my $filename = shift || 'test.pdf'; my $oldpdf = PDF::API2->open($filename); my $newpdf = PDF::API2->new;

for my $page_nb (1..$oldpdf->pages) { my ($page, @cropdata);

$page = $newpdf->importpage($oldpdf, $page_nb); @cropdata = $page->get_mediabox; $cropdata[2] /= 2; $page->cropbox(@cropdata); $page->trimbox(@cropdata); $page->mediabox(@cropdata);

$page = $newpdf->importpage($oldpdf, $page_nb); @cropdata = $page->get_mediabox; $cropdata[0] = $cropdata[2] / 2; $page->cropbox(@cropdata); $page->trimbox(@cropdata); $page->mediabox(@cropdata); }

(my $newfilename = $filename) =~ s/(.*)\.(\w+)$/$1.clean.$2/; $newpdf->saveas($newfilename);

__END__

Esse post foi baseado no post em http://snipplr.com/view/18924/split-crop-double-page-pdfs-in-two/

Como criar um repositório Git remoto usando o SSH

Fabrício Godoy — Sun, 15 Nov 2009 02:59:25 +0000

Abordarei a criação de um repositório Git remoto usando o SSH num ambiente Linux.
Não incluirei detalhes da configuração do SSH.

É necessário que os seguintes pacotes estejam instalados: git, openssh-server e openssh-client.

Primeiro configure o SSH editando o arquivo /etc/ssh/sshd_config.
Eu recomendo algumas configurações[1]:

Protocol 2    # Permite apenas a versão 2 do protocolo (mais seguro)

PermitRootLogin no    # Não permite login como root

PasswordAuthentication no    # Não permite login por senha

Não esqueça de iniciar ou reiniciar o servidor SSH.

Agora é necessário criar um usuário para acesso ao Git através do SSH.
Eu recomendo que o nome do usuário seja git e que seja criado com o seguinte comando[2]:

useradd -r -m --shell /usr/bin/git-shell git

Definindo o shell do usuário para /usr/bin/git-shell o acesso do usuário será restrito aos comandos do Git[3].
O diretório pessoal do usuário git será criado em /home/git.

Se você não tem uma chave para o SSH, crie-a com o comando ssh-keygen (usando seu usuário).
Será criada uma chave pública e privada em ~/.ssh, a chave pública tem o sufixo .pub (nunca compartilhe sua chave privada).
Agora é necessário adicionar sua chave pública a lista de chaves autorizadas do usuário git, para isso faça o seguinte:

mkdir /home/git/.ssh

cat /home/seu_usuario/.ssh/id_rsa.pub >> /home/git/.ssh/authorized_keys

Supondo que o nome de sua chave pública seja id_rsa.pub.

Agora será necessário criar um repositório no diretório pessoal do usuário git.
Para criar um repositório para o projeto ProjetoTeste, faça o seguinte:

mkdir /home/git/ProjetoTeste

cd /home/git/ProjetoTeste

git init --bare

Agora é necessário garantir que tudo pertença ao usuário git, faça o seguinte:

cd /home/git

chown -R git.git .    # não esqueça do ponto no final

Isso é tudo.

Para clonar o repositório use o seguinte comando:

git clone git@ip_do_servidor:ProjetoTeste

Referência:
1- http://linux.die.net/man/5/sshd_config ou man 5 sshd_config.
2- http://linux.die.net/man/8/useradd ou man 8 useradd.
3- http://linux.die.net/man/1/git-shell ou man 1 git-shell.

[Autotools] Internacionalização (I18n)

Fabrício Godoy — Mon, 14 Sep 2009 01:41:46 +0000

Explicarei como internacionalizar, ou seja, tornar um programa traduzível.

Tomarei como exemplo o projeto hello-world do post anterior.

Você pode baixar o pacote final do projeto do post anterior em http://dl.getdropbox.com/u/1671797/Blog/hello-world-0.2.0.tar.gz.

Será necessário as seguintes ferramentas: intltool e gettext.

Adicione o seguinte código no arquivo configure.ac:

# Checks for libraries.
PKG_CHECK_MODULES([DEPS],[glib-2.0])
AC_SUBST(DEPS_CFLAGS)
AC_SUBST(DEPS_LIBS)

# ------------------------------------------------------------------------------
# Internationalization
# ------------------------------------------------------------------------------
GETTEXT_PACKAGE=hello-world
AC_SUBST(GETTEXT_PACKAGE)
AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE], ["$GETTEXT_PACKAGE"],
 [the gettext translation domain])

AM_GLIB_GNU_GETTEXT
GLIB_DEFINE_LOCALEDIR(HELLO_WORLD_LOCALEDIR)

IT_PROG_INTLTOOL([0.35.1])

# ------------------------------------------------------------------------------
# Check OS-specific platform

PKG_CHECK_MODULES([DEPS], [glib-2.0]): Procura pela biblioteca glib-2.0 e define as variáveis DEPS_CFLAGS e DEPS_LIBS (detalhes abaixo). Caso a biblioteca não seja encontrada é retornado um erro.

AC_SUBST(DEPS_CFLAGS): Faz com que @DEPS_CFLAGS@ ou $(DEPS_CFLAGS), nos arquivos de saída do autoconf, seja substituído pelo valor da variável.

AC_SUBST(DEPS_LIBS): O mesmo que o comando acima, mas com a variável DEPS_LIBS.

GETTEXT_PACKAGE=network-logger: Está sendo definida uma variável local.

AC_SUBST(GETTEXT_PACKAGE): O mesmo que as macros AC_SUBST acima, mas com a variável GETTEXT_PACKAGE.

AC_DEFINE_UNQUOTED: Igual a macro AC_DEFINE com o diferencial de expandir expressões de shell (ver “Definindo símbolos”). Define, no arquivo config.h, o símbolo GETTEXT_PACKAGE com o valor da variável GETTEXT_PACKAGE.

AM_GLIB_GNU_GETTEXT: Faz verificações se o gettext pode ser usado, define o símbolo HAVE_GETTEXT no arquivo config.h entre outros.

GLIB_DEFINE_LOCALEDIR: Define o nome do símbolo que conterá o caminho do diretório de localização. É o caminho do diretório de onde os catálogos de mensagens de cada língua será instalado.

IT_PROG_INTLTOOL: Faz verificações se o intltool pode ser usado e define a versão mínima necessária.

Ainda no arquivo configure.ac adicione o arquivo “po/Makefile.in” em AC_CONFIG_FILES. Desta maneira o arquivo Makefile que será criado no diretório po fará parte da compilação.

AC_CONFIG_FILES([Makefile
    src/Makefile
    po/Makefile.in])

Para que se possa fazer o uso da biblioteca glib-2.0 é necessário indicar ao compilador onde achar os arquivos de cabeçalho e os objetos de ligação. Para isso é necessário modificar o arquivo Makefile.am como abaixo:

bin_PROGRAMS = hello-world

hello_world_SOURCES = main.cpp
if OS_WIN32
hello_world_SOURCES += windowsdef.h
endif

hello_world_LDADD = $(DEPS_LIBS)
hello_world_CXXFLAGS = $(DEPS_CFLAGS)

DEPS_LIBS: Variável com os caminhos para os objetos de ligação. Esses objetos têm a listagem e endereçamento de cada função.

DEPS_CFLAGS: Variável com os caminhos para os arquivos de cabeçalho.

Crie o diretório po no diretório raíz do projeto, este diretório conterá os catálogos de cada língua.

Crie um arquivo vazio com o nome LINGUAS, neste arquivo será listado os códigos de cada idioma com suporte.

Crie um arquivo vazio com o nome POTFILES.in, neste arquivo será listado todos os arquivos com mensagens traduzíveis.

No arquivo Makefile.am do diretório raíz do projeto adicione o diretório po em SUBDIRS.

SUBDIRS = src po

É necessário adicionar os scripts de internacionalização ao pacote de distribuição, para isso adicione o código abaixo ao arquivo Makefile.am do diretório raíz.

SUBDIRS = src po

INTLTOOL_FILES = \
 intltool-extract.in \
 intltool-merge.in \
 intltool-update.in

EXTRA_DIST = \
 $(INTLTOOL_FILES)

DISTCLEANFILES = intltool-extract \
    intltool-merge \
    intltool-update \
    po/.intltool-merge-cache

INTLTOOL_FILES: Define uma variável com a lista de scripts usados pelo intltool.

EXTRA_DIST: Define arquivos adicionais que serão adicionados ao pacote de distribuição.

DISTCLEANFILES: Define os arquivos adicionais que serão removidos pelo comando “make distclean“.

Para atualizar os scripts com as mudanças execute o comando “autoreconf“.

Para preparar o projeto para o intltool, execute o comando “intltoolize” no diretório raíz do projeto.

Agora é necessário inicializar o libintl e marcar as strings como traduzíveis. Para isso modifique o arquivo main.cpp como a seguir:

#ifdef HAVE_CONFIG_H
#include 
#endif

#ifdef WINNT
#include "windowsdef.h"
#endif

#include 
#include 

int main()
{
  // Gettext initialization
  setlocale(LC_ALL, "");
  bindtextdomain(GETTEXT_PACKAGE, HELLO_WORLD_LOCALEDIR);
  bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
  textdomain(GETTEXT_PACKAGE);

  std::cout << _("Hello World!") << std::endl;
  return 0;
}

Para usar os símbolos GETTEXT_PACKAGE e HELLO_WORLD_LOCALEDIR é necessário incluir o cabeçalho config.h.

O cabeçalho gi18n.h inclui o cabeçalho libintl.h, que contém as funções de internacionalização, e define símbolos comumente usados na internacionalização.

A função getlocale() define a localização atual que será usada pelo gettext.

A função bindtextdomain() define o caminho do catálogo de GETTEXT_PACKAGE para HELLO_WORLD_LOCALEDIR.

A função bind_textdomain_codeset() define a codificação das mensagens do catálogo de GETTEXT_PACKAGE para UTF-8.

A função textdomain() define o catálogo de mensagens padrão para GETTEXT_PACKAGE.

A função _() é um símbolo que foi definido pelo gi18n.h que é um apelido para a função gettext() do cabeçalho libintl.h.

Agora o projeto está pronto para ser traduzido (localizado).

O pacote final pode ser acessado neste link: http://dl.getdropbox.com/u/1671797/Blog/hello-world-0.3.0.tar.gz.

Referências:

Definindo símbolos: http://www.gnu.org/software/hello/manual/autoconf/Defining-Symbols.html

Internacionalização: http://www.gtkmm.org/docs/gtkmm-2.4/docs/tutorial/html/chapter-internationalization.html

pkg-config: http://pkg-config.freedesktop.org/

setlocale: http://www.opengroup.org/onlinepubs/009695399/functions/setlocale.html

[Autotools] Identificando ambiente de destino

Fabrício Godoy — Sun, 14 Jun 2009 21:07:52 +0000

Explicarei aqui como identificar qual o ambiente de destino de compilação, ou seja, o ambiente no qual será executado o binário.

Para isso tomarei como exemplo o projeto hello-world do post anterior.

Você pode baixar o pacote final do projeto do post anterior em http://dl.getdropbox.com/u/1671797/Blog/hello-world-0.1.0.tar.gz.

No arquivo configure.ac, é necessário adicionar a seguinte macro:

AM_INIT_AUTOMAKE([1.9 -Wall -Werror])

# Check build environment
AC_CANONICAL_HOST

# Checks for programs.

Com essa macro serão criados os arquivos de script config.guess e config.sub que serão usados para identificar o ambiente de destino.

Serão definidas quatro variáveis de ambiente, que são: host, host_cpu, host_vendor, host_os. Com essas variáveis é possível condicionar a compilação para cada ambiente.

Caso o ambiente de destino seja o MinGW de 32 bits para PC, normalmente, a variável host teria o valor i686-pc-mingw32 e como consequência as variáveis host_cpu, host_vendor e host_os teriam os valores i686, pc e mingw32 respectivamente. Assim podemos dizer que “host=$host_cpu-$host_vendor-$host_os”.

Criarei uma verificação para definir a variável OS_WIN32 caso a variável host_os tenha a palavra “mingw”. Para isso adicionarei o seguinte script no arquivo configure.ac:

# ------------------------------------------------------------------------------
# Check OS-specific platform
# ------------------------------------------------------------------------------
AC_MSG_CHECKING([for native Win32])
case "$host_os" in
  *mingw*)
    iswin32=yes
  ;;
  *)
    iswin32=no
  ;;
esac
AC_MSG_RESULT([$iswin32])

AM_CONDITIONAL(OS_WIN32, [test "$iswin32" = "yes"])

A macro AC_MSG_CHECKING faz imprimir na tela a mensagem “checking for native Win32…” indicando que está sendo feita a verificação por uma característica específica.

Em seguida é verificada a variável de ambiente pela palavra “mingw”, caso encontre a variável local iswin32 será definida para o valor “yes”, senão para o valor “no” (Leia sobre Bash).

A macro AC_MSG_RESULT imprime na tela o resultado da última macro AC_MSG_CHECKING. Imprime “checking for native Win32… yes”, caso a variável iswin32 tenha o valor “yes”.

A macro AM_CONDITIONAL de maneira condicional define ou não a variável OS_WIN32 a qual será compartilhada a todos Makefiles. Caso a variável local iswin32 tenha o valor “yes” a variável OS_WIN32 será definida.

Adicionarei o seguinte conteúdo no arquivo Makefile.am:

hello_world_SOURCES = main.cpp
if OS_WIN32
hello_world_SOURCES += windowsdef.h
endif

Assim o arquivo windowsdef.h só será compilado caso esteja definida a variável OS_WIN32.

Criarei o arquivo windowsdef.h com o seguinte conteúdo:

#ifndef _WINDOWSDEF_H
#define _WINDOWSDEF_H

#ifdef HAVE_CONFIG_H
#include 
#endif

#ifndef WINVER
// Windows Server 2003 with SP1, Windows XP with SP2
// See http://msdn.microsoft.com/en-us/library/aa383745.aspx
#define WINVER 0x0502
#endif /* WINVER */

#include 

#endif    /* _WINDOWSDEF_H */

Definindo a variável WINVER para o valor 0×0502 estaremos limitando o executável ao Windows XP SP2 ou Windows Server 2003 SP1 no mínimo.

Adicionarei o seguinte conteúdo ao arquivo main.cpp:

#ifdef WINNT
#include "windowsdef.h"
#endif

#include

O compilador só referenciará o arquivo windowsdef.h caso a variável WINNT esteja definida. A variável WINNT é definida automaticamente pelo compilador caso o mesmo esteja sendo executado em um ambiente do Windows NT.

Para consultar as variáveis automaticamente definidas pelo seu compilador execute o seguinte comando “gcc -E -dM – < /dev/null | sort”, sendo que “| sort” é para ordenar a saída em ordem alfabética.

Com essas instruções já se tem o básico para construir um programa multi-plataforma.

O pacote final pode ser acessado neste link: http://dl.getdropbox.com/u/1671797/Blog/hello-world-0.2.0.tar.gz

Referências:

http://www.gnu.org/software/hello/manual/autoconf/Canonicalizing.html

http://www.gnu.org/software/hello/manual/autoconf/Printing-Messages.html

http://www.gnu.org/software/hello/manual/automake/Usage-of-Conditionals.html

http://tldp.org/LDP/Bash-Beginners-Guide/html/sect_07_03.html

http://git.gnome.org/cgit/gtk+/tree/configure.in#n127

https://svn.win.tue.nl/viewcvs/MCRL2/trunk/src/configure.ac?rev=808&view=markup

http://www.rtems.com/ml/rtems-users/1998/march/msg00046.html

Hello World com Autotools

Fabrício Godoy — Sat, 23 May 2009 20:23:36 +0000

Para quem não conhece o Autotools, as ferramentas do mesmo têm o principal objetivo de fazer programas portáveis, possibilitando assim que o programa possa ser compilado em qualquer ambiente.

Vou explicar como fazer um programa que exibe “Hello World!” no console configurado com Autotools. Não vou me ater a detalhes, ficando a cargo do leitor pesquisar detalhadamente sobre as ferramentas.

Para continuar você precisará ter instalado as seguintes ferramentas: make, gcc-c++, autoconf e automake. Para Windows você precisará também do MinGW e do MSYS.

Vamos ao projeto:

1- Primeiramente crie uma pasta para o projeto (hello-world por exemplo).

2- Agora crie a pasta src (o nome é sua escolha), ela irá conter o código fonte do projeto.

3- Crie o arquivo main.cpp dentro da pasta src, como o código abaixo.

#include

int main() { std::cout << "Hello World!" << std::endl; return 0; }

4- Dentro da pasta raíz do projeto crie o arquivo Makefile.am, com o conteúdo abaixo.

SUBDIRS = src

Os arquivos Makefile.am têm instruções de compilação, mais especificamente, instruções para o comando make.
No caso deste arquivo, ele indica que deve ser pesquisado o diretório src.

5- Agora crie outro arquivo Makefile.am no diretório src, com o seguinte conteúdo:

bin_PROGRAMS = hello-world

hello_world_SOURCES = main.cpp

A primeira linha indica quais são os nomes dos programa executáveis.
A segunda linha indica quais são os arquivos fontes do programa hello-world. Observe que todos os caracteres não alfabéticos devem der substituídos por “_”, como em hello_world.

6- Agora precisamos criar o arquivo configure.ac (no diretório raíz do projeto, daqui em diante iremos trabalhar apenas no diretório raíz), que irá conter as configurações do projeto, como nome, versão e dependências do projeto entre outros.
Para criar um arquivo configure.ac preliminar execute o comando abaixo.

$ autoscan

Serão criados os arquivos configure.scan e configure.log, sendo que o configure.scan é o configure.ac preliminar e o configure.log contém os erros encontrados.
Renomeie o arquivo configure.scan para configure.ac. O arquivo configure.log pode ser excluído.

7- Modifique o arquivo configure.ac como abaixo.

#                                               -*- Autoconf -*-

# Process this file with autoconf to produce a configure script.
AC_PREREQ([2.54])

AC_INIT([Hello World], [0.1.0], [myemail@server.com], [hello-world])

AC_CONFIG_SRCDIR([src])

AC_CONFIG_HEADERS([config.h])

AM_INIT_AUTOMAKE([1.9 -Wall -Werror])
# Checks for programs.

AC_PROG_CXX
# Checks for libraries.
# Checks for header files.
# Checks for typedefs, structures, and compiler characteristics.
# Checks for library functions.

AC_CONFIG_FILES([Makefile src/Makefile]) AC_OUTPUT

AC_PREREQ: A versão mínima necessária do autoconf, geralmente é a versão 2.54.
AC_INIT: Define o nome e versão do projeto, endereço para relatar erros e o nome do pacote do projeto.
AC_CONFIG_SRCDIR: Define a pasta que contém o código fonte.
AC_CONFIG_HEADERS: Define o nome do arquivo de definições do projeto, é recomendável deixar o padrão.
AM_INIT_AUTOMAKE: É necessário para fazer uso dos Makefile.am. Define a versão mínima do automake e as opções -Wall e -Werror definem respectivamente que devem ser mostrados todos os alertas e que todos os alertas devem ser tratados como erros.
AC_PROG_CXX: Verifica e exige o compilador C++ para o projeto.
AC_CONFIG_FILES: Define os locais dos arquivo Makefile do projeto.
AC_OUTPUT: Macro que executa a saída do autoconf.

8- É necessário executar os comandos aclocal, autoconf, autoheader e automake para gerar o script de configuração do projeto, mas para facilitar há o comando autoreconf que executa todos os comandos necessários.
Inicialmente iremos executar o comando abaixo para que os arquivos iniciais necessários sejam criados.

$ autoreconf --install

Serão criados vários arquivos, sendo que o arquivo INSTALL contém instruções de instalação e configuração e o arquivo COPYING contém a licença do programa.

O automake exige os arquivos NEWS, README, AUTHORS e ChangeLog. Inicialmente crie-os vazios.

$ touch NEWS README AUTHORS ChangeLog

9- Execute o comando autoreconf e será gerado o script de configuração do projeto novamente, agora sem erros com o automake.

10- Execute o script ./configure para configurar o projeto.

11- Execute o comando make para compilar o projeto.

12- Teste o executável do projeto:

$ src/hello-world

13- Para criar um pacote do projeto execute o seguinte comando:

$ make dist

E será criado um pacote distribuível para outros que queiram compilar o projeto.

Para que além de ser criado o pacote o mesmo seja testado, execute o seguinte comando:

$ make distcheck

Pronto, é isso.

Aqui só é mostrado o básico necessário para começar a usar o Autotools, as possibilidades vão muito além destas explicadas.
O pacote final pode ser acessado neste link: http://dl.getdropbox.com/u/1671797/Blog/hello-world-0.1.0.tar.gz

Referências:
Manual do autoconf: http://www.gnu.org/software/autoconf/manual/index.html
Manual do automake: http://www.gnu.org/software/automake/manual/index.html

Network Traffic (antigo Network Logger)

Fabrício Godoy — Thu, 21 May 2009 03:05:37 +0000

Agora irei falar um pouco sobre o projeto que está sendo a base de meus estudos.

O objetivo do projeto é gravar a quantidade de tráfego de rede diariamente, ou seja, ficará salvo a quantidade de bytes que saíram e entraram de uma determinada interface de rede. Com essas informações é possível saber o quanto foi consumido em um dia, semana, mês, ano etc.

A ideia do projeto veio quando assinei um serviço de banda larga que restringia o tráfego de entrada e saída mensal. O projeto inicial se chamava GS Network Monitor que era escrito em C# e apesar dos vários bugs está relativamente funcional, a última versão lançada em 2006. E acredito que o mesmo tenha apenas um usuário ativo, nem eu o uso mais pois o mesmo só funciona no ambiente Windows, que não é meu ambiente principal a um bom tempo.

Desde de 2006 eu não modifiquei mais nada do projeto GS Network Monitor, só agora estou tendo a idéia de desenvolvê-lo do zero em C++ e multiplataforma, mas com o nome modificado para ~~Network Logger~~ Network Traffic. Não sei se é um bom nome, só sei que é melhor do que Network Monitor. Se alguém tiver uma idéia de nome melhor irei analisá-la com prazer.

Comecei a trabalhar no ~~Network Logger~~ Network Traffic no dia 25 de Março de 2009 (data do meu primeiro envio ao repositório SVN) e já estou na revisão 37 com aproximadamente 748 linhas de código C/C++ (dados do ohloh).

Atualmente é exibido a quantidade de bytes que saíram e entraram entre outras informações da interface de rede, isso tudo no console e funcionando tanto no Linux quanto no Windows. A interface gráfica está começando ainda, apenas é exibida uma janela com dados estáticos.

Mesmo estando pouco tempo trabalhando no projeto já aprendi muitas coisas, das quais quero compartilhar neste blog. Tudo depende do meu tempo.

~~Página do projeto: http://network-logger.googlecode.com/~~
Página do projeto: http://github.com/skarllot/network-traffic
~~Página de discussão do projeto: http://groups.google.com/group/network-logger~~
~~Página com dados de análise do projeto: http://www.ohloh.net/p/network-logger~~
Página com dados de análise do projeto: http://www.ohloh.net/p/network-traffic
~~Repositório do projeto: http://network-logger.googlecode.com/svn/trunk/~~
Repositório do projeto: git://github.com/skarllot/network-traffic.git

Apresentação

Fabrício Godoy — Wed, 20 May 2009 03:23:27 +0000

Olá a todos.

Estou iniciando esse blog com a intenção de descrever minhas experiências com C++, gtkmm, Autotools e MinGW.

Meu primeiro projeto que usa essas ferramentas é o ~~network-logger~~ network-traffic (darei mais detalhes sobre o mesmo em breve), o qual será a principal fonte de minhas experiências.

Meu ambiente de trabalho é o Fedora 10, GNOME, gedit, NetBeans 6.5 e MinGW. Graças ao grupo de projeto de compilação cruzada com o MinGW do Fedora eu consigo compilar para o Windows facilmente mesmo estando num ambiente Linux.

Espero que com este blog eu consiga passar informações úteis aos interessandos no assunto, ao menos aos que estão iniciando :).

Até breve!