file_server

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

#define TEMP_FILE "/tmp/pic_out"
char name_buf[100];
char name_buf_out[100];
char name_buf_in[100];

int recv_file(int new_fd)
{
    int cLen;
    unsigned int img_size, name_size, total_size, in_size;
    unsigned char * buff_in = NULL;

    img_size = 0;
    cLen = recv(new_fd, &img_size, sizeof(img_size),0);
    if((cLen < 0)||(cLen == 0)) {
        printf("file_server: recv img_size failure!\n");
        return -1;
    }

    name_size = 0;
    cLen = recv(new_fd, &name_size, sizeof(name_size),0);
    if((cLen < 0)||(cLen == 0)) {
        printf("file_server: recv name_size failure!\n");
        return -1;
    }

    total_size = img_size+name_size;
    buff_in = (unsigned char *)malloc(total_size);
    if(NULL == buff_in){
        printf("file_server: malloc buff_in failure!\n");
        return -1;
    }

    in_size = 0;
    while(in_size < total_size){
        cLen = recv(new_fd, &buff_in[in_size],total_size - in_size,0);
        if((cLen < 0)||(cLen == 0)) {
            printf("file_server: recv buff_in failure!\n");
            return -1;
        }
        in_size+=cLen;
    }

    memset(name_buf, 0, 100);
    memcpy(name_buf, buff_in, name_size);
    printf("file_server: recv file:%s name_size:%d\n", name_buf, name_size);
    memset(name_buf_in, 0, 100);
    snprintf(name_buf_in, 100, "/tmp/%s", name_buf);
    FILE* out = fopen( name_buf_in, "w+" );
    if ( out == NULL ) {
        printf("file_server: open file %s failed\n", name_buf_in);
        return -1;
    }
    
    fwrite(&buff_in[name_size], img_size, 1, out);
    fclose(out);
    free(buff_in);
    return 0;
}

int send_file(int new_fd)
{
    unsigned char * buff_out = NULL;
    unsigned int img_size = 0;
    unsigned int name_size = 0;
    unsigned int total_size = 0;

    memset(name_buf_out, 0, 100);
    snprintf(name_buf_out, 100, "ldc_%s", name_buf);
    
    char *input = name_buf_out;
    printf("file_server: send file:%s name_size:%d\n", input, strlen(input));

    FILE* out = fopen(TEMP_FILE, "rw+" );
    if ( out == NULL ) {
        printf("file_server: open file %s failed\n", TEMP_FILE);
        return -1;
    }
    fseek(out, 0, SEEK_END);
    img_size = ftell(out);
    fseek(out, 0, SEEK_SET);
    name_size =  strlen(input);

    total_size = img_size + name_size;

    buff_out = (unsigned char *)malloc(total_size);
    if(NULL == buff_out){
        printf("file_server: malloc buff_out failure!\n");
        goto out2;
    }

    if (send(new_fd, &img_size, sizeof(img_size), 0) < 0) {
        printf("file_server: send img_size failure!\n");
        goto out1;
    }

    if (send(new_fd, &name_size, sizeof(name_size), 0) < 0) {
        printf("file_server: send name_size failure!\n");
        goto out1;
    }

    memcpy(buff_out,input, strlen(input));
    fread(&buff_out[strlen(input)], img_size ,1 ,out);
    
    if (send(new_fd, buff_out, total_size, 0) < 0) {
        printf("file_server: send buff_out failure!\n");
        goto out1;
    }

    free(buff_out);
    fclose(out);
    return 0;

out1:
    free(buff_out);
out2:
    fclose(out);
    return -1;
}

int run(void) {
    int sockfd,new_fd;
    struct sockaddr_in my_addr;
    struct sockaddr_in their_addr;
    unsigned int sin_size, myport, lisnum;

    myport = 66;
    lisnum = 1;

    if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }
    printf("file_server: socket %d ok \n",myport);

    my_addr.sin_family=PF_INET;
    my_addr.sin_port=htons(myport);
    my_addr.sin_addr.s_addr = INADDR_ANY;
    bzero(&(my_addr.sin_zero), 0);
    if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {
        perror("bind");
        exit(1);
    }
    printf("file_server: bind ok \n");

    if (listen(sockfd, lisnum) == -1) {
        perror("listen");
        exit(1);
    }
    printf("file_server: listen ok \n");

    while(1) {
        sin_size = sizeof(struct sockaddr_in);
        printf("file_server: start listen \n");
        if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) {
            perror("accept");
            continue;
        }

        printf("file_server: server: got connection from %s\n",inet_ntoa(their_addr.sin_addr));

        if(recv_file(new_fd)){
            close(new_fd);
            continue;
        }

        remove("/tmp/input_name");
        FILE* input_name = fopen( "/tmp/input_name", "w+" );
        if ( input_name == NULL ) {
            printf("file_server: open file %s failed\n", input_name);
            return -1;
        }
        fwrite(name_buf_in, strlen(name_buf_in), 1, input_name);
        fclose(input_name);

        FILE* start_ldc = fopen( "/tmp/start_ldc", "w+" );
        if ( start_ldc == NULL ) {
            printf("file_server: open file %s failed\n", start_ldc);
            return -1;
        }
        fclose(start_ldc);

        int timeout = 0;
        while(1){
            if(access("/tmp/start_send",F_OK)==0){
                break;
            }else{
                usleep(1000000);
                timeout++;
                if(timeout > 10){
                    printf("file_server: timeout\n");
                    close(new_fd);
                    break;
                }
            }
        }

        remove("/tmp/start_send");

        if(send_file(new_fd)){
            close(new_fd);
            continue;
        }

        close(new_fd);
    }
}

int main(int argc, char **argv)
{
    run();
    return 0;
}