Estás en: Inicio >> Foros >> Informática >> Programación
Programación /

[JAVA] Enviar archivos con Java - AYUDA

Participa en el tema [JAVA] Enviar archivos con Java - AYUDA en el foro Programación.
Hola a todos, estoy realizando un trabajo final en Java y necesito saber como enviar ...

Buscar en este tema:
 
  •  
    #1 [JAVA] Enviar archivos con Java - AYUDA
    Hola a todos, estoy realizando un trabajo final en Java y necesito saber como enviar y recibir archivos en Java utilizando (importando) java.net.

    El tema es el siguiente, necesito crear un cliente-servidor
    El cliente me tiene que dar la opcion de seleccionar un archivo y luego, enviar ese archivo a la IP/Socket del servidor.
    El servidor tiene que recibir el archivo, y me "tendria que permitir" ponerle un nombre y guardarlo en disco.

    Esa es la idea del trabajo, vi un par de ejemplos, pero me gustaria que alguien con mas experiencia me diera una mano.

    Saludos y mil gracias
    +
     
    0
    Me gusta
     
    | Más
  • #2 Re: Enviar archivos con Java - AYUDA

    La idea de un aplicativo cliente servidor en java es simple. En java tenes dos clases de socket, los socket comunes y los server sockets. Los server sockets son los que se quedan a la escuca en algun puerto y ante la llegada de un pedido de conexion te devuelven un socket ya conectado a la IP del cliente.

    Y los socket comunes son los que conocemos para enviar datos...

    Todos los sockets tienen como siempre streams tanto de entrada como de salida, mediante los metodos getOutputStream y getInputStream relativamente le podes pedir esos streams para tanto leer o escribir en ellos.

    Esos streams los podes wrappear en objetos ObjectInputStream y ObjectOutputStreams que en vez de trabajar vos a bajo nivel enviando leyendo datos en bytes directamente lees y escribis objetos mientras que ellos se encargan de serializarte los objetos que mandan.

    Por otro lado el servidor para que sea un servidor tiene que poder aceptar varias conexiones simultaneas y para eso necesitas si o si el uso de threads, es decir que por cada conexion entrante la maneje un thread aparte.

    Entonces para que nos quede maso menos claro una idea basica:

    El servidor va a implementar un thread que sea mas o menos de la siguiente forma:

    Código:
    public class ServerThread extends Thread {
    
    private Socket socket = null;
    private ObjectInputStream inputStream = null;
    private ObjectOutputStream outputStream = null;
    
    public ServerThread(Socket socket) {
    if (socket == null) 
    throw new IllegalArgumentException("Socket no puede ser null");
    
    this.socket = socket;
    
    //Aca creo que lanza IOException asi que verificar si hay que poner todo en un try...catch
    inputStream = new ObjectInputStream(socket.getInputStream());
    outputStream = new ObjectOutputStream(socket.getOutputStream());
    }
    
    public void run() {
    //Aca va el codigo que lee datos del socket y responde de acuerdo
    
    try {
    File file = (File) inputStream.readObject();
    
    //Aca procesamos el archivo o hacemos lo que necesitemos.
    } catch (IOException exception) {
    //Loggear que no se pudo leer del socket
    }
    }
    }
    
    
    //El servidor tendra un while true o while alguna condicion que haga algo asi
    
    ServerSocket serverSocket = new ServerSocket(PUERTO); //Crea un server socket que escucha en PUERTO
    
    while (condicionCorte) {
    Socket socket = 
    serverSocket.accept(); //Se queda esperando conecciones
    
    ServerThread thread = new ServerThread(socket); //Crea un thread que maneje la conexion remota
    
    thread.run(); //Pone a correr al thread
    
    }
    
    
    //Del lado del cliente solamente hacemos lo siguiente
    
    Socket socket = new Socket(url, PUERTO); //Le pasamos la url del servidor y el puerto
    ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
    ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
    
    File file = new File("archivo");
    
    try {
    
    outputStream.writeObject(file);
    outputStream.flush();
    outputStream.close();
    socket.close();
    } catch (IOException exception) {
    //Loguear que no se pudo enviar datos al servidor
    }
    
    Mas o menos la idea de una aplicacion cliente / servidor en java tiene esta pinta a muy grandes rasgos.... Habria que pulir mucho mas el tema de que pasa si cuando leo del stream del socket en el ServerThread es null, tengo que manejar esos casos o en casos de un protocolo que defina yo hay que manejar esa maquina de estados para saber que responder al cliente.

    Saludos
    Pablo
    Me gusta este mensaje
  • #3 Re: Enviar archivos con Java - AYUDA

    Mil gracias!!!! , me es de muchisima ayuda ExtrañoInocente!!!. Ahora viene el tema dificil, probando me funciona barbaro, envia el archivo y lo rebice, el tema esta en que lo tengo que hacer con Swing. La ventana del cliente me tiene que permitir seleccionar con jFileChooser el archivo a enviar, eso es relativamnete facil, no lo veo muy complicado, ahora, el drama esta del lado del servidor, cuando el archivo llega completamente, me tiene que permiter, en la ventana del servidor, tambien con jFileChooser, la posibilidad de ponerle el lugar en donde quiero guardar el archivo, y tambien el nombre.
    ¿Alguna idea con respecto a como hacer eso con el servidor? ¿como le digo al servidor que me levante el jFileChooser una ves que el archivo llego completamente?
    Les paso el codígo que mas o menos arme para el envio y recepcion de un archivo ( consola )
    Cliente
    import java.net.Socket;
    import java.io.InputStreamReader;
    public class Cliente {
    private String ip = "127.0.0.1";//O localhost o la que quieras 192.168.0.1 etc...
    private int puerto = 2002;
    private String nomArchivo = "temp.msi";
    public Cliente(){
    Socket socket = null;
    java.io.FileInputStream in = null;
    java.io.FileOutputStream pt = null;
    try {
    socket = new Socket(ip,puerto);
    pt = (java.io.FileOutputStream)socket.getOutputStream() ;//
    in = new java.io.FileInputStream(new java.io.File(nomArchivo));
    } catch(Exception e) {
    System.out.println("No se pudo crear la conexión\n"+e);
    }
    try {
    socket.sendUrgentData(100);
    byte[] buf = new byte[1024];
    int len;
    while ((len = in.read(buf)) > 0 ){
    pt.write(buf, 0, len);
    }
    pt.close();
    in.close();
    socket.close();
    } catch(Exception e) {
    System.out.println("Error al enviar mensaje\n"+e);
    }
    }
    public static void main(String a[]) {
    new Cliente();
    }
    }
    Servidor
    import java.net.ServerSocket;
    import java.net.Socket;
    public class Servidor implements Runnable {
    ServerSocket server;
    public Servidor() {
    try {
    //CREAMOS EL SOCKET DEL SERVIDOR
    server=new ServerSocket(2002);
    System.out.println("Servidor corriendo...");
    } catch(Exception e) {
    System.out.println("Error al correr el servidor\n"+e);
    System.exit(1);
    }
    }

    public void run() {
    Socket client=null;
    while (true) {
    if (server==null)
    return;
    try {
    //ESPERA A QUE LLEGUE UN CLIENTE
    client=server.accept();
    System.out.println("Llegó un cliente!");
    } catch(java.io.IOException e) {
    System.err.println("No se pudo establecer conexión " + e.getMessage());
    }
    try {
    //ABRIMOS UN BUFER PARA DESCARGAR LO QUE EL CLIENTE NOS ESTÁ ENVIANDO
    java.io.InputStream in = client.getInputStream();
    //CREAMOS LA INSTANCIA PARA ESCRIBIR EL ARCHIVO EN DISCO
    java.io.FileOutputStream out = new java.io.FileOutputStream(new java.io.File("C:\\llego.msi"));
    byte[] buf = new byte[1024]; // ¿QUE HACE ESTO?
    int len;
    while ((len = in.read(buf)) > 0) {
    out.write(buf, 0, len); // ¿Y ACA?
    }
    in.close();
    out.close();
    } catch(java.io.IOException e) {
    System.out.println("Error: " + e);
    }
    }
    }

    public static void main(String a[]) {
    Servidor servidor = new Servidor();
    // Ponemos a correr nuestro hilo servidor
    new Thread(servidor).start();
    }
    }
    El cliente es facil de entender..y me doy maña para como armarlo con interfaz grafica, el servidor tambien lo entiendo, exceptuando las marcas en rojo, en las cuales se crea un array de Bytes con una capacidad de 1024, ¿para que lo usa?

    Muchas gracias!!!

    perdon por no ponerlo tabulado , me equivoque ..
    Me gusta este mensaje
  • #4 Re: Enviar archivos con Java - AYUDA

    No entiendo lo que vos no entendes del codigo ese, la linea:
    Código:
                    byte[] buf = new byte[1024];
    

    Esta linea define un array de 1024 bytes, es decir 1Kb que se usa como buffer, un buffer sirve para almacenar pequeñas partes de datos a transferir para no cargar todo en memoria, se va haciendo por partes, entonces como el cliente le manda al servidor el archivo por partes iguales de 1Kb el servidor tiene que ir leyendo todo lo que le envia el cliente e ir almacenandolo en el archivo final.

    La linea de codigo:
    Código:
                        out.write(buf, 0, len);
    

    Esta linea toma el buffer recien leido del stream de entrada del socket y lo escribe en el stream de salida al archivo. es decir esta appendeando todo loq ue lee al archivo...

    Con respecto al tema de que el servidor te abra un JFileChooser para seleccionar donde vas a guardar el archivo tenes 2 posibilidades, la primera es: Que leas todo el archivo en memoria y una vez terminado de transferirse y lo tengas en memoria abras un JFileChooser (Obviamente el servidor seria una venana ademas de tener un thread adentro con el manejo interno de los sockets) y una vez que seleccione el archivo el usuario vuelques el contenido de la memoria al archivo....

    Oooo tenes como posibilidad la siguiente: Definis un protocolo que sea asi... El cliente le envia un mensaje "ENVIAR-ARCHIVO" al servidor el servidor procesa este mensaje y como respuesta le abre un JFileChooser al usuario para seleccionar el nombre del archivo a guardar... y le envia al cliente el mensaje "RECIBI-RESPUESTA", ante este mensaje el cliente comienza a transferirle el archivo...
    El cliente como final cuando termina de enviar todo el archivo le envia un mensaje al servidor "FIN-ENVIO-ARCHIVO", el servidor lo procesa y sabe que ahi tiene que cortar la transferencia porque ya finalizo... luego le responde al cliente con el mensaje "RECIBI-RESPUESTA"

    La ventaja que tenes aca es que estas usando buffers y no tenes todo el contenido del archivo en memoria hasta que el ususario selecciona el nombre donde guardarlo...

    Otra alternativa es usar lo que estas haciendo ahora, guardando todo en un archivo temporal, y al finalizar le abris un JFileChooser, el usuario selecciona el archivo a gaurdar y solo renombras el temporal.

    Saludos
    Pablo
    Me gusta este mensaje
  • #5 Re: Enviar archivos con Java - AYUDA

    mil gracias!!!!
    Me gusta este mensaje
  • #6 Re: Enviar archivos con Java - AYUDA

    No se ni de que se trata el tema pero bueno, no sabia comunicarme con ustedes por favor comunicquenme porq no entiendo nada, porfi porfi besos dahiana
    Me gusta este mensaje
  • #7 Re: Enviar archivos con Java - AYUDA

    No entiendo Dahiana a que te referis..... podias ser un poco mas especifica???

    Saludos
    Pablo
    Me gusta este mensaje
  • #8 Re: Enviar archivos con Java - AYUDA

    Yo tengo algo que te puede ayudar.

    Cuando envias un archivo, el cliente primero envia el nombre del archivo y el usuario que lo manda, el servidor te muestra esta informacion y te pide una confirmación para aceptar el archuivo, es algo sencillo, espero que te sirva:

    Código PHP:
    import java.io.*;
    import java.net.Socket;
    import java.io.InputStreamReader;
    import javax.swing.*;
    public class 
    ClienteDeArchivos{
    private 
    String ip="192.168.0.1"//O localhost o la que quieras p.ej.192.168.0.1, etc debe ser la ip del servidor
    private int puerto 2002;
    private 
    String nomArchivo="";
    private 
    boolean ArchivoEncontradotrue;

    private 
    ClienteDeArchivos(String RutaArchivoString IP){
    nomArchivo RutaArchivo;
    ip=IP;
    Socket socket null;
    java.io.FileInputStream in null;
    java.io.FileOutputStream pt null;

    try{
    socket = new Socket(ippuerto);
    pt = (java.io.FileOutputStream)socket.getOutputStream();
    in = new java.io.FileInputStream(new java.io.File(nomArchivo));
    }catch(
    Exception e){
    JOptionPane.showMessageDialog(null,"No se pudo crear la conexion\no no existe el archivo\nO posiblemente la direccion IP que proporcionaste\nNo existe en la red\n\nMensaje del sistema:\n"+e,"ERROR!",JOptionPane.ERROR_MESSAGE);
    System.out.println("No se pudo crear la conexion\n"+e);
    ArchivoEncontrado false;
    }
    if(
    ArchivoEncontrado){
    try{
    socket.sendUrgentData(100);
    byte buf[] = new byte[1024];
    int len;
    while((
    len in.read(buf)) > 0){
    pt.write(buf0len);
    }
    pt.close();
    in.close();
    socket.close();
    }catch(
    Exception e){
    JOptionPane.showMessageDialog(null,"Error al enviar mensaje\n"+e,"ERROR",JOptionPane.ERROR_MESSAGE);
    }
    }
    }
    public static 
    void main(String args[]){
    String RutaArchivo "";
    boolean Envio=false;
    String NombreDelUsuario "CesPower";
    do{
    RutaArchivo String.valueOf(JOptionPane.showInputDialog("Da la ruta del archivo: "));
    if(
    RutaArchivo.equals("") || RutaArchivo.equals("null")){
    if(
    RutaArchivo.equals(""))
    JOptionPane.showMessageDialog(null,"La ruta no es valida","ERROR!",JOptionPane.ERROR_MESSAGE);
    else
    break;
    }
    else{
    File Nombre = new File(RutaArchivo);
    if(
    Nombre.exists()){
    if(
    Nombre.isDirectory())
    JOptionPane.showMessageDialog(null,"Solo diste el directorio","ERROR!",JOptionPane.ERROR_MESSAGE);
    else{
    String IP "";
    do{
    IP String.valueOf(JOptionPane.showInputDialog("Da la direccion IP destino: "));
    if(
    IP.equals("") || IP.equals("\t") || IP.equals("\n"))
    JOptionPane.showMessageDialog(null,"No has dado una direccion","ERROR!",JOptionPane.ERROR_MESSAGE);
    }while(
    IP.equals("") || IP.equals("\t") || IP.equals("\n"));
    JOptionPane.showMessageDialog(null,"Nombre Del Archivo: " Nombre.getName(),"sss",JOptionPane.INFORMATION_MESSAGE)
    ;
    /*****************************************************************************************/
    //EN ESTA PARTE ES EN DONDE SE ENVIA EL NOMBRE DEL ARCHIVO Y EL MISMO
    /*****************************************************************************************/
    new EnviarNombreDelArchivo(Nombre.getName(), IPNombreDelUsuario);
    new 
    ClienteDeArchivos(RutaArchivoIP);
    Envio=true;

    }
    }
    else
    JOptionPane.showMessageDialog(null,"El fichero no existe","ERROR!",JOptionPane.ERROR_MESSAGE);
    }
    }while(!
    Envio);
    }
    }
    class 
    EnviarNombreDelArchivo{
    private 
    String HOST = new String(""); //IP destino
    static final int PUERTO=5001;
    private 
    String mens = new String(); //nombre del archivo a enviar
    public EnviarNombreDelArchivo(String NombreDelArchivoString ipHostString NombreDelUsuario){
    HOST ipHost;
    mens NombreDelArchivo;
    try{
    Socket skCliente = new SocketHOST PUERTO );
    OutputStream aux2 skCliente.getOutputStream();
    DataOutputStream flujo2= new DataOutputStreamaux2 );
    System.out.println("Mensaje: " mens);
    flujo2.writeUTFmens ); //=> Enviar archivo
    ObjectOutputStream bufferObjetos = new ObjectOutputStream (skCliente.getOutputStream());
    bufferObjetos.writeObject(mens); //=> Enviar el Nombre del Archivo

    ObjectOutputStream bufferObjetos2 = new ObjectOutputStream (skCliente.getOutputStream());
    bufferObjetos2.writeObject(NombreDelUsuario); //=> Enviar el Nombre del Usuario
    skCliente.close();
    }catch( 
    Exception e ) {
    JOptionPane.showMessageDialog(null,"Ha ocurrido un error\nPosiblemente la direccion IP que proporcionaste\nNo existe en la red\n"+e.getMessage(),"ERROR",JOptionPane.ERROR_MESSAGE);
    System.exit(0);
    }
    }
    }
     
    /////////SERVIDOR
    import java.io.*;
    import java.net.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    class 
    ClaseNombreDelUsuario{
    String NombreUsuario "";
    }
    public class 
    ServidorDeArchivos implements Runnable {
    ServerSocket server;
    static 
    String NombreDelArchivo = new String();
    String DirectorioDestino = new String();

    public 
    ServidorDeArchivos() {
    try {
    //CREAMOS EL SOCKET DEL SERVIDOR
    server=new ServerSocket(2002);
    System.out.println("Servidor corriendo...");
    } catch(
    Exception e) {
    System.out.println("Error al correr el servidor\n"+e);
    System.exit(1);
    }
    }

    public 
    void run() {
    Socket client=null;
    File Ruta null;
    while (
    true) {
    ClaseNombreDelUsuario ObNom = new ClaseNombreDelUsuario();
    ServidorDeNombres servDeNombs = new ServidorDeNombres();
    NombreDelArchivo servDeNombs.Servidor2Nom(ObNom);
    System.out.println("Nombre del Archivo que te quieren enviar: " NombreDelArchivo);
    VentanaConfirmaArchivo Confirmacion = new VentanaConfirmaArchivo();

    /*************************************************************************************/
    //AQUI VA A IR LA CONFIRMACION DE ACEPTACION DEL ARCHIVO
    /*************************************************************************************/
    if(Confirmacion.VentanaConfirmaArchivo1(NombreDelArchivoObNom.NombreUsuario)){
    do{
    DirectorioDestino String.valueOf(JOptionPane.showInputDialog("Da el directorio en el cual se guardara el archivo: "));
    if(
    DirectorioDestino.equals(" ") || DirectorioDestino.equals("null") || DirectorioDestino.equals("\n") || DirectorioDestino.equals("\t")){
    if(
    DirectorioDestino.equals(""))
    JOptionPane.showMessageDialog(null,"La ruta no es valida","ERROR!",JOptionPane.ERROR_MESSAGE);
    }
    else{
    Ruta = new File(DirectorioDestino);
    if(
    Ruta.exists()){
    if(!
    Ruta.isDirectory())
    JOptionPane.showMessageDialog(null,"La ruta no es valida","ERROR!",JOptionPane.ERROR_MESSAGE);
    else
    break;
    }
    else
    continue;
    }
    }while(
    true);

    JOptionPane.showMessageDialog(null,"Ruta:"+DirectorioDestino "\nVar File: " Ruta,"XXX",JOptionPane.INFORMATION_MESSAGE);

    if (
    server==null)
    return;
    try {
    //ESPERA A QUE LLEGUE UN CLIENTE
    client=server.accept();
    System.out.println("Llego un cliente!");
    } catch(
    java.io.IOException e) {
    System.err.println("No se pudo establecer conexion " e.getMessage());
    }


    try {
    //ABRIMOS UN BUFER PARA DESCARGAR LO QUE EL CLIENTE NOS ESTA ENVIANDO
    java.io.InputStream in client.getInputStream();
    //CREAMOS LA INSTANCIA PARA ESCRIBIR EL ARCHIVO EN DISCO
    String Nombre String.valueOf(in);
    //java.io.FileOutputStream out = new java.io.FileOutputStream(new java.io.File(NombreDelArchivo));
    java.io.FileOutputStream out = new java.io.FileOutputStream(new java.io.File(Ruta+"/"+NombreDelArchivo));
    byte[] buf = new byte[1024];
    int len;
    while ((
    len in.read(buf)) > 0) {
    out.write(buf0len);
    }
    in.close();
    out.close();
    } catch(
    java.io.IOException e) {
    System.out.println("Error: " e);
    }
    }
    else
    JOptionPane.showMessageDialog(null,"Rechazaste el archivo","Cancelacion",JOptionPane.INFORMATION_MESSAGE);
    }
    }

    public static 
    void main(String a[]) {
    ServidorDeArchivos servArchs = new ServidorDeArchivos();
    // Ponemos a correr nuestro hilo servidor
    new Thread(servArchs).start();
    }
    }
    class 
    ServidorDeNombres 
    static final 
    int PUERTO=5001;
    static 
    String mens=new String(""); 
    static 
    String salir=new String("");
    public 
    String Servidor2Nom(ClaseNombreDelUsuario obNomb) {
    try {
    ServerSocket skServidor = new ServerSocketPUERTO );
    System.out.println("Escucho el puerto " PUERTO );

    Socket skCliente skServidor.accept();
    InputStream aux skCliente.getInputStream();
    DataInputStream flujo = new DataInputStreamaux );

    System.out.println("Nombre enviado: " flujo.readUTF());

    ObjectInputStream bufferObjetos = new ObjectInputStream (skCliente.getInputStream());
    String Temp String.valueOf(bufferObjetos.readObject());
    mens String.valueOf(Temp.toString());
    System.out.println("Nombre obtenido: " mens);

    ObjectInputStream bufferObjetos2 = new ObjectInputStream (skCliente.getInputStream());
    obNomb.NombreUsuario String.valueOf(bufferObjetos2.readObject());
    System.out.println("Nombre del Usuario: " obNomb.NombreUsuario);

    skCliente.close();
    skServidor.close();
    } catch( 
    Exception e ) {
    System.out.printlne.getMessage() );
    }
    return(
    mens);
    }
    }
    class 
    VentanaConfirmaArchivo extends JFrame{
    private 
    JButton BotonSiBotonNo;
    private 
    JLabel EtiPregunta,EtiPregunta2;
    private 
    Container Contenedor;
    private 
    BorderLayout esquema;
    private 
    JPanel panelBotones;
    boolean Respuesta trueterminaCiclo=false;

    boolean VentanaConfirmaArchivo1(String NombreAString NombreU){
    esquema = new BorderLayout(5,5);
    Contenedor getContentPane();
    Contenedor.setLayout(esquema);
    panelBotones = new JPanel();
    panelBotones.setLayout(new GridLayout(13));

    EtiPregunta = new JLabel("El usuario: " NombreU);
    EtiPregunta2 = new JLabel("te envia el archivo: "+NombreA+", Lo aceptas?");
    BotonSi = new JButton("Si");
    BotonNo = new JButton("No");

    Contenedor.add(EtiPreguntaBorderLayout.NORTH);
    Contenedor.add(EtiPregunta2BorderLayout.CENTER);
    panelBotones.add(BotonSi);
    panelBotones.add(BotonNo);
    Contenedor.add(panelBotonesBorderLayout.SOUTH);

    setSize(310,120);
    setVisible(true);

    while(!
    terminaCiclo){
    BotonSi.addActionListener(
    new 
    ActionListener(){
    public 
    void actionPerformed(ActionEvent evento){
    Respuesta true;
    setVisible(false);
    terminaCiclo=true;
    }
    }
    );

    BotonNo.addActionListener(
    new 
    ActionListener(){
    public 
    void actionPerformed(ActionEvent evento){
    Respuesta false;
    setVisible(false);
    terminaCiclo=true;
    }
    }
    );
    }

    return (
    Respuesta);
    }

    Me gusta este mensaje
  • #9 programa simple en java

    hola extrAñoinocente: mira tengu un problemita con java el tema parece muy simple pero no me sale
    la consigna es la siguiente crear un programa en java que ingrese cadenas en mayusculas o minusculas convieta esos strings en minusculas y luego muestre ordenadamente en columnos cada string pero con la primera letra en mayuscula solo la primera
    yo llego bien hasta separar el caracter y pasarlo a mayuscula pero me quedo alli no lo puedo agregar


    saludos y gracias
    Me gusta este mensaje
  • #10 Re: Enviar archivos con Java - AYUDA

    una pregunta, haber si alguien me responde todavia, la pregunta es si al darle la direccion en donde se va a alojar el archivo, ya existe uno, lo reemplaza???.
    Me gusta este mensaje
Estás en: Inicio >> Foros >> Informática >> Programación


Estadísticas del tema
  • 9 RESPUESTAS
  • 26958 VISTAS
  • 6 USUARIOS RESPONDIERON
 
Ir arriba
Contacto | Acerca de | Ayuda | Términos Legales | privacidad | Pautas de convivencia | Mapa de los foros | TrabajÁ con nosotros
©2008 Psicofxp.com S.A. - Todos los derechos reservados
Certifica IAB