Esempio n. 1
0
        }).Start();     //Se encarga de solicitar las partes de los archivos
        public void ManejadorSolicitudes() =>
        new Thread(() =>
        {
            while (PermitirEnviarSolicitudes)
            {
                PermitirEnviarSolicitud.Reset();

                if (ArchivoSolicitado.Hacer(null, "L", null) > 0)
                {
                    ArchivoSolicitado AS = ArchivoSolicitado.archivosSolicitados[0];
                    ArchivoSolicitado.Hacer(null, "DEL", 0);
                    AS.posicionLista = Archivo.PosicionArchivo(AS.MD5);

                    if (AS.posicionLista > -1)
                    {
                        STCP.EnviarSolicitud(AS);
                        PermitirEnviarSolicitud.WaitOne();
                        Thread.Sleep(100);
                    }
                }
                else
                {
                    Thread.Sleep(2000);
                }
            }
        }).Start();                                                                                 //Se encarga de enviar las partes solicitadas
Esempio n. 2
0
        //-----------------------------------------------------------------------------------------------------------
        //-----------------------------------------------------------------------------------------------------------Enviar
        public void EnviarSolicitud(ArchivoSolicitado AS)
        {
            IPEndPoint remoteEP = new IPEndPoint(AS.IPDestino, port);
            Socket     client   = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                connectDone.Reset();
                sendDone.Reset();

                client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
                connectDone.WaitOne();

                Controlador.PermitirEnviarSolicitud.Set();

                Send(client, frmCliente.archivosCompartidos[AS.posicionLista].Ruta, AS.MD5, AS.ParteArchivo);
                sendDone.WaitOne();

                client.Shutdown(SocketShutdown.Send);
                client.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine("StartClient Error: " + e.ToString());
            }
        }
Esempio n. 3
0
        public static int Hacer(object AS, string hacer, object dato)
        {
            lock (locker)
            {
                switch (hacer)
                {
                case "ADD":     //Añadir
                {
                    ArchivoSolicitado ASAUX = (ArchivoSolicitado)AS;
                    if (!archivosSolicitados.Exists(x => (Archivo.CompararMD5(x.MD5, ASAUX.MD5) && ASAUX.IDPosicion == x.IDPosicion && ASAUX.ParteArchivo == x.ParteArchivo)))
                    {
                        archivosSolicitados.Add(ASAUX);
                    }
                    break;
                }

                case "DEL":     //Eliminar
                {
                    archivosSolicitados.RemoveAt((int)dato);
                    break;
                }

                case "DELIP":     //Existe
                {
                    for (int i = 0; i < archivosSolicitados.Count; i++)
                    {
                        if (archivosSolicitados[i].IPDestino.Equals((IPAddress)dato))
                        {
                            archivosSolicitados.RemoveAt(i);
                            i = -1;
                        }
                    }
                    break;
                }

                case "L":
                {
                    return(archivosSolicitados.Count);
                }
                }
                return(1); //true
            }
        }
Esempio n. 4
0
        } //Prepara el archivoNecesitado

        public void agregarSolicitud(ArchivoSolicitado AS)
        {
            ArchivoSolicitado.Hacer(AS, "ADD", null);
        } //Agrega nuevas solicitudes de archivos a la lista
Esempio n. 5
0
        private void cbRecibir(IAsyncResult ar)
        {
            TodoHecho.Set();

            StateObject SO           = (StateObject)ar.AsyncState;
            Socket      s            = SO.socket;
            IPEndPoint  sender       = new IPEndPoint(IPAddress.Any, puerto);
            EndPoint    tempRemoteEP = sender;

            int       read       = s.EndReceiveFrom(ar, ref tempRemoteEP);
            IPAddress IPRecibida = IPAddress.Parse(tempRemoteEP.ToString().Split(':')[0]);

            if (!IPRecibida.Equals(Controlador.ObtenerIPLocal()))
            {
                byte[]   data       = new byte[1024];
                string[] stringData = Encoding.UTF8.GetString(SO.buffer, 0, read).Split('@');

                if (stringData[0] == "bitNode")
                {
                    //---
                    //    Console.WriteLine("RECIBI: -IP: " + IPRecibida + " -MSJ: " + Encoding.UTF8.GetString(SO.buffer, 0, read));
                    //---
                    bool primeraVez = controlador.AgregarIP(IPRecibida);

                    //--------------- Solicitar archivos a descargar
                    if (primeraVez)
                    {
                        controlador.EnviarArchivosNecesitados(IPRecibida);
                    }
                    bool sync = new Configuracion().Leer().SyncActiva;
                    //--------------------------------------
                    switch (stringData[1])
                    {
                    case "PPING":     // PrimerPing
                    {
                        string[] msj = stringData[2].Split('|');
                        if (msj[0] == "OK")
                        {
                            if (bool.Parse(msj[1]))         //true
                            {
                                EnviarMSJ_UDP(IPRecibida, "bitNode@ETACV@");
                            }
                            else if (!(Controlador.RecivirACV && primeraVez && sync))
                            {
                                EnviarMSJ_UDP(IPRecibida, "bitNode@PONG@");
                            }
                        }
                        else         //IPFIJA
                        {
                            controlador.EnviarListaIPS(IPRecibida);
                            if (bool.Parse(msj[1]))         //true
                            {
                                EnviarMSJ_UDP(IPRecibida, "bitNode@ETACV@");
                            }
                        }

                        if (Controlador.RecivirACV && primeraVez && sync)
                        {
                            EnviarMSJ_UDP(IPRecibida, "bitNode@PPING@OK|true");
                        }

                        break;
                    }

                    //------------------------------------------------------------------------------
                    case "PING":     //Estoy vivo?
                    {
                        EnviarMSJ_UDP(IPRecibida, "bitNode@PONG@");
                        break;
                    }

                    case "SOLICITAR":     //Hay una solicitud
                    {
                        Controlador.Solicitudes.Add(stringData[2]);
                        Controlador.InformarSolicitud();
                        break;
                    }

                    case "ETACV":     // EliminarTodosLosArchivosCompartidosVecinos
                    {
                        if (Controlador.RecivirACV)
                        {
                            controlador.EliminarArchivosCompartidosDeIP(IPRecibida);
                            controlador.EnviarUDP(IPRecibida, "bitNode@CEACV@");
                        }
                        break;
                    }

                    case "CEACV":     // ConfirmadoEliminoArchivosCompartidosVecinos
                    {
                        controlador.EnviarListaArchivosCompartidos(IPRecibida);
                        break;
                    }

                    case "SAD":     // Solicitar Archivo a Descargar
                    {
                        string[]          msj = stringData[2].Split('|');
                        ArchivoSolicitado AS  = new ArchivoSolicitado()
                        {
                            IPDestino = IPRecibida, MD5 = msj[0], ParteArchivo = Convert.ToInt32(msj[1])
                        };
                        controlador.agregarSolicitud(AS);
                        break;
                    }

                    case "IPV":     // Añadir IPVecinas
                    {
                        if (controlador.AgregarIP(IPAddress.Parse(stringData[2])))
                        {
                            EnviarMSJ_UDP(IPAddress.Parse(stringData[2]), "bitNode@PPING@OK|" + Controlador.RecivirACV);
                        }
                        break;
                    }

                    case "BYE":     // Se desconecto un bitNoder
                    {
                        controlador.EliminarIP(IPRecibida);
                        controlador.EliminarArchivosCompartidosDeIP(IPRecibida);
                        controlador.EliminarPeticiones(IPRecibida);
                        break;
                    }

                    case "SAC":     // SolicitarArchivosCompartidos
                    {
                        EnviarMSJ_UDP(IPRecibida, "bitNode@ETACV@");
                        break;
                    }

                    case "ASNULL":     // ArchivoSolicitado NULL - no existe
                    {
                        new frmMensaje(stringData[2] + " : " + Idioma.StringResources.msjASNULL).ShowDialog();
                        break;
                    }

                    case "AAC":     // AgregarArchivoCompartido
                    {
                        if (Controlador.RecivirACV && sync)
                        {
                            controlador.AgregarArchivoCompartido(JsonConvert.DeserializeObject <Archivo>(stringData[2]), IPRecibida);
                        }
                        break;
                    }

                    case "EAC":     // EliminarArchivoCompartido
                    {
                        if (Controlador.RecivirACV)
                        {
                            controlador.EliminarArchivosCompartidosDeMD5(stringData[2], IPRecibida);
                        }
                        break;
                    }

                    case "SACTAG":     //SolicitarArchivosCompartidos por TAG
                    {
                        controlador.EnviarListaArchivosCompartidosTAG(IPRecibida, stringData[2]);
                        break;
                    }

                    case "AACT":     // AgregarArchivoCompartido por TAGub
                    {
                        if (Controlador.RecivirACV && !sync)
                        {
                            controlador.AgregarArchivoCompartido(JsonConvert.DeserializeObject <Archivo>(stringData[2]), IPRecibida);
                        }
                        break;
                    }

                    case "TEA":     // TENES ESTE ARCHIVO
                    {
                        controlador.EnviarArchivosMD5(IPRecibida, stringData[2]);
                        break;
                    }

                    case "AAS":     // AgregarArchivoSolicitadoIP
                    {
                        controlador.AgregarIPArchivosNecesitados(IPRecibida, JsonConvert.DeserializeObject <Archivo>(stringData[2]).ArchivoMD5);
                        break;
                    }

                    case "EAS":     // EliminarArchivoSolicitado
                    {
                        ArchivoNecesitado.Hacer(null, "DELIP", IPRecibida);
                        break;
                    }
                    }
                }
            }
        }