tftpc.c

tftp-1.0源码

                            }
                            /*if (debug)
                              ip_port(server); */
                        }
                        /* from here we will loop back and resend */
                    }
                    else
                    {
                        if (debug)
                            printf
                                ("Client: Remote host successfully ACK'd (#%d)\n",
                                 rcount);
                        break;
                    }
                }
                for (i = 0; i <= bcount; i++)
                {
                    if (sendto (sock, packetbuf[i], len, 0, (struct sockaddr *) &server, sizeof (server)) != len)	/* resend the data packet */
                    {
                        if (debug)
                            printf ("Client: Mismatch in number of sent bytes\n");
                        return;
                    }
                    if (debug)
                    {
                        printf ("Client: Ack(s) lost. Resending: %d\n",
                                count - bcount + i);
                        ip_port (server);
                    }
                }
                if (debug)
                    printf ("Client: Ack(s) lost. Resending complete.\n");

            }
            /* The ack sending 'for' loop ends here */

        }
        else if (debug)
        {
            printf
                ("Client: Not attempting to recieve ack. Not required. count: %d\n",
                 count);
            n = recvfrom (sock, recvbuf, sizeof (recvbuf), MSG_DONTWAIT, (struct sockaddr *) &ack, (socklen_t *) & server_len);	/* just do a quick check incase the remote host is trying with ackfreq = 1 */
            /*if (debug)
              ip_port(ack); */
        }

        if (j == RETRIES)
        {
            if (debug)
                printf ("Client: Ack Timeout. Aborting transfer\n");
            fclose (fp);

            return;
        }
        if (ssize != datasize)
            break;

        memset (filebuf, 0, sizeof (filebuf));	/* fill the filebuf with zeros so that when the fread fills it, it is a null terminated string */
    }

    fclose (fp);
    if (debug)
        printf ("Client: File sent successfully\n");

    return;
}				//end of tsend function


/*
*This function is called when the client would like to download a file from the server.
*/
void
tget (char *pFilename, struct sockaddr_in server, char *pMode, int sock)
{
    /* local variables */
    int len, server_len, opcode, i, j, n, tid = 0, flag = 1;
    unsigned short int count = 0, rcount = 0;
    unsigned char filebuf[MAXDATASIZE + 1];
    unsigned char packetbuf[MAXDATASIZE + 12];
    extern int errno;
    char filename[128], mode[12], *bufindex, ackbuf[512];
    struct sockaddr_in data;
    FILE *fp;			/* pointer to the file we will be getting */

    strcpy (filename, pFilename);	//copy the pointer to the filename into a real array
    strcpy (mode, pMode);		//same as above


    if (debug)
        printf ("branched to file receive function\n");

    fp = fopen (filename, "w");	/* open the file for writing */
    if (fp == NULL)
    {				//if the pointer is null then the file can't be opened - Bad perms 
        if (debug)
            printf ("Client requested bad file: cannot open for writing (%s)\n",
                    filename);
        return;
    }
    else				/* File is open and ready to be written to */
    {
        if (debug)
            printf ("Getting file... (destination: %s) \n", filename);
    }
    /* zero the buffer before we begin */
    memset (filebuf, 0, sizeof (filebuf));
    n = datasize + 4;
    do
    {
        /* zero buffers so if there are any errors only NULLs will be exposed */
        memset (packetbuf, 0, sizeof (packetbuf));
        memset (ackbuf, 0, sizeof (ackbuf));
        if (n != (datasize + 4))	/* remember if our datasize is less than a full packet this was the last packet to be received */
        {
            if (debug)
                printf
                    ("Last chunk detected (file chunk size: %d). exiting while loop\n",
                     n - 4);
            len = sprintf (ackbuf, "%c%c%c%c", 0x00, 0x04, 0x00, 0x00);
            ackbuf[2] = (count & 0xFF00) >> 8;	//fill in the count (top number first)
            ackbuf[3] = (count & 0x00FF);	//fill in the lower part of the count
            if (debug)
                printf ("Sending ack # %04d (length: %d)\n", count, len);
            if (sendto
                    (sock, ackbuf, len, 0, (struct sockaddr *) &server,
                     sizeof (server)) != len)
            {
                if (debug)
                    printf ("Mismatch in number of sent bytes\n");
                return;
            }
            if (debug)
                printf ("The Client has sent an ACK for packet\n");
            goto done;		/* gotos are not optimal, but a good solution when exiting a multi-layer loop */
        }

        count++;

        for (j = 0; j < RETRIES; j++)	/* this allows us to loop until we either break out by getting the correct ack OR time out because we've looped more than RETRIES times */
        {
            server_len = sizeof (data);
            errno = EAGAIN;	/* this allows us to enter the loop */
            n = -1;
            for (i = 0; errno == EAGAIN && i <= TIMEOUT && n < 0; i++)	/* this for loop will just keep checking the non-blocking socket until timeout */
            {

                n =
                    recvfrom (sock, packetbuf, sizeof (packetbuf) - 1,
                            MSG_DONTWAIT, (struct sockaddr *) &data,
                            (socklen_t *) & server_len);
                usleep (1000);
            }
            /*if(debug)
              ip_port (data);  print the vlaue recived from the server */
            if (!tid)
            {
                tid = ntohs (data.sin_port);	//get the tid of the server.
                server.sin_port = htons (tid);	//set the tid for rest of the transfer 
            }

            if (n < 0 && errno != EAGAIN)	/* this will be true when there is an error that isn't the WOULD BLOCK error */
            {
                if (debug)
                    printf
                        ("The server could not receive from the client (errno: %d n: %d)\n",
                         errno, n);

                //resend packet
            }
            else if (n < 0 && errno == EAGAIN)	/* this is true when the error IS would block. This means we timed out */
            {
                if (debug)
                    printf ("Timeout waiting for data (errno: %d == %d n: %d)\n",
                            errno, EAGAIN, n);
                //resend packet
            }
            else
            {
                if (server.sin_addr.s_addr != data.sin_addr.s_addr)	/* checks to ensure get from ip is same from ACK IP */
                {
                    if (debug)
                        printf
                            ("Error recieving file (data from invalid address)\n");
                    j--;
                    continue;	/* we aren't going to let another connection spoil our first connection */
                }
                if (tid != ntohs (server.sin_port))	/* checks to ensure get from the correct TID */
                {
                    if (debug)
                        printf ("Error recieving file (data from invalid tid)\n");
                    len = sprintf ((char *) packetbuf,
                            "%c%c%c%cBad/Unknown TID%c",
                            0x00, 0x05, 0x00, 0x05, 0x00);
                    if (sendto (sock, packetbuf, len, 0, (struct sockaddr *) &server, sizeof (server)) != len)	/* send the data packet */
                    {
                        printf
                            ("Mismatch in number of sent bytes while trying to send mode error packet\n");
                    }
                    j--;
                    continue;	/* we aren't going to let another connection spoil our first connection */
                }
                /* this formatting code is just like the code in the main function */
                bufindex = (char *) packetbuf;	//start our pointer going
                if (bufindex++[0] != 0x00)
                    printf ("bad first nullbyte!\n");
                opcode = *bufindex++;
                rcount = *bufindex++ << 8;
                rcount &= 0xff00;
                rcount += (*bufindex++ & 0x00ff);
                memcpy ((char *) filebuf, bufindex, n - 4);	/* copy the rest of the packet (data portion) into our data array */
                if (debug)
                    printf
                        ("Remote host sent data packet #%d (Opcode: %d packetsize: %d filechunksize: %d)\n",
                         rcount, opcode, n, n - 4);
                if (flag)
                {
                    if (n > 516)
                        datasize = n - 4;
                    else if (n < 516)
                        datasize = 512;
                    flag = 0;
                }
                if (opcode != 3)	/* ack packet should have code 3 (data) and should be ack+1 the packet we just sent */
                {
                    if (debug)
                        printf
                            ("Badly ordered/invalid data packet (Got OP: %d Block: %d) (Wanted Op: 3 Block: %d)\n",
                             opcode, rcount, count);
                    /* sending error message */
                    if (opcode > 5)
                    {
                        len = sprintf ((char *) packetbuf,
                                "%c%c%c%cIllegal operation%c",
                                0x00, 0x05, 0x00, 0x04, 0x00);
                        if (sendto (sock, packetbuf, len, 0, (struct sockaddr *) &server, sizeof (server)) != len)	/* send the data packet */
                        {
                            printf
                                ("Mismatch in number of sent bytes while trying to send mode error packet\n");
                        }
                    }
                }
                else
                {
                    len = sprintf (ackbuf, "%c%c%c%c", 0x00, 0x04, 0x00, 0x00);
                    ackbuf[2] = (count & 0xFF00) >> 8;	//fill in the count (top number first)
                    ackbuf[3] = (count & 0x00FF);	//fill in the lower part of the count
                    if (debug)
                        printf ("Sending ack # %04d (length: %d)\n", count, len);
                    if (((count - 1) % ackfreq) == 0)
                    {
                        if (sendto
                                (sock, ackbuf, len, 0, (struct sockaddr *) &server,
                                 sizeof (server)) != len)
                        {
                            if (debug)
                                printf ("Mismatch in number of sent bytes\n");
                            return;
                        }
                        if (debug)
                            printf ("The client has sent an ACK for packet %d\n",
                                    count);
                    }		//check for ackfreq
                    else if (count == 1)
                    {
                        if (sendto
                                (sock, ackbuf, len, 0, (struct sockaddr *) &server,
                                 sizeof (server)) != len)
                        {
                            if (debug)
                                printf ("Mismatch in number of sent bytes\n");
                            return;
                        }
                        if (debug)
                            printf ("The Client has sent an ACK for packet 1\n");
                    }
                    break;
                }		//end of else
            }
        }
        if (j == RETRIES)
        {
            if (debug)
                printf ("Data recieve Timeout. Aborting transfer\n");
            fclose (fp);
            return;
        }
    }
    while (fwrite (filebuf, 1, n - 4, fp) == n - 4);	/* if it doesn't write the file the length of the packet received less 4 then it didn't work */
    fclose (fp);
    sync ();
    if (debug)
        printf
            ("fclose and sync unsuccessful. File failed to recieve properly\n");
    return;

done:

    fclose (fp);
    sync ();
    if (debug)
        printf ("fclose and sync successful. File received successfully\n");
    return;
}