Resulta que al hacer sizeof(mac), obtengo 4 bytes, cuando una mac tiene 6 bytes, uno para cada u_char si no me equivoco.

u_char *mac_gateway = new u_char[6]();
 
		u_long num_gateway = inet_addr(adaptador->GatewayList.IpAddress.String);
 
 
		if (num_gateway == INADDR_NONE){
			Sleep(REINTENTAR_MITM * 1000);
			continue;
		}
 
		if (!enviar_arp(adaptador->GatewayList.IpAddress.String,
			adaptador->IpAddressList.IpAddress.String, mac_gateway)){
			Sleep(REINTENTAR_MITM/2 * 1000);
			continue;
		}
 
		for (int i = 0; i < 6; i++)
			printf("%d=%x ", i,mac_gateway[i]); 
 
		system("pause");
 
		for (int i = 0; i < 4; i++)
			printf("%d=%x ", i, ip_gateway[i]);
		system("pause");
		cout << sizeof(mac_gateway) << sizeof(mac_atacante);

Me salen que todas las macs tienen 4 bytes WTF, la ip son 4 bytes, pero las macs no se supone que tienen 6?.

Me he quedado un poco loco con esto. Haber si sabéis algo.

Gracias, un saludo.

Edito: Que broma es esta:

u_char *mac = new u_char[500]();
cout << sizeof(mac);

No, es de 64 bits

Ahh vale, estaba cambiandolo por variables estaticas u_char[6] etc, pero no creo que sea buena idea, ¿como puedo hacer para que me diga el tamaño de lo que apunta el puntero? XP porque con sizeof(*mac) me sale uno el primer elemento, pero para que me diga el tamaño de todos como se puede hacer?.

Gracias como siempre, un saludo.

Edito: Parece que no se puede, hay que hacer una variable estatica y pasar su dirección al puntero, luego ¿la unica solucion es multiplicar por 2 las variables declaradas?.

porque ahora habra:

 u_char mac[6]; u_char *pmac; pmac = &(mac[0]); ...

Y me parece una caca tremenda XD.

Bueno parece que sustituyendo los punteros por esto:

&(mac_gateway[0])

Se soluciona parcialmente el problema, pero esto no lo consigo solucionar:

&(ip_atacante[0]) = (u_char*)&num_atacante;

ERROR: La expresion debe tener valor L modificable.

Solución:

memcpy(&(ip_atacante[0]), (u_char*)&num_atacante, sizeof(u_char)* 4);
		memcpy(&(ip_gateway[0]), (u_char*)&num_gateway, sizeof(u_char)* 4);
		memcpy(&(mac_atacante[0]), (u_char*)adaptador->Address, sizeof(u_char)* 6);

Así funciona, ¿os parece  buena idea? O es mala calidad de código?

La idea de conocer el tamaño de bytes de la variable es para detectar posibles errores al pasar la mac, por ejemplo si llegan 4 bytes solo, pues que detecte error apartir del tamaño, pues deberían llegar 6.

Pero con un puntero parece que no se puede por si mismo, por ello es mejor haciendo u_char mac[6]; y pasar &(ip_gateway[0]) como puntero ¿no?

Saludos.

Quiero saber los bytes que tiene cada u_char*, supongo que no podré utilizar entonces u_char* mac= new...

Necesito declararlo en la HEAP, por lo tanto lo dejaré como lo tenía al principio.

Y ¿como sé si me llegan los bytes o no me llegan?, me refiero me pasan un puntero que apunta a 2 u_char, y lo copio en un puntero de mac, no daría error, pero la mac solo tendría 2 caracteres válidos.

u_char *mac1 = u_char[6]();
u_char * mac2 = u_char[6]();
 
mac1[0] = 0x12; mac 1[1] = 0xc3;
 
mac2 = mac1; // ¿Como detecto que no tiene 6 bytes válidos
//¿tengo que crear una función que lo calcule? o hay alguna funcion que lo haga o algo?
 
 

La idea es que no de lugar a problemas como el que puse, por ejemplo al añadir una victima (ip y mac) a la lista de hosts):

u_char* lista_victimas::obtener_ip(u_char* mac)
{
	if (sizeof(mac) != sizeof(u_char)* 6)
		return NULL;

Quizaaas:

u_char* lista_victimas::obtener_ip(u_char* mac)
{
	if (strlen((char*)mac) != sizeof(u_char)* 6)
		return NULL;

Aunque así da desde la posicion del puntero que pasamos hasta el final de este. Si es mayor no hay problema, si es menor que 6 la mac que obtendremos será erronea.