Así pues si queremos un thread que realice una determinada tarea este método es muy eficaz, por ejemplo para hacer ARP spoofing, debemos de trabajar con listas de hosts, funciones que afectan sobre ellos, y luego tenemos que permitir acceso externo para poder detenerlo o reiniciarlo.
Así pues creo este hilo para buscar cual es la mejor forma de programar esas subrutinas o módulos que están formados por funciones estáticas, atributos propios, y luego funciones externas que hacen de wrapper de los anteriores para poder controlar el funcionamiento de la subrutina desde otra parte del código externa.
Y bien ¿qué ideas se me han ocurrido?, me gustaría ver cuáles se os ocurrirían a vosotros y debatirlo hasta encontrar la manera más eficaz. La idea es no dar visibilidad en partes donde no se necesita, proteger el código.
1. Crear un namespace, con funciones que hacen de wrapper y pueden ser llamadas por terceros para controlar la subrutina. Y declarar las funciones correspondientes a la subrutina como static fuera del namespace.
spoofing.h
Código
namespace Spoofing { Init(); Restart(); Uninit(); }; void EscanearRed(); void RealizarSpoofing(); ...
spoofing.cpp
Código
static BOOL * run = new BOOL(); Spoofing::Init() { *run = TRUE; hosts param1, param2 //declaramos aqui todas las variables de la subrutina, la lista de hosts... //y las inicializamos con las funciones static. while(*run) { EscanerRed(); if(hosts) thread spoof(RealizarSpoofing, param1, param2);... } ... } Spoofing::Uninit() { *run = FALSE; } ... static void EscanearRed(para1, param2) { if(*run) ... } static void RealizarSpoofing() { while(*run) ... }
Utilizo una variable booleana para detener los subthreads que genera la subrutina. De esta manera controlo la subrutina desde el namespace. Al incluir al main.cpp la cabecera spoofing.h no tiene visibilidad a funciones que no son del namespace, no tiene acceso a datos que no le interesan.
Lo malo que hay que pasar parametros del namespace a las funciones static, ¿sería mejor declarar todas las variables fuera de Init() para así no tener que estar pasandolas como argumento de una funcion a otra?, como ocurre con el BOOL* que gracias a que esta fuera no es necesario pasarlo entre funciones.
2. Crear una clase con todos los atributos, ponerla un método Init(), Uninit(), Restart(). Un constructor que inicialice a NULL los atributos, y tras instanciar la clase pasar a llamar a Init(), Uninit(), etc. Lo malo de esto sería que esa clase para poderla usar desde fuera habría que pasar su dirección de memoria. Por ejemplo si en el main.cpp la instanciamos y llamamos a Init(), y luego en archivox.cpp queremos llamar a Uninit(), debemos de pasarle la dirección de la clase instanciada.
También puede tener funciones estáticas.
De momento pongo estos 2 que son los que más me han hecho dudar, y sí también se puede poner todo con funciones staticas, pero ya que es C++ vamos a aprovechar los namespaces y las clases.
Agradecería críticas constructivas
¿Cual creéis que es la mejor? ¿y cuál usaríais vosotros?.
Saludos!!.