/// <summary>
/// Cuando se manda a llamar este evento al presionar el boton bt_ipv6_dirrecion_actualizar
/// se desea reactualizar las dirreciones sea con una nueva oferta de DHCP o con
/// una rneovacion a la dirrecion enlace local.
/// NOTA: Como IPv6 puede causar mucho revuelo se ejecutara un RESET antes de estos comandos.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void bt_ipv6_dirrecion_actualizar_Click(object sender, EventArgs e)
{
BoxInterfasesRedes bxInterfas = (BoxInterfasesRedes)box_lista_interfases.SelectedItem;
//En teoria solo debe de pasar con dos posibilidades, pero nos aseugramos
//de que solo sea en esos dos casos.
if (!((rd_ipv6_dhcp.Checked) || (rd_ipv6_plugplay.Checked)))
{
return;
}
if (rd_ipv6_dhcp.Checked)
{
ValidarOperacionInterfas(bxInterfas.setNewDHCPClient(false));
}
else if (rd_ipv6_plugplay.Checked)
{
ValidarOperacionInterfas(bxInterfas.SetIPv6_PlugPlay());
}
//En ambos casos se recomienda esperar algo de tiempo...
//Plug&Play requiere los mensajes de NDP, DHCPv6 requiere respuesta del servidor
Contador.Tick += new EventHandler(Tick_RefreshInterface); // Everytime timer ticks, timer_Tick will be called
//Contador.Interval = (1000) * (1); // Timer will tick evert second
Contador.Enabled = true; // Enable the timer
Contador.Start(); // Start the timer
}
/// <summary>
/// Los eventos cuando se seleccione una IPv6 de la lista de opciones.
/// Cada vez que se selecciona una se indica su tipo (Plug&Play, DHCP, static)
/// Observacion: Plug&Play considera el formato IETF64 y el Random.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ipv6_lb_addresses_SelectedIndexChanged(object sender, EventArgs e)
{
BoxInterfasesRedes bxInterfas = (BoxInterfasesRedes)box_lista_interfases.SelectedItem;
//Si no hay elementos no se ejecuta (En teoria no deberia llamarse este evento
//si no los hay... pero mejor prevengo...
if (ipv6_lb_addresses.Items.Count < 1)
{
return;
}
String sAux = ipv6_lb_addresses.Items[0].ToString();
if ((bxInterfas.getOrigingIPv6Suffix(sAux, SuffixOrigin.LinkLayerAddress)) ||
(bxInterfas.getOrigingIPv6Suffix(sAux, SuffixOrigin.Random)))
{
rd_ipv6_plugplay.Checked = true;
}
else if (bxInterfas.getOrigingIPv6Suffix(sAux, SuffixOrigin.OriginDhcp))
{
rd_ipv6_dhcp.Checked = true;
}
else
{
rd_ipv6_static.Checked = true;
}
}
private int ActualizarListaInterfases()
{
int iC2 = 0;
BoxInterfasesRedes bxAux;
niInterfases = new List <NetworkInterface>(NetworkInterface.GetAllNetworkInterfaces());
box_lista_interfases.BeginUpdate();
box_lista_interfases.Items.Clear();
for (int c = 0; c < niInterfases.Count; c++)
{
/// El gran problema que se tiene es que Win7 maneja demasiadas interfases especiales por
/// cada una que tengamos, asi que tenemos uqe filtrar hasta obtener las que si son
/// interfases fisicas, despues estas las almacenaremos tal por cual dentro del Combobox
/// box_lista_interfases y utilizaremos la clase BoxInterfasesRedes para facilitarnos las cosas
if ((niInterfases[c].NetworkInterfaceType != NetworkInterfaceType.Loopback) &&
(niInterfases[c].NetworkInterfaceType != NetworkInterfaceType.Tunnel) &&
(niInterfases[c].NetworkInterfaceType != NetworkInterfaceType.Unknown) /*&&
* (niInterfases[c].OperationalStatus == OperationalStatus.Up)*/)
{
iC2++;
bxAux = new BoxInterfasesRedes(niInterfases[c]);
box_lista_interfases.Items.Add(bxAux);
}
}
box_lista_interfases.Sorted = true;
box_lista_interfases.EndUpdate();
return(1);
}
private void bt_ipv6_form_avanzado_Click(object sender, EventArgs e)
{
BoxInterfasesRedes bxInterfas = (BoxInterfasesRedes)box_lista_interfases.SelectedItem;
conf_avanzada Formulario = new conf_avanzada(bxInterfas);
Formulario.VersionIP = false;
Formulario.ShowDialog();
//Una vez hecho las modificaciones (klas cuales se ejecutan en el mismo formulario hijo )
//reactualizamos las interfases
Actualizar_Despliegue_Interfaz();
}
/// <summary>
/// Este es el evento para validar la dirreción IP
/// Para dejarlo sencillo, pasaremos un vil y simple Parse para validar el formato, en caso qeu sea erroneo...
/// le notificaremos al usuario, en caso qeu sea valido, cerramos el formulario.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button1_Click(object sender, EventArgs e)
{
BoxInterfasesRedes Validador = new BoxInterfasesRedes();
if (!Validador.GetIsValidIPAddress(text_ip.Text, bVersionIP))
{
MessageBox.Show("Error en el formato", "Campo invalido", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, MessageBoxOptions.DefaultDesktopOnly);
return;
}
//Como la IP es valida
sIPAddress = text_ip.Text;
bModificado = true;
this.Close();
}
/// <summary>
/// Este es el constructor que poblara de forma correcta el nuevo formulario
/// </summary>
/// <param name="Interfaz"></param>
public conf_avanzada(BoxInterfasesRedes Interfaz)
{
InitializeComponent();
nInterfaz = Interfaz;
bModificado_dns = false;
bModificado_win = false;
bModificado_gtw = false;
/// Esta linea fue omitida ya que en estos momentos, no hay informacion
/// valida en bVersionIP para poblar adecuadamente las tablas
/// Si se queda, se deber[ia de volver a ejecutar para estar seguros
//PoblarTablas();
}
/// <summary>
/// Este evento anexara el Gtw de IPv6 a la lista
/// La razon porla que se maneja separdo a la dirrecion es que puede
/// ser mas dificil de manipular.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void bt_ipv6_gt_anexar_Click(object sender, EventArgs e)
{
String[] sGtw = new String[1];
BoxInterfasesRedes bxInterfas = (BoxInterfasesRedes)box_lista_interfases.SelectedItem;
//Solo debe de ocurrir cuando se este trabajando con estaticas
if (!rd_ipv6_static.Checked)
{
return;
}
sGtw[0] = ipv6_tb_gtw.Text;
//Gtw solo cmabia si no esta en blanco
if (!(sGtw[0].Equals("::")) && !(sGtw[0].Equals("0::0")) && !(sGtw[0].Equals("")))
{
ValidarOperacionInterfas(bxInterfas.SetIPv6Gateways(sGtw));
}
}
/// <summary>
/// Al ejecutar este boton se abre una nueva forma ( con_avanzadas )
/// con el cual se supone el usuario puede introducir una serie
/// de colecciones de servidores DNS y WIN ademas de Gateways
/// Para facilitar las cosas, no enviaremos colecciones, si no el objeto
/// de la interfaz con esa misma info
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void bt_form_avanzado_Click(object sender, EventArgs e)
{
//Empeznado con lo basico, hay que declarar tres coleccioens o listas
//A partir de la interfaz seleccionada
BoxInterfasesRedes bxInterfas = (BoxInterfasesRedes)box_lista_interfases.SelectedItem;
conf_avanzada Formulario = new conf_avanzada(bxInterfas);
Formulario.VersionIP = true;
Formulario.ShowDialog();
//Una vez hecho las modificaciones (klas cuales se ejecutan en el mismo formulario hijo )
//reactualizamos las interfases
Actualizar_Despliegue_Interfaz();
}
/// <summary>
/// Cuando el boton ipv4_bt_editardirre es presionado se esta intentando
/// fijar una IP estatica. Por lo tanto tomamos
/// los campos de IP (IP/Prefijo + Gtw) y los enviamos a NethSH
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ipv4_bt_editardirre_Click(object sender, EventArgs e)
{
BoxInterfasesRedes bxInterfas = (BoxInterfasesRedes)box_lista_interfases.SelectedItem;
String sIP = ipv4_tb_address.Text;
String sMk = ipv4_tb_mask.Text;
String sGt = ipv4_tb_gtw.Text;
//Aunque se supone que solo se puede dar clic cuando el boton esta disponible
//garantizamos que sea cuando el usuario esta trabajando con IPv4 estatica.
if (!ipv4_estatica.Checked)
{
return;
}
//Ejecutamos el comando para fijar la IP.
ValidarOperacionInterfas(bxInterfas.setIPv4FullAddress(sIP, sMk, sGt));
return;
}
/// <summary>
/// Cuando el usuario da clic en el boton ipv4_bt_dhcprenew el objetivo es renovar
/// la IP con una nueva solicitud desde un cliente DHCP. Por medio de Netsh se hara tal cosa.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ipv4_bt_dhcprenew_Click(object sender, EventArgs e)
{
BoxInterfasesRedes bxInterfas = (BoxInterfasesRedes)box_lista_interfases.SelectedItem;
//Aunque se supone que solo se puede dar clic cuando el boton esta disponible
//garantizamos que sea cuando el usuario esta trabajando con IPv4 dinamica.
if (!ipv4_dinamica.Checked)
{
return;
}
ValidarOperacionInterfas(bxInterfas.setNewDHCPClient(true));
//NOTA: Aqui suelen morir los que solo programan Software... el comando se ejecuta
// en nanosegundos, pero obviamente la respuesta del servidor llegara en milisegundos
// DEBEMOS ESPERAR para obtener una respuesta satisfactoria.
Contador.Tick += new EventHandler(Tick_RefreshInterface); // Everytime timer ticks, timer_Tick will be called
//Contador.Interval = (1000) * (1); // Timer will tick evert second
Contador.Enabled = true; // Enable the timer
Contador.Start(); // Start the timer
}
/// <summary>
/// Cuando se llame este evento es para eliminar una dirrecion de red IPv6
/// con todo y gateway de las que estan en el listbox.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void bt_ipv6_dirrecion_quitar_Click(object sender, EventArgs e)
{
BoxInterfasesRedes bxInterfas = (BoxInterfasesRedes)box_lista_interfases.SelectedItem;
String sIPv6Add;
String[] sGtw = new String[1];
//Primero, solo debe de ocurrir cuando se este trabajando con estaticas
if (!rd_ipv6_static.Checked)
{
return;
}
//Segundo, solo debe de pasar cuando el LB tiene mas de un objeto
if (!(ipv6_lb_addresses.Items.Count > 0))
{
return;
}
//Tercero, solo debe de pasar cuando hay una dirrecion selecciona
sIPv6Add = (String)ipv6_lb_addresses.SelectedItem;
if (sIPv6Add == null)
{
return;
}
else if (sIPv6Add.Equals("")) //String vacio no es aceptable (Antes debemos evitar null).
{
return;
}
sGtw[0] = ipv6_tb_gtw.Text;
ValidarOperacionInterfas(bxInterfas.RemoveIPv6Address(sIPv6Add));
//Gtw solo cmabia si no esta en blanco
if (!(sGtw[0].Equals("::")) && !(sGtw[0].Equals("0::0")) && !(sGtw[0].Equals("")))
{
ValidarOperacionInterfas(bxInterfas.RemoveIPv6Gateways(sGtw));
}
}
/// <summary>
/// Cuando este evento es invocado lo que se desea es introducir una nueva
/// dirrecion IPv6 a la lista de dirreciones (Con todo y potencial Gateway si es uno valido)
/// La metodologia es invocar el formulario form_ipaddress para que el usuario
/// pueda introducir la sintaxis.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void bt_ipv6_dirrecion_anexar_Click(object sender, EventArgs e)
{
BoxInterfasesRedes bxInterfas = (BoxInterfasesRedes)box_lista_interfases.SelectedItem;
form_ipaddress fIPadd = new form_ipaddress();
//Solo debe de ocurrir cuando se este trabajando con estaticas
if (!rd_ipv6_static.Checked)
{
return;
}
fIPadd.ShowDialog();
//Le pasamos el chisme de que que es IPv6 lo que queremos
fIPadd.VersionIP = false;
//¿Se introdujo una IP adecuada?
if (fIPadd.Valido)
{
//Anexamos la IPv6 ADdress
ValidarOperacionInterfas(bxInterfas.setIPv6Address(fIPadd.IPAddress));
}
fIPadd.Dispose();
}
/// <summary>
/// Este metodo se mandara a llamar cada vez que se desee actualizar la información en pantalla
/// de la interfaz seleccionada.
/// Se debe garantizar que este seleccionado un item en el combobox antes de mandar a llarmarlo.
/// </summary>
/// <returns></returns>
///
private int Actualizar_Despliegue_Interfaz()
{
///Lo primero, es obtener la Interfaz seleccionada
BoxInterfasesRedes bxInterfas = (BoxInterfasesRedes)box_lista_interfases.SelectedItem;
ipv6_lb_addresses.BeginUpdate();
#region Limpiar_Componentes
//Lo primero es limpiar los cuadros de texto, con el objetivo de que no se despliegue
//informacion anterior y por lo mismo erronea(Particularmente importante cuando
//el protocolo esta deshabilitado).
ipv4_tb_address.Text = "";
ipv4_tb_gtw.Text = "";
ipv4_tb_mask.Text = "";
ipv6_tb_gtw.Text = "";
ipv6_lb_addresses.Items.Clear();
#endregion
#region Detectar_EstadoInterfaz
//Vemos como esta la itnerfaz, para motivos practicos, mostramos DOWN para cualquier
//estatus distinto a una interfaz Levantada.
// En caso de estar caida deshabilito los componentes y botones de esa hoja del tabulador.
// Dejo el Try-Catch por trabajar con archivos fisicos (las imagenes )
try
{
if (bxInterfas.getIntStatus())
{
//El boton de estatus de la interfaz
picture_updown.Image = global::Manejador_de_Redes.Properties.Resources.UP;
toolTip1.SetToolTip(picture_updown, Msg_EstatusInterfazUP);
//ADemas del estado del a interfaz depende el protocolo habilitado.
//Los componentes IPv4
if (bxInterfas.getisIPv4Enable())
{
panel_ipv4.Enabled = true;
bt_ipv4_form_avanzado.Enabled = true;
ipv4_groupbox_tipodirre.Enabled = true;
}
else
{
panel_ipv4.Enabled = false;
bt_ipv4_form_avanzado.Enabled = false;
ipv4_groupbox_tipodirre.Enabled = false;
}
//Los componentes IPv6
if (bxInterfas.getisIPv6Enable())
{
panel_ipv6.Enabled = true;
bt_ipv6_form_avanzado.Enabled = true;
ipv6_groupbox_tipodirre.Enabled = true;
}
else
{
panel_ipv6.Enabled = false;
bt_ipv6_form_avanzado.Enabled = false;
ipv6_groupbox_tipodirre.Enabled = false;
}
}
else //TODO MUERE
{
//El boton de estatus de la interfaz
picture_updown.Image = global::Manejador_de_Redes.Properties.Resources.Down;
toolTip1.SetToolTip(picture_updown, Msg_EstatusInterfazDown);
//Los componentes IPv4
panel_ipv4.Enabled = false;
bt_ipv4_form_avanzado.Enabled = false;
ipv4_groupbox_tipodirre.Enabled = false;
//Los componentes IPv6
panel_ipv6.Enabled = false;
bt_ipv6_form_avanzado.Enabled = false;
ipv6_groupbox_tipodirre.Enabled = false;
}
}
catch (SystemException error)
{
throw (error); // Rethrowing exception e
}//Catch*
#endregion
#region Actualizar_datos
//Con las ventanas preparadas llenaremos los campos de IPv4 e IPv6 con
//datos obtenidos de la misma interfaz.
ipv4_tb_address.Text = bxInterfas.getIpv4Address();
ipv4_tb_gtw.Text = bxInterfas.getFirstIpv4Gateway();
ipv4_tb_mask.Text = bxInterfas.getNetmask();
ipv6_tb_gtw.Text = bxInterfas.getFirstIpv6Gateway();
List <String> lAux;
lAux = bxInterfas.getAllIpv6Address();
//Cada dirrecion debe ser incluida en el ListBox
//Por defecto la primera dirrecion sera selecionada
foreach (String sIPv6 in lAux)
{
ipv6_lb_addresses.Items.Add(sIPv6);
}
if (ipv6_lb_addresses.Items.Count > 0)
{
ipv6_lb_addresses.SelectedIndex = 0;
}
ipv6_lb_addresses.EndUpdate();
//Ahora viene detectar el modo de trabajo de IPv4
//Relativamente facil al solo tener un tipo de dirrecionamiento.
if (bxInterfas.getisDHCPv4Enabled())
{
ipv4_dinamica.Checked = true;
}
else
{
ipv4_estatica.Checked = true;
}
//IPv6 es otro boleto... al tener multiples dirreciones
//Potencial Error en el disenio de la aplicacion: las multiples posibles
//dirreciones por interfaz ¿permiten tener DHCP y Estaticas simultaneamente?
//¿Permite tener stateless y stateful simultaneamente? (Ya que el link-state siempre
// sera stateless es un hecho que pueden haber fe80:: con stateful)
//Por el momento la aplicacion forzara a la persona a solo tener
// DHCP | Estatica | plug&play
//La solucion sera manejar IPv6 de forma distinta a IPv4. Se indicara el tipo
//de dirrecion seleccionada del List Box ipv6_lb_addresses
//Claro, esto si hay dirreciones posibles...
if (ipv6_lb_addresses.Items.Count < 1)
{
return(1);
}
if ((bxInterfas.getOrigingIPv6Suffix(lAux[0], SuffixOrigin.LinkLayerAddress)) ||
(bxInterfas.getOrigingIPv6Suffix(lAux[0], SuffixOrigin.Random)))
{
rd_ipv6_plugplay.Checked = true;
}
else if (bxInterfas.getOrigingIPv6Suffix(lAux[0], SuffixOrigin.OriginDhcp))
{
rd_ipv6_dhcp.Checked = true;
}
else
{
rd_ipv6_static.Checked = true;
}
#endregion
return(1);
}
