Manual de código fuente ftp

/* El cliente del servicio FTP.

Acción:

-Conectarse al servidor y solicitar el servicio

-Enviar información del tamaño de Lexi al servidor

-Comenzar a recibir archivos del servidor

-Conexión estrecha

*/

# include ltstdio.h gt

# include ltsys/types .h gt;

# incluye ltsys/socket . h gt；

# incluye ltnetinet/in .

# incluye ltarpa/inet . # incluir lttime.h gt

# incluir lterror numbergt

# definir SERVIDOR _ PUERTO _ ID 6081

#Definir ID de puerto de cliente 6086

#Definir server_host_ADDR " 128.119 . 40 . 186 "

/* gaia.cs.umass.edu */

#Definir MAXSIZE 512

#Definir confirmación 2

#Definir NACK 3

#Definir archivo de solicitud 100

#definir comando no admite 150

#Definir soporte de comando 160

#Definir nombre de archivo incorrecto 200

#Definir nombre de archivo OK 400

#Definir inicio de transferencia 500

int readn(int sd, char *ptr, int tamaño);

int writen(int sd, char *ptr, int tamaño);

main(int argc, char *argv [])

{

int sockid, newsockid, I, getfile, ack, msg, msg_2, c, len

int no_writen, start_xfer, num_blks, num_last_blk

struct sockaddr_in my_addr, server_addr

FILE * fp

char in _ buf[MAXSIZE];

if (argc != 2) {printf ("Error: uso: nombre de archivo sftp\n"); salida(0);}

no_writen = 0;

num _ blks = 0; num _ last _ blk = 0;

len = strlen(argv[1]);

printf("cliente: Creando socket\n ");

if ((sockid = socket(AF_INET, SOCK_STREAM, 0)) lt; 0)

{ printf("cliente: error de socket :d\n ", errno (0); p>

}

printf("cliente: vincular mi socket local\n ");

bzero((char *) & my_addr, sizeof(my_addr));

mi_dirección.sin_home=AF_INET

mi

_ addr . sin _ addr s _ addr = htonl(in addr _ ANY);

mi _ addr . if (bind(sockid, (struct sockaddr *) & my_addr, sizeof(my _ addr)) lt; 0)

{printf("cliente: error de enlace: d\n ", errno); (0);

}

printf("cliente: iniciando conexión\n ");

bzero((char *) & server_addr, sizeof(servidor). _ addr));

servidor _ addr . sin _ family = AF _ INET;

SERVER _ addr . sin _ addr = inet _ addr( SERVER_HOST_ADDR);

SERVER_addr. sin_PORT = htons(SERVER_PORT_ID);

if (connect(sockid, (struct sockaddr *) amp ;Dirección del servidor,

sizeof(server_addr) ) lt;0)

{ printf("cliente: error de conexión: d\n",errno);exit(0) ;

}

/ *Una vez que lleguemos aquí, podemos conectarnos al servidor*/

/*Dile al servidor que queremos obtener un archivo*/

getfile = htons(request file);

printf("cliente: enviar solicitud de comando al servidor ftp\n ");

if((writen( sockid, (char *) & getfile, sizeof(getfile))) lt ; 0)

{printf("cliente: error de escritura: d\n ", errno);}

/*Quiero obtener permiso del servidor* /

msg = 0;

if((readn(sockid, (char *) amp; msg, sizeof (msg))) lt; 0)

{printf("cliente: error de lectura: d\n ", errno(0);}

msg = ntohs (msg);

if (msg== COMMANDNOTSUPPORTED) {

printf("Cliente: El servidor rechazó el comando.

Adiós\n");

Exit(0);

}

Otro

printf("Cliente: El servidor respondió d , comando support\n ", msg);

/*Enviar el nombre del archivo al servidor*/

printf("cliente: enviar nombre del archivo\n ");

/ p>

if ((writen(sockid, argv[1], len)) lt; 0)

{printf("cliente: error de escritura: d\n " , errno); exit( 0);}

/*Compruebe si la respuesta del servidor al nombre del archivo es normal*/

msg _ 2 = 0;

if ((readn(sockid, ( char *) amp; msg_2, sizeof(msg_2))) lt; 0)

{printf("cliente: error de lectura: d\n ", errno) ; exit(0);}

msg_2 = ntohs(msg_2);

if (msg_2 == BADFILENAME) {

printf("Cliente: El servidor informó un nombre de archivo de error.\n");

Salir(0);

}

Otro

printf( "Cliente del cliente: El servidor respondió d, nombre del archivo OK\n ", msg _ 2

/*El cliente sabe que el servidor puede abrir el archivo en modo lectura y requiere Continuar */

/*El cliente ahora abre una copia del archivo en modo de escritura y envía

el GOAHEAD del servidor */

printf("cliente: enviando el comando de transmisión iniciado\ n ");

start _ xfer = STARTTRANSFER

start _ xfer = htons(start _ xfer);

if ((writen(sockid , (char *) & start_xfer, sizeof(start _ xfer))) lt; 0)

{printf("cliente: error de escritura: d\n ", errno(0);

}

if ((fp = fopen(argv[1], " w)) = = NULL)

{printf(" cliente: abrir localmente FileError\n" ); exit(0);}

/* Ahora el cliente está leyendo del servidor cuántos

bloques completos de tamaño MAXSIZE hay.

También recibe el número

El número de bytes restantes en el último bloque parcialmente lleno, si corresponde */

if((readn(sockid, (char *) amp; num_blks, sizeof(num_blks))) lt; 0)

{ printf("cliente: error de lectura en n bloques: d\n ", errno(0); num _ blks = ntohs(num _ blks);

printf("Cliente: Respuesta del servidor: Hay d bloques en el archivo\n ", num _ blks);

p >

ack = ACK

ack = htons(ack);

if((writen(sockid, (char *) & ack, sizeof(ack))) lt; 0)

{printf("cliente: error de escritura de confirmación: d\n ", errno(0);

}

if(( readn(sockid, (char *)&num_last_blk,sizeof(num_last_blk))) lt;0)

{printf("cliente: error de lectura: d en nbytes\ n ", error (0)); ; }

num _ last _ blk = ntohs(num _ last _ blk

printf("Cliente: Respuesta del servidor: d bytes último blk\n ", num_last_blk);

if((writen(sockid, (char *) & ack, sizeof(ack))) lt; 0)

{printf("cliente: ack error de escritura: d\ n ", errno); salir (0);

}

/*Empezar a leer el bloque enviado del servidor */

printf("cliente: empezar a recibir contenido del archivo\n");

for(I = 0; iltnum_blksi) {

if((readn(sockid, in_buf, MAXSIZE)) lt; 0)

{printf("cliente: Error de bloqueo leído: d\n ", errno);}

no_writen = fwrite(in_buf, sizeof(char), MAXSIZE, FP);

if(no_writen == 0){ printf("cliente: Error de escritura de archivo\ n "); salida(0);}

if (no_writen! = MAXSIZE)

{printf("cliente: Error de escritura de archivo: no_writen es más pequeño\n "); exit(0);}

/*Enviar ACK para el bloque * /

if((writen(sockid, (char *) & ack, sizeof(ack))) lt; 0)

{printf("cliente: ack error de escritura: d\ n ", errno); salir (0); }

printf(" d ... ", i);

}

/ *Si hay es un último bloque parcialmente lleno, léelo*/

if(num _

último _ blk gt; 0) {

printf("d\n ",num_blks);

if((readn(sockid,in_buf,num_last_blk) ) lt; 0)

{printf("cliente: Error en la última lectura del bloque: d\n ", errno (0);}

no_writen = fwrite (in_buf, sizeof(char), num_last_blk, FP);

if (no_writen == 0)

{printf("cliente: Error de escritura del archivo del último bloque: d\ n ", errno (0)); }

if (no_writen!=último bloque numerado)

{printf("cliente: Error de escritura del archivo: no_writen es menor que 2\n "); }

if((writen(sockid, (char *) & ack, sizeof(ack))) lt; 0)

{printf("cliente: ack error de escritura: d \n ", errno); exit(0);}

}

else printf(" \n ");

/*La transferencia de archivos finaliza. El cliente finaliza después de cerrar todos los archivos

y sockets*/

fclose(FP);

printf("cliente: Transferencia de archivos completada\n") ;

close(sockid);

}

/*Porque se puede alcanzar el límite de buffer del socket en el kernel

Lecturas y Las escrituras pueden devolver valores positivos cuando

son menores que el número solicitado.

Entonces llamamos a estos dos procedimientos

para manejar tales emergencias*/

int readn(int sd, char *ptr, int size)

{ int no_left, no_read

no_left = tamaño

mientras(no_left gt; 0)

{ no_read = read(sd,ptr , no _ left

if (no _ read lt; 0) devuelve (no _ read);

if (no _ read == 0)

no _ left-= no; _ leer;

ptr = no _ leer

}

return(size-no _ left); p>

int escrito(int sd, char *ptr, int tamaño)

{ int no_left, no _ escrito

no _ left = tamaño

mientras(no _ izquierda gt; 0)

{ no_escrito = escribir(sd, ptr, no _ izquierda

if( no _ escrito lt; = 0) devuelve ( no _ escrito);

no _ left-= no _ escrito

ptr = no _ escrito

}

retorno; (tamaño-no _ izquierda);

}

Servidor de red informática

# incluir ltstdio.h gt

# incluir ltsys/ tipos . h gt；

# incluye ltsys/socket . h gt；

# incluye ltnetinet/in .

# incluye ltarpa/inet . h gt;

# incluir lttime.h gt

# incluir número de error gt

#Definir mi ID de puerto 6081

#Definir límite máximo 256

#Definir MAXSIZE 512

#Definir confirmación 2

#Definir NACK 3

#Definir archivo de solicitud 100

#define el comando no admite 150

#Define el comando admite 160

#Define nombre de archivo incorrecto 200

#Define nombre de archivo OK 400

int escrito(int sd, char *ptr, int tamaño);

int readn(int sd, char *ptr, int tamaño);

>main() {

int sockid, newsd, pid, clilen

struct sockaddr_in my_addr, client _ addr

printf("Servidor: Creando socket\n ");

if ((sockid = socket(AF_INET, SOCK_STREAM, 0)) lt

;0)

{printf("Servidor: Error de socket: d\n ", errno); salida(0);}

printf("servidor: vincularme al socket local\ n");

bzero((char *) & my_addr, sizeof(my_addr));

my_address.sin_home = AF_INET

MY _ addr . sin _ PUERTO = htons(MI _ PUERTO _ ID);

mi _ dirección . sin _ dirección s _ dirección = htons(en dirección _ CUALQUIER);

if (bind(. sockid, (struct sockaddr *) & my_addr, sizeof(my _ addr)) lt; 0)

{printf("Servidor: Error de enlace: d\n ", errno); }

printf("Servidor: Comience a escuchar\n ");

if (listen(sockid , 5) lt; 0)

{ printf(" servidor:escucha error: d\n",errno);exit(0);}

while(1==1 ) {

/*Acepta la conexión, luego crea una proceso hijo para hacer el trabajo*/

/*Bucle hacia atrás y espere otra conexión*/

printf("Servidor: empezar a aceptar\n");

if ((newsd = aceptar(sockid, (struct sockaddr *) amp; dirección del cliente,

ampclilen)) lt; 0)

{printf("Servidor: Aceptar error: d\n ", errno); exit(0);}

printf("servidor: retorno de aceptar, Socket para este ftp: d\n ",

newsd);

if ( (pid=fork()) == 0) {

/*El subproceso comienza aquí. Realizará la transferencia de archivos real */

close(sockid); /*Los niños no deberían aceptarlo*/

doftp(newsd); ( newsd);

Salir (0); /*Los niños han completado su trabajo*/

}

/*Los padres continúan abajo*/

Close(newsd);/*El padre lo hace todo el cliente, solo el hijo*/

} /*Se comunicará con este cliente de ahora en adelante*/

}