lynq/S300AI/ap/app/wefota/wefota_main.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include "wefota_main.h"
#include "wefota_socket.h"
#include "wefota_device.h"

#define RECV_WHOLE_PACK 1

static FOTA_Status s_status = FOTA_STATUS_IDLE;
static struct sockaddr_in s_server1_addr = {0};
static struct sockaddr_in s_server2_addr = {0};
static unsigned char s_req[WEFOTA_REQ_MAX_LEN] = {0};
static unsigned char s_resp[WEFOTA_RESP_MAX_LEN] = {0};
static char s_destVersion[32] = {0};
static VerID s_verID = {0};
static DiffPackInfo s_diffpack_info = {0};
static unsigned int s_costTime = 0;
static unsigned int s_pack_date_count = 0;
static DiffPackDataReq s_diffpack_data_req = {0};

const WeFOTA_MSG s_wefota_msg_table[] = {
    {FOTA_STATUS_IDLE, 0xFF, 0, 0x00, 0}, // no use
    {FOTA_STATUS_GET_IP_1, 0x10, 0, 0x11, 18},
    {FOTA_STATUS_CHECK_TASK, 0xBF, 32, 0xC0, 41},
    {FOTA_STATUS_GET_IP_2, 0x10, 0, 0x11, 18},
    {FOTA_STATUS_GET_VER_ID, 0x04, 68, 0x05, 12},
    {FOTA_STATUS_GET_DIFF_PACK_ID, 0x00, 12, 0x02, 35},
    {FOTA_STATUS_GET_DIFF_PACK_DATA, 0x01, 23, 0x03, WEFOTA_RESP_DIFF_PACK_DATA_MAX_LEN},
    {FOTA_STATUS_GET_DIFF_PACK_END, 0x30, 19, 0x33, 0},
    {FOTA_STATUS_INSTALL_DIFF_PACK, 0xFF, 0, 0x00, 0}, // no use
    {FOTA_STATUS_MAX, 0xFF, 0, 0x00, 0}, // no use
};

void set_fota_status(FOTA_Status status) {
    s_status = status;
}

FOTA_Status get_fota_status(void) {
    return s_status;
}

int wefota_header_init(WeFOTAHeader *hdr) {
    if(NULL == hdr) {
        return -1;
    }

    memset(hdr, 0, sizeof(WeFOTAHeader));
    hdr->magic = WEFOTA_HEADER_MAGIC; // maybe need htonl
    hdr->protocol = WEFOTA_HEADER_PROTOCOL;
    get_iccid(hdr->iccid);
    get_imei(hdr->devid + 16);
    hdr->tid = WEFOTA_HEADER_TID;
    
    hdr->code = s_wefota_msg_table[s_status].req_code;
    int count = s_wefota_msg_table[s_status].req_count;
    hdr->count = htons(count);

	printf("header:[imei:%s]\n", hdr->devid + 16);
    return count;
}

int is_valid_resp_hdr(const WeFOTAHeader *hdr) {
    if(NULL == hdr) {
        return 0;
    }
    if(hdr->magic != WEFOTA_HEADER_MAGIC && hdr->magic != htonl(WEFOTA_HEADER_MAGIC)) {
        return 0;
    }
    if(hdr->protocol != WEFOTA_HEADER_PROTOCOL) {
        return 0;
    }

    return 1;
}

int init_wefota_server1_addr(void) {
    char ip[16] = {0};
    int port = 0;
    get_wefota_server1_cfg(ip, &port);
    return init_server_addr(&s_server1_addr, ip, port);
}

int init_wefota_server2_addr(const char *ip, int port) {
    int ret = init_server_addr(&s_server2_addr, ip, port);
    if(0 == ret) {
        set_wefota_server2_cfg(ip, port);
    }
    return ret;
}

int recv_with_retry(int sock, struct sockaddr_in* server_addr, 
                    unsigned char* response, size_t response_size, int max_retries) {
    if (NULL == response || response_size < WEFOTA_HEADER_SIZE) {
        return -1;
    }
    int retry_count = 0;
    int recv_date_err = 0;
	while (retry_count < max_retries) {
        do {
            recv_date_err = 0;
            WeFOTAHeader *hdr = (WeFOTAHeader *)response;
            int received = receive_message(sock, hdr, response_size, server_addr);
            printf("received=%d\n", received);
            if (received < WEFOTA_HEADER_SIZE) {
                printf("recv header failed\n");
                break;
            }
            if (0 == is_valid_resp_hdr(hdr)) {
                printf("recv invalid header\n");
                break;
            }
            printf("recv code=%d, count=%d)\n", hdr->code, hdr->count);
            if (hdr->count + WEFOTA_HEADER_SIZE != received) {
                printf("recv count error\n");
                break;
            }

			if (s_status == FOTA_STATUS_GET_DIFF_PACK_DATA)
			{
				if (hdr->code == s_wefota_msg_table[s_status].resp_code && hdr->count == s_pack_date_count)
				{
					DiffPackDataResp * data = (DiffPackDataResp *)(s_resp + WEFOTA_HEADER_SIZE);
					printf("proc_get_diff_pack_data recv [data->offset %u offset:%u][data->length %u length:%u]\n", 
					       data->offset, s_diffpack_data_req.offset, data->length, s_diffpack_data_req.length);
					if (data->offset == s_diffpack_data_req.offset || data->length == s_diffpack_data_req.length) {
						return received;
					}
				}
				printf("proc_get_diff_pack_data recv wrong data\n");
				recv_date_err = 1;
				break;
			}
			else
			{
            	if (hdr->code == s_wefota_msg_table[s_status].resp_code
                 	&& hdr->count == s_wefota_msg_table[s_status].resp_count) { // code and count right
                	return received;
            	} else { // code or count wrong
                	break;
            	}
			}
        }while(0);

        printf("retry (%d/%d)\n", retry_count + 1, max_retries);
		if (recv_date_err == 0)
		{
        	retry_count++;
		}
    }
    
    return -1;
}

#ifdef RECV_WHOLE_PACK
int send_with_retry(int sock, const unsigned char* msg, size_t len, struct sockaddr_in* server_addr, 
                    unsigned char* response, size_t response_size, int max_retries) {
    if (NULL == msg || NULL == response || 0 == len || response_size < WEFOTA_HEADER_SIZE) {
        return -1;
    }
    int retry_count = 0;
    while (retry_count < max_retries) {
        do {
            if (send_message(sock, msg, len, server_addr) < 0) {
                printf("send message failed\n");
                break;
            }
#if 0
            WeFOTAHeader *hdr = (WeFOTAHeader *)response;;
            int received = receive_message(sock, hdr, response_size, server_addr);
            printf("received=%d\n", received);
            if (received < WEFOTA_HEADER_SIZE) {
                printf("recv header failed\n");
                break;
            }
            if (0 == is_valid_resp_hdr(hdr)) {
                printf("recv invalid header\n");
                break;
            }
            printf("recv code=%d, count=%d)\n", hdr->code, hdr->count);
            if (hdr->count + WEFOTA_HEADER_SIZE != received) {
                printf("recv count error\n");
                break;
            }

			if (s_status == FOTA_STATUS_GET_DIFF_PACK_DATA)
			{
				if (hdr->code == s_wefota_msg_table[s_status].resp_code && hdr->count == s_pack_date_count)
				{
					return received;
				}
				else
				{
					return -1;
				}
			}
			else
			{
            	if (hdr->code == s_wefota_msg_table[s_status].resp_code
                 	&& hdr->count == s_wefota_msg_table[s_status].resp_count) { // code and count right
                	return received;
            	} else { // code or count wrong
                	return -1;
            	}
			}
#endif
			int received = recv_with_retry(sock, server_addr, response, response_size, max_retries);
			if (received > 0)
			{
				return received;
			}
        }while(0);

        printf("retry (%d/%d)\n", retry_count + 1, max_retries);
        retry_count++;
        sleep(WEFOTA_TIMEOUT_SEC);
    }
    
    return -1;
}
#else
int send_with_retry(int sock, const unsigned char* msg, size_t len, struct sockaddr_in* server_addr, 
                    unsigned char* response, size_t response_size, int max_retries) {
    if (NULL == msg || NULL == response || 0 == len || response_size < WEFOTA_HEADER_SIZE) {
        return -1;
    }
    int retry_count = 0;
    while (retry_count < max_retries) {
        do {
            if (send_message(sock, msg, len, server_addr) < 0) {
                printf("send message failed\n");
                break;
            }

            WeFOTAHeader *hdr = (WeFOTAHeader *)response;;
            int received = receive_message(sock, hdr, WEFOTA_HEADER_SIZE, server_addr);
            printf("received=%d\n", received);
            if (received != WEFOTA_HEADER_SIZE) {
                printf("recv header failed\n");
                break;
            }
            if (0 == is_valid_resp_hdr(hdr)) {
                printf("recv invalid header\n");
                break;
            }
            printf("recv code=%d, count=%d)\n", hdr->code, hdr->count);
            if (hdr->count + WEFOTA_HEADER_SIZE > response_size) {
                printf("recv count > response_size\n");
                break;
            }

            if (hdr->code == s_wefota_msg_table[s_status].resp_code
                 && hdr->count == s_wefota_msg_table[s_status].resp_count) { // code and count right
                if (hdr->count == 0) {
                    return 0;
                } else {
                    received = receive_message(sock, response + WEFOTA_HEADER_SIZE, hdr->count, server_addr);
                    printf("recv data len=%d\n", received);
                    return received;
                }
            } else { // code or count wrong
                if (hdr->count == 0) {
                    return -1;
                } else {
                    received = receive_message(sock, response + WEFOTA_HEADER_SIZE, hdr->count, server_addr);
                    printf("recv data len=%d, drop\n", received);
                    return -1;
                }
            }
        }while(0);

        printf("retry (%d/%d)\n", retry_count + 1, max_retries);
        retry_count++;
        sleep(WEFOTA_TIMEOUT_SEC);
    }
    
    return -1;
}
#endif

int proc_get_ip(int sock) {
    int ret = -1;
    WeFOTAHeader * hdr = (WeFOTAHeader *)s_req;
    int count = wefota_header_init(hdr);
    printf("proc_get_ip send code=%d, count=%d)\n", hdr->code, count);

    if (0 > send_with_retry(sock, hdr, WEFOTA_HEADER_SIZE + count, &s_server1_addr, s_resp, sizeof(s_resp), WEFOTA_MAX_RETRIES)) {
        printf("comm fail\n");
        return ret;
    }

    ServerAddr * data = (ServerAddr *)(s_resp + WEFOTA_HEADER_SIZE);
    ret = init_wefota_server2_addr(data->ip, (int)data->port);
    return ret;
}

int proc_get_ip_1(int sock) {
    set_fota_status(FOTA_STATUS_GET_IP_1);
    return proc_get_ip(sock);
}

int proc_check_task(int sock) {
    set_fota_status(FOTA_STATUS_CHECK_TASK);

    int ret = -1;
    WeFOTAHeader * hdr = (WeFOTAHeader *)s_req;
	printf("proc_check_task header\n");
    int count = wefota_header_init(hdr);
    printf("proc_check_task send code=%d, count=%d)\n", hdr->code, count);

    char originVersion [32] = {0};
    get_version(originVersion);
    memcpy(s_req + WEFOTA_HEADER_SIZE, originVersion, sizeof(originVersion));
	printf("proc_check_task originVersion:[%s]\n", originVersion);

    if (0 > send_with_retry(sock, hdr, WEFOTA_HEADER_SIZE + count, &s_server2_addr, s_resp, sizeof(s_resp), WEFOTA_MAX_RETRIES)) {
        printf("comm fail\n");
        return ret;
    }

    FotaTask * data = (FotaTask *)(s_resp + WEFOTA_HEADER_SIZE);
	printf("proc_check_task recv:[flag:%d][interval:%u][delay:%u][destVersion:%s]\n", data->flag, data->interval, data->delay, data->destVersion);
    if (data->flag == 1) {
        strncpy(s_destVersion, data->destVersion, sizeof(s_destVersion));
        printf("exist fota task\n");
        return 0;
    } else {
        printf("no fota task\n");
        return ret;
    }
}

int proc_get_ip_2(int sock) {
    set_fota_status(FOTA_STATUS_GET_IP_2);
    return proc_get_ip(sock);
}

int proc_get_ver_id(int sock) {
    set_fota_status(FOTA_STATUS_GET_VER_ID);

    char product_id[32] = {0};
    int ret = -1;
    WeFOTAHeader * hdr = (WeFOTAHeader *)s_req;
    int count = wefota_header_init(hdr);
    printf("proc_get_ver_id send code=%d, count=%d)\n", hdr->code, count);

    Version version = {0};
    get_version(version.orig_version);
    strncpy(version.dest_version, s_destVersion, sizeof(version.dest_version));
    cfg_get_item("wefota_product_id", product_id, sizeof(product_id));
	strcpy(version.product, product_id);
    memcpy(s_req + WEFOTA_HEADER_SIZE, &version, sizeof(version));

    if (0 > send_with_retry(sock, hdr, WEFOTA_HEADER_SIZE + count, &s_server2_addr, s_resp, sizeof(s_resp), WEFOTA_MAX_RETRIES)) {
        printf("comm fail\n");
        return ret;
    }

    VerID * data = (VerID *)(s_resp + WEFOTA_HEADER_SIZE);
    s_verID = *data;
    return 0;
}

int proc_get_diff_pack_id(int sock) {
    set_fota_status(FOTA_STATUS_GET_DIFF_PACK_ID);

    int ret = -1;
    WeFOTAHeader * hdr = (WeFOTAHeader *)s_req;
    int count = wefota_header_init(hdr);
    printf("proc_get_diff_pack_id send code=%d, count=%d)\n", hdr->code, count);

    memcpy(s_req + WEFOTA_HEADER_SIZE, &s_verID, sizeof(s_verID));

    if (0 > send_with_retry(sock, hdr, WEFOTA_HEADER_SIZE + count, &s_server2_addr, s_resp, sizeof(s_resp), WEFOTA_MAX_RETRIES)) {
        printf("comm fail\n");
        return ret;
    }

    DiffPackInfo * data = (DiffPackInfo *)(s_resp + WEFOTA_HEADER_SIZE);
    s_diffpack_info = *data;
	printf("proc_get_diff_pack_id [diffPackID:%s][MD5:%s][size:%u]\n", s_diffpack_info.diffPackID, s_diffpack_info.MD5, s_diffpack_info.size);
    if (s_diffpack_info.size == 0) {
        printf("diff pack size==0\n");
        return ret;
    }
    return 0;
}

#if 0
int proc_get_diff_pack_data(int sock) {
    set_fota_status(FOTA_STATUS_GET_DIFF_PACK_DATA);

    unsigned int startTime = time(NULL);
    int ret = -1;
	int recv_packet_retry = 0;
    WeFOTAHeader * hdr = (WeFOTAHeader *)s_req;
    int count = wefota_header_init(hdr);
    printf("proc_get_diff_pack_data send code=%d, count=%d)\n", hdr->code, count);
	system("rm -rf /cache/zte_fota");
	system("mkdir /cache/zte_fota");
    FILE *fp = fopen(FOTA_DOWNLOAD_FILEPATH, "wb");
    if (NULL == fp) {
        printf("open file failed\n");
        return ret;
    }

    unsigned int size = s_diffpack_info.size;
    while (size > 0) {
        unsigned int len = size > WEFOTA_DIFF_PACK_DATA_MAX_LEN ? WEFOTA_DIFF_PACK_DATA_MAX_LEN : size;
		s_pack_date_count = len + 39;
        unsigned int offset = s_diffpack_info.size - size;
        DiffPackDataReq req = {0};
        memcpy(req.diffPackID, s_diffpack_info.diffPackID, sizeof(req.diffPackID));
		req.length = len;
        req.offset = offset;
		printf("proc_get_diff_pack_data request [offset %d][req.diffPackID %s][len %d][s_pack_date_count:%d][offset %d]\n",
				offset, req.diffPackID, len, s_pack_date_count, offset);
        memcpy(s_req + WEFOTA_HEADER_SIZE, &req, sizeof(req));
		s_diffpack_data_req = req;
        if (0 > send_with_retry(sock, hdr, WEFOTA_HEADER_SIZE + count, &s_server2_addr, s_resp, sizeof(s_resp), WEFOTA_MAX_RETRIES)) {
            printf("comm fail\n");
            fclose(fp);
            return ret;
        }

        DiffPackDataResp * data = (DiffPackDataResp *)(s_resp + WEFOTA_HEADER_SIZE);
		printf("proc_get_diff_pack_data recv [data->offset %d offset:%d][data->length %d en:%d]\n", data->offset, offset, data->length, len);
        if (data->offset != offset || data->length != len) {
            printf("offset or len error\n");
			if (recv_packet_retry < 3)
			{
				printf("offset error, retry\n");
				recv_packet_retry++;
				continue;
			}
            fclose(fp);
            return ret;
        }
        fwrite(data->data, 1, len, fp);
        size -= len;
		recv_packet_retry = 0;
    }

    fclose(fp);
    s_costTime = time(NULL) - startTime;
    return 0;
}
#endif

static void send_request(int sockfd, struct sockaddr_in *server_addr, int offset)
{
    char request[16];
    snprintf(request, sizeof(request), "%d", offset);
    sendto(sockfd, request, strlen(request), 0, (struct sockaddr *)server_addr, sizeof(*server_addr));
}

static int receive_data(int sockfd, int filefd, struct sockaddr_in *server_addr, socklen_t addr_len, int *received)
{
    ssize_t bytes_received;
    struct sockaddr_in from_addr;
    socklen_t from_len = sizeof(from_addr);

    bytes_received = recvfrom(sockfd, s_resp, WEFOTA_RESP_MAX_LEN, 0, (struct sockaddr *)&from_addr, &from_len);
    if (bytes_received < 0)
    {
        printf("receive_data received < 0\n");
        perror("recvfrom failed");
        return -1;
    }

    DiffPackDataResp * data = (DiffPackDataResp *)(s_resp + WEFOTA_HEADER_SIZE);
    int offset = data->offset / 1024;

    printf("receive_data received offset:%u\n", data->offset);

    if (received[offset])
    {
        return 0;
    }

    usleep(10000);
    if (lseek(filefd, offset * 1024, SEEK_SET) < 0)
    {
        printf("receive_data lseek error\n");
        perror("lseek failed");
        return -1;
    }
    if (write(filefd, data->data, bytes_received - WEFOTA_HEADER_SIZE - 39) < 0)
    {
        printf("receive_data write error\n");
        perror("write failed");
        return -1;
    }

    received[offset] = 1;
    printf("write packet %d,%u\n", offset, data->offset);

    return 0;
}

int proc_get_diff_pack_data(int sock)
{
    set_fota_status(FOTA_STATUS_GET_DIFF_PACK_DATA);

    unsigned int startTime = time(NULL);
    int ret = -1;
    int i = 0;
    int recv_packet_retry = 0;
    int upgradeStatus = -1;
    WeFOTAHeader * hdr = (WeFOTAHeader *)s_req;
    int count = wefota_header_init(hdr);
    printf("proc_get_diff_pack_data send code=%d, count=%d)\n", hdr->code, count);

    fota_get_update_status(&upgradeStatus);
    printf("proc_get_diff_pack_data fota_get_update_status upgradeStatus=%d\n", upgradeStatus);
    if (upgradeStatus == 0)
    {
        if(fota_is_file_exist(FOTA_DOWNLOAD_FILEPATH))
        {
            printf("proc_get_diff_pack_data upgradeStatus=0, Continue upgrading!!\n");
            return FOTA_NEED_CONTINUE_PREVIOUS_UPGRADE;
        }
    }
	
    system("rm -rf /cache/zte_fota");
    system("mkdir /cache/zte_fota");

    int filefd = open(FOTA_DOWNLOAD_FILEPATH, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (filefd < 0)
    {
    printf("proc_get_diff_pack_data open failed\n");
        perror("file open failed");
        return ret;
    }

    unsigned int size = s_diffpack_info.size;
    int total_packets = size / 1024;
    if (size % 1024 != 0)
    {
        total_packets += 1;
    }
    int received[total_packets];
    fd_set read_fds;
    int max_fd;
    struct timeval timeout;
    int select_result = 0;
    int max_retry_count = 0;

    memset(received, 0, sizeof(received));
    while (size > 0)
    {
        unsigned int len = size > WEFOTA_DIFF_PACK_DATA_MAX_LEN ? WEFOTA_DIFF_PACK_DATA_MAX_LEN : size;
        s_pack_date_count = len + 39;
        unsigned int offset = s_diffpack_info.size - size;
        DiffPackDataReq req = {0};
        memcpy(req.diffPackID, s_diffpack_info.diffPackID, sizeof(req.diffPackID));
        req.length = len;
        req.offset = offset;
        printf("proc_get_diff_pack_data send request [offset %u][req.diffPackID %s][len %u][s_pack_date_count:%u][offset %u]\n",
                offset, req.diffPackID, len, s_pack_date_count, offset);
        memcpy(s_req + WEFOTA_HEADER_SIZE, &req, sizeof(req));
        s_diffpack_data_req = req;
        send_message(sock, hdr, WEFOTA_HEADER_SIZE + count, &s_server2_addr);
        size -= len;
    }

    while (1)
    {
        FD_ZERO(&read_fds);
        FD_SET(sock, &read_fds);
        max_fd = sock;
        while (1)
        {
            timeout.tv_sec = 3;
            timeout.tv_usec = 0;
            select_result = select(max_fd + 1, &read_fds, NULL, NULL, &timeout);
            if (select_result < 0)
            {
                printf("proc_get_diff_pack_data select failed\n");
                perror("select failed");
                break;
            }
            else if (select_result == 0)
            {
                printf("proc_get_diff_pack_data No data to read, or timeout\n");
                break;
            }
            if (FD_ISSET(sock, &read_fds))
            {
                if (receive_data(sock, filefd, &s_server2_addr, sizeof(s_server2_addr), received) < 0)
                {
                    break;
                }
            }
        }

        if (max_retry_count++ > WEFOTA_MAX_RETRY_COUNT)
        {
            printf("proc_get_diff_pack_data reach the maximum retry count, break!!!\n");
            break;
        }

        int all_received = 1;
        for (i = 0; i < total_packets; i++)
        {
            if (!received[i])
            {
                all_received = 0;
                unsigned int len = s_diffpack_info.size - i * 1024 > WEFOTA_DIFF_PACK_DATA_MAX_LEN ? WEFOTA_DIFF_PACK_DATA_MAX_LEN : s_diffpack_info.size - i * 1024;
                s_pack_date_count = len + 39;
                unsigned int offset = i * 1024;
                DiffPackDataReq req = {0};
                memcpy(req.diffPackID, s_diffpack_info.diffPackID, sizeof(req.diffPackID));
                req.length = len;
                req.offset = offset;
                printf("Re request, send request [offset %u]\n", offset);
                memcpy(s_req + WEFOTA_HEADER_SIZE, &req, sizeof(req));
                s_diffpack_data_req = req;
                send_message(sock, hdr, WEFOTA_HEADER_SIZE + count, &s_server2_addr);
            }
        }

        if (all_received)
        {
            printf("All packets received successfully.\n");
            break;
        }
    }

    close(filefd);
    s_costTime = time(NULL) - startTime;
    return 0;
}


int proc_get_diff_pack_end(int sock) {
    set_fota_status(FOTA_STATUS_GET_DIFF_PACK_END);

    int ret = -1;
    WeFOTAHeader * hdr = (WeFOTAHeader *)s_req;
    int count = wefota_header_init(hdr);
    printf("proc_get_diff_pack_end send code=%d, count=%d)\n", hdr->code, count);

    DiffPackEnd end = {0};
    memcpy(end.diffPackID, s_diffpack_info.diffPackID, sizeof(end.diffPackID));
    end.costTime = s_costTime;
    memcpy(s_req + WEFOTA_HEADER_SIZE, &end, sizeof(end));

    if (0 > send_with_retry(sock, hdr, WEFOTA_HEADER_SIZE + count, &s_server2_addr, s_resp, sizeof(s_resp), WEFOTA_MAX_RETRIES)) {
        printf("comm fail\n");
        return ret;
    }
    return 0;
}

static int verify_md5(const unsigned char *expected_md5, const char *file_path)
{
    char command[256];
	char expected_md5_str[33];
	char md5sum_output[33];
	int i = 0;

    snprintf(command, sizeof(command), "md5sum \"%s\"", file_path);
    FILE *pipe = popen(command, "r");
    if (!pipe)
	{
		printf("verify_md5 pipe error\n");
        return -1;
    }

    if (fgets(md5sum_output, sizeof(md5sum_output), pipe) == NULL)
	{
		printf("verify_md5 fgets error\n");
        pclose(pipe);
        return -1;
    }

    pclose(pipe);

    for (i = 0; i < 16; ++i)
	{
        sprintf(expected_md5_str + i * 2, "%02x", expected_md5[i]);
    }

    if (strncmp(expected_md5_str, md5sum_output, 32) == 0)
	{
		printf("md5 check OK\n");
        return 1;
    }
	else
	{
		printf("md5 check error\n");
        return 0;
    }
}

int proc_install_diff_pack(void)
{
	const char *file_path = "/cache/zte_fota/delta.package";
	int result = 0;

	printf("**********proc_install_diff_pack begin \n");
    set_fota_status(FOTA_STATUS_INSTALL_DIFF_PACK);

	result = verify_md5(s_diffpack_info.MD5, file_path);
	if (result == 1)
	{
		return start_wefota_install();
	}
	else
	{
		return -1;
	}
	
}

int wefota_proc(void) {
	printf("**********wefota_proc\n");
    int ret = -1;
    int sock = -1;
	set_wefota_upgrade_flag_cfg("1");
    do {
        sock = create_udp_socket();
        if (sock < 0) {
			printf("**********create_udp_socket socket < 0 \n");
            break;
        }
        
        ret = init_wefota_server1_addr();
        if (ret < 0) {
			printf("**********init_wefota_server1_addr error \n");
            break;
        }

        ret = proc_get_ip_1(sock);
        if (ret < 0) {
			printf("**********proc_get_ip_1 error \n");
            break;
        }

        ret = proc_check_task(sock);
        if (ret < 0) {
			printf("**********proc_check_task error \n");
            break;
        }

        ret = proc_get_ip_2(sock);
        if (ret < 0) {
			printf("**********proc_get_ip_2 error \n");
            break;
        }

        ret = proc_get_ver_id(sock);
        if (ret < 0) {
			printf("**********proc_get_ver_id error \n");
            break;
        }

        ret = proc_get_diff_pack_id(sock);
        if (ret < 0) {
			printf("**********proc_get_diff_pack_id error \n");
            break;
        }

        ret = proc_get_diff_pack_data(sock);
        if (ret < 0) {
			printf("**********proc_get_diff_pack_data error \n");
            break;
        }
        else if (ret == FOTA_NEED_CONTINUE_PREVIOUS_UPGRADE)
        {
            printf("**********wefota_proc,The last upgrade was not completed, continue upgrading \n");
            close_udp_socket(sock);
            sock = -1;
            wefota_upgrade_without_verify();
            break;
        }

        ret = proc_get_diff_pack_end(sock);

        close_udp_socket(sock);
        sock = -1;

        ret = proc_install_diff_pack();
    }while(0);

    set_wefota_upgrade_flag_cfg("0");
    if (sock >= 0) {
        close_udp_socket(sock);
    }
    return ret;
}

int main(void) {
	printf("**********main\n");
    while (1) {
        wait_fota_conditions();
        wefota_proc();
    }
    return 0;
}