Solicite el código fuente java o C++ para el servidor FTP y el cliente FTP.

> printf("cliente: enviar comando de inicio de transferencia\n");

start_xfer = STARTTRANSFER;

start_xfer = htons(start_xfer); write(sockid,(char *)&start_xfer,sizeof(start_xfer)))< 0)

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

}

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

{printf(" cliente: local abierto error de archivo \n");exit(0);}

/* El cliente ahora leerá información del servidor sobre el número máximo de bloques completos que puede esperar. esperado.

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

if((readn(sockid,(char *)&num_blks,sizeof(num_blks)) < 0)

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

num_blks = ntohs(num_blks);

printf(" cliente: el servidor respondió: Hay %d bloques en el archivo",num_blks);

ack = ACK;

ack = htons(ack);

if((write(sockid,(char *)) &ack,sizeof(ack))) < 0)

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

}

if((readn(sockid,(char *)&. num_last_blk,sizeof(num_last_blk))) < 0)

{printf("Cliente: Error de lectura: %d en nbytes\n",errno);exit(0);}

num_last_blk = ntohs( num_last_blk);

printf(" cliente: el servidor respondió: %d bytes último blk\n",num_last_blk);

if(( write(sockid,(char *)&ack,)) sizeof(ack))) < 0)

{printf("client: ack write error :%d\n",errno);exit(0);

}

/ * Comienza a leer el bloque enviado por el servidor* /

printf("cliente: comenzando a obtener el contenido del archivo\n"

for(i= 0; i < num_blks; i ++) {

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

{printf("cliente: error de bloqueo leído: %d\n", errno);salir (0);}

no_writen = fwrite(in_buf,sizeof(char),MAXSIZE,fp

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

if ( no_writen ! = MAXSIZE)

{printf("cliente: error de escritura de archivo: no_writen es menor \n") ;exit(0);}

/* Enviar ACK para este bloque */

if ((writeen( sockid,(char *)&ack,sizeof(ack ))) < 0)

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

(0);}

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

}

/*si HAY UN ÚLTIMO BLOQUE PARCIALMENTE LLENADO , LÉELO */

if (num_last_blk > 0) {

printf("%d\n",num_blks

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

{printf("cliente: Error en el último bloque de lectura: %d\n",errno);exit(0);}

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

if (no_writen == 0)

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

if (no_writen! = num_last_blk)

{printf("cliente: error de escritura de archivo: no_writen es menor 2 \n");salir( 0);}

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

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

}

}

else printf(" \ n");

/*FILE TRANSFER ENDS.CLIENT finaliza después de cerrar todos los archivos

y SOCKETS*/

fclose(fp);

p>

printf("cliente: TRANSFERENCIA DE ARCHIVO COMPLETA/n");

close(sockid);

}

/* Finaliza la transferencia de archivos.

/* Debido a que los límites del búfer en el kernel SOCKET pueden verse afectados, es posible que las lecturas y escrituras devuelvan valores menos positivos que los solicitados.

Por lo tanto, llamamos a los dos procedimientos siguientes para manejar esta excepción */

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); no_read <0) return(no_read);

if (no_read == 0) break;

no_left -= no_read; /p>

}

return(tamaño - no_left);

}

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

{ int no_left,no_write

no_left = tamaño

while (no_left > 0)

{ no_writing = write(sd) ,ptr,no_left);

if(no_escrito <=0) return(no_escrito);

no_escrito -= no_escrito

ptr + = no_escrito;

}

return(size - no_left);

}

Lado del servidor

# incluir

#include

#include

#incluye

#include

#include

#include p >

#define MY_PORT_ID 6081

#define MAXLINE 256

#define MAXSIZE 512

#define ACK 2

# define NACK 3

#define REQUESTFILE 100

#define COMMANDNOTSUPPORTED 150

#define COMMANDSUPPORTED 160

#define BADFILENAME 200

#define FILENAMEOK 400

int writen(int sd, char *ptr, int size); /p>

main() {

int sockid, newsd, pid, clilen;

struct sockaddr_in my_addr, client_addr

printf(" servir

r.creando socket\n");

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

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

printf("servidor: vinculando mi socket local\n");

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

my_addr.sin_family = AF_INET;

my_addr.sin_port = htons(MY_PORT_ID);

my_addr.sin_addr.s_addr = htons( INADDR_ANY);

if (bind(sockid,(struct sockaddr * ) &my_addr,sizeof(my_addr)) < 0)

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

printf("servidor: iniciando escucha\n" );

if (listen(sockid,5) < 0)

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

while(1==1) {

/* ACEPTAR UNA CONEXIÓN Y LUEGO CREAR UN NIÑO PARA HACER EL TRABAJO */

/* VOLVER Y ESPERAR OTRA CONEXIÓN */

printf("server:

printf("servidor: iniciando aceptar\n");

if ((newsd = aceptar(sockid,(struct sockaddr *)) &client_addr,

&clilen)) < 0)

{printf("servidor: aceptar error :%d\n" , errno);

{printf("); servidor: aceptar error :%d\n" , errno); salir(0); }

printf("servidor: regresar de aceptar, socket para este ftp: %d\n",

newsd);

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

/* El proceso hijo comienza aquí.

Realizará una transferencia de archivo real*/

close(sockid); /* El proceso hijo no debe realizar una aceptación*/

doftp(newsd); p> close ( newsd);

exit(0); /* El proceso hijo ha completado su trabajo*/

}

/* El proceso padre continuará a continuación* /

close( newsd); /* El proceso principal ha completado todo el trabajo del cliente, solo el proceso secundario */

}/* Se comunicará con el cliente desde ahora en */

}