套接字程序 - 使用 UDP 的可靠数据传输

Question

I have written code for reliable data transfer in C. Here the client sends the file to the server in chunks of 1024 bytes. And the server writes the packets received into another file.

The program works fine for string file/binary data file. But when I try to copy image file there comes the problem. when I try transferring .jpg file there is no compilation error or run time error. But when I try opening the destination file it says, "could not open image file','error interpreting jpeg file' ' improper call to jpeg library in state 201".

Can anybody look into the codes and suggest any solution?

Here is my client code

#include<stdio.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<netdb.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<arpa/inet.h>

char *itoa(long i,char *s,int dummy_radix)
{
    sprintf(s,"%ld",i);
    return s;
}

int main(int argc, int *argv[])
{
    int sock,length,n;
    struct sockaddr_in server,from;
    struct hostent *hp;
    long int packets =0;
    unsigned char buff[1024] = {0};

    // checking if hostname and the port address is provided //
    if(argc!=3)
    {
        printf("insufficient arguments\n");
        exit(1);
    }

    //create a socket//
    sock = socket(AF_INET,SOCK_DGRAM,0);

    if(sock<0)
    {
        printf("error in opening socket\n");
        return 1;
    }

    //to get  the hostname of the system or the machine//
    hp= gethostbyname(argv[1]);

    if(hp==0)
    {
        printf("Unknown host\n");
        return 1;
    }
    //build the server's IP address //
    bzero((char *)&server,sizeof(server));
    bcopy((char*)hp->h_addr,(char *)&server.sin_addr,hp->h_length);
    server.sin_family = AF_INET;
    server.sin_port =  htons(atoi(argv[2]));
    length = sizeof(server);

    /*open the file that we wish to transfer*/
    FILE *fp = fopen("landscape.jpeg","rb");
    if(fp==NULL)
    {
        printf("file open error");
        return 1;
    }
    fseek(fp,0,SEEK_END); //if exists read the size of the file 
    size_t file_size = ftell(fp);
    fseek(fp,0,SEEK_SET); 

    printf("size of the file is %d\n", file_size);

    /*find the number of packets*/
    packets = (file_size/1024)+1 ;

    /*send the number of packets to the server*/
    itoa(packets,buff,10);
    n = sendto(sock,buff,strlen(buff),0,(struct sockaddr *)&server,sizeof(struct sockaddr));
    if(n<0)
    {
        printf("error in sending message to the serveR");
        return 1;
    }

    /*Read data from file and send it*/
    int packetNum = 0;
    while(1)
    {
        /*First read file in chunks of  1024  bytes */
        int nread = fread(buff,1,1024,fp);
        //printf("Bytes read %d\n",nread);

        /*if read was success ,send data*/
        if(nread>0)
        {
            //printf("data sent now is %s\n",buff);
            n = sendto(sock,buff,strlen(buff),0,(struct sockaddr *)&server,sizeof(struct sockaddr));
            printf("Sending %d, numBytes sent: %d\n", packetNum, n);
            packetNum++;
            if(n<0)
            {
                printf("error in sending message to the server");
                fclose(fp);
                return 1;
            }
        }

        /*There is something tricky going on with the read..
         * Either there was error ,or we reached end of  file.
         */
        if(nread<1024)
        {
            if(feof(fp))
                printf("End of file\n");

            if(ferror(fp))
                printf("Error reading\n");
            break;
        }
    }
    close(sock);
    fclose(fp);

    return 0;
}

Here is my server code

#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<netdb.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<arpa/inet.h>

int main(int argc, char *argv[])
{
    int sock,length,fromlen,n;
    struct sockaddr_in server;
    struct sockaddr_in from;
    char buf[1024];
    char file_buf[1024];
    int packets = 0;
    int received = 0;
    FILE *newfp;
    newfp = fopen("output.jpeg","wb");
    if(newfp==NULL)
    {
        printf("error opening the file\n");
        return 1;
    }    
    if(argc<2)
    {
        fprintf(stderr, "no port number specified\n");
        exit(0);
    }
    sock = socket(AF_INET,SOCK_DGRAM,0);
    if(sock<0)
    {
        printf("error in opening socket\n");
        return 1;
    }
    length = sizeof(server);
    bzero(&server,length);
    server.sin_family= AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons(atoi(argv[1]));
    if(bind(sock,(struct sockaddr*)&server,length)<0)
    {
        printf("cannot bind\n");
        return 1;
    }
    fromlen = sizeof(struct sockaddr_in);
    n = recvfrom(sock,buf,1024,0,(struct sockaddr *)&from,&fromlen);
    if(n<0)
    {
        printf("recvfrom  error\n");
        return 1;
    }

    packets = atoi(buf);
    printf("Num packets expected: %d\n", packets);

    while(received<packets)
    {
        n = recvfrom(sock,buf,sizeof (buf),0,(struct sockaddr *)&from,&fromlen);    

        //printf ("%d\n", n);
        printf("Packet num %d, numBytes received: %d\n", received, n);

        if(n<0)
        {
            printf("recvfrom  error\n");
            return 1;
        }
        //printf("%s",buf);
        if((fwrite(buf,1,n,newfp)) < n)
        {
            printf("error in writing to the file\n");
            return 1;
        }
        received++;
    }
    printf("Finished\n");
    fclose(newfp);
    return 0;
}

Answer 1

1. You are assuming that fread() null-terminates the buffer. It doesn't.
2. You are assuming that the data doesn't contain other nulls: it can.
3. You should use nread instead of strlen(buffer) as the count parameter when sending the file data.
4. The correct test for end of file is not nread < 1024 , which can happen any time: it is nread == 0 .
5. You aren't handling out of sequence packets, or missing or duplicated ones. In fact there is nothing reliable about this code at all. You need sequence numbers in the packets, which are removed when writing the data to the file; you need an ACK or NACK mechanism for missing packets; you need a mechanism that ignores duplicates; ...

You've barely started.