Código fuente de la estación ftp
/* El cliente del servicio FTP.
Acción:
-Conéctate al servidor y solicita el servicio
-Envía información del tamaño de Lexi al servidor
-Comienza a recibir archivos del servidor
-conexión estrecha
*/
# include & ltstdio.h & gt
# include & ltsys/types.h & gt;
# incluir & ltsys/socket .
# incluir & ltnetinet/in .
# incluir & ltarpa/inet . & gt ;
# incluir & lttime.h & gt
# incluir & número de error& gt
# 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 es compatible con 150
#Definir el comando admite 160
#Definir nombre de archivo incorrecto 200
#Definir nombre de archivo OK 400
#Definición iniciar transferencia 500
int readn(int sd, char *ptr, int size
int writen(int sd, char *ptr, int size); p>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))<0)
{ printf("cliente: error de socket : %d\n ", errno); salir (0);
}
printf("cliente: vincular mi socket local\n");
bzero((char *)&my_addr, sizeof(my_addr));
my_address .sin_family=AF_INET
my_addr .sin_addr .s_addr = htonl(in addr_ANY);
mi_dirección .sin_POR
T = htons(CLIENT_PORT_ID);
if (bind(sockid, (struct sockaddr *)&my_addr, sizeof(my_addr))<0)
{printf("cliente : error de enlace :%d\n ", errno); salir (0);
}
printf("cliente: iniciando conexión\ n ");
bzero((char *)&server_addr, sizeof(server_addr));
server_addr. sin_family = AF_INET;
SERVER_addr. /p>
SERVER_addr. sin_PORT = htons(SERVER_PORT_ ID);
if (connect(sockid, (struct sockaddr *)&dirección del servidor,
sizeof(server_addr) )<0)
{ printf(" cliente:error de conexión:% d \ n ", errno(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)) )<0)
{printf("cliente:Error de escritura: %d\n ", errno); exit(0);}
/*Espero obtener permiso de el servidor*/
msg = 0;
if((readn(sockid, (char *)&msg,sizeof(msg)))<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, soporte de comando\n ", msg);
/*Enviar el nombre del archivo al servidor*/
printf("cliente:Enviar nombre del archivo\n ");
if ((writen(sockid, argv[1], len))& lt; 0)
{printf("cliente: error de escritura: %d\n ", errno) ;Salir(0);}
/*Compruebe si el servidor responde con un nombre de archivo normal*/
msg _ 2 = 0;
if ( (readn( sockid, (char *)&msg_2,sizeof(msg_2)))<0)
{printf("cliente: error de lectura: %d\n ", errno); 0);}
msg _ 2 = ntohs(msg _ 2);
if (msg_2 == BADFILENAME) {
printf("Terminal de cliente: El servidor informó un nombre de archivo incorrecto. \n ");
Exit(0);
Otro
printf("Cliente: El servidor respondió %d , el nombre del archivo está bien\n ", msg _ 2);
/*El cliente sabe que el servidor puede abrir el archivo en modo lectura
modo y solicita continuar * /
/*El cliente ahora abre una copia del archivo en modo de escritura y envía el GOAHEAD del servidor */
printf("cliente:Enviar comando de inicio de transmisión\ n ");
start _ xfer = STARTTRANSFER
start _ xfer = htons(start _ xfer);
if ((writen(sockid, (char *)& start_xfer,sizeof(start_xfer)))<0)
{printf("cliente:escribir error:%d\n ", errno (0);
if ((fp = fopen(argv[1], " w))== NULL)
{printf("cliente:Error de archivo abierto local\n");salir (0);}
/*Ahora el cliente está leyendo del servidor aproximadamente cuántos
Un bloque completo de tamaño MAXSIZE.
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)))<0)
{ printf("cliente: error de lectura en n bloques: %d\n ", errno(0) ;}
<); p>num _ blks = ntohs(num _ blks);printf("Cliente: Respuesta del servidor: Hay %d bloques en el archivo\n ", num _ blks );
ack = ACK
ack = htons(ack);
if((writen(sockid, (char *)&ack, sizeof (ack)))<0 )
{printf("cliente: error de escritura de confirmación: %d\n ", error (0);
}
if(( readn(sockid, (char *)&num_last_blk,sizeof(num_last_blk)))<0)
{printf("cliente: Error de lectura: %d en nbytes\n ", errno); (0); }
num_last_blk = ntohs(num_last_blk);
printf("Cliente: Respuesta del servidor: %d bytes último negro\n ", num_last_blk);
if((writen(sockid, (char *)&ack, sizeof(ack)))<0)
{printf("cliente: error de escritura de confirmación: %d\n " , errno); exit(0);
}
/*Comienza a leer el bloque enviado por el servidor*/
printf("cliente: Comienza a obtener contenido del archivo\ n ");
for(I = 0;i<num_blksi++) {
if((readn(sockid, in_buf, MAXSIZE))<0)
{printf("cliente:bloque Error al leer: %d\n ", errno (0);
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 del bloque * /
if((writen(sockid, (char *)&ack,sizeof(ack)))<0)
{printf("cliente: ackwrite Ingrese error: % d\n ", errno); salir (0); }
printf(" %d... ", i);
}
/ *Si hay un último bloque parcialmente lleno, léelo*/
if(num _ last _ blk & gt; 0) {
printf("% d\n ", num_blks);
if((readn(sockid,i
n_buf,num_last_blk))<0)
{printf("cliente: Error al leer el último bloque: %d\n", errno);}
no_writen); = fwrite(in_buf, sizeof(char), num_last_blk, FP);
if (no_writen == 0)
{printf("cliente: Error de escritura del último archivo de bloque: %d \n ", errno); exit (0); }
if (no_writen! = último bloque numerado)
{printf ("cliente: Error de escritura de archivo: no_writen menos de 2 \n"); exit(0);}
if((writen(sockid, (char *)&ack,sizeof(ack) ))<0)
{printf("cliente:ack error de escritura: %d\n ", errno(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 la cantidad solicitada.
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>0)
{ no_read = read(sd, ptr, no_left);
if(no_read<0)return(no_read);
if(no_read==0)break;
no _ left-= no _ read
ptr+= no _ lectura;
}
return(size-no _ left );
}
int escrito(int sd , char *ptr, int tamaño)
{ int no_left, no _ escrito
no_left = tamaño
while(no_left>0)
{ no_escrito = escribir(sd,ptr,no_left);
if(no_escrito<=0)return(no_escrito);
no_left-= no_escrito;
ptr+= no_escrito;
no_left-= no_escrito;
ptr+= no_escrito;
p>
}
regresar (size-no_left);
}
Servidor de red informática
# include & ltstdio.h & gt
# include & ltsys /types . h & gt；
# incluir & ltsys/socket .
# incluir & ltnetinet/in . # include & ltarpa/inet . h & gt；
# include & lttime.h & gt
# include & ltError number& gt
#Definir mi puerto ID 6081
#Definir el límite máximo 256
#Definir MAXSIZE 512
#Definir confirmación 2
#Definir NACK 3
#Definir archivo de solicitud 100
#definir comando no admite 150
#Definición de comando compatible 160
#Definir nombre de archivo incorrecto 200
#Definir nombre de archivo OK 400
int writen(int sd, char *ptr, int size
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))< 0)
{printf("Servidor: Socket error: %d\n ", errno); exit(0);}
printf ("servidor: vincular mi 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_ANY) ;
if (. bind(sockid, (struct sockaddr *)&my_addr,sizeof(my_addr))<0)
{printf("Servidor: enlace Error definitivo: %d\n ", errno); 0);}
printf("Servidor: Comience a escuchar\n ");
if (escuchar(sockid, 5)<0)
{ printf(" servidor:escucha error:% d \ n ", errno);}
while(1== 1) {
/*Aceptar la conexión , luego cree un proceso hijo para hacer el trabajo*/
/*Bucle invertido y espere otra conexión*/
printf("Servidor: comience a aceptar\n");
if ((newsd = aceptar(sockid, (struct sockaddr *)& dirección del cliente,
& ampclilen))<0)
{printf(" Servidor: Error de aceptación: %d\n ", errno); exit(0);}
printf("servidor: Devuelto de aceptar, el socket de este ftp: %d\n ",
newsd);
if ( (pid=fork()) == 0) {
/*El subproceso comienza aquí y realizará la transferencia de archivos real. */
close(sockid); /*El niño no debe aceptarlo*/
doftp(newsd);
Close(newsd);
Salir(0);/*Todos los niños han completado su trabajo*/
}
/*Los padres continúan abajo*/
Cerrar (newsd); /*La crianza de los hijos la realiza el cliente, solo los niños*/
} /*Comenzar ahora Se comunicará con este cliente*/
}