void readFile(char *filename){
    FILE *fp;
    fp = fopen(filename,"r");
    if (NULL == fp){
        printf("open %s error\n",filename);
        return;
    }
    uint8_t *str = NULL;
    size_t calloc_size = 1024;
    str = (uint8_t *)calloc(1,1024);
    int c = getc(fp);
    int index = 0;
    while (c != EOF){
        printf("%d\t",c);
        if (index != 0 && index % 16 == 0){
            printf("\n");
        }
        if (index > calloc_size){
            uint8_t  *tmp = calloc(1, calloc_size * 2);
            memcpy(tmp, str, calloc_size);
            calloc_size *= 2;
            free(str);
            str = tmp;
        }
        *(str + index) = c;
        index ++;
        c = getc(fp);
    }
    printf("\n");
    printf("readsize: %d bytes\n", index);
    printf("callocsize: %ld bytes\n", calloc_size);
    printf("\n");
    printf("%s\n", str);
    free(str);
    fclose(fp);
}

void readFile2(char *filepath) {
    struct stat statbuf;
    stat(filepath, &statbuf);
    long size = statbuf.st_size;
    FILE *fp;
    fp = fopen(filepath, "r");
    if (NULL == fp) {
        printf("open %s error\n", filepath);
        return;
    }
    uint8_t *str = NULL;
    str = (uint8_t *)calloc(1, size);
    if (NULL == str){
        printf("calloc failed.\n");
        return;
    }
    int c = getc(fp);
    size_t index = 0;
    while (c != EOF){
        *(str + index) = c;
        index ++;
        c = getc(fp);
    }
    printf("%s\n",str);
    free(str);
    fclose(fp);
}

void readFile3(const char *filepath) {
    FILE *fp;
    fp = fopen(filepath, "r");
    if (NULL == fp) {
        printf("open %s failed.\n", filepath);
        return;
    }
    struct stat statbuf;
    stat(filepath, &statbuf);
    long size = statbuf.st_size;
    char *buf = calloc(1, size + 1);
    size_t read_size = 0;
    char *res = fgets(buf, size + 1,fp);
    while (res != NULL) {
        read_size += strlen(res);
        res = fgets(buf + read_size, (size + 1 - strlen(res)), fp );
        
    }
    printf("%s\n", buf);
    printf("filesize: %ld\n", size);
    printf("readsize: %ld\n", read_size);
}

void writeFile(char *filepath, const uint8_t *data, size_t data_len) {
    FILE *fp;
    fp = fopen(filepath, "w");
    if (NULL == fp){
        printf("open %s failed.\n", filepath);
        return;
    }
    size_t input_size = 0;
    while (input_size < data_len) {
        int c = putc(*(data + input_size), fp);
        if (c == EOF) {
            printf("write finish...\n");
            break;
        }
        input_size++;
    }
    fclose(fp);
}

void writeStringToFile(const char *filepath, const char *data) {
    FILE *fp;
    fp = fopen(filepath, "w");
    if (NULL == fp) {
        printf("open %s failed.\n", filepath);
        return;
    }
    int ret = fputs(data, fp);
    if(EOF == ret) {
        printf("write string %s failed.\n", data);
        fclose(fp);
        return;
    }
    fclose(fp);
}

void writeStringToFile2(const char *filepath, const char *data) {
    FILE *fp;
    fp = fopen(filepath, "w");
    if (NULL == fp) {
        printf("open %s failed.\n", filepath);
        return;
    }
    int ret = fprintf(fp, "%s", data);
    if (EOF == ret) {
        printf("write %s failed.\n", data);
        fclose(fp);
        return;
    }
    fclose(fp);
}

typedef struct data_s {
    int type;
    char *description;
    int num[10];
    char str[1000];
    struct data_s *next;
} data_t;

void writeStruct2File(const char *filename, const data_t *data, const size_t data_size){
    FILE *fp;
    fp = fopen(filename, "w");
    if (NULL == fp) {
        printf("open %s failed.\n", filename);
        return;
    }
    size_t write_size = fwrite(data, data_size, 1, fp);
    printf("write_size: %ld\n", write_size);
    fclose(fp);
}

void readStructfromFile(const char *filename, data_t *data, size_t data_size) {
    FILE *fp;
    fp = fopen(filename, "r");
    size_t read_size = fread(data, data_size, 1, fp);
    printf("read_size: %ld\n",read_size);
    fclose(fp);
}
int main() {
     data_t data;
    
    data_t *data2;
    data2 = calloc(1, sizeof(data_t));
    
    memset(&data, 0, sizeof(data));
    strcpy(data2->str, "NEW DATA STRUCT");
    
    
    data.type = 1000;
    data.description = calloc(1, 30);
    strcpy(data.description, "Hello World...");
    strcpy(data.str,"this is data.str");
    int num[10] = {1,2,3,4,5,6,7,8,8,9};
    memcpy(data.num, num, sizeof(num));
    data.next = data2;
    
    writeStruct2File("Hello.bin",&data, sizeof(data) + 30);
    free(data.description);
    
    memset(&data, 0, sizeof(data));
    readStructfromFile("Hello.bin", &data, sizeof(data) + 30);
    printf("read data:::\n");
    printf("data->type:%d\n", data.type);
    printf("data->description:%s\n", data.description);
    printf("data->num::\n");
    for (int i = 0;i < 10;i ++) {
        printf("data->num[%d]:%d\n", i, data.num[i]);
    }
    printf("data->str:%s\n",data.str);
    printf("data->next: %p\n",data.next);
    if (NULL != data.next){
        printf("data->next->str:%s\n", data.next->str);
    }
    printf("finish!!!!");
    printf("data struct size:%ld", sizeof(data_t));
    return 0;
}

void *vp = calloc(4,4);

int *int_arr = vp;
for (int i = 0; i < 4; ++i){
    printf("int array[%d] => %d\n", i, int_arr[i]);
    int_arr[i] = i;
}
for (int i = 0; i < 4; ++i){
    printf("int array[%d] => %d\n", i, int_arr[i]);
}

char *char_arr = (char *)vp;
for (int i = 0; i < 16; ++i) {
    char_arr[i] = 'a' + i;
}
char_arr[15] = '\0';
printf("char_arr = %s\n", char_arr);

memset(vp,0,16);

memset(vp, 12, 1);
strcpy(vp+4,"Tom Jerry");

struct person {
    int32_t age;
    char name[12];
} *person_ptr;

person_ptr = vp;
printf("person age:%d, name : %s\n",person_ptr->age, person_ptr->name);

memset(vp+4,0,12);
strcpy(vp+4, "man");
strcpy(vp + 4 + 6,"fat");

struct annimal {
    int32_t type;
    char type_name[6];
    char description[6];
} *annimal_ptr;
annimal_ptr = (struct annimal *)person_ptr;
printf("annimal type: %d, type_name: %s, description: %s\n",annimal_ptr->type, annimal_ptr->type_name, annimal_ptr->description);
free(vp);

int *int_arr = vp;
    for (int i = 0; i < 4; ++i){
        printf("int array[%d] => %d\n", i, int_arr[i]);
        int_arr[i] = i;
    }

char *char_arr = (char *)vp;
for (int i = 0; i < 16; ++i) {
    char_arr[i] = 'a' + i;
}
char_arr[15] = '\0';

memset(vp,0,16);
memset(vp, 12, 1);
strcpy(vp+4,"Tom Jerry");

struct person {
    int32_t age;
    char name[12];
} *person_ptr;

person_ptr = vp;
printf("person age:%d, name : %s\n",person_ptr->age, person_ptr->name);

memset(vp+4,0,12);
strcpy(vp+4, "man");
strcpy(vp + 4 + 6,"fat");

struct annimal {
    int32_t type;
    char type_name[6];
    char description[6];
} *annimal_ptr;

annimal_ptr = (struct annimal *)person_ptr;
printf("annimal type: %d, type_name: %s, description: %s\n",annimal_ptr->type, annimal_ptr->type_name, annimal_ptr->description);

void printData(uint8_t *data,int32_t len){
    int j = 1;
    for (int i=0;i<len;i++){
        printf("%2x ",(uint8_t)data[i]);
        if(j % 16 == 0){
            printf("\n");
        }
        j++;
    }
}
// 加密数据
void encryptConfigFile(){
    char *filename = "./long_plain.txt";
    char content[1024*10];
    char encrypt[1024*10];
    size_t filesize;
    FILE *fp = fopen(filename,"r");
    filesize = fread(content,1,1024*10,fp);
    content[filesize] = '\0';
    printf("\n=========================\n");
    printf("file content:\n%s",content);
    printf("\n=========================\n");
    printf("\n 文件大小: %lu %lu\n",filesize,strlen(content));
    printf("\n==============从文件读取到的数据===================\n");
    printData(content,filesize);
    printf("\n================================================\n");
    // 加密数据
    uint8_t *dataforencrypt = (uint8_t *)calloc(1,strlen(content)+AES_BLOCK_SIZE);
    if (NULL == dataforencrypt){
        dbg("无法分配内存");
        return;
    }
    memcpy(dataforencrypt,content,strlen(content));
    size_t padding_len = strlen(content);
    pkcs5padding((uint8_t * const)dataforencrypt,(size_t * const)&padding_len,AES_BLOCK_SIZE);
    size_t encrypt_len = 0;
    char key[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
    char iv[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};

    if (!aes_cbc_encrypt(dataforencrypt,padding_len,encrypt,&encrypt_len,key,sizeof(key),iv,sizeof(iv))){
        dbg("加密失败");
    }
    fclose(fp);
    printf("\n================加密后数据==========\n");
    printData(encrypt,encrypt_len);
    printf("\n===================================\n");

    fp = fopen("long_encrypt.txt","w+");
    // 第一个字节写入2,后面是加密数据。然后写入文件
    uint8_t *write_data = NULL;
    write_data = calloc(1,encrypt_len+1);
    write_data[0] = 2;
    uint8_t *tmp = &write_data[1];
    memcpy(tmp,encrypt,encrypt_len);
    fwrite(write_data,encrypt_len+1,1,fp);
    printf("\n===============写入文件数据==============\n");
    printData(write_data,encrypt_len+1);
    printf("\n===========================================\n");
    printf("\n");
    printf("加密写入文件成功\n");
    fclose(fp);
    free(write_data);
}
// 解密文件
void decryptConfigFile(){
    char *filename = "./long_encrypt.txt";
    uint8_t content[10*1024];
    size_t  filesize;
    FILE *fp = fopen(filename,"r");
    filesize = fread(content,1,1024*10,fp);
    // 取出第一个字节，
    uint8_t version = content[0];
    printf("version = %d\n",version);
    printf("\n=============读取到文件内容=============\n");
    printData(content,filesize);
    printf("\n========================================\n");
    // 获得待解密的数据
    uint8_t *decrypt_data = NULL;
    uint8_t *tmp = &content[1];
    decrypt_data = calloc(1,filesize-1);
    // 读出后面的数据
    memcpy(decrypt_data,tmp,filesize-1);
    char key[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
    char iv[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
    //
    printf("\n=========待解密数据============\n");
    printData(decrypt_data,filesize-1);
    printf("\n==============================\n");
    // 解密
    uint8_t decrypt[10*1024];
    size_t decrypt_len;
    if (!aes_cbc_decrypt(decrypt_data,filesize-1,decrypt,&decrypt_len,key,sizeof(key),iv,sizeof(iv))){
        dbg("解密失败\n");
        return;
    }
    dbg("\n===========解密后的数据================\n");
    printData(decrypt,decrypt_len);
    printf("\n====================================\n");
       pkcs5unpadding(decrypt,&decrypt_len);
    printf("\n===========unpadding之后的数据==========================\n");
    printData(decrypt,decrypt_len);
    printf("\n===============================================\n");

    decrypt[decrypt_len] = '\0';
    printf("解密后数据:\n%s\n",decrypt);
    fclose(fp);
    fp = fopen("long_decrypt.txt","w+");
    fwrite(decrypt,decrypt_len,1,fp);
    fclose(fp);
    printf("\n解密后数据写入文件成功\n");
}

#include <stdio.h>
int main() {
#ifdef MC
    printf("===MC 宏开启 \n");   
#ifdef DMC
    printf("===DMC 宏开启\n");
#endif
#else
    printf("===MC 宏未开启\n");
#endif
    return 0;
}

#include <stdio.h>
void printData(uint8_t *data,int32_t len){
    int j = 1;
    for (int i=0;i<len;i++){
        printf("%2x ",(uint8_t)data[i]);
        if(j % 16 == 0){
            printf("\n");
        }
        j++;
    }
}
int main() {
#ifdef MC_NUM
    int i = 22;
    int result = i + MC_NUM;
    printf("%d = %d + %d ",result,i,MC_NUM);
#else
    printf("MC_NUM 未开启");
#endif
#ifdef MC_STR
    printf("MC_STR = %s\n",MC_STR);
#endif    
#ifdef MC_BYTE
    uint8_t data21[] = {MC_BYTE};
    printf("\n=========字节宏==========\n");
    printData(data21,sizeof(data21));
    printf("\n==========================\n");
#endif
    return 0;
}

char *sc4[] ={"hello","world","Welcome","C"};
   printf("arr total byte = %ld\n",sizeof(sc4));
   printf("arr single element byte = %ld\n",sizeof(sc4[0]));
   printf("arr length = %ld\n",sizeof(sc4)/sizeof(sc4[0]));
   printf("arr length = %ld\n",sizeof(sc4)/sizeof(*sc4));

int n[8] = {1,2,3,4,5};
  printf("arr total byte = %ld\n",sizeof(n));
  printf("arr single element byte = %ld\n",sizeof(n[0]));
  printf("arr length = %ld\n",sizeof(n)/sizeof(n[0]));
  printf("arr length = %ld\n",sizeof(n)/sizeof(*n));

char* arr2[2][3];
   printf("total byte = %ld\n",sizeof(arr2));
   printf("row byte = %ld\n",sizeof(arr2[0]));
   printf("column byte = %ld\n",sizeof(arr2[0][0]));
   printf("rows = %ld\n",sizeof(arr2) / sizeof(arr2[0]));
   printf("rows = %ld\n",sizeof(arr2) / sizeof(*arr2));
   printf("columns = %ld\n",sizeof(arr2[0])/sizeof(arr2[0][0]));
   printf("columns = %ld\n",sizeof(*arr2)/sizeof(**arr2));

typedef struct People_s {
    char *name;
    int age;
}People;

People arr3[3][9];
  printf("total byte = %ld\n",sizeof(arr3));
  printf("row byte = %ld\n",sizeof(arr3[0]));
  printf("column byte = %ld\n",sizeof(arr3[0][0]));
  printf("rows = %ld\n",sizeof(arr3) / sizeof(arr3[0]));
  printf("rows = %ld\n",sizeof(arr3) / sizeof(*arr3));
  printf("columns = %ld\n",sizeof(arr3[0])/sizeof(arr3[0][0]));
  printf("columns = %ld\n",sizeof(*arr3)/sizeof(**arr3));

char **arr = NULL;
// 10 个字符串
arr = calloc(10, sizeof(char *));
arr[0] = calloc(1, 100);
strcpy(arr[0], "Hello");
arr[1] = calloc(1, 100);
strcpy(arr[1], "World");

char *print2[10];
for (int i = 0; i < 10; ++i) {
    print2[i] = calloc(1, i + 2);
    sprintf(print2[i], "%d", i);
}
for (int i = 0; i < 10; ++i) {
    printf("%s\n", print2[i]);
    free(print2[i]);
}

char print[2][10] = {"Hello", "World"};
for (int i = 0; i < 2; ++i) {
    printf("%s\n", print[i]);
}

void checkcond(int32_t cond){
    if (cond) {
        printf("cond %d is true\n", cond);
    }else {
        printf("cond %d is false\n", cond);
    }
}

int main(int argc, char *argv[]) {
    int32_t cond = 0;
    checkcond(cond);
    
    cond = -1;
    checkcond(cond);
    
    cond = -1000;
    checkcond(cond);
    
    cond = 1;
    checkcond(cond);
    
    cond = 100;
    checkcond(cond);
    
    checkcond(NULL);
    checkcond(true);
    checkcond(false);
    return 0;
}

// ouput
/*
cond 0 is false
cond -1 is true
cond -1000 is true
cond 1 is true
cond 100 is true
cond 0 is false
cond 1 is true
cond 0 is false
*/

// char *str
if (!strcmp("Hello", str)) {
    // str equal "Hello"
}else{
    // str !equal "Hello"
}

// 大小端字节转换
int32_t bytes_to_int32_big_endian(char *byte) {
    return ((byte[3] << 0  & 0x000000FF)|
            (byte[2] << 8  & 0x0000FF00)|
            (byte[1] << 16 & 0x00FF0000)|
            (byte[0] << 24 & 0xFF000000));
}
int32_t int32_to_bytes_big_endian(const int32_t n, char *result) {
    result[3] = (char)(n);
    result[2] = (char)(n >> 8);
    result[1] = (char)(n >> 16);
    result[0] = (char)(n >> 24);
    return 0;
}

int32_t bytes_to_int32_little_endian(char *byte) {
    return ((byte[0] << 0  & 0x000000FF)|
            (byte[1] << 8  & 0x0000FF00)|
            (byte[2] << 16 & 0x00FF0000)|
            (byte[3] << 24 & 0xFF000000));
}

int32_t int32_to_bytes_little_endian(const int32_t n, char *result) {
    result[0] = (char)(n >> 0 );
    result[1] = (char)(n >> 8 );
    result[2] = (char)(n >> 16);
    result[3] = (char)(n >> 24);
    return 0;
}
int main(int argc, char *argv[]) {
    char byte[5] = {0};
    int32_t num = 43234325;
    int32_to_bytes_big_endian(num, byte);
    num = 0;
    num = bytes_to_int32_big_endian(byte);
    printf("test big endian num = %d\n", num);

    memset(byte, 0, sizeof(byte));
    num = -12345151;
    int32_to_bytes_little_endian(num, byte);
    num = 0;
    num = bytes_to_int32_little_endian(byte);
    printf("test little endian num = %d\n", num);
    return 0;
}
// output
/*
test big endian num = 43234325
test little endian num = -12345151
*/

#include "linux_list.h"
#include "stdlib.h"
#include "string.h"
#include "stdio.h"
#include "stdint.h"
typedef struct book_list_s {
    struct list_head list;
    // 自定义数据结构
    char data[12];
}book_list_t;
int main(int argc, char *argv[]) {
    // 哑结点
    book_list_t bookList;
    INIT_LIST_HEAD(&bookList.list);
    sprintf(bookList.data, "%d", -1);
    unsigned char number = 12;
    book_list_t *item = calloc(number, sizeof(book_list_t));
    
    // 添加
    if (NULL != item) {
        for (uint8_t i = 0;i < number;i ++) {
            INIT_LIST_HEAD(&item[i].list);
            sprintf(item[i].data, "%d", i);
            list_add_tail(&item[i].list, &bookList.list);
        }
    }
    // 查看顺序
    printf("list info\n");
    struct list_head  *pos;
    book_list_t *node;
    list_for_each(pos, &bookList.list) {
        node = list_entry(pos, book_list_t,list);
        printf("%s\t", node->data);
    }
    printf("\n");
    
    
    printf("Test Delete\n");
    // 删除节点,必须使用safe才能删除
    struct list_head *n = NULL;
    list_for_each_safe(pos, n,&bookList.list) {
        node = list_entry(pos, book_list_t,list);
        printf("%s\t", node->data);
        if (0 == strcmp("5", node->data)) {
            list_del(&node->list);
        }
    }
    printf("\n");
    
    printf("After Delete\n");
    list_for_each(pos, &bookList.list) {
        node = list_entry(pos, book_list_t,list);
        printf("%s\t", node->data);
    }
    printf("\n");
    
    // 重新构建连接
    printf("rebuild list\n");
    book_list_t *i5 = item + 5;
    printf("add item %s\n", i5->data);
    list_add_tail(&i5->list, &bookList.list);
    printf("info\n");
    list_for_each(pos, &bookList.list) {
        node = list_entry(pos, book_list_t,list);
        printf("%s\t", node->data);
    }
    printf("\n");
    
    free(item);
    return 0;
}


// output
/*
list info
0    1    2    3    4    5    6    7    8    9    10    11    
Test Delete
0    1    2    3    4    5    6    7    8    9    10    11    
After Delete
0    1    2    3    4    6    7    8    9    10    11    
rebuild list
add item 5
info
0    1    2    3    4    6    7    8    9    10    11    5    
*/

book_list_t *deleteItem = NULL;
    list_for_each(pos, &bookList.list) {
        node = list_entry(pos, book_list_t, list);
        if (0 == strcmp("7", node->data)) {
            // 找到数据,外部删除
            deleteItem = node;
            break;
        }
    }
list_del(&deleteItem->list);

typedef void *ptr;
typedef struct {
    char name[12];
}Book;
void get_book(void **book) {
    Book *_book = calloc(1, sizeof(Book));
    strcpy(_book->name, "FF");
    *book = _book;
}
int main(int argc,char *argv[]) {
    char *data = "Hello World";
    ptr a;
    a = data;
    printf("%s\n", a);
    int32_t data2 = 12;
    a = &data2;
    printf("%d\n", *((int32_t *)(a)));
    Book book = {0};
    memset(book.name, 0, sizeof(book.name));
    strcpy(book.name, "LL");
    a = &book;
    printf("book name: %s\n", ((Book *)(a))->name);
    
    get_book(&a);
    printf("book name: %s\n", ((Book *)(a))->name);
    free(a);
    
    return 0;
}

#include <stdlib.h>
#include <zconf.h>
#include "pthread.h"
#include "stdio.h"
#include "stddef.h"
#include "stdint.h"
#include "string.h"

// 定义一个函数模板
typedef int32_t opt_t(int32_t x, int32_t y);
int32_t option(int32_t x, int32_t y,  opt_t func) {
    return func(x,y);
}

// 直接是入参的
int32_t option2(int32_t x, int32_t y, int32_t(func(int32_t x, int32_t y))) {
    return func(x, y);
}

// 加减乘除的实现
int32_t add(int32_t x, int32_t y){return x+y;}
int32_t multi(int32_t x, int32_t y){return x *y;}

// 结构体指针返回的
typedef struct {
    char name[30];
    int32_t price;
}Book;

Book *getOneBook(char *name, Book* (generateBook(char *name, int32_t price))){
    // 其他处理
    return generateBook(name, 120);
}

Book *generateBookDemo(char *name, int32_t price){
    Book *ptr = calloc(1, sizeof(Book));
    strcpy(ptr->name, name);
    ptr->price = price;
    return ptr;
}

typedef void task_cb_t(int num);

void *task(void *arg){
    task_cb_t *cb = arg;
    for (int i = 0; i < 5; ++i) {
        // 直接调用回调
        cb(i);
        sleep(1);
    }
    cb(2345);
    return NULL;
}

void finishTaskCallBack(int num) {
    printf("Task Call Back %d\n", num);
}

int main(int argc, char *argv[]) {
    //
    int32_t x = 12;
    int32_t y = 22;
    printf("%d + %d = %d\n", x, y, option(x, y, add));
    printf("%d * %d = %d\n", x, y, option(x,y, multi));

    printf("%d + %d = %d\n", x, y, option2(x, y, add));
    printf("%d * %d = %d\n", x, y, option2(x,y, multi));

    Book *book = getOneBook("CPLUS", generateBookDemo);
    printf("book name:%s, price:%d\n", book->name, book->price);
    free(book);

    pthread_t handle;
    pthread_create(&handle, NULL, task, finishTaskCallBack);

    sleep(20000);

    return 0;

}