branches/RB-1.1/ftpget.c

/*

    libftp 1.0 (stable): this is an FTP library to simplify the work to a Developer
    who want to work with FTP servers (RFC 959).
    Copyright (C) 2007/2008  omnipresent - omnipresent[at]email.it

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>

*/

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#include <time.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <netdb.h>
#include <fcntl.h>

#include "ftp_main.h"

/*** 
     ftp_get:
        - int sck        => Socket Descriptor
        - char *FileName => The file name that you want to download
        - int verbose    => Verbose?
           . 0 Do not Print
           . 1 Print
        - ret            => Success?
           . 0 Success
           .-1 Error
***/

#define DATA_CONNECTION_ERROR   -3
#define WRONG_DATA_P            -3
#define USR_TOO_LONG            -2

time_t res_get;

int ftp_get (int sck, char *FileName, int verbose)
{
    char *buffer;
    int n = 0;
    int flags;
    time_t start, end;
    int sock;
    int con_err = 0;
    FILE *fd;
    char buff[4096];
    int n_bytes;
    int n_recv=0;


    extern int data_port;
    extern struct sockaddr_in ftp_connection;


    buffer = (char *)malloc(4092*sizeof(char));
    if (buffer == NULL) {
        printf("Unable to alloc 4092 bytes to buffer (ftp_get)\n");
        return -1;
    }

    memset(buffer, 0x0, 4092);


    if (data_port == 0) {

        free(buffer);
        
        return WRONG_DATA_P;

    }

    if (strlen(FileName) > 1024) {

        return USR_TOO_LONG;

    }

    sprintf(buffer, "RETR %s\r\n", FileName);

    if (write(sck, buffer, strlen(buffer)) == -1) {

        if (verbose) {
            if (errno == EBADF) {
                fprintf(stderr, "Socket Descriptor Not Valid!\n");
                free(buffer);
                
                return -1;

            } else if (errno == EIO) {

                fprintf(stderr, "I/O Error!\n");
                free(buffer);
                
                return -1;

            } else if (errno == EINTR) {

                fprintf(stderr, "Signal Interrupted The write() Function\n");
                free(buffer);
                
                return -1;
            }

        } else {

            if (errno == EBADF) {
                free(buffer);
                
                return -1;

            } else if (errno == EIO) {
                free(buffer);
                
                return -1;

            } else if (errno == EINTR) {
                free(buffer);
                
                return -1;
            }

        }

        free(buffer);
                
        return -1;

    }

    memset(buffer, 0x0, 4092);

    sleep(1);
    n = recv(sck, buffer, 4092, MSG_DONTWAIT);

    if (strlen(buffer) != 0) {

        if (ftp_file_handler (buffer, 0) != 0) {
            free(buffer);
        
            return 1;
        }

    }


    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == -1) {
        free(buffer);
        if (verbose) {
            perror("Socket");
        }
        return -1;
    }


    ftp_connection.sin_port = htons(data_port);


    if ( (con_err = connect(sock, (struct sockaddr *)&ftp_connection, sizeof(struct sockaddr)) ) != 0)  {
        if (con_err == ECONNREFUSED) {
            free(buffer);

            return -1;          
        }

        data_port = 0;
        if (verbose) {
            perror("connect");
        }

        free(buffer);

        return -1;
    }

    if ( (flags=fcntl(sock, F_GETFL,0)) < 0) {
        printf("--[ fcntl get flags error.\n");
        exit(1);
    }

    flags |= O_NONBLOCK;

    if ( fcntl (sock, F_SETFL, flags ) < 0 ) {
        printf("--[ Non Blocking Socket Error.\n");
        exit(1);
    }

    buff[4095] = '\0';

    fd = fopen(FileName, "wb");
                
    if (fd == NULL) {
        if (verbose) {
            printf("--[ Error: Unable to open '%s' in ftp_get function\n", FileName);
        }

        free(buffer);
                
        return -1;
    }

    time(&start);

    while (1) {

        usleep(150);
        n_recv = recv(sock, buff, 4094, 0);
        if( n_recv < 0 ) {
            if( errno == EAGAIN ) continue;
            break;
        }
        n_bytes = fwrite(buff, sizeof(char), n_recv, fd);
                
        if (n_recv == 0) {
            break;
        }

        n_recv = 0;

        memset(buff, 0x0, n_bytes);
                
    }

        
    fclose(fd);
    close(sock);

        
    memset(buffer, 0x0, 4092);

    while (1) {

        sleep(1);
        n = recv(sck, buffer, 4092, MSG_DONTWAIT);
        if (n == 0)
            break;

        if (n < 0) {

            if ( (errno == ESPIPE) || (errno == EAGAIN) ) {
                break;
            }

            if (verbose) {
                printf("--[ Error: Error in ftp_get() while getting the file\n");
            }
            free(buffer);
        

            return -1;
                
        }

        buffer[n] = '\0';

                
        n = 0;
        memset(buffer, 0x0, 4092);

    }

    memset(buffer, 0x0, 4092);

    time(&end);

    res_get = (int)(end - start);
        
    free(buffer);


    return 0;
}