diff --git a/mbtk/libmbtk_ftp/mbtk_ftp.c b/mbtk/libmbtk_ftp/mbtk_ftp.c
new file mode 100755
index 0000000..2821087
--- /dev/null
+++ b/mbtk/libmbtk_ftp/mbtk_ftp.c
@@ -0,0 +1,3058 @@
+/*************************************************************
+ Description:
+ $file_description$
+ Author:
+ LiuBin
+ Date:
+ 2020/10/28 11:49:08
+ *************************************************************/
+#include "mbtk_ftp.h"
+#include "mbtk_list.h"
+#include "mbtk_sock.h"
+#include "mbtk_str.h"
+#include "mbtk_sock2.h"
+#include<linux/msg.h>
+
+/*************************************************************
+ Constants and Macros
+ *************************************************************/
+#define FTP_HANDLE_MAX 5
+#define FTP_ANONYMOUS_USER "Anonymous"
+#define FTP_ANONYMOUS_PASS "@"
+
+//#define FTP_RESUME_DEBUG
+
+#ifdef MBTK_PLATFORM_QCOMM
+#define FTP_TIMEOUT 60000    // 60s
+#else
+#define FTP_TIMEOUT 3000    // 3s
+#endif
+
+/*************************************************************
+ typedef struct:local at
+ *************************************************************/
+typedef struct
+{
+    char host[64];
+    uint16 port;
+    mbtk_ftp_auth_type_enum auth_type;
+    bool ftp_type;
+    bool use_cert;
+    char name[FTP_SERVER_USER_NAME_MAX+1];
+    char pass[FTP_SERVER_USER_PASS_MAX+1];
+    mbtk_ftp_handle at_ftp_handle;
+    char remote_path[MBTK_FTP_FILE_NAME_MAX+1];
+    char local_path[MBTK_FTP_FILE_NAME_MAX+1];
+    int rest_size;
+    int read_size;
+    int put_len;
+} mbtk_at_init_parameter;
+
+mbtk_at_init_parameter mbtk_at_ftp_par={0};
+
+/*************************************************************
+ Variables:local
+ *************************************************************/
+static list_node_t *ftp_client_list = NULL;
+
+/*************************************************************
+ Variables:public
+ *************************************************************/
+
+/*************************************************************
+ Local Function Declaration
+ *************************************************************/
+
+/*************************************************************
+ Local Function Definitions
+ *************************************************************/
+static bool ftp_ch_is_space(char ch)
+{
+    if (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t')
+        return true;
+
+    return false;
+}
+
+static const char* ftp_str_next(const char* str, char *result, uint32 len)
+{
+    memset(result, 0x0, len);
+    const char* ptr = str;
+    const char* ptr_result;
+    while (*ptr && ftp_ch_is_space(*ptr))
+    {
+        ptr++;
+    }
+    if (*ptr == '\0')
+    {
+        return NULL;
+    }
+    // Point to first no space char.
+    ptr_result = ptr;
+    while (*ptr && !ftp_ch_is_space(*ptr))
+    {
+        ptr++;
+    }
+
+    // Point to first space char or '\0'.
+    memcpy(result, ptr_result, ptr - ptr_result);
+
+    if (*ptr == '\0')
+    {
+        return NULL;
+    }
+
+    return ptr;
+}
+
+static int ftp_cmd_handle(mbtk_ftp_info_s *info, const void *cmd, void *rsp,
+                          uint32 *rsp_len)
+{
+    int err;
+    int rsp_code;
+    int len = strlen((char*) cmd);
+    // Write cmd
+    if(info->auth_type != 0)
+    {
+        mbtk_sock_write(info->ftp_ssl_handle,info->session,cmd,len,60000,&err);
+        if(err!=0)
+        {
+            printf("\nmbtk_sock_write error:%d\n",err);
+            return err;
+        }
+    }
+    else
+    {
+        if (sock_write(&info->net_info, &info->sock_info[FTP_SOCK_CTRL], cmd, len, 60000, &err)
+            != len)
+        {
+            LOGE("Socket write fail[err = %d].", err);
+            return -1;
+        }
+    }
+
+    // Read cmd response
+    if (rsp != NULL && *rsp_len > 0)
+    {
+    read_angin_1:
+        memset(rsp, 0x0, *rsp_len);
+        if(info->auth_type != 0)
+        {
+            unsigned char mbtk_ftp_ssl_read_buf[16384 + 1];
+            len = mbtk_sock_read(info->ftp_ssl_handle,info->session,mbtk_ftp_ssl_read_buf,sizeof(mbtk_ftp_ssl_read_buf),FTP_TIMEOUT,&err);
+            if(err != 0)
+            {
+                printf("\n mbtk_sock_read error:%d \n",err);
+            }
+            rsp_code = atoi(mbtk_ftp_ssl_read_buf);
+            printf("%s -> Code:%d; RSP:%s\n", (char*)cmd, rsp_code, (char* )mbtk_ftp_ssl_read_buf);
+            if (rsp_code == 0)
+            {
+                goto read_angin_1;
+            }
+            memcpy((char* )rsp, mbtk_ftp_ssl_read_buf, strlen(mbtk_ftp_ssl_read_buf));
+            //printf("\nrsp = %s\n",(char* )rsp);
+            return rsp_code;
+        }
+        else
+        {
+            len = sock_readline(&info->net_info, &info->sock_info[FTP_SOCK_CTRL], rsp, *rsp_len, FTP_TIMEOUT,&err);
+        }
+        if (len <= 0)
+        {
+            LOGE("Socket read fail[len = %d].", len);
+            return -1;
+        }
+        rsp_code = atoi(rsp);
+        LOGI("%s -> Code:%d; RSP:%s", (char*)cmd, rsp_code, (char* )rsp);
+        //log_hex("FTP_RSP",(char* )rsp,len);
+
+        if (rsp_code == 0)
+        {
+            goto read_angin_1;
+        }
+
+        *rsp_len = len;
+    }
+    else
+    {
+        char buff[1024];
+
+    read_angin_2:
+        memset(buff, 0x0, 1024);
+        if(info->auth_type != 0)
+        {
+            unsigned char mbtk_ftp_ssl_read_buf[16384 + 1];
+            len = mbtk_sock_read(info->ftp_ssl_handle,info->session,mbtk_ftp_ssl_read_buf,sizeof(mbtk_ftp_ssl_read_buf),FTP_TIMEOUT,&err);
+            if(err != 0)
+            {
+                printf("\nmbtk_sock_read error:%d\n",err);
+            }
+            rsp_code = atoi(mbtk_ftp_ssl_read_buf);
+            printf("%s -> Code:%d; RSP:%s\n", (char*)cmd, rsp_code, (char* )mbtk_ftp_ssl_read_buf);
+            char *mbtk_ftp_ssl_read_buf_p = NULL;
+            mbtk_ftp_ssl_read_buf_p = strstr(mbtk_ftp_ssl_read_buf,"\n");
+            if(mbtk_ftp_ssl_read_buf_p!=NULL);
+            {
+                if(strlen(mbtk_ftp_ssl_read_buf_p)>1)
+                {
+                    mbtk_ftp_ssl_read_buf_p++;
+                    rsp_code = atoi(mbtk_ftp_ssl_read_buf_p);
+                }
+            }
+            if (rsp_code == 0)
+            {
+                goto read_angin_2;
+            }
+            return rsp_code;
+        }
+        else
+        {
+            len = sock_readline(&info->net_info, &info->sock_info[FTP_SOCK_CTRL], buff, 1024, FTP_TIMEOUT,
+                            &err);
+        }
+        if (len <= 0)
+        {
+            LOGE("Socket read fail[len = %d].", len);
+            return -1;
+        }
+
+        rsp_code = atoi(buff);
+        LOGI("%s -> Code:%d; RSP:%s", (char*)cmd, rsp_code, buff);
+        //log_hex("FTP_RSP",buff,len);
+
+        if (rsp_code == 0)
+        {
+            goto read_angin_2;
+        }
+    }
+
+    return rsp_code;
+}
+
+// Create data socket service and waitting client connect.
+static mbtk_ftp_error_enum ftp_data_sock_service_create(mbtk_ftp_sock_s *sock)
+{
+    return FTP_ERR_SUCCESS;
+}
+
+static bool ftp_internal_ipv4_check(void *ipv4)
+{
+    char *ip = (char*) ipv4;
+    int ip1 = atoi(ip);
+    ip = strstr(ip, ".");
+    if (!ip)
+        return FALSE;
+    int ip2 = atoi(ip + 1);
+
+    if (ip1 == 10)   // 10.x.x.x
+    {
+        return TRUE;
+    }
+    else if (ip1 == 172 && (ip2 >= 16 && ip2 <= 31))     // 172.16.0.0 ~ 172.31.255.255
+    {
+        return TRUE;
+    }
+    else if (ip1 == 192 && ip2 == 168)     // 192.168.x.x
+    {
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+static mbtk_ftp_error_enum ftp_sock_set_by_port(mbtk_ftp_info_s *info,
+        mbtk_ftp_sock_s *sock)
+{
+    // port = port1 * 256 + port2
+    // "PORT ip1,ip2,ip3,ip4,port1,port2\r\n"
+    int code;
+    char cmd_buff[100];
+    memset(cmd_buff, 0x0, 100);
+    if (info->sock_info[FTP_SOCK_CTRL].addr_family == MBTK_ADDR_IPV6 || sock->port <= 1024
+        || strlen((char*) sock->host) == 0)
+    {
+        LOGE("FTP params set error.");
+        return FTP_ERR_PARAM_SET;
+    }
+
+    if (ftp_data_sock_service_create(sock) != FTP_ERR_SUCCESS)
+    {
+        LOGE("FTP data services create fail.");
+        return FTP_ERR_UNKNOWN;
+    }
+
+    uint8 *ptr = sock->host;
+    while (*ptr)
+    {
+        if (*ptr == '.')
+            *ptr = ',';
+        ptr++;
+    }
+    // Waitting client connect.
+    snprintf(cmd_buff, 100, "PORT %s,%d,%d\r\n", sock->host, sock->port / 256,
+             sock->port % 256);
+    code = ftp_cmd_handle(info, cmd_buff, NULL, NULL);
+    if (code / 100 != 2)   // Not 2xx
+    {
+        LOGE("PORT rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_sock_set_by_eprt(mbtk_ftp_info_s *info,
+        mbtk_ftp_sock_s *sock)
+{
+    int code;
+    char cmd_buff[100];
+    memset(cmd_buff, 0x0, 100);
+    if (sock->port <= 1024 || strlen((char*) sock->host) == 0)
+    {
+        LOGE("FTP params set error.");
+        return FTP_ERR_PARAM_SET;
+    }
+    if (ftp_data_sock_service_create(sock) != FTP_ERR_SUCCESS)
+    {
+        LOGE("FTP data services create fail.");
+        return FTP_ERR_UNKNOWN;
+    }
+
+    // "EPRT |2|1080::8:800:200C:417A|5282|"
+    if (info->sock_info[FTP_SOCK_CTRL].addr_family == MBTK_ADDR_IPV6)
+    {
+        uint8 *ptr = NULL;
+        if (sock->host[strlen((char*) sock->host) - 1] == ']')
+            sock->host[strlen((char*) sock->host) - 1] = '\0';
+
+        if (sock->host[0] == '[')
+            ptr = sock->host + 1;
+        else
+            ptr = sock->host;
+        snprintf(cmd_buff, 100, "EPRT |2|%s|%d|\r\n", ptr, sock->port);
+    }
+    else       // IPV4 "EPRT |1|132.235.1.2|6275|"
+    {
+        snprintf(cmd_buff, 100, "EPRT |1|%s|%d|\r\n", sock->host, sock->port);
+    }
+
+    code = ftp_cmd_handle(info, cmd_buff, NULL, NULL);
+    if (code / 100 != 2)   // Not 2xx
+    {
+        LOGE("PORT rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_sock_get_by_pasv(mbtk_ftp_info_s *info,
+        mbtk_ftp_sock_s *sock)
+{
+    int code;
+    uint8 rsp[1024];
+    uint32 rsp_len = 1024;
+    memset(sock, 0x0, sizeof(mbtk_ftp_sock_s));
+    code = ftp_cmd_handle(info, "PASV\r\n", rsp, &rsp_len);
+    /* Found reply-strings include:
+     * "227 Entering Passive Mode (127,0,0,1,4,51)"
+     * "227 Data transfer will passively listen to 127,0,0,1,4,51"
+     * "227 Entering passive mode. 127,0,0,1,4,51"
+     */
+    if (code != 227)
+    {
+        LOGE("PASV rsp error[code = %d].", code);
+        if(code == 421)
+        {
+            printf("\n code:%d\n",code);
+            return FTP_ERR_UNKNOWN+1;
+        }
+        return FTP_ERR_UNKNOWN;
+    }
+
+    // Get IPv4 and port
+    uint8 *ptr = rsp + 4;
+    while (*ptr)
+    {
+        if (isdigit(*ptr))
+            break;
+        ptr++;
+    }
+    // ptr point to first digit.
+    memcpy(sock->host, ptr, strlen((char*) ptr));
+    ptr = sock->host;
+    int count = 0;
+    while (*ptr)
+    {
+        if (*ptr == ',')
+        {
+            *ptr = '.';
+            count++;
+        }
+        if (count == 4)
+        {
+            *ptr = '\0';
+            break;
+        }
+        ptr++;
+    }
+    ptr++;
+
+    // ptr point to first port digit.
+    int port1 = atoi((char*) ptr);
+    while (*ptr)
+    {
+        if (*ptr == ',')
+            break;
+        ptr++;
+    }
+    ptr++;
+
+    // ptr point to second port digit.
+    int port2 = atoi((char*) ptr);
+    sock->port = port1 * 256 + port2;
+
+    LOGI("PASV: %s:%d", sock->host, sock->port);
+
+    if(ftp_internal_ipv4_check(sock->host))
+    {
+        memset(sock->host,0x0,MBTK_FTP_IP_MAX + 1);
+        memcpy(sock->host,info->sock_info[FTP_SOCK_CTRL].host,strlen(info->sock_info[FTP_SOCK_CTRL].host));
+        LOGI("This is internal ipv4,so use IP - %s:%d",sock->host, sock->port);
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_sock_get_by_epsv(mbtk_ftp_info_s *info,
+        mbtk_ftp_sock_s *sock)
+{
+    int code;
+    char rsp[1024];
+    uint32 rsp_len = 1024;
+    memset(sock, 0x0, sizeof(mbtk_ftp_sock_s));
+    // |||6446|
+    code = ftp_cmd_handle(info, "EPSV\r\n", rsp, &rsp_len);
+    if (code != 229)
+    {
+        LOGE("EPSV rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    /* positive EPSV response */
+    char *ptr = strchr(rsp, '(');
+    if (ptr)
+    {
+        unsigned int num;
+        char separator[4];
+        ptr++;
+        if (5
+            == sscanf(ptr, "%c%c%c%u%c", &separator[0], &separator[1],
+                      &separator[2], &num, &separator[3]))
+        {
+            const char sep1 = separator[0];
+            int i;
+
+            /* The four separators should be identical, or else this is an oddly
+             formatted reply and we bail out immediately. */
+            for (i = 1; i < 4; i++)
+            {
+                if (separator[i] != sep1)
+                {
+                    ptr = NULL; /* set to NULL to signal error */
+                    break;
+                }
+            }
+            if (num > 0xffff)
+            {
+                LOGE("Illegal port number in EPSV reply");
+                return FTP_ERR_UNKNOWN;
+            }
+            if (ptr)
+            {
+                sock->port = (uint32) (num & 0xffff);
+                memcpy(sock->host, info->sock_info[FTP_SOCK_CTRL].host,
+                       strlen(info->sock_info[FTP_SOCK_CTRL].host));
+            }
+        }
+        else
+        {
+            ptr = NULL;
+        }
+    }
+    if (!ptr)
+    {
+        LOGE("Weirdly formatted EPSV reply");
+        return FTP_ERR_UNKNOWN;
+    }
+
+    LOGI("PASV: %s:%d", sock->host, sock->port);
+
+    return FTP_ERR_SUCCESS;
+}
+
+/*
+ * 04-26-20  02:13PM               379193 audio_0426.zip
+ * 09-10-20  02:31PM              4660645 Log.zip
+ * 10-28-20  01:53PM       <DIR>          PicLibs
+ */
+
+ /*
+ *-rw-r--r-- 1 ftp ftp     2097152000 Feb 18 17:28 ASR1803_Linux.tar.gz_aa
+ *-rw-r--r-- 1 ftp ftp     2097152000 Feb 18 17:21 ASR1803_Linux.tar.gz_ab
+ *-rw-r--r-- 1 ftp ftp     1198057917 Feb 18 17:29 ASR1803_Linux.tar.gz_ac
+ *-rw-r--r-- 1 ftp ftp         445043 Apr 06  2021 data
+ *drwxr-xr-x 1 ftp ftp              0 Apr 10  2021 L306
+ */
+static mbtk_ftp_error_enum ftp_cmd_list_parse(mbtk_ftp_info_s *info,
+        mbtk_ftp_file_info_s *file_list)
+{
+    char line[1024];
+    char line_buf[1024];
+    int len, err;
+    mbtk_ftp_file_info_s file_ptr;
+    memset(file_list, 0x0, sizeof(mbtk_ftp_file_info_s)-sizeof(void *));
+
+    // Save file number.
+    file_list->size = 0;
+    len = 1;
+    int read_line_count=0;
+    while (len > 0)
+    {
+        if(info->auth_type!=0)
+        {
+            len = mbtk_sock_readline(info->ftp_ssl_handle,info->session_data,line_buf,1024,FTP_TIMEOUT,&err,&read_line_count,line);
+        }
+        else
+        {
+            len = sock_readline(&info->net_info, &info->sock_info[FTP_SOCK_DATA], line, 1024,FTP_TIMEOUT, &err);
+        }
+        LOGD("Line:%s", line);
+        if(len <= 0)
+            {
+                if (err == MBTK_SOCK_SUCCESS)
+                    return FTP_ERR_SUCCESS;
+                break;
+            }
+        else
+            len = strlen(line) - 1;
+        if (line[0] >= '0' && line[0] <= '9')
+        {
+            /*
+             * 04-26-20  02:13PM               379193 audio_0426.zip
+             * 09-10-20  02:31PM              4660645 Log.zip
+             * 10-28-20  01:53PM       <DIR>          PicLibs
+             */
+            line[len] = '\0';
+            /*
+            file_ptr = (mbtk_ftp_file_info_s*) malloc(
+                           sizeof(mbtk_ftp_file_info_s));
+            if (!file_ptr)
+            {
+                LOGE("malloc() fail.");
+                return FTP_ERR_UNKNOWN;
+            }
+            */
+            memset(&file_ptr, 0x0, sizeof(mbtk_ftp_file_info_s));
+
+            char str[MBTK_FTP_FILE_NAME_MAX];
+            const char *temp = line;
+            // Data
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+            if (strlen(str) > 0)
+            {
+                LOGV("Data:%s", str);
+            }
+
+            // Time
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+            if (strlen(str) > 0)
+            {
+                LOGV("Time:%s", str);
+            }
+
+            // <DIR> or file size
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+            if (strlen(str) > 0)
+            {
+                LOGV("<DIR>/size:%s", str);
+                if (!strcmp("<DIR>", str))
+                {
+                    file_ptr.is_file = false;
+                    file_ptr.size = 0;
+                }
+                else
+                {
+                    file_ptr.is_file = true;
+                    file_ptr.size = atoi(str);
+                }
+            }
+
+            const char *name = temp;
+            while (*name && ftp_ch_is_space(*name))
+            {
+                name++;
+            }
+
+            // Name
+            if (strlen(name) > 0)
+            {
+                LOGV("Name:%s",name);
+                memset(file_ptr.name,0,strlen(file_ptr.name)+1);
+                memcpy(file_ptr.name, name, strlen(name));
+                char *temp = (char*) file_ptr.name
+                             + strlen((char*) file_ptr.name) - 1;
+                while (ftp_ch_is_space(*temp))
+                {
+                    *temp = '\0';
+                    temp--;
+                }
+            }
+            else
+            {
+                LOGE("Can not get name[%s].", line);
+                return FTP_ERR_UNKNOWN;
+            }
+
+            (file_list->ftp_ls_cb_typedef)(&file_ptr);
+            //file_ptr->next = file_list->next;
+            //file_list->next = file_ptr;
+            //file_list->size++;
+            //free(file_ptr);
+        } else if(!ftp_ch_is_space(line[0])) {
+             /*
+             *-rw-r--r-- 1 ftp ftp     2097152000 Feb 18 17:28 ASR1803_Linux.tar.gz_aa
+             *-rw-r--r-- 1 ftp ftp     2097152000 Feb 18 17:21 ASR1803_Linux.tar.gz_ab
+             *-rw-r--r-- 1 ftp ftp     1198057917 Feb 18 17:29 ASR1803_Linux.tar.gz_ac
+             *-rw-r--r-- 1 ftp ftp         445043 Apr 06  2021 data
+             *drwxr-xr-x 1 ftp ftp              0 Apr 10  2021 L306
+             */
+            line[len] = '\0';
+             /*
+            file_ptr = (mbtk_ftp_file_info_s*) malloc(
+                           sizeof(mbtk_ftp_file_info_s));
+            if (!file_ptr)
+            {
+                LOGE("malloc() fail.");
+                return FTP_ERR_UNKNOWN;
+            }
+            */
+            memset(&file_ptr, 0x0, sizeof(mbtk_ftp_file_info_s));
+
+            char str[MBTK_FTP_FILE_NAME_MAX];
+            const char *temp = line;
+            // rwx
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+            if (strlen(str) > 0)
+            {
+                LOGV("rwx:%s", str);
+                file_ptr.is_file = (str[0] == '-' ? true : false);
+            }
+
+            // 1 ftp ftp
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+
+            // size
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+            if (strlen(str) > 0)
+            {
+                LOGV("Size:%s", str);
+                file_ptr.size = atoi(str);
+            }
+
+            // Feb 18 17:28
+            // or
+            // Apr 10  2021
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+            temp = ftp_str_next(temp, str, MBTK_FTP_FILE_NAME_MAX);
+
+            const char *name = temp;
+            while (*name && ftp_ch_is_space(*name))
+            {
+                name++;
+            }
+
+            // Name
+            if (strlen(name) > 0)
+            {
+                LOGV("Name:%s",name);
+                memset(file_ptr.name,0,strlen(file_ptr.name)+1);
+                memcpy(file_ptr.name, name, strlen(name));
+                char *temp = (char*) file_ptr.name
+                             + strlen((char*) file_ptr.name) - 1;
+                while (ftp_ch_is_space(*temp))
+                {
+                    *temp = '\0';
+                    temp--;
+                }
+            }
+            else
+            {
+                LOGE("Can not get name[%s].", line);
+                return FTP_ERR_UNKNOWN;
+            }
+
+            (file_list->ftp_ls_cb_typedef)(&file_ptr);
+            //file_ptr->next = file_list->next;
+            //file_list->next = file_ptr;
+            //file_list->size++;
+            //free(file_ptr);
+        }else {
+            LOGE("Data error.");
+            return FTP_ERR_UNKNOWN;
+        }
+    }
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_download_process(mbtk_ftp_info_s *info)
+{
+#define READ_BUF_SIZE 2048
+    char buff[READ_BUF_SIZE];
+    int len, err, len_read;
+    int read_count = info->file_trans.size_send;
+
+#ifdef FTP_RESUME_DEBUG
+    int count = 0;
+#endif
+
+    if (info->file_trans.size_count - read_count > READ_BUF_SIZE)
+        len_read = READ_BUF_SIZE;
+    else
+        len_read = info->file_trans.size_count - read_count;
+
+    if(info->auth_type != 0)
+        len = mbtk_sock_read(info->ftp_ssl_handle,info->session_data,buff,len_read,FTP_TIMEOUT,&err);
+    else
+        len = sock_read(&info->net_info, &info->sock_info[FTP_SOCK_DATA], buff, len_read,FTP_TIMEOUT, &err);
+    /*
+    while (len_read > 0 && (len = sock_read(&info->net_info, &info->sock_info[FTP_SOCK_DATA], buff, len_read,
+                                    FTP_TIMEOUT, &err)) > 0)
+    */
+    while (len_read > 0 && len > 0)
+    {
+        read_count += len;
+
+#ifdef FTP_RESUME_DEBUG
+        count++;
+        if (count <= 1000)
+        {
+#endif
+            if (info->file_trans.data_cb)
+            {
+                info->file_trans.data_cb(buff, len);
+            }
+            else     // Write to efs.
+            {
+                if (len != file_write(info->file_trans.fd, buff, len))
+                {
+                    LOGE("EFS write fail.");
+                    return FTP_ERR_EFS_FILE;
+                }
+            }
+            memset(buff,0,sizeof(buff));
+            info->file_trans.size_send = read_count;
+#ifdef FTP_RESUME_DEBUG
+        }
+#endif
+
+        if (info->file_trans.size_count - read_count > READ_BUF_SIZE)
+            len_read = READ_BUF_SIZE;
+        else
+            len_read = info->file_trans.size_count - read_count;
+
+        if(info->auth_type != 0)
+            len = mbtk_sock_read(info->ftp_ssl_handle,info->session_data,buff,len_read,FTP_TIMEOUT,&err);
+        else
+            len = sock_read(&info->net_info, &info->sock_info[FTP_SOCK_DATA], buff, len_read,FTP_TIMEOUT, &err);
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_update_process(mbtk_ftp_info_s *info)
+{
+#define READ_BUF_SIZE 2048
+    char buff[READ_BUF_SIZE];
+    int len, err, len_write;
+	int file_total_size = 0;
+    int write_count = 0;
+
+	if(info->file_trans.fd > 0)
+	{
+		file_total_size = file_length(info->file_trans.fd);
+        info->file_trans.size_count = file_total_size;
+		while((len_write = file_read(info->file_trans.fd, buff, READ_BUF_SIZE)) > 0 )
+		{
+			LOGE("file_read.len:%d, buf；%s", len_write, buff);
+            if(info->auth_type != 0)
+                len = mbtk_sock_write(info->ftp_ssl_handle,info->session_data,buff,len_write,FTP_TIMEOUT,&err);
+            else
+			    len = sock_write(&info->net_info, &info->sock_info[FTP_SOCK_DATA], buff, len_write,
+                                    FTP_TIMEOUT, &err);
+			if(len < 0)
+			{
+				LOGE("EFS write fail.len:%d, err；%d", len, err);
+                return FTP_ERR_EFS_FILE;
+			}
+
+			write_count += len;
+		}
+
+        info->file_trans.size_send = write_count;
+		if( write_count != file_total_size)
+		{
+			LOGE("socket write fail.,file_total_size:%d, write_count:%d", file_total_size,write_count);
+            return FTP_ERR_NET_WRITE;
+		}
+		else{
+			LOGE("socket write success.,file_total_size:%d, write_count:%d", file_total_size, write_count);
+		}
+
+	}
+	else
+	{
+		LOGE("EFS write fail.");
+        return FTP_ERR_EFS_FILE;
+	}
+
+	return FTP_ERR_SUCCESS;
+}
+
+
+/*
+ * audio_0426.zip
+ * Log.zip
+ * PicLibs
+ */
+static mbtk_ftp_error_enum ftp_cmd_nlst_parse(mbtk_ftp_info_s *info,
+        mbtk_ftp_file_info_s *file_list)
+{
+    char line[1024];
+    int len, err;
+    mbtk_ftp_file_info_s *file_ptr = NULL;
+    while ((len = sock_readline(&info->net_info, &info->sock_info[FTP_SOCK_DATA], line, 1024,
+                                FTP_TIMEOUT, &err)) > 0)
+    {
+        if (!ftp_ch_is_space(line[0]))
+        {
+            file_ptr = (mbtk_ftp_file_info_s*) malloc(
+                           sizeof(mbtk_ftp_file_info_s));
+            if (!file_ptr)
+            {
+                LOGE("malloc() fail.");
+                return FTP_ERR_UNKNOWN;
+            }
+            memset(file_ptr, 0x0, sizeof(mbtk_ftp_file_info_s));
+            memcpy(file_ptr->name, line, strlen(line));
+            char *temp = (char*) file_ptr->name + strlen((char*) file_ptr->name)
+                         - 1;
+            while (ftp_ch_is_space(*temp))
+            {
+                *temp = '\0';
+                temp--;
+            }
+
+            file_ptr->next = file_list->next;
+            file_list->next = file_ptr;
+        }
+    }
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_data_sock_read(mbtk_ftp_info_s *info,
+        mbtk_ftp_cmd_enum cmd, void *req, void *rsp)
+{
+    int err, len, code;
+    mbtk_ftp_error_enum result = FTP_ERR_SUCCESS;
+    char buff[1024];
+    if (info->is_data_sock_busy)
+    {
+        LOGW("Data socket is busy!");
+        return FTP_ERR_DATA_SOCK_BUSY;
+    }
+
+    info->is_data_sock_busy = true;
+    // Connect to service by data socket.
+    if (info->data_mode == FTP_MODE_PASSIVE)
+    {
+        mbtk_ftp_sock_s sock;
+        if(info->auth_type != FTP_AUTH_TYPE_NON) {
+            // PROT P
+            char cmd_ssl[50];
+            memset(cmd_ssl,0,50);
+            snprintf(cmd_ssl, 50, "PROT P\r\n");
+            code = ftp_cmd_handle(info, cmd_ssl, NULL,NULL);
+            if (code/100 != 2)
+            {
+                LOGE("PROT P error[code = %d].", code);
+                goto end;
+            }
+        }
+
+        if (info->sock_info[FTP_SOCK_CTRL].addr_family == MBTK_ADDR_IPV6)
+        {
+            if ((result = ftp_sock_get_by_epsv(info, &sock))
+                != FTP_ERR_SUCCESS)
+            {
+                goto end;
+            }
+        }
+        else
+        {
+            if ((result = ftp_sock_get_by_pasv(info, &sock))
+                != FTP_ERR_SUCCESS)
+            {
+                printf("\nftp_sock_get_by_pasv end.result=%d\n",result);
+            }
+            else
+            {
+                printf("\nftp_sock_get_by_pasv ok!\n");
+            }
+        }
+
+        if(info->auth_type != FTP_AUTH_TYPE_NON)
+        {
+            info->ftp_ssl_handle_data = mbtk_sock_init(&info->ftp_ssl_info_data);
+            if(info->ftp_ssl_handle_data == -1)
+            {
+                printf("mbtk_sock_init error\n");
+            }
+            info->ftp_sock_ssl_info_data = (mbtk_sock_info*) malloc(sizeof(mbtk_sock_info));
+            memset(info->ftp_sock_ssl_info_data, 0x0, sizeof(mbtk_sock_info));
+            info->ftp_sock_ssl_info_data->is_support_ssl = info->auth_type;
+            info->ftp_sock_ssl_info_data->ftp_ssl_support=1;
+            info->ftp_sock_ssl_info_data->port = sock.port;
+            info->ftp_sock_ssl_info_data->type = MBTK_SOCK_TCP;
+            info->ftp_sock_ssl_info_data->ingnore_cert = ~(info->sock_info[FTP_SOCK_CTRL].use_cert);
+            memcpy(info->ftp_sock_ssl_info_data->address, sock.host, strlen(sock.host));
+            if(info->ftp_sock_ssl_info_data->is_support_ssl != 0)
+            {
+                info->ftp_sock_ssl_info_data->is_support_ssl = 0;
+            }
+            info->session_data = mbtk_sock_open(info->ftp_ssl_handle,info->ftp_sock_ssl_info_data,60000,&err);
+            if(err!=0)
+            {
+                printf("mbtk_sock_open error : %d\n",err);
+            }
+            else
+            {
+                info->ftp_sock_ssl_info_data->is_support_ssl = info->auth_type;
+                //printf("\ninfo->session_data = %d \n",info->session_data);
+            }
+        }
+        else
+        {
+            memcpy(info->sock_info[FTP_SOCK_DATA].host, sock.host, strlen((char*)sock.host));
+            info->sock_info[FTP_SOCK_DATA].port = sock.port;
+            info->sock_info[FTP_SOCK_DATA].is_ssl = (info->auth_type != FTP_AUTH_TYPE_NON);
+            info->sock_info[FTP_SOCK_DATA].addr_family = info->sock_info[FTP_SOCK_CTRL].addr_family;
+            info->sock_info[FTP_SOCK_DATA].use_cert = info->sock_info[FTP_SOCK_CTRL].use_cert;
+            info->net_info.keep_alive = FALSE;
+            info->net_info.recv_buff_size = 32 * 1024; // 32K
+            info->sock_info[FTP_SOCK_DATA].fd = sock_open(&info->net_info, &info->sock_info[FTP_SOCK_DATA],
+                                                    FTP_TIMEOUT, &err);
+        }
+
+    }
+    else    // Active mode
+    {
+        if (req == NULL)
+        {
+            result = FTP_ERR_PARAM_SET;
+            goto end;
+        }
+        mbtk_ftp_sock_s *sock = (mbtk_ftp_sock_s*) req;
+
+        if (info->sock_info[FTP_SOCK_CTRL].addr_family == MBTK_ADDR_IPV6)
+        {
+            if ((result = ftp_sock_set_by_eprt(info, sock))
+                != FTP_ERR_SUCCESS)
+            {
+                goto end;
+            }
+        }
+        else
+        {
+            if ((result = ftp_sock_set_by_port(info, sock))
+                != FTP_ERR_SUCCESS)
+            {
+                goto end;
+            }
+        }
+
+        // Wait for client[service] connect.
+
+    }
+    if(info->auth_type != FTP_AUTH_TYPE_NON)
+    {
+        if(info->session_data < 0)
+        {
+               //printf("Socket open/connect ssl fail[err = %d].", err);
+               result = FTP_ERR_NET_CONN;
+               goto read_end;
+        }
+    }
+    else
+    {
+        if (info->sock_info[FTP_SOCK_DATA].fd < 0)
+        {
+            LOGE("Socket open/connect fail[err = %d].", err);
+            result = FTP_ERR_NET_CONN;
+            goto read_end;
+        }
+
+        if(info->auth_type == FTP_AUTH_TYPE_IMPLICIT) {
+            info->sock_info[FTP_SOCK_DATA].is_ssl = true;
+        }
+    }
+
+    if (cmd == FTP_CMD_GET)   // Is download
+    {
+        char cmd[100];
+        if (info->file_trans.size_send > 0)   // Resume transmission
+        {
+            // REST size
+            memset(cmd, 0x0, 100);
+            snprintf(cmd, 100, "REST %ld\r\n", info->file_trans.size_send);
+            code = ftp_cmd_handle(info, cmd, NULL, NULL);
+            if (code != 350)
+            {
+                LOGE("REST rsp error[code = %d].", code);
+                result = FTP_ERR_UNKNOWN;
+                goto end;
+            }
+        }
+
+        memset(cmd, 0x0, 100);
+        snprintf(cmd, 100, "RETR %s\r\n", info->file_trans.remote_name);
+        code = ftp_cmd_handle(info, cmd, NULL, NULL);
+        if (code != 125 && code != 150)
+        {
+            LOGE("RETR %s rsp error[code = %d].", info->file_trans.remote_name,
+                 code);
+            result = FTP_ERR_UNKNOWN;
+            goto end;
+        }
+
+        int mbtk_errno;
+        if(info->auth_type != 0)
+        {
+            mbtk_errno = mbtk_ssl_init_func(info->ftp_ssl_handle,info->ftp_sock_ssl_info_data->ingnore_cert,info->session_data);
+            if(mbtk_errno != 0)
+            {
+                printf("\nmbtk_ssl_init_func error = %d",mbtk_errno);
+                goto end;
+            }
+
+        }
+        result = ftp_download_process(info);
+        if(info->auth_type != 0)
+        {
+            char mbtk_ftp_ssl_read_buf[256];
+            memset(mbtk_ftp_ssl_read_buf,0,sizeof(mbtk_ftp_ssl_read_buf));
+            mbtk_sock_read(info->ftp_ssl_handle,info->session,
+                                       mbtk_ftp_ssl_read_buf,
+                                       sizeof(mbtk_ftp_ssl_read_buf),
+                                       6000,
+                                       &mbtk_errno);
+            printf("\nmbtk_sock_read:\n%s\n",mbtk_ftp_ssl_read_buf);
+        }
+        if(info->auth_type != 0)
+            goto read_end;
+    }
+	else if (cmd == FTP_CMD_PUT)   // Is download
+    {
+        if(info->auth_type != 0)
+        {
+                int mbtk_errno;
+                char cmd[100];
+                memset(cmd, 0x0, 100);
+                snprintf(cmd, 100, "STOR %s\r\n", info->file_trans.remote_name);
+        		LOGE("STOR %s .name:%s ", cmd, info->file_trans.remote_name);
+                code = ftp_cmd_handle(info, cmd, NULL, NULL);
+                if (code != 125 && code != 150)
+                {
+                    LOGE("RETR %s rsp error[code = %d].", info->file_trans.remote_name,
+                         code);
+                    //printf("RETR %s rsp error[code = %d].\n", info->file_trans.remote_name,code);
+                    result = FTP_ERR_UNKNOWN;
+                    goto end;
+                }
+
+                mbtk_errno = mbtk_ssl_init_func(info->ftp_ssl_handle,info->ftp_sock_ssl_info_data->ingnore_cert,info->session_data);
+                if(mbtk_errno != 0)
+                {
+                    printf("\nmbtk_ssl_init_func error = %d",mbtk_errno);
+                    goto end;
+                }
+                if(info->file_trans.size_count == 0)
+            	{
+            	    result = ftp_update_process(info);
+            	    goto read_end;
+            	}
+            	else
+            	{
+                    //printf("FTP_SOCK_DATA,fd:%d\n",info->file_trans.size_count);
+            	    return FTP_ERR_SUCCESS;
+            	}
+            goto end;
+        }
+        else
+        {
+            char cmd[100];
+            memset(cmd, 0x0, 100);
+            snprintf(cmd, 100, "STOR %s\r\n", info->file_trans.remote_name);
+    		LOGE("STOR %s .name:%s ", cmd, info->file_trans.remote_name);
+            code = ftp_cmd_handle(info, cmd, NULL, NULL);
+            if (code != 125 && code != 150)
+            {
+                LOGE("RETR %s rsp error[code = %d].", info->file_trans.remote_name,
+                     code);
+                result = FTP_ERR_UNKNOWN;
+                goto end;
+            }
+
+        	if(info->file_trans.size_count == 0)
+        	{
+        	    result = ftp_update_process(info);
+        	    goto read_end;
+        	}
+        	else
+        	{
+                    LOGE("FTP_SOCK_DATA,fd:%d", info->sock_info[FTP_SOCK_DATA].fd);
+        	    return FTP_ERR_SUCCESS;
+        	}
+        }
+    }
+    else if (cmd == FTP_CMD_LIST)
+    {
+        if(info->auth_type != 0)
+        {
+        	int mbtk_errno;
+        	code = ftp_cmd_handle(info, "LIST\r\n", NULL, NULL);
+        	if (code != 125 && code != 150)
+            {
+            	LOGE("LIST rsp error[code = %d].", code);
+                result = FTP_ERR_UNKNOWN;
+                goto read_end;
+            }
+
+            mbtk_errno = mbtk_ssl_init_func(info->ftp_ssl_handle,info->ftp_sock_ssl_info_data->ingnore_cert,info->session_data);
+            if(mbtk_errno != 0)
+            {
+            	printf("\nmbtk_ssl_init_func error = %d",mbtk_errno);
+                goto read_end;
+            }
+
+            result = ftp_cmd_list_parse(info, (mbtk_ftp_file_info_s*) rsp);
+            char mbtk_ftp_ssl_read_buf[1024];
+            memset(mbtk_ftp_ssl_read_buf,0,sizeof(mbtk_ftp_ssl_read_buf));
+            mbtk_sock_read(info->ftp_ssl_handle,info->session,
+                                mbtk_ftp_ssl_read_buf,
+                                sizeof(mbtk_ftp_ssl_read_buf),
+                                6000,
+                                &mbtk_errno);
+            printf("\nmbtk_sock_read:\n%s\n",mbtk_ftp_ssl_read_buf);
+            int rsp_code = atoi(mbtk_ftp_ssl_read_buf);
+            if(rsp_code / 200)
+            	result = FTP_ERR_SUCCESS;
+            goto read_end;
+        }
+        else
+        {
+            code = ftp_cmd_handle(info, "LIST\r\n", NULL, NULL);
+            if (code != 125 && code != 150)
+            {
+                LOGE("LIST rsp error[code = %d].", code);
+                result = FTP_ERR_UNKNOWN;
+                goto end;
+            }
+
+            result = ftp_cmd_list_parse(info, (mbtk_ftp_file_info_s*) rsp);
+        }
+    }
+    else if (cmd == FTP_CMD_NLST)
+    {
+        code = ftp_cmd_handle(info, "NLST\r\n", NULL, NULL);
+        if (code != 125 && code != 150)
+        {
+            LOGE("LIST rsp error[code = %d].", code);
+            result = FTP_ERR_UNKNOWN;
+            goto end;
+        }
+
+        result = ftp_cmd_nlst_parse(info, (mbtk_ftp_file_info_s*) rsp);
+    }
+    else
+    {
+        LOGE("No support this cmd[%d].", cmd);
+        result = FTP_ERR_UNKNOWN;
+        goto read_end;
+    }
+
+    // Read [226 Transfer complete.]
+read_code:
+    memset(buff, 0x0, 1024);
+    len = sock_readline(&info->net_info, &info->sock_info[FTP_SOCK_CTRL], buff, 1024, FTP_TIMEOUT,
+                    &err);
+    if (len <= 0)
+    {
+        LOGE("Socket read fail[len = %d].", len);
+        result = FTP_ERR_NET_READ;
+        goto sock_error;
+    }
+    LOGI("RSP[len-%d]:%s",len,buff);
+    //log_hex("FTP_RSP",buff,len);
+    code = atoi(buff);
+    if (code == 0)
+    {
+        goto read_code;
+    }
+#if 1
+    // 426 Connection closed; aborted transfer of "/files/test"
+    else if (code == 426)
+    {
+        LOGE("Connection closed,restart download...");
+        result = FTP_ERR_UNKNOWN;
+        goto sock_error;
+    }
+#endif
+    else if (code != 226)
+    {
+        LOGE("Code not be 226[%s].", buff);
+        result = FTP_ERR_UNKNOWN;
+        goto read_end;
+    }
+
+    goto read_end;
+sock_error:
+    {
+        if (info->sock_info[FTP_SOCK_CTRL].fd > 0)
+        {
+            if (sock_close(&info->net_info, &info->sock_info[FTP_SOCK_CTRL], FTP_TIMEOUT, &err))
+            {
+                LOGE("Close ctrl socket fail[%d].", err);
+            }
+        }
+        info->state = FTP_STATE_NON;
+        info->sock_info[FTP_SOCK_CTRL].fd = -1;
+    }
+read_end:
+    // Close data socket.
+    if (info->sock_info[FTP_SOCK_DATA].fd > 0)
+    {
+        if (sock_close(&info->net_info, &info->sock_info[FTP_SOCK_DATA], FTP_TIMEOUT, &err))
+        {
+            LOGE("Close data socket fail[%d].", err);
+            result = FTP_ERR_NET_CLOSE;
+        }
+        else
+        {
+            info->sock_info[FTP_SOCK_DATA].fd = -1;
+        }
+    }
+    if(info->auth_type != 0)
+    {
+        if(mbtk_sock_close(info->ftp_ssl_handle,info->session_data,6000,&err))
+        {
+            LOGE("Close ssl data socket fail[%d].", err);
+            result = FTP_ERR_NET_CLOSE;
+        }
+        else
+        {
+        //    info->sock_info[FTP_SOCK_DATA].fd = -1;
+        }
+    }
+    if (info->data_mode == FTP_MODE_PASSIVE)
+    {
+
+    }
+    else
+    {
+
+    }
+
+end:
+    // Default is passive.
+    info->data_mode = FTP_MODE_PASSIVE;
+    info->is_data_sock_busy = false;
+
+    return result;
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process_pwd(mbtk_ftp_info_s *info,
+        char *path)
+{
+    int code;
+    char rsp[100];
+    uint32 rsp_len = 100;
+    code = ftp_cmd_handle(info, "PWD\r\n", rsp, &rsp_len);
+    if (code != 257)
+    {
+        LOGE("PWD rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    // "path" is current ....
+    char *ptr = strchr(rsp, '"');
+    if (!ptr)
+    {
+        LOGE("PWD rsp error[%d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    ptr++;
+    char *ptr_temp = ptr;
+    while (*ptr_temp)
+    {
+        if (*ptr_temp == '"')
+        {
+            *ptr_temp = '\0';
+            break;
+        }
+        ptr_temp++;
+    }
+    memcpy(path, ptr, strlen(ptr));
+    path[strlen(ptr)] = '\0';
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process_cwd(mbtk_ftp_info_s *info,
+        const char *path)
+{
+    int code;
+    char cmd[100] = { 0 };
+    snprintf(cmd, 100, "CWD %s\r\n", path);
+    code = ftp_cmd_handle(info, cmd, NULL, NULL);
+    if (code != 250)
+    {
+        LOGE("CWD rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process_mkd(mbtk_ftp_info_s *info,
+        const char *path)
+{
+    int code;
+    char cmd[100] = { 0 };
+    snprintf(cmd, 100, "MKD %s\r\n", path);
+    code = ftp_cmd_handle(info, cmd, NULL, NULL);
+    if (code == 257)
+    {
+        return FTP_ERR_SUCCESS;
+    }
+    else if (code == 550)
+    {
+        LOGE("Dir has exist[%s].", path);
+        return FTP_ERR_FILE_EXIST;
+    }
+    else
+    {
+        LOGE("MKD rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process_rmd(mbtk_ftp_info_s *info,
+        const char *path)
+{
+    int code;
+    char cmd[100] = { 0 };
+    snprintf(cmd, 100, "RMD %s\r\n", path);
+    code = ftp_cmd_handle(info, cmd, NULL, NULL);
+    if (code == 250)
+    {
+        return FTP_ERR_SUCCESS;
+    }
+    else if (code == 550)
+    {
+        LOGE("Dir not exist or not empty[%s].", path);
+        return FTP_ERR_FILE_NO_FOUND;
+    }
+    else
+    {
+        LOGE("RMD rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process_stat(mbtk_ftp_info_s *info,
+        void *status)
+{
+    int code;
+    char rsp[1024];
+    uint32 rsp_len = 1024;
+    code = ftp_cmd_handle(info, "STAT\r\n", rsp, &rsp_len);
+    if (code != 211)
+    {
+        LOGE("STAT rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    memcpy(status, rsp, rsp_len);
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process_type(mbtk_ftp_info_s *info,
+        mbtk_ftp_data_type_enum type)
+{
+    int code;
+    if (type == FTP_DATA_TYPE_I)
+        code = ftp_cmd_handle(info, "TYPE I\r\n", NULL, NULL);
+    else if (type == FTP_DATA_TYPE_E)
+        code = ftp_cmd_handle(info, "TYPE E\r\n", NULL, NULL);
+    else
+        code = ftp_cmd_handle(info, "TYPE A\r\n", NULL, NULL);
+
+    if (code != 200)
+    {
+        LOGE("TYPE rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process_size(mbtk_ftp_info_s *info,
+        const char *path, uint32 *size)
+{
+    int code;
+    char cmd[100] = { 0 };
+    char rsp[100];
+    uint32 rsp_len = 100;
+    snprintf(cmd, 100, "SIZE %s\r\n", path);
+    code = ftp_cmd_handle(info, cmd, rsp, &rsp_len);
+
+    if (code == 213)
+    {
+        // "213 4660645"
+        *size = atoi(rsp + 4);
+    }
+    else if (code == 550)
+    {
+        LOGW("No found file[%s].", path);
+        return FTP_ERR_FILE_NO_FOUND;
+    }
+    else
+    {
+        LOGE("SIZE rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process_mdtm(mbtk_ftp_info_s *info,
+        const char *path, char *time)
+{
+    int code;
+    char cmd[100] = { 0 };
+    char rsp[100];
+    uint32 rsp_len = 100;
+    snprintf(cmd, 100, "MDTM %s\r\n", path);
+    code = ftp_cmd_handle(info, cmd, rsp, &rsp_len);
+
+    if (code == 213)
+    {
+        // "213 20181017014716"
+        memcpy(time, rsp + 4, 14);
+    }
+    else if (code == 550)
+    {
+        LOGW("No found file[%s].", path);
+        return FTP_ERR_FILE_NO_FOUND;
+    }
+    else
+    {
+        LOGE("MDTM rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process_dele(mbtk_ftp_info_s *info,
+        const char *path)
+{
+    int code;
+    char cmd[100] = { 0 };
+    snprintf(cmd, 100, "DELE %s\r\n", path);
+    code = ftp_cmd_handle(info, cmd, NULL, NULL);
+    if (code == 250)
+    {
+        return FTP_ERR_SUCCESS;
+    }
+    else if (code == 550)
+    {
+        LOGW("No found file[%s].", path);
+        return FTP_ERR_FILE_NO_FOUND;
+    }
+    else
+    {
+        LOGE("DELE rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process_quit(mbtk_ftp_info_s *info)
+{
+    int code;
+    code = ftp_cmd_handle(info, "QUIT\r\n", NULL, NULL);
+    if (code != 221)
+    {
+        LOGE("CWD rsp error[code = %d].", code);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+static mbtk_ftp_error_enum ftp_cmd_process(mbtk_ftp_info_s *info,
+        mbtk_ftp_cmd_enum cmd, void *req, void *rsp)
+{
+    mbtk_ftp_error_enum result = FTP_ERR_SUCCESS;
+    if (info->state == FTP_STATE_READY)   // FTP login
+    {
+        info->state = FTP_STATE_CMD_PROCESS;
+        switch (cmd)
+        {
+            case FTP_CMD_LIST:
+            {
+                result = ftp_data_sock_read(info, FTP_CMD_LIST, req, rsp);
+                break;
+            }
+            case FTP_CMD_NLST:
+            {
+                result = ftp_data_sock_read(info, FTP_CMD_NLST, req, rsp);
+                break;
+            }
+            case FTP_CMD_PWD:
+            {
+                result = ftp_cmd_process_pwd(info, rsp);
+                break;
+            }
+            case FTP_CMD_CWD:
+            {
+                result = ftp_cmd_process_cwd(info, (char*) req);
+                break;
+            }
+            case FTP_CMD_MKD:
+            {
+                result = ftp_cmd_process_mkd(info, (char*) req);
+                break;
+            }
+            case FTP_CMD_RMD:
+            {
+                result = ftp_cmd_process_rmd(info, (char*) req);
+                break;
+            }
+            case FTP_CMD_STAT:
+            {
+                result = ftp_cmd_process_stat(info, rsp);
+                break;
+            }
+            case FTP_CMD_TYPE:
+            {
+                mbtk_ftp_data_type_enum *type = (mbtk_ftp_data_type_enum*) req;
+                result = ftp_cmd_process_type(info, *type);
+                break;
+            }
+            case FTP_CMD_SIZE:
+            {
+                result = ftp_cmd_process_size(info, (char*) req, (uint32*) rsp);
+                break;
+            }
+            case FTP_CMD_MDTM:
+            {
+                result = ftp_cmd_process_mdtm(info, (char*) req, (char*) rsp);
+                break;
+            }
+            case FTP_CMD_DELE:
+            {
+                result = ftp_cmd_process_dele(info, (char*) req);
+                break;
+            }
+            case FTP_CMD_QUIT:
+            {
+                result = ftp_cmd_process_quit(info);
+                break;
+            }
+            default:
+            {
+                LOGE("Unknown cmd:%d", cmd);
+                result = FTP_ERR_UNKNOWN;
+                break;
+            }
+        }
+        info->state = FTP_STATE_READY;
+    }
+    else
+    {
+        LOGW("FTP state error[%d].", info->state);
+        result = FTP_ERR_UNKNOWN;
+    }
+
+    return result;
+}
+
+static mbtk_ftp_error_enum ftp_login(mbtk_ftp_info_s *info,mbtk_ftp_user_info_s *user)
+{
+    // Open net in the first.
+    if(info->net_info.net_id <= 0) {
+        if(sock_net_open(&info->net_info,info->sock_info[FTP_SOCK_CTRL].addr_family))
+        {
+            LOGE("sock_net_open() fail.");
+            return FTP_ERR_NET_CONN;
+        }
+    }
+
+    int err;
+    mbtk_ftp_error_enum ftp_err = FTP_ERR_SUCCESS;
+    info->state = FTP_STATE_CONNECTING;
+    info->net_info.keep_alive = TRUE;
+    info->net_info.recv_buff_size = 0; // Default
+    info->sock_info[FTP_SOCK_CTRL].fd = sock_open(&info->net_info, &info->sock_info[FTP_SOCK_CTRL], FTP_TIMEOUT, &err);
+    if (info->sock_info[FTP_SOCK_CTRL].fd < 0)   // Fail
+    {
+        LOGE("Socket open/connect fail[err = %d].", err);
+        ftp_err = FTP_ERR_NET_CONN;
+        goto login_fail;
+    }
+
+    if(info->auth_type == FTP_AUTH_TYPE_IMPLICIT)
+        info->sock_info[FTP_SOCK_CTRL].is_ssl = true;
+
+    // Ctrl socket connect success.
+    info->state = FTP_STATE_CONNECTED;
+    LOGI("FTP ctrl socket connected.");
+
+    char buff[1024];
+    int len;
+    char *ptr = NULL;
+
+    // 220-FileZilla Server version 0.9.43 beta
+    // 220-written by Tim Kosse (tim.kosse@filezilla-project.org)
+    // 220 Please visit http://sourceforge.net/projects/filezilla/
+    while(TRUE) {
+        memset(buff, 0x0, 1024);
+        len = sock_readline(&info->net_info, &info->sock_info[FTP_SOCK_CTRL], buff, 1024, FTP_TIMEOUT,
+                            &err);
+        if (len <= 0)
+        {
+            LOGE("Socket read fail[err = %d].", err);
+            ftp_err = FTP_ERR_NET_READ;
+            goto login_fail;
+        } else {// xxx yyyyyy
+            if((ptr = strstr(buff,"220 ")) || (ptr = strstr(buff,"230 "))) {
+                LOGI("RSP:%s",ptr);
+                break;
+            }
+        }
+    }
+
+    int code = atoi(ptr);
+    if (code == 230)   // Has logged in.
+    {
+        info->state = FTP_STATE_READY;
+        LOGI("FTP Has logged in.");
+        return FTP_ERR_SUCCESS;
+    }
+    else if (code == 220)       // Should logn in.
+    {
+        int len;
+        char cmd_buff[50];
+
+#if 0
+        // Read other data.
+        char buff[1024];
+        memset(buff,0x0,1024);
+        while((len = sock_read(&info->net_info,info->ctrl_sock.fd, buff, 1024, info->ssl_enable, 1000,
+                                &err)) > 0)
+        {
+            LOGI("RSP[%d]:%s",len,buff);
+            memset(buff,0x0,1024);
+        }
+#endif
+
+        if(info->auth_type == FTP_AUTH_TYPE_EXPLICIT_SSL
+            || info->auth_type == FTP_AUTH_TYPE_EXPLICIT_TLS) {
+            if(info->auth_type == FTP_AUTH_TYPE_EXPLICIT_SSL) {
+                len = snprintf(cmd_buff, 50, "AUTH SSL\r\n");
+            } else {
+                len = snprintf(cmd_buff, 50, "AUTH TLS\r\n");
+            }
+            cmd_buff[len] = '\0';
+            code = ftp_cmd_handle(info, cmd_buff, NULL, NULL);
+            if (code != 234 && code != 334)
+            {
+                LOGE("AUTH SSL/TLS fail[code = %d].", code);
+                ftp_err = FTP_ERR_LOGIN_DENIED;
+                goto login_fail;
+            }
+
+#if 0
+            if(sock_ssl_enable(&info->net_info,info->ctrl_sock.fd
+                ,info->ctrl_sock.host,info->ctrl_sock.port,info->use_cert,FTP_TIMEOUT)){
+                LOGE("sock_ssl_enable() fail.");
+                ftp_err = FTP_ERR_LOGIN_DENIED;
+                goto login_fail;
+            }
+#endif
+            info->sock_info[FTP_SOCK_CTRL].is_ssl = true;
+        }
+
+        if(info->auth_type != FTP_AUTH_TYPE_NON) {
+            len = snprintf(cmd_buff, 50, "PBSZ 0\r\n");
+            cmd_buff[len] = '\0';
+            code = ftp_cmd_handle(info, cmd_buff, NULL, NULL);
+            if (code != 200 && code != 220)
+            {
+                LOGE("PBSZ 0 fail[code = %d].", code);
+                ftp_err = FTP_ERR_LOGIN_DENIED;
+                goto login_fail;
+            }
+        }
+
+        len = snprintf(cmd_buff, 50, "USER %s\r\n", user->name);
+        cmd_buff[len] = '\0';
+        code = ftp_cmd_handle(info, cmd_buff, NULL, NULL);
+        if (code == 331) // USER is 331
+        {
+            len = snprintf(cmd_buff, 50, "PASS %s\r\n", user->pass);
+            cmd_buff[len] = '\0';
+            code = ftp_cmd_handle(info, cmd_buff, NULL, NULL);
+        }
+
+        if (code / 100 == 2)   // USER/PASS is 2xx
+        {
+            info->state = FTP_STATE_READY;
+            LOGI("FTP logn in success.");
+            return FTP_ERR_SUCCESS;
+        }
+        else if (code == 332)   // // USER/PASS is 332
+        {
+            LOGW("Should set ACCT.");
+            ftp_err = FTP_ERR_UNKNOWN;
+            goto login_fail;
+        }
+        else
+        {
+            LOGE("FTP login denied[code = %d].", code);
+            ftp_err = FTP_ERR_LOGIN_DENIED;
+            goto login_fail;
+        }
+    }
+    else
+    {
+        LOGE("FTP code error[%d].", code);
+        ftp_err = FTP_ERR_UNKNOWN;
+        goto login_fail;
+    }
+
+login_fail:
+    info->state = FTP_STATE_NON;
+    return ftp_err;
+}
+
+static mbtk_ftp_info_s* ftp_info_find(mbtk_ftp_handle handle)
+{
+    if (!ftp_client_list)
+    {
+        LOGE("FTP Client List not init.");
+        return NULL;
+    }
+
+    mbtk_ftp_info_s *result = NULL;
+    list_first(ftp_client_list);
+    while ((result = (mbtk_ftp_info_s*) list_next(ftp_client_list)))
+    {
+        if (result->handle == handle)
+            break;
+    }
+
+    return result;
+}
+
+mbtk_ftp_handle mbtk_ftp_upload_end(mbtk_ftp_handle handle)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        printf("No such FTP handle:%d\n", handle);
+    }
+
+    char buff[1024]={0};
+    int err=0;
+    int len=0;
+    int result;
+
+    if (info->sock_info[FTP_SOCK_DATA].fd > 0)
+    {
+        if (sock_close(&info->net_info, &info->sock_info[FTP_SOCK_DATA], FTP_TIMEOUT, &err))
+        {
+            LOGE("Close data socket fail[%d].", err);
+            result = FTP_ERR_NET_CLOSE;
+        }
+        else
+        {
+        //    info->sock_info[FTP_SOCK_DATA].fd = -1;
+        }
+    }
+    if(info->auth_type != 0)
+    {
+        if(mbtk_sock_close(info->ftp_ssl_handle,info->session_data,6000,&err))
+        {
+            LOGE("Close ssl data socket fail[%d].", err);
+            result = FTP_ERR_NET_CLOSE;
+        }
+        else
+        {
+        //    info->sock_info[FTP_SOCK_DATA].fd = -1;
+        }
+    }
+    info->data_mode = FTP_MODE_PASSIVE;
+    info->is_data_sock_busy = false;
+    info->file_trans.size_count = 0;
+    info->file_trans.size_send = 0;
+
+    char line_buf[1024];
+    if(info->auth_type != 0)
+        len = mbtk_sock_read(info->ftp_ssl_handle,info->session,buff,sizeof(buff),FTP_TIMEOUT,&err);
+    else
+        len = sock_readline(&info->net_info, &info->sock_info[FTP_SOCK_CTRL], buff, 1024, FTP_TIMEOUT, &err);
+    if(len > 0)
+    {
+        printf("\n%s\n",buff);
+        if(err != 0)
+            printf("socket read error: %d\n",err);
+    }
+    else
+    {
+        printf("socket_read error:%d\n",err);
+        result = -1;
+    }
+
+    return result;
+}
+
+static mbtk_ftp_handle ftp_next_handle()
+{
+    if (!ftp_client_list)
+    {
+        LOGE("FTP Client List not init.");
+        return -1;
+    }
+
+    mbtk_ftp_info_s *info = NULL;
+    mbtk_ftp_handle handle = 1;
+    bool used;
+    while (handle <= FTP_HANDLE_MAX)
+    {
+        used = false;
+        // This handle used?
+        list_first(ftp_client_list);
+        while ((info = (mbtk_ftp_info_s*) list_next(ftp_client_list)))
+        {
+            if (handle == info->handle)
+            {
+                used = true;
+                break;
+            }
+        }
+
+        if (!used)
+        {
+            break;
+        }
+
+        handle++;
+    }
+
+    LOGI("Get free handle:%d", handle);
+
+    return handle;
+}
+
+static void ftp_free_func(void *data)
+{
+    if (data)
+    {
+        mbtk_ftp_info_s *info = (mbtk_ftp_info_s*) data;
+        LOGI("Free FTP client[handle = %d].", info->handle);
+        free(info);
+    }
+}
+
+/*************************************************************
+ Public Function Definitions
+ *************************************************************/
+mbtk_ftp_handle mbtk_ftp_init(const void* host, uint16 port, mbtk_ftp_auth_type_enum auth_type,
+                              bool is_ipv6, bool use_cert)
+{
+    if (!ftp_client_list)
+        ftp_client_list = list_create(ftp_free_func);
+
+    if (!ftp_client_list)
+    {
+        LOGE("FTP Client List not init.");
+        return -1;
+    }
+
+    if (list_size(ftp_client_list) > FTP_HANDLE_MAX)
+    {
+        LOGE("FTP client is full.");
+        return -1;
+    }
+
+    if (host == NULL || strlen(host) == 0)
+    {
+        LOGE("Host error.");
+        return -1;
+    }
+
+    if (port == 0)
+    {
+        port = FTP_SERVICE_PORT_DEF;
+    }
+
+    mbtk_ftp_info_s *info = (mbtk_ftp_info_s*) malloc(sizeof(mbtk_ftp_info_s));
+    if (!info)
+    {
+        LOGE("malloc() fail.");
+        return -1;
+    }
+    memset(info, 0x0, sizeof(mbtk_ftp_info_s));
+    list_add(ftp_client_list, info);
+    memcpy(info->sock_info[FTP_SOCK_CTRL].host, host, strlen(host));
+    info->sock_info[FTP_SOCK_CTRL].port = port;
+    // info->auth_type == FTP_AUTH_TYPE_IMPLICIT, info->is_ipv6 ? MBTK_ADDR_IPV6 : MBTK_ADDR_IPV4,info->use_cert,
+    info->sock_info[FTP_SOCK_CTRL].is_ssl = (auth_type == FTP_AUTH_TYPE_IMPLICIT);
+    info->sock_info[FTP_SOCK_CTRL].addr_family = is_ipv6 ? MBTK_ADDR_IPV6: MBTK_ADDR_IPV4;
+    info->sock_info[FTP_SOCK_CTRL].use_cert = use_cert;
+
+    info->handle = ftp_next_handle();
+    info->state = FTP_STATE_NON;
+    info->data_mode = FTP_MODE_PASSIVE;
+    info->sock_info[FTP_SOCK_CTRL].fd = -1;
+    info->sock_info[FTP_SOCK_DATA].fd = -1;
+    //info->is_ipv6 = is_ipv6;
+    info->auth_type = auth_type;
+    //info->use_cert = use_cert;
+
+    LOGI("FTP info#host:%s,port:%d,ipv6:%d,ssl:%d,cert:%d",info->sock_info[FTP_SOCK_CTRL].host,
+            info->sock_info[FTP_SOCK_CTRL].port,
+            is_ipv6,info->auth_type,use_cert);
+
+    if(auth_type != FTP_AUTH_TYPE_NON)
+    {
+        info->ftp_ssl_handle = mbtk_sock_init(&info->ftp_ssl_info);
+        if(info->ftp_ssl_handle == -1)
+        {
+            printf("mbtk_sock_init error\n");
+        }
+
+        info->ftp_sock_ssl_info = (mbtk_sock_info*) malloc(sizeof(mbtk_sock_info));
+        memset(info->ftp_sock_ssl_info, 0x0, sizeof(mbtk_sock_info));
+        info->ftp_sock_ssl_info->is_support_ssl = (auth_type != FTP_AUTH_TYPE_NON);
+        info->ftp_sock_ssl_info->ftp_ssl_support = 1;
+        info->ftp_sock_ssl_info->port = port;
+        info->ftp_sock_ssl_info->type = MBTK_SOCK_TCP;
+        info->ftp_sock_ssl_info->ingnore_cert = !use_cert;
+        memcpy(info->ftp_sock_ssl_info->address, host, strlen(host));
+    }
+    return info->handle;
+}
+
+mbtk_ftp_error_enum mbtk_ftp_reconfig(mbtk_ftp_handle handle,const void* host, uint16 port, mbtk_ftp_auth_type_enum auth_type,
+                                      bool is_ipv6, bool use_cert)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+    if(auth_type != FTP_AUTH_TYPE_NON)
+    {
+        info->ftp_sock_ssl_info = (mbtk_sock_info*) malloc(sizeof(mbtk_sock_info));
+        memset(info->ftp_sock_ssl_info, 0x0, sizeof(mbtk_sock_info));
+        if(host && strlen(host) > 0)
+        {
+            memcpy(info->ftp_sock_ssl_info->address, host, strlen(host));
+            info->ftp_sock_ssl_info->address[strlen(host)] = '\0';
+        }
+        info->ftp_sock_ssl_info->is_support_ssl = (auth_type != FTP_AUTH_TYPE_NON);
+        info->ftp_sock_ssl_info->ftp_ssl_support = 1;
+        info->ftp_sock_ssl_info->port = port;
+        info->ftp_sock_ssl_info->ingnore_cert = !use_cert;
+        info->ftp_sock_ssl_info->type = MBTK_SOCK_TCP;
+    }
+    if(info->state == FTP_STATE_NON)
+    {
+        if(host && strlen(host) > 0)
+        {
+            memcpy(info->sock_info[FTP_SOCK_CTRL].host, host, strlen(host));
+            info->sock_info[FTP_SOCK_CTRL].host[strlen(host)] = '\0';
+        }
+        info->sock_info[FTP_SOCK_CTRL].port = port;
+        info->sock_info[FTP_SOCK_CTRL].addr_family = is_ipv6 ? MBTK_ADDR_IPV6 : MBTK_ADDR_IPV4;
+        info->auth_type = auth_type;
+        info->sock_info[FTP_SOCK_CTRL].use_cert = use_cert;
+
+        return FTP_ERR_SUCCESS;
+    }
+    else
+    {
+        LOGE("Not reset FTP config.The state is %d", info->state);
+        return FTP_ERR_UNKNOWN;
+    }
+}
+
+mbtk_ftp_error_enum mbtk_ftp_user_set(mbtk_ftp_handle handle,void* user,void* pass)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    if(info->state == FTP_STATE_NON && !str_empty(user) && !str_empty(pass))
+    {
+        memset(&info->user,0x0,sizeof(mbtk_ftp_user_info_s));
+        memcpy(info->user.name, user, strlen(user));
+        memcpy(info->user.pass, pass, strlen(pass));
+        return FTP_ERR_SUCCESS;
+    }
+    else
+    {
+        LOGE("Not reset FTP config.The state is %d", info->state);
+        return FTP_ERR_UNKNOWN;
+    }
+}
+
+mbtk_ftp_error_enum mbtk_ftp_deinit(mbtk_ftp_handle handle)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    if (list_remove(ftp_client_list, info))
+    {
+        int err;
+        if(info->auth_type == FTP_AUTH_TYPE_NON) {
+            sock_close(&info->net_info, &info->sock_info[FTP_SOCK_CTRL], FTP_TIMEOUT, &err);
+            sock_close(&info->net_info, &info->sock_info[FTP_SOCK_DATA], FTP_TIMEOUT, &err);
+        } else {
+            mbtk_sock_deinit(info->ftp_ssl_handle);
+        }
+        ftp_free_func(info);
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+/*
+ * Quit FTP service.
+ */
+mbtk_ftp_error_enum mbtk_ftp_quit(mbtk_ftp_handle handle)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    int err = 0;
+    if(info->sock_info[FTP_SOCK_CTRL].fd > 0) {
+        mbtk_ftp_error_enum ftp_err = ftp_cmd_process(info, FTP_CMD_QUIT, NULL,
+                                      NULL);
+        if (ftp_err != FTP_ERR_SUCCESS)
+        {
+            LOGE("FTP QUIT fail[%d].", ftp_err);
+            //return ftp_err;
+        }
+
+        // FTP quit success.
+        info->state = FTP_STATE_CONNECTED;
+    }
+
+    if(info->auth_type == FTP_AUTH_TYPE_NON) {
+        if (sock_close(&info->net_info, &info->sock_info[FTP_SOCK_CTRL], FTP_TIMEOUT, &err))
+        {
+            LOGE("Close ctrl socket fail[%d].", err);
+            return FTP_ERR_NET_CLOSE;
+        }
+
+        if (sock_close(&info->net_info, &info->sock_info[FTP_SOCK_DATA], FTP_TIMEOUT, &err))
+        {
+            LOGE("Close data socket fail[%d].", err);
+            return FTP_ERR_NET_CLOSE;
+        }
+    } else {
+        if(mbtk_sock_close(info->ftp_ssl_handle,info->session,6000,&err))
+        {
+            LOGE("Close ssl ctrl socket fail[%d].", err);
+            //return FTP_ERR_NET_CLOSE;
+        }
+
+        if(mbtk_sock_close(info->ftp_ssl_handle,info->session_data,6000,&err))
+        {
+            LOGE("Close ssl data socket fail[%d].", err);
+            //return FTP_ERR_NET_CLOSE;
+        }
+    }
+
+
+    info->state = FTP_STATE_NON;
+    info->data_mode = FTP_MODE_PASSIVE;
+    memset(&info->file_trans, 0x0, sizeof(mbtk_ftp_file_trans_info_s));
+    info->sock_info[FTP_SOCK_CTRL].fd = -1;
+    info->sock_info[FTP_SOCK_DATA].fd = -1;
+
+    return FTP_ERR_SUCCESS;
+}
+
+mbtk_ftp_error_enum mbtk_ftp_net_close(mbtk_ftp_handle handle)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    if(info->net_info.net_id > 0) {
+        int err;
+        if(sock_net_close(&info->net_info, FTP_TIMEOUT,&err))
+        {
+            LOGE("sock_net_close() fail[%ld].",err);
+            return FTP_ERR_NET_CLOSE;
+        }
+
+        info->net_info.net_id = -1;
+    }
+
+    return FTP_ERR_SUCCESS;
+}
+
+
+mbtk_ftp_info_s* mbtk_ftp_info_get(mbtk_ftp_handle handle)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return NULL;
+    }
+
+    return info;
+}
+
+/*
+ * Login specified FTP service.
+ */
+mbtk_ftp_error_enum mbtk_ftp_login(mbtk_ftp_handle handle, void *name,
+                                   void *pass)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    if (info->state == FTP_STATE_NON)
+    {
+        mbtk_ftp_user_info_s user;
+        memset(&user,0x0,sizeof(mbtk_ftp_user_info_s));
+        if (!str_empty(name) && !str_empty(pass))
+        {
+            memcpy(user.name, name, strlen(name));
+            memcpy(user.pass, pass, strlen(pass));
+            memcpy(info->user.name, name, strlen(name));
+            memcpy(info->user.pass, pass, strlen(pass));
+        }
+        else
+        {
+            memcpy(user.name, FTP_ANONYMOUS_USER, strlen(FTP_ANONYMOUS_USER));
+            memcpy(user.pass, FTP_ANONYMOUS_PASS, strlen(FTP_ANONYMOUS_PASS));
+            memcpy(info->user.name, FTP_ANONYMOUS_USER, strlen(FTP_ANONYMOUS_USER));
+            memcpy(info->user.pass, FTP_ANONYMOUS_PASS, strlen(FTP_ANONYMOUS_PASS));
+        }
+
+        LOGI("FTP login#user:%s,pass:%s",user.name,user.pass);
+
+        if(info->auth_type != 0)
+        {
+            int mbtk_errno=-1;
+            info->session = mbtk_sock_open(info->ftp_ssl_handle,info->ftp_sock_ssl_info,60000,&mbtk_errno);
+            if(mbtk_errno!=0)
+            {
+                printf("mbtk_sock_open error : %d\n",mbtk_errno);
+            }
+            else
+            {
+                unsigned char mbtk_ftp_ssl_read_buf[16384 + 1];
+                char cmd[50];
+                memset(cmd,0,50);
+                int len_ssl;
+
+
+                memset(cmd,0,50);
+                snprintf(cmd, 50, "PBSZ 0\r\n");
+                mbtk_sock_write(info->ftp_ssl_handle,info->session,
+                                    cmd,
+                                    sizeof(cmd),
+                                    60000,
+                                    &mbtk_errno);
+                memset(mbtk_ftp_ssl_read_buf,0,sizeof(mbtk_ftp_ssl_read_buf));
+                mbtk_sock_read(info->ftp_ssl_handle,info->session,
+                            mbtk_ftp_ssl_read_buf,
+                            sizeof(mbtk_ftp_ssl_read_buf),
+                            60000,
+                            &mbtk_errno);
+                printf("\nmbtk_sock_read PBSZ 0:\n%s\n",mbtk_ftp_ssl_read_buf);
+                memset(cmd,0,50);
+                snprintf(cmd, 50, "PROT P\r\n");
+                mbtk_sock_write(info->ftp_ssl_handle,info->session,
+                                    cmd,
+                                    sizeof(cmd),
+                                    60000,
+                                    &mbtk_errno);
+                memset(mbtk_ftp_ssl_read_buf,0,sizeof(mbtk_ftp_ssl_read_buf));
+                mbtk_sock_read(info->ftp_ssl_handle,info->session,
+                            mbtk_ftp_ssl_read_buf,
+                            sizeof(mbtk_ftp_ssl_read_buf),
+                            60000,
+                            &mbtk_errno);
+                printf("\nmbtk_sock_read PROT P:\n%s\n",mbtk_ftp_ssl_read_buf);
+                memset(cmd,0,50);
+                snprintf(cmd, 50, "USER %s\r\n",info->user.name);
+                mbtk_sock_write(info->ftp_ssl_handle,info->session,
+                                    cmd,
+                                    sizeof(cmd),
+                                    60000,
+                                    &mbtk_errno);
+                memset(mbtk_ftp_ssl_read_buf,0,sizeof(mbtk_ftp_ssl_read_buf));
+                mbtk_sock_read(info->ftp_ssl_handle,info->session,
+                            mbtk_ftp_ssl_read_buf,
+                            sizeof(mbtk_ftp_ssl_read_buf),
+                            60000,
+                            &mbtk_errno);
+                printf("\nmbtk_sock_read USER:\n%s\n",mbtk_ftp_ssl_read_buf);
+                memset(cmd,0,50);
+                snprintf(cmd, 50, "PASS %s\r\n",info->user.pass);
+                mbtk_sock_write(info->ftp_ssl_handle,info->session,
+                                    cmd,
+                                    sizeof(cmd),
+                                    60000,
+                                    &mbtk_errno);
+                memset(mbtk_ftp_ssl_read_buf,0,sizeof(mbtk_ftp_ssl_read_buf));
+                mbtk_sock_read(info->ftp_ssl_handle,info->session,
+                            mbtk_ftp_ssl_read_buf,
+                            sizeof(mbtk_ftp_ssl_read_buf),
+                            60000,
+                            &mbtk_errno);
+                printf("\nmbtk_sock_read PASS:\n%s\n",mbtk_ftp_ssl_read_buf);
+                char *ptr = NULL;
+                if((ptr = strstr(mbtk_ftp_ssl_read_buf,"220 ")) || (ptr = strstr(mbtk_ftp_ssl_read_buf,"230 "))) {
+                    LOGI("RSP:%s",ptr);
+                    printf("RSP:%s\n",ptr);
+                }
+                else
+                {
+                    printf("\nptr error.\n");
+                    return FTP_ERR_UNKNOWN;
+                }
+                int code = atoi(ptr);
+                if (code / 100 == 2)   // USER/PASS is 2xx
+                {
+                    info->state = FTP_STATE_READY;
+                    LOGI("FTP logn in success.");
+                    printf("FTP logn in success.\n");
+                }
+                else if (code == 332)   // // USER/PASS is 332
+                {
+                    LOGW("Should set ACCT.");
+                    printf("Should set ACCT.\n");
+                    return FTP_ERR_UNKNOWN;
+                }
+                else
+                {
+                    LOGE("FTP login denied[code = %d].", code);
+                    printf("FTP login denied[code = %d].\n", code);
+                    return FTP_ERR_UNKNOWN;
+                }
+
+                memset(cmd,0,50);
+                snprintf(cmd, 50, "PWD\r\n");
+                mbtk_sock_write(info->ftp_ssl_handle,info->session,
+                                    cmd,
+                                    sizeof(cmd),
+                                    60000,
+                                    &mbtk_errno);
+                memset(mbtk_ftp_ssl_read_buf,0,sizeof(mbtk_ftp_ssl_read_buf));
+                mbtk_sock_read(info->ftp_ssl_handle,info->session,
+                            mbtk_ftp_ssl_read_buf,
+                            sizeof(mbtk_ftp_ssl_read_buf),
+                            60000,
+                            &mbtk_errno);
+                printf("\nmbtk_sock_read PWD:\n%s\n",mbtk_ftp_ssl_read_buf);
+            }
+            return mbtk_errno;
+        }
+
+        return ftp_login(info,&user);
+    }
+    else
+    {
+        LOGD("Has login.");
+        return FTP_ERR_SUCCESS;
+    }
+}
+
+/*
+ * Get current directory's path.
+ */
+mbtk_ftp_error_enum mbtk_ftp_pwd(mbtk_ftp_handle handle, void *path)
+{
+    if (!path)
+    {
+        LOGE("No set path");
+        return FTP_ERR_PARAM_SET;
+    }
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return ftp_cmd_process(info, FTP_CMD_PWD, NULL, path);
+}
+
+/*
+ * Go to specified directory.
+ */
+mbtk_ftp_error_enum mbtk_ftp_cd(mbtk_ftp_handle handle, void *path)
+{
+    if (!path)
+    {
+        LOGE("No set path");
+        return FTP_ERR_PARAM_SET;
+    }
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return ftp_cmd_process(info, FTP_CMD_CWD, path, NULL);
+}
+
+/*
+ * Get the native ip and free port.
+ */
+mbtk_ftp_error_enum mbtk_ftp_get_ip_and_port(char *ipBuf_out,
+                                    int *port,int iptype)
+{
+    char psz_port_cmd[128];
+    int i=0;
+
+    *port = rand() % (60000 - 50000 + 1) + 50000;
+    sprintf(psz_port_cmd, "netstat -an | grep :%d > /dev/null", *port);
+
+        char ipBuf[32] = "";
+        FILE *fstream=NULL;
+
+        char buff[1024];
+        char iptype_str[8];
+        memset(buff,0,sizeof(buff));
+        /*eth0可以换成eth1、docker0、em1、lo等*/
+        if(iptype == MBTK_ADDR_IPV6)
+        {
+
+            if(NULL==(fstream=popen("ifconfig ccinet0 | grep \"inet6 addr: 2\" | awk '{print $3}'","r")))
+            {
+                snprintf(ipBuf, 39, "%s","0:0:0:0:0:0:0:0");
+            }
+            if(NULL!=fgets(buff, sizeof(buff), fstream))
+            {
+                snprintf(ipBuf, 39, "%s",buff);
+            }
+            else
+            {
+                snprintf(ipBuf, 39, "%s","0:0:0:0:0:0:0:0");
+                pclose(fstream);
+            }
+        }
+        else
+        {
+            if(NULL==(fstream=popen("ifconfig ccinet0 | grep \"inet addr:\" | awk \'{print $2}\' | cut -c 6-","r")))
+            {
+                snprintf(ipBuf, 18, "%s","0.0.0.0");
+            }
+            if(NULL!=fgets(buff, sizeof(buff), fstream))
+            {
+                snprintf(ipBuf, 18, "%s",buff);
+            }
+            else
+            {
+                snprintf(ipBuf, 18, "%s","0.0.0.0");
+                pclose(fstream);
+            }
+        }
+            pclose(fstream);
+
+        printf("ip:%s\n", ipBuf);
+        memcpy(ipBuf_out, ipBuf, 32);
+        return 0;
+}
+/*
+ * Get current directory's subdirectory.
+ */
+mbtk_ftp_error_enum mbtk_ftp_dir_ls(mbtk_ftp_handle handle,
+                                    mbtk_ftp_file_info_s *list_head)
+{
+    if (!list_head)
+    {
+        LOGE("No set file list.");
+        return FTP_ERR_PARAM_SET;
+    }
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return ftp_cmd_process(info, FTP_CMD_LIST, NULL, list_head);
+}
+
+/*
+ * Get specified file's size.
+ */
+uint32 mbtk_ftp_file_size(mbtk_ftp_handle handle, void *path)
+{
+    if (!path)
+    {
+        LOGE("No set path");
+        return 0;
+    }
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return 0;
+    }
+    uint32 size = 0;
+    if (ftp_cmd_process(info, FTP_CMD_SIZE, path, &size) != FTP_ERR_SUCCESS)
+        return 0;
+
+    return size;
+}
+
+/*
+ * Get specified file's modify time.
+ */
+mbtk_ftp_error_enum mbtk_ftp_file_time(mbtk_ftp_handle handle, void *path,
+                                       void *time)
+{
+    if (!path)
+    {
+        LOGE("No set path");
+        return FTP_ERR_PARAM_SET;
+    }
+
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return ftp_cmd_process(info, FTP_CMD_MDTM, path, time);
+}
+
+/*
+ * Delete specified file.
+ */
+mbtk_ftp_error_enum mbtk_ftp_file_del(mbtk_ftp_handle handle, void *path)
+{
+    if (!path)
+    {
+        LOGE("No set path");
+        return FTP_ERR_PARAM_SET;
+    }
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return ftp_cmd_process(info, FTP_CMD_DELE, path, NULL);
+}
+
+/*
+ * Create specified directory.
+ */
+mbtk_ftp_error_enum mbtk_ftp_dir_mkdir(mbtk_ftp_handle handle, void *path)
+{
+    if (!path)
+    {
+        LOGE("No set path");
+        return FTP_ERR_PARAM_SET;
+    }
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return ftp_cmd_process(info, FTP_CMD_MKD, path, NULL);
+}
+
+/*
+ * Delete specified directory.
+ */
+mbtk_ftp_error_enum mbtk_ftp_dir_rmdir(mbtk_ftp_handle handle, void *path)
+{
+    if (!path)
+    {
+        LOGE("No set path");
+        return FTP_ERR_PARAM_SET;
+    }
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return ftp_cmd_process(info, FTP_CMD_RMD, path, NULL);
+}
+
+/*
+ * Set data type.
+ */
+mbtk_ftp_error_enum mbtk_ftp_data_type_set(mbtk_ftp_handle handle,
+        mbtk_ftp_data_type_enum data_type)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    return ftp_cmd_process(info, FTP_CMD_TYPE, &data_type, NULL);
+}
+
+/*
+ * Set FTP mode.
+ */
+mbtk_ftp_error_enum mbtk_ftp_mode_set(mbtk_ftp_handle handle,
+                                      mbtk_ftp_mode_enum mode)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    info->data_mode = mode;
+
+    return FTP_ERR_SUCCESS;
+}
+
+uint32 mbtk_ftp_download_start(mbtk_ftp_handle handle, void *remote_path,
+                               void *local_path, mbtk_data_cb_func data_cb)
+{
+    if (!remote_path || (local_path && data_cb) || (!local_path && !data_cb))
+    {
+        LOGE("Param set error.");
+        return 0;
+    }
+
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return 0;
+    }
+
+    if (info->state >= FTP_STATE_READY && !info->is_trans)
+    {
+        int retry_time = 0;
+        memset(&info->file_trans, 0x0, sizeof(mbtk_ftp_file_trans_info_s));
+
+        // Set data type to "I"
+        if (FTP_ERR_SUCCESS
+            != mbtk_ftp_data_type_set(handle, FTP_DATA_TYPE_I))
+        {
+            LOGE("Set data type to I fail.");
+            return 0;
+        }
+
+        // Get file size.
+        info->file_trans.size_count = mbtk_ftp_file_size(handle, remote_path);
+        if (info->file_trans.size_count > 0)
+        {
+            LOGI("File size:%d", info->file_trans.size_count);
+        }
+        else
+        {
+            LOGE("File not exist.");
+            return 0;
+        }
+
+        //Get file modify time.
+        if (FTP_ERR_SUCCESS
+            != mbtk_ftp_file_time(handle, remote_path,
+                                  (char*) info->file_trans.modify_time))
+        {
+            LOGE("Get file modify time fail.");
+            return 0;
+        }
+
+        memcpy(info->file_trans.remote_name, remote_path,
+               strlen((char*) remote_path));
+        if (local_path)
+        {
+            memcpy(info->file_trans.local_name, local_path,
+                   strlen((char*) local_path));
+            info->file_trans.data_cb = NULL;
+        }
+        else
+        {
+            info->file_trans.data_cb = data_cb;
+        }
+        info->file_trans.size_send = 0;
+        info->file_trans.is_download = true;
+        info->file_trans.fd = -1;
+        info->is_trans = true;
+
+        if (!info->file_trans.data_cb)   // Save to efs
+        {
+            info->file_trans.fd = file_open((const char*)info->file_trans.local_name,
+                                            O_WRONLY | O_CREAT | O_TRUNC);
+            if (info->file_trans.fd <= 0)
+            {
+                LOGE("Can not open EFS file[%s].", info->file_trans.local_name);
+                return 0;
+            }
+        }
+
+        do {
+            // Start download file.
+            if (FTP_ERR_SUCCESS
+                != ftp_data_sock_read(info, FTP_CMD_GET, NULL, NULL))
+            {
+                LOGW("ftp_data_sock_read() fail.");
+            }
+
+            if(info->sock_info[FTP_SOCK_CTRL].fd <= 0) {
+                // Download fail.
+                LOGW("Ctrl socket error,should login angin.");
+                break;
+            } else if (info->file_trans.size_send == info->file_trans.size_count) {
+                // Download success
+                break;
+            }
+
+            // Should redownload without quit.
+            char time[20] = { 0 };
+            if (FTP_ERR_SUCCESS
+                != mbtk_ftp_file_time(handle, info->file_trans.remote_name,
+                                      time))
+            {
+                LOGE("Get file modify time fail.");
+                break;
+            }
+
+            if (strcmp(time, (char*) info->file_trans.modify_time))
+            {
+                LOGW("Service file changed.");
+                break;
+            }
+
+            retry_time++;
+        } while(retry_time < 5);
+
+
+        if (!info->file_trans.data_cb && info->file_trans.fd > 0)   // Save to efs
+        {
+            if (file_close(info->file_trans.fd))
+            {
+                LOGE("EFS close fail.");
+                return 0;
+            }
+        }
+
+        // Download success.
+        if (info->file_trans.size_send == info->file_trans.size_count)
+        {
+            LOGI("Download %s success[%d].", (char* )remote_path,
+                 info->file_trans.size_count);
+
+            // Reset download configs.
+            info->is_trans = false;
+            // memset(&info->file_trans, 0x0, sizeof(mbtk_ftp_file_trans_info_s));
+        }
+        else
+        {
+            LOGW("Download %s fail[%d / %d].", (char* )remote_path,
+                 info->file_trans.size_send, info->file_trans.size_count);
+        }
+
+        return info->file_trans.size_send;
+    }
+    else
+    {
+        LOGE("FTP state error[%d].", info->state);
+        return 0;
+    }
+}
+
+uint32 mbtk_ftp_download_continue(mbtk_ftp_handle handle)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return 0;
+    }
+
+    if(info->state == FTP_STATE_NON) {
+        if(FTP_ERR_SUCCESS != ftp_login(info,&info->user)) {
+            LOGE("FTP login fail.");
+            return 0;
+        }
+    }
+
+    if (info->state >= FTP_STATE_READY && info->is_trans
+        && info->file_trans.is_download
+        && info->file_trans.size_send < info->file_trans.size_count)
+    {
+        // Set data type to "I"
+        if (FTP_ERR_SUCCESS
+            != mbtk_ftp_data_type_set(handle, FTP_DATA_TYPE_I))
+        {
+            LOGE("Set data type to I fail.");
+            return 0;
+        }
+
+        // Get file size.
+        uint32 size = mbtk_ftp_file_size(handle, info->file_trans.remote_name);
+        if (size > 0)
+        {
+            LOGI("File size:%d", size);
+        }
+        else
+        {
+            LOGE("File not exist.");
+            return 0;
+        }
+        if (size != info->file_trans.size_count)
+        {
+            LOGW("Service file changed.");
+            return 0;
+        }
+
+        //Get file modify time.
+        char time[20] = { 0 };
+        if (FTP_ERR_SUCCESS
+            != mbtk_ftp_file_time(handle, info->file_trans.remote_name,
+                                  time))
+        {
+            LOGE("Get file modify time fail.");
+            return 0;
+        }
+        if (strcmp(time, (char*) info->file_trans.modify_time))
+        {
+            LOGW("Service file changed.");
+            return 0;
+        }
+
+        if (!info->file_trans.data_cb)   // Save to efs
+        {
+            info->file_trans.fd = file_open((const char*)info->file_trans.local_name,
+                                            O_WRONLY | O_CREAT | O_APPEND);
+            if (info->file_trans.fd <= 0)
+            {
+                LOGE("Can not open EFS file[%s].", info->file_trans.local_name);
+                return FTP_ERR_EFS_FILE;
+            }
+        }
+
+        uint32 size_last = info->file_trans.size_send;
+        // Start download file.
+        if (FTP_ERR_SUCCESS
+            != ftp_data_sock_read(info, FTP_CMD_GET, NULL, NULL))
+        {
+            LOGW("Data download fail.");
+        }
+
+        if (!info->file_trans.data_cb && info->file_trans.fd > 0)
+        {
+            if (file_close(info->file_trans.fd))
+            {
+                LOGE("EFS close fail.");
+                return 0;
+            }
+        }
+
+        // Download success.
+        if (info->file_trans.size_send == info->file_trans.size_count)
+        {
+            LOGI("Download %s success[%d].", info->file_trans.remote_name,
+                 info->file_trans.size_count);
+
+            // Reset download configs.
+            info->is_trans = false;
+            //memset(&info->file_trans, 0x0, sizeof(mbtk_ftp_file_trans_info_s));
+        }
+        else
+        {
+            LOGW("Download %s fail[%d / %d].", info->file_trans.remote_name,
+                 info->file_trans.size_send, info->file_trans.size_count);
+        }
+
+        return info->file_trans.size_send - size_last;
+    }
+    else
+    {
+        LOGE("FTP state error[%d].", info->state);
+        return 0;
+    }
+}
+
+/*
+* Upload EFS:  local_path is efs path;size_byte is 0.
+* Upload data: local_path is NULL;size_byte is data size.
+*/
+int mbtk_ftp_upload_start(mbtk_ftp_handle handle, const void *remote_path,
+                          const void *local_path, uint32 size_byte)
+{
+    if (!remote_path || (size_byte == 0 && !local_path)
+        || (size_byte > 0 && local_path))
+    {
+        LOGE("Param set error.");
+        return -1;
+    }
+
+	int result = 0;
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return -1;
+    }
+
+    LOGE("info->state:%d, info->is_trans:%d", info->state,info->is_trans);
+
+    if (info->state >= FTP_STATE_READY && !info->is_trans)
+    {
+		        // Set data type to "I"
+        if (FTP_ERR_SUCCESS
+            != mbtk_ftp_data_type_set(handle, FTP_DATA_TYPE_I))
+        {
+            LOGE("Set data type to I fail.");
+            return -1;
+        }
+
+        memset(&info->file_trans, 0x0, sizeof(mbtk_ftp_file_trans_info_s));
+        info->file_trans.is_download = false;
+
+        memcpy(info->file_trans.remote_name, remote_path,
+               strlen((char*) remote_path));
+
+        if (local_path)
+        {
+            memcpy(info->file_trans.local_name, local_path,
+                   strlen((char*) local_path));
+            info->file_trans.fd = file_open((const char*)info->file_trans.local_name,
+                                            O_RDONLY);
+            if (info->file_trans.fd <= 0)
+            {
+                LOGE("Can not open EFS file[%s].", info->file_trans.local_name);
+                return -1;
+            }
+
+        }
+        info->file_trans.size_count = size_byte;
+        info->file_trans.size_send = 0;
+        // Start upload data.
+
+
+	    // Start update file.
+        if (FTP_ERR_SUCCESS != ftp_data_sock_read(info, FTP_CMD_PUT, NULL, NULL))
+        {
+            LOGW("ftp_data_sock_read() fail.");
+			if(info->file_trans.size_count == info->file_trans.size_send && info->file_trans.size_send != 0)
+			{
+				result = FTP_ERR_SUCCESS;
+			}
+			else
+			{
+			    mbtk_at_ftp_par.rest_size = info->file_trans.size_send;
+				result = FTP_ERR_UNKNOWN;
+			}
+        }
+
+		if (info->file_trans.fd > 0 )   // Save to efs
+		{
+            info->file_trans.size_count = 0;
+			info->file_trans.size_send = 0;
+			if (file_close(info->file_trans.fd))
+			{
+				LOGE("EFS close fail.");
+				return -1;
+			}
+		}
+
+    }
+    else
+    {
+        LOGE("FTP state error[%d].", info->state);
+        return -1;
+    }
+
+    return result;
+}
+
+/*
+* This only for upload data(No for upload efs).
+*/
+int mbtk_ftp_upload_send(mbtk_ftp_handle handle, const void *data,uint16 data_len)
+{
+    if (!data || data_len == 0)
+    {
+        LOGE("Param set error.");
+        return -1;
+    }
+
+    int err;
+	int result = 0;
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return -1;
+    }
+
+    if(info->file_trans.fd > 0)   // Is upload from efs.
+    {
+        LOGE("Not upload from EFS.");
+        return -1;
+    }
+
+//LOGE("1socket:%d, data:%s, data_len:%d", info->sock_info[FTP_SOCK_DATA].fd, data, data_len );
+    if((info->file_trans.size_send + data_len) > info->file_trans.size_count)
+	{
+		printf("send over set length\n");
+        result = FTP_ERR_UNKNOWN;
+        goto overlong;
+    }
+    int len;
+    if(info->auth_type != 0)
+        len = mbtk_sock_write(info->ftp_ssl_handle,info->session_data,data,data_len,FTP_TIMEOUT,&err);
+    else
+	    len = sock_write(&info->net_info, &info->sock_info[FTP_SOCK_DATA], data, data_len,
+                            FTP_TIMEOUT, &err);
+	if(len < 0)
+	{
+		LOGE("EFS write fail.len:%d, err；%d", len, err);
+        return FTP_ERR_EFS_FILE;
+	}
+
+	info->file_trans.size_send += len;
+    mbtk_at_ftp_par.rest_size = info->file_trans.size_send;
+
+    LOGE("size_count:%d, size_send:%d.", info->file_trans.size_count,info->file_trans.size_send);
+
+    if((info->file_trans.size_count <= info->file_trans.size_send) )
+	{
+	    printf("\nClose data socket begin!\n ");
+			    // Close data socket.
+overlong:    if (info->sock_info[FTP_SOCK_DATA].fd > 0)
+	    {
+	        if (sock_close(&info->net_info, &info->sock_info[FTP_SOCK_DATA], FTP_TIMEOUT, &err))
+	        {
+	            LOGE("Close data socket fail[%d].", err);
+                printf("\nClose data socket fail[%d].\n", err);
+	            result = FTP_ERR_NET_CLOSE;
+	        }
+	        else
+	        {
+	            printf("\nClose data socket ok[%d].\n", err);
+	        //    info->sock_info[FTP_SOCK_DATA].fd = -1;
+	        }
+	    }
+        if(info->auth_type != 0)
+        {
+            if(mbtk_sock_close(info->ftp_ssl_handle,info->session_data,6000,&err))
+            {
+	            LOGE("Close ssl data socket fail[%d].", err);
+                printf("\nClose ssl data socket fail[%d].\n", err);
+	            result = FTP_ERR_NET_CLOSE;
+	        }
+	        else
+	        {
+	            printf("\nClose ssl data socket ok[%d].\n", err);
+	        //    info->sock_info[FTP_SOCK_DATA].fd = -1;
+	        }
+        }
+        info->data_mode = FTP_MODE_PASSIVE;
+        info->is_data_sock_busy = false;
+        info->file_trans.size_count = 0;
+        info->file_trans.size_send = 0;
+	}
+	else
+	{
+		LOGE("size_count:%d, size_send:%d.", info->file_trans.size_count,info->file_trans.size_send);
+	}
+
+
+    // Start update data.
+
+    return result;
+}
+
+mbtk_ftp_error_enum mbtk_ftp_trans_reset(mbtk_ftp_handle handle)
+{
+    mbtk_ftp_info_s *info = ftp_info_find(handle);
+    if (!info)
+    {
+        LOGE("No such FTP handle:%d", handle);
+        return FTP_ERR_UNKNOWN;
+    }
+
+    info->is_trans = false;
+    memset(&info->file_trans, 0x0, sizeof(mbtk_ftp_file_trans_info_s));
+
+    return FTP_ERR_SUCCESS;
+}
+
+