socket file transfer

//socket file transfer
//copyright by TONAN robot. 2019.
//HeFei, China.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<unistd.h>
#include<signal.h>

#define MAXCHAR           512
#define FILE_PORT         6665
#define FILE_NAME_RECV    "456.txt"
#define FILE_NAME_SEND    "123.txt"
#define SERVER_IP         "192.168.30.115"

#ifndef SERVER
    //#define SERVER
#endif

static bool g_run = true;
static void signalHandler(int sig)
{
    (void)sig;
    g_run = false;
}

#if defined(SERVER)
///Server code:
int main()
{
    signal(SIGTERM, signalHandler);
    signal(SIGINT, signalHandler);

    static int  listenfd;
    struct sockaddr_in  servaddr;
    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }
    printf("----init socket done!----\n");

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(FILE_PORT);

    if( bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)
    {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }
    printf("----bind sucess----\n");

    if(listen(listenfd, 1) == -1)
    {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -3;
    }
    printf("======waiting for client's request======\n");

    char recv_buff[MAXCHAR];
    static int i_recv = 0;
    while(g_run)
    {
        struct sockaddr_in client_addr;
        socklen_t size = sizeof(client_addr);
        int connfd = 0;
        if((connfd = accept(listenfd, (struct sockaddr *)&client_addr, &size)) == -1)
        {
            printf("accept socket error: %s(errno: %d)", strerror(errno), errno);
            exit(-6);
            //continue;
        }
        else
        {
            i_recv = 0;
            printf("server has got connet from client.\n");
        }

        FILE *fr;
        if((fr = fopen(FILE_NAME_RECV, "a") ) == nullptr)
        {
            printf("file not found \n");
        }
        else
        {
            bzero(recv_buff, MAXCHAR);
            long fr_block_sz = 0;
            while((fr_block_sz = recv(connfd, recv_buff, MAXCHAR, 0)) > 0)
            {
                unsigned long fr_block_sz_t = static_cast<unsigned long>(fr_block_sz);
                unsigned long write_sz = fwrite(recv_buff, sizeof(char), fr_block_sz_t, fr);
                if(write_sz < fr_block_sz_t)
                {
                    printf("write error\n");
                }
                bzero(recv_buff, MAXCHAR);
                if(fr_block_sz == 0)
                {
                    printf("fr_block_sz == 0, break \n");
                    break;
                }
                i_recv++;
                //printf("recv times : %d length : %d\n", i_recv, fr_block_sz);
            }

            if(fr_block_sz < 0)
            {
                printf("sth error %ld!\n", fr_block_sz);
                printf("recv socket error: %s(errno: %d) \n", strerror(errno), errno);
            }
            else
            {
                printf("fr_block_sz == 0, recv OK.\n");
            }

            fclose(fr);
        }
    }
    close(listenfd);
    return 0;
}
#else
///Client code:
#include <arpa/inet.h>
int main()
{
    signal(SIGTERM, signalHandler);
    signal(SIGINT, signalHandler);

    /* Variable Definition */
    int sockfd;
    struct sockaddr_in remote_addr;

    /* Get the Socket file descriptor */
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        fprintf(stderr, "ERROR: Failed to obtain Socket Descriptor! (errno = %d)\n", errno);
        exit(1);
    }

    /* Fill the socket address struct */
    remote_addr.sin_family = AF_INET;
    remote_addr.sin_port = htons(FILE_PORT);
    inet_pton(AF_INET, SERVER_IP, &remote_addr.sin_addr);
    bzero(&(remote_addr.sin_zero), 8);

    /* Try to connect the remote */
    if (connect(sockfd, (struct sockaddr *)&remote_addr, sizeof(struct sockaddr)) == -1)
    {
        fprintf(stderr, "ERROR: Failed to connect to the host! (errno = %d)\n", errno);
        exit(-1);
    }
    else
    {
        printf("[Client] Connected to server at port %d...ok!\n", FILE_PORT);
    }

    /* Send File to Server */
    printf("[Client] Sending %s to the Server... ", FILE_NAME_SEND);
    FILE *fs = fopen(FILE_NAME_SEND, "r");
    if(fs == nullptr)
    {
        printf("ERROR: File %s not found.\n", FILE_NAME_SEND);
        exit(-2);
    }

    char sdbuf[MAXCHAR];
    bzero(sdbuf, MAXCHAR);
    unsigned long fs_block_sz;
    while((fs_block_sz = fread(sdbuf, sizeof(char), MAXCHAR, fs)) > 0)
    {
        if(send(sockfd, sdbuf, fs_block_sz, 0) < 0)
        {
            fprintf(stderr, "ERROR: Failed to send file %s. (errno = %d)\n", FILE_NAME_SEND, errno);
            break;
        }
        bzero(sdbuf, MAXCHAR);
    }

    //shutdown(sockfd, SHUT_WR);
    printf("Ok File %s from Client was Sent!\n", FILE_NAME_SEND);
    close(sockfd);
    printf("[Client] Connection close.\n");
    return (0);
}
#endif