rpm2cpio arquivo.rpm | cpio -idmv

Link sobre cpio

Esses dias tive que estudar um pouco sobre Postfix para entender marromenos como que funciona um server de email. Então ai vai um passo-a-passo do que eu fiz para subir  esse servidor de email com Postfix usando o squirrelmail para testar os envios e recebimentos dos emails

Usei Ubuntu Server (não gosto muito mas era o que eu tinha na mão) e gerenciador de pacote aptitude. O mesmo funciona com apt-get se preferir :-p

Primeiramente, vamos instalar os pacotes básicos na máquina. Esses pacotes não são necessariamente só do Postfix.

# aptitude install openssh-server vim-full mutt nmap postfix

Durante a instalação, provavelmente serão feitas algumas perguntas. Por enquanto, apenas dê ENTER para todas elas. Porque assim que a instalação terminar, iremos reconfigurar algumas opções e depois editar o arquivo de configuração direto.

Feita a instalação, vamos reconfigurar algumas opções básicas:

# dpkg-reconfigure postfix

Abaixo, segue um exemplo de configuração que foi definida:

=> OK
=> Internet Site
=> dominio.com.br
=> (em branco)
=> $myhostname, localhost.$mydomain, $mydomain
=> yes
=> 127.0.0.0/8 192.168.1.0/24
=> yes
=> 0
=> +
=> all

Depois que definirmos todas essas configurações, então automaticamente o postfix será recarregado (reload) e reiniciado.
Nesse server básico de Postfix, estou usando a mesma base de usuários comuns do sistema, como usuários que terão email no postfix. Lembrando que todos esses usuários comuns, são os que possuem ID maior que 1000 e estão dentro de /etc/passwd.

Para esse primeiro teste, vou adicionar um usuário novo no sistema:

# adduser joao

Como o postfix já está instalado e com uma pré-configuração, então vamos enviar alguns emails entre os usuários comuns do sistema. Para isso, vamos usar o telnet mesmo:

$ telnet localhost 25

HELO smtp.dominio.com.br
MAIL From: user@dominio.com.br
RCPT to: joao@dominio.com.br
DATA
Mensagem do email.
.
QUIT

Como estamos fazendo tudo na máquina local por enquanto, então usei um telnet localhost na porta 25. Na linha HELO como o próprio nome já fala, estou dando um "Olá" para o meu server de email e domínio. Na linha MAIL From estou avisando qual o usuário que irá enviar o email e na linha RCPT to está o usuário que irá receber o email. Para escrever a mensagem, chamamos o DATA e então basta escrever o que você quiser. Para finalizar a mensagem, basta dar um . único e ele entenderá como fim da mensagem. E para finalizar o telnet, basta dar um QUIT.
É importante prestar atenção nas palavras e letras maiúsculas.

Quando enviarmos esse email para o joao@dominio.com.br, será criado um arquivo com o nome do usuário em /var/mail/.
Por exemplo:

# ls /var/mail
joao

Então para ler o email, pode-se dar um cat nesse arquivo, ou então usar uma ferramenta chamada mutt, que lê emails em linha de comando.

# cat /var/mail/joao
ou
# su joao
$ mutt

Abaixo, segue a estrutura do arquivo /etc/hostname:

# cat /etc/hostname
dominio.com.br

Abaixo, segue a estrutura do arquivo /etc/hosts:

# cat /etc/hosts
127.0.0.1 localhost
127.0.1.1 dominio.com.br dominio.com.br
IP.ex.ter.no dominio.com.br dominio.com.br

A estrutura desses arquivos é importante, porque dependendo dos casos, o hostname e o domínio tem que estar com o mesmo nome.

O arquivo de configuração do Postfix está localizado em /etc/postfix/main.cf.
Abaixo vou colocar umas linhas básicas desse arquivo de configuração para analisar o conteúdo. Não vou explicar o que todas as linhas fazem, mas sites como o do próprio postfix explica o conteúdo de cada linha e muitas vezes cita exemplos =p

# vim /etc/postfix/main.cf
myhostname = IP.ex.ter.no.dominio.com.br
mydomain = dominio.com.br
alias_maps = hash:/etc/aliases
alias_database = hash:/etc/aliases
myorigin = /etc/mailname
mydestination = $myhostname, localhost.$mydomain, $mydomain
relayhost =
relay_domains = $mydomain
mynetworks = 127.0.0.0/8 192.168.1.0/24
home_mailbox = Maildir/
recipient_delimiter = +
inet_interfaces = all
inet_protocols = all
mailbox_size_limit = 0

Vamos configurar os serviços de pop e imap. Para isso, será necessário instalar os seguintes pacotes:

# aptitude install courier-pop courier-pop-ssl
# aptitude install courier-imap courier-imap-ssl

Quando instalarmoas esses pacotes, será criado um diretório courier dentro do /etc/ e dentro desse diretório, teremos diversos arquivos. Antesde editar os arquivos e fazer as alterações, aconselho renomear os arquivos originais:

# cd /etc/courier
# mv imapd.pem imapd.pem.old
# mv pop3d.pem pop3d.pem.old

O próximo passo, é editar os arquivos imap.cnf e pop3d.cnf e alterar as informações necessárias. Por exemplo coloque em Country=BR, State=Sao Paulo e etc:

# vim imapd.cnf
# vim pop3d.cnf

Quando os arquivos forem alterados, devemos devemos criar novamente os arquivos imapd.pem e pop3d.pem com os comandos:

# mkimapdcert
# mkpop3dcert

O próximo passo agora é instalar o squirrelmail, que é uma ferramenta para testar o envio e recebimento de mensagens de email através de uma interface web mesmo. Se preferir, pode usar alguma outra ferramenta, como eu já tinha comentado antes:

# aptitude install squirrelmail
# aptitude install php5

Continua... :-p

Links de Referências:

http://www.postfix.org/documentation.html

https://help.ubuntu.com/7.04/server/C/postfix.html

http://virtual01.lncc.br/~licht/linux/servidores.postfix.arq.html

http://www.gdhpress.com.br/redeseservidores/leia/index.php?p=cap10-2

Introdução
Imagine que seu professor de linguagem C++ (ou outra de sua preferência, mas uma linguagem descente, por favor) lhe passe uma lição de casa: “Faça um MMORPG em 5 idiomas diferentes”.
Simples não? Qualquer um faz um MMORPG em C++ da noite para o dia. O detalhe desta simples aplicação é permitir a utilização ou diversão (já que é um game) em outros idiomas.
Se você pensou em um colocar vários “IFs” ou “CASEs” para cada linha que contenha uma string...

Bom, talvez não seja algo tão errado, se você tiver tempo para colocar vários “IFs” para cada uma das 4.000 strings de frases aleatórias dos NPCs do seu game. O trabalho todo será seu mesmo.
Tudo bem, é só uma lição de casa, mas se não for pegue suas coisas e passe no RH (ou passe no RH e depois pegue as suas coisas... vocês entenderam né?).

Bom, sem encher muita lingüiça, vamos ao ponto: i18n

What?
i18n é o acrônimo de internacionalization (“i” + 18 letras + “n”). As vantagens de se utilizar i18n são:

- O programa não precisa ser re-compilado a cada alteração nas traduções. Alternar entre os idiomas pode ser feito dinamicamente em tempo de execução (salvo algumas situações específicas).

- Este método é válido para muitas linguagens, não só o C++, o processo é praticamente o mesmo.

- Se o programa não conseguir encontrar a string traduzida ele exibirá a string original.

- A pessoa que fará as traduções não precisa entender de programação. Como o arquivo a ser traduzido está separado do programa, você pode mandar para um tradutor e depois só fazer as modificações necessárias para encaixar no programa (poucas coisas mesmo).

- Seu amigo chinês vai poder jogar seu game! De quebra ele indica o seu game para outros amiguinhos chineses que devem ser mais ou menos uns 10 mil só no bairro dele.

- Formatação correta de moeda, pesos, medidas, data, hora, etc. para o idioma escolhido.

- Aumento do alcance do seu programa/game em escala mundial. Para um alemão, nada melhor do que se utilizar um software em alemão. Para um brasileiro, nada melhor do que utilizar um software em português, não é?

- Perdão. Não existe nada melhor do que utilizar um software em português brasileiro (ora pois!).

- E outros benefícios que eu não me lembro ou não consegui inventar.

Nada mastigado, apenas o caminho das pedras...
Mas como utilizar a/o i18n em meu programa? A melhor forma é utilizando o gettext. Seu uso é relativamente simples (claro, se você for um programador de verdade). Os passos e quesitos básicos para implementar as traduções são:

- O programa para estar perfeitamente internacionalizado deve ter suporte a caracteres UNICODE, mas tem que ter suporte de verdade ao UNICODE. Por exemplo, no Delphi só é possível manipular esses caracteres internamente sem poder exibi-los, pois os componentes dele não possuem suporte ao UNICODE (e vai saber quando terá de verdade). Mas você pode comprar componentes de terceiros com suporte a UNICODE, ou fazer que nem eu que alterei o componente TEdit na mão e fez o antivírus apitar na hora de rodar o programa (depois eu conto essa história).

- Instalar o gettext se você não tiver.

- Marcar no código as strings que serão traduzidas. Por exemplo:

printf("Welcome to the Django Mr. %s!\n", name);

se transforma em:

printf(_("Welcome to the Django Mr. %s!\n"), name);

onde “_()” é uma função do gettext que marca a string para extração. Esta talvez seja a parte chata da coisa, mas não é tanto esforço assim.

- Um botão ou opção no seu programa para o usuário mudar o idioma.

- Extrair as strings (veja o manual do gettext). Será gerado um arquivo *.po com as strings marcadas.

- Traduzir as strings para um idioma em um editor de texto UNICODE. Utilizando o exemplo anterior ficaria assim:
"Welcome to the Django Mr. %s!\n"
"Bem-vindo a Djelva Sr. %s!\n"

- Compilar o arquivo traduzido com uma ferramenta apropriada, será gerado um arquivo *.mo. Uma ferramenta que utilizo para compilar e editar é o Poedit.

- Copiar o arquivo compilado para a pasta correta, normalmente (ou sempre) é em “diretório_do_programa/locale/sigla_do_idioma/LC_MESSAGES/default.mo”. Como em “meu_programa_bilingue/locale/pt_BR/LC_MESSAGES/default.mo”. Agora você sabe por que alguns programas com vários idiomas possuem uma pasta “locale” no diretório de instalação?

- Testar o seu programa.

- Para alterar a tradução basta editar apenas o *.po do idioma e compila-lo novamente, sem precisar mexer no código fonte do programa.

Basicamente, para cada idioma haverá um arquivo compilado diferente. De preferência, o idioma original do seu programa deve estar em inglês, mas nada impede que você o faça em português.

Dicas
- Ao fazer a tradução procure fazer com que a tradução possua um tamanho próximo ao do original.

- No caso do Delphi você pode utilizar o dxgettext, ele faz a captura automática das strings dos componentes. Infelizmente, faça uma boa leitura da documentação dele, pois existem alguns atributos de componentes que não devem ser traduzidos.

- Antes de fazer o seu programa estude (é estude!) um pouco sobre os idiomas que você irá disponibilizar em seu programa. Dependendo do idioma será necessário colocar algumas alterações no programa, como a escrita da direita-para-esquerda, de cima-para-baixo, etc. Não é nada muito difícil de fazer, muitas vezes isso é feito de forma automática pelo programa (depende muito da API utilizada) ou só mudar uma flag do componente que está utilizando (que também depende muito da API utilizada XD).

- Permita que o usuário escolha o idioma. Não obrigue ele a utilizar somente o idioma definido pelo SO. Eu mesmo já sofri muito com isso. :´(

- Para aplicações Desktop o ideal é que o texto possa fluir na tela de forma dinâmica, pois um texto pode aumentar ou diminuir de dimensões ao mudar de idioma, como de "texto romanizado" para "ideogramas chineses". Faça com que os itens da tela se redimensionem e se posicionem automaticamente. Uma boa opção é deixar com quebras de linhas automáticas, tomando o cuidado para que o texto não fique em cima de outros itens ao quebrar a linha.

Repare que só é possível fazer essas traduções com textos estáticos do programa. Se vierem dados do banco de dados já é mais complicado. A não ser que suas tabelas estejam bem modeladas, pelo menos na 3NF já daria para traduzir boa parte dos campos. Por exemplo, uma tabela de cores poderia ter os campos “cor_ptbr” e “cor_en”. Mas como fazer traduções corretamente de banco de dados isso eu deixo para próxima (pois nem eu sei XD).

Não entendeu nada do que falei? Clique aqui que tudo ficará mais claro.

Esse meu amigo estava fazendo um sisteminha em Delphi para rodar na versão japonesa do Windows XP. Mas a versão do Delphi dele não tinha Quickreport, só tinha o Rave Report, e o Rave Report não exibia caracteres japoneses. Como eu... digo, esse meu amigo, precisava de uma solução rapidamente, ele resolveu exportar os dados para o Excel. Assim resolveria o problema de exibição dos caracteres japoneses e o cliente teria um arquivo que é familiar a ele, tanto para somente visualizar quanto para imprimir os dados/relatório.

É mais complicado e lento gerar planilhas no Excel do que gerar relatórios no Rave Report, mas em compensação os dados exportados ficam melhor formatados e maleáveis.

Passos:
- Adicione a unit ExcelXP
- Adicionar as variaveis globais
- Instâncie os componentes no OnCreate
- Adicione um botao no Form
- Gerar a planilha no OnClick do botão
- Liberar a memoria no OnClose

unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExcelXP;
 
type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
 
var
  Form1: TForm1;
  LCID: Integer;
  ExcelApplication1: TExcelApplication;
  ExcelWorkbook1: TExcelWorkbook;
  ExcelWorksheet1: TExcelWorksheet;
implementation
 
{$R *.dfm}
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  ExcelApplication1 := TExcelApplication.Create(nil);
  ExcelWorkbook1 := TExcelWorkbook.Create(nil);
  ExcelWorksheet1 := TExcelWorksheet.Create(nil);
end;
 
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  ExcelWorksheet1.Free;
  ExcelWorkbook1.Free;
  ExcelApplication1.Free;
end;
 
procedure TForm1.Button1Click(Sender: TObject);
begin
  LCID := GetUserDefaultLCID;
 
  ExcelApplication1.DisplayAlerts[LCID] := False;
 
  ExcelApplication1.Workbooks.Add(EmptyParam, LCID);
  ExcelWorkbook1.ConnectTo(ExcelApplication1.Workbooks[1] as _Workbook);
  ExcelWorksheet1.ConnectTo(ExcelWorkbook1.Worksheets[1] as _Worksheet);
 
  ExcelWorksheet1.Activate(LCID);
  ExcelApplication1.ScreenUpdating[LCID] := true;
 
  // nome da planilha (que aparece na aba)
  ExcelWorksheet1.Name := 'Relatório ou Exportação';
 
  { inserindo dados na planilha }
 
  // colocando titulo na primeira celula da planilha
  ExcelWorksheet1.Range['A1', 'A1'].Value2 := 'Título';
 
  // unindo as células de A1 ate C1 para o titulo ocupar 3 colunas
  ExcelWorksheet1.Range['A1', 'C1'].Merge(True);
 
  // formatando o titulo
  ExcelWorksheet1.Range['A1', 'C1'].Font.Bold := True;
  ExcelWorksheet1.Range['A1', 'C1'].Font.Size := 16;
  ExcelWorksheet1.Range['A1', 'C1'].Font.Color := RGB(255,0,0);
  ExcelWorksheet1.Range['A1', 'C1'].HorizontalAlignment := xlCenter;
  ExcelWorksheet1.Range['A1', 'C1'].VerticalAlignment := xlCenter;
 
  // colocando os nomes dos campos na segunda linha
  ExcelWorksheet1.Range['A2', 'A2'].Value2 := 'Campo1';
  ExcelWorksheet1.Range['B2', 'B2'].Value2 := 'Campo2';
  ExcelWorksheet1.Range['C2', 'C2'].Value2 := 'Campo3';
  ExcelWorksheet1.Range['A2', 'C2'].Font.Bold := True;
  ExcelWorksheet1.Range['A2', 'C2'].Font.Color := RGB(0,0,255);
  ExcelWorksheet1.Range['A2', 'C2'].HorizontalAlignment := xlCenter;
  ExcelWorksheet1.Range['A2', 'C2'].VerticalAlignment := xlCenter;
 
  // colocando os valores
  ExcelWorksheet1.Range['A3', 'A3'].Value2 := 'Valor1';
  ExcelWorksheet1.Range['B3', 'B3'].Value2 := 'Valor2';
  ExcelWorksheet1.Range['C3', 'C3'].Value2 := 'Valor3';
  ExcelWorksheet1.Range['A4', 'A4'].Value2 := 'Valor4';
  ExcelWorksheet1.Range['B4', 'B4'].Value2 := 'Valor5';
  ExcelWorksheet1.Range['C4', 'C4'].Value2 := 'Valor6';
 
  // colocando borda nas celulas dos valores
  ExcelWorksheet1.Range['A3', 'C4'].Borders.Weight := xlThin;
 
  ExcelWorksheet1.Range['A3', 'C4'].HorizontalAlignment := xlCenter;
  ExcelWorksheet1.Range['A3', 'C4'].VerticalAlignment := xlCenter;
 
  { formatando a pagina de impressão }
 
  // ajusta o tamanho das colunas
  ExcelWorksheet1.Cells.EntireColumn.AutoFit;
 
  // define borda de impressao com cerca de 1cm
  ExcelWorksheet1.PageSetup.BottomMargin := 30;
  ExcelWorksheet1.PageSetup.LeftMargin := 30;
  ExcelWorksheet1.PageSetup.RightMargin := 30;
  ExcelWorksheet1.PageSetup.TopMargin := 30;
 
  // deixa a planilha no centro da pagina horizontalmente
  ExcelWorksheet1.PageSetup.CenterHorizontally := True;
 
  // imprime o numero da pagina no rodapé
  // '&P' e o codigo para numero de pagina
  ExcelWorksheet1.PageSetup.CenterFooter := '&P';
 
  // Exibe o programa do Excel com a planilha criada
  ExcelApplication1.Visible[LCID] := True;
end;
 
end.

E este é o resultado final:

Enquanto os objetos não forem destruídos o Excel estará aberto na memória, por isso tem uns "Frees" no OnClose do Form. Aqui tem outro comandos que podem ser usados:

// abre o PrintPreview (use depois do "ExcelApplication1.Visible[LCID] := True;")
ExcelWorksheet1.PrintPreview;
 
// folha na horizontal
ExcelWorksheet1.PageSetup.Orientation := xlLandscape;
 
// impressao em preto e branco
ExcelWorksheet1.PageSetup.BlackAndWhite := True;
 
// Salva a planilha
ExcelWorksheet1.SaveAs('c:\caminho\onde\voce\quer\salvar\planilha.xls');

Não dei muitos detalhes sobre os componentes utilizados, mas acho que já deve ajudar bastante pra procurar o resto

Sockets são importantes, por isso eu tinha que tomar vergonha na cara e aprender a usá-los, comecei a ler sobre o assunto e consegui fazer uma pequena aplicação que envia mensagens para outra.

Primeiramente vou mostrar o código e depois ir (tentando) descrever as funções. Não vou me aprofundar, é só para ter uma idéia de como a coisa funciona, mesmo porque eu acho que aprofundei demais na explicação (mas quanto mais se sabe, mas se sabe que não se sabe nada XD).

O código foi feito para Windows, mas a implementação no Linux é bem parecida. No Windows você deve usar a WinSock API para trabalhar com sockets, não se esqueça de linkar a lib na hora de compilar. Eu uso o Dev-C++ e a lib é a libwsock32.a.

Criando o servidor que recebe mensagens

/*
    SERVIDOR
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock.h>
 
#define BACKLOG_MAX 5
#define BUFFER_SIZE 128
#define EXIT_CALL_STRING "#quit"
 
int local_socket = 0;
int remote_socket = 0;
 
int remote_length = 0;
int message_length = 0;
 
unsigned short local_port = 0;
unsigned short remote_port = 0;
 
char message[BUFFER_SIZE];
 
struct sockaddr_in local_address;
struct sockaddr_in remote_address;
 
WSADATA wsa_data;
 
/* Exibe uma mensagem de erro e termina o programa */
void msg_err_exit(char *msg)
{
    fprintf(stderr, msg);
    system("PAUSE");
    exit(EXIT_FAILURE);
}
 
int main(int argc, char **argv)
{
    // inicia o Winsock 2.0 (DLL), Only for Windows
    if (WSAStartup(MAKEWORD(2, 0), &wsa_data) != 0)
        msg_err_exit("WSAStartup() failed\n");
 
    // criando o socket local para o servidor
    local_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (local_socket == INVALID_SOCKET)
    {
        WSACleanup();
        msg_err_exit("socket() failed\n");
    }
 
    printf("Porta local: ");
    scanf("%d", &local_port);
    fflush(stdin);
 
    // zera a estrutura local_address
    memset(&local_address, 0, sizeof(local_address));
 
    // internet address family
    local_address.sin_family = AF_INET;
 
    // porta local
    local_address.sin_port = htons(local_port);
 
    // endereco
    local_address.sin_addr.s_addr = htonl(INADDR_ANY); // inet_addr("127.0.0.1")
 
    // interligando o socket com o endereço (local)
    if (bind(local_socket, (struct sockaddr *) &local_address, sizeof(local_address)) == SOCKET_ERROR)
    {
        WSACleanup();
        closesocket(local_socket);
        msg_err_exit("bind() failed\n");
    }
 
    // coloca o socket para escutar as conexoes
    if (listen(local_socket, BACKLOG_MAX) == SOCKET_ERROR)
    {
        WSACleanup();
        closesocket(local_socket);
        msg_err_exit("listen() failed\n");
    }
 
    remote_length = sizeof(remote_address);
 
    printf("aguardando alguma conexao...\n");
    remote_socket = accept(local_socket, (struct sockaddr *) &remote_address, &remote_length);
    if(remote_socket == INVALID_SOCKET)
    {
        WSACleanup();
        closesocket(local_socket);
        msg_err_exit("accept() failed\n");
    }
 
    printf("conexao estabelecida com %s\n", inet_ntoa(remote_address.sin_addr));
    printf("aguardando mensagens...\n");
    do
    {
        // limpa o buffer
        memset(&message, 0, BUFFER_SIZE);
 
        // recebe a mensagem do cliente
        message_length = recv(remote_socket, message, BUFFER_SIZE, 0);
        if(message_length == SOCKET_ERROR)
            msg_err_exit("recv() failed\n");
 
        // exibe a mensagem na tela
        printf("%s: %s\n", inet_ntoa(remote_address.sin_addr), message);
    }
    while(strcmp(message, EXIT_CALL_STRING)); // sai quando receber um "#quit" do cliente
 
    printf("encerrando\n");
    WSACleanup();
    closesocket(local_socket);
    closesocket(remote_socket);
 
    system("PAUSE");
    return 0;
}

WSAStartup()

A função WSAStartup() inicia o Windows Sockets Dynamic Link (WinSock DLL). Ela também é usada para confirma a versão do WinSock DLL. Estamos utilizando a 2.0.

Declaração:

int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);

O parâmetro wVersionRequested é número da maior versão que a aplicação pode usar. Repare que ele é uma WORD onde o byte de maior ordem especifica a número da minor version e o byte de ordem menor indica a major version. Por isso eu utilizo a função MAKEWORD para retornar uma WORD (e facilitar minha vida), por exemplo, se quiser usar a versão do WinSock 1.1 é só alterar para MAKEWORD(1, 1). Fácil demais...

O parâmetro lpWSAData é um ponteiro para um estrutura WSADATA que receberá os detalhes da implementação do WinSock.

Se der tudo certo a função retornará 0. Se ocorrer um erro você pode usar a função WSAGetLastError() para saber mais detalhes.

socket()

Use a função socket() parar criar o socket \o/.

Declaração:

SOCKET WSAAPI socket(int af, int type, int protocol);

O parâmetro af especifica o "address family" que este socket usa. Nós iremos usar o AF_INET. A versão 1.1 do WinSock só suporta o formato AF_INET.

Alguns formatos possíveis:
AF_INET: Arpa Internet Protocols
AF_UNIX: Unix Internet Protocols
AF_ISSO: Iso Protocols
AF_NS: Xerox Network System Protocols

Se você olhar no header (winsock.h) vai encontrar outros como o AF_FIREFOX, mas é melhor ver quais realmente podem ser usados no MSDN.

O parâmetro type especifica o tipo do socket, no nosso caso é SOCK_STREAM (utilizado na maioria dos programas), mas você pode usar o SOCK_DGRAM (UDP), mas não vou abordar as diferenças entre eles.

Em protocol deixe 0 (zero), isto indica que o socket irá usar o valor padrão. O protocol pode ser o padrão porque a combinação do AF_INET+SOCK_STREAM já indica que o protocolo é TCP. Eu coloquei IPPROTO_TCP no código, mas não precisa, é só deixar como 0.

Alguns valores possíveis para o protocol:
IPPROTO_IP: Internet Protocol (0)
IPPROTO_ICMP: Internet Control Message Protocol (1)
IPPROTO_IGMP: Internet Group Multicast Protocol (2)
IPPROTO_GGP: Gateway-Gateway Protocol (3)
IPPROTO_TCP: Transmission Control Protocol (6)
IPPROTO_UDP: User Datagrama Protocol (17)

Se der tudo certo a função irá retornar o socket descriptor, que é um número que identifica o socket criado. Se falhar irá retorna INVALID_SOCKET, você pode usar a função WSAGetLastError() para saber mais detalhes do erro.

bind()

Agora precisamos dar nomes aos bois, precisamos dizer que o nosso socket se chama "192.168.0.1", por exemplo. Usaremos a função bind() para isso.

Declaração:

int bind(SOCKET s, const struct sockaddr *addr, int namelen);

O parâmetro s é o socket descriptor retornado pela função socket(). O parâmetro addr é um ponteiro para uma estrutura do tipo sockaddr. O namelen é o tamanho em bytes da estrutura, use a função sizeof() para isto.

Esta parte pode confundir, antes de usar a função bind() nós precisamos conhecer as estruturas sockaddr, sockaddr_in e in_addr, mas a que iremos utilizar é a sockaddr_in.

Definições da estrutura sockaddr:

struct sockaddr
{
    u_short sa_family; // address family
    char sa_data[14]; // address
};

O item sa_data da estrutura vai depende do "address family". No WinSock 1.1, como eu disse, apenas o AF_INET é suportado, logo somente um "endereçamento de internet" é suportado no sa_data. Lembrando que você não vai utilizar esta estrutura, mas eu coloquei porque ela aparece em um "cast" de um dos parâmetros da função bind() que estamos utilizando. Você deve utilizar uma outra estrutura no lugar da sockaddr quando chamar a função bind(), use a sockaddr_in.

Definições da estrutura sockaddr_in:

struct sockaddr_in
{
    short sin_family; // address family
    u_short sin_port; // port
    struct in_addr sin_addr; // internet address
    char sin_zero[8]; // to make a beautiful cast
};

Primeiro você deve zerar a estrutura e depois preencher alguns itens. No código que eu fiz está assim:

struct sockaddr_in local_address;
/* ... */
memset(&local_address, 0, sizeof(local_address)); // zera a estrutura
 
local_address.sin_family = AF_INET;
local_address.sin_port = htons(local_port);
local_address.sin_addr.s_addr = htonl(INADDR_ANY);

Importante!
Nem todos os computadores armazenam os dados na mesma ordem na memória. Existem computadores que trabalham no formato "Big Endian", onde byte menos significativo fica no endereço de memória de maior valor. Por exemplo, para armazenar o número 0x01234567 ficaria assim:
endereço 0x101: 01
endereço 0x102: 23
endereço 0x103: 45
endereço 0x104: 67

O maior endereço é o 0x104 e o byte menos significativo de 0x01234567 é o último da direita (67).

Já nos computadores "Little Endian", ocorre o inverso, o byte menos significativo fica no endereço de memória de menor valor:
endereço 0x101: 67
endereço 0x102: 45
endereço 0x103: 23
endereço 0x104: 01
O menor endereço é o 0x101 e o byte menos significativo de 0x01234567 é o último da direita (67).

Os computadores com processadores baseados no Intel x86 são "Little Endian", mas a ordem dos bytes na rede (network) é "Big Endian". Precisamos converter os dados antes de enviá-los usando as funções htons() e htonl():
htons(): converte um unsigned short (host-to-network)
htonl(): converte um unsigned long (host-to-network)

Existem outras funções para esta converter os dados, mas nós iremos utilizar apenas esses.

Voltando a estrutura sockaddr_in, vamos falar do item sin_addr. Veja na declaração que este item é uma estrutura do tipo in_ddr.

Definições da estrutura in_addr:

struct in_addr
{
    union
    {
        struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
        struct { u_short s_w1,s_w2; } S_un_w;
        u_long S_addr;
    } S_un;
    #define s_addr S_un.S_addr
    #define s_host S_un.S_un_b.s_b2
    #define s_net S_un.S_un_b.s_b1
    #define s_imp S_un.S_un_w.s_w2
    #define s_impno S_un.S_un_b.s_b4
    #define s_lh S_un.S_un_b.s_b3
};

Repare nos defines que ela possui, você pode acessar o dados da estrutura através deles. Quando você acessa local_address.sin_addr.s_addr na verdade esta acessando local_address.sin_addr.S_un.S_addr. Mas sempre use os defines para manter compatibilidade, não acesse os dados diretamente.

O valor indicado para local_address.sin_addr.s_addr é htonl(INADDR_ANY), isto indica que usaremos todos os endereços locais designados ao nosso servidor. Por exemplo, se sua máquina possui duas placas de rede (192.168.0.1 e 192.168.0.2), você pode usar os dois endereços para o seu socket. Mas se você quiser especificar apenas uma placa, use a função inet_addr(). Nós usaremos esta função para fazer o programa cliente.

Sobre o item sin_zero da estrutura sockaddr_in, ele server apenas para ocupar espaço, de modo que a estrutura tenha o mesmo tamanho (em bytes) da estrutura sockaddr. Assim podemos fazer "casts" de uma estrutura para outra (utilizado no parâmetro da função bind()). Por isso a estrutura deve ser preenchida com zeros antes de ser utilizada.

Se der tudo certo a função bind() retornará 0, caso contrário retornará SOCKET_ERROR, use o WSAGetLastError() para analisar o erro.

listen()

A função listen() coloca o socket para escutar as conexões. Seria como ligar o socket, agora ele pode receber por conexões dos clientes.

Declaração:

int listen(SOCKET s, int backlog);

O parâmetro s é o socket descriptor que você já conhece. O backlog indica quantas conexões pendentes o socket pode deixar na fila para serem processadas, quando as conexões são aceitas elas são removidas da fila. O mínimo para o backlog é 1 e o máximo 5, mas não achei alguma coisa no site do MSDN que indicasse que o limite é sempre 5.

Se tudo der certo ele vai retornar 0, caso contrário ele retornará um SOCKET_ERROR. Novamente você pode usar a função WSAGetLastError() para analisar o erro se quiser.

accept()

O accept() aceita a conexão quando ela é detectada.

Declaração:

SOCKET accept(SOCKET s, struct sockaddr* addr, int* addrlen);

O parâmetro s é o socket descriptor. O parâmetro addr é um ponteiro para uma estrutura do tipo sockaddr (igual ao do função bind()), nela a função irá armazenar a o endereço (estrutura) da entidade (cliente) que requisitou a conexão. Você não precisa armazenar este valor se não quiser obter informações do cliente, pode colocar apenas um NULL no lugar.

O parâmetro addrlen é um ponteiro onde a função irá colocar o tamanho em bytes da estrutura addr recebida do cliente. Se você passar um NULL para o parâmetro addr então o addrlen retornará NULL para o ponteiro. Você também pode apenas colocar um NULL no parâmetro do addrlen.

Repare que o programa ficará esperando por uma conexão, ele ficará meio travado enquanto isso. Você terá que fazer ele rodar de forma assíncrona, mas isso não é importante agora, primeiro temos que fazer o servidor e o cliente funcionarem.

A função accept() irá retornar um socket descriptor do cliente. Se der algum problema será retornado um INVALID_SOCKET. Novamente use o WSAGetLastError() para verificar os erros.

recv()

O recv() recebe os dados de uma conexão.

Declaração:

int recv(SOCKET s, char* buf, int len, int flags);

O parâmetro s é o socket descriptor do cliente. O parâmetro buf é o buffer onde serão armazenadas as informações recebidas. O len é o tamanho deste buffer.

O parâmetro flags indica o modo como serão recebidos os dados, eu deixei como 0 (zero) assim ele não fará nenhuma ação especial. Para mais detalhes sobre outras opções olhe no site MSDN.

O recv() irá retornar o total de bytes recebidos, mas você não irá receber mais bytes do que especificou em len. Ele retorna 0 (zero) quando a conexão é fechada normalmente. Se der algum erro ele retorna um SOCKET_ERROR. Use o WSAGetLastError() para saber mais do erro.

Repare que eu também usei a função inet_ntoa() para exibir junto com a mensagem. Essa função converte um endereço de Internet (IPv4) em uma string do endereço formatado nos padrões de Internet com pontos decimais. Ela já retorna em "Little Endian".

O recv() está dentro de um loop, antes de receber uma mensagem o buffer (variável message no código) deverá ser limpo. Após receber a mensagem, ela é exibida. O loop só pára quando o cliente enviar uma mensagem "#quit". Não é a melhor maneira de ser terminar o programa, mas serve por enquanto.

Depois de tudo pronto, nós devemos finalizar a aplicação com as funções WSACleanup() e closesocket(). Você só precisa olhar o código para entender como usa-las. E é isso, o micro-nano-humilde-servidor tá pronto agora só falta fazer o cliente.

Criando cliente que envia as mensagens

/*
    CLIENTE
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock.h>
 
#define BUFFER_SIZE 128
#define EXIT_CALL_STRING "#quit"
 
int remote_socket = 0;
int message_length = 0;
 
unsigned short remote_port = 0;
 
char remote_ip[32];
char message[BUFFER_SIZE];
 
struct sockaddr_in remote_address;
 
WSADATA wsa_data;
 
/* Exibe uma mensagem de erro e termina o programa */
void msg_err_exit(char *msg)
{
    fprintf(stderr, msg);
    system("PAUSE");
    exit(EXIT_FAILURE);
}
 
int main(int argc, char **argv)
{
    if (WSAStartup(MAKEWORD(2, 0), &wsa_data) != 0)
        msg_err_exit("WSAStartup() failed\n");
 
    printf("IP do servidor: ");
    scanf("%s", remote_ip);
    fflush(stdin);
 
    printf("Porta do servidor: ");
    scanf("%d", &remote_port);
    fflush(stdin);
 
    remote_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (remote_socket == INVALID_SOCKET)
    {
        WSACleanup();
        msg_err_exit("socket() failed\n");
    }
 
    // preenchendo o remote_address (servidor)
    memset(&remote_address, 0, sizeof(remote_address));
    remote_address.sin_family = AF_INET;
    remote_address.sin_addr.s_addr = inet_addr(remote_ip);
    remote_address.sin_port = htons(remote_port);
 
    printf("conectando ao servidor %s...\n", remote_ip);
    if (connect(remote_socket, (struct sockaddr *) &remote_address, sizeof(remote_address)) == SOCKET_ERROR)
    {
        WSACleanup();
        msg_err_exit("connect() failed\n");
    }
 
    printf("digite as mensagens\n");
    do
    {
        // limpa o buffer
        memset(&message, 0, BUFFER_SIZE);
 
        printf("msg: ");
        gets(message);
        fflush(stdin);
 
        message_length = strlen(message);
 
        // envia a mensagem para o servidor
        if (send(remote_socket, message, message_length, 0) == SOCKET_ERROR)
        {
            WSACleanup();
            closesocket(remote_socket);
            msg_err_exit("send() failed\n");
        }
    }
    while(strcmp(message, EXIT_CALL_STRING)); // sai quando enviar um "#quit" para o servidor
 
    printf("encerrando\n");
    WSACleanup();
    closesocket(remote_socket);
 
    system("PAUSE");
    return 0;
}

Essa parte vai ser mais rápida, pois já vimos o básico sobre sockets no servidor.

Você deve criar um socket no cliente para poder conectar ao servidor. Ele precisa preencher uma estrutura do tipo socketaddr_in (que nós já vimos) com as informações do servidor, olhe o código para entender melhor.

connect()

A função connect() irá conectar o cliente com o servidor.

Declaração:

int connect(SOCKET s, const struct sockaddr* name, int namelen);

Ele recebe parâmetros iguais ao da função bind(). Se der algum erro ele retorna um SOCKET_ERROR.

A função connect() tem o mesmo problema da função accept(), enquanto ele estiver tentando conectar ficará travado (precisa ser assíncrono), mas não vou mostra como se faz isso, fica como lição de casa XD.

send()

E o send() é a função responsável por enviar informações ao servidor.

Declaração:

int send(SOCKET s, const char* buf, int len, int flags);

Os parâmetro que ele recebe também são iguais ao da função recv(). O send() retonará o número de bytes enviados, esse número não será maior do len (e ele não enviará mais o que o especificado em len). Se der um erro ele retornará SOCKET_ERROR. Use o WSAGetLastError() para mais informações.

Lembre-se de limpar o buffer de mensagens, senão você irá enviar "lixo" para o servidor.

Pronto!

Compile os dois programas, depois execute primeiro o servidor depois o cliente. Se estiver rodando na mesma máquina você pode conectar o cliente no IP "127.0.0.1" que dará no mesmo. E é só isso, fácil demais não?

Para saber mais informações sobre o WinSock visite a página de referência da MSDN em Winsock Reference.

Bom, só isso não porque o código não se escreve sozinho... (hehe)
[python]
from VideoCapture import Device

# Aqui sua WebCam é ativada
cam = Device()

# Salva no diretório atual a imagem capturada deste instante
cam.saveSnapshot('image.jpg')
[/python]

Você também pode trabalhar com as imagens (PIL) diretamente:
[python]
from VideoCapture import Device

cam = Device()

# Retorna uma imagem PIL
im = cam.getImage()

width, height = im.size
red, green, blue = im.getpixel((x, y))
[/python]

Certas WebCams precisam "aquecer" antes que a imagem apareça limpa na tela, se for seu/meu caso é só colocar um delay depois de instanciar a classe Device:
[python]
from time import sleep
from VideoCapture import Device

cam = Device()
# Aquecendo (Oê!)
sleep(4)
[/python]

Agora vem a má notícia... Infelizmente o módulo VideoCapture só funciona no Windows.

Sem um controle seu jogo irá processar os gráficos na velocidade do processador. Os computadores tem velocidades diferentes e as aplicações não tem um processamento constante e igual, seu jogo poderá rodar a 124 FPS, mas se mexer o mouse irá para 81 FPS, por exemplo.

Antes de continuar você tem que conhecer o básico de como criar uma janela usando a Win32 API. Terá que usar também o PeekMessage ao invés do GetMessage no loop que pega os eventos (mensagens).

Agora vamos a lógica da coisa, você tem que "pausar" esse loop em determinados intervalos, por exemplo, se quiser 60 FPS terá que pausar 60 vezes por segundo de modo que no final a soma dos intervalos atinja 1 segundo. Para pausar use o Sleep, porém ele trabalha em milisegundos, mas é só dividir 1000.0 (milisegundos) por 60.0 (FPS).

Sleep(16.66);
// ou
Sleep(1000.0/60.0);

Pronto! Rápido e prático que nem miojo.

Agora se for um jogo pesado você terá que levar em contar o tempo de cada execução do loop. Use a função GetTickCount para capturar o tempo.

A cada loop some 16.66 ao tempo de execução do loop anterior, subtraia pelo tempo atual e o resultado será o tempo que o loop deve aguardar (Sleep). Se o resultado for negativo então o loop não deve aguardar.

Código abaixo pode ser mais esclarecedor:

// ...
int iSleepTime = 0;
BOOL bPeekMsgRes;
DWORD lastTime = GetTickCount();
 
while(1) // Main event loop
{
 
    bPeekMsgRes = PeekMessage(&Msg,
                              NULL,
                              0,
                              0,
                              PM_REMOVE);
   if(bPeekMsgRes)
   {
       if(Msg.message == WM_QUIT)
       {
           break; // Break main event loop
       } else {
           TranslateMessage(&Msg);
           DispatchMessage(&Msg);
       }
   }
 
   /* ---- Main game processing ---- */
   // Corta, pica e fatia no jogo...
 
   /* ---- FPS control ---- */
   lastTime += 16.66;
 
   iSleepTime = lastTime - GetTickCount();
 
   if(iSleepTime > -1)
   {
       // Normal
       Sleep(iSleepTime);
   } else {
       // Lento
       printf("OMG! Tá lento isso hein?\n");
   }
}
 
/* ---- Game Over ---- */
// ...

obs: Tem um "printf" ali que só vai aparecer se a janela tiver um prompt. Você pode compilar sua aplicação/jogo/miojo para que seja exibido o prompt junto, não sei como se faz isso no VisualC++, mas no DevC++ (GCC) crie um projeto "Win32 Console" ou compile com "-mconsole".