Hola, estoy desarrollando un proyecto de cooperación (sistema corrector de programas informaticos) y estoy un poco perdido con mi liberia en C para la comunicación mediante sockets.

Hasta el momento he creado una libreria para comunicar distintos procesos y que entre ellos se manden mensajes y archivos de texto.

Esta parte funciona correctamente.

EL PROBLEMA:

No he conseguido cerrar/matar uno de los processos que recibe el codigo (un archivo .c o .cpp) sin que el sistema se cuelgue.

Tengo un processo llamado manager que controla y gestiona todo los processos worker encargados de recibir, compilar y ejecutar codigos C o C++.

Este es el codigo de la parte que crea la connexion de la libreria.

Si alguien tiene conocimientos de sockets en C agradeceria mucho la ayuda. Si haec falta puedo facilitar-le el codigo de las distintas partes que usan sockets. Muchas gracias.

El proyecto sera libre en codigo abierto.

/*
* Se le pasa un socket de servidor y acepta en el una conexion de cliente.
* devuelve el descriptor del socket del cliente o -1 si hay problemas.
* Esta funcion vale para socket AF_INET o AF_UNIX.
*/
int Servidor_Acepta_Conexion_Del_Cliente (int Descriptor)
{
	socklen_t Longitud_Cliente;
	struct sockaddr Cliente;
	int Hijo;
 
	/*
	* La llamada a la funcion accept requiere que el parametro 
	* Longitud_Cliente contenga inicialmente el tamano de la
	* estructura Cliente que se le pase. A la vuelta de la
	* funcion, esta variable contiene la longitud de la informacion
	* util devuelta en Cliente
	*/
	Longitud_Cliente = sizeof (Cliente);
	Hijo = accept (Descriptor, &Cliente, &Longitud_Cliente);
	if (Hijo == -1)
		return -1;
 
	/*
	* Se devuelve el descriptor en el que esta "enchufado" el cliente.
	*/
	return Hijo;
}
 
/*
* Abre un socket servidor de tipo AF_INET. Devuelve el descriptor
*	del socket o -1 si hay probleamas
* Se pasa como parametro el nombre del servicio. Debe estar dado
* de alta en el fichero /etc/services
*/
int Servidor_Abre_Socket_Inet (char *Servicio, int longitudColaEspera)
{
	struct sockaddr_in Direccion;
	struct sockaddr Cliente;
	socklen_t Longitud_Cliente;
	struct servent *Puerto;
	int Descriptor;
 
	/*
	* se abre el socket
	*/
	Descriptor = socket (AF_INET, SOCK_STREAM, 0);
	if (Descriptor == -1)
	 	return -1;
 
	/*
	* Se obtiene el servicio del fichero /etc/services
	*/
	Puerto = getservbyname (Servicio, "tcp");
	if (Puerto == NULL)
		return -1;
 
	/*
	* Se rellenan los campos de la estructura Direccion, necesaria
	* para la llamada a la funcion bind()
	*/
	Direccion.sin_family = AF_INET;
	Direccion.sin_port = htons(Puerto->s_port);
	Direccion.sin_addr.s_addr = htonl(INADDR_ANY);
	//Direccion.sin_port = (Puerto->s_port);
	//Direccion.sin_addr.s_addr = (INADDR_ANY);
	if (bind (
			Descriptor, 
			(struct sockaddr *)&Direccion, 
			sizeof (Direccion)) == -1)
	{
		close (Descriptor);
		return -1;
	}
 
	/*
	* Se avisa al sistema que comience a atender llamadas de clientes
	*/
	if (listen (Descriptor, longitudColaEspera) == -1)
	{
		close (Descriptor);
		return -1;
	}
 
	/*
	* Se devuelve el descriptor del socket servidor
	*/
	return Descriptor;
}
 
/*
/ Conecta con un servidor remoto a traves de socket INET
*/
int Cliente_Abre_Conexion_Inet (char *Host_Servidor, char *Servicio)
{
	struct sockaddr_in Direccion;
	struct servent *Puerto;
	struct hostent *Host;
	int Descriptor;
 
	Puerto = getservbyname (Servicio, "tcp");
	if (Puerto == NULL)
		return -1;
 
	Host = gethostbyname (Host_Servidor);
	if (Host == NULL)
		return -1;
 
	Direccion.sin_family = AF_INET;
	Direccion.sin_addr.s_addr = ((struct in_addr *)(Host->h_addr))->s_addr;
	Direccion.sin_port = htons(Puerto->s_port);
	//Direccion.sin_port = (Puerto->s_port);
 
	Descriptor = socket (AF_INET, SOCK_STREAM, 0);
	if (Descriptor == -1)
		return -1;
 
	if (connect (
			Descriptor, 
			(struct sockaddr *)&Direccion, 
			sizeof (Direccion)) == -1)
	{
		return -1;
	}
 
	return Descriptor;
}
 

---

Si mato uno de los procesos worker el gestor se cuelga devido a la connexión.

Mod: prohibido hacer doble post... tema modificado con etiquetas GeSHi para hacerlo más visible