public static byte[] NotificarSincronizacion()
{
string mensajeOK = "OK";
Protocolo.Protocolo protocoloRespuesta = new Protocolo.Protocolo("RES", "5", 9 + mensajeOK.Length, Encoding.ASCII.GetBytes(mensajeOK));
return(Encoding.ASCII.GetBytes(protocoloRespuesta.ToString()));
}
public static byte[] IniciarSesion(byte[] data)
{
//Procesar la info y validar el usuario
Protocolo.Protocolo prot = Protocolo.Protocolo.BytesAProtocolo(data);
var nombreUsuario = Encoding.UTF8.GetString(prot.darBytes()).TrimEnd().Replace("\0", string.Empty);
bool valido = false;
XmlDocument datosServer = new XmlDocument();
datosServer.Load("../../../Servidor/UsuariosHabilitados.xml");
XmlNodeList users = datosServer.GetElementsByTagName("usuarios");
//Primero verificamos que exista una conexion para este cliente y luego que este habilitado
if (!ConexionServidor.YaEstaConectado(nombreUsuario))
{
foreach (XmlElement user in users)
{
var nombresUsuarios = user.ChildNodes;
foreach (XmlElement usuario in nombresUsuarios)
{
string nombre = usuario.FirstChild.Value;
if (nombre == nombreUsuario)
{
valido = true;
}
}
}
}
string respuesta = nombreUsuario + "#" + valido.ToString();
Protocolo.Protocolo ProtRespuesta = new Protocolo.Protocolo("RES", "1", 9 + respuesta.ToString().Length, Encoding.ASCII.GetBytes(respuesta.ToString()));
return(Encoding.ASCII.GetBytes(ProtRespuesta.ToString()));
}
public static byte[] SubirArchivo(string datos)
{
string nombreArchivoYCantPaquetes = datos.TrimEnd().Replace("\0", string.Empty);
string nombreArchivo = nombreArchivoYCantPaquetes.Split('#')[0];
int cantPaquetes = Int16.Parse(nombreArchivoYCantPaquetes.Split('#')[1]);
string mensajeRet = "";
//Verificamos que no exista un archivo con ese nombre
if (archivosEnServidor == null)
{
archivosEnServidor = new List <string>();
}
lock (archivosEnServidor)
{
if (archivosEnServidor.Contains(nombreArchivo))
{
mensajeRet = "ERROR";
}
else
{
mensajeRet = "OK";
archivosEnServidor.Add(nombreArchivo);
}
}
Protocolo.Protocolo protocoloRespuesta = new Protocolo.Protocolo("RES", "3", 9 + mensajeRet.Length, Encoding.ASCII.GetBytes(mensajeRet));
return(Encoding.ASCII.GetBytes(protocoloRespuesta.ToString()));
}
public static byte[] SubirPaqueteDeArchivo(byte[] datos)
{
string datosString = Encoding.UTF8.GetString(datos).TrimEnd().Replace("\0", string.Empty);
string mensajeOK = "OK";
Protocolo.Protocolo protocoloRespuesta = new Protocolo.Protocolo("RES", "7", 9 + mensajeOK.Length, Encoding.ASCII.GetBytes(mensajeOK));
return(Encoding.ASCII.GetBytes(protocoloRespuesta.ToString()));
}
public static byte[] ListarArchivos()
{
string directorio = directorioServidor;
string[] fileEntries = Directory.GetFiles(directorio);
string archivos = "";
foreach (var file in fileEntries)
{
archivos += file + "#";
}
string comando = "2";
string header = "RES";
int largo = 9 + archivos.Length;
Protocolo.Protocolo protocoloRespuesta = new Protocolo.Protocolo(header, comando, largo, Encoding.ASCII.GetBytes(archivos));
return(Encoding.ASCII.GetBytes(protocoloRespuesta.ToString()));
}
public static byte[] DescargarArchivo(byte[] datos)
{
string directorio = directorioServidor;
string nombreArchivo = Encoding.UTF8.GetString(datos).TrimEnd().Replace("\0", string.Empty).Split('#')[0];
int cantPaquetes = 0;
//Aca hay que verificar que exista el archivo
try
{
int largo = File.ReadAllBytes(directorio + "\\" + nombreArchivo).Length;
cantPaquetes = (largo / 9990) + 1; // minimo 1
}
catch (FileNotFoundException e)
{
}
string archivoYCantPaquetes = nombreArchivo + "#" + cantPaquetes;
Protocolo.Protocolo protocoloRespuesta = new Protocolo.Protocolo("RES", "4", 9 + archivoYCantPaquetes.Length, Encoding.ASCII.GetBytes(archivoYCantPaquetes));
string protocoloString = protocoloRespuesta.ToString();
byte[] bytes = Encoding.ASCII.GetBytes(protocoloString);
return(bytes);
}
static void HandleClient(Socket client)
{
bool reciboNombre = true;
bool connected = true;
while (connected)
{
try
{
int i;
byte[] data = new byte[9999];
byte[] loginResponse = new byte[1];
i = client.Receive(data);
if (reciboNombre)
{
byte[] respuestaLogin = SistemaServidor.IniciarSesion(data);
string respuestaString = Encoding.UTF8.GetString(SistemaServidor.getDatos(respuestaLogin)).TrimEnd().Replace("\0", string.Empty);
bool usuarioValido = Boolean.Parse(respuestaString.Split('#')[1]);
string nombreUsuario = respuestaString.Split('#')[0];
if (usuarioValido)
{
ObjetoConexion con = new ObjetoConexion(client, nombreUsuario);
AgregarCliente(con);
reciboNombre = false;
client.Send(respuestaLogin);
Console.WriteLine("Conectado al cliente " + nombreUsuario);
}
else
{
client.Send(respuestaLogin);
Console.WriteLine("Cliente " + nombreUsuario + " inválido.");
}
}
else
{
string comando = SistemaServidor.getComando(data);
byte[] datos = SistemaServidor.getDatos(data);
byte[] respuestaServidor = new byte[9999];
if (comando == "2")
{
respuestaServidor = SistemaServidor.ListarArchivos();
client.Send(respuestaServidor);
}
if (comando == "3")
{
respuestaServidor = SistemaServidor.SubirArchivo(Encoding.UTF8.GetString(datos).TrimEnd());
int cantPaquetes = Int16.Parse(Encoding.UTF8.GetString(datos).TrimEnd().Replace("\0", string.Empty).Split('#')[1]);
string nombreArchivoASubir = Encoding.UTF8.GetString(datos).TrimEnd().Replace("\0", string.Empty).Split('#')[0];
client.Send(respuestaServidor);
int paqueteActual = 1;
int offset = 0;
FileStream fileStream = new FileStream(directorioServidor + "\\" + nombreArchivoASubir, FileMode.Create, FileAccess.Write);
while (paqueteActual <= cantPaquetes)
{
i = client.Receive(data);
Console.WriteLine("Recibiendo " + nombreArchivoASubir + ". Paquete " + paqueteActual + " de " + cantPaquetes);
int largoPaquete = SistemaServidor.darLargo(data) - 9;
byte[] PaqueteArchivo = SistemaServidor.getDatos(data);
if (paqueteActual == cantPaquetes)
{
PaqueteArchivo = PaqueteArchivo.Take(largoPaquete).ToArray();
}
SistemaServidor.GuardarPaqueteDeArchivo(fileStream, PaqueteArchivo, nombreArchivoASubir);
paqueteActual++;
respuestaServidor = SistemaServidor.SubirPaqueteDeArchivo(data);
client.Send(respuestaServidor);
}
fileStream.Close();
}
if (comando == "4")
{
respuestaServidor = SistemaServidor.DescargarArchivo(datos);
client.Send(respuestaServidor);
Protocolo.Protocolo protocoloRespuesta = Protocolo.Protocolo.BytesAProtocolo(respuestaServidor);
byte[] bytesRespuesta = protocoloRespuesta.darBytes();
string stringRespuesta = Encoding.UTF8.GetString(bytesRespuesta);
int cantPaquetesAMandar = Int16.Parse(stringRespuesta.Split('#')[1]);
string nombreArchivo = Encoding.UTF8.GetString(bytesRespuesta).Split('#')[0];
if (cantPaquetesAMandar == 0)
{ //No se encontro el archivo
Console.WriteLine("Error. No se encontro el archivo " + nombreArchivo + " en el directorio del cliente");
}
else
{
string rutaArchivo = directorioServidor + "\\" + nombreArchivo;
FileStream fs = new FileStream(rutaArchivo, FileMode.Open);
int paqueteActual = 1;
while (paqueteActual <= cantPaquetesAMandar)
{
byte[] req = new byte[256];
i = client.Receive(req);
int bytesPorDefecto = 9990;
if (paqueteActual == cantPaquetesAMandar)
{
var largo = fs.Length;
bytesPorDefecto = (int)largo - (9990 * (paqueteActual - 1));
}
byte[] dataParaEnviar = new byte[bytesPorDefecto];
int iDataRead = fs.Read(dataParaEnviar, 0, bytesPorDefecto);
byte[] dataProtocolo = SistemaServidor.DescargarPaqueteDeArchivo(dataParaEnviar);
client.Send(dataProtocolo);
Console.WriteLine("Descargando " + nombreArchivo + ". Paquete " + paqueteActual + " de " + cantPaquetesAMandar);
paqueteActual++;
}
fs.Close();
}
}
if (comando == "5")
{
string[] datosServidor = Encoding.UTF8.GetString(datos).TrimEnd().Replace("\0", string.Empty).Split('#');
string ipServidor = datosServidor[0];
string puertoServidor = datosServidor[1];
IPEndPoint clientEndPoint = new IPEndPoint(IPAddress.Parse(Ip), Puerto + 2);
IPEndPoint serverEndPoint = new IPEndPoint(IPAddress.Parse(ipServidor), Int32.Parse(puertoServidor));
Socket socketSinc = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socketSinc.Bind(clientEndPoint);
try
{
socketSinc.Connect(serverEndPoint);
bool loggedIn = false;
byte[] dataLog = SistemaCliente.ProcesarPedido("1", "servidor");
socketSinc.Send(dataLog);
byte[] loginRes = new byte[256];
int response = socketSinc.Receive(loginRes);
loggedIn = Boolean.Parse(SistemaCliente.ProcesarRespuesta(loginRes).Split('#')[1]);
if (!loggedIn)
{
Console.WriteLine("Nombre de cliente inválido!");
}
else
{
byte[] serverRequest = SistemaCliente.ProcesarPedido("2");
socketSinc.Send(serverRequest);
byte[] serverResponse = new byte[256];
int k = socketSinc.Receive(serverResponse);
string listaArchivos2 = SistemaCliente.ProcesarRespuesta(serverResponse);
/*listaArchivos2 = listaArchivos2.Replace("#", "\n");
* Console.WriteLine("Lista de archivos");
* Console.WriteLine(listaArchivos2);*/
string[] archivosServidor2 = listaArchivos2.TrimEnd().Replace("\0", string.Empty).Split('#');
byte[] listaArchivosByte = SistemaServidor.ListarArchivos();
string listaArchivos1 = SistemaCliente.ProcesarRespuesta(listaArchivosByte);
string[] archivosServidor1 = listaArchivos1.Split('#');
string[] archivosFaltan = new string[archivosServidor2.Length];
int h = 0;
foreach (string archivo in archivosServidor2)
{
if (!archivosServidor1.Contains(archivo))
{
archivosFaltan[h] = archivo;
h++;
}
}
foreach (string archivo in archivosFaltan)
{
if (archivo != null)
{
string nombreArchivo = archivo.Substring(37);
byte[] dataRequest = SistemaCliente.ProcesarPedido("4", nombreArchivo);
socketSinc.Send(dataRequest);
byte[] dataResponse = new byte[9999];
int z = socketSinc.Receive(dataResponse);
dataResponse = dataResponse.Take(z).ToArray();
int cantPaquetes = Int16.Parse(SistemaCliente.ProcesarRespuesta(dataResponse).Split('#')[1]);
int paqueteActual = 1;
if (cantPaquetes == 0)
{
Console.WriteLine("No es posible descargar el archivo indicado.");
}
else
{
FileStream fileStream = new FileStream(directorioServidor + "\\" + nombreArchivo, FileMode.Create, FileAccess.Write);
while (paqueteActual <= cantPaquetes)
{
byte[] requestPaquete = SistemaCliente.ProcesarPedido("8", paqueteActual.ToString());
socketSinc.Send(requestPaquete);
byte[] responsePaquete = new byte[9999];
int j = socketSinc.Receive(responsePaquete);
Console.WriteLine("Recibiendo " + nombreArchivo + ". Paquete " + paqueteActual + " de " + cantPaquetes);
int largoPaquete = SistemaCliente.darLargo(responsePaquete) - 9;
byte[] PaqueteArchivo = SistemaCliente.getDatos(responsePaquete);
if (paqueteActual == cantPaquetes)
{
PaqueteArchivo = PaqueteArchivo.Take(largoPaquete).ToArray();
}
SistemaCliente.GuardarPaqueteDeArchivo(fileStream, PaqueteArchivo, nombreArchivo);
paqueteActual++;
}
fileStream.Close();
}
}
}
byte[] respuestaSinc = SistemaServidor.NotificarSincronizacion();
client.Send(respuestaSinc);
}
}
catch (SocketException ex)
{
socketSinc.Shutdown(SocketShutdown.Both);
socketSinc.Close();
Console.WriteLine("El servidor cerró la conexión");
Console.ReadLine();
}
//respuestaServidor = SistemaServidor.SincronizarServidor(Encoding.UTF8.GetString(datos).TrimEnd().Replace("\0", string.Empty));
}
if (comando == "6")
{
DesconectarCliente(client);
connected = false;
}
/*if (comando == "8")
* {
* respuestaServidor = SistemaServidor.DescargarPaqueteDeArchivo(datos);
* }
* if (comando == "7")
* {
* respuestaServidor = SistemaServidor.SubirPaqueteDeArchivo(datos);
* }*/
//byte[] respuestaServidor = SistemaServidor.ProcesarPedido(data);
//aca separo segun el comando que haya llegado
//client.Send(respuestaServidor);
//Console.WriteLine(Encoding.UTF8.GetString(data).TrimEnd());
}
}
catch (SocketException ex)
{
Console.WriteLine("El cliente cerró la conexión");
connected = false;
}
}
client.Shutdown(SocketShutdown.Both);
client.Close();
}
public static int darLargo(byte[] data)
{
Protocolo.Protocolo prot = Protocolo.Protocolo.BytesAProtocolo(data);
return(prot.DarLargo());
}
public static byte[] getDatos(byte[] data)
{
Protocolo.Protocolo prot = Protocolo.Protocolo.BytesAProtocolo(data);
return(prot.darBytes());
}
public static string getComando(byte[] data)
{
Protocolo.Protocolo prot = Protocolo.Protocolo.BytesAProtocolo(data);
return(prot.darComando());
}
