uff a ver nunca he usado esta manera para crear distintos hilos de ejecucion, pero creo que en algo puedo ayudar:

1) en cuanto a tu duda inicial:

switch(getpeername(sockfd, &sockbuf, &stsize))
   {
    case 0: break; 
    case ENOTCONN:
     printf("Proceso %i: reconectando socket...", ((struct params*)p)->thread);
     //...
 

la funcion getpeername() devuelve 0 en caso de que vaya bien, y -1 en caso de error, y es entonces cuando le da un valor a errno que es el que tu tienes que comprobar. el codigo seria algo asi:

aux=getpeername(sockfd, &sockbuf, &stsize);
if (aux<0 && strcmp("ENOTCONN", strerror(errno))==0) {
     //reconectando socket... etc

2) veo muchas reservas de memoria pero ningun free(). aunque lo normal es que los so modernos se encarguen de liberarla al finalizar el programa, nunca esta de mas ponerlo por si las moscas y para evitar posibles quebraderos de cabeza. te dejo un enlace corto que habla sobre ello:

http://cboard.cprogramming.com/cplusplus-programming/76877-general-malloc-question.html

3) cuando declaras el array de structs:

struct params *p = (struct params*)malloc(atoi(argv[1])*sizeof(struct params));

lo haces como un puntero, pero luego accedes a ellos de esta manera:

p[j].thread = j;
p[j].port = atoi(argv[3]);

no deberias acceder a los campos del struct asi:

*(p[j]).thread=j;

o lo que es lo mismo, asi:

p[j]->thread=j;

en lugar de como tu lo haces? tenia entendido que hacerlo como tu lo haces era solo para un struct estatico. quizas he dicho una burrada, pero me refiero a que pensaba que era para una variable que la declaras asi (lo de estatico no se si esta bien dicho):

struct params p;

y no como un puntero. te funciona bien? si es asi ya lo se para la proxima vez. aunque entonces no se que utilidad tiene el operador '->'.

4) es un codigo que aunque no sea demasiado largo es bastante denso. tu eres quien lo ha codeado y quizas no tengas problemas, pero para quien quiera leerlo e intentar entenderlo cuesta bastante. unos cuantos espaciados y algun que otro comentario ayudarian bastante, y tambien te ayudarian a ti en caso de que dentro de unos meses quieras volver a mirarte el codigo.


5) si no te es mucha molestia podrias colgar el codigo cuando lo acabes ya que a mas de uno le vendra bien para aprender (yo incluido).

un saludo!

pd. estas haciendo este flooder para aquel proyecto en el que os juntasteis unos cuantos de este foro?

sin el codigo completo es algo dificil adivinar de donde viene el error...

getpeername()

y para lo otro, aunque ya lo hayas encontrado, por si acaso no lo has hecho asi, tienes todos los errores definidos en el archivo de cabecera syscall.h, que lo tendras en /usr/include o por ahi.

un saludo!

cierto, no lo dije como deberia haberlo hecho. me referia mas bien a que no hace falta usar ninguna libreria para hacer esto que comentas.


no se si lo sabras, pero para pasar de binario a hexadecimal se cogen los bits en grupos de 4 (por lo que tienes un valor de 0 a 15 para cada agrupacion) y se pasa directamente al caracter hexadecimal. por ejemplo:


luego en cuanto a las mascaras, las mas simples son una AND (&) o una OR (|). para una AND, el resultado sera cierto (1) solo si los dos operandos son 1, y para los demas casos sera 0. en cuanto a la OR, solo sera falso (0) cuando los dos operandos son 0, y en cualquier otro caso sera 1.

te pondre un par de ejemplos mas:

si tienes un numero inicial 01100110 (102 en decimal), y quieres poner a 0 el bit 1 y 2 (en binario, el bit menos significativo es el de la derecha de todo y se considera el bit 0), entonces deberas aplicar una mascara AND con un numero que en esas posiciones tenga los bits en 0, y en todas las restantes tenga 1 para no alterar nada, ya que un AND con un 1 hara que el resultado siga como estaba, puesto que si estaba en 1 seria: 1&1=1 y si estaba en 0 seria: 1&0=0. por lo tanto, el numero que debemos usar para la mascara seria el 11111001, que es el 0xF9 en hexadecimal.

ahora imagina que quieres poner el bit 4 a 1, lo que deberias hacer es aplicar una mascara OR con un numero que tenga el bit en 1 en esa posicion, y las demas en 0 para no alterar nada mas, ya que si el bit estaba en 0: 0|0=0 y si estaba en 1: 1|0=1. este numero seria el 00010000, que es el 0x10 en hexadecimal.

con esto y el operador shift (<< o >>) se pueden hacer infinidad de cosas a nivel de bits. la mas simple de todas, un simple programa que te pase de decimal a binario sin divisiones ni restos. (compila con un warning pero funciona bien, me daba pereza buscar el especificador de formato adecuado):

#include <stdio.h>
 
int main() {
 
	unsigned char byte;
	short int i;
 
	printf("Ingresa un numero del 0-255: ");
	scanf("%u", &byte);
 
	for (i=7; i>=0; i--)
		printf("%u", (byte>>i)&0x01);
	printf("\n");
 
	return 0;
}

con su salida:


espero que te ayude, un saludo!

dependera de si es un entero, un entero corto, un tipo caracter, etc.

para que veas un ejemplo:

#include <stdio.h>
 
int main() {
 
	unsigned int ui;
	unsigned short int usi;
	unsigned char uc;
 
	printf("unsigned int: %lu bytes\n", sizeof(ui));
	printf("unsigned short int: %lu bytes\n", sizeof(usi));
	printf("unsigned char: %lu byte\n", sizeof(uc));
 
	return 0;
}

lo que dara una salida de:


un saludo!

con C se ve que puedes controlar los puertos de tu computadora y hacer lo que dices. he encontrado una pequeña introduccion en el primer o segundo resultado de google:

http://hgr.tripod.com/puertos_c.html

sino siempre puedes usar un microcontrolador y programarlo en C con los compiladores HITECH o CSS por ejemplo, para luego comunicar el microcontrolador con el pc ya que a partir de cierta gama no muy cara disponen de un modulo USART muy facil de usar, entre otros.

espero que te sirva de ayuda, un saludo!

una pregunta que es lo que quieres hacer exactamente? modificar los bits de un byte? esto se suele hacer aplicando mascaras al byte. por ejemplo, si tienes un byte inicial:
y quieres poner a 0 el MSB para que quede asi:
lo que deberias hacer es aplicar la siguiente mascara:
con lo que estarias poniendo a 0 el bit mas significativo, y dejando igual a los demas. si ahora quisieras volver a ponerlo a 1, deberias aplicar la siguiente mascara:

lo digo porque no creo que hagan falta librerias externas y demas para acceder a los bits, ya que con los operadores que trae hay mas que suficiente para muchisimas aplicaciones. si tienes alguna pregunta ya diras...

espero que te sirva de ayuda, un saludo!

Datos[c].CodigoBarras es un numero entero, y tu lo estas pasando como argumento a una funcion que espera un puntero a caracter. no se si lo sabras, pero strlen() devuelve la longitud de la cadena pasada como parametro, por lo que pasarle un entero como parametro no tiene mucho sentido.

si lo que quieres hacer es tratar a un codigo de barras como un array de enteros, entonces tienes que hacerte alguna funcion que te diga el total de digitos que tiene el numero. ademas seria mas facil declarar el codigo de barras asi:

int CodigoBarras[10];

si quieres trabajar el codigo de barras como una cadena para usar strlen(), entonces debes declararlo como tal:

char CodigoBarras[10];

espero que te ayude, un saludo!

estas reservando memoria para un array de punteros a caracter, pero luego no reservas memoria para cada uno de esos punteros. suponiendo que quieres que la matriz contenga NumPal palabras y que cada palabra tenga un maximo de NumLet letras (sin incluir el NULL al final):

char** matriz=(char**)malloc(NumPal*sizeof(char*));
for (j=0; j<NumPal; j++) matriz[j]=(char*)malloc((NumLet+1)*sizeof(char));

y al final de programa, no te olvides de liberar la memoria reservada:

for (j=0; j<NumPal; j++) free(matriz[i]);
free(matriz);

un saludo!

prueba asi:

#include <stdio.h>
#include <stdlib.h>
 
int main(){
 
	int n, *p;
	FILE *f;
 
	n=10;
	f=fopen("mem.txt","w");
	fprintf(f,"%p",&n);
	fclose(f);
 
	f=fopen("mem.txt","r");
	fscanf(f,"%p",&p); // aqui te faltaba el &
	fclose(f);
	printf("%d\n", *p); // aqui se imprime el numero 10
 
	return 0;
}

un saludo!