segunda-feira, 2 de novembro de 2009

Curso de C: Aula 7 - Funções

Como o nome diz, intuitivamente, são "coisas" que desenvolvem tarefas, saõ como caixas pretas, onde você passa algum tipo de dado, e espera receber algum tipo de saída. Explicando tecnicamente, são módulos ou blocos de código que executam uma determinada tarefa.

As funções existem, por dois motivos básicos: depuração de erros, quando se quebra um problema em pedaços menores, fica mais fácil detectar onde pode existir um problema. Outro motivo é a reutilização. É visível que grande parte dos códigos que existem em um programa são repetidos, só se diferenciando as variáveis que são passadas a eles.

Podemos dar nomes as funções assim como em variáveis, lembre-se da aula passada. Letras de A até Z, sem preocupação de case (maiúscula/minúscula), de 0 a 9 e com underscore (aquele menos achatado, "_"). Precisa começar por um caracter ou underscore. É sensitivo a case, ou seja, funções com o mesmo nome, mas letras diferentes (em case) não são consideradas iguais. Podemos exemplificar: esta_e_uma_funcao e Esta_e_uma_funcao, o "E" ("e") é diferente!

A cara de uma função em C é assim:

tipo nome(tipo1 var1, tipo2 var2, ...)
{
código1;
.
.
.
códigoN;
}



void diminuir(int parcela1, int parcela2)
{
int total;
total = parcela1 - parcela2;
printf ("A subtracao vale: %d",total);
}

Ignore a palavra void por enquanto, acredite que ela quer dizer nada pelo momento. Quando a chamo, diminuir(5,3);, eu recebo a mensagem da subtração de 5 por 3, e retorno ao meu programa.

Note que as chaves ({ e }) delimitam o que é da função (bloco) e o que não é.

A função main()

A função main() é a função principal de um programa. Ou seja, todo programa tem que ter a função main(), caso contrário o compilador reclama e não gera o executável.

Um programa começa executando a função main(). E um programa termina, quando esta função termina. Porém, dentro da função main() você pode chamar (executar) outras funções. Falaremos mais sobre o main() adiante.

Podemos chamar (executar) as funções do ponto que desejamos, desde que ela já tenha sido declarada. Ela desvia o fluxo do programa, por exemplo:

main()
{
int a=10,b=3;
ação1;
ação2;
diminuir(a,b);
ação3;
}

Nota: neste exemplo ação 1, 2 e 3, podem ser qualquer comando (Até mesmo outra função).

O programa desviará o fluxo, após a "ação2", quando ele chamar a função diminuir. isto suspenderá temporariamente a execução do programa para poder executar a função diminuir, até que a mesma termine (retorne).

Existem basicamente, dois tipos de funções. Aquelas que retornam alguma coisa a quem a chamou e aquela que não retorna nada.

Começando pelas que não retornam, elas simplesmente realizam tarefas, como o exemplo anterior. Ela faz uma série de passos, e retorna o fluxo ao programa principal, sem interferir em nada em sua execução, a não ser pelo tempo perdido e saída na tela.

Outra opção são funções que retornam um valor de um tipo. Lembre-se, como declaramos uma função? tipoX nome(tipo1 var1,tipo2 var2); e assim vai. Ou seja, o tipoX eqüivale ao que a função vai retornar. Vamos entender:

int diminuir(int parcela1, int parcela2)
{
int total;
total = parcela1 - parcela2;
return total;
}

main()
{
int a=10,b=3,total;
ação1;
ação2;
total = diminuir(a,b);
printf ("A subtracao vale: %d",total);
ação3;
}

O efeito é exatamente o mesmo, só que agora o programa principal é que estará jogando a mensagem na tela e a variável do programa, chamada total, que terá o valor da subtração (resultado, tipo int, retornado de diminuir(a,b)). Aos poucos vamos juntando as peças.

O que determinou a saída da função, no caso, foi a chamada ao comando return, que interrompe o fluxo do bloco que está sendo executado (saindo deste bloco) e volta aquele imediatamente anterior. Não é necessário chegar até a última linha da função, o return pode estar na 1a, 2a, onde quer que seja.

O que é o main?

main() também é uma função, é a função que é obrigada a existir em todos os programas. Como já disse, tal função é procurada e a primeira a ser executada em todo programa.

Ela pode retornar um valor de tipo int. Ou seja, retorna um número, em geral para o sistema operacional, com o código de sucesso ou indicando qual o erro (número do erro) ocorreu durante a execução do programa.

segunda-feira, 12 de outubro de 2009

Curso de C: Aula 6 - Variaveis

Me desculpem a demora na postagem e obrigado pelo e-mails de vocês, continuem mandando. Quanto ao conteúdo, falaremos de variáveis! Ou seja, uma assunto interessante. Essa aula juntará com a próxima, será uma seqüência importante e conceitos indispensáveis para programação em qualquer linguagem. Vamos lá ..

O que são variáveis?

São espaços reservados que guardam valores durante a execução de um programa. Como o nome diz, elas tem a capacidade de "variar" no tempo. Em geral, são exatamente um pedaço de memória (o tamanho depende do que se esteja guardando) no qual botamos alguma informação e podemos nos referir a ela, utilizá-la, alterá-la ou fazermos o que bem entendermos durante a execução de um programa.

Toda variável tem um nome pela qual é chamada (identificada) e um tipo (o que ela guardará). Os nomes podem ser de uma letra até palavras. Obrigatoriamente deve começar por uma letra ou underscore (o sinal de menos achatado: "_"). O restante pode ser letras de A até Z, maiúsculas, minúsculas, números e o underscore. Exemplos: e, variável _essa_e_uma_variavel, tambem_variavel. Vale ressaltar que ela é sensível a case, o que significa que diferencia maiúsculas e minúsculas.

As variáveis possuem tipos, como dito anteriormente. Os tipos dizem ao compilador que tipo de dado será armazenado. Isso é feito com o intuito do compilador obter as informações necessárias sobre quanto de memória ele terá que reservar para uma determinada variável. Também ajuda o compilador com uma lista de variáveis em um lugar reservado de memória, para que ele possa fazer referências, checar nomes e tipos e que possa determinar erros. Basicamente possibilita uma estrutura bem definida do que é usado e uma arrumação conveniente na memória.

Tipos de dados em C

Existem vários tipos de dados em C. Todos eles são palavras reservadas. O C é bem flexível e possibilita a criação de tipos (iremos ver isso em outra oportunidade). Agora vamos aos tipos mais usuais, já dá para o começo.

char: Caracter unitário (só 1 mesmo)
short int: inteiro "pequeno"
int: um inteiro (em geral 32 bits)
float: número real
double: número real grande
Existem também os tipos void, enum, volatile que citaremos futuramente. Não podemos esquecer dos ponteiros, que falaremos também em futuros capítulos.

Outro detalhe, existe a possibilidade de se colocar a palavra unsigned, que significa não sinalizado, antes de um tipo. Isso quer dizer que um inteiro, por exemplo, que varia entre -32.768 até 32767 (isso calcula-se através do tamanho máximo que ele pode ocupar em memória) variaria só de 0 em diante. Ou seja, o espaço do menos seria utilizado para mais um número, ficaríamos com 0 até 65535, gastando o mesmo espaço de memória só que de forma diferente.

Declarando minha primeira variável

Para declarar uma variável, precisamos apenas dizer o tipo da variável, seguida de uma lista dos identificadores (nomes), separado por vírgula. Por exemplo:

char ch;
int i,j;
double x,y,z;

É muito interessante a forma que o C trabalha com variáveis, desde a declaração, passagem de parâmetros e todos tipos de operações com variáveis, ele checa, e torna os problemas referentes a isso mais facilmente de serem detectados.

Variáveis Globais x Locais

Existem basicamente dois tipos de varáveis, as locais e as globais. As locais são aquelas que só o pedaço (pedaço == função e será explicado na próxima aula) do programa que a pertence poderá alterá-la. Já a global, todo programa poderá mexer com ela. Citaremos exemplos mais específicos depois, fique tranqüilo se foi muito abstrato.

Inicializando variáveis

As variáveis em C, em geral, não são necessariamente zeradas quando são declaradas. Vamos pensar, as variáveis são pedaços de memória, quando resolvo declarar alguma variável, estamos associando um nome com um pedaço da memória.

Este pedaço de memória pode estar sujo, ou algo assim, e acaba interferindo no que vou utilizar numa variável que seria "limpa". Por isso, torne uma prática dar valores (iniciar) as variáveis antes de utilizá-las.

Podemos fazer isso de duas formas, inicializando ao declará-las, assim:

int i = 0;
float j = 2.0;

Ou podemos:
int i;
float j;

i = 0 ;
j = 2.0 ;

Normalmente você deve utilizar a declaração que torne seu programa mais claro para você. Lembre-se, clareza é muito importante em um programa, artigo passado falamos disso.

Escolhendo variáveis

Ao se escolher uma variável, você deve pensar:

Qual tipo de variável é preciso para aquele dado;
Escolher um nome claro para ela;
Qual será a área de atuação da variável (ficará mais claro na próxima semana)
Mediante a isso, basta declara-la.

Algumas variáveis já se tornaram consagradas, como o char ch, ou o int i,j,k, para controle de laços.

É isso pessoal, próxima aula tem mais .

domingo, 27 de setembro de 2009

Curso e C - Aula 5: Arquivos

Hoje vou "esticar" um pouco mais o assunto mas semana que vem piora! Estou brincando, vamos lá que tem muito o que falar .. fiquem tranqüilos, tudo é normal e o aprendizado sempre faz parte de uma fase, depois as coisas vão se encaixando e fica tudo mais tranqüilo, todos conseguirão superar.

Extensões de arquivo

Existe uma convenção usada pelos compiladores para denominarmos os programas escritos em C e todos elementos que se referem ao conjunto programa. As denominações encontradas são:

O fonte do programa: nome_do_programa.c
Arquivo Objeto: nome_do_programa.o
Arquivo no formato executável: nome_do_programa ou nome_do_programa.exe (não Linux)
Arquivo de cabeçalho: Nome_da_Biblioteca.h
Biblioteca: libNome_da_Biblioteca.so libNome_da_Biblioteca.a

O final do arquivo após o ponto (c,o,a,so ou nada) identifica o tipo de arquivo para o compilador. Ele usa isso para gerar o executável. Os arquivos objeto e executável podem ser deletados sem problemas, são fáceis de serem gerados. Já o .c é o fonte do programa, ele que contém o código real do que o programa fará. Para executar o compilar, você deve:

cc -o nome_do_executável nome_do_programa.c

Que chama o CC, ou, C Compiler, em geral o GCC, compilador C da GNU.

Um detalhe interessante de se saber é como parar a execução de um programa. Todo sistema tem sua forma particular de fazer isso. Em geral, devemos pressionar Ctrl (tecla Control) junto com C, ou junto com Z, ou mesmo D.

Outra, o comando ls é equivalente ao DIR do DOS e permite listar os arquivos do diretório atual. O comando cd, change dir, também é equivalente a outros sistemas, serve para trocar de diretório.

O arquivo de cabeçalho mais comum existente hoje é o padrão de entrada/saída, da biblioteca C padrão.

Para incluir um cabeçalho, adicione ao código fonte:
#include cabecalho.h
em cima do programa.

#include "meu_cabecalho.h"
para incluir um arquivo pessoal, que esteja no diretório atual.

#include quando ele se encontra em um dos diretórios padrão, como /usr/include.

A diretiva #include é um comando para o pré-processador, que falaremos em outra semana.

Existem situações que não precisamos dizer cabeçalho algum ou ter bibliotecas chamadas explicitamente, todo programa utiliza a biblioteca c padrão, libc. Sempre. Ou seja, programas que utilizam de suas funções não precisam que a chamem explicitamente.

#include
main() {
printf ("Biblioteca C padrão incluida\n");
printf ("Cozinhando com C e Linux!");
}

Um programa que use funções matemáticas, como por exemplo "seno", precisará adicionar os cabeçalho da respectiva biblioteca matemática.

#include
#include

main ()

{
double x,y;

y = sin (x);
printf ("Biblioteca matemática ok!");
}

Existem variações de sistema para sistema. Isso em relação a mouse, desenhos de janelas, propriedades do terminal e várias outras situações. Necessariamente, você terá que procurar no manual do sistema (man função, uma ajuda e tanto) ou do compilador.

Não importa quantas bibliotecas você usará, sua limitação será em geral memória, toda biblioteca adiciona o fonte e o código objeto. Sistemas Operacionais como o Linux tem a capacidade de distinguir e pegar apenas as funções que interessam. Já outros, são obrigados a adicionar todos os códigos na memória, e depois de já ter perdido tempo e espaço.

A forma de um programa em C

C é uma das linguagens mais flexíveis em termos de formato já existentes. É uma linguagem livre de formato. Isso quer dizer que não existem regras de onde quebrar linhas, botar chaves, e assim vai. Isso é ao mesmo tempo vantajoso mas perigoso. A vantagem é que o usuário tem a liberdade para criar um estilo que melhor lhe atenda. A desvantagem é que programas "bizarros" podem aparecer, e de impossível manutenção. Algumas dicas de se escolher uma estrutura bem definida:

* Programas maiores são de gerenciamento possível só se estiverem bem organizados.

* Programas são entendidos somente se os nomes de variáveis e funções condizem com o que fazem.

* É mais fácil achar partes de um programa se ele tiver bem ordenado, é impossível num programa totalmente desorganizado e "macarrônico" se achar algo.

Simplesmente regras rígidas na hora de escrever um programa não significam que ele terá êxito. Experiência na programação, muito bom senso e clareza de idéias são fatores decisivos na hora de se programar.

Até a próxima semana.

terça-feira, 22 de setembro de 2009

Curso de C: Aula 4 - Conceituações necessárias

Como foram de descanso? Semana passada realmente estava meio sem tempo, e resolvi aumentar o nível esta semana. Vamos ver a opinião de vocês no final, vou adiantando que hoje muita coisa é referência e de cultura geral, mas tem muitos conceitos novos e necessários.

Falamos de alguns conceitos de Sistemas Operacionais, características poderosas herdadas dos velhos e robustos sistemas Unix e várias outras coisas.

Caso tenham problemas para entender de primeira, releiam o texto, é sempre o recomendado. Muitos não fazem isso, me mandam e-mail, sem problemas.

Vale ressaltar que dúvidas são comuns e sempre nos depararemos com elas, mas transpassaremos e chegaremos ao nosso objetivo.

Então...mãos na massa!

Quem realmente controla os programas?

Quem controla as ações mais básicas de um computador, é o Sistema Operacional. É o que podemos chamar de camada de software, que faz a interface (comunicação) entre os usuários e o Hardware(parte física da máquina, placas, circuitos, memórias). O objetivo básico é controlar as atividades do Hardware e prover um ambiente agradável para o usuário do sistema, que ele possa trabalhar com maior grau de abstração(se preocupar menos com problemas relativos ao tipo de máquina, como ela funcione e pensar mais no problema real que tem de ser resolvido).

O Sistema Operacional(SO), tem dois componentes básicos importantes para o usuário : sistema de arquivos e interpretador de comandos. O SO é que coordena todo tráfego de saída e entrada de informações. Por exemplo, ele que determina o que vai para a tela, o que vem do teclado, movimentos do mouse, etc...

O Interpretador de comandos aceita toda interação com o usuário, e faz todo trabalho de gerenciamento, analisando o que vem do usuário, por exemplo, e entregando para o SO de forma que ele entenda. Ele é uma interface, digamos assim, entre usuário e SO. Faz com que eles falem a mesma língua, para simplificar a história.

O interpretador de comandos é conhecido no mundo Linux como SHELL (pode variar para outros sistemas).

Interfaces Gráficas

Uma questão interessante é separarmos os termos, Back-end e Front-end. Back-end, é a parte core(a parte interna, o código que executa realmente as tarefas). A parte gráfica é conhecida como Front-end, é uma capa, como se fosse a casca, embalagem, a apresentação do trabalho. Não há dúvidas, que situações existam que essa "cara bonita" necessariamente deve aparecer.

As linguagens de programação e o C

Quando várias das linguagens de programação antigas foram desenvolvidos, elas foram criados para rodar em computadores de grande porte(grandes máquinas de tamanhos de prédios, depois andares, depois salas...), Sistemas Multi-Usuários(vários operadores usando o sistema ao mesmo tempo), time-sharing((tempo compartilhado), todos esses usuários dividiam uma fração(parte) da unidade de processamento) e eram incapazes de interagir diretamente com o usuário(vários detalhes técnicos são citados meramente como curiosidades para aprendizado histórico, não se preocupe caso tenha fugido algo).

O C é diferente de tudo isso pois possui um modelo de implementação de forma bem definida, e melhor desenhado. Podemos dizer que o C é um primor em termos de design. Todos mecanismos de entrada/saída de dados não são definidos como partes fixas da linguagem, imutáveis e embutidos no código. Existe um arquivo padrão, que deve ser declarado(explicaremos, mas podemos entender como chamado, utilizado) no começo do programa, que ensina ao C como ele deve se comportar em situações de entrada/saída, no computador que ele está rodando.



Quando mudamos de arquitetura, é só mudar este arquivo. Ele é conhecido como Biblioteca C padrão(ainda explicaremos melhor isso tudo). Ela é padrão no sentindo de implementar(ter para executar) um conjunto de instruções que todos os computadores e SO's devem implementar, mas são especialmente adaptados ao seu sistema atual. Basicamente, ela existe em todos os tipos de sistemas, funciona de forma padrão, mas, é internamente escrita para a arquitetura de computador que você está utilizando(arquitetura == tipo). Lembre-se, não se vive simplesmente da arquitetura Intel, i386. Existem diversas outras por aí, uma característica marcante do C é sua portabilidade(capacidade de rodar em múltiplas plataformas).



Dispositivos de Entrada/Saída

O Sistema de Arquivos do Linux pode ser considerado parte ativa do Sistema de Entrada/Saída, fluxo de dados, em sistemas Unix-Like(Linux também). Em vários SO's, ele próprio coordena os recursos/movimentação entre entrada/saída, isso tudo através de arquivos ou fluxo de dados.

O C faz isso tudo implícito (herdado dos Unix). O arquivo de onde o C geralmente pega a entrada, chama-se stdin, que quer dizer Standard Input(ou entrada padrão). Ele geralmente costuma ser o Teclado. O arquivo correspondente para saída, é conhecido como stdout, ou Standard Output (saída padrão). O monitor de vídeo faz esse papel.

É importante deixar claro, que o monitor e nem o teclado, são arquivos. Eles são periféricos reais(não é possível reler algo que foi enviado ao monitor ou rescrever para o teclado).

Devemos representa-los através de arquivos, mas devemos entender, que o arquivo de entrada padrão, teclado, serve apenas para leitura. Já o monitor, de saída padrão, simplesmente trabalha com escrita. Nota-se, características de escrita e leitura bem definidos.

Porque utilizá-los ?

Uma boa explicação para utilizarmos os tais arquivos é nos abstermos de como funcionam a fundo, é realmente essa "camada" de abstração. Pensarmos simplesmente em utiliza-los (tudo ficará claro com o tempo). Com isso criamos essa camada que pode ser utilizado com diversos outros tipos de periféricos, de forma igualmente transparente e fácil.

Os nomes do arquivos de dispositivos, em geral são conhecidos por abreviaturas de seus nomes originais. A impressora, por exemplo, é conhecida como LP, ou Line Printer.

Por hoje é só. O que acharam ? Espero que tenham gostado, aguardo o feedback. Até a próxima !

segunda-feira, 14 de setembro de 2009

Curso de C - Aula 3: Palavras Reservadas

Oi pessoal! O que acharam da semana passada? Não se preocupem se não entenderam alguns detalhes, e' só mandar e-mail. Muitas das questões tratadas nas postagens passadas são teóricas demais e demora um tempo para se acostumar. A programação em si é mais fácil do que parece. Nesta nova postagem, trataremos de algumas coisas interessantes, entre elas as palavras reservadas do C.

O que vem a ser palavras reservadas? São palavras que têm significado especial na linguagem. Cada palavra quer dizer alguma coisa e em C as instruções são executadas através do uso de palavras chaves previamente determinadas que chamaremos de palavras reservadas. Elas não poderão ser usadas para outras coisas, alem do determinado para o C, mas entenderemos mais a fundo o que isso quer dizer com o tempo.

Para o C conseguir trabalhar ficaria complicado distinguir quando uma dessas palavras especiais forem usadas como variáveis ou com instruções. Por isso, foi determinado a não utilização desta para outra coisa senão comando e afirmativas.

Abaixo está a lista dessas palavras. Relembrando, o C entende, tais palavras apenas em letras minúsculas (não funcionará se você colocar em maiúsculas).


auto, break, case, char, continue, default, do, double, else, entry, extern, float, for, goto, if, int, long, register, return, short, sizeof, static, struct, switch, typedef, union, unsigned, while, enum, void, const, signed, volatile.

Todo conjunto de palavras reservadas acima são o conjunto das instruções básicas do C. Aparentemente, parecem poucas e você na prática usará apenas algumas poucas delas. Tal fato acontece pois uma das facilidades do C é a utilização muito natural de bibliotecas que funcionam como acessórios para o C (como plugins do seu netscape). Tais bibliotecas (conjunto de funções) não fazem parte intrínseca do C, mas você não encontrará nenhuma versão do C sem nenhuma delas. Algumas são até tratadas como parte da linguagem por serem padronizadas.

Bibliotecas
Como dito anteriormente, funções são uma forma genérica de resolvermos problemas. É como uma caixa preta, você passa os dados para ela e recebe o resultado.

Vamos supor que tenho uma função de realizar soma, eu só me preocupo em passar para ela os números que desejo ver somado e a função se preocupa em me entregar o resultado, o que acontece lá dentro é problema dela.

Através deste método, dividimos os programas em pedaços de funcionalidades, genéricos e pequenos de preferência, com intuito de utiliza-lo futuramente em situações que sejam convenientes.

Assim como soma, pode-se fazer uma função de subtração, multiplicação, divisão e várias outras e juntando-as se cria a tal famosa biblioteca.

As bibliotecas em si podem ser utilizadas por vários programas. Estes utilizam os subprogramas(funções!) desta mesma biblioteca tornando o programa gerado de menor tamanho, ou seja, o executável só vai possuir as chamadas das funções da biblioteca e não o incluirá no executável.

Só para esclarecer, tenho uma biblioteca que desenha botões em janelas(GTK faz isso). Na hora que se for criar uma agenda, por exemplo, utilizo as funções desta biblioteca sem precisar rescrever estas mesmas funções neste programa.

Em geral, utilizamos algumas funções já prontas para fazer determinadas tarefas que são consideradas básicas. O programador não costuma fazer uma rotina que leia diretamente do teclado ou imprima na tela um caracter.

Isso já existe e é bem implementado (uma coisa interessante de se entender em programação é, o que já existe de bem feito e pode ser utilizado deve ser utilizado). Seu sistema não será menos digno ou pior se você utilizar uma rotina que todo mundo utiliza em vez de ter a sua própria. O que importa e a finalidade do programa e o quão bem implementado ele esteja.

Tais funções que falamos, básicas, fazem parte da biblioteca C padrão (citada acima). Todo compilador C a possui, ele faz parte da padronização ANSI C. Seu compilador, independente do sistema que você utiliza, deve possuir. Outras bibliotecas a mais, além das padronizadas pelo ANSI, também vem junto com seu compilador porém não é recomendado a utilização, caso você queira escrever programas portáveis (que rode em todas as plataformas). Podemos aqui citar programação gráfica, de rede, etc como casos que são "perigosos" para programação portável. Não estou dizendo que você não deve programar para estas áreas, futuramente haverão tutoriais para essas áreas por aqui, porém deve atentar-se que tal programação é peculiar a plataforma que você está utilizando e fazer algo padronizado portável torna-se quase impossível.

Printf():
Se desejamos citar uma função invariável e já consagrada que não é da linguagem C, porém já pode até ser considerada é a função printf(). Ela está contida na biblioteca padrão de entrada/saída (a barra eqüivale a palavra e tal biblioteca se chama stdio.h, o .h eqüivale a terminação de biblioteca, header em inglês).

A função printf quer dizer print-formated, ou imprimir formatado. A maneira mais simples de imprimir algo é:

printf("algum texto aqui!");

Bem, comecemos então. Caso você não queira imprimir uma coisa fixa, um texto, mas sim algo que varie durante a execução de um programa, digamos uma variável. Chamemos de controladores de seqüência os caracteres especiais que significarão as variáveis que serão impressas pela função. O lugar onde o controlador for colocado é o lugar onde a variável será impressa. Por exemplo, caso queiramos imprimir um inteiro.

printf ("O inteiro vale: %d, legal!", algum_inteiro);

A saída será:

O inteiro vale: 10, legal!

onde 10 é o valor dado a variável chamada "algum_inteiro" (sem aspas)

Exemplo básico de um programa em C:
/*************************************************************/

/* Primeiro exemplo */


/************************************************************/

#include /* Aqui incluímos a biblioteca */

/* C padrão de Entrada/Saída */

/***********************************************************/

main () /* Comentários em C ficam nesse formato! */

{

printf (" nosso exemplo número %d em C !", 1);

printf ("Hello World! Que desse exemplo número %d surja o %d .. \n", 1, 1+1);

printf ("E depois o %d ! \n", 3);

printf (" To meio sem criatividade e venceu de %d X %d de mim!", 1000, 0);

}

Saída:

nosso exemplo número 1 em C !
Hello World! Que desse exemplo número 1 surja o 2 ..
E depois o 3 !
To meio sem criatividade e venceu de 1000 X 0 de mim!

Até semana que vem !

domingo, 6 de setembro de 2009

Curso de C - Aula 2: Compilador

Terminei a postagem da semana passada falando de compiladores, espero que tenham gostado.

Vamos relembrar pontos interessantes: Usar um compilador, uma linguagem compilada não é o mesmo que usar uma linguagem interpretada, como Perl. Existem diferenças na forma de execução. Porém, a implementação é opção de quem criou a linguagem.

Um programa em C é elaborado em dois passos básicos:

O programa é escrito em texto puro num editor de texto simples. Tal programa se chama "código fonte" (source code em inglês). Passamos o código fonte para o compilador que é o programa que gera um arquivo num formato que a máquina entenda.
O compilador trabalha, em geral, em duas fases básicas:

O compilador gera, através do código fonte, um código intermediário que ajuda a simplificar a "gramática" da linguagem. Como o processamento subsequente agirá: um arquivo "objeto" será criado para cada código fonte. Depois, o linkador junta o arquivo objeto com a biblioteca padrão. A tarefa de juntar todas as funções do programa é bastante complexa. Nesse estágio, o compilador pode falhar se ele não encontrar referências para a função.

Para evitar a digitação de 2 ou 3 comandos você pode tentar:

$ gcc fonte.c

ou

$ cc fonte.c

que evitará esse inconveniente.

Na maioria dos computadores, isso gerará um arquivo chamado "a.out", para evitar isso você pode utilizar a opção -o, assim fica:

gcc -o destino fonte.c

O seu programa se chamará destino e será o derivado do fonte chamado fonte.c.

Erros
Erros são provocados sempre pelo programador. Existem basicamente dois tipos de erros:Lógico e de Sintaxe

Os erros de sintaxe são os melhores que podem acontecer. Você é capaz de identificá-lo durante a compilação do programa. Ou seja, não existe um efeito desagradável na execução do programa, ele não pode fazer algo que seja impossível ou não determinado previamente na linguagem (==gramática).

Em geral, quando os compiladores encontram um erro não terminam imediatamente, mas continuam procurando e ao final do programa mostram indicativamente onde os erros se encontram e do que se tratam. É a mesma coisa que uma correção ortográfica, você nunca pode falar nada errado ortograficamente nem gramaticalmente, o compilador não deixa.

É bastante traumatizante para alguém, fazendo seu primeiro programa, obter um erro e ver diversas linhas de erro e avisos "estranhos". Não se assuste nem se desmotive, pode ser um simples ponto e vírgula ou um detalhe bobo. Com o tempo e a experiência você começará a se acostumar e aprender a lidar com isso.

Caso não tenha erros de escrita, o compilador transformará o seu código fonte (texto puro) em código de maquina (os tais 0's e 1's, o que a máquina entende) e você poderá executa-lo. Bem, e se a lógica do programa estiver errada? Este tipo de erro não pode ser detectado pelo compilador.

É como se você falasse todas as coisas certas, desse todas as ordens entedíveis para um empregado seu por exemplo porem com inconsistência de dados.

Exemplificando hipoteticamente, você pode falar com seu empregado e ele não entender o que você está expressando e assim ele não conseguirá executar a tarefa e reclamará. Por exemplo, falando em japonês com ele! (erro sintático). Você explica tudo certo para o seu empregado, ele entende tudo porém a explicação é inconsistente. Por exemplo, manda ele ir para uma rua que não existe ou comprar algo que não existe (erro de lógica).

Tais erros podem acarretar algumas conseqüências graves como o programa terminar repentinamente ou o programa funcionar incorretamente e gere dados inconsistentes

Alguns detalhes interessantes para você que está começando a programar, por exemplo, caso você tenha algum erro e conserte-o você é obrigado a compilar o programa novamente para que este tenha efeito, caso contrário o executável não reflitirá o atual código fonte, essa conversão não é automática.

Outro detalhe importante, o C, como tudo no mundo Linux/UNIX, difere letras maiúsculas e minúsculas (case sensitive em inglês). Ou seja, você tem que obedecer esse critério e atentar-se a isso. O comum é colocar tudo em minúsculas, com exceção das strings que ficam a gosto do programador.

Outra coisa importante, o C (como a maioria das linguagens atuais) exige que se faça uma listagem de todas as variáveis do programa previamente. Ou seja, não existe uso dinâmico de variáveis e tudo que você usa tem que ser previamente declarado.

É como na construção de um prédio, todo material (tijolos, cimento, madeira) tem que ser calculado e comprado antes pois na hora que você precisa usar um tijolo, você não fala, quero um tijolo e ele aparece na sua mão.

Exercício I
Algumas perguntas básicas que você deveria responder depois a primeira e segunda postagem sobre C Básico.

A linguagem C é alto ou baixo nível? Qual a relação de C com outras linguagens de programação nesses termos?

Qual a filosofia da linguagem estruturada? Qual a vantagem? Exemplifique.

A linguagem C é compilada ou interpretada? Qual diferença? Qual é melhor?

O que é um compilador?

Como um programa C roda?

Como se compila um programa em C?

As letras maiúsculas e minúsculas são diferenciadas?

Quais os tipos de erros que existem em C e qual é o preferível ?

quarta-feira, 2 de setembro de 2009

Curso de C - Aula 1: O primeiro passo

Introdução:
Começando uma seção de programação do nosso site e daqui para frente semanalmente vou colocar as aulas de C que estou convertendo para o formato ONLINE.

Com o intuito de uma introdução teórica, utilizaremos a linguagem C, a linguagem de programação mais utilizada no mundo. Vários dos meus artigos tem base em outros artigos/sites (a maioria do exterior, senão todos) como fonte de pesquisa. Procure por estes na área de links, sempre estarão disponíveis e serão muito úteis para consultas futuras e aprofundamento no assunto.

Não espante-se com alguns termos e vários conceitos novos, o ato de programar é mais fácil do que parece, não se assuste, com um pouco de leitura e tempo para praticar você pode tornar-se um bom programador C.

"Programar é o ato de pensar utilizando-se algumas padronizações (pré-definições). Aqui vou tentar direcionar como você deve canalizar seus pensamentos para resolver os problemas propostos e te colocar a frente das padronizações da linguagem C".

Programar é só isso, resolver problemas da vida real de forma "entendível" ao computador. Mostrar-lhe como você fez em uma linguagem que ele entenda.

Um bom programador C, o que você tende a ser tornar, é algo que está em falta no mercado. Se tem a idéia que o mercado de programação está saturado e tem programadores saindo pelas janelas. Não é verdade. O que não falta por aí na verdade são programadores de "linguagens" visuais e programas populares de propósito superficial e de rápida implementação que não servem para o "trabalho pesado", está área sim, está saturada. Fora que se você for administrar um ambiente UNIX, C será um diferencial no seu dia-a-dia. Pode apostar.

Irremediavelmente, quando uma empresa precisa fazer um programa "pesado" (algo robusto e flexível ao mesmo tempo, bem modelado e que utilize toda potencialidade possível de sua máquina) ela tem que utilizar o C, e a falta programadores desta área é notória. É uma mão de obra muito escassa e que cada vez mais ganha destaque e valor no mercado.

Como nem todos tem a sua disposição um servidor com UNIX ou não tem Linux eu vou usar recursos visuais, front-end gráfico que faz o programa parecer mais amigável, mas isso é casca, perfumaria ... na verdade não importa muito. O importante realmente são os conceitos, é o que está acontecendo por trás, como as coisas funcionam e justamente isso que será nosso enfoque.


Senta que lá vem História:
Em 1973, Dennis Ritchie, pesquisador da Bell Labs rescreveu todo sistema UNIX para uma linguagem de alto nível (na época considerada) chamada C (desenvolvida por ele), para um PDP-11 (o microcomputador mais popular na época). Tal situação de se ter um sistema escrito em linguagem de alto nível foi ímpar e pode ter sido um dos motivos da aceitação do sistema por parte dos usuários externos a Bell e sua popularização tem relação direta com o exponencial uso do C.

Por vários anos o padrão utilizado para o C foi o que era fornecido com o UNIX versão 5 (descrito em The C programming Language, de Brian Kernighan e Dennis Ritchie - 1978. Se você está interessado em saber mais, vá para a introdução).

Começaram a surgir diversos diversas implementações da tal linguagem e os códigos gerados por tais implementações era altamente incompatíveis. Não existia nada que formalizasse essas compatibilizações e com o aumento do uso das diversas "vertentes" da linguagem surgiu a necessidade de uma padronização, algo que todos devessem seguir para poderem rodar seus programas em todos os lugares que quisessem.

O ANSI (American National Standards Intitute, Instituto Americano que até hoje dita diversos padrões) estabeleceu em 1983 um comitê responsável pela padronização da linguagem. Atualmente, a grande maioria dos compiladores já suportam essa padronização.

Trocando em miúdos, o C pode ser escrito em qualquer máquina que se utilize de tal padrão e rodar em qualquer outra que também o faça. Parece inútil? Não, na verdade isso é a semente de grande parte dos avanços tecnológicos que toda programação nos tem proporcionado no mundo de hoje. Com o tempo isso ficará mais claro.

Características da Linguagem C:
C é uma linguagem que alia características de linguagens de alto nível (como pascal, basic) e outras de baixo nível como assembly. O que isso quer dizer? Que C junta flexibilidade, praticidade e poder de manipulação da máquina diretamente e, por isso, não traz as limitações dessas linguagens, como dificuldade de uso, limitações na operação, etc. C permite liberdade total ao programador e este é responsável por tudo que acontece, nada é imposto ou acontece simplesmente ao acaso, tudo é pensado pelo programador e isso significa um bom controle e objetividade em suas tarefas, o que não é conseguido em outras linguagens que pecam em alguma coisa.

C é uma linguagem que podemos chamar de estruturada. Não queremos nos ater muito a nomenclaturas, mas ling. estruturadas são linguagens que estruturam o programa em blocos para resolver os problemas. A filosofia básica de uma linguagem estruturada é dividir para trabalhar, você divide um problema em pequenas partes que sejam possíveis de serem feitas. Por exemplo, temos um problema grande que é impossível de se resolver sozinho, dividimos este problema em pequenas partes simples que se integrando os pedacinhos acabam resolvendo o problema maior complexo.

Outra coisa atrelada a essa idéia básica de dividir para trabalhar é que as divisões sejam feitas de modo que os módulos sejam independentes ao máximo do contexto onde se está inserido.

O que isso quer dizer? Que os módulos tem que ter um caráter geral, independente, para que futuramente possa ser encaixado em outro problema que possa necessitar da tarefa que esse módulo realiza. Você precisa apenas saber o que a rotina faz e não como ela faz, isso pode ser útil para compartilhar código. Imagine que daqui a 1 ano, você tenha diversas funções desenvolvidas e deseje criar um programa com algumas similaridades do que você já criou. Simples, basta pegar as funções que você nem lembra mais como funcionam mas sabe o que elas fazem e encaixar no lugar certo do seu novo programa, economizará muito código e tempo.


Vamos a um exemplo, tem-se um problema de matemática de arranjo ou combinação (probabilidade? matemática combinatória?) Também não sou muito bom nisso:) e precisa-se calcular a fatorial de determinado número. Uma vez feita a função de fatorial, não importa como ela trabalha. O que me interessa é só passar como para metro para esta função o número que eu quero ter o seu fatorial calculado e receber o resultado pronto. Você só se preocupou uma vez em saber como funciona tal função para criá-la.

Outra situação, imagine você trabalhando em um grande projeto e seu trabalho ser parte de um problema maior. Você sabe o que tem, o que é recebido pelo seu módulo, o que ele deve trabalhar e qual saída deve gerar. Só com essas informações deve-se fazer o trabalho e futuramente entregar a alguém que não sabe como ele funciona e sim apenas as especificações pedidas. Ele simplesmente fará a inserção no contexto do programa. Note, nem você sabe o que o programa todo faz ou como funciona. Nem o responsável por juntar sabe como o seu programa funciona por dentro e sim apenas o que ele faz e onde deve ser inserido. Isso é bastante comum para quem trabalha com programação.

Compilada ou Interpretada:
C é uma linguagem compilada, utiliza de um compilador C para ser executado. Ao contrário de outras linguagens que utilizam de um interpretador para tal. Na concepção da linguagem é que se decide se ela vai ser compilada ou interpretada,
pois é um detalhe de implementação (que não deixa de ser importante). A priori qualquer uma poderia ser interpretada ou compilada.

Na verdade, quem faz um programa ser executado é também um programa, só que um programa avançado que lê todo código fonte (o que foi escrito pelo programador) e o traduz de alguma forma para ser executado, isso acontece em todas linguagens.

A diferença básica é que um interpretador lê linha a linha do fonte, o examina sintaticamente e o executa. Cada vez que o programa for executado esse processo tem de ser repetido e o interpretador é chamado. Já um compilador, lê todo programa e o converte para código-objeto (código de máquina, binário, 0's e 1's) e pronto. Sempre quando tiver que ser executado é só chamá-lo, todas instruções já estão prontas para tal, não tem mais vínculo com seu código-fonte.

Bem pessoal, muitos conceitos novos já foram dados por hoje. Aproveite essa semana para tentar instalar LINUX na sua máquina ou um compilador gcc para poder fazer os exercícios.

Uma boa semana e até a próxima !

quinta-feira, 13 de agosto de 2009

VIrtualização: Faça você mesmo



Já há algum tempo que quero fazer um tutorial, ou como é o objetivo do blog: Uma receita, sobre virtualização pois essa é uma tecnologia que tive oportunidade de atuar com AIX e Red-Hat e que vem despertando muito interesse em mim.

Virtualização, apesar de já existir há muitos anos, vem se tornando a grande assunto em tecnologia do momento. Tem o ponto de vista corporativo, onde é possível fazer virtualização de vários servidores em uma máquina, implementar servidores com alta disponibilidade, etc. A PRODAM, que é responsável pela tecnologia de informação da Prefeitura de São Paulo reorganizou toda sua infra-estrutura através da virtualização de seus servidores. No vídeo acima Luís Fernando Vieira Quevedo, Gerente de infra-estrutura e produção, fala sobre como foi o processo de virtualização de 130 servidores em 3 lâminas Blade.

Quanto a virtualização de servidores, alta disponibilidade e Storage corporativo eu ainda não tive oportunidade de criar um tutorial a altura, mas estou aproveitando essas minhas férias forçadas pra brincar com essa tecnologia em casa.

O enfoque que quero dar nesse post é a questão da ferramenta de virtualização da VMWare que além de muito útil pode nos dar as bases de um conceito bastante consistente de como a visrtualização de ambientes funciona. Existem outras ferramentas como o Virtual PC da Microsoft e o Virtual Box. Vou explicar passo a passo a instalação do VMWare Server, que é gratuito. É muito interessante para fins educacionais, estudos, testes e a curiosidade de conhecer novos sistemas operacionais e ferramentas sem ter que particionar o HD, além de ser muito mais prático. É possível virtualizar vários sistemas operacionais na mesma máquina, claro, isso depende muito do equipamento que você tem em mãos para virtualização. No meu caso estou usando um Core 2 Duo Intel, motherboard Gigabyte GA-G31M-S2L e 4GB de memória RAM Kingston. Nada assustador.

O Conceito

Virtualização é a execução de diversos sistemas operacionais em um único equipamento físico. Não confunda Virtualização com Emulação. Emulação é a recriação de um ambiente de trabalho sem qualquer relação necessário com o ambiente-anfitrião e sem auxílio de hardware, enquanto a virtualização permite criar diversas máquinas virtuais, utilização recursos de rede e de hardware.

A receita do bolo
O primeiro passo é baixar o VMWare Server no próprio site da VMWare que é gratuito.
Antes de baixar é necessário clicar em “Register” e fazer o registro para você receber por e-mail o serial do VMWare. Depois é só baixar o arquivo de aproximadamente 150mb.

O link do registro é esse: http://register.vmware.com/content/download-107.html

O link do download é esse: http://download3.vmware.com/software/vmserver/VMware-server-installer-1.0.7-108231.exe

Depois de baixar, execute o arquivo .exe e inicie o processo de instalação seguindo o " Windows way of life", ou seja, é só ir dando next até finalizar a instalação.

Depois de finalizado, abra o “VMWare Server Console”. Clique em OK.

A próxima tela irá mostrar as máquinas virtuais que já estão instaladas em seu computador

No meu caso, tenho instalado o Ubuntu 8.04, o Windows Server 2003 Enterprise Edition, o Windows Server 2008 e o Windows Vista x64 Edition.

O Ubuntu pode ser baixado através da própria internet gratuitamente através do site http://www.ubuntu-br.org/. A lincença é free. Já as máquinas virtuais do Windows precisam da licença para instalação.

A instalação de máquinas virtuais é basicamente a mesma, independente do SO que será instalado. Para esse tutorial estarei instalando do Solaris10 x64, pois é um sistema operacional desenvolvido pela Sun, é free e nunca vi o funcionando desse SO.

Para baixar o Solaris, clique no link http://dlc.sun.com/osol/opensolaris/2008/05/os200805.iso
Obs.: Como disse, a forma de instalação de qualquer sistema operacional é a mesma, seja Windows, Linux, Solaris etc. Você pode fazer a instalação de um arquivo .iso ou através do drive de CD/DVD.

Nesse exemplo estarei usando o .iso.

Então, mãos na massa. Depois de aberto o VMWare Server clique em “File”, “New” e depois “Virtual machine” e depois Clique em “Avançar”.

Agora você deve escolher o sistema operacional que você está instalando, pois dependendo do SO a ser instalado, ele já configura um default de configurações como espaço em disco, memória RAM mínima para instalação. Selecionando o sistema operacional na opção “Version”, você pode escolher a versão do sistema operacional que você está instalando. Na nossa receita selecione o “Sun Solaris” e em Version escolha “Solaris 10” e clique em avançar.

Agora você irá definir onde salvar sua VM. Eu deixei como está, mas você pode salvar onde você achar melhor. Clique em “Avançar”.

Neste ponto iremos configurar a rede. Deixe clicada a primeira opção, pois logo que instalar o SO ele já estará na sua rede e com a internet em funcionamento. Clique em “Avançar”. A internet que utilizo é ADSL. Não sei como é o funcionamento com net via wireless mas se souber mande sua dica.

Agora vamos definir o quanto de espaço em disco que iremos reservar para essa máquina virtual. Deixaremos 8GB de espaço em disco mas o detalhe é desclicar a opção “Allocate all disk space now”, pois se ficar clicado ele já alocará para o SO os 8GB, mesmo que não seja utilizado. Desclicando-o ele reservará esse espaço para a VM,mas não alocará esses 8GB de imediato, o espaço será sendo utilizado a medida que você for ocupando os espaço em disco. Clique em “Concluir”.

Vamos entrar no processo de criação de disco. Como podem ver já aparece o Solaris 10 como uma das máquinas virtuais do inventário do VMWare. Foi criada a VM mas ainda o Solaris não está instalado. Em “Devices” são mostrados as configurações de nosso computador virtual como quantidade de memória, hard disk, cd ROM, rede, etc...

Agora é preciso configurar a máquina virtual clicando em “Edit virtual machine settings" onde vamos configurar a quantidade de memória, boot em drives, configurações de rede, como é feito em qualquer computador “convencional”. Clique na opção Cd-Rom.

Voilá! É chegada a hora de configuramos onde vamos dar o boot para dar início à instalação do sistema operacional. Se deixar como está, quando iniciar a máquina virtual, ele dará o boot no cd-rom, mas no nosso caso vamos utilizar o .iso do Solaris 10, portanto, mude a opção para “Use ISO image” e procure onde você deixou salvo o arquivo iso do Solaris.

Depois que selecionar o arquivo .iso dê OK e pronto! Já está tudo configurado, agora vamos instalar o Solaris 10.

Clique em “Start this virtual machine” e dará início a instalação do SO. A instalação do Solaris é bem simples, mas se estiver instalando outro sistema operacional, é só fazer como você está acostumado. Detalhe: No começo é estranho trabalhar com o SO em outra janela pois para dar um comando na máquina virtual você precisa clicar dentro dela. Dois comandos são fundamentais na utilização: Ctrl+Alt você sai da máquina virtual e Ctrl+Alt+Enter coloca a VM em full Screen. Para sair do modo full screen é só clicar Ctrl+Alt+Enter.

Essa versão do Solaris é uma das que roda através do cd, por isso, toda vez que reiniciamos a VMWare ele dá boot novamente. Nos demais SO’s, depois da instalação ele não dá mais boot nem no cd-rom e nem no arquivo .iso.

Divirtam-se !!!

domingo, 26 de julho de 2009

SSH sem uso de senha

Como último tópico desta série sobre SSH, vou mostrar como habilitar o ssh sem senha.

Primeiro precisamos gerar um par de chaves públicas/privadas para autenticar com chaves RSA2 ou DSA.

RSA:
ssh-keygen -t rsa
DSA:
ssh-keygen -t dsa

As chaves são gerados no $HOME do usuário que você esta utilizando para que a chave seja criada

~/.ssh/id_rsa.pub
ou
~/.ssh/id_dsa.pub

OBS.: As permissões do home do usuário e do .ssh precisa ser setada como 750 em ambos os servidores.

Depois precisamos instalar a chave pública/privada no servidor ao qual desejamos logar sem senha.

ssh-copy-id -i ~/.ssh/id_rsa.pub user@remote_server
ou
ssh-copy-id -i ~/.ssh/id_dsa.pub user@remote_server

Podemos fazer o mesmo processo acima utilizando o comando scp.

scp ~/.ssh/id_rsa.pub user@remote_server:~/.ssh/authorized_keys
ou
scp ~/.ssh/id_dsa.pub user@remote_server:~/.ssh/authorized_keys

OBS.:
O comando acima irá instalar a chave pública local ~/.ssh/id_rsa.pub no arquivo ~/.ssh/authorized_keys do servidor remoto. Este arquivo possui o mesmo formato do arquivo ~/.ssh/know_hosts com uma chave pública por linha.
Para alterar o passphrase caso você tenho escolhido um utilizamos o comando abaixo:

ssh-keygen -p -t rsa -f ~/.ssh/id_rsa.pub
ou
ssh-keygen -p -t rsa -P old_passphrase -N new_passphrase -f ~/.ssh/id_rsa.pub

Após isso é necessário exportar a chave pública para o servidor remoto novamente.

quarta-feira, 15 de julho de 2009

SSH: X11 Forwarding

Solução aplicavel em: HP-UX, SUSE, AIX, Solaris, Red Hat, Debian

Com esta opção no SSH podemos redicionar conexão ao X Window no servidor para o servidor X local.

Ao realizar a conexão no servidor X Remoto a conexão é direcionada por default ao DISPLAY :10

Para isto realizamos a seguinte configuração nos arquivos abaixo:

Descomentar a linha no arquivo /etc/ssh/sshd_config (arquivo de configuração do servidor).

AllowX11Forwarding yes

E depois alterar o arquivo /etc/ssh/ssh_config (arquivo de configuração do cliente).

Host *

ForwardAgent yes
ForwardX11 yes

Para realizar testes logando basta seguir os passos abaixo em um cliente Linux/UNIX.

ssh servidor_remoto -X -l user

OBS.:

Se estiver utilizando o Putty como cliente é necessário fazer as seguintes configurações:

a. Instalar um servidor X local (como exemplo utilizo o Xming)

b. Marcar a opção “Enable X11 forwarding” no Putty

sábado, 11 de julho de 2009

SSH Tunnel Proxy

Aplicavel para: HP-UX, SUSE, AIX, Solaris, Red Hat, Debian

Continuando com ess série de receitas sobre o SSH, vamos ver hoje Tunnel.

O conceito é praticamento o mesmo do X11 Forward, com esta opcão do SSH direcionamos uma porta do servidor remoto para qualquer porta local.

Exemplo, para direcionar a porta 25 do servidor para a porta 3000 local mantendo a conexão por 60 segundos:

ssh -l user servidor -L3000:servidor:25 -f sleep 60

Agora basta verificar se a porta 3000 encontra-se aberta localmente.

telnet localhost 3000

OBS.:

Se estiver utilizando o Putty como cliente é necessário fazer as seguintes configurações:

a. Na opção “Source port” coloque a porta que será aberta localmente
b. Na opcão “Destination” coloque ipservidor:porta
c. Deixe as opção “Local” e “Auto” selecionadas e clique em “Add”

segunda-feira, 6 de julho de 2009

SSH timeout for connection idle

* Procedimento igual nos sistemas HP-UX, SUSE, AIX, Solaris, Red Hat e Debian

Recentimente em testes e estudos aqui em casa percebi que em alguns servidores que eu estava logando quando uma conexão ssh ficava aberta por mais de 5 minutos sem que eu tomasse nenhuma ação, a mesma se encerrava automaticamente por inatividade.

Para solucionar este problema, encontrei duas opções:

1. Configuração realizada no servidor SSH

Habilitar a seguinte configuração do arquivo /etc/ssh/sshd_config

KeepAlive yes
ClientAliveInterval 240

Isto faz com que o servidor ssh envie um “null packet” para o cliente a cada 4 minutos fazendo a conexão se manter ativa.

2. Configuração realizada no cliente SSH

No Putty por exemplo, basta setar um valor de 120 na opção “Sending of null packets to keep session active“.
Fazendo com que o Putty envie um “null packet” para o servidor a cada 2 minutos mantendo a conexão ativa novamente.