EL PROTOCOLO DE TRANSFERENCIA DE ARCHIVOS (FTP).

Marcelo Abimael Flores Tapia

Universidad Autónoma Metropolitana

Unidad Iztapalapa

CBI

Licenciatura en Computación

Asesor: René Mac Kinney Romero

México, D.F.

OBJETIVO DEL PROYECTO

El objetivo principal al desarrollar este programa (cliente ftp) fue comprender como se lleva a cabo el

establecimiento de una sesión FTP no nada más a nivel externo sino comprender en un cierto sentido como se

efectúa la creación de las conexiones de control y datos por medio de los sockets y a su vez revisar como se

realiza la transmisión de los datos por medio de la conexión de datos creada a través de un socket.

Se implemento en el lenguaje de programación C ya que este permite realizar un manejo de los

sockets haciendo uso de algunas librerías definidas dentro del lenguaje con lo que permite una mayor

facilidad al efectuar la codificación del programa deseado.

Además se eligió este protocolo (FTP) porque se tienen muy pocas aplicaciones que hacen uso del

mismo y es poco comercial ya que el Internet permite llevar a cabo muchas tareas sin la necesidad de andar

manejando protocolos que no son conocidos por parte de los usuarios.

Indice

1. INTRODUCCIÓN.

2. ACERCA DEL PROTOCOLO.

3. COMANDOS DE FTP.

4. CONTROL Y CONEXIONES DE DATOS.

5. MANEJO DE CONEXIONES.

6. FTP ANÓNIMO.

7. EJEMPLO DE CONEXIÓN FTP

1. INTRODUCCIÓN.

Podemos comenzar por hacer mención de que un archivo es una abstracción fundamental para el almacenamiento de la información. Cuando las redes aparecieron se hizo necesario el transferir información de una computadora a otra para poder llevar a cabo la comunicación entre dos usuarios que desean compartirla por medio de este protocolo, otro caso puede ser si se desea obtenerla de un servidor remoto o colocarla dentro de un servidor. La transferencia de información es complicada porque se debe tomar en cuenta que existen diferencias entre los distintos sistemas informáticos, entre las cuales se pueden mencionar las siguientes: los nombres, las extensiones, las propiedades, etc.

Aunque actualmente se han establecido muchos protocolos para llevar a cabo la transferencia entre archivos que son fáciles de usar se considera a FTP como uno de los más usados para realizar dicha operación. FTP en un principio se desarrolló como una utilidad Unix para transferir archivos, así FTP es un acrónimo de protocolo de transferencia de archivos. Debido a que muchos sistemas Unix estaban en Internet, FTP era usado por muchos usuarios para transferir archivos a través de la red. La primera propuesta sobre mecanismos para el envío y recepción de archivos data de 1971 y fue desarrollada para su implementación en los sistemas del M.I.T. (Instituto Tecnológico de Massachussets) hasta que en Julio de 1973 se produjeron considerables cambios en las nuevas versiones de FTP.

En realidad FTP es más que una utilidad de transferencia de archivos, es también un estándar que establece como deben ser transferidos los archivos. FTP trabaja sobre el concepto de relación cliente/servidor, en Internet, muchos servidores FTP son utilizados como almacenes de archivos, ya que se puede acceder a los mismos siempre que se disponga de un programa FTP cliente.

Se trata una aplicación que permite realizar la transferencia de archivos entre computadoras, ya que hace posible que un usuario copie en una computadora los archivos que están almacenados en otra o en un servidor. Los programas y protocolos diseñados para llevar a cabo esta función se conocen con el nombre de FTP. Los archivos a transferir pueden ser documentos, textos, imágenes, sonidos, programas, etc. El procedimiento mediante el cual se accede a una computadora o servidor para copiar archivos en forma libre y sin restricciones se conoce como FTP anónimo y en este caso por tanto no se necesita de un password (contraseña) para entrar en el servidor remoto o computadora. La aplicación FTP funciona de forma muy similar en todos los sistemas, los distintos comandos que pueden ejecutarse tienen en su mayoría el mismo formato.

Aunque FTP es el protocolo más conocido y utilizado para la transferencia de archivos en Internet, también existen otros protocolos similares como:

- Protocolo Trivial de Transferencia de Archivos (TFTP) :

Este protocolo omite intencionadamente gran parte de las capacidades de FTP y se centra minuciosamente en las operaciones de leer y escribir un archivo, para la ejecución de las cuales utiliza UDP (Protocolo de Datagrama de usuario). A diferencia de FTP no utiliza directorios ni autoriza usuarios. Utiliza un sistema de confirmaciones para asegurar la entrega de datos entre el servidor y el cliente. Es una aplicación muy facil de implementar y que ocupa muy poco espacio, por lo cual se propuso utilizarlo para transferir bootstrap loaders (programas de arranque).

- Protocolo Simple de Transferencia de Archivos (SFTP) :

Es un intento por encontrar un punto intermedio entre FTP y TFTP. Soporta el control de acceso para los usuarios, transferencia de archivos, listas de directorios, cambio de directorios, renombramiento y borrado de archivos. Utiliza el protocolo TCP pero con una sola conexión.

Los objetivos de FTP son los siguientes:

• Promover el uso de archivos compartidos (programas de computadora y/o datos). • Proteger a un usuario de posibles variaciones en el almacenamiento de archivos a través de un host

(servidor raíz): Los archivos que se encuentran dentro de la computadora del usuario pueden no coincidir con los existentes dentro del servidor o viceversa por lo que se pueden hacer actualizaciones en ambos sentidos buscando con esto una sincronización de los archivos en ambos lados de la comunicación (cliente-servidor).

• Contenido arbitrario del archivo: El FTP transfiere los datos arbitrarios como son texto y archivos binarios.

• Autentificación y propiedad: El FTP permite que los archivos tengan restricciones de propiedad y de acceso.

• Acomoda heterogeneidad: El FTP oculta los detalles de los sistemas informáticos individuales.

Sistema de archivos

Servidor PI

Servidor DTP

Usuario PI

UsuarioDTP

Interfaz Usuario

Usuario

Sistema de archivos

SERVIDOR FTP USUARIO FTP

Conexión

Respuesta FTP

2. ACERCA DEL PROTOCOLO.

2.1 EL MODELO FTP.

En la figura 1 se muestra un diagrama de bloques que ilustra como trabaja el protocolo FTP, con lo que se puede tener una mejor idea sobre el funcionamiento del mismo

Comando FTP

Datos

Figura 1: Diagrama a bloques del sistema FTP

NOTACIÓN:

- Servidor /Usuario PI: Es el intérprete del protocolo que se encarga de llevar a cabo la traducción de las peticiones del usuario al servidor y viceversa (se hace por medio de los comandos de parte del servidor y de las respuestas a los mismos por parte del servidor).

- Servidor/Usuario DTP: Es el proceso que se encarga de la transferencia de datos entre ambos lados de la comunicación establecida mediante en PI, se comunican con los sistemas de archivos para llevar a cabo dicha operación.

En el modelo anterior se puede notar que el usuario del protocolo es el que comienza la conexión para después a través del intérprete de protocolo generar los comandos estándar y transmitirlos al proceso servidor, el cual a su vez transmite al proceso usuario las respuestas respectivas a los comandos recibidos.

Los comandos FTP especifican los parámetros para la conexión de datos (puerto, modo de transferencia, tipo de representación y estructura) y las operaciones del sistema de archivos (almacenar, borrar, recuperar, etc.) Después el proceso de transferencia de datos que está en el usuario comienza a escuchar por el puerto definido para que el servidor inicie la conexión y transferencia de archivos.

2.2 CONFIGURACION Y DISEÑO.

FTP emplea dos conexiones TCP para ejecutar las transferencias de archivos, identificando una como conexión de control y otra como conexión de datos. La conexión de control es una configuración cliente/servidor común. El servidor FTP hace una apertura pasiva en el puerto de protocolo 21 y espera las conexiones del cliente. A su vez el cliente contacta al servidor FTP y los programas negocian una conexión TCP, permaneciendo la conexión de control activa durante toda la transacción FTP.

FTP crea una conexión de datos independiente para cada transferencia de archivos. El tipo de servicio IP para la conexión de datos es maximizar la productividad ya que se trata de transferencia de

archivos completos. El usuario normalmente no tiene que tratar directamente con las órdenes y respuestas que fluyen a través de la conexión de control. De estos detalles se encarga el intérprete del protocolo. El interfaz de usuario representa cualquier tipo de interfaz que utilice el usuario para la transferencia. Las acciones del usuario son traducidas a órdenes FTP que se envían a través de la conexión de control. Así mismo las respuestas que devuelve el servidor por la conexión de control pueden convertirse en cualquier formato para ser presentadas en la interfaz de usuario.

Los dos Intérpretes de protocolo son los encargados de invocar a las funciones de transferencia de datos cuando sea necesario. En el núcleo de la operación están los intérpretes de protocolos (PI) y los procesos de transferencia de datos (DTP). Cliente y Servidor tienen cada uno su propio intérprete de protocolos y su propio proceso de transferencia de datos. Los procesos de transferencia de datos establecen y manejan la conexión de datos. Los interpretes de protocolo interpretan los comandos FTP y se comunican a través de la conexión de control, que el PI cliente establece al principio de la sesión.

2.3 MANEJO DE LA INFORMACIÓN.

FTP requiere que los usuarios seleccionen de una gran variedad de opciones para las operaciones de transferencia de archivos. Las opciones de FTP se clasifican en 4 categorías: tipos de archivos, formatos de archivos, estructuras de archivos y modos de transmisión.

2.3.1 TIPOS DE ARCHIVO.

Puede utilizar cuatro tipos de archivos: local, binario, EBCDIC y ASCII.

1. Local: Permite la transferencia de archivos entre anfitriones que utilizan diferentes tamaños de bytes.

2. Binario: También llamado imagen, trata la información del archivo como un flujo de datos contiguo. Por lo general, la mayoría de usuarios de FTP transfieren los archivos como archivos imagen.

3. EBCDIC: Es un método alterno para la transferencia de archivos de texto entre dos computadoras como los mainframes de IBM y mini computadoras que emplean la codificación EBCDIC (Código para intercambio decimal en codificación binaria extendida). Este tipo se puede utilizar si los sistemas remotos en cada lado de la conexión utilizan EBCDIC, para simplificar la transmisión de archivos basados en texto.

4. ASCII: Son las transferencias preestablecidas en FTP. Para utilizar este tipo de transferencia, el sistema remoto transmisor debe convertir el archivo de texto local a NVT ASCII (ASCII de 7 bits), y el receptor debe traducirlo a texto local. El fin de línea se transfiere utilizando los caracteres (en NVT ASCII) retorno de carro seguido de fin de línea. Lo cual implica que el receptor debe rastrear todos los bytes que le llegan buscando la pareja CR, LF.

2.3.2 FORMATOS DE ARCHIVO FTP.

Un usuario también debe de especificar un control de formato. FTP define tres tipos de controles de formato:

- De no impresión

- Control de formato Telnet.

- Control de carro FORTRAN.

Para los archivos de texto, el control predeterminado es el de no impresión.

2.3.3 MODOS DE TRANSMISIÓN.

Otra de las características que el usuario debe especificar es el modo de transmisión. FTP define 3 modos de transmisión: de bloque, comprimido y de flujo.

1. De Bloque : Transfiere un archivo como una serie de bloques, cada uno de los cuales con uno o más bytes de encabezado, que especifican el tamaño del bloque enviado, así como los códigos descriptores, que identifican el fin del archivo.

2. Comprimido: Un algoritmo sencillo de codificación de longitud de ejecución comprime ocurrencias consecutivas del mismo byte, utilizando un símbolo especial seguido por un conteo. Aunque en general la mayoría de los usuarios utilizan algoritmos de compresión, los cuales tienen un mejor funcionamiento.

3. De Flujo (stream mode): Se transfiere un archivo como un flujo de bytes de datos. Si el tipo de estructura que se transmite es un registro, FTP utiliza una secuencia especial de caracteres de dos bytes para marcar el fin de un registro y el fin de un archivo. Mientras que cuando es un archivo, señala su fin al cerrar la conexión de datos TCP.

2.3.4 ESTRUCTURA DE ARCHIVO.

FTP define tres tipos de estructuras: archivo, registro y página. Se utiliza el comando STRU para especificar qué estructura se va a utilizar para las operaciones de transferencia de archivos.

STRU Descripción

F Archivo

R Registro

P Página

3. COMANDOS DEL FTP.

3.1 DEFINICIÓN DE LOS COMANDOS DE FTP.

El FTP tiene comandos que permiten a los usuarios conectarse con una computadora remota y proporcionan la autentificación. Aunque la mayoría se utilizan originalmente para el sistema UNIX se pueden emplear actualmente bajo cualquier otra plataforma. En la figura 2 se listan los nombres más comunes de los comandos.

Figura 2: Comandos del FTP

Algunos de los anteriores se ponen en ejecución raramente, algunos son irrelevantes y algunos son alias (ejem: el dir y el ls ambos solicitan un listado del directorio).

FTP incluye más de 30 comandos que se pueden emplear para manejar las operaciones de transferencia de archivos.

Los comandos FTP se clasifican en:

DE CONEXIÓN Y AUTORIZACIÓN :

COMANDO DESCRIPCIÓN

ABORT Aborta la orden FTP previa y la transferencia de datos asociada.

PASS Contraseña Palabra clave para el servidor

QUIT Desconexión

USER NombreUsuario

Identifica al usuario en el servidor.

GESTION DE ARCHIVOS Y DIRECTORIOS :

COMANDO DESCRIPCIÓN

CDUP Cambia al directorio padre en el servidor.

DELE NombreArchivo

Borra un archivo.

LIST ListaArchivos

Lista Información de archivos y directorios.

MKD NombreDirectorio

Crea un directorio

NLST NombreDirectorio

Lista de archivos o directorios

PWD Muestra el nombre del directorio actual.

NFR NombreArchivo

Identifica un archivo para cambiarlo de nombre.

RNTO NombreArchivo

Cambia de nombre un archivo.

TRANSFERENCIA DE ARCHIVOS :

COMANDO DESCRIPCIÓN

PASV Pide al servidor que identifique una dirección IP y un puerto para que el cliente inicie una conexión de datos.

PORT n1,n2,n3,n4,n5,n6

Dirección IP del cliente (n1.n2.n3.n4) y puerto (n5 x 256+n6)

REST marcador, orden

Identifica a un restart marker (marcador de reinicio), seguido de la orden de transferencia que hay que reiniciar.

RETR NombreArchivo

Obtiene un archivo desde el servidor.

STOR NombreArchivo

Almacena un archivo en el servidor

STOU NombreArchivo

Almacena un archivo en el servidor con nombre único.

TYPE tipo Se especifica el tipo de sistema: A para ASCII, I para imagen

OTROS COMANDOS :

COMANDO DESCRIPCION

NOV No operación: pide al servidor que responda OK.

STAT Solicita información sobre los parámetros y estado de la conexión.

SIST El servidor informa sobre el tipo de sistema.

En algunos casos existe una correspondencia uno a uno entre lo que teclea un cliente interactivo y las órdenes FTP que se envían a través de la conexión de control. En otras ocasiones, un único comando del cliente genera múltiples comandos FTP.

3.2 CÓDIGOS DE RESPUESTA FTP.

El protocolo FTP, usa un esquema de códigos de respuesta donde cada uno de sus dígitos tiene un significado especial. Son números de tres dígitos en ASCII, con un mensaje opcional siguiendo al número. El software sólo necesita leer el número para determinar la respuesta del servidor. Cada uno de los códigos tiene un significado diferente:

CÓDIGO DESCRIPCIÓN

1yz Respuesta preliminar positiva, el servidor inició la acción solicitada.

2yz Respuesta de terminación positiva, el servidor terminó con éxito la acción solicitada.

3yz Respuesta intermedia positiva, el servidor aceptó el comando pero la acción solicitada necesita más información.

4yz Respuesta de terminación negativa transitoria, el servidor no aceptó el comando, y la acción solicitada no ocurrió.

5yz Respuesta de terminación negativa permanente, el servidor no aceptó el comando y la acción solicitada no ocurrió.

Para el segundo dígito:

CÓDIGO DESCRIPCIÓN

X0z Se refiere a errores de sintaxis.

X1z Se refieren a solicitudes de información, como estado o ayuda.

X2z Se refieren a las conexiones de control o de datos.

X3z Para el proceso de inicio de sesión y procedimientos contables.

X4z Aun no se ha especificado.

X5z Indican el estado del sistema de archivos del servidor frente a la transferencia solicitada u otra acción.

CÓDIGOS DE RESPUESTA FTP.

CÓDIGO DESCRIPCIÓN

110 Reiniciar respuesta del marcador

120 Servicio listo en n minutos

125 Conexión de datos abierta. Inicio de la transferencia.

150 Buen estado del archivo.

200 Comando correcto.

202 Comando no implementado.

211 Estado del sistema.

212 Estado del directorio.

213 Estado del Archivo.

214 Mensaje de ayuda.

215 Tipo de sistema NAME

220 Servicio listo para nuevo usuario.

221 Servicio cierra la conexión de control.

225 Conexión de datos abierta. No hay transferencia en curso.

226 Cierra la conexión de datos. Acción de archivo solicitada terminada con éxito.

227 Entra al modo pasivo.

230 Usuario inició la sesión.

250 Acción de archivo solicitada, correcta.

257 "PATHNAME" creado

331 Nombre de usuario correcto. Se pide contraseña

332 Se necesita cuenta para iniciar sesión.

350 Acción de archivo solicitada pendiente en espera de más información.

421 Servicio no disponible, se cierra conexión de control.

425 No se puede abrir la conexión de datos.

426 Conexión cerrada, transferencia abortada.

450 Acción de archivo solicitada no se tomó. Archivo no disponible.

451 Abortada acción solicitada: Error local en el procesamiento.

452 Acción solicitada no se tomó. Espacio de almacenamiento en sistema insuficiente.

500 Error de sintaxis, comando no reconocido.

501 Error de sintaxis en parámetros o argumentos.

502 Comando no implementado.

503 Secuencia de comandos errónea.

504 Comando no implementado para ese parámetro.

530 No se inició sesión.

532 Necesita cuenta para almacenar archivos.

550 Acción solicitada no se tomó.

551 Abortada acción solicitada. Se desconoce tipo de página.

552 Abortada acción de archivo solicitada. Asignación de almacenamiento excedida.

553 Acción solicitada no se tomó. Nombre de archivo no permitido.

4. CONTROL Y CONEXIONES DE DATOS.

Como otros usos de la red, el FTP utiliza el paradigma del servidor/cliente. El cliente establece una conexión del control. Cuando el usuario incorpora un comando, el cliente forma una petición usando el protocolo del FTP y la envía al servidor. Semejantemente, el servidor utiliza el protocolo del FTP para enviar una contestación.

El FTP utiliza la conexión de control para enviar y para recibir solamente mensajes de control. Establece una conexión de datos separada para cada transferencia de archivo. Aunque estas conexiones de datos aparecen y desaparecen con frecuencia, la conexión de control persiste para la sesión entera. En la figura 3 se ilustra el concepto antes mencionado para la conexión FTP.

Figura 3: Ejemplo de una conexión FTP

Las conexiones separadas para el control y la transferencia tienen varias ventajas entre ellas se encuentra que simplifica el protocolo y permite que la conexión del control sea utilizada durante una transferencia de archivo, ejem: para abortar la transferencia.

5. MANEJO DE CONEXIONES.

Los comandos de servicio de FTP que envía el cliente a través de la conexión de control le piden al servidor realizar alguna acción relacionada con archivos en el sistema servidor, o transferir información a través de la conexión de datos. El cliente FTP crea la conexión con el servidor remoto, utilizando un socket que luego conecta al puerto del servidor.

Una sesión FTP común pasa por cuatro etapas:

1. Un programa cliente se conecta a un servidor FTP en el puerto 21.

2. El usuario inicia la sesión con el anfitrión servidor FTP.

3. El cliente y el servidor FTP realizan un intercambio de comandos y respuestas.

4. El cliente FTP cierra la conexión con el servidor.

La forma en que se llevan a cabo las etapas anteriores se describen en la sección 7 donde se describe un ejemplo de una conexión FTP.

La conexión de datos tiene 3 utilidades:

- Enviar archivos del cliente al servidor

- Enviar archivos del servidor al cliente

- Enviar listados de archivos o directorios desde el servidor al cliente.

Cuando el cliente o el servidor utilizan la conexión de datos para transferir archivos u otro tipo de información, primero el cliente creará la conexión de datos, puesto que el inicia todos los comandos que se necesitan usar en la conexión, y también debe crear la conexión para recibir los datos solicitados. Mientras que la conexión de control permanece abierta durante todo el proceso, la conexión de datos sólo se mantiene mientras esté en curso una operación de transferencia. Cada vez que el cliente necesita intercambiar datos con el servidor crea una conexión de datos nueva, lo que no es necesario si se utiliza el comando PASV el cual identifica una sola dirección para la conexión de datos que permanece durante toda la sesión.

Un cliente FTP debe hacer una apertura pasiva en el socket de conexión de datos y luego indicar al servidor en que puerto conectar al host cliente, para que el servidor sepa donde enviar los datos que le solicitó el cliente, a través de la conexión de control. Después el servidor hace una apertura activa y el cliente emplea el socket y el puerto de protocolo que especificó.

Para la conexión de datos, el cliente FTP actúa como un servidor: crea un socket, lo une a una dirección local, le indica al servidor con que dirección conectar y luego espera a que llegue una conexión entrante. Un cliente FTP almacena la dirección del servidor FTP en el socket creado para la conexión de datos, luego el socket solo aceptará conexiones de ese servidor.

Para abortar una transmisión el usuario inserta el comando de FTP (por ej. ABORT) a través de la conexión de control.

Hay que tener en cuenta que el servidor siempre realiza la apertura activa de la conexión de datos, y normalmente siempre es el encargado de realizar el cierre activo, excepto cuando el cliente envía un archivo, en este caso la utilización del modo flujo requiere que sea el cliente quien cierre la conexión, que por otro lado es la forma de indicar el fin de archivo.

Se puede dar el caso de que el cliente no envíe la orden PORT, en este caso el servidor realiza una conexión utilizando el mismo número de puerto que el que utilizó el cliente para la conexión de datos. Esto es correcto ya que el número de puerto en el servidor es distinto para las conexiones de datos y de control.

TCP exige que cuando se realiza un cierre activo y se envía el ACK final, la conexión debe permanecer en estado de espera durante dos veces el MSL (Tiempo de vida máximo del segmento). Con esto TCP puede reenviar el ACK final en el caso de que este ACK se perdiera. Por lo tanto una vez que se ha cerrado la conexión, esta permanece inutilizable durante un periodo de 2MSL. Por eso se recomienda utilizar la orden PORT, para evitar la espera de 2MSL en conexiones de datos sucesivas.

6. FTP ANÓNIMO. Al conectarnos por FTP, nos encontramos con el problema de disponer de un identificador (login) y

una clave de acceso (password) para cada máquina a la que nos conectemos. Esto se debe a la protección que da el servidor a la información que posee para mantenerla fuera del alcance de intrusos. Por fortuna, los usuarios de Internet pueden realizar FTP sobre los servidores de la red configurados con el título "anonymous FTP" (FTP anónimo).

La comunicación por FTP anónimo es una forma de conectarse a los servidores de archivos de

Internet sin necesidad de poseer una contraseña. Existen muchos servidores públicos que admiten conexiones FTP anónimas llamados FTP-sites (son servidores que poseen información y puede descargarse por medio de este tipo de conexión). Estos servidores se dedican a distribuir software de dominio público y shareware (programas a prueba por un periodo determinado de tiempo y después para seguir usándolo se tiene que realizar un pago en efectivo) para cualquier tipo de ordenador o sistema operativo existente.

Para utilizar un FTP anónimo, el usuario debe introducir el identificador de usuario anonymous y

como contraseña se considera una muestra de cortesía introducir la dirección de correo electrónico aunque también se suele introducir la palabra guest (huésped).

Para poder realizar conexiones FTP como las que hemos mencionado necesitamos disponer de soporte TCP/IP o SLIP o estar conectado a un servidor que nos ofrezca FTP. Para usuarios que no tengan contratado este servicio, existe el FTPmail, el cual, permite acceder mediante mensajes de correo electrónico a servidores de archivos FTP. Utilizando un formato de dirección especial, se pueden enviar mensajes al servidor con comandos de texto para obtener directorios, moverse por el sistema de archivos o transferir archivos. La respuesta del servidor vuelve también en forma de mensajes de correo. Este sistema es muy lento y dista mucho de la facilidad de una conexión en línea

7. EJEMPLO DE CONEXIÓN FTP.

Primero se debe conocer la dirección del servidor FTP con el que se desea conectar. Por ejemplo, se va a establecer una conexión con el servidor FTP del laboratorio de redes:

Si aún no se ha iniciado FTP se debe teclear desde la línea de comandos lo siguiente:

c> ftp zoltar.redes.upv.es o desde ftp: ftp> open zoltar.redes.upv.es

Después aparecerá un saludo en pantalla del servidor FTP remoto. Si se tienen derechos especiales en el servidor, le tendremos que proporcionar al sistema la identificación de usuario y la contraseña. Y si no se dispone de privilegios, se entra con el estatus de invitado: anonymous FTP. Para entrar al servidor como invitado, en la identificación de usuario pondremos anonymous y como password la dirección de correo electrónico.

Lo anterior corresponde a las etapas uno y dos de la sesión FTP.

220 zoltar.redes.upv.es FTP server (Version wu-2.4.2-academ[BETA-15](1) Wed May 20

13:45:04 CDT 1998) ready.

user anonymous

331 Guest login ok, send your complete e-mail address as password.

pass cavifoda@catarroja.infoville.net

230- Laboratorio de Redes de Computadores.

230- Departamento DISCA

230- zoltar.redes.upv.es

230-

230--Bienvenido usuario FTP procedente de rad212.catarroja.infoville.net.

230--- Todo lo que haga usted en esta maquina queda registrado.

230--- Si no esta de acuerdo con esta politica, desconecte ahora.

230-Es usted el usuario numero 1 actualmente presente de su clase.

230-El límite de usuarios en su clase es de 60 usuarios.

230-Son las: Tue Jun 8 10:59:27 1999.

230-Si su cliente tiene problemas con nuestro servidor, coloque el caracter

230-"-" delante de su password. Esto evitara que su cliente se confunda con

230-los mensajes de continuacion FTP.

230-

230- Para cualquier duda, queja o sugerencia enviar un e-mail a: ftpmaster @redes.upv.es

230 Guest login ok, access restrictions apply.

Una vez conectados, para obtener una lista de los comandos FTP, podemos teclear ? ó help. Y podemos obtener una breve descripción de los mismos con help NombreComando. Al hacer un dir sobre el servidor FTP, nos aparecerán varias columnas de información sobre archivos y directorios, la primera columna de la izquierda indica los atributos de los mismos.

ATRIBUTO SIGNIFICADO - Archivo de disco

D Directorio

L referencia enlazada

R Archivo de lectura

W Archivo con permiso de escritura

Los servidores FTP disponen de unos archivos de texto denominados archivos índices, que explican lo que hay en un directorio particular. Lo más apropiado es transferirlo al sistema local y visualizar su contenido. Para transferir archivos, tendremos que asegurarnos de que estamos utilizando el tipo de transferencia apropiado:

COMANDO SIGNIFICADO Ascii Establece el tipo de transferencia de archivo en ASCII

Binary Establece el tipo de transferencia de archivo en BINARIO

Una vez establecido el tipo de transferencia, este permanecerá en activo hasta que se vuelva a cambiar de nuevo el tipo. Podemos averiguar que tipo de transferencia está en activo, con el comando type. Si deseamos movernos por los directorios del servidor podemos utilizar los comandos, pwd, cd y cdup. Si lo que queremos es obtener un listado de los archivos de un directorio utilizaremos el comando ls, etc.

ftp> ls

200 PORT command succesful

150 Opening ASCII mode data connection for file list

etc

pub

usr

bin

lib

incoming

welcome.msg

mirror

226 Transfer complete

56 bytes received in 0.00 seconds (56000.00 Kbytes/sec)

Lo anterior corresponde a la tercera etapa de la sesión FTP.

Para dar por terminada la sesión FTP se tiene que teclear el comando quit dentro de la sesión con lo que se cierran las conexiones de datos y control establecidas durante la sesión, esto corresponde a la cuarta etapa de la sesión FTP.

ftp>quit

221 Goodbye

CODIGO DEL PROGRAMA

/* Proyecto de Investigación II Nombre del proyecto: Cliente ftp Elaborado por: Marcelo Abimael Flores Tapia Asesorado por: Rene Mackinney Romero Lenguaje de implementación: C La forma de ejecución por línea de comandos es: c:\>cliente2 <nombre_host> <opción> si en <opción> es -v se colocan en batalla todos los comandos internos para el comando general en el caso de get, put y list*/ /*Librerías a ser usadas dentro de todo el proyecto*/ #include <stdio.h> #include <string.h> #include <stdlib.h> #include <conio.h> #include <windows.h> /*Librería a ser utilizada para el manejo de los sockets*/ #include <winsock.h> /*Definición del tamaño de los buffers para la recepción de datos*/ #define TAM_BUF 1025 #define TAM_BUF1 1025 #define TAM_BUF2 1025 /*Prototipos de funciones a usar*/ void get(char *,char *); void put(char *,char *); void list(char *,char *); /*Variables globales*/ //Estructura para datos del servidor (dirección IP y puerto) SOCKADDR_IN DireccionServer; //Estructuras usadas para información de la transmisión de datos SOCKADDR_IN DireccionDatos,DireccionDatos1,DireccionDatos2; //Definición de los sockets SOCKET Sock,Sock1,Sock2,Sock3; //Definición de los buffers a ser usados para la transmisión de datos char buffer[TAM_BUF]; char buffer1[TAM_BUF1]; char buffer2[TAM_BUF2]; /*FUNCIÓN PRINCIPAL*/ void main(int argc,char *argv[]) { //Definicion de una cadena para ver cual es la opcion dada por el usuario char *opcion; //Paso de la opcion dada por linea de comandos para ser usada en el programa opcion=argv[2]; //Inicializacion de los valores de la libreria winsock que es usada para manejo de sockets WSADATA WsaData; WORD wVersionRequerida = MAKEWORD (2, 2); WSAStartup (wVersionRequerida, &WsaData); /*Creacion de los sockets*/ //Socket para enviar y/o recibir comandos y respuestas al servidor Sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); //Sockets para recibir datos del servidor Sock1 = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); Sock2 = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); Sock3 = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); /*Reservación de memoria para las estructuras de datos y control*/

//Estructura de control memset (&DireccionServer, 0, sizeof (DireccionServer)); //Estructuras de Datos memset (&DireccionDatos, 0, sizeof (DireccionDatos)); memset (&DireccionDatos1, 0, sizeof (DireccionDatos1)); memset (&DireccionDatos2, 0, sizeof (DireccionDatos2)); /* Se utiliza para convertir el nombre del host a su direccion IP */ struct hostent *host; /* Convertimos el nombre del host a su direccion IP */ if ((host=gethostbyname(argv[1])) == NULL) { printf("error al obtener la dirección del host"); return; } /*Inicialización de los valores de la estructura de control*/ DireccionServer.sin_family = AF_INET; //Aqui se establece la dirección IP obtenida anteriormente para la conexión DireccionServer.sin_addr=*((struct in_addr *)host->h_addr); //Se declara el puerto 21 para la conexión al servidor ya que es la predefinida para FTP DireccionServer.sin_port = htons(21); /*Chequeo de que la conexion se realice de forma adecuada*/ int iResult = connect (Sock, (SOCKADDR*) &DireccionServer,sizeof(DireccionServer)); if (iResult) { //Mensaje de error para el caso de la conexión al servidor printf ("No se puede conectar\n"); return; } /*Parte de definicion de variables locales*/ //Cadenas auxiliares para el manejo de los comandos char cadena[20],cadena1[100],aux[100],aux1[100],aux2[5],comando[100]; char com[100],aux3[20],aux4[50],cmd[100],auxi[50]; //Variables para el control de datos generados por el programa int result,i,j,lon=0,lon1=0,error,bandera=0; memset(cadena1, NULL, 100); /*Obtención de la cadena de presentación del host*/ do { //Reservación de memoria para cadena de presentación del host memset(cadena1, NULL, 100); //Recepción de la respuesta por parte del servidor error=recv(Sock,cadena1, sizeof (cadena1), 0); printf("%s",cadena1); }while(cadena1[3] != ' ');//La opción cuando el cuarto caracter es espacio en blanco se da por que asi es el formato establecido para el ftp /*Ciclo para la revisión de que el usuario sea valido en el servidor*/ do { flushall(); //Reservación de memoria para la cadena de respuesta del servidor memset(cadena1, NULL, 100); //Reservación de memoria para las cadenas usadas para el manejo de nombre de usuario memset(aux, NULL, 100); memset(cadena, NULL, 100); printf("\nNombre del usuario:"); gets(aux); //Construcción del comando USER sprintf(cadena,"USER %s\r\n",aux); //Envio de comando USER al servidor

send(Sock,cadena, strlen(cadena), 0); //Recepción de respuesta de parte del servidor al comando USER int error1,bandera1=0; do { //Reservación de memoria para cadena de presentación del host memset(cadena1, NULL, 100); //Recepción de la respuesta por parte del servidor error1=recv(Sock,cadena1, sizeof (cadena1), 0); printf("%s",cadena1); }while(cadena1[3] != ' ');//La opción cuando el cuarto caracter es espacio en blanco se da por que asi es el formato establecido para el ftp //recv (Sock,cadena1, sizeof(cadena1), 0); //printf("%s",cadena1); //Reservación de memoria para las cadenas usadas para el manejo del password*/ memset(cadena1, NULL, 100); memset(aux1, NULL, 100); printf("\nContraseña:"); gets(aux1); //Construcción y envio del comando PASS sprintf(cadena,"PASS %s\r\n",aux1); send(Sock,cadena, strlen(cadena), 0); //Recepción de respuesta de parte del servidor al comando PASS int error2,bandera2=0; do { //Reservación de memoria para cadena de presentación del host memset(cadena1, NULL, 100); //Recepción de la respuesta por parte del servidor error2=recv(Sock,cadena1, sizeof (cadena1), 0); printf("%s",cadena1); }while(cadena1[3] != ' ');//La opción cuando el cuarto caracter es espacio en blanco se da por que asi es el formato establecido para el ftp //recv (Sock,cadena1, sizeof(cadena1), 0); //printf("%s",cadena1);*/ //Reservación de memoria para colocar la condición de paro del ciclo memset(aux2, NULL, 5); //Colocación del código de respuesta del servidor para validar el ciclo sprintf(aux2,"530"); //Chequeo de la condición de paro del ciclo result=strncmp(cadena1,aux2,3); }while(result == 0); /*Ciclo para obtener comandos por parte del cliente mientras no sea quit o QUIT*/ do { printf("\nftp>:"); //Obtención del comando por parte del usuario gets(cadena); //Complemento del comando para que sea reconocido por el servidor strcat(cadena,"\r\n"); /*Chequeo de que el comando sea LIST*/ if(strncmp(cadena,"LIST",4)==0) { //Obtención de la longitud del comando lon1=strlen(cadena); //Reservación de la memoria para la cadena auxiliar donde se pone el complemento del LIST memset(aux4, NULL, 50); //Obtención del complemento (ruta) para el comando LIST for(j=5;j<lon1;j++) aux4[j-5]=cadena[j]; //Reservación de memoria para constuir el comando total memset(cmd, NULL, 100); //Creación del comando LIST con la ruta correspondiente sprintf(cmd,"LIST %s",aux4); //Llamado a la función correspondiente para el LIST con el envio de la opcion dada por el usuario

list(cmd,opcion); } else { /*Chequeo de que el comando sea GET*/ if(strncmp(cadena,"GET",3)==0) { //Obtención de la longitud del comando lon=strlen(cadena); //Reservación de la memoria para la cadena auxiliar donde se pone el complemento del GET memset(aux3, NULL, 50); //Obtención del complemento (ruta) para el comando RETR que sera enviado a la función for(i=4;i<lon;i++) aux3[i-4]=cadena[i]; //Reservación de memoria para constuir el comando total memset(comando, NULL, 100); //Creación del comando RETR con la ruta correspondiente sprintf(comando,"RETR %s",aux3); //Llamado a la función correspondiente para el GET con el envio de la opcion dada por el usuario get(comando,opcion); } else { /*Chequeo de que el comando sea PUT*/ if(strncmp(cadena,"PUT",3)==0) { //Obtención de la longitud del comando lon=strlen(cadena); //Reservación de la memoria para la cadena auxiliar donde se pone el complemento del PUT memset(auxi, NULL, 50); //Obtención del complemento (ruta) para el comando STOR que sera enviado a la función for(i=4;i<lon;i++) auxi[i-4]=cadena[i]; //Reservación de memoria para constuir el comando total memset(com, NULL, 100); //Creación del comando STOR con la ruta correspondiente sprintf(com,"STOR %s",auxi); //Llamado a la función correspondiente para el PUT con el envio de la opcion dada por el usuario put(com,opcion); } /*En caso de que sea algun otro comando se realiza*/ else { //Envío de comando al servidor send(Sock,cadena, sizeof (cadena), 0); /*Recepción de respuestas por parte del servidor*/ do { //Reservación de memoria para la cadena de respuesta memset(cadena1, NULL, 100); //Recepción de la respuesta por parte del servidor recv (Sock,cadena1, sizeof(cadena1), 0); printf("%s",cadena1); }while(cadena1[3] != ' ');//La opción cuando el cuarto caracter es espacio en blanco se da por que asi es el formato establecido para el ftp } } } }while(((strcmp(cadena,"QUIT\r\n")) && (strcmp(cadena,"quit\r\n")))!=0);

//Cierre de conexion y libreria closesocket (Sock); closesocket (Sock1); WSACleanup(); } /*Funciones a usar en el programa*/ //Función utilizada para el comando GET void get(char *comando,char *opcion) { //Esta variable se utiliza para hacer la transmisión de datos para el comando int datos1; //Estas son variables auxiliares para obtener datos para el comando GET char caden[50],caden1[50],caden2[100],cadena[50]; //Estas variables son auxiliares para complementar el comando GET int puerto1,l1,largo=0,i; //Este apuntador es utilizado para el archivo requerido para el GET FILE *arch; //Se le da el tipo a la estructura que se maneja para los datos del comando GET DireccionDatos1.sin_family = AF_INET; //Ligamiento del socket para el GET y el servidor int Result1 = bind (Sock2, (SOCKADDR*)&DireccionDatos1, sizeof (DireccionDatos1)); //Puesta en listen al Sock2 listen(Sock2,1); //Chequeo de que se lleve adecuadamente el listen por el socket if (Result1) { printf ("No se puede realizar listen\n"); return; } else { //Se coloca dentro de l1 el tamaño de la estructura de datos l1=sizeof(DireccionDatos1); //Chequeo de que el socket se haya creado correctamente int Result2=getsockname(Sock2,(SOCKADDR *) &DireccionDatos1,&l1); if (Result2) { printf ("No se puede obtener el nombre del socket\n"); return; } //Obtención del puerto por donde el socket esta esperando datos puerto1=ntohs(DireccionDatos1.sin_port); } if(opcion="-v") { //Presentación al usuario del puerto por donde se recibirán los datos del servidor printf("El puerto por donde se transmitira es: %u\n",puerto1); //Reservación de memoria para las cadenas usadas en este envio de comandos y obtención de respuestas memset(caden1, NULL, 50); memset(caden2, NULL, 100); //Traducción del puerto obtenido a la necesaria para el comando PORT int numero1=(int) puerto1 / 256; int numero2=puerto1 % 256; //Presentación al usuario de los datos para el comando PORT printf("\nLos valores son: %d y %d que van en el comando PORT\n",numero1,numero2); //Creación del comando PORT con los datos obtenidos sprintf(caden1,"PORT 127,0,0,1,%d,%d\r\n",numero1,numero2); //Presentación al usuario del comando PORT ha enviar al servidor printf("\nEl comando PORT queda de la siguiente forma: %s",caden1); //Envío del comando PORT al servidor send(Sock,caden1, sizeof (caden1), 0); //Obtención de la respuesta por parte del servidor al comando PORT recv(Sock,caden2,sizeof(caden2),0); //Presentación al usuario de la respuesta obtenida y del siguiente comando a enviar al servidor printf("\nLa respuesta al PORT es: %s\n",caden2);

printf("\nEl comando a enviar es el siguiente: %s\n",comando); } //Se coloca en el campo respectivo dentro de la estructura de datos el puerto obtenido DireccionDatos1.sin_port = puerto1; //Reservación de memoria para conformar el comando recibido por el usuario memset(caden, NULL, 50); //Cambio a una variable auxiliar para manejar el comando recibido de los parametros de la función strcpy(caden,comando); //Envío del comando RETR al servidor send(Sock,caden, sizeof(caden), 0); //Se hace esta asignación debido a que el accept genera un nuevo identificador para el socket datos1 = accept(Sock2,NULL,NULL); int cont1=0; /*Ciclo de obtención de respuesta al comando RETR*/ do { //Reservación de memoria para la cadena donde se obtiene la respuesta de parte del servidor memset(caden2, NULL, 100); //Recepción de la respuesta del servidor recv (Sock,caden2, sizeof(caden2), 0); //Presentación de respuesta al usuario printf("%s\n",caden2); cont1++; }while(cont1<2); //Obtención del tamaño del comando enviado largo=strlen(caden); //Reservación de memoria para obtener el nombre del archivo a manejar memset(cadena, NULL, 50); //En este for se obtiene la ruta enviada con el comando RETR for(i=6;i<(largo-2);i++) cadena[i-6]=caden[i]; //Chequeo de que la apertura del archivo obtenido anteriormente sea correcta if( (arch=fopen(cadena,"w+b")) == NULL ) { printf("No se pudo abrir el archivo"); return; } //Variables de control para el ciclo siguiente int err1=0, band1=0; /*Ciclo para realizar el comando RETR*/ do { //Reservación de memoria para el buffer que recibe los datos del servidor memset(buffer1, NULL, TAM_BUF1); //Colocación en la variable del valor que sera utilizado posteriormente para ver si hay mas datos err1 = recv(datos1,buffer1,TAM_BUF1,0); //Escritura de los datos obtenidos del servidor al archivo abierto fwrite(buffer1,err1,1,arch); if(opcion="-v") printf("%s\n",buffer1); //Chequeo de que todavia se esten recibiendo datos por parte del servidor debido a que si err1 es -1 significa que no hay mas datos if (!err1) { //Activación de la bandera para terminar el ciclo del comando RETR band1=1; return; } }while(band1!=1); //Cierre de archivo y socket fclose(arch); closesocket (Sock2); } //Función utilizada para el comando PUT void put(char *com,char *opcion)

{ //Esta variable se utiliza para hacer la transmisión de datos para el comando int datos2; //Estas son variables auxiliares para obtener datos para el comando PUT char cade[50],cade1[50],cade2[100],caden[50]; //Estas variables son auxiliares para complementar el comando PUT int puerto2,l2,largo1=0,j; //Este apuntador es utilizado para el archivo requerido para el PUT FILE *arch1; //Se le da el tipo a la estructura que se maneja para los datos del comando PUT DireccionDatos2.sin_family = AF_INET; //Ligamiento del socket para el PUT y el servidor int Resulta1 = bind (Sock3, (SOCKADDR*)&DireccionDatos2, sizeof (DireccionDatos2)); //Puesta en listen al Sock3 listen(Sock3,1); //Chequeo de que se lleve adecuadamente el listen por el socket if (Resulta1) { printf ("No se puede realizar listen\n"); return; } else { //Se coloca dentro de l1 el tamaño de la estructura de datos l2=sizeof(DireccionDatos2); //Chequeo de que el socket se haya creado correctamente int Resulta2=getsockname(Sock3,(SOCKADDR *) &DireccionDatos2,&l2); if (Resulta2) { printf ("No se puede obtener el nombre del socket\n"); return; } //Obtención del puerto por donde el socket esta esperando datos puerto2=ntohs(DireccionDatos2.sin_port); } if(opcion="-v") { //Presentación al usuario del puerto por donde se recibirán los datos del servidor printf("El puerto por donde se transmitira es: %u\n",puerto2); //Reservación de memoria para las cadenas usadas en este envio de comandos y obtención de respuestas memset(cade1, NULL, 50); memset(cade2, NULL, 100); //Traducción del puerto obtenido a la necesaria para el comando PORT int nume1=(int) puerto2 / 256; int nume2=puerto2 % 256; //Presentación al usuario de los datos para el comando PORT printf("\nLos valores son: %d y %d que van en el comando PORT\n",nume1,nume2); //Creación del comando PORT con los datos obtenidos sprintf(cade1,"PORT 127,0,0,1,%d,%d\r\n",nume1,nume2); //Presentación al usuario del comando PORT ha enviar al servidor printf("\nEl comando PORT queda de la siguiente forma: %s",cade1); //Envío del comando PORT al servidor send(Sock,cade1, sizeof (cade), 0); //Obtención de la respuesta por parte del servidor al comando PORT recv(Sock,cade2,sizeof(cade2),0); //Presentación al usuario de la respuesta obtenida y del siguiente comando a enviar al servidor printf("\nLa respuesta al PORT es: %s\n",cade2); printf("\nEl comando a enviar es el siguiente: %s\n",com); } //Se coloca en el campo respectivo dentro de la estructura de datos el puerto obtenido DireccionDatos2.sin_port = puerto2; //Reservación de memoria para conformar el comando recibido por el usuario memset(cade, NULL, 50); //Cambio a una variable auxiliar para manejar el comando recibido de los parametros de la función strcpy(cade,com); //Envío del comando STOR al servidor

send(Sock,cade, sizeof(cade), 0); //Se hace esta asignación debido a que el accept genera un nuevo identificador para el socket datos2 = accept(Sock3,NULL,NULL); int con1=0; /*Ciclo de obtención de respuesta al comando STOR*/ do { //Reservación de memoria para la cadena donde se obtiene la respuesta de parte del servidor memset(cade2, NULL, 100); //Recepción de la respuesta del servidor recv (Sock,cade2, sizeof(cade2), 0); //Presentación de respuesta al usuario printf("%s\n",cade2); con1++; }while(con1<2); //Obtención del tamaño del comando enviado largo1=strlen(cade); //Reservación de memoria para obtener el nombre del archivo a manejar memset(caden, NULL, 50); //En este for se obtiene la ruta enviada con el comando STOR for(j=6;j<(largo1-2);j++) caden[j-6]=cade[j]; //Chequeo de que la apertura del archivo obtenido anteriormente sea correcta if( (arch1=fopen(caden,"r+b")) == NULL ) { printf("No se pudo abrir el archivo"); return; } //Variables de control para el ciclo siguiente int error=0, bande=0; /*Ciclo para realizar el comando STOR*/ do { //Reservación de memoria para el buffer que recibe los datos del servidor memset(buffer2, NULL, TAM_BUF2); //Lectura de los datos del archivo abierto anteriormente fread(buffer2,TAM_BUF2,1,arch1); //Colocación en la variable del valor que sera utilizado posteriormente para ver si hay mas datos error = send(datos2,buffer2,TAM_BUF2,0); if(opcion="-v") printf("%s\n",buffer2); //Chequeo de que todavia se esten recibiendo datos por parte del servidor debido a que si err1 es -1 significa que no hay mas datos if (!error) { //Activación de la bandera para terminar el ciclo del comando STOR bande=1; return; } }while(bande!=1); //Cierre de archivo y socket fclose(arch1); closesocket (Sock3); } void list(char *cmd,char *opcion) { //Esta variable se utiliza para hacer la transmisión de datos para el comando int datos; //Estas son variables auxiliares para obtener datos para el comando LIST char cad[50],cad1[50],cad2[100]; //Estas variables son auxiliares para complementar el comando LIST int puerto,l; //Se le da el tipo a la estructura que se maneja para los datos del comando LIST DireccionDatos.sin_family = AF_INET; //Ligamiento de los sockets de servidor y cliente int iResult1 = bind (Sock1, (SOCKADDR*)&DireccionDatos, sizeof (DireccionDatos));

//Puesta en listen al Sock1 listen(Sock1,1); //Chequeo de que se lleve adecuadamente el listen por el socket if (iResult1) { printf ("No se puede realizar listen\n"); return; } else { //Se coloca dentro de l1 el tamaño de la estructura de datos l=sizeof(DireccionDatos); //Chequeo de que el socket se haya creado correctamente int iResult2=getsockname(Sock1,(SOCKADDR *) &DireccionDatos,&l); if (iResult2) { printf ("No se puede obtener el nombre del socket\n"); return; } //Obtención del puerto por donde el socket esta esperando datos puerto=ntohs(DireccionDatos.sin_port); } if(opcion="-v") { //Presentación al usuario del puerto por donde se recibirán los datos del servidor printf("El puerto por donde se transmitira es: %u\n",puerto); //Reservación de memoria para las cadenas usadas en este envio de comandos y obtención de respuestas memset(cad1, NULL, 50); memset(cad2, NULL, 100); //Traducción del puerto obtenido a la necesaria para el comando PORT int num1=(int) puerto / 256; int num2=puerto % 256; //Presentación al usuario de los datos para el comando PORT printf("\nLos valores son: %d y %d que van en el comando PORT\n",num1,num2); //Creación del comando PORT con los datos obtenidos sprintf(cad1,"PORT 127,0,0,1,%d,%d\r\n",num1,num2); //Presentación al usuario del comando PORT ha enviar al servidor printf("\nEl comando PORT queda de la siguiente forma: %s",cad1); //Envío del comando PORT al servidor send(Sock,cad1, sizeof (cad1), 0); //Obtención de respuesta al comando PORT de parte del servidor recv(Sock,cad2,sizeof(cad2),0); //Presentación de la respuesta al usuario printf("\nLa respuesta al PORT es: %s\n",cad2); //Presentación al usuario de la respuesta obtenida y del siguiente comando a enviar al servidor printf("\nEl comando a enviar es el siguiente: %s\n",cmd); } //Se coloca en el campo respectivo dentro de la estructura de datos el puerto obtenido DireccionDatos.sin_port = puerto; //Reservación de memoria para conformar el comando recibido por el usuario memset(cad, NULL, 50); //Cambio a una variable auxiliar para manejar el comando recibido de los parametros de la función strcpy(cad,cmd); //Envío del comando obtenido al servidor send(Sock,cad, sizeof(cad), 0); //Se hace esta asignación debido a que el accept genera un nuevo identificador para el socket datos = accept(Sock1,NULL,NULL); int cont1=0; /*Ciclo de obtención de respuesta al comando STOR*/ do { //Reservación de memoria para el buffer que recibe los datos del servidor memset(cad2, NULL, 100); //Recepción de la respuesta del servidor recv (Sock,cad2, sizeof(cad2), 0); //Presentación al usuario de las respuestas de parte del servidor

printf("%s\n",cad2); cont1++; }while(cont1<2); //Variables de control para el ciclo siguiente int err=0, band=0; do { //Reservación de memoria para el buffer que recibe los datos del servidor memset(buffer, NULL, TAM_BUF); //Colocación en la variable del valor que sera utilizado posteriormente para ver si hay mas datos err = recv(datos,buffer,TAM_BUF,0); //Presentación de los datos al usuario printf("%s",buffer); //Chequeo de que todavia se esten recibiendo datos por parte del servidor debido a que si err1 es -1 significa que no hay mas datos if (!err) { //Activación de la bandera para terminar el ciclo del comando LIST band=1; return; } }while(band!=1); }

REFERENCIAS:

- http://members.tripod.com/vteforte/ftp.htm

- http://usuarios.lycos.es/vteforte/ftp.htm

- http://penguin.dcs.bbk.ac.uk/academic/networks/application-layer/ftp/index.php

- RFC 959 File Transfer Protocol. Networking Group.