.::IPC::Signal::.

:Introdução:
Essa é a segunda parte da série de tutoriais sobre IPC, agora sobre signals.
Signal é um sinal (lógico), que você pode usar para enviar a alguns processos. Exemplos de sinais são SIGKILL (para matar algum processo), SIGINT 
(para interromper algum processo).

:Lista dos principais sinais:
[lista signals]
SIGHUP   1  // HangUp
SIGINT   2  // Interromper
SIGQUIT  3  // Sair
SIGILL   4  // Instrução ilegal 
SIGABRT  6  // Abortar
SIGKILL  9  // Matar um processo
SIGALRM  14 // Relógio de alarme
SIGCONT  19 // Continuar um processo parado
[/lista]
São no total 32 sinais, numerados de 0 a 31, mas somente listei os mais importantes :).

:Enviando sinais:
[prot header: signal.h, sys/types.h]
int kill(pid_t pid, int sig);
int raise(int sig);
[/prot]

A função kill() por incrivel que pareça, só envia um signal, qualquer um não necessariamente só SIGKILL. A variável pid seria o pid do processo alvo, 
e sig seria o signal. Enquanto raise() é somente para enviar um sinal para si mesmo (para o processo que chama o raise(). Ambas retornam -1 em caso 
de erro :)

[code killer.c]
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>

int main()
{
	int opc;
	pid_t p;
	
	do
	{
		printf("Digite a opção\n");
		printf("[1] Mata esse processo.\n");
		printf("[2] Mata outro processo.\n");
		scanf("%d", &opc);
	} while((opc < 1) || (opc > 2));
	
	switch(opc)
	{
		case 1:
			raise(SIGKILL);
		break;
		case 2:;
			printf("Digite o pid alvo\n");
			scanf("%d", &p);
			if(kill(p, SIGKILL) == -1)
			{
				perror("Kill");
				exit(1);
			}
		break;	
	}
	
	return 0;
}
[/code]

Esse code demonstra como funciona o kill() e raise().

:Criando direções de sinais com signal():
[prot header: signal.h]
sighandler_t signal(int signum, sighandler_t handler);
[/prot]
Essa função manipula sinais, jogando, em caso de recebimento de determinado signal(signum), fazendo-o ir para a função handler.

[code signal.c]
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void ha(void);

int main()
{
	signal(SIGINT, ha);
	printf("Que legal :D\n");
	for(;;);
	return 0;
}

void ha(void)
{
	printf("Buá, seu merda :(\n");
	exit(1);
}
[/code]

Esse code gera um loop infinito, e redireciona SIGINT para a função ha(). Assim, quando você for interromper o processo dando ctrl + c, ele irá falar 
"Buá, seu merda :(", e irá fechar o processo com exit(1).

:Bibliografia:
Dave C
Manuais padrão do linux

:Contato:
fpc@bsdmail.org
morte137@gmail.com

:Finalização:
Espero que tenham gostado desse tutorial sobre signal, ele é útil para programas maliciosos, quando você não quer que seu processo não seja morto :).