DNW源码 -- 备份

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>

const char* dev = "/dev/secbulk0"; //dnw所创建的设备文件，要对其写入
#define BLOCK_SIZE (1*1024*1024) //设置的写入块大小1MB

struct download_buffer {
    uint32_t    load_addr; /* load address */
    uint32_t    size; /* data size *///size=地址（4位）+大小（4位）+数据+校验（2位）
    uint8_t     data[0];//0长度数组，指向数据
    /* uint16_t checksum; */ //数组后紧接着的两位是校验位
};

static int _download_buffer(struct download_buffer *buf)//从缓存写入到usb设备文件
{
    int fd_dev = open(dev, O_WRONLY);//打开设备
    if( -1 == fd_dev) {
        printf("Can not open %s: %s\n", dev, strerror(errno));
        return -1;
    }

    printf("Writing data...\n");
    size_t remain_size = buf->size;//写入文件的剩余大小
    size_t block_size = BLOCK_SIZE;//每次写入的大小
    size_t writed = 0;//已经写入的文件大小
    while(remain_size>0) {
        size_t to_write = remain_size > block_size ? block_size : remain_size;//每次写入的实际大小
        if( to_write != write(fd_dev, (unsigned char*)buf + writed, to_write)) {
            perror("write failed");
            close(fd_dev);
            return -1;
        }
        remain_size -= to_write;
        writed += to_write;
        printf("\r%02zu%%\t0x%08zX bytes (%zu K)",
             (size_t)((uint64_t)writed*100/(buf->size)),
               writed,
               writed/1024);//打印写入的百分比
        fflush(stdout);//将缓存写入文件
    }
    printf("\n");
    close(fd_dev);
    return 0;
}

static inline void cal_and_set_checksum(struct download_buffer *buf)
{
    uint16_t sum = 0;
    int i;

    for(i = 0; i < buf->size; i++) {
        sum += buf->data[i];
    }
    *((uint16_t*)(&((uint8_t*)buf)[buf->size - 2])) = sum;//校验码赋值给最后一个word
}

static struct download_buffer* alloc_buffer(size_t data_size)//分配空间的函数
{
    struct download_buffer *buffer = NULL;
    size_t total_size = data_size + sizeof(struct download_buffer) + 2; //buffer=文件大小+结构体前两项的大小+2位的校验位
    buffer = (typeof(buffer))malloc(total_size);
    if(NULL == buffer)
        return NULL;
    buffer->size = total_size;
    return buffer;//返回指向结构体的指针
}

static void free_buffer(struct download_buffer *buf)
{
    free(buf);
}

static struct download_buffer *load_file(const char *path, unsigned long load_addr)//载入文件到缓存
{
    struct stat     file_stat;
    struct download_buffer *buffer = NULL;
    int fd;

    fd = open(path, O_RDONLY);//通过路径打开文件，获得fd文件标识符
    if(-1 == fd) {
        printf("Can not open file %s: %s\n", path, strerror(errno));
        return NULL;
    }

    if( -1 == fstat(fd, &file_stat) ) {//获取文件的属性
        perror("Get file size filed!\n");
        goto error;
    }

    buffer = alloc_buffer(file_stat.st_size);//给buffer分配空间（文件占用空间+结构体空间+2位校验）
    if(NULL == buffer) {
        perror("malloc failed!\n");
        goto error;
    }
    if( file_stat.st_size != read(fd, buffer->data, file_stat.st_size)) {//将文件写入buffer-》data
        perror("Read file failed!\n");
        goto error;
    }

    buffer->load_addr = load_addr;//填充结构体
    cal_and_set_checksum(buffer);//校验数据

    return buffer;

error:
    if(fd != -1)
        close(fd);
    if( NULL != buffer )
        free(buffer);
    return NULL;
}

static int download_file(const char *path, unsigned long load_addr)
{
    struct download_buffer *buffer;
    struct timeval __start, __end;
    long __time_val = 0;
    float speed = 0.0;

    buffer = load_file(path, load_addr);//将文件载入到buffer中
    gettimeofday(&__start,NULL);

    if (buffer != NULL) {
        if (_download_buffer(buffer) == 0) {//将缓存中的数据写入usb口
            gettimeofday(&__end,NULL);
            __time_val = (long) (__end.tv_usec - __start.tv_usec)/1000 + \
                (long)(__end.tv_sec - __start.tv_sec) * 1000;
            speed = (float)buffer->size/__time_val/(1024*1024) * 1000;
            printf("speed: %fM/S\n",speed);
            free_buffer(buffer);
            return 0;
        } else {
            free_buffer(buffer);
            return -1;
        }
    }

    return -1;
}

int main(int argc, char* argv[])
{
    unsigned load_addr = 0x57e00000;
    char* path = NULL;
    int c;

    while ((c = getopt (argc, argv, "a:h")) != EOF)
        switch (c) {
        case 'a':
            load_addr = strtol(optarg, NULL, 16);
            continue;
        case '?':
        case 'h':
        default:
        usage:
            printf("Usage: dwn [-a load_addr] \n");
            printf("Default load address: 0x57e00000\n");
            return 1;
        }
    if (optind < argc)
        path = argv[optind];
    else
        goto usage;

    printf("load address: 0x%08X\n", load_addr);
    if (download_file(path, load_addr) != 0) {
        return -1;
    }

    return 0;
}