TMDSICE3359: Socket error 10054: occurs after about 1 hour(Again)

/**
 * ftpserver.c
 *
 *   This file contains:                                 ���̃t�@�C���ɂ͎��̂�̂��܂܂�Ă��܂��B
 *   - FTP Server and client implementation               -FTP�T�[�o�[�ƃN���C�A���g�̎���
 *   .
 *   which are relevant for the ftpserver module.         �����ftpserver���W���[���Ɋ֘A���Ă��܂��B
 *
 *   Used Registry entries:
 *        "NETWORK/FTPSERVER/CONFIG/PORT"
 *        "NETWORK/FTPSERVER/CONFIG/LISTEN_TIMEOUT"
 *        "NETWORK/FTPSERVER/USERNAME"
 *        "NETWORK/FTPSERVER/PASSWORD"
 *
 *     Registry write callback:
 *
 */

 /**
  * Include files
  */
#include "ti/transport/ndk/nimu/example/ftpApp/modules.h"

#ifdef FTP_SERVER_MODULE_INCLUDED

#include <ti/csl/csl_error.h>
#include <ti/fs/fatfs/ff.h>
#include <ti/transport/ndk/nimu/example/ftpApp/ftpserver/ftpserver.h>

/*
 * Defines
 */
#define LISTEN_TIMEOUT                        (10000)
#define FTPSERVER_PORT                        (21)

/* Ftpserver task definitions */                                   // Ftpserver�^�X�N��`
#define TASK_FTP_SERVER_STACK_SIZE            (4096)
//#define TASK_FTP_SERVER_STACK_SIZE            (16384)               // �e�X�g �ς�炸
#define TASK_FTP_SERVER_PRIO                (5)
#define TASK_FTP_SERVER_NAME                "FTP Task"

/* Ftpserver client connection task definitions */                 // FTP�T�[�o�[�N���C�A���g�ڑ��^�X�N�̒�`
//#define TASK_FTP_SERVER_CLIENT_STACK_SIZE    (16384)
#define TASK_FTP_SERVER_CLIENT_STACK_SIZE    (32768)                  // �e�X�g
#define TASK_FTP_SERVER_CLIENT_PRIO            (5)
#define TASK_FTP_SERVER_CLIENT_NAME            "FTP-Client Task"

/*
 * Local functions
 */
static void ftpserver_thread_entry(UArg a0, UArg a1);
static void ftpserver_client_thread_entry (UArg a0, UArg a1);
static int32_t ftpserver_parser (io_handler_t *ioh);
static uint16_t port;
static uint32_t listen_timeout;

extern ftp_cmd_handler_t cmd_handler[];

char ftpUser[NAME_AND_PASSWD_LEN];
char ftpPassword[NAME_AND_PASSWD_LEN];

/*
 * ftpserver_init
 */
int32_t ftpserver_init(void)
{
    Task_Handle task;
    Task_Params params;
    Error_Block eb;

    Task_Params_init(&params);
    Error_init(&eb);

    params.priority = TASK_FTP_SERVER_PRIO;
    params.stackSize = TASK_FTP_SERVER_STACK_SIZE;
    params.arg0 = 0;
    params.arg1 = 0;
    
    /* Read data from config (or default values) */             // �\���i�܂��̓f�t�H���g�l�j����f�[�^��ǂݎ��܂�
    port = FTPSERVER_PORT;
    listen_timeout = LISTEN_TIMEOUT;

    task = Task_create(ftpserver_thread_entry, &params, &eb);
    if (task == NULL)
    {
//      UART_printf("Task '%s', creation failed for ftpserver_thread!, Error %s\n", Error_getMsg(&eb));
        return ERROR_TASK_CREATE;
    }

    return ERROR_SUCCESS;
}

/**
 * ftpserver_thread_entry
 *
 * @brief     FTP server main thread. Listen on new connections and spawnes of client connection tasks.
 *            FTP�T�[�o�[�̃��C���X���b�h�B �V�����ڑ��ƃN���C�A���g�ڑ��^�X�N�̐�������b�X�����܂��B
 * @param a0    Not used
 * @param a1    Not used
 *
 * @return        -
 */
void ftpserver_thread_entry(UArg a0, UArg a1)
{

    Task_Params params;
    Error_Block eb;

    struct sockaddr_in server_addr, client_addr;
    SOCKET listen_sock, client_sock;
    int len = sizeof(struct sockaddr_in);
    struct timeval timeout = {10, 0};



    memset(&server_addr, 0, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;                                                                        //TYPE (AF_INET:IP4,AF_INET6)
    server_addr.sin_addr.s_addr = NDK_htonl(0xC0A80249);   // NDK_htonl(INADDR_ANY);                         //IP�A�h���X 192.168.2.73
//  server_addr.sin_addr.s_addr = NDK_htonl(0xC0A8024A);   // NDK_htonl(INADDR_ANY);                         //IP�A�h���X 192.168.2.74
    server_addr.sin_port = NDK_htons(port);                                                                  //�|�[�g 

    fdOpenSession (TaskSelf ());

    if ((listen_sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)                        // SOCKET = socket(int domain, int type, int protocol)
    {                                                                                                        // �C�[�T�l�b�g�\�P�b�g��쐬
        return;
    }

    memset(&server_addr, 0, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr("192.168.2.73");  // 0xC0A80249; //inet_addr("192.168.2.73");
//  server_addr.sin_addr.s_addr = inet_addr("192.168.2.74");  // 0xC0A8024A; //inet_addr("192.168.2.74");
    server_addr.sin_port = NDK_htons(port);

    if (bind(listen_sock, (struct sockaddr*)&server_addr, sizeof(struct sockaddr_in)) == SOCKET_ERROR)       // bind(SOCKET s, struct sockaddr *pName, int len)
    {                                                                                                        // ���O��\�P�b�g�Ƀo�C���h����
        fdClose(listen_sock);
        return;
    }

    if (listen(listen_sock, 5) == SOCKET_ERROR)                                                              // listen(SOCKET s, int maxcon) s:�\�P�b�g maxcon:�L���[�ւ̐ڑ��ő吔
    {                                                                                                        // �\�P�b�g�̐ڑ��v����ҋ@���܂�
        fdClose(listen_sock);
        return;
    }

    /* Set listen timeout to make watchdog work */                                                           // �E�H�b�`�h�b�O��@�\�����邽�߂Ƀ��b�X���^�C���A�E�g��ݒ肷��
    timeout.tv_sec = listen_timeout;
    if (setsockopt(listen_sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) == SOCKET_ERROR)         // setsockopt(SOCKET s, int level, int op, void *pbuf, int bufsize)
    {                                                                                                        // 
        fdClose(listen_sock);
        return;
    }
    UART_printStatus("\n All tests have passed.\n");                                                         // �e�X�g����̍쐬�ɍ��i

    for (;;)
    {
        Task_Handle task;

        if( (client_sock = accept(listen_sock, (struct sockaddr*)&client_addr, &len)) == INVALID_SOCKET)     // SOCKET accept(SOCKET s, struct sockaddr *pName, int *plen)
        {                                                                                                    // �\�P�b�g�Őڑ���󂯓���� 
                                                                                                             // ������ (struct sockaddr*)&client_addr, �Ƀ}�X�^��IP�Ԓn�|�[�g�ԍ���������?
            /* Timeout, Wait a short time and try again */                                                   // �^�C���A�E�g�A���΂炭�҂��Ă���Ď��s���Ă�������
            fdClose (listen_sock);
            Task_sleep (100);
            break;
        }


        Task_Params_init(&params);
        Error_init(&eb);
    
        params.priority = TASK_FTP_SERVER_CLIENT_PRIO;
        params.stackSize = TASK_FTP_SERVER_CLIENT_STACK_SIZE;
        params.arg0 = (UArg)client_sock;
        params.arg1 = 0;


        task = Task_create(ftpserver_client_thread_entry, &params, &eb);                                     // �ڑ������� �^�X�N�쐬 ftpserver_client_thread_entry
        if (task == NULL)
        {
            fdClose(client_sock);
            Task_sleep (100);
            continue;
        }
    }

    // Close the file session
    fdCloseSession(TaskSelf());
}

/**
 * ftpserver_client_thread_entry
 *
 * @brief     FTP server client connection task. Spawned of from the ftp server task                // FTP�T�[�o�[�N���C�A���g�ڑ��^�X�N�B
 *          when a new connection is established                                                    // �V�����ڑ����m�����ꂽ�Ƃ���ftp�T�[�o�[�^�X�N���琶������܂�
 *
 * @param a0    client socket
 * @param a1    Not used
 *
 * @return        -
 */
static void ftpserver_client_thread_entry (UArg a0, UArg a1)
{
    io_handler_t ftpserver;
    SOCKET socket = (SOCKET)a0;
    int32_t opt = 1;

    strcpy (ftpUser, "user");
    strcpy (ftpPassword, "password");

    // Close the file session                                                                       // �t�@�C���Z�b�V������‚���
    fdOpenSession(TaskSelf());

    memset (&ftpserver, 0, sizeof (ftpserver));

    /* Disables the Nagle algorithm for TCP sockets */                                              // TCP�\�P�b�g��Nagle�A���S���Y���𖳌��ɂ��܂�
    if (setsockopt(socket, IPPROTO_TCP, NDK_TCP_NODELAY, &opt, sizeof(opt)) != SOCKET_ERROR)
    {
        ftpserver.authenticated = 0;
        ftpserver.socket = (void *)socket;
        ftpserver.send_buffer = malloc(BUFFER_SIZES);                                               // BUFFER_SIZES = 1024
        ftpserver.receive_buffer = malloc(BUFFER_SIZES);                                            
        ftpserver.current_working_dir_path = malloc(DATA_BUFFER_SIZE);                              // DATA_BUFFER_SIZE=512
        ftpserver.DataBuf = malloc (DATA_BUFFER_SIZE);                                              
        ftpserver.temp = malloc(DATA_BUFFER_SIZE);                                                  

        sprintf (ftpserver.current_working_dir_path, "0:");

        if (ftpserver.send_buffer &&
            ftpserver.receive_buffer &&
            ftpserver.current_working_dir_path &&
            ftpserver.DataBuf &&
            ftpserver.temp)
        {
            ftpserver_parser (&ftpserver);

// �ڑ����(�������̉��)
            if (ftpserver.send_buffer) free (ftpserver.send_buffer);
            if (ftpserver.receive_buffer) free (ftpserver.receive_buffer);
            if (ftpserver.current_working_dir_path) free (ftpserver.current_working_dir_path);
            if (ftpserver.temp) free (ftpserver.temp);
            if (ftpserver.DataBuf) free (ftpserver.DataBuf);
        }
    }
    
    /* Close the client socket */               // �N���C�A���g�\�P�b�g��‚��܂�
    fdClose(socket);
    
    /* Close the file session */                // �t�@�C���Z�b�V������‚���
    fdCloseSession(TaskSelf());
}

/**
 * ftpserver_parser()
 *
 * @brief FTP Server comand parser              // FTP�T�[�o�[�R�}���h �p�[�T�[
 *
 * @params ioh    Pointer to io-structure that contains buffers, socket etc, see          �\�P�b�g�Ȃǂ�܂�io-structure�ւ̃|�C���^�o�b�t�@�B
 *              io_handler_t structure definition.                                        io_handler_t�\���̂̒�`��Q�Ƃ��Ă��������B
 *
 * @return ERROR_SUCCESS
 */
uint8_t EtxBuf[DATA_BUFFER_SIZE] ;
uint8_t ErxBuf[DATA_BUFFER_SIZE];


static int32_t ftpserver_parser (io_handler_t *ioh)
{
    int32_t n, bytes,rlen;
    int     i, EtxBytes;

//    ftp_cmd_handler_t *p;

    /* Respond with welcome message */                                                   // �E�F���J�����b�Z�[�W�ŕԐM���� (�K�v�Ȃ���Εs�v)
    sprintf(ioh->send_buffer,"220 Welcome to TCP-TEST FTP server \r\n");                 // ���M�o�b�t�@�ɕ�����Z�b�g
    bytes = send(ioh->socket, ioh->send_buffer, strlen(ioh->send_buffer), 0);            // �ڑ����ꂽ�\�P�b�g�Ƀf�[�^�𑗐M���� send(SOCKET s, void *pbuf, int size, int flags)
                                                                                         // s:�\�P�b�g pbuf:���M�f�[�^�̂���f�[�^�o�b�t�@ size:�f�[�^�̃T�C�Y �t���O:
                                                                                         // �߂�l:���펞�͑��M������,�G���[���͕��l
    ioh->running = TRUE;
    while (ioh->running)
    {
        n = 0;
        while (1)
        {
            if (n > (BUFFER_SIZES - 2)) break;                                           // ��M�������̐���
            
            bytes = recv(ioh->socket, &ioh->receive_buffer[n], 1, 0);                    // receive byte by byte... (�o�C�g���ƂɎ�M...) recv(SOCKET s, void *pbuf, int size, int flags)
                                                                                         // s:�\�P�b�g pbuf:��M�f�[�^��ۑ�����o�b�t�@ size:�f�[�^�̃T�C�Y �t���O:
            if ( bytes <= 0 ) break;                                                     // // �߂�l:���펞�͎�M������,�G���[���͕��l,����0
//          if (ioh->receive_buffer[n] == '\n')
//          {
//              ioh->receive_buffer[n] = '\0';
//              break;
//          }
//          if (ioh->receive_buffer[n] != '\r') n++; /*ignore CRs*/

            if (++n >=6){
                rlen = (ioh->receive_buffer[4]<<8) + (ioh->receive_buffer[5]);           // Modbus TCP�̓f�[�^���̍ő�256�ȉ� 
                if(n >= (rlen+6)){                                                       // ��M����
                /* Process requested command */                                          // �v�����ꂽ�R�}���h���������
                    for (i = 0; i < rlen; i++){
                        ErxBuf[i] = ioh->receive_buffer[i+6];                            // ��M������R�s�[
                    }
//                  EtxBytes = comm_rtu(&ErxBuf,&EtxBuf,rlen,PORT_ETH);                  // ��M�R�}���h��� & �����̍쐬 (PORT_ETH:CRC�`�F�b�N�����ɂ���)
// Debug ��
// ��������͂��ꂽ�Ƃ��ĉ���������
                    EtxBytes = 11;
                    EtxBuf[0] = 0x01; 
                    EtxBuf[1] = 0x03; 
                    EtxBuf[2] = 0x08; 
                    EtxBuf[3] = 0x01; 
                    EtxBuf[4] = 0x02; 
                    EtxBuf[5] = 0x03; 
                    EtxBuf[6] = 0x04; 
                    EtxBuf[7] = 0x05; 
                    EtxBuf[8] = 0x06; 
                    EtxBuf[9] = 0x07; 
                    EtxBuf[10] = 0x08; 
// Debug ��

                    if(EtxBytes > 0){
                        for (i = 0; i < 4; i++){
                            ioh->send_buffer[i] = ioh->receive_buffer[i];                // MBAP�w�b�_���R�s�[(�G�R�[�o�b�N)
                        }
                        ioh->send_buffer[4] = (EtxBytes>>8) & 0xFF;                      // �f�[�^���T�C�Y(���)
                        ioh->send_buffer[5] = (EtxBytes) & 0xFF;                         // �f�[�^���T�C�Y(����)
                        for (i = 0; i < EtxBytes; i++){
                            ioh->send_buffer[i+6] = EtxBuf[i];                           // �����f�[�^���R�s�[
                        }
                        
                        bytes = send(ioh->socket, ioh->send_buffer, (EtxBytes+6), 0);    // �ڑ����ꂽ�\�P�b�g�Ƀf�[�^�𑗐M���� 
                    }
                    break; 
                }                                              
            }
        }
        if ( bytes <= 0 ) break;

        /* Process requested command */                                                  // �v�����ꂽ�R�}���h���������
//      for (p = &cmd_handler[0]; p->func != NULL; p++)
//      {
//          if (strncmp(ioh->receive_buffer, p->cmd, p->len) == 0)
//          {
//              if (p->func) p->func(ioh);
//              break;
//          }
//      }

        /* Command NOT found! */
//      if (p->func == NULL)
//      {
//          sprintf(ioh->send_buffer,"202 Command not implemented (%s), superfluous at this site. \r\n", ioh->receive_buffer);
//          bytes = send(ioh->socket, ioh->send_buffer, strlen(ioh->send_buffer), 0);
//      }

    }

    return ERROR_SUCCESS;
}

#endif