Seja Elegante

Talvez possa ser algo que passe despercebido por vários desenvolvedores, porém dúvido quem nunca tenha se deparado com mensagens de “log” vagas ou sem nenhum nexo ou bem pior, como mensagens idênticas replicadas por várias partes do código!
A algum tempo atrás estava trabalhando em um projeto em que um respectivo desenvolvedor da equipe possuia o costume de espalhar ou replicar centenas de printf() pelo código com mensagens tipo!

printf(“!!! FULANO – Aqui!!!”);

ou

printf(“!!! FULANO – Arquivo.cpp:  Aqui!!!\n”);

Precisa falar que isto e pessímo? Certo que e preciso um bom senso com o uso de mensagens de depuração pois dependendo ao invés de ajudar podem só atrapalhar. principalmente quando você necessita ter controle sobre tais mensagens, como por exemplo obter a localização da mensagem através do nome da função, arquivo e linha.

O pré-processador do GCC oferece (*) várias macros, as que irei utilizar em questão são:

• __FILE__ : Substituída pelo nome do arquivo.
• __PRETTY_FUNCTION__ : Substituídas pelo nome nome da função.
• __LINE__ : Substituída pelo número da linha de código.

(*) Mais detalhes sobre as macros do GCC.

A utilização dessas macros irá facilitar a localização das mensagens de depuração, Abaixo um simples exemplo demonstrado em debug1.c.

/**
 * By Jorge Pereira <jpereiran@gmail.com>
 * Date: Tue Jun 29 02:51:44 BRT 2010
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

// Macro condicional
#ifdef DEBUG
#	warning "Debug is enabled"
#	define TRACE_DEBUG(fmt, ...) \
	fprintf(stderr, " ** DEBUG: %s:%d %s(): "fmt"\n", \
	__FILE__, __LINE__, __PRETTY_FUNCTION__, ##__VA_ARGS__)
#else
#	warning "Debug is disabled"
#	define TRACE_DEBUG(fmt, ...)
#endif

#define MAX_STRING 5 /* tamanho maximo de uma string */

// Função simples de exemplo...
void
show_name (const char* name,
		   size_t len)
{
	size_t offset = len;

	// Verificação qualquer...
	if (len > MAX_STRING)
	{
		// Abaixo mensagem de depuração, perceba que ela será ativada apenas
                // quando em tempo de compilação você ativar a macro "DEBUG"
		TRACE_DEBUG ("Ooops! Tamanho da string(%d) e excedeu o limite(%d)...",
			len, MAX_STRING);
		offset = MAX_STRING;
	}

	// Manipulação qualquer...
	write (STDOUT_FILENO, name, offset);
	write (STDOUT_FILENO, "\n", 1);
}

int
main (int argc, char* argv[])
{
	if (argc < 2)
	{
		printf ("Usage: %s <string>\n", argv[0]);
		exit (1);
	}

	show_name (argv[1], strlen (argv[1]));

	return 0;
}

Com este exemplo básico em mãos, vamos compilar e executar.

[jpereira@miracleworld Codes]$ gcc -Wall -o debug1 debug1.c
debug1.c:18:3: warning: #warning "Debug is disabled"
[jpereira@miracleworld Codes]$ ./debug1 "Jorge"
Jorge
[jpereira@miracleworld Codes]$ ./debug1 "Jorge Pereira"
Jorge
[jpereira@miracleworld Codes]$

Imagine que seu sistema possui inúmeros arquivos e você precisa em determinados pontos obter o máximo de informação sobre as mensagens de depuração, talvez seja interessante ter além de uma mensagem objetiva obter juntamente o nome da função, arquivo e linha de onde foi invocada tal mensagem.

[jpereira@miracleworld Codes]$ gcc -Wall -DDEBUG -o debug1 debug1.c
debug1.c:13:3: warning: #warning "Debug is enabled"
[jpereira@miracleworld Codes]$ ./debug1 "Jorge"
Jorge
[jpereira@miracleworld Codes]$ ./debug1 "Jorge Pereira"
 ** DEBUG: debug1.c:36 show_name(): Ooops! Tamanho da string(13) e excedeu o limite(5)...
Jorge
[jpereira@miracleworld Codes]$

Lembrando que este e o primeiro post entre vários que pretendo publicar relacionados a sugestões e técnicas de depuração. Fique de olho na segunda parte desta saga em que irei explicar uma mais dinâmica do mesmo assunto abordado neste post associando ao uso de variáveis de ambiente.
Dúvidas e Sugestões, são sempre bem vindas!

Autor: Jorge Pereira

Caso você tenha necessidade ou curiosidade em relação a Device Drivers no Linux, este com certeza será um bom material para iniciar-se na “brincadeira”.

Introdução aos Linux Device Drivers (ILDD) é um curso que tem por objectivo apresentar os princípios básicos do desenvolvimento de device drivers no Linux kernel. Pretende-se com este curso, que o leitor tenha contacto com várias ferramentas e sub-sistemas existentes no kernel, adquirindo assim as bases que lhe irão permitir desenvolver o suporte para a grande maioria dos dispositivos. Alguns dos temas introduzidos são: estrutura básica de um device driver, comunicação com o userspace, memória dinâmica, eventos assíncronos, primitivas de sincronização e comunicação com o hardware.

Este curso aborda o tema de uma perspectiva pedagógica, através da sistematização dos conceitos em conjunto com uma forte componente prática, na qual se convida o leitor à implementação gradual de um device driver que dará suporte a um dispositivo especificamente concebido para o efeito. O leitor poderá ainda consultar a literatura de referência, de onde se destacam os excelentes títulos: Linux Device Drivers, Understanding the Linux Kernel e Linux Kernel in a Nutshell.

O autor, com a ajuda dos seus revisores, investiu mais de um ano de trabalho na elaboração e preparação deste curso, no sentido de oferecer à comunidade, não só um manual de aprendizagem abrangente, mas também uma importante referência futura. Caso encontre alguns erros ou tenha sugestões que visam melhorar ou complementar este trabalho, não hesite em contactar o autor.

Download aqui

O que acontece basicamente e que o linker dinâmico do Linux (assim como em tantos outros sistemas operacionais) utiliza diversas formas, alguma delas sendo através de variáveis de ambiente para controlar seu comportamento. Sendo que neste caso a variável LD_PRELOAD informa ao linker dinâmico que carregue as bibliotecas listadas nela antes de carregar quaisquer outras bibliotecas necessárias, enquando LD_LIBRARY_PATH especifica um caminho alternativo para usar ao procurar bibliotecas que serão carregadas.

Partindo deste principio podemos fazer com que um programa a ser executado seja “hijacked” por outro programa, ou seja. Podemos fazer por exemplo que a função hehe() previamente chamada pelo programa “A” tenha seu comportamento alterado sem precisar fazer quaisquer alteração no programa “A”. Um pouco complexo? talvez! Mais vamos por a mão na massa! hands on!

Digamos que você tem o programa “main” conforme o código de exemplo abaixo, perceba que o código e super simples. apenas declaro um ponteiro de caracteres, aloco memória e em seguida copio uma sequência de caracteres para o ponteiro previamente alocado. Simples, certo?

1) Abaixo código de exemplo de nosso “main.c” ou clique aqui para download.

/*
 *  Filename: hijack_main.c
 *  Created: Wed Jun  9 22:11:12 BRT 2010
 *  Author: Jorge Pereira <jpereiran@gmail.com>
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int
main (int argc,
      char* argv[])
{
  char* nome = (char*)malloc (100);

  strcpy (nome, "Jorge Pereira");
  printf ("NOME: %s\n", nome);

  free (nome);
  return 0;
}

# Vamos compilar e executar o nosso exemplo “main.c”

$ gcc -Wall -o main main.c
$ ./main
NOME: Jorge Pereira
$

Até aqui tudo bem, porém imagine você em uma determinada situação em que precisa saber quantos bytes está sendo alocado por um determinado programa? e você por alguns instantes imagina sobre a possibilidade de poder fazer algum tipo de “overload” de uma determinada função na qual você conhece sua assinatura. (Digamos, você sabe a assinatura do método, quantidade e tipos dos parâmetros, …).

Pois bem, neste exemplo que irei demonstrar será para sobrecarregar todas as chamadas feitas pelo meu programa “main” às funções malloc() e free() e em seguida exibir uma mensagem no caso do malloc() imprimindo seu parâmetro que e o tamanho de bytes alocados, e na função free() exibindo os ponteiros que foram liberados.

Neste caso, iremos criar uma biblioteca chamada “libhijack_hehe.so” que será carregada através da variável mágica LD_PRELOAD em parceria com nosso querido linker dinâmico.

2) Abaixo código de exemplo de “hijack_hehe.c“, ou clique aqui para download.

/*
 *  Filename: hijack_hehe.c
 *  Created: Wed Jun  9 22:11:12 BRT 2010
 *  Author: Jorge Pereira <jpereiran@gmail.com>
 */
#define _GNU_SOURCE
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#include <dlfcn.h>

#define HIJACK_DEBUG(fmt, ...) \
	fprintf(stderr, " ** DEBUG: %s:%d %s(): "fmt"\n", \
	__FILE__, __LINE__, __PRETTY_FUNCTION__, ##__VA_ARGS__)

static void* (*hack_malloc)(size_t size) = NULL;
static void  (*hack_free)(void *p) = NULL;

static void* rest_malloc = NULL;

void*
malloc (size_t size)
{
  if (hack_malloc == NULL)
  {
    hack_malloc = (void *(*)(size_t)) dlsym (RTLD_NEXT, "malloc");
    rest_malloc = NULL;
  }

  if (rest_malloc == NULL)
  {
    rest_malloc = hack_malloc (size);
    HIJACK_DEBUG ("Alocando (%d) bytes, chunck(%p)", size, (void*)rest_malloc);
    return rest_malloc;
  }

  hack_malloc = NULL;
  return rest_malloc;
}

void
free (void *p)
{
	HIJACK_DEBUG ("Desalocando (%p)", p);

  if (hack_free == NULL)
  {
    hack_free = (void (*)(void *)) dlsym(RTLD_NEXT, "free");
  }

  hack_free (p);
}

Agora vamos compilar, executar e analisar o comportamento.

$ gcc -Wall -shared -ldl -o libhijack_hehe.so hijack_hehe.c
$ LD_PRELOAD=./libhijack_hehe.so ./main
 ** DEBUG: hijack_hehe.c:35 malloc(): Alocando (100) bytes, chunck(0x9273008)
NOME: Jorge Pereira
 ** DEBUG: hijack_hehe.c:46 free(): Desalocando (0x9273008)
$

Percebeu algo diferente na execução com a LD_PRELOAD passando como parâmetro a nossa libhijack_hehe.so? pois bem, todas as chamadas às funções malloc() e free() foram sobrecarregadas e passaram a se comportar conforme as versões que escrevi em hijack_hehe.c. Caso tenha ficado curioso, e so re-escrever tais exemplos com outras funções que você deseja sobrecarregar e ver o comportamento. Lembrando que basta utilizar a criatividade e perceberá na quantidade de coisas que podem ser feita com tal técnica.

Exemplo: Nas funções que fazem checagem com strcmp(), uso da crypt(), … entre outras.

Referências

• man 8 ld.so

Autor: Jorge Pereira
Data: Wed Jun 9 23:42:26 BRT 2010

Glibc x uClibc

Justamente a minha necessidade foi diferente, estava precisando em algum momento verificar se um determinado executável estava em execução na lista de processos, foi desta forma que baixei o código fonte do pacote procps e fui da uma olhada para entender sua API que por sinal não existe nenhuma documentação! isto mesmo, existe apenas o pacote procps e o procps-devel que possui os headers utilizado para a acessar os métodos existentes na libproc (geralmente em /lib/libproc.so) conforme abaixo.

[jpereira@jiraya codes]$ ls -1 /usr/include/procps/
alloc.h
devname.h
escape.h
procps.h
pwcache.h
readproc.h
sig.h
slab.h
sysinfo.h
version.h
wchan.h
whattime.h
[jpereira@jiraya codes]$

Desta forma segue um simples código de exemplo utilizado para verificar se o programa especifico passado como parâmetro está em execução.

/**
 * Autor: Jorge Pereira <jpereiran@gmail.com>
 * Data:  Ter Jan 13 14:29:29 BRST 2009
 * Desc:  Simples aplicacao utilizada para verificar se existe um
 * processo em execucao utilizando a procps (libproc)
 *
 * Build: gcc -o checkps checkps.c -lproc
 **/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdbool.h>

#include <readproc.h>

bool check_process(const char *proc)
{
	int32_t flags = 0;
	PROCTAB *ptp  = NULL;
	bool 	 st   = false;
	proc_t task;

	memset(&task, 0, sizeof (task));

	if (!proc || strlen(proc) < 1)
		return false;

	flags = PROC_FILLCOM | PROC_FILLSTATUS;

	if ((ptp = openproc (flags)) == NULL)
		return false;

	while(!st && readproc(ptp, &task))
	{
        const char *cmd = (task.cmdline != NULL) ? task.cmdline[0] : task.cmd;

		st = !strncmp(proc, cmd, strlen(proc));
		memset (&task, 0, sizeof (task));
	}

	closeproc (ptp);

    return st;
}

int main (int argc, char *argv[])
{
    if (argc < 2)
    {
        printf ("Usage: %s <nome do processo>\n", argv[0]);
        exit(EXIT_SUCCESS);
    }

    printf("O Programa (%s) %sesta em execucao\n", argv[1], check_process(argv[1]) ? "" : "nao ");

    return EXIT_SUCCESS;
}

Baixando este código de exemplo, compilando e fazendo uma checagem se existe o processo “dbus-launch” em execução!

[jpereira@jiraya tmp]$ wget http://blog.jorgepereira.com.br/jorge/wp-content/uploads/2009/01/checkps.c
[jpereira@jiraya tmp]$ gcc -o checkps checkps.c -lproc
[jpereira@jiraya tmp]$ ./checkps dbus-launch
O Programa (dbus-launch) está em execução
[jpereira@jiraya tmp]$ ./checkps dbus-lanche
O Programa (dbus-lanche) não está em execução
[jpereira@jiraya tmp]$

• Mais informações sobre o procps

Este sem sombra de dúvidas e um excelente documento desenvolvido e utilizado no desenvolvimento do Mozilla, vale a pena conferir!

Em computação, mmap é uma chamada de sistema do Unix, em conformidade com o POSIX, que mapeia arquivos ou dispositivos na memória. É um método de E/S de arquivo mapeado em memória. Ela implementa naturalmente a paginação por demanda, pois os conteúdos iniciais dos arquivos não são inteiramente lidos do disco e não usam a memória RAM física completamente. A real leitura do disco é feita de maneira “preguiçosa”, após uma posição específica ter sido acessada.

Ou seja, podemos fazer muitas coisas utilizando a chamada mmap(), principalmente quando e preciso manipular arquivos de grande portes, e você não quer ter buffers auxiliares entre tantas outras possibilidades, que na grande maioria seguimos o seguinte fluxo.

open() -> read() || write() -> close()

Abaixo segue o  código cp-no-mmap.c detalhando melhor meu comentário!

/**
 * Autor: Jorge Pereira
 * Data: Thu Oct  9 22:47:47 BRT 2008
 * Desc: Exemplo de um codigo para copia de arquivos.
 * Arquivo: cp-no-mmap.c
 */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <err.h>

#define IO_SIZE 4096

int
main(int argc, char *argv[])
{
int32_t fdr, fdw;
ssize_t reads;

/* Como de costume, temos um buffer temporario para auxiliar a copia */
char buf[IO_SIZE];

if(argc < 3)
{
  printf("Usage: %s  \n", argv[0]);
  exit(EXIT_FAILURE);
}

/* Arquivo de origem */
fdr = open(argv[1], O_RDONLY);
if(fdr < 0)
{
  err(1, "Falha ao abrir (%s)", argv[1]);
  exit(EXIT_FAILURE);
}

/* Arquivo de destino */
fdw = open(argv[2], O_CREAT | O_RDWR, 0644);
if(fdw < 0)
{
  err(1, "Falha ao abrir (%s)", argv[2]);
  exit(EXIT_FAILURE);
}

/* Inicio da copia */
while ((reads = read(fdr, buf, sizeof(buf))) > 0)
{
  if(write(fdw, buf, reads) < reads)
  {
    err(1, "Problemas com write()");
    break;
  }
}

/* fechando os descritores */
close(fdr);
close(fdw);

return EXIT_SUCCESS;
}

O Arquivo de exemplo se chama “Prison.Break.S04E07.HDTV.XviD-0TV.avi”, abaixo segue o tamanho dele para termos idéia em relação ao tempo de cópia!

[jpereira@jiraya blog]$ ls -lh Prison.Break.S04E07.HDTV.XviD-0TV.avi
-rw-r–r– 1 jpereiran jpereiran 351M 2008-10-09 22:06 Prison.Break.S04E07.HDTV.XviD-0TV.avi
[jpereira@jiraya blog]$ gcc -o cp-no-mmap cp-no-mmap.c
[jpereira@jiraya blog]$ time ./cp-no-mmap Prison.Break.S04E07.HDTV.XviD-0TV.avi Prison.Break.S04E07.HDTV.XviD-0TV.avi.copia
real 0m3.115s
user 0m0.008s
sys 0m2.496s
[jpereiran@jiraya blog]$

Agora veremos exemplo do mesmo código chamado cp-mmap.c utilizando uma chamada mmap(), fazendo com que todos os bytes lidos pela chamada read() sejam salvos em uma região de memória previamente mapeada para que possamos efetuar operações de leitura, e escrita caso seja necessário! repare que não esta sendo utilizado um buffer auxiliar para salvar os dados do read(), como e feito de costume!

/**
 * Autor: Jorge Pereira
 * Data: Thu Oct  9 22:47:47 BRT 2008
 * Desc: Exemplo de um codigo para copia de arquivos utilizando mmap()
 * Arquivo: cp-mmap.c
 */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <err.h>

#define IO_SIZE 4096

int
main(int argc, char *argv[])
{
int32_t fdr, fdw, fdm;
ssize_t reads;
/* repare que ao inves de utilizarmos um buffer auxilia, iremos ter um ponteiro apenas */
void *mem;

if(argc < 3)
{
  printf("Usage: %s  \n", argv[0]);
  exit(EXIT_FAILURE);
}

/* Arquivo de origem */
fdr = open(argv[1], O_RDONLY);
if(fdr < 0)
{
  err(1, "Falha ao abrir (%s)", argv[1]);
  exit(EXIT_FAILURE);
}

/* Arquivo de destino */
fdw = open(argv[2], O_CREAT | O_RDWR, 0644);
if(fdw < 0)
{
  err(1, "Falha ao abrir (%s)", argv[2]);
  exit(EXIT_FAILURE);
}

/* tal device abaixo ira prover caracteres nulos '\0', estaremos apenas fazendo
* o mapeamento do dispositivo para uma regiao de memoria com tamanho definido
* neste caso por "IO_SIZE", com protecao R+W e sendo visivel apenas para o
* processo corrente, sem offsets referente a paginas de memoria.
*
* 1) Abrindo o device /dev/zero
* 2) Fazendo o mapeamento na linha 67
*
* OBS: Na duvida consulte a man do mmap(), e veja um exemplo utilizando mais
* detalhes conforme sua necessidade!
*/
if((fdm = open("/dev/zero", O_RDWR)) < 0)
{
  err(1, "Falha ao abrir (%s)", argv[2]);
  exit(EXIT_FAILURE);
}
mem = mmap(NULL, IO_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE, fdm, 0);
close(fdm);

/**
* Inicio da copia, repare que estamos lendo do disco e "copiando" para regiao
* de  memoria mapeada, e escrevendo apartir do mesmo mapeamento! funcionando
* como uma variavel temporaria.
*/
while ((reads = read(fdr, mem, IO_SIZE)) > 0)
{
  if(write(fdw, mem, reads) < reads)
  {
    err(1, "Problemas com write()");
    break;
 }
}

munmap(mem, IO_SIZE);

/* fechando os descritores */
close(fdr);
close(fdw);

return EXIT_SUCCESS;
}

Abaixo vamos compilar e fazer o mesmo teste, copiando o mesmo arquivo!
[jpereira@jiraya blog]$ gcc -o cp-mmap cp-mmap.c
[jpereira@jiraya blog]$ time ./cp-mmap Prison.Break.S04E07.HDTV.XviD-0TV.avi Prison.Break.S04E07.HDTV.XviD-0TV.avi.copia
real 0m2.777s
user 0m0.020s
sys 0m2.056s
[jpereiran@jiraya blog]$

Conclusão

Repare que o ganho e imperceptível quando executamos tais rotinas em computadores x86 compostos de processadores de alta capacidade, sem falar dos discos rígidos de alta rotação! certo?
Porém quando você está trabalhando em um ambiente embarcado limitado de recursos, que quaisquer ganho de performance e velocidade e bem vindo! este foi meu caso em que precisava-se efetuar operações de I/O em um SD-CARD com um processador ARM um tanto quanto “humilde”, e tais dados além de ser copiados eram necessário gerar chaves MD5 entre outros detalhes com tal stream de dado, lembro que o ganho ficou por volta de 20% e 30% com o mapeamento utilizando mmap(). Dúvidas e comentários serão bem vindos

Referências

• man 2 open
• man 2 mmap
• http://www.gnu.org/software/libtool/manual/libc/Memory_002dmapped-I_002fO.html

Autor

Jorge Pereira

Alguns clássicos da cultura, história e literatura de C seria o famoso [2]. Assim como um outros mais genéricos [3][4] que inclui alguns clássicos do C++ e do OOP.

Porém o POST e específico sobre desenvolvimento Unix, a principio podemos começar por Filosofia Unix e lembrando que nos dias de hoje sempre estamos trabalhando com softwares e suas diversas licenças, sendo muito interessante e indispensável o conhecimento sobre as principais licenças[5] de softwares!

[1] The Ten Commandments for C Programmers
[2] Programming in C
[3] http://www.mycplus.com/Programming-Tutorials-Index.asp
[4] http://www.di-mgt.com.au/cprog.html
[5] http://blog.jorgepereira.com.br/2006/10/15/entendendo-o-softwarelivre/

/*
 * Autor: Jorge Pereira
 * Data:  Tue Jul 29 09:35:42 BRT 2008
 * Desc:  Implementacao da funcao getch() no Linux,
 * podendo ser feito leitura de um unico byte por vez.
 *
 */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <termios.h>
#include <sys/ioctl.h>

#ifdef getch
#undef getch
#endif
typedef unsigned int keybd_t;

keybd_t getch (void)
{
	struct termio old_tty;	 /* current terminal settings */
	struct termio new_tty;	 /* new terminal settings     */
	keybd_t	key = 0;         /* character "buffer"	      */

	if (ioctl(STDIN_FILENO, TCGETA, &old_tty) < 0)
	{
		fprintf(stderr,"Port ioctl(TCGETA) it's failed, exiting...\n");
		exit(EXIT_FAILURE);
	}

	new_tty 	 = old_tty;		/* copy terminal settings    */
	new_tty.c_lflag &= ~(ICANON | ECHO);	/* set flags in teminal      */
	new_tty.c_cc[4]  = 01;			/* struct for raw mode	     */

	if (ioctl(STDIN_FILENO, TCSETA, &new_tty) < 0)
	{
		fprintf(stderr,"Port ioctl(TCSETA) it's failed, exiting...\n");
		exit(EXIT_FAILURE);
	}

	if(read(STDIN_FILENO, &key, sizeof(key)) < 0)
	{
		fprintf(stderr,"Problems in read()\n");
		exit(EXIT_FAILURE);
	}

	if (ioctl(STDIN_FILENO, TCSETA, &old_tty) < 0)
	{
		fprintf(stderr,"Port ioctl(TCSETA) it's failed, exiting...\n");
		exit(EXIT_FAILURE);
	}

	return key;
}

#if defined(RUN_MAIN)
int
main (void)
{
    keybd_t key;

    printf ("(*) Teste para funcao getch(), pressione  para sair!\n");

    while ((key = getch()) != 0x1b)
    {
        char ch = (key >= 'a' && key <= 'z') || (key >= 'A' && key <= 'Z') || (key >= '0' && key <= '9') ? key: ' ';

        printf (" -> key char(%c) hex(0x%08x) dec(%d)\n", ch, key, key);
    }

    printf ("(*) Saindo...\n");

    return EXIT_SUCCESS;
}
#endif

Adicionei um bloco ifdef com um main(), para que seja possível executar e testar a função. Abaixo segue exemplo de compilação.

[jorge@jiraya codigos]$ gcc -W -Wall -DRUN_MAIN -o getch getch.c
[jorge@jiraya codigos]$ ./getch
(*) Teste para funcao getch(), pressione <ESC> para sair!
-> key char(a) hex(0×00000061) dec(97)
-> key char(b) hex(0×00000062) dec(98)
-> key char(c) hex(0×00000063) dec(99)
-> key char(d) hex(0×00000064) dec(100)
(*) Saindo…
[jorge@jiraya codigos]$

Caso queira adicionar o ao seu projeto, basta remover o bloco #ifdef e utilizar normalmente!

[sourcecode language='cpp']
/*
* Source: statfs.c
* Autor: Jorge Pereira
* Data: Tue Jul 29 09:35:42 BRT 2008
* Desc: Exemplo acessando a quantidade de espaço de uma partição no Linux.
*/
#include
#include
#include
#include
#include
#include

inline long _tok(long b, long bs)
{
return ( b * (long long) bs + 1024 / 2 ) / 1024;
}

int main(int argc, char *argv[])
{
struct statfs s;

if (argc < 2)
{
printf ("Usage: %s \n", argv[0]);
exit (1);
}

if (statfs(argv[1], &s) != 0)
{
printf ("Problemas ao tentar abrir (%s), msg='%s'\n", argv[1], strerror(errno));
exit (1);
}

printf(" + SYSTEMA ARQUIVOS: (%s) \n", argv[1]);
printf(" +-- CAPACIDADE: (%lu)\n", _tok(s.f_blocks, s.f_bsize));
printf(" +-- OCUPADO: (%lu)\n", _tok(s.f_blocks-s.f_bfree, s.f_bsize));
printf(" +-- LIVRE: (%lu)\n", _tok(s.f_bavail, s.f_bsize));

return EXIT_SUCCESS;
}
[/sourcecode]

Basta compilar, e executar o exemplo conforme abaixo.

[jorge@jiraya c]$ gcc -o statfs statfs.c
[jorge@jiraya c]$ pwd
/home/codes/c
[jorge@jiraya c]$ ./statfs $PWD
+ SYSTEMA ARQUIVOS: (/home/codigos/c)
+– CAPACIDADE: (48444420)
+– OCUPADO: (13660960)
+– LIVRE: (32341984)
[jorge@jiraya c]$ df $PWD
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda3 48444420 13660960 32341984 30% /home
[jorge@jiraya c]$