Question

Como dice el titulo, intento en C, crear un array donde cada posicion del mismo, tenga una longitud de 1 bit.

El problema es el siguiente, necesito una forma de listar todos los puertos, y que cada puerto tenga 2 estados. Cerrado (0), o abierto (1). Para ello, solo necesito un bit de memoria por puerto.

Lo intenté de la siguiente manera:

typedef struct{
      int ports:1 [65535];
}ports;

Pero no funciona. Otra solucion posible era:

 typedef struct{
        int 1:1;
        int 2:1;
        int 3:1;
        int 4:1;
        .
        .
        .
        int 65535:1;
    }ports;

Y obtener el resultado con un simple:
ports.N
Donde N es el numero de puerto

Pero por razones obvias, quiero buscar una solucion mejor que escribir los 65535 puertos y quedarme sin manos en el proceso ._.

¿Alguna idea?

Answer 1

Hola Facu-Curti,

vamos por partes. Por un lado, no puede tener una variable en C que ocupe solo un bit, ya que el mínimo tamaño que C puede direccionar es de 1 byte.

En este caso, podrías tener un array de bytes y asignarles valores de 0 y 1 (o V y F, o O y C [Open / Close])

Podrías complicarte la vida o montar todo esto sobre un unsigned long que va desde 0 a 2 mil millones y pico, y trabajar con operaciones de corrimiento de bits y un poco de álgebra boleana para que cada 0 y 1 que en binario forman estos 2 bytes, tenga para tu software el sentido semántico que corresponde a un puerto abierto o cerrado, según la posición del 0 y 1 que ocupan, que en definitiva será algo así como 000011000... para representar que están abiertos los puertos de PING, FTP DATA y FTP (7+20+21)... pero para mi gusto es demasiado complicado y salvo que estés trabajando con software embebido o algún tipo de hardware mínimo, lo evitaría.

Para no consumir toda la memoria de un tirón en la asignación, creo que lo mejor es un arreglo dinámico en el que por ejemplo guardarás solo los puertos abiertos (que deberían ser menos que los cerrados) y soportar el costo de agregar elementos dinámicamente. Te dejo acá un enlace con ejemplos de uso y de asignación de espacio: http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Manejo_din%C3%A1mico_de_memoria

En tu caso, haría un aray de punteros a byte, que es el menor espacio que pudés direccionar.

Si los recursos no son un problema, usá directamente un array de char con 65535 posiciones: consumirás 64K de RAM al crearlo, pero el manejo es trivial.

char ports[65535];

ponerlo dentro de un struct o no es ya cuestión de gustos.

Saludos!

Answer 2

Como comenta @facu-curti, se podría hacer algo como:

char puertos[8191];

Luego a la hora de acceder sería una simple operación matemática:

int getPosicionArray(int puerto) {
    if(puerto > 65534 || puerto < 0) {
        printf("El valor del puerto no es correcto");
        return -1;
    }

    return puerto / 8;    //Division entera
}

Por otro lado, necesitarías una función que te diga el bit (de entre los 8 de cada posición) es el que necesitas:

int getPosicionBit(int puerto) {
    if(puerto > 65534 || puerto < 0) {
        printf("El valor del puerto no es correcto");
        return -1;
    }

    return puerto % 8;   //Modulo o resto de la division
}

Por último para recuperar el bit sólo habría que utilizar las dos funciones anteriores:

int getEstadoPuerto(int puerto) {
    if(puerto > 65534 || puerto < 0) {
        printf("El valor del puerto no es correcto");
        return -1;
    }

    int posicionArray = getPosicionArray(puerto);
    int posicionBit = getPosicionBit(puerto);
    return (int) 0x00000001 & (puertos[posicionArray] >> posicionBit);
}

Esa función devolvería 0 y 1 dependiendo del estado del puerto. Para abrir o cerrar un puerto bastaría hacer otro método parecido a getEstadoPuerto pero escribiendo el valor.

Cabría destacar que los puertos irían desde el 0 hasta el 65534. En caso de querer que fuesen desde el 1 hasta el 65535 habría que hacer pequeñas modificaciones.

Con ese código en memoria sólo tendrías 7KB (8191 bytes / 1024), por lo que quizás sería una solución a tener en cuenta.

Saludos.

Answer 3

@Leonardo-Tadei , no. mira:
unsigned char b0:1;

Eso dentro del struct, consume solo 1 bit. Es cierto lo que dices, la direccion minima redireccionable de memoria es de un byte. PERO, se puede trabajar individualmente bit a bit. Gracias a los struct.

En ese struct yo defino 8 lugares de un bit cada uno. Podria haber echo:

struct bits{
   int b0:1;
   int b1:1;
   int b2:1;
   int b3:1;
   int b4:1;
   int b5:1;
   int b6:1;
   int b7:1;
}

Y todo el struct seguria ocupando un byte. Puesto que tiene 8 posiciones de un bit cada uno. El :1 al lado del nombre de la variable, indica la cantidad de bits a ocupar. Podrian haber sido 5, 7 o 100 si quisiera. La definicion como int, o unsigned char, solo se hace para especificar la forma en que se almacenaran los valores dentro de ese bit. Si hubiera puesto float o double, trabajaria de forma diferente, pero seguiria ocupando un bit cada posicion del struct.

Por otro lado, si yo hubiera colocado:

  struct bits{
   unsigned char b0:1;
   unsigned char b1:1;
   unsigned char b2:1;
}

Eso no ocuparía 3 bits, como se puede esperar. Eso ocupa un byte. Por que como dices, es la minima dimension redireccionable. Por lo tanto, el tamaño de un struct, siempre deben ser multiplos de un byte. PERO, se pueden trabajar esos bytes de forma que podamos utilziarlos bit a bit.

Otra solucion que encontre, y a mi parecer mucho mejor, fue la de crear un unsigned char. Y trabajar con esta variable a travez de operaciones de corrimientos de bits. Mira:

    int checkPort(unsigned short int ports, unsigned short int port){
        return (ports & (1 << port));
}

void openPort(unsigned short int* ports, unsigned short int port){
    if ( !checkPort(*ports,port) ){
        *ports ^= (1 << port);
    }
}

void closePort(unsigned short int* ports, unsigned short int port){
    if (checkPort(*ports,port)){
        *ports ^= (1 << port);
    }
}

Con esas 3 funciones, checo el estado, abro, o cierro un puerto, respectivamente.

Gracias a todos, saludos! ;)