Merge branch 'cwc' into 'master'

【修改内容】添加产测相关代码

See merge request chenweican/k-sdk!74

factory_test_src/exe/oled.config

+{
+    "args": {
+        "ccu": {
+            "id": "*",
+            "version": "*",
+            "name": "*"
+        },
+        "net": {
+            "interface": "eth1"
+        },
+        "qr_code": {
+            "string": "http://www.ikonke.com",
+            "show": true
+        }
+    },
+    "config":
+    {
+        "path": "/tmp/oled_addr",
+        "hw_ver": 1
+    }
+}

factory_test_src/src/Serial.c

+#include <termios.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/signal.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <signal.h>
+#include <string.h>
+
+#include "Serial.h"
+
+#define DBG_SERIAL 0
+
+extern int verbosity;
+
+extern volatile sig_atomic_t bRunning;
+
+int serial_fd = 0;
+
+//static struct termios options;       //place for settings for serial port
+char buf[255];                       //buffer for where data is put
+
+/**************serial open *******************/
+
+/***********************************************************
+* 名    称：int set_Parity(int fd,int databits,int stopbits,int parity)
+* 功    能：串口属性
+* 入口参数：无 
+* 出口参数：无
+* 说    明： 					 
+**********************************************************/ 
+/**
+*@brief   设置串口数据位，停止位和效验位
+*@param  fd     类型  int  打开的串口文件句柄*
+*@param  databits 类型  int 数据位   取值 为 7 或者8*
+*@param  stopbits 类型  int 停止位   取值为 1 或者2*
+*@param  parity  类型  int  效验类型 取值为N,E,O,,S
+*/
+int set_Parity(int fd,int databits,int stopbits,int parity)
+{
+	struct termios options;
+	
+ 	if  ( tcgetattr( fd,&options)  !=  0)
+  	{
+	  	perror("SetupSerial 1");
+	  	return(0);
+  	}
+
+ 	
+  	options.c_cflag &= ~CSIZE;
+	
+  	switch (databits) /*设置数据位数*/
+  	{
+	  	case 7:
+	  		options.c_cflag |= CS7;
+	  		break;
+	  	case 8:
+			options.c_cflag |= CS8;
+			break;
+		default:
+			fprintf(stderr,"Unsupported data size\n");
+			return (0);
+	}
+	
+  	switch (parity)
+  	{
+	  	case 'n':
+		case 'N':
+			options.c_cflag &= ~PARENB;   /* Clear parity enable */
+			options.c_iflag &= ~INPCK;     /* Enable parity checking */
+			break;
+		case 'o':
+		case 'O':
+			options.c_cflag |= (PARODD | PARENB);  /* 设置为奇效验*/ 
+			options.c_iflag |= INPCK;             /* Disnable parity checking */
+			break;
+		case 'e':
+		case 'E':
+			options.c_cflag |= PARENB;     /* Enable parity */
+			options.c_cflag &= ~PARODD;   /* 转换为偶效验*/  
+			options.c_iflag |= INPCK;       /* Disnable parity checking */
+			break;
+		case 'S':
+		case 's':  /*as no parity*/
+			options.c_cflag &= ~PARENB;
+			options.c_cflag &= ~CSTOPB;
+			break;
+		default:
+			fprintf(stderr,"Unsupported parity\n");
+			return (0);
+	}
+  /* 设置停止位*/   
+  
+  	switch (stopbits)
+  	{
+	  	case 1:
+	  		options.c_cflag &= ~CSTOPB;
+			break;
+		case 2:
+			options.c_cflag |= CSTOPB;
+			break;
+		default:
+			fprintf(stderr,"Unsupported stop bits\n");
+			return (0);
+	}
+  /* Set input parity option */
+
+	if ((parity != 'n') && (parity != 'N'))
+    	{
+        	options.c_iflag |= INPCK;
+    	}
+
+	options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);
+    	options.c_oflag  &= ~OPOST;
+    	options.c_cflag |= (CLOCAL | CREAD);
+
+    	options.c_oflag &= ~(ONLCR | OCRNL);
+    	options.c_iflag &= ~(ICRNL | INLCR);
+    	options.c_iflag &= ~(IXON | IXOFF | IXANY);
+
+	options.c_cc[VTIME] = 30; // 30 seconds
+	options.c_cc[VMIN] =  0;//15
+  
+
+  	tcflush(fd,TCIFLUSH); /* Update the options and do it NOW */
+  	if (tcsetattr(fd,TCSANOW,&options) != 0)
+  	{
+  		perror("SetupSerial 3");
+		return (0);
+	}
+	
+  	return (1);
+ }
+
+/***********************************************************
+* 名    称：set_speed(int fd, int speed)
+* 功    能：串口波特率设置
+* 入口参数：
+* 出口参数：
+* 说    明： 					 
+**********************************************************/  
+
+int speed_arr[] = { B115200,B38400, B19200, B9600, B4800, B2400, B1200, B300,\
+	    B38400, B19200, B9600, B4800, B2400, B1200, B300, };
+int name_arr[] = {115200,38400, 19200,  9600,  4800,  2400,  1200,  300,\
+	    38400,  19200,  9600, 4800, 2400, 1200,  300, };
+
+
+teSerial_Status set_speed(int fd, int speed)
+{
+  printf("set_speed\n");
+  int   i;
+  int   status;
+  struct termios   Opt;
+  tcgetattr(fd, &Opt);
+  for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)
+   {
+        printf("input:%d,speed:%d,i = %d\n",speed,name_arr[i],i);
+   	if  (speed == name_arr[i])
+   	{
+
+	    	SERIAL_LOG_ERR("speed:%d,i = %d\n",name_arr[i],i);
+                printf("speed:%d,i = %d\n",name_arr[i],i);
+   	    	tcflush(fd, TCIOFLUSH);
+	    	cfsetispeed(&Opt, speed_arr[i]);
+	    	cfsetospeed(&Opt, speed_arr[i]);
+	    	status = tcsetattr(fd, TCSANOW, &Opt);
+	    	if  (status != 0)
+            {
+                    perror("tcsetattr fd1");
+                    return E_ERROR;
+                }
+                tcflush(fd,TCIOFLUSH);
+                return E_SERIAL_OK;
+            }
+   	
+   }
+
+  return E_ERROR;
+}
+
+/***********************************************************
+* 名    称：int devOpen(char *dev)
+* 功    能：打开串口设备
+* 入口参数： 
+* 出口参数：
+* 说    明： 					 
+**********************************************************/
+ 
+int devOpen(char *dev)
+{
+	 int fd;
+   	 fd = open(dev, O_RDWR | O_NOCTTY | O_NDELAY);   
+    
+   	 if(fd == -1)
+        {
+	 	SERIAL_LOG_ERR("devOpen %s\n ",dev);
+         	perror("devOpen");
+	 	return -1;
+    	}
+   
+    if (fd>0)
+    {
+        set_speed(fd,9600);
+    }  
+	else
+	{
+		    SERIAL_LOG_ERR("Can't Open Serial Port!\n");
+		    return -1;
+	}
+	if (set_Parity(fd,8,1,'N')== 0)
+	{
+	        SERIAL_LOG_ERR("Set Parity Error\n");
+		return -1;
+	} 
+    	return fd;
+}
+
+
+
+
+/***********************************/
+
+/***********************************************************
+* 名    称：eSerial_start()
+* 功    能：打开串口
+* 入口参数： 
+* 出口参数：
+* 说    明： 					 
+**********************************************************/  
+
+void eSerial_start()
+{
+        #if 0
+        int ret = eSerial_Init(SERIAL_NAME, SERIAL_BAUD, &serial_fd);
+
+        if(E_SERIAL_OK != ret)
+        {
+                SERIAL_LOG_ERR("Open serial faild\n");
+        }
+        #endif
+
+        serial_fd = devOpen(SERIAL_NAME);
+}
+
+/***********************************************************
+* 名    称：eSerial_stop()
+* 功    能：停止串口
+* 入口参数： 
+* 出口参数：
+* 说    明： 					 
+**********************************************************/  
+
+void eSerial_stop()
+{
+        if(serial_fd>0)
+        {
+                close(serial_fd);
+                serial_fd = 0;
+                SERIAL_LOG_DBG("close serial_fd ok\n");
+        }
+}
+
+/***********************************************************
+* 名    称：eSerial_Read(unsigned char *data)
+* 功    能：读串口（单个字节）
+* 入口参数： 
+* 出口参数：
+* 说    明： 					 
+**********************************************************/  
+
+teSerial_Status eSerial_Read(unsigned char *data)
+{
+    signed char res;
+
+    if(serial_fd <= 0)
+    {
+        return E_SERIAL_FD_ERROR;
+    }
+
+    res = read(serial_fd,data,1);
+    if (res > 0)
+    {
+        //SERIAL_LOG_DBG("RX 0x%02x\n", *data);
+        return E_SERIAL_OK;
+    }
+    else
+    {
+        printf("Serial read: %d\n", res);
+        if (res == 0)
+        {
+            
+        }
+        
+        return E_SERIAL_NODATA;
+    }
+    
+}
+
+/***********************************************************
+* 名    称：eSerial_Write(const unsigned char data)
+* 功    能：读串口（单个字节）
+* 入口参数：
+* 出口参数：
+* 说    明： 					 
+**********************************************************/  
+teSerial_Status eSerial_Write(const unsigned char data)
+{
+    int err, attempts = 0;
+
+    if(serial_fd <= 0)
+    {
+        return E_SERIAL_FD_ERROR;
+    }
+    
+     SERIAL_LOG_DBG("TX 0x%02x\n", data);
+    
+    err = write(serial_fd,&data,1);
+    if (err < 0)
+    {
+        if (errno == EAGAIN)
+        {
+            for (attempts = 0; attempts <= 5; attempts++)
+            {
+                usleep(1000);
+                err = write(serial_fd,&data,1);
+                if (err < 0) 
+                {
+                    if ((errno == EAGAIN) && (attempts == 5))
+                    {
+                        SERIAL_LOG_ERR("Error writing to module after %d attempts(%s)", attempts, strerror(errno));
+                        exit(-1);
+                    }
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+        else
+        {
+            SERIAL_LOG_ERR("Error writing to module(%s)", strerror(errno));
+            exit(-1);
+        }
+    }
+    return E_SERIAL_OK;
+}
+
+/***********************************************************
+* 名    称：eSerial_ReadBuffer(unsigned char *data, int *count)
+* 功    能：读串口（多个字节）
+* 入口参数： 
+* 出口参数：
+* 说    明： 					 
+**********************************************************/  
+teSerial_Status eSerial_ReadBuffer(unsigned char *data, int *count)
+{
+    int res;
+
+    if(serial_fd <= 0)
+    {
+        return E_SERIAL_FD_ERROR;
+    }
+    
+    res = read(serial_fd, data, *count);
+    SERIAL_LOG_DBG("uart recv res:%d\n",res);
+    if (res > 0)
+    {
+        *count = res;
+        SERIAL_LOG_DBG("uart recv:%d\n",res);
+        return E_SERIAL_OK;
+    }
+    else
+    {
+#if DEBUG
+        if (verbosity >= LOG_DEBUG) daemon_log(LOG_DEBUG, "Serial read: %d\n", res);
+#endif /* DEBUG */
+
+        if(res < 0)
+        {
+                SERIAL_LOG_ERR("readbuff error\n");
+                return E_SERIAL_FD_ERROR;
+        }
+
+        if (res == 0)
+        {
+            //SERIAL_LOG_ERR("Serial connection to module interrupted");
+            //bRunning = 0;
+        }
+        res = *count = 0;
+        return E_SERIAL_NODATA;
+    }
+}
+
+/***********************************************************
+* 名    称：eSerial_WriteBuffer(unsigned char *data, int *count)
+* 功    能：写串口（多个字节）
+* 入口参数： 
+* 出口参数：
+* 说    明： 					 
+**********************************************************/  
+teSerial_Status eSerial_WriteBuffer(unsigned char *data, uint32_t count)
+{
+    int attempts = 0;
+    //printf("send char %d\n", data);
+    int total_sent_bytes = 0, sent_bytes = 0;
+    
+    while (total_sent_bytes < count)
+    {
+        sent_bytes = write(serial_fd, &data[total_sent_bytes], count - total_sent_bytes);
+        if (sent_bytes <= 0)
+        {
+            if (errno == EAGAIN)
+            {
+                if (++attempts >= 5)
+                {
+                    SERIAL_LOG_ERR("Error writing to module(%s)", strerror(errno));
+                    return E_SERIAL_ERROR;
+                }
+                usleep(1000);
+            }
+            else
+            {
+                SERIAL_LOG_ERR("Error writing to module(%s)", strerror(errno));
+                return -1;
+            }
+        }
+        else
+        {
+            attempts = 0;
+            total_sent_bytes += sent_bytes;
+        }
+    }
+    return E_SERIAL_OK;
+}
+
+

factory_test_src/src/Serial.h

+#include <stdint.h>
+
+#ifndef __SERIAL_H__
+#define __SERIAL_H__
+
+#include <syslog.h>
+
+#if defined __cplusplus
+extern "C" {
+#endif
+
+/****************************************************************************/
+/***        Include files                                                 ***/
+/****************************************************************************/
+
+
+/****************************************************************************/
+/***        Macro Definitions                                             ***/
+/****************************************************************************/
+
+#define _SERIAL_LOG(level, fmt, args...)   \
+    do                                  \
+    {                                   \
+        syslog(level, fmt, ##args);     \
+        printf("\n["__FILE__":%d] "fmt,__LINE__, ##args);           \
+    } while(0)
+
+#define SERIAL_LOG_DBG(fmt, args...)      _SERIAL_LOG(LOG_DEBUG, fmt, ##args)
+#define SERIAL_LOG_ERR(fmt, args...)      _SERIAL_LOG(LOG_ERR, fmt, ##args)
+
+#define SERIAL_NAME "/dev/ttyS0"
+#define SERIAL_BAUD 115200
+
+/****************************************************************************/
+/***        Type Definitions                                              ***/
+/****************************************************************************/
+
+typedef enum
+{
+    E_ERROR = -1,
+    E_SERIAL_OK = 0,
+    E_SERIAL_ERROR,
+    E_SERIAL_NODATA,
+    E_SERIAL_FD_ERROR,
+} teSerial_Status;
+
+/****************************************************************************/
+/***        Local Function Prototypes                                     ***/
+/****************************************************************************/
+
+/****************************************************************************/
+/***        Exported Variables                                            ***/
+/****************************************************************************/
+
+extern int serial_fd;
+
+/****************************************************************************/
+/***        Local Variables                                               ***/
+/****************************************************************************/
+
+/****************************************************************************/
+/***        Exported Functions                                            ***/
+/****************************************************************************/
+
+void eSerial_start();
+void eSerial_stop();
+
+teSerial_Status eSerial_Init(char *name, uint32_t baud, int *piserial_fd);
+teSerial_Status eSerial_Read(unsigned char *data);
+teSerial_Status eSerial_Write(const unsigned char data);
+
+teSerial_Status eSerial_ReadBuffer(unsigned char *data, int *count);
+teSerial_Status eSerial_WriteBuffer(unsigned char *data, uint32_t count);
+
+/****************************************************************************/
+/***        Local Functions                                               ***/
+/****************************************************************************/
+
+/****************************************************************************/
+/***        END OF FILE                                                   ***/
+/****************************************************************************/
+#if defined __cplusplus
+}
+#endif
+
+#endif /* __SERIAL_H__ */

factory_test_src/src/cJSON.c

+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+/* cJSON */
+/* JSON parser in C. */
+
+#ifdef __GNUC__
+#pragma GCC visibility push(default)
+#endif
+
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <float.h>
+#include <limits.h>
+#include <ctype.h>
+#include <locale.h>
+
+#ifdef __GNUC__
+#pragma GCC visibility pop
+#endif
+
+#include "cJSON.h"
+
+/* define our own boolean type */
+#define true ((cJSON_bool)1)
+#define false ((cJSON_bool)0)
+
+typedef struct {
+    const unsigned char *json;
+    size_t position;
+} error;
+static error global_error = { NULL, 0 };
+
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void)
+{
+    return (const char*) (global_error.json + global_error.position);
+}
+
+/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */
+#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 5) || (CJSON_VERSION_PATCH != 9)
+    #error cJSON.h and cJSON.c have different versions. Make sure that both have the same.
+#endif
+
+CJSON_PUBLIC(const char*) cJSON_Version(void)
+{
+    static char version[15];
+    sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH);
+
+    return version;
+}
+
+/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */
+static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)
+{
+    if ((string1 == NULL) || (string2 == NULL))
+    {
+        return 1;
+    }
+
+    if (string1 == string2)
+    {
+        return 0;
+    }
+
+    for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++)
+    {
+        if (*string1 == '\0')
+        {
+            return 0;
+        }
+    }
+
+    return tolower(*string1) - tolower(*string2);
+}
+
+typedef struct internal_hooks
+{
+    void *(*allocate)(size_t size);
+    void (*deallocate)(void *pointer);
+    void *(*reallocate)(void *pointer, size_t size);
+} internal_hooks;
+
+static internal_hooks global_hooks = { malloc, free, realloc };
+
+static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)
+{
+    size_t length = 0;
+    unsigned char *copy = NULL;
+
+    if (string == NULL)
+    {
+        return NULL;
+    }
+
+    length = strlen((const char*)string) + sizeof("");
+    if (!(copy = (unsigned char*)hooks->allocate(length)))
+    {
+        return NULL;
+    }
+    memcpy(copy, string, length);
+
+    return copy;
+}
+
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)
+{
+    if (hooks == NULL)
+    {
+        /* Reset hooks */
+        global_hooks.allocate = malloc;
+        global_hooks.deallocate = free;
+        global_hooks.reallocate = realloc;
+        return;
+    }
+
+    global_hooks.allocate = malloc;
+    if (hooks->malloc_fn != NULL)
+    {
+        global_hooks.allocate = hooks->malloc_fn;
+    }
+
+    global_hooks.deallocate = free;
+    if (hooks->free_fn != NULL)
+    {
+        global_hooks.deallocate = hooks->free_fn;
+    }
+
+    /* use realloc only if both free and malloc are used */
+    global_hooks.reallocate = NULL;
+    if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free))
+    {
+        global_hooks.reallocate = realloc;
+    }
+}
+
+/* Internal constructor. */
+static cJSON *cJSON_New_Item(const internal_hooks * const hooks)
+{
+    cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON));
+    if (node)
+    {
+        memset(node, '\0', sizeof(cJSON));
+    }
+
+    return node;
+}
+
+/* Delete a cJSON structure. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)
+{
+    cJSON *next = NULL;
+    while (item != NULL)
+    {
+        next = item->next;
+        if (!(item->type & cJSON_IsReference) && (item->child != NULL))
+        {
+            cJSON_Delete(item->child);
+        }
+        if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))
+        {
+            global_hooks.deallocate(item->valuestring);
+        }
+        if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
+        {
+            global_hooks.deallocate(item->string);
+        }
+        global_hooks.deallocate(item);
+        item = next;
+    }
+}
+
+/* get the decimal point character of the current locale */
+static unsigned char get_decimal_point(void)
+{
+    struct lconv *lconv = localeconv();
+    return (unsigned char) lconv->decimal_point[0];
+}
+
+typedef struct
+{
+    const unsigned char *content;
+    size_t length;
+    size_t offset;
+    size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */
+    internal_hooks hooks;
+} parse_buffer;
+
+/* check if the given size is left to read in a given parse buffer (starting with 1) */
+#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
+#define cannot_read(buffer, size) (!can_read(buffer, size))
+/* check if the buffer can be accessed at the given index (starting with 0) */
+#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
+#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
+/* get a pointer to the buffer at the position */
+#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
+
+/* Parse the input text to generate a number, and populate the result into item. */
+static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)
+{
+    double number = 0;
+    unsigned char *after_end = NULL;
+    unsigned char number_c_string[64];
+    unsigned char decimal_point = get_decimal_point();
+    size_t i = 0;
+
+    if ((input_buffer == NULL) || (input_buffer->content == NULL))
+    {
+        return false;
+    }
+
+    /* copy the number into a temporary buffer and replace '.' with the decimal point
+     * of the current locale (for strtod)
+     * This also takes care of '\0' not necessarily being available for marking the end of the input */
+    for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++)
+    {
+        switch (buffer_at_offset(input_buffer)[i])
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            case '+':
+            case '-':
+            case 'e':
+            case 'E':
+                number_c_string[i] = buffer_at_offset(input_buffer)[i];
+                break;
+
+            case '.':
+                number_c_string[i] = decimal_point;
+                break;
+
+            default:
+                goto loop_end;
+        }
+    }
+loop_end:
+    number_c_string[i] = '\0';
+
+    number = strtod((const char*)number_c_string, (char**)&after_end);
+    if (number_c_string == after_end)
+    {
+        return false; /* parse_error */
+    }
+
+    item->valuedouble = number;
+
+    /* use saturation in case of overflow */
+    if (number >= INT_MAX)
+    {
+        item->valueint = INT_MAX;
+    }
+    else if (number <= INT_MIN)
+    {
+        item->valueint = INT_MIN;
+    }
+    else
+    {
+        item->valueint = (int)number;
+    }
+
+    item->type = cJSON_Number;
+
+    input_buffer->offset += (size_t)(after_end - number_c_string);
+    return true;
+}
+
+/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)
+{
+    if (number >= INT_MAX)
+    {
+        object->valueint = INT_MAX;
+    }
+    else if (number <= INT_MIN)
+    {
+        object->valueint = INT_MIN;
+    }
+    else
+    {
+        object->valueint = (int)number;
+    }
+
+    return object->valuedouble = number;
+}
+
+typedef struct
+{
+    unsigned char *buffer;
+    size_t length;
+    size_t offset;
+    size_t depth; /* current nesting depth (for formatted printing) */
+    cJSON_bool noalloc;
+    cJSON_bool format; /* is this print a formatted print */
+    internal_hooks hooks;
+} printbuffer;
+
+/* realloc printbuffer if necessary to have at least "needed" bytes more */
+static unsigned char* ensure(printbuffer * const p, size_t needed)
+{
+    unsigned char *newbuffer = NULL;
+    size_t newsize = 0;
+
+    if ((p == NULL) || (p->buffer == NULL))
+    {
+        return NULL;
+    }
+
+    if ((p->length > 0) && (p->offset >= p->length))
+    {
+        /* make sure that offset is valid */
+        return NULL;
+    }
+
+    if (needed > INT_MAX)
+    {
+        /* sizes bigger than INT_MAX are currently not supported */
+        return NULL;
+    }
+
+    needed += p->offset + 1;
+    if (needed <= p->length)
+    {
+        return p->buffer + p->offset;
+    }
+
+    if (p->noalloc) {
+        return NULL;
+    }
+
+    /* calculate new buffer size */
+    if (needed > (INT_MAX / 2))
+    {
+        /* overflow of int, use INT_MAX if possible */
+        if (needed <= INT_MAX)
+        {
+            newsize = INT_MAX;
+        }
+        else
+        {
+            return NULL;
+        }
+    }
+    else
+    {
+        newsize = needed * 2;
+    }
+
+    if (p->hooks.reallocate != NULL)
+    {
+        /* reallocate with realloc if available */
+        newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize);
+        if (newbuffer == NULL)
+        {
+            p->hooks.deallocate(p->buffer);
+            p->length = 0;
+            p->buffer = NULL;
+
+            return NULL;
+        }
+    }
+    else
+    {
+        /* otherwise reallocate manually */
+        newbuffer = (unsigned char*)p->hooks.allocate(newsize);
+        if (!newbuffer)
+        {
+            p->hooks.deallocate(p->buffer);
+            p->length = 0;
+            p->buffer = NULL;
+
+            return NULL;
+        }
+        if (newbuffer)
+        {
+            memcpy(newbuffer, p->buffer, p->offset + 1);
+        }
+        p->hooks.deallocate(p->buffer);
+    }
+    p->length = newsize;
+    p->buffer = newbuffer;
+
+    return newbuffer + p->offset;
+}
+
+/* calculate the new length of the string in a printbuffer and update the offset */
+static void update_offset(printbuffer * const buffer)
+{
+    const unsigned char *buffer_pointer = NULL;
+    if ((buffer == NULL) || (buffer->buffer == NULL))
+    {
+        return;
+    }
+    buffer_pointer = buffer->buffer + buffer->offset;
+
+    buffer->offset += strlen((const char*)buffer_pointer);
+}
+
+/* Render the number nicely from the given item into a string. */
+static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    double d = item->valuedouble;
+    int length = 0;
+    size_t i = 0;
+    unsigned char number_buffer[26]; /* temporary buffer to print the number into */
+    unsigned char decimal_point = get_decimal_point();
+    double test;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* This checks for NaN and Infinity */
+    if ((d * 0) != 0)
+    {
+        length = sprintf((char*)number_buffer, "null");
+    }
+    else
+    {
+        /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */
+        length = sprintf((char*)number_buffer, "%1.15g", d);
+
+        /* Check whether the original double can be recovered */
+        if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || ((double)test != d))
+        {
+            /* If not, print with 17 decimal places of precision */
+            length = sprintf((char*)number_buffer, "%1.17g", d);
+        }
+    }
+
+    /* sprintf failed or buffer overrun occured */
+    if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1)))
+    {
+        return false;
+    }
+
+    /* reserve appropriate space in the output */
+    output_pointer = ensure(output_buffer, (size_t)length);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+
+    /* copy the printed number to the output and replace locale
+     * dependent decimal point with '.' */
+    for (i = 0; i < ((size_t)length); i++)
+    {
+        if (number_buffer[i] == decimal_point)
+        {
+            output_pointer[i] = '.';
+            continue;
+        }
+
+        output_pointer[i] = number_buffer[i];
+    }
+    output_pointer[i] = '\0';
+
+    output_buffer->offset += (size_t)length;
+
+    return true;
+}
+
+/* parse 4 digit hexadecimal number */
+static unsigned parse_hex4(const unsigned char * const input)
+{
+    unsigned int h = 0;
+    size_t i = 0;
+
+    for (i = 0; i < 4; i++)
+    {
+        /* parse digit */
+        if ((input[i] >= '0') && (input[i] <= '9'))
+        {
+            h += (unsigned int) input[i] - '0';
+        }
+        else if ((input[i] >= 'A') && (input[i] <= 'F'))
+        {
+            h += (unsigned int) 10 + input[i] - 'A';
+        }
+        else if ((input[i] >= 'a') && (input[i] <= 'f'))
+        {
+            h += (unsigned int) 10 + input[i] - 'a';
+        }
+        else /* invalid */
+        {
+            return 0;
+        }
+
+        if (i < 3)
+        {
+            /* shift left to make place for the next nibble */
+            h = h << 4;
+        }
+    }
+
+    return h;
+}
+
+/* converts a UTF-16 literal to UTF-8
+ * A literal can be one or two sequences of the form \uXXXX */
+static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)
+{
+    long unsigned int codepoint = 0;
+    unsigned int first_code = 0;
+    const unsigned char *first_sequence = input_pointer;
+    unsigned char utf8_length = 0;
+    unsigned char utf8_position = 0;
+    unsigned char sequence_length = 0;
+    unsigned char first_byte_mark = 0;
+
+    if ((input_end - first_sequence) < 6)
+    {
+        /* input ends unexpectedly */
+        goto fail;
+    }
+
+    /* get the first utf16 sequence */
+    first_code = parse_hex4(first_sequence + 2);
+
+    /* check that the code is valid */
+    if (((first_code >= 0xDC00) && (first_code <= 0xDFFF)))
+    {
+        goto fail;
+    }
+
+    /* UTF16 surrogate pair */
+    if ((first_code >= 0xD800) && (first_code <= 0xDBFF))
+    {
+        const unsigned char *second_sequence = first_sequence + 6;
+        unsigned int second_code = 0;
+        sequence_length = 12; /* \uXXXX\uXXXX */
+
+        if ((input_end - second_sequence) < 6)
+        {
+            /* input ends unexpectedly */
+            goto fail;
+        }
+
+        if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u'))
+        {
+            /* missing second half of the surrogate pair */
+            goto fail;
+        }
+
+        /* get the second utf16 sequence */
+        second_code = parse_hex4(second_sequence + 2);
+        /* check that the code is valid */
+        if ((second_code < 0xDC00) || (second_code > 0xDFFF))
+        {
+            /* invalid second half of the surrogate pair */
+            goto fail;
+        }
+
+
+        /* calculate the unicode codepoint from the surrogate pair */
+        codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));
+    }
+    else
+    {
+        sequence_length = 6; /* \uXXXX */
+        codepoint = first_code;
+    }
+
+    /* encode as UTF-8
+     * takes at maximum 4 bytes to encode:
+     * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+    if (codepoint < 0x80)
+    {
+        /* normal ascii, encoding 0xxxxxxx */
+        utf8_length = 1;
+    }
+    else if (codepoint < 0x800)
+    {
+        /* two bytes, encoding 110xxxxx 10xxxxxx */
+        utf8_length = 2;
+        first_byte_mark = 0xC0; /* 11000000 */
+    }
+    else if (codepoint < 0x10000)
+    {
+        /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */
+        utf8_length = 3;
+        first_byte_mark = 0xE0; /* 11100000 */
+    }
+    else if (codepoint <= 0x10FFFF)
+    {
+        /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */
+        utf8_length = 4;
+        first_byte_mark = 0xF0; /* 11110000 */
+    }
+    else
+    {
+        /* invalid unicode codepoint */
+        goto fail;
+    }
+
+    /* encode as utf8 */
+    for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--)
+    {
+        /* 10xxxxxx */
+        (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF);
+        codepoint >>= 6;
+    }
+    /* encode first byte */
+    if (utf8_length > 1)
+    {
+        (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF);
+    }
+    else
+    {
+        (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F);
+    }
+
+    *output_pointer += utf8_length;
+
+    return sequence_length;
+
+fail:
+    return 0;
+}
+
+/* Parse the input text into an unescaped cinput, and populate item. */
+static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)
+{
+    const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1;
+    const unsigned char *input_end = buffer_at_offset(input_buffer) + 1;
+    unsigned char *output_pointer = NULL;
+    unsigned char *output = NULL;
+
+    /* not a string */
+    if (buffer_at_offset(input_buffer)[0] != '\"')
+    {
+        goto fail;
+    }
+
+    {
+        /* calculate approximate size of the output (overestimate) */
+        size_t allocation_length = 0;
+        size_t skipped_bytes = 0;
+        while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"'))
+        {
+            /* is escape sequence */
+            if (input_end[0] == '\\')
+            {
+                if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length)
+                {
+                    /* prevent buffer overflow when last input character is a backslash */
+                    goto fail;
+                }
+                skipped_bytes++;
+                input_end++;
+            }
+            input_end++;
+        }
+        if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"'))
+        {
+            goto fail; /* string ended unexpectedly */
+        }
+
+        /* This is at most how much we need for the output */
+        allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes;
+        output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof(""));
+        if (output == NULL)
+        {
+            goto fail; /* allocation failure */
+        }
+    }
+
+    output_pointer = output;
+    /* loop through the string literal */
+    while (input_pointer < input_end)
+    {
+        if (*input_pointer != '\\')
+        {
+            *output_pointer++ = *input_pointer++;
+        }
+        /* escape sequence */
+        else
+        {
+            unsigned char sequence_length = 2;
+            if ((input_end - input_pointer) < 1)
+            {
+                goto fail;
+            }
+
+            switch (input_pointer[1])
+            {
+                case 'b':
+                    *output_pointer++ = '\b';
+                    break;
+                case 'f':
+                    *output_pointer++ = '\f';
+                    break;
+                case 'n':
+                    *output_pointer++ = '\n';
+                    break;
+                case 'r':
+                    *output_pointer++ = '\r';
+                    break;
+                case 't':
+                    *output_pointer++ = '\t';
+                    break;
+                case '\"':
+                case '\\':
+                case '/':
+                    *output_pointer++ = input_pointer[1];
+                    break;
+
+                /* UTF-16 literal */
+                case 'u':
+                    sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer);
+                    if (sequence_length == 0)
+                    {
+                        /* failed to convert UTF16-literal to UTF-8 */
+                        goto fail;
+                    }
+                    break;
+
+                default:
+                    goto fail;
+            }
+            input_pointer += sequence_length;
+        }
+    }
+
+    /* zero terminate the output */
+    *output_pointer = '\0';
+
+    item->type = cJSON_String;
+    item->valuestring = (char*)output;
+
+    input_buffer->offset = (size_t) (input_end - input_buffer->content);
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if (output != NULL)
+    {
+        input_buffer->hooks.deallocate(output);
+    }
+
+    if (input_pointer != NULL)
+    {
+        input_buffer->offset = (size_t)(input_pointer - input_buffer->content);
+    }
+
+    return false;
+}
+
+/* Render the cstring provided to an escaped version that can be printed. */
+static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)
+{
+    const unsigned char *input_pointer = NULL;
+    unsigned char *output = NULL;
+    unsigned char *output_pointer = NULL;
+    size_t output_length = 0;
+    /* numbers of additional characters needed for escaping */
+    size_t escape_characters = 0;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* empty string */
+    if (input == NULL)
+    {
+        output = ensure(output_buffer, sizeof("\"\""));
+        if (output == NULL)
+        {
+            return false;
+        }
+        strcpy((char*)output, "\"\"");
+
+        return true;
+    }
+
+    /* set "flag" to 1 if something needs to be escaped */
+    for (input_pointer = input; *input_pointer; input_pointer++)
+    {
+        switch (*input_pointer)
+        {
+            case '\"':
+            case '\\':
+            case '\b':
+            case '\f':
+            case '\n':
+            case '\r':
+            case '\t':
+                /* one character escape sequence */
+                escape_characters++;
+                break;
+            default:
+                if (*input_pointer < 32)
+                {
+                    /* UTF-16 escape sequence uXXXX */
+                    escape_characters += 5;
+                }
+                break;
+        }
+    }
+    output_length = (size_t)(input_pointer - input) + escape_characters;
+
+    output = ensure(output_buffer, output_length + sizeof("\"\""));
+    if (output == NULL)
+    {
+        return false;
+    }
+
+    /* no characters have to be escaped */
+    if (escape_characters == 0)
+    {
+        output[0] = '\"';
+        memcpy(output + 1, input, output_length);
+        output[output_length + 1] = '\"';
+        output[output_length + 2] = '\0';
+
+        return true;
+    }
+
+    output[0] = '\"';
+    output_pointer = output + 1;
+    /* copy the string */
+    for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
+    {
+        if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))
+        {
+            /* normal character, copy */
+            *output_pointer = *input_pointer;
+        }
+        else
+        {
+            /* character needs to be escaped */
+            *output_pointer++ = '\\';
+            switch (*input_pointer)
+            {
+                case '\\':
+                    *output_pointer = '\\';
+                    break;
+                case '\"':
+                    *output_pointer = '\"';
+                    break;
+                case '\b':
+                    *output_pointer = 'b';
+                    break;
+                case '\f':
+                    *output_pointer = 'f';
+                    break;
+                case '\n':
+                    *output_pointer = 'n';
+                    break;
+                case '\r':
+                    *output_pointer = 'r';
+                    break;
+                case '\t':
+                    *output_pointer = 't';
+                    break;
+                default:
+                    /* escape and print as unicode codepoint */
+                    sprintf((char*)output_pointer, "u%04x", *input_pointer);
+                    output_pointer += 4;
+                    break;
+            }
+        }
+    }
+    output[output_length + 1] = '\"';
+    output[output_length + 2] = '\0';
+
+    return true;
+}
+
+/* Invoke print_string_ptr (which is useful) on an item. */
+static cJSON_bool print_string(const cJSON * const item, printbuffer * const p)
+{
+    return print_string_ptr((unsigned char*)item->valuestring, p);
+}
+
+/* Predeclare these prototypes. */
+static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer);
+static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer);
+static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer);
+static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer);
+static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer);
+static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer);
+
+/* Utility to jump whitespace and cr/lf */
+static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
+{
+    if ((buffer == NULL) || (buffer->content == NULL))
+    {
+        return NULL;
+    }
+
+    while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
+    {
+       buffer->offset++;
+    }
+
+    if (buffer->offset == buffer->length)
+    {
+        buffer->offset--;
+    }
+
+    return buffer;
+}
+
+/* Parse an object - create a new root, and populate. */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
+{
+    parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
+    cJSON *item = NULL;
+
+    /* reset error position */
+    global_error.json = NULL;
+    global_error.position = 0;
+
+    if (value == NULL)
+    {
+        goto fail;
+    }
+
+    buffer.content = (const unsigned char*)value;
+    buffer.length = strlen((const char*)value) + sizeof("");
+    buffer.offset = 0;
+    buffer.hooks = global_hooks;
+
+    item = cJSON_New_Item(&global_hooks);
+    if (item == NULL) /* memory fail */
+    {
+        goto fail;
+    }
+
+    if (!parse_value(item, buffer_skip_whitespace(&buffer)))
+    {
+        /* parse failure. ep is set. */
+        goto fail;
+    }
+
+    /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
+    if (require_null_terminated)
+    {
+        buffer_skip_whitespace(&buffer);
+        if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0')
+        {
+            goto fail;
+        }
+    }
+    if (return_parse_end)
+    {
+        *return_parse_end = (const char*)buffer_at_offset(&buffer);
+    }
+
+    return item;
+
+fail:
+    if (item != NULL)
+    {
+        cJSON_Delete(item);
+    }
+
+    if (value != NULL)
+    {
+        error local_error;
+        local_error.json = (const unsigned char*)value;
+        local_error.position = 0;
+
+        if (buffer.offset < buffer.length)
+        {
+            local_error.position = buffer.offset;
+        }
+        else if (buffer.length > 0)
+        {
+            local_error.position = buffer.length - 1;
+        }
+
+        if (return_parse_end != NULL)
+        {
+            *return_parse_end = (const char*)local_error.json + local_error.position;
+        }
+ 
+        global_error = local_error;
+    }
+
+    return NULL;
+}
+
+/* Default options for cJSON_Parse */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value)
+{
+    return cJSON_ParseWithOpts(value, 0, 0);
+}
+
+#define cjson_min(a, b) ((a < b) ? a : b)
+
+static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)
+{
+    printbuffer buffer[1];
+    unsigned char *printed = NULL;
+
+    memset(buffer, 0, sizeof(buffer));
+
+    /* create buffer */
+    buffer->buffer = (unsigned char*) hooks->allocate(256);
+    buffer->format = format;
+    buffer->hooks = *hooks;
+    if (buffer->buffer == NULL)
+    {
+        goto fail;
+    }
+
+    /* print the value */
+    if (!print_value(item, buffer))
+    {
+        goto fail;
+    }
+    update_offset(buffer);
+
+    /* check if reallocate is available */
+    if (hooks->reallocate != NULL)
+    {
+        printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->length);
+        buffer->buffer = NULL;
+        if (printed == NULL) {
+            goto fail;
+        }
+    }
+    else /* otherwise copy the JSON over to a new buffer */
+    {
+        printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
+        if (printed == NULL)
+        {
+            goto fail;
+        }
+        memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
+        printed[buffer->offset] = '\0'; /* just to be sure */
+
+        /* free the buffer */
+        hooks->deallocate(buffer->buffer);
+    }
+
+    return printed;
+
+fail:
+    if (buffer->buffer != NULL)
+    {
+        hooks->deallocate(buffer->buffer);
+    }
+
+    if (printed != NULL)
+    {
+        hooks->deallocate(printed);
+    }
+
+    return NULL;
+}
+
+/* Render a cJSON item/entity/structure to text. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item)
+{
+    return (char*)print(item, true, &global_hooks);
+}
+
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item)
+{
+    return (char*)print(item, false, &global_hooks);
+}
+
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)
+{
+    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
+
+    if (prebuffer < 0)
+    {
+        return NULL;
+    }
+
+    p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
+    if (!p.buffer)
+    {
+        return NULL;
+    }
+
+    p.length = (size_t)prebuffer;
+    p.offset = 0;
+    p.noalloc = false;
+    p.format = fmt;
+    p.hooks = global_hooks;
+
+    if (!print_value(item, &p))
+    {
+        global_hooks.deallocate(p.buffer);
+        return NULL;
+    }
+
+    return (char*)p.buffer;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buf, const int len, const cJSON_bool fmt)
+{
+    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
+
+    if ((len < 0) || (buf == NULL))
+    {
+        return false;
+    }
+
+    p.buffer = (unsigned char*)buf;
+    p.length = (size_t)len;
+    p.offset = 0;
+    p.noalloc = true;
+    p.format = fmt;
+    p.hooks = global_hooks;
+
+    return print_value(item, &p);
+}
+
+/* Parser core - when encountering text, process appropriately. */
+static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)
+{
+    if ((input_buffer == NULL) || (input_buffer->content == NULL))
+    {
+        return false; /* no input */
+    }
+
+    /* parse the different types of values */
+    /* null */
+    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0))
+    {
+        item->type = cJSON_NULL;
+        input_buffer->offset += 4;
+        return true;
+    }
+    /* false */
+    if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0))
+    {
+        item->type = cJSON_False;
+        input_buffer->offset += 5;
+        return true;
+    }
+    /* true */
+    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0))
+    {
+        item->type = cJSON_True;
+        item->valueint = 1;
+        input_buffer->offset += 4;
+        return true;
+    }
+    /* string */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"'))
+    {
+        return parse_string(item, input_buffer);
+    }
+    /* number */
+    if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9'))))
+    {
+        return parse_number(item, input_buffer);
+    }
+    /* array */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '['))
+    {
+        return parse_array(item, input_buffer);
+    }
+    /* object */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{'))
+    {
+        return parse_object(item, input_buffer);
+    }
+
+
+    return false;
+}
+
+/* Render a value to text. */
+static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output = NULL;
+
+    if ((item == NULL) || (output_buffer == NULL))
+    {
+        return false;
+    }
+
+    switch ((item->type) & 0xFF)
+    {
+        case cJSON_NULL:
+            output = ensure(output_buffer, 5);
+            if (output == NULL)
+            {
+                return false;
+            }
+            strcpy((char*)output, "null");
+            return true;
+
+        case cJSON_False:
+            output = ensure(output_buffer, 6);
+            if (output == NULL)
+            {
+                return false;
+            }
+            strcpy((char*)output, "false");
+            return true;
+
+        case cJSON_True:
+            output = ensure(output_buffer, 5);
+            if (output == NULL)
+            {
+                return false;
+            }
+            strcpy((char*)output, "true");
+            return true;
+
+        case cJSON_Number:
+            return print_number(item, output_buffer);
+
+        case cJSON_Raw:
+        {
+            size_t raw_length = 0;
+            if (item->valuestring == NULL)
+            {
+                if (!output_buffer->noalloc)
+                {
+                    output_buffer->hooks.deallocate(output_buffer->buffer);
+                }
+                return false;
+            }
+
+            raw_length = strlen(item->valuestring) + sizeof("");
+            output = ensure(output_buffer, raw_length);
+            if (output == NULL)
+            {
+                return false;
+            }
+            memcpy(output, item->valuestring, raw_length);
+            return true;
+        }
+
+        case cJSON_String:
+            return print_string(item, output_buffer);
+
+        case cJSON_Array:
+            return print_array(item, output_buffer);
+
+        case cJSON_Object:
+            return print_object(item, output_buffer);
+
+        default:
+            return false;
+    }
+}
+
+/* Build an array from input text. */
+static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer)
+{
+    cJSON *head = NULL; /* head of the linked list */
+    cJSON *current_item = NULL;
+
+    if (input_buffer->depth >= CJSON_NESTING_LIMIT)
+    {
+        return false; /* to deeply nested */
+    }
+    input_buffer->depth++;
+
+    if (buffer_at_offset(input_buffer)[0] != '[')
+    {
+        /* not an array */
+        goto fail;
+    }
+
+    input_buffer->offset++;
+    buffer_skip_whitespace(input_buffer);
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']'))
+    {
+        /* empty array */
+        goto success;
+    }
+
+    /* check if we skipped to the end of the buffer */
+    if (cannot_access_at_index(input_buffer, 0))
+    {
+        input_buffer->offset--;
+        goto fail;
+    }
+
+    /* step back to character in front of the first element */
+    input_buffer->offset--;
+    /* loop through the comma separated array elements */
+    do
+    {
+        /* allocate next item */
+        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
+        if (new_item == NULL)
+        {
+            goto fail; /* allocation failure */
+        }
+
+        /* attach next item to list */
+        if (head == NULL)
+        {
+            /* start the linked list */
+            current_item = head = new_item;
+        }
+        else
+        {
+            /* add to the end and advance */
+            current_item->next = new_item;
+            new_item->prev = current_item;
+            current_item = new_item;
+        }
+
+        /* parse next value */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_value(current_item, input_buffer))
+        {
+            goto fail; /* failed to parse value */
+        }
+        buffer_skip_whitespace(input_buffer);
+    }
+    while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
+
+    if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']')
+    {
+        goto fail; /* expected end of array */
+    }
+
+success:
+    input_buffer->depth--;
+
+    item->type = cJSON_Array;
+    item->child = head;
+
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if (head != NULL)
+    {
+        cJSON_Delete(head);
+    }
+
+    return false;
+}
+
+/* Render an array to text */
+static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    size_t length = 0;
+    cJSON *current_element = item->child;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* Compose the output array. */
+    /* opening square bracket */
+    output_pointer = ensure(output_buffer, 1);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+
+    *output_pointer = '[';
+    output_buffer->offset++;
+    output_buffer->depth++;
+
+    while (current_element != NULL)
+    {
+        if (!print_value(current_element, output_buffer))
+        {
+            return false;
+        }
+        update_offset(output_buffer);
+        if (current_element->next)
+        {
+            length = (size_t) (output_buffer->format ? 2 : 1);
+            output_pointer = ensure(output_buffer, length + 1);
+            if (output_pointer == NULL)
+            {
+                return false;
+            }
+            *output_pointer++ = ',';
+            if(output_buffer->format)
+            {
+                *output_pointer++ = ' ';
+            }
+            *output_pointer = '\0';
+            output_buffer->offset += length;
+        }
+        current_element = current_element->next;
+    }
+
+    output_pointer = ensure(output_buffer, 2);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+    *output_pointer++ = ']';
+    *output_pointer = '\0';
+    output_buffer->depth--;
+
+    return true;
+}
+
+/* Build an object from the text. */
+static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer)
+{
+    cJSON *head = NULL; /* linked list head */
+    cJSON *current_item = NULL;
+
+    if (input_buffer->depth >= CJSON_NESTING_LIMIT)
+    {
+        return false; /* to deeply nested */
+    }
+    input_buffer->depth++;
+
+    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{'))
+    {
+        goto fail; /* not an object */
+    }
+
+    input_buffer->offset++;
+    buffer_skip_whitespace(input_buffer);
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}'))
+    {
+        goto success; /* empty object */
+    }
+
+    /* check if we skipped to the end of the buffer */
+    if (cannot_access_at_index(input_buffer, 0))
+    {
+        input_buffer->offset--;
+        goto fail;
+    }
+
+    /* step back to character in front of the first element */
+    input_buffer->offset--;
+    /* loop through the comma separated array elements */
+    do
+    {
+        /* allocate next item */
+        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
+        if (new_item == NULL)
+        {
+            goto fail; /* allocation failure */
+        }
+
+        /* attach next item to list */
+        if (head == NULL)
+        {
+            /* start the linked list */
+            current_item = head = new_item;
+        }
+        else
+        {
+            /* add to the end and advance */
+            current_item->next = new_item;
+            new_item->prev = current_item;
+            current_item = new_item;
+        }
+
+        /* parse the name of the child */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_string(current_item, input_buffer))
+        {
+            goto fail; /* faile to parse name */
+        }
+        buffer_skip_whitespace(input_buffer);
+
+        /* swap valuestring and string, because we parsed the name */
+        current_item->string = current_item->valuestring;
+        current_item->valuestring = NULL;
+
+        if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':'))
+        {
+            goto fail; /* invalid object */
+        }
+
+        /* parse the value */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_value(current_item, input_buffer))
+        {
+            goto fail; /* failed to parse value */
+        }
+        buffer_skip_whitespace(input_buffer);
+    }
+    while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
+
+    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}'))
+    {
+        goto fail; /* expected end of object */
+    }
+
+success:
+    input_buffer->depth--;
+
+    item->type = cJSON_Object;
+    item->child = head;
+
+    input_buffer->offset++;
+    return true;
+
+fail:
+    if (head != NULL)
+    {
+        cJSON_Delete(head);
+    }
+
+    return false;
+}
+
+/* Render an object to text. */
+static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    size_t length = 0;
+    cJSON *current_item = item->child;
+
+    if (output_buffer == NULL)
+    {
+        return false;
+    }
+
+    /* Compose the output: */
+    length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */
+    output_pointer = ensure(output_buffer, length + 1);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+
+    *output_pointer++ = '{';
+    output_buffer->depth++;
+    if (output_buffer->format)
+    {
+        *output_pointer++ = '\n';
+    }
+    output_buffer->offset += length;
+
+    while (current_item)
+    {
+        if (output_buffer->format)
+        {
+            size_t i;
+            output_pointer = ensure(output_buffer, output_buffer->depth);
+            if (output_pointer == NULL)
+            {
+                return false;
+            }
+            for (i = 0; i < output_buffer->depth; i++)
+            {
+                *output_pointer++ = '\t';
+            }
+            output_buffer->offset += output_buffer->depth;
+        }
+
+        /* print key */
+        if (!print_string_ptr((unsigned char*)current_item->string, output_buffer))
+        {
+            return false;
+        }
+        update_offset(output_buffer);
+
+        length = (size_t) (output_buffer->format ? 2 : 1);
+        output_pointer = ensure(output_buffer, length);
+        if (output_pointer == NULL)
+        {
+            return false;
+        }
+        *output_pointer++ = ':';
+        if (output_buffer->format)
+        {
+            *output_pointer++ = '\t';
+        }
+        output_buffer->offset += length;
+
+        /* print value */
+        if (!print_value(current_item, output_buffer))
+        {
+            return false;
+        }
+        update_offset(output_buffer);
+
+        /* print comma if not last */
+        length = (size_t) ((output_buffer->format ? 1 : 0) + (current_item->next ? 1 : 0));
+        output_pointer = ensure(output_buffer, length + 1);
+        if (output_pointer == NULL)
+        {
+            return false;
+        }
+        if (current_item->next)
+        {
+            *output_pointer++ = ',';
+        }
+
+        if (output_buffer->format)
+        {
+            *output_pointer++ = '\n';
+        }
+        *output_pointer = '\0';
+        output_buffer->offset += length;
+
+        current_item = current_item->next;
+    }
+
+    output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2);
+    if (output_pointer == NULL)
+    {
+        return false;
+    }
+    if (output_buffer->format)
+    {
+        size_t i;
+        for (i = 0; i < (output_buffer->depth - 1); i++)
+        {
+            *output_pointer++ = '\t';
+        }
+    }
+    *output_pointer++ = '}';
+    *output_pointer = '\0';
+    output_buffer->depth--;
+
+    return true;
+}
+
+/* Get Array size/item / object item. */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)
+{
+    cJSON *child = NULL;
+    size_t size = 0;
+
+    if (array == NULL)
+    {
+        return 0;
+    }
+
+    child = array->child;
+
+    while(child != NULL)
+    {
+        size++;
+        child = child->next;
+    }
+
+    /* FIXME: Can overflow here. Cannot be fixed without breaking the API */
+
+    return (int)size;
+}
+
+static cJSON* get_array_item(const cJSON *array, size_t index)
+{
+    cJSON *current_child = NULL;
+
+    if (array == NULL)
+    {
+        return NULL;
+    }
+
+    current_child = array->child;
+    while ((current_child != NULL) && (index > 0))
+    {
+        index--;
+        current_child = current_child->next;
+    }
+
+    return current_child;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index)
+{
+    if (index < 0)
+    {
+        return NULL;
+    }
+
+    return get_array_item(array, (size_t)index);
+}
+
+static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)
+{
+    cJSON *current_element = NULL;
+
+    if ((object == NULL) || (name == NULL))
+    {
+        return NULL;
+    }
+
+    current_element = object->child;
+    if (case_sensitive)
+    {
+        while ((current_element != NULL) && (strcmp(name, current_element->string) != 0))
+        {
+            current_element = current_element->next;
+        }
+    }
+    else
+    {
+        while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0))
+        {
+            current_element = current_element->next;
+        }
+    }
+
+    return current_element;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string)
+{
+    return get_object_item(object, string, false);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string)
+{
+    return get_object_item(object, string, true);
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string)
+{
+    return cJSON_GetObjectItem(object, string) ? 1 : 0;
+}
+
+/* Utility for array list handling. */
+static void suffix_object(cJSON *prev, cJSON *item)
+{
+    prev->next = item;
+    item->prev = prev;
+}
+
+/* Utility for handling references. */
+static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)
+{
+    cJSON *reference = NULL;
+    if (item == NULL)
+    {
+        return NULL;
+    }
+
+    reference = cJSON_New_Item(hooks);
+    if (reference == NULL)
+    {
+        return NULL;
+    }
+
+    memcpy(reference, item, sizeof(cJSON));
+    reference->string = NULL;
+    reference->type |= cJSON_IsReference;
+    reference->next = reference->prev = NULL;
+    return reference;
+}
+
+/* Add item to array/object. */
+CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item)
+{
+    cJSON *child = NULL;
+
+    if ((item == NULL) || (array == NULL))
+    {
+        return;
+    }
+
+    child = array->child;
+
+    if (child == NULL)
+    {
+        /* list is empty, start new one */
+        array->child = item;
+    }
+    else
+    {
+        /* append to the end */
+        while (child->next)
+        {
+            child = child->next;
+        }
+        suffix_object(child, item);
+    }
+}
+
+CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)
+{
+    if (item == NULL)
+    {
+        return;
+    }
+
+    /* call cJSON_AddItemToObjectCS for code reuse */
+    cJSON_AddItemToObjectCS(object, (char*)cJSON_strdup((const unsigned char*)string, &global_hooks), item);
+    /* remove cJSON_StringIsConst flag */
+    item->type &= ~cJSON_StringIsConst;
+}
+
+#if defined (__clang__) || ((__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
+    #pragma GCC diagnostic push
+#endif
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#endif
+
+/* Add an item to an object with constant string as key */
+CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)
+{
+    if ((item == NULL) || (string == NULL))
+    {
+        return;
+    }
+    if (!(item->type & cJSON_StringIsConst) && item->string)
+    {
+        global_hooks.deallocate(item->string);
+    }
+    item->string = (char*)string;
+    item->type |= cJSON_StringIsConst;
+    cJSON_AddItemToArray(object, item);
+}
+#if defined (__clang__) || ((__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
+    #pragma GCC diagnostic pop
+#endif
+
+CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
+{
+    if (array == NULL)
+    {
+        return;
+    }
+
+    cJSON_AddItemToArray(array, create_reference(item, &global_hooks));
+}
+
+CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)
+{
+    if ((object == NULL) || (string == NULL))
+    {
+        return;
+    }
+
+    cJSON_AddItemToObject(object, string, create_reference(item, &global_hooks));
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item)
+{
+    if ((parent == NULL) || (item == NULL))
+    {
+        return NULL;
+    }
+
+    if (item->prev != NULL)
+    {
+        /* not the first element */
+        item->prev->next = item->next;
+    }
+    if (item->next != NULL)
+    {
+        /* not the last element */
+        item->next->prev = item->prev;
+    }
+
+    if (item == parent->child)
+    {
+        /* first element */
+        parent->child = item->next;
+    }
+    /* make sure the detached item doesn't point anywhere anymore */
+    item->prev = NULL;
+    item->next = NULL;
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which)
+{
+    if (which < 0)
+    {
+        return NULL;
+    }
+
+    return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which));
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which)
+{
+    cJSON_Delete(cJSON_DetachItemFromArray(array, which));
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string)
+{
+    cJSON *to_detach = cJSON_GetObjectItem(object, string);
+
+    return cJSON_DetachItemViaPointer(object, to_detach);
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string)
+{
+    cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string);
+
+    return cJSON_DetachItemViaPointer(object, to_detach);
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string)
+{
+    cJSON_Delete(cJSON_DetachItemFromObject(object, string));
+}
+
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string)
+{
+    cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string));
+}
+
+/* Replace array/object items with new ones. */
+CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)
+{
+    cJSON *after_inserted = NULL;
+
+    if (which < 0)
+    {
+        return;
+    }
+
+    after_inserted = get_array_item(array, (size_t)which);
+    if (after_inserted == NULL)
+    {
+        cJSON_AddItemToArray(array, newitem);
+        return;
+    }
+
+    newitem->next = after_inserted;
+    newitem->prev = after_inserted->prev;
+    after_inserted->prev = newitem;
+    if (after_inserted == array->child)
+    {
+        array->child = newitem;
+    }
+    else
+    {
+        newitem->prev->next = newitem;
+    }
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement)
+{
+    if ((parent == NULL) || (replacement == NULL) || (item == NULL))
+    {
+        return false;
+    }
+
+    if (replacement == item)
+    {
+        return true;
+    }
+
+    replacement->next = item->next;
+    replacement->prev = item->prev;
+
+    if (replacement->next != NULL)
+    {
+        replacement->next->prev = replacement;
+    }
+    if (replacement->prev != NULL)
+    {
+        replacement->prev->next = replacement;
+    }
+    if (parent->child == item)
+    {
+        parent->child = replacement;
+    }
+
+    item->next = NULL;
+    item->prev = NULL;
+    cJSON_Delete(item);
+
+    return true;
+}
+
+CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)
+{
+    if (which < 0)
+    {
+        return;
+    }
+
+    cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem);
+}
+
+static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)
+{
+    if ((replacement == NULL) || (string == NULL))
+    {
+        return false;
+    }
+
+    /* replace the name in the replacement */
+    if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL))
+    {
+        cJSON_free(replacement->string);
+    }
+    replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
+    replacement->type &= ~cJSON_StringIsConst;
+
+    cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement);
+
+    return true;
+}
+
+CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem)
+{
+    replace_item_in_object(object, string, newitem, false);
+}
+
+CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem)
+{
+    replace_item_in_object(object, string, newitem, true);
+}
+
+/* Create basic types: */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_NULL;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_True;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_False;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool b)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = b ? cJSON_True : cJSON_False;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_Number;
+        item->valuedouble = num;
+
+        /* use saturation in case of overflow */
+        if (num >= INT_MAX)
+        {
+            item->valueint = INT_MAX;
+        }
+        else if (num <= INT_MIN)
+        {
+            item->valueint = INT_MIN;
+        }
+        else
+        {
+            item->valueint = (int)num;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_String;
+        item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
+        if(!item->valuestring)
+        {
+            cJSON_Delete(item);
+            return NULL;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type = cJSON_Raw;
+        item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks);
+        if(!item->valuestring)
+        {
+            cJSON_Delete(item);
+            return NULL;
+        }
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if(item)
+    {
+        item->type=cJSON_Array;
+    }
+
+    return item;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void)
+{
+    cJSON *item = cJSON_New_Item(&global_hooks);
+    if (item)
+    {
+        item->type = cJSON_Object;
+    }
+
+    return item;
+}
+
+/* Create Arrays: */
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (numbers == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+    for(i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateNumber(numbers[i]);
+        if (!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (numbers == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateNumber((double)numbers[i]);
+        if(!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (numbers == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for(i = 0;a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateNumber(numbers[i]);
+        if(!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    return a;
+}
+
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count)
+{
+    size_t i = 0;
+    cJSON *n = NULL;
+    cJSON *p = NULL;
+    cJSON *a = NULL;
+
+    if ((count < 0) || (strings == NULL))
+    {
+        return NULL;
+    }
+
+    a = cJSON_CreateArray();
+
+    for (i = 0; a && (i < (size_t)count); i++)
+    {
+        n = cJSON_CreateString(strings[i]);
+        if(!n)
+        {
+            cJSON_Delete(a);
+            return NULL;
+        }
+        if(!i)
+        {
+            a->child = n;
+        }
+        else
+        {
+            suffix_object(p,n);
+        }
+        p = n;
+    }
+
+    return a;
+}
+
+/* Duplication */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse)
+{
+    cJSON *newitem = NULL;
+    cJSON *child = NULL;
+    cJSON *next = NULL;
+    cJSON *newchild = NULL;
+
+    /* Bail on bad ptr */
+    if (!item)
+    {
+        goto fail;
+    }
+    /* Create new item */
+    newitem = cJSON_New_Item(&global_hooks);
+    if (!newitem)
+    {
+        goto fail;
+    }
+    /* Copy over all vars */
+    newitem->type = item->type & (~cJSON_IsReference);
+    newitem->valueint = item->valueint;
+    newitem->valuedouble = item->valuedouble;
+    if (item->valuestring)
+    {
+        newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks);
+        if (!newitem->valuestring)
+        {
+            goto fail;
+        }
+    }
+    if (item->string)
+    {
+        newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks);
+        if (!newitem->string)
+        {
+            goto fail;
+        }
+    }
+    /* If non-recursive, then we're done! */
+    if (!recurse)
+    {
+        return newitem;
+    }
+    /* Walk the ->next chain for the child. */
+    child = item->child;
+    while (child != NULL)
+    {
+        newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */
+        if (!newchild)
+        {
+            goto fail;
+        }
+        if (next != NULL)
+        {
+            /* If newitem->child already set, then crosswire ->prev and ->next and move on */
+            next->next = newchild;
+            newchild->prev = next;
+            next = newchild;
+        }
+        else
+        {
+            /* Set newitem->child and move to it */
+            newitem->child = newchild;
+            next = newchild;
+        }
+        child = child->next;
+    }
+
+    return newitem;
+
+fail:
+    if (newitem != NULL)
+    {
+        cJSON_Delete(newitem);
+    }
+
+    return NULL;
+}
+
+CJSON_PUBLIC(void) cJSON_Minify(char *json)
+{
+    unsigned char *into = (unsigned char*)json;
+
+    if (json == NULL)
+    {
+        return;
+    }
+
+    while (*json)
+    {
+        if (*json == ' ')
+        {
+            json++;
+        }
+        else if (*json == '\t')
+        {
+            /* Whitespace characters. */
+            json++;
+        }
+        else if (*json == '\r')
+        {
+            json++;
+        }
+        else if (*json=='\n')
+        {
+            json++;
+        }
+        else if ((*json == '/') && (json[1] == '/'))
+        {
+            /* double-slash comments, to end of line. */
+            while (*json && (*json != '\n'))
+            {
+                json++;
+            }
+        }
+        else if ((*json == '/') && (json[1] == '*'))
+        {
+            /* multiline comments. */
+            while (*json && !((*json == '*') && (json[1] == '/')))
+            {
+                json++;
+            }
+            json += 2;
+        }
+        else if (*json == '\"')
+        {
+            /* string literals, which are \" sensitive. */
+            *into++ = (unsigned char)*json++;
+            while (*json && (*json != '\"'))
+            {
+                if (*json == '\\')
+                {
+                    *into++ = (unsigned char)*json++;
+                }
+                *into++ = (unsigned char)*json++;
+            }
+            *into++ = (unsigned char)*json++;
+        }
+        else
+        {
+            /* All other characters. */
+            *into++ = (unsigned char)*json++;
+        }
+    }
+
+    /* and null-terminate. */
+    *into = '\0';
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Invalid;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_False;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xff) == cJSON_True;
+}
+
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & (cJSON_True | cJSON_False)) != 0;
+}
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_NULL;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Number;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_String;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Array;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Object;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item)
+{
+    if (item == NULL)
+    {
+        return false;
+    }
+
+    return (item->type & 0xFF) == cJSON_Raw;
+}
+
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive)
+{
+    if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)) || cJSON_IsInvalid(a))
+    {
+        return false;
+    }
+
+    /* check if type is valid */
+    switch (a->type & 0xFF)
+    {
+        case cJSON_False:
+        case cJSON_True:
+        case cJSON_NULL:
+        case cJSON_Number:
+        case cJSON_String:
+        case cJSON_Raw:
+        case cJSON_Array:
+        case cJSON_Object:
+            break;
+
+        default:
+            return false;
+    }
+
+    /* identical objects are equal */
+    if (a == b)
+    {
+        return true;
+    }
+
+    switch (a->type & 0xFF)
+    {
+        /* in these cases and equal type is enough */
+        case cJSON_False:
+        case cJSON_True:
+        case cJSON_NULL:
+            return true;
+
+        case cJSON_Number:
+            if (a->valuedouble == b->valuedouble)
+            {
+                return true;
+            }
+            return false;
+
+        case cJSON_String:
+        case cJSON_Raw:
+            if ((a->valuestring == NULL) || (b->valuestring == NULL))
+            {
+                return false;
+            }
+            if (strcmp(a->valuestring, b->valuestring) == 0)
+            {
+                return true;
+            }
+
+            return false;
+
+        case cJSON_Array:
+        {
+            cJSON *a_element = a->child;
+            cJSON *b_element = b->child;
+
+            for (; (a_element != NULL) && (b_element != NULL);)
+            {
+                if (!cJSON_Compare(a_element, b_element, case_sensitive))
+                {
+                    return false;
+                }
+
+                a_element = a_element->next;
+                b_element = b_element->next;
+            }
+
+            /* one of the arrays is longer than the other */
+            if (a_element != b_element) {
+                return false;
+            }
+
+            return true;
+        }
+
+        case cJSON_Object:
+        {
+            cJSON *a_element = NULL;
+            cJSON *b_element = NULL;
+            cJSON_ArrayForEach(a_element, a)
+            {
+                /* TODO This has O(n^2) runtime, which is horrible! */
+                b_element = get_object_item(b, a_element->string, case_sensitive);
+                if (b_element == NULL)
+                {
+                    return false;
+                }
+
+                if (!cJSON_Compare(a_element, b_element, case_sensitive))
+                {
+                    return false;
+                }
+            }
+
+            /* doing this twice, once on a and b to prevent true comparison if a subset of b
+             * TODO: Do this the proper way, this is just a fix for now */
+            cJSON_ArrayForEach(b_element, b)
+            {
+                a_element = get_object_item(a, b_element->string, case_sensitive);
+                if (a_element == NULL)
+                {
+                    return false;
+                }
+
+                if (!cJSON_Compare(b_element, a_element, case_sensitive))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        default:
+            return false;
+    }
+}
+
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size)
+{
+    return global_hooks.allocate(size);
+}
+
+CJSON_PUBLIC(void) cJSON_free(void *object)
+{
+    global_hooks.deallocate(object);
+}

factory_test_src/src/cJSON.h

+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 5
+#define CJSON_VERSION_PATCH 9
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON
+{
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks
+{
+      void *(*malloc_fn)(size_t sz);
+      void (*free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 2 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type __stdcall
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type __stdcall
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type __stdcall
+#endif
+#else /* !WIN32 */
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *c);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* These utilities create an Array of count items. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char **strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detatch items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
+CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+need to be released. With recurse!=0, it will duplicate any children connected to the item.
+The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
+
+
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Macros for creating things quickly. */
+#define cJSON_AddNullToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateNull())
+#define cJSON_AddTrueToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
+#define cJSON_AddFalseToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
+#define cJSON_AddBoolToObject(object,name,b) cJSON_AddItemToObject(object, name, cJSON_CreateBool(b))
+#define cJSON_AddNumberToObject(object,name,n) cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
+#define cJSON_AddStringToObject(object,name,s) cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
+#define cJSON_AddRawToObject(object,name,s) cJSON_AddItemToObject(object, name, cJSON_CreateRaw(s))
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

factory_test_src/src/cJSON_Utils.c

+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#pragma GCC visibility push(default)
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <limits.h>
+#pragma GCC visibility pop
+
+#include "cJSON_Utils.h"
+
+/* define our own boolean type */
+#define true ((cJSON_bool)1)
+#define false ((cJSON_bool)0)
+
+static unsigned char* cJSONUtils_strdup(const unsigned char* const string)
+{
+    size_t length = 0;
+    unsigned char *copy = NULL;
+
+    length = strlen((const char*)string) + sizeof("");
+    copy = (unsigned char*) cJSON_malloc(length);
+    if (copy == NULL)
+    {
+        return NULL;
+    }
+    memcpy(copy, string, length);
+
+    return copy;
+}
+
+/* string comparison which doesn't consider NULL pointers equal */
+static int compare_strings(const unsigned char *string1, const unsigned char *string2, const cJSON_bool case_sensitive)
+{
+    if ((string1 == NULL) || (string2 == NULL))
+    {
+        return 1;
+    }
+
+    if (string1 == string2)
+    {
+        return 0;
+    }
+
+    if (case_sensitive)
+    {
+        return strcmp((const char*)string1, (const char*)string2);
+    }
+
+    for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++)
+    {
+        if (*string1 == '\0')
+        {
+            return 0;
+        }
+    }
+
+    return tolower(*string1) - tolower(*string2);
+}
+
+/* Compare the next path element of two JSON pointers, two NULL pointers are considered unequal: */
+static cJSON_bool compare_pointers(const unsigned char *name, const unsigned char *pointer, const cJSON_bool case_sensitive)
+{
+    if ((name == NULL) || (pointer == NULL))
+    {
+        return false;
+    }
+
+    for (; (*name != '\0') && (*pointer != '\0') && (*pointer != '/'); (void)name++, pointer++) /* compare until next '/' */
+    {
+        if (*pointer == '~')
+        {
+            /* check for escaped '~' (~0) and '/' (~1) */
+            if (((pointer[1] != '0') || (*name != '~')) && ((pointer[1] != '1') || (*name != '/')))
+            {
+                /* invalid escape sequence or wrong character in *name */
+                return false;
+            }
+            else
+            {
+                pointer++;
+            }
+        }
+        else if ((!case_sensitive && (tolower(*name) != tolower(*pointer))) || (case_sensitive && (*name != *pointer)))
+        {
+            return false;
+        }
+    }
+    if (((*pointer != 0) && (*pointer != '/')) != (*name != 0))
+    {
+        /* one string has ended, the other not */
+        return false;;
+    }
+
+    return true;
+}
+
+/* calculate the length of a string if encoded as JSON pointer with ~0 and ~1 escape sequences */
+static size_t pointer_encoded_length(const unsigned char *string)
+{
+    size_t length;
+    for (length = 0; *string != '\0'; (void)string++, length++)
+    {
+        /* character needs to be escaped? */
+        if ((*string == '~') || (*string == '/'))
+        {
+            length++;
+        }
+    }
+
+    return length;
+}
+
+/* copy a string while escaping '~' and '/' with ~0 and ~1 JSON pointer escape codes */
+static void encode_string_as_pointer(unsigned char *destination, const unsigned char *source)
+{
+    for (; source[0] != '\0'; (void)source++, destination++)
+    {
+        if (source[0] == '/')
+        {
+            destination[1] = '1';
+            destination++;
+        }
+        else if (source[0] == '~')
+        {
+            destination[0] = '~';
+            destination[1] = '1';
+            destination++;
+        }
+        else
+        {
+            destination[0] = source[0];
+        }
+    }
+
+    destination[0] = '\0';
+}
+
+CJSON_PUBLIC(char *) cJSONUtils_FindPointerFromObjectTo(const cJSON * const object, const cJSON * const target)
+{
+    size_t child_index = 0;
+    cJSON *current_child = 0;
+
+    if ((object == NULL) || (target == NULL))
+    {
+        return NULL;
+    }
+
+    if (object == target)
+    {
+        /* found */
+        return (char*)cJSONUtils_strdup((const unsigned char*)"");
+    }
+
+    /* recursively search all children of the object or array */
+    for (current_child = object->child; current_child != NULL; (void)(current_child = current_child->next), child_index++)
+    {
+        unsigned char *target_pointer = (unsigned char*)cJSONUtils_FindPointerFromObjectTo(current_child, target);
+        /* found the target? */
+        if (target_pointer != NULL)
+        {
+            if (cJSON_IsArray(object))
+            {
+                /* reserve enough memory for a 64 bit integer + '/' and '\0' */
+                unsigned char *full_pointer = (unsigned char*)cJSON_malloc(strlen((char*)target_pointer) + 20 + sizeof("/"));
+                /* check if conversion to unsigned long is valid
+                 * This should be eliminated at compile time by dead code elimination
+                 * if size_t is an alias of unsigned long, or if it is bigger */
+                if (child_index > ULONG_MAX)
+                {
+                    cJSON_free(target_pointer);
+                    return NULL;
+                }
+                sprintf((char*)full_pointer, "/%lu%s", (unsigned long)child_index, target_pointer); /* /<array_index><path> */
+                cJSON_free(target_pointer);
+
+                return (char*)full_pointer;
+            }
+
+            if (cJSON_IsObject(object))
+            {
+                unsigned char *full_pointer = (unsigned char*)cJSON_malloc(strlen((char*)target_pointer) + pointer_encoded_length((unsigned char*)current_child->string) + 2);
+                full_pointer[0] = '/';
+                encode_string_as_pointer(full_pointer + 1, (unsigned char*)current_child->string);
+                strcat((char*)full_pointer, (char*)target_pointer);
+                cJSON_free(target_pointer);
+
+                return (char*)full_pointer;
+            }
+
+            /* reached leaf of the tree, found nothing */
+            cJSON_free(target_pointer);
+            return NULL;
+        }
+    }
+
+    /* not found */
+    return NULL;
+}
+
+/* non broken version of cJSON_GetArrayItem */
+static cJSON *get_array_item(const cJSON *array, size_t item)
+{
+    cJSON *child = array ? array->child : NULL;
+    while ((child != NULL) && (item > 0))
+    {
+        item--;
+        child = child->next;
+    }
+
+    return child;
+}
+
+static cJSON_bool decode_array_index_from_pointer(const unsigned char * const pointer, size_t * const index)
+{
+    size_t parsed_index = 0;
+    size_t position = 0;
+
+    if ((pointer[0] == '0') && ((pointer[1] != '\0') && (pointer[1] != '/')))
+    {
+        /* leading zeroes are not permitted */
+        return 0;
+    }
+
+    for (position = 0; (pointer[position] >= '0') && (pointer[0] <= '9'); position++)
+    {
+        parsed_index = (10 * parsed_index) + (size_t)(pointer[position] - '0');
+
+    }
+
+    if ((pointer[position] != '\0') && (pointer[position] != '/'))
+    {
+        return 0;
+    }
+
+    *index = parsed_index;
+
+    return 1;
+}
+
+static cJSON *get_item_from_pointer(cJSON * const object, const char * pointer, const cJSON_bool case_sensitive)
+{
+    cJSON *current_element = object;
+
+    if (pointer == NULL)
+    {
+        return NULL;
+    }
+
+    /* follow path of the pointer */
+    while ((pointer[0] == '/') && (current_element != NULL))
+    {
+        pointer++;
+        if (cJSON_IsArray(current_element))
+        {
+            size_t index = 0;
+            if (!decode_array_index_from_pointer((const unsigned char*)pointer, &index))
+            {
+                return NULL;
+            }
+
+            current_element = get_array_item(current_element, index);
+        }
+        else if (cJSON_IsObject(current_element))
+        {
+            current_element = current_element->child;
+            /* GetObjectItem. */
+            while ((current_element != NULL) && !compare_pointers((unsigned char*)current_element->string, (const unsigned char*)pointer, case_sensitive))
+            {
+                current_element = current_element->next;
+            }
+        }
+        else
+        {
+            return NULL;
+        }
+
+        /* skip to the next path token or end of string */
+        while ((pointer[0] != '\0') && (pointer[0] != '/'))
+        {
+            pointer++;
+        }
+    }
+
+    return current_element;
+}
+
+CJSON_PUBLIC(cJSON *) cJSONUtils_GetPointer(cJSON * const object, const char *pointer)
+{
+    return get_item_from_pointer(object, pointer, false);
+}
+
+CJSON_PUBLIC(cJSON *) cJSONUtils_GetPointerCaseSensitive(cJSON * const object, const char *pointer)
+{
+    return get_item_from_pointer(object, pointer, true);
+}
+
+/* JSON Patch implementation. */
+static void decode_pointer_inplace(unsigned char *string)
+{
+    unsigned char *decoded_string = string;
+
+    if (string == NULL) {
+        return;
+    }
+
+    for (; *string; (void)decoded_string++, string++)
+    {
+        if (string[0] == '~')
+        {
+            if (string[1] == '0')
+            {
+                decoded_string[0] = '~';
+            }
+            else if (string[1] == '1')
+            {
+                decoded_string[1] = '/';
+            }
+            else
+            {
+                /* invalid escape sequence */
+                return;
+            }
+
+            string++;
+        }
+    }
+
+    decoded_string[0] = '\0';
+}
+
+/* non-broken cJSON_DetachItemFromArray */
+static cJSON *detach_item_from_array(cJSON *array, size_t which)
+{
+    cJSON *c = array->child;
+    while (c && (which > 0))
+    {
+        c = c->next;
+        which--;
+    }
+    if (!c)
+    {
+        /* item doesn't exist */
+        return NULL;
+    }
+    if (c->prev)
+    {
+        /* not the first element */
+        c->prev->next = c->next;
+    }
+    if (c->next)
+    {
+        c->next->prev = c->prev;
+    }
+    if (c==array->child)
+    {
+        array->child = c->next;
+    }
+    /* make sure the detached item doesn't point anywhere anymore */
+    c->prev = c->next = NULL;
+
+    return c;
+}
+
+/* detach an item at the given path */
+static cJSON *detach_path(cJSON *object, const unsigned char *path, const cJSON_bool case_sensitive)
+{
+    unsigned char *parent_pointer = NULL;
+    unsigned char *child_pointer = NULL;
+    cJSON *parent = NULL;
+    cJSON *detached_item = NULL;
+
+    /* copy path and split it in parent and child */
+    parent_pointer = cJSONUtils_strdup(path);
+    if (parent_pointer == NULL) {
+        goto cleanup;
+    }
+
+    child_pointer = (unsigned char*)strrchr((char*)parent_pointer, '/'); /* last '/' */
+    if (child_pointer == NULL)
+    {
+        goto cleanup;
+    }
+    /* split strings */
+    child_pointer[0] = '\0';
+    child_pointer++;
+
+    parent = get_item_from_pointer(object, (char*)parent_pointer, case_sensitive);
+    decode_pointer_inplace(child_pointer);
+
+    if (cJSON_IsArray(parent))
+    {
+        size_t index = 0;
+        if (!decode_array_index_from_pointer(child_pointer, &index))
+        {
+            goto cleanup;
+        }
+        detached_item = detach_item_from_array(parent, index);
+    }
+    else if (cJSON_IsObject(parent))
+    {
+        detached_item = cJSON_DetachItemFromObject(parent, (char*)child_pointer);
+    }
+    else
+    {
+        /* Couldn't find object to remove child from. */
+        goto cleanup;
+    }
+
+cleanup:
+    if (parent_pointer != NULL)
+    {
+        cJSON_free(parent_pointer);
+    }
+
+    return detached_item;
+}
+
+/* sort lists using mergesort */
+static cJSON *sort_list(cJSON *list, const cJSON_bool case_sensitive)
+{
+    cJSON *first = list;
+    cJSON *second = list;
+    cJSON *current_item = list;
+    cJSON *result = list;
+    cJSON *result_tail = NULL;
+
+    if ((list == NULL) || (list->next == NULL))
+    {
+        /* One entry is sorted already. */
+        return result;
+    }
+
+    while ((current_item != NULL) && (current_item->next != NULL) && (compare_strings((unsigned char*)current_item->string, (unsigned char*)current_item->next->string, case_sensitive) < 0))
+    {
+        /* Test for list sorted. */
+        current_item = current_item->next;
+    }
+    if ((current_item == NULL) || (current_item->next == NULL))
+    {
+        /* Leave sorted lists unmodified. */
+        return result;
+    }
+
+    /* reset pointer to the beginning */
+    current_item = list;
+    while (current_item != NULL)
+    {
+        /* Walk two pointers to find the middle. */
+        second = second->next;
+        current_item = current_item->next;
+        /* advances current_item two steps at a time */
+        if (current_item != NULL)
+        {
+            current_item = current_item->next;
+        }
+    }
+    if ((second != NULL) && (second->prev != NULL))
+    {
+        /* Split the lists */
+        second->prev->next = NULL;
+    }
+
+    /* Recursively sort the sub-lists. */
+    first = sort_list(first, case_sensitive);
+    second = sort_list(second, case_sensitive);
+    result = NULL;
+
+    /* Merge the sub-lists */
+    while ((first != NULL) && (second != NULL))
+    {
+        cJSON *smaller = NULL;
+        if (compare_strings((unsigned char*)first->string, (unsigned char*)second->string, false) < 0)
+        {
+            smaller = first;
+        }
+        else
+        {
+            smaller = second;
+        }
+
+        if (result == NULL)
+        {
+            /* start merged list with the smaller element */
+            result_tail = smaller;
+            result = smaller;
+        }
+        else
+        {
+            /* add smaller element to the list */
+            result_tail->next = smaller;
+            smaller->prev = result_tail;
+            result_tail = smaller;
+        }
+
+        if (first == smaller)
+        {
+            first = first->next;
+        }
+        else
+        {
+            second = second->next;
+        }
+    }
+
+    if (first != NULL)
+    {
+        /* Append rest of first list. */
+        if (result == NULL)
+        {
+            return first;
+        }
+        result_tail->next = first;
+        first->prev = result_tail;
+    }
+    if (second != NULL)
+    {
+        /* Append rest of second list */
+        if (result == NULL)
+        {
+            return second;
+        }
+        result_tail->next = second;
+        second->prev = result_tail;
+    }
+
+    return result;
+}
+
+static void sort_object(cJSON * const object, const cJSON_bool case_sensitive)
+{
+    if (object == NULL)
+    {
+        return;
+    }
+    object->child = sort_list(object->child, case_sensitive);
+}
+
+static cJSON_bool compare_json(cJSON *a, cJSON *b, const cJSON_bool case_sensitive)
+{
+    if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)))
+    {
+        /* mismatched type. */
+        return false;
+    }
+    switch (a->type & 0xFF)
+    {
+        case cJSON_Number:
+            /* numeric mismatch. */
+            if ((a->valueint != b->valueint) || (a->valuedouble != b->valuedouble))
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+
+        case cJSON_String:
+            /* string mismatch. */
+            if (strcmp(a->valuestring, b->valuestring) != 0)
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+
+        case cJSON_Array:
+            for ((void)(a = a->child), b = b->child; (a != NULL) && (b != NULL); (void)(a = a->next), b = b->next)
+            {
+                cJSON_bool identical = compare_json(a, b, case_sensitive);
+                if (!identical)
+                {
+                    return false;
+                }
+            }
+
+            /* array size mismatch? (one of both children is not NULL) */
+            if ((a != NULL) || (b != NULL))
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+
+        case cJSON_Object:
+            sort_object(a, case_sensitive);
+            sort_object(b, case_sensitive);
+            for ((void)(a = a->child), b = b->child; (a != NULL) && (b != NULL); (void)(a = a->next), b = b->next)
+            {
+                cJSON_bool identical = false;
+                /* compare object keys */
+                if (compare_strings((unsigned char*)a->string, (unsigned char*)b->string, case_sensitive))
+                {
+                    /* missing member */
+                    return false;
+                }
+                identical = compare_json(a, b, case_sensitive);
+                if (!identical)
+                {
+                    return false;
+                }
+            }
+
+            /* object length mismatch (one of both children is not null) */
+            if ((a != NULL) || (b != NULL))
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+
+        default:
+            break;
+    }
+
+    /* null, true or false */
+    return true;
+}
+
+/* non broken version of cJSON_InsertItemInArray */
+static cJSON_bool insert_item_in_array(cJSON *array, size_t which, cJSON *newitem)
+{
+    cJSON *child = array->child;
+    while (child && (which > 0))
+    {
+        child = child->next;
+        which--;
+    }
+    if (which > 0)
+    {
+        /* item is after the end of the array */
+        return 0;
+    }
+    if (child == NULL)
+    {
+        cJSON_AddItemToArray(array, newitem);
+        return 1;
+    }
+
+    /* insert into the linked list */
+    newitem->next = child;
+    newitem->prev = child->prev;
+    child->prev = newitem;
+
+    /* was it at the beginning */
+    if (child == array->child)
+    {
+        array->child = newitem;
+    }
+    else
+    {
+        newitem->prev->next = newitem;
+    }
+
+    return 1;
+}
+
+static cJSON *get_object_item(const cJSON * const object, const char* name, const cJSON_bool case_sensitive)
+{
+    if (case_sensitive)
+    {
+        return cJSON_GetObjectItemCaseSensitive(object, name);
+    }
+
+    return cJSON_GetObjectItem(object, name);
+}
+
+enum patch_operation { INVALID, ADD, REMOVE, REPLACE, MOVE, COPY, TEST };
+
+static enum patch_operation decode_patch_operation(const cJSON * const patch, const cJSON_bool case_sensitive)
+{
+    cJSON *operation = get_object_item(patch, "op", case_sensitive);
+    if (!cJSON_IsString(operation))
+    {
+        return INVALID;
+    }
+
+    if (strcmp(operation->valuestring, "add") == 0)
+    {
+        return ADD;
+    }
+
+    if (strcmp(operation->valuestring, "remove") == 0)
+    {
+        return REMOVE;
+    }
+
+    if (strcmp(operation->valuestring, "replace") == 0)
+    {
+        return REPLACE;
+    }
+
+    if (strcmp(operation->valuestring, "move") == 0)
+    {
+        return MOVE;
+    }
+
+    if (strcmp(operation->valuestring, "copy") == 0)
+    {
+        return COPY;
+    }
+
+    if (strcmp(operation->valuestring, "test") == 0)
+    {
+        return TEST;
+    }
+
+    return INVALID;
+}
+
+/* overwrite and existing item with another one and free resources on the way */
+static void overwrite_item(cJSON * const root, const cJSON replacement)
+{
+    if (root == NULL)
+    {
+        return;
+    }
+
+    if (root->string != NULL)
+    {
+        cJSON_free(root->string);
+    }
+    if (root->valuestring != NULL)
+    {
+        cJSON_free(root->valuestring);
+    }
+    if (root->child != NULL)
+    {
+        cJSON_Delete(root->child);
+    }
+
+    memcpy(root, &replacement, sizeof(cJSON));
+}
+
+static int apply_patch(cJSON *object, const cJSON *patch, const cJSON_bool case_sensitive)
+{
+    cJSON *path = NULL;
+    cJSON *value = NULL;
+    cJSON *parent = NULL;
+    enum patch_operation opcode = INVALID;
+    unsigned char *parent_pointer = NULL;
+    unsigned char *child_pointer = NULL;
+    int status = 0;
+
+    path = get_object_item(patch, "path", case_sensitive);
+    if (!cJSON_IsString(path))
+    {
+        /* malformed patch. */
+        status = 2;
+        goto cleanup;
+    }
+
+    opcode = decode_patch_operation(patch, case_sensitive);
+    if (opcode == INVALID)
+    {
+        status = 3;
+        goto cleanup;
+    }
+    else if (opcode == TEST)
+    {
+        /* compare value: {...} with the given path */
+        status = !compare_json(get_item_from_pointer(object, path->valuestring, case_sensitive), get_object_item(patch, "value", case_sensitive), case_sensitive);
+        goto cleanup;
+    }
+
+    /* special case for replacing the root */
+    if (path->valuestring[0] == '\0')
+    {
+        if (opcode == REMOVE)
+        {
+            static const cJSON invalid = { NULL, NULL, NULL, cJSON_Invalid, NULL, 0, 0, NULL};
+
+            overwrite_item(object, invalid);
+
+            status = 0;
+            goto cleanup;
+        }
+
+        if ((opcode == REPLACE) || (opcode == ADD))
+        {
+            value = get_object_item(patch, "value", case_sensitive);
+            if (value == NULL)
+            {
+                /* missing "value" for add/replace. */
+                status = 7;
+                goto cleanup;
+            }
+
+            value = cJSON_Duplicate(value, 1);
+            if (value == NULL)
+            {
+                /* out of memory for add/replace. */
+                status = 8;
+                goto cleanup;
+            }
+
+            overwrite_item(object, *value);
+
+            /* delete the duplicated value */
+            cJSON_free(value);
+            value = NULL;
+
+            /* the string "value" isn't needed */
+            if (object->string != NULL)
+            {
+                cJSON_free(object->string);
+                object->string = NULL;
+            }
+
+            status = 0;
+            goto cleanup;
+        }
+    }
+
+    if ((opcode == REMOVE) || (opcode == REPLACE))
+    {
+        /* Get rid of old. */
+        cJSON *old_item = detach_path(object, (unsigned char*)path->valuestring, case_sensitive);
+        if (old_item == NULL)
+        {
+            status = 13;
+            goto cleanup;
+        }
+        cJSON_Delete(old_item);
+        if (opcode == REMOVE)
+        {
+            /* For Remove, this job is done. */
+            status = 0;
+            goto cleanup;
+        }
+    }
+
+    /* Copy/Move uses "from". */
+    if ((opcode == MOVE) || (opcode == COPY))
+    {
+        cJSON *from = get_object_item(patch, "from", case_sensitive);
+        if (from == NULL)
+        {
+            /* missing "from" for copy/move. */
+            status = 4;
+            goto cleanup;
+        }
+
+        if (opcode == MOVE)
+        {
+            value = detach_path(object, (unsigned char*)from->valuestring, case_sensitive);
+        }
+        if (opcode == COPY)
+        {
+            value = get_item_from_pointer(object, from->valuestring, case_sensitive);
+        }
+        if (value == NULL)
+        {
+            /* missing "from" for copy/move. */
+            status = 5;
+            goto cleanup;
+        }
+        if (opcode == COPY)
+        {
+            value = cJSON_Duplicate(value, 1);
+        }
+        if (value == NULL)
+        {
+            /* out of memory for copy/move. */
+            status = 6;
+            goto cleanup;
+        }
+    }
+    else /* Add/Replace uses "value". */
+    {
+        value = get_object_item(patch, "value", case_sensitive);
+        if (value == NULL)
+        {
+            /* missing "value" for add/replace. */
+            status = 7;
+            goto cleanup;
+        }
+        value = cJSON_Duplicate(value, 1);
+        if (value == NULL)
+        {
+            /* out of memory for add/replace. */
+            status = 8;
+            goto cleanup;
+        }
+    }
+
+    /* Now, just add "value" to "path". */
+
+    /* split pointer in parent and child */
+    parent_pointer = cJSONUtils_strdup((unsigned char*)path->valuestring);
+    child_pointer = (unsigned char*)strrchr((char*)parent_pointer, '/');
+    if (child_pointer != NULL)
+    {
+        child_pointer[0] = '\0';
+        child_pointer++;
+    }
+    parent = get_item_from_pointer(object, (char*)parent_pointer, case_sensitive);
+    decode_pointer_inplace(child_pointer);
+
+    /* add, remove, replace, move, copy, test. */
+    if ((parent == NULL) || (child_pointer == NULL))
+    {
+        /* Couldn't find object to add to. */
+        status = 9;
+        goto cleanup;
+    }
+    else if (cJSON_IsArray(parent))
+    {
+        if (strcmp((char*)child_pointer, "-") == 0)
+        {
+            cJSON_AddItemToArray(parent, value);
+            value = NULL;
+        }
+        else
+        {
+            size_t index = 0;
+            if (!decode_array_index_from_pointer(child_pointer, &index))
+            {
+                status = 11;
+                goto cleanup;
+            }
+
+            if (!insert_item_in_array(parent, index, value))
+            {
+                status = 10;
+                goto cleanup;
+            }
+            value = NULL;
+        }
+    }
+    else if (cJSON_IsObject(parent))
+    {
+        if (case_sensitive)
+        {
+            cJSON_DeleteItemFromObjectCaseSensitive(parent, (char*)child_pointer);
+        }
+        else
+        {
+            cJSON_DeleteItemFromObject(parent, (char*)child_pointer);
+        }
+        cJSON_AddItemToObject(parent, (char*)child_pointer, value);
+        value = NULL;
+    }
+
+cleanup:
+    if (value != NULL)
+    {
+        cJSON_Delete(value);
+    }
+    if (parent_pointer != NULL)
+    {
+        cJSON_free(parent_pointer);
+    }
+
+    return status;
+}
+
+CJSON_PUBLIC(int) cJSONUtils_ApplyPatches(cJSON * const object, const cJSON * const patches)
+{
+    const cJSON *current_patch = NULL;
+    int status = 0;
+
+    if (!cJSON_IsArray(patches))
+    {
+        /* malformed patches. */
+        return 1;
+    }
+
+    if (patches != NULL)
+    {
+        current_patch = patches->child;
+    }
+
+    while (current_patch != NULL)
+    {
+        status = apply_patch(object, current_patch, false);
+        if (status != 0)
+        {
+            return status;
+        }
+        current_patch = current_patch->next;
+    }
+
+    return 0;
+}
+
+CJSON_PUBLIC(int) cJSONUtils_ApplyPatchesCaseSensitive(cJSON * const object, const cJSON * const patches)
+{
+    const cJSON *current_patch = NULL;
+    int status = 0;
+
+    if (!cJSON_IsArray(patches))
+    {
+        /* malformed patches. */
+        return 1;
+    }
+
+    if (patches != NULL)
+    {
+        current_patch = patches->child;
+    }
+
+    while (current_patch != NULL)
+    {
+        status = apply_patch(object, current_patch, true);
+        if (status != 0)
+        {
+            return status;
+        }
+        current_patch = current_patch->next;
+    }
+
+    return 0;
+}
+
+static void compose_patch(cJSON * const patches, const unsigned char * const operation, const unsigned char * const path, const unsigned char *suffix, const cJSON * const value)
+{
+    cJSON *patch = NULL;
+
+    if ((patches == NULL) || (operation == NULL) || (path == NULL))
+    {
+        return;
+    }
+
+    patch = cJSON_CreateObject();
+    if (patch == NULL)
+    {
+        return;
+    }
+    cJSON_AddItemToObject(patch, "op", cJSON_CreateString((const char*)operation));
+
+    if (suffix == NULL)
+    {
+        cJSON_AddItemToObject(patch, "path", cJSON_CreateString((const char*)path));
+    }
+    else
+    {
+        size_t suffix_length = pointer_encoded_length(suffix);
+        size_t path_length = strlen((const char*)path);
+        unsigned char *full_path = (unsigned char*)cJSON_malloc(path_length + suffix_length + sizeof("/"));
+
+        sprintf((char*)full_path, "%s/", (const char*)path);
+        encode_string_as_pointer(full_path + path_length + 1, suffix);
+
+        cJSON_AddItemToObject(patch, "path", cJSON_CreateString((const char*)full_path));
+        cJSON_free(full_path);
+    }
+
+    if (value != NULL)
+    {
+        cJSON_AddItemToObject(patch, "value", cJSON_Duplicate(value, 1));
+    }
+    cJSON_AddItemToArray(patches, patch);
+}
+
+CJSON_PUBLIC(void) cJSONUtils_AddPatchToArray(cJSON * const array, const char * const operation, const char * const path, const cJSON * const value)
+{
+    compose_patch(array, (const unsigned char*)operation, (const unsigned char*)path, NULL, value);
+}
+
+static void create_patches(cJSON * const patches, const unsigned char * const path, cJSON * const from, cJSON * const to, const cJSON_bool case_sensitive)
+{
+    if ((from == NULL) || (to == NULL))
+    {
+        return;
+    }
+
+    if ((from->type & 0xFF) != (to->type & 0xFF))
+    {
+        compose_patch(patches, (const unsigned char*)"replace", path, 0, to);
+        return;
+    }
+
+    switch (from->type & 0xFF)
+    {
+        case cJSON_Number:
+            if ((from->valueint != to->valueint) || (from->valuedouble != to->valuedouble))
+            {
+                compose_patch(patches, (const unsigned char*)"replace", path, NULL, to);
+            }
+            return;
+
+        case cJSON_String:
+            if (strcmp(from->valuestring, to->valuestring) != 0)
+            {
+                compose_patch(patches, (const unsigned char*)"replace", path, NULL, to);
+            }
+            return;
+
+        case cJSON_Array:
+        {
+            size_t index = 0;
+            cJSON *from_child = from->child;
+            cJSON *to_child = to->child;
+            unsigned char *new_path = (unsigned char*)cJSON_malloc(strlen((const char*)path) + 20 + sizeof("/")); /* Allow space for 64bit int. log10(2^64) = 20 */
+
+            /* generate patches for all array elements that exist in both "from" and "to" */
+            for (index = 0; (from_child != NULL) && (to_child != NULL); (void)(from_child = from_child->next), (void)(to_child = to_child->next), index++)
+            {
+                /* check if conversion to unsigned long is valid
+                 * This should be eliminated at compile time by dead code elimination
+                 * if size_t is an alias of unsigned long, or if it is bigger */
+                if (index > ULONG_MAX)
+                {
+                    cJSON_free(new_path);
+                    return;
+                }
+                sprintf((char*)new_path, "%s/%lu", path, (unsigned long)index); /* path of the current array element */
+                create_patches(patches, new_path, from_child, to_child, case_sensitive);
+            }
+
+            /* remove leftover elements from 'from' that are not in 'to' */
+            for (; (from_child != NULL); (void)(from_child = from_child->next))
+            {
+                /* check if conversion to unsigned long is valid
+                 * This should be eliminated at compile time by dead code elimination
+                 * if size_t is an alias of unsigned long, or if it is bigger */
+                if (index > ULONG_MAX)
+                {
+                    cJSON_free(new_path);
+                    return;
+                }
+                sprintf((char*)new_path, "%lu", (unsigned long)index);
+                compose_patch(patches, (const unsigned char*)"remove", path, new_path, NULL);
+            }
+            /* add new elements in 'to' that were not in 'from' */
+            for (; (to_child != NULL); (void)(to_child = to_child->next), index++)
+            {
+                compose_patch(patches, (const unsigned char*)"add", path, (const unsigned char*)"-", to_child);
+            }
+            cJSON_free(new_path);
+            return;
+        }
+
+        case cJSON_Object:
+        {
+            cJSON *from_child = NULL;
+            cJSON *to_child = NULL;
+            sort_object(from, case_sensitive);
+            sort_object(to, case_sensitive);
+
+            from_child = from->child;
+            to_child = to->child;
+            /* for all object values in the object with more of them */
+            while ((from_child != NULL) || (to_child != NULL))
+            {
+                int diff;
+                if (from_child == NULL)
+                {
+                    diff = 1;
+                }
+                else if (to_child == NULL)
+                {
+                    diff = -1;
+                }
+                else
+                {
+                    diff = compare_strings((unsigned char*)from_child->string, (unsigned char*)to_child->string, case_sensitive);
+                }
+
+                if (diff == 0)
+                {
+                    /* both object keys are the same */
+                    size_t path_length = strlen((const char*)path);
+                    size_t from_child_name_length = pointer_encoded_length((unsigned char*)from_child->string);
+                    unsigned char *new_path = (unsigned char*)cJSON_malloc(path_length + from_child_name_length + sizeof("/"));
+
+                    sprintf((char*)new_path, "%s/", path);
+                    encode_string_as_pointer(new_path + path_length + 1, (unsigned char*)from_child->string);
+
+                    /* create a patch for the element */
+                    create_patches(patches, new_path, from_child, to_child, case_sensitive);
+                    cJSON_free(new_path);
+
+                    from_child = from_child->next;
+                    to_child = to_child->next;
+                }
+                else if (diff < 0)
+                {
+                    /* object element doesn't exist in 'to' --> remove it */
+                    compose_patch(patches, (const unsigned char*)"remove", path, (unsigned char*)from_child->string, NULL);
+
+                    from_child = from_child->next;
+                }
+                else
+                {
+                    /* object element doesn't exist in 'from' --> add it */
+                    compose_patch(patches, (const unsigned char*)"add", path, (unsigned char*)to_child->string, to_child);
+
+                    to_child = to_child->next;
+                }
+            }
+            return;
+        }
+
+        default:
+            break;
+    }
+}
+
+CJSON_PUBLIC(cJSON *) cJSONUtils_GeneratePatches(cJSON * const from, cJSON * const to)
+{
+    cJSON *patches = NULL;
+
+    if ((from == NULL) || (to == NULL))
+    {
+        return NULL;
+    }
+
+    patches = cJSON_CreateArray();
+    create_patches(patches, (const unsigned char*)"", from, to, false);
+
+    return patches;
+}
+
+CJSON_PUBLIC(cJSON *) cJSONUtils_GeneratePatchesCaseSensitive(cJSON * const from, cJSON * const to)
+{
+    cJSON *patches = NULL;
+
+    if ((from == NULL) || (to == NULL))
+    {
+        return NULL;
+    }
+
+    patches = cJSON_CreateArray();
+    create_patches(patches, (const unsigned char*)"", from, to, true);
+
+    return patches;
+}
+
+CJSON_PUBLIC(void) cJSONUtils_SortObject(cJSON * const object)
+{
+    sort_object(object, false);
+}
+
+CJSON_PUBLIC(void) cJSONUtils_SortObjectCaseSensitive(cJSON * const object)
+{
+    sort_object(object, true);
+}
+
+static cJSON *merge_patch(cJSON *target, const cJSON * const patch, const cJSON_bool case_sensitive)
+{
+    cJSON *patch_child = NULL;
+
+    if (!cJSON_IsObject(patch))
+    {
+        /* scalar value, array or NULL, just duplicate */
+        cJSON_Delete(target);
+        return cJSON_Duplicate(patch, 1);
+    }
+
+    if (!cJSON_IsObject(target))
+    {
+        cJSON_Delete(target);
+        target = cJSON_CreateObject();
+    }
+
+    patch_child = patch->child;
+    while (patch_child != NULL)
+    {
+        if (cJSON_IsNull(patch_child))
+        {
+            /* NULL is the indicator to remove a value, see RFC7396 */
+            if (case_sensitive)
+            {
+                cJSON_DeleteItemFromObjectCaseSensitive(target, patch_child->string);
+            }
+            else
+            {
+                cJSON_DeleteItemFromObject(target, patch_child->string);
+            }
+        }
+        else
+        {
+            cJSON *replace_me = NULL;
+            cJSON *replacement = NULL;
+
+            if (case_sensitive)
+            {
+                replace_me = cJSON_DetachItemFromObjectCaseSensitive(target, patch_child->string);
+            }
+            else
+            {
+                replace_me = cJSON_DetachItemFromObject(target, patch_child->string);
+            }
+
+            replacement = merge_patch(replace_me, patch_child, case_sensitive);
+            if (replacement == NULL)
+            {
+                return NULL;
+            }
+
+            cJSON_AddItemToObject(target, patch_child->string, replacement);
+        }
+        patch_child = patch_child->next;
+    }
+    return target;
+}
+
+CJSON_PUBLIC(cJSON *) cJSONUtils_MergePatch(cJSON *target, const cJSON * const patch)
+{
+    return merge_patch(target, patch, false);
+}
+
+CJSON_PUBLIC(cJSON *) cJSONUtils_MergePatchCaseSensitive(cJSON *target, const cJSON * const patch)
+{
+    return merge_patch(target, patch, true);
+}
+
+static cJSON *generate_merge_patch(cJSON * const from, cJSON * const to, const cJSON_bool case_sensitive)
+{
+    cJSON *from_child = NULL;
+    cJSON *to_child = NULL;
+    cJSON *patch = NULL;
+    if (to == NULL)
+    {
+        /* patch to delete everything */
+        return cJSON_CreateNull();
+    }
+    if (!cJSON_IsObject(to) || !cJSON_IsObject(from))
+    {
+        return cJSON_Duplicate(to, 1);
+    }
+
+    sort_object(from, case_sensitive);
+    sort_object(to, case_sensitive);
+
+    from_child = from->child;
+    to_child = to->child;
+    patch = cJSON_CreateObject();
+    while (from_child || to_child)
+    {
+        int diff;
+        if (from_child != NULL)
+        {
+            if (to_child != NULL)
+            {
+                diff = strcmp(from_child->string, to_child->string);
+            }
+            else
+            {
+                diff = -1;
+            }
+        }
+        else
+        {
+            diff = 1;
+        }
+
+        if (diff < 0)
+        {
+            /* from has a value that to doesn't have -> remove */
+            cJSON_AddItemToObject(patch, from_child->string, cJSON_CreateNull());
+
+            from_child = from_child->next;
+        }
+        else if (diff > 0)
+        {
+            /* to has a value that from doesn't have -> add to patch */
+            cJSON_AddItemToObject(patch, to_child->string, cJSON_Duplicate(to_child, 1));
+
+            to_child = to_child->next;
+        }
+        else
+        {
+            /* object key exists in both objects */
+            if (!compare_json(from_child, to_child, case_sensitive))
+            {
+                /* not identical --> generate a patch */
+                cJSON_AddItemToObject(patch, to_child->string, cJSONUtils_GenerateMergePatch(from_child, to_child));
+            }
+
+            /* next key in the object */
+            from_child = from_child->next;
+            to_child = to_child->next;
+        }
+    }
+    if (patch->child == NULL)
+    {
+        /* no patch generated */
+        cJSON_Delete(patch);
+        return NULL;
+    }
+
+    return patch;
+}
+
+CJSON_PUBLIC(cJSON *) cJSONUtils_GenerateMergePatch(cJSON * const from, cJSON * const to)
+{
+    return generate_merge_patch(from, to, false);
+}
+
+CJSON_PUBLIC(cJSON *) cJSONUtils_GenerateMergePatchCaseSensitive(cJSON * const from, cJSON * const to)
+{
+    return generate_merge_patch(from, to, true);
+}

factory_test_src/src/cJSON_Utils.h

+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#include "cJSON.h"
+
+/* Implement RFC6901 (https://tools.ietf.org/html/rfc6901) JSON Pointer spec. */
+CJSON_PUBLIC(cJSON *) cJSONUtils_GetPointer(cJSON * const object, const char *pointer);
+CJSON_PUBLIC(cJSON *) cJSONUtils_GetPointerCaseSensitive(cJSON * const object, const char *pointer);
+
+/* Implement RFC6902 (https://tools.ietf.org/html/rfc6902) JSON Patch spec. */
+/* NOTE: This modifies objects in 'from' and 'to' by sorting the elements by their key */
+CJSON_PUBLIC(cJSON *) cJSONUtils_GeneratePatches(cJSON * const from, cJSON * const to);
+CJSON_PUBLIC(cJSON *) cJSONUtils_GeneratePatchesCaseSensitive(cJSON * const from, cJSON * const to);
+/* Utility for generating patch array entries. */
+CJSON_PUBLIC(void) cJSONUtils_AddPatchToArray(cJSON * const array, const char * const operation, const char * const path, const cJSON * const value);
+/* Returns 0 for success. */
+CJSON_PUBLIC(int) cJSONUtils_ApplyPatches(cJSON * const object, const cJSON * const patches);
+CJSON_PUBLIC(int) cJSONUtils_ApplyPatchesCaseSensitive(cJSON * const object, const cJSON * const patches);
+
+/*
+// Note that ApplyPatches is NOT atomic on failure. To implement an atomic ApplyPatches, use:
+//int cJSONUtils_AtomicApplyPatches(cJSON **object, cJSON *patches)
+//{
+//    cJSON *modme = cJSON_Duplicate(*object, 1);
+//    int error = cJSONUtils_ApplyPatches(modme, patches);
+//    if (!error)
+//    {
+//        cJSON_Delete(*object);
+//        *object = modme;
+//    }
+//    else
+//    {
+//        cJSON_Delete(modme);
+//    }
+//
+//    return error;
+//}
+// Code not added to library since this strategy is a LOT slower.
+*/
+
+/* Implement RFC7386 (https://tools.ietf.org/html/rfc7396) JSON Merge Patch spec. */
+/* target will be modified by patch. return value is new ptr for target. */
+CJSON_PUBLIC(cJSON *) cJSONUtils_MergePatch(cJSON *target, const cJSON * const patch);
+CJSON_PUBLIC(cJSON *) cJSONUtils_MergePatchCaseSensitive(cJSON *target, const cJSON * const patch);
+/* generates a patch to move from -> to */
+/* NOTE: This modifies objects in 'from' and 'to' by sorting the elements by their key */
+CJSON_PUBLIC(cJSON *) cJSONUtils_GenerateMergePatch(cJSON * const from, cJSON * const to);
+CJSON_PUBLIC(cJSON *) cJSONUtils_GenerateMergePatchCaseSensitive(cJSON * const from, cJSON * const to);
+
+/* Given a root object and a target object, construct a pointer from one to the other. */
+CJSON_PUBLIC(char *) cJSONUtils_FindPointerFromObjectTo(const cJSON * const object, const cJSON * const target);
+
+/* Sorts the members of the object into alphabetical order. */
+CJSON_PUBLIC(void) cJSONUtils_SortObject(cJSON * const object);
+CJSON_PUBLIC(void) cJSONUtils_SortObjectCaseSensitive(cJSON * const object);

factory_test_src/src/iot.mk

+LIBA_TARGET 		:= libiot_factory.a
+
+$(call Append_Conditional, LIB_SRCS_EXCLUDE, main.c)
+$(call Append_Conditional, SRCS_product_test, main.c)
+$(call Append_Conditional, TARGET, product_test)
+

factory_test_src/src/main.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <time.h>
+#include <signal.h>
+#include <errno.h>
+#include <net/if.h>
+#include <netdb.h>
+#include <syslog.h>
+#include <arpa/inet.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h> 
+#include <pthread.h>
+#include <ctype.h>
+#include <execinfo.h>
+
+#include "oled_dp.h"
+#include "cJSON.h"
+
+#include "main.h"
+#include "Serial.h"
+#include "uart_proto.h"
+
+
+
+oled_config_t g_oled_config;
+
+
+
+uint8_t qr_change = 1;
+
+int delay_cnt = 0;
+
+uint8_t qr_img[128][128] = {0};
+uint8_t oled_img[1024] = {0};
+
+char cfg_file_name[80] = "/etc/dropbear/accessory/hj_db/oled.config";
+char ko_file_name[80] = "ssd1306-revision.ko";
+
+pthread_t key_thread;
+pthread_attr_t key_attr;
+
+pthread_t test_dp_thread;
+pthread_attr_t test_dp_attr;
+
+pthread_t oled_dp_thread;
+pthread_attr_t oled_dp_attr;
+
+pthread_t udp_recv_thread;
+pthread_attr_t udp_recv_attr;
+
+pthread_mutex_t data_mutex;
+
+pthread_t uart_recv_thread;
+pthread_attr_t uart_recv_attr;
+
+uint32_t run_level_1 = 3600;
+
+uint32_t run_time = 0;  //秒
+
+#define RUN_FLAG_WIFI_SUB_BOARD  "subboard"  // wifi单板测试
+#define RUN_FLAG_AGING  "aging"  // 老化
+#define RUN_FLAG_TEST  "test"  // 整机产测
+#define RUN_FLAG_OK  "success"  // 测试成功
+
+char run_flag[10] = "aging";
+
+char run_flag_file_name[30] = "/product/run_flag";
+
+int key_pressed = 0;
+
+int is_mac_burn();
+
+
+static void load_cfg_str_from_file(char *cfg_file_name, char *str)
+{
+    char *temp_str = NULL;
+    char line_buf[512] = {0};
+
+    FILE *fp = fopen(cfg_file_name, "r");
+    
+    if (fp == NULL)
+    {
+        OLED_LOG_DBG("Unable to open file: %s\n", cfg_file_name);
+        OLED_LOG_DBG("Use default cfg\r\n");
+        strcpy(str, "aging");
+        return;
+    }
+
+    if (str == NULL)
+    {
+        OLED_LOG_DBG("string is null\r\n");
+        return;
+    }
+
+    temp_str = str;
+
+    while (!feof(fp))
+    {
+        int read_cnt = 0;
+
+        memset(line_buf, 0, sizeof(line_buf));
+
+        read_cnt = fread(line_buf, 1, sizeof(line_buf), fp);
+
+        OLED_LOG_DBG("read_cnt %d \r\n", read_cnt);
+
+        if (read_cnt > 0)
+        {
+            memcpy(temp_str, line_buf, read_cnt);
+            temp_str += read_cnt;
+        }
+        else
+        {
+            break;
+        }
+    }
+    
+    fclose(fp);
+    return;
+}
+
+static void load_ccu_from_file(char *cfg_file_name, char *str)
+{
+    char *temp_str = NULL;
+    char line_buf[512] = {0};
+
+    FILE *fp = fopen(cfg_file_name, "r");
+    
+    if (fp == NULL)
+    {
+        OLED_LOG_DBG("Unable to open file: %s\n", cfg_file_name);
+        OLED_LOG_DBG("Use default cfg\r\n");
+        strcpy(str, "*");
+        return;
+    }
+
+    if (str == NULL)
+    {
+        OLED_LOG_DBG("string is null\r\n");
+        return;
+    }
+
+    temp_str = str;
+
+    while (!feof(fp))
+    {
+        int read_cnt = 0;
+
+        memset(line_buf, 0, sizeof(line_buf));
+
+        read_cnt = fread(line_buf, 1, sizeof(line_buf), fp);
+
+        OLED_LOG_DBG("read_cnt %d \r\n", read_cnt);
+
+        if (read_cnt > 0)
+        {
+            memcpy(temp_str, line_buf, read_cnt);
+            temp_str += read_cnt;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    str[5] = '\0';
+    fclose(fp);
+    return;
+}
+
+ void load_sn_from_file(char *cfg_file_name, char *str)
+{
+    char *temp_str = NULL;
+    char line_buf[512] = {0};
+
+    FILE *fp = fopen(cfg_file_name, "r");
+    
+    if (fp == NULL)
+    {
+        OLED_LOG_DBG("Unable to open file: %s\n", cfg_file_name);
+        return;
+    }
+
+    if (str == NULL)
+    {
+        OLED_LOG_DBG("string is null\r\n");
+        return;
+    }
+
+    temp_str = str;
+
+    while (!feof(fp))
+    {
+        int read_cnt = 0;
+
+        memset(line_buf, 0, sizeof(line_buf));
+
+        read_cnt = fread(line_buf, 1, sizeof(line_buf), fp);
+
+        OLED_LOG_DBG("read_cnt %d \r\n", read_cnt);
+
+        if (read_cnt > 0)
+        {
+            memcpy(temp_str, line_buf, read_cnt);
+            temp_str += read_cnt;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    //str[temp_str] = '\0';
+    fclose(fp);
+    return;
+}
+
+
+
+
+static void load_version_from_file(char *cfg_file_name, char *str,char * whole_ver)
+{
+    char *temp_str = NULL;
+    char line_buf[512] = {0};
+    int count = 0;
+
+
+    if (str == NULL)
+    {
+        OLED_LOG_DBG("string is null\r\n");
+        return;
+    }
+	
+
+    FILE *fp = fopen(cfg_file_name, "r");
+    
+    if (fp == NULL)
+    {
+        OLED_LOG_DBG("Unable to open file: %s\n", cfg_file_name);
+        OLED_LOG_DBG("Use default version\r\n");
+	  
+        strcpy(str, "*");
+        return;
+    }
+
+   
+
+    temp_str = line_buf;
+    count = sizeof(line_buf);
+
+    while (!feof(fp))
+    {
+        int read_cnt = 0;
+
+        memset(line_buf, 0, sizeof(line_buf));
+
+        read_cnt = fread(temp_str, 1, count, fp);
+
+        OLED_LOG_DBG("read_cnt %d \r\n", read_cnt);
+
+        if (read_cnt > 0)
+        {
+
+	     
+            //memcpy(temp_str, line_buf, read_cnt);
+            temp_str += read_cnt;
+			count -= read_cnt;
+	}
+        else
+        {
+            break;
+        }
+    }
+
+
+	 if((strstr(line_buf,"SW_VER") != NULL ) && (strstr(line_buf," ") != NULL) )
+	 {
+		 memcpy(str,strstr(line_buf,"SW_VER")+6,strstr(line_buf," ")-strstr(line_buf,"SW_VER")-6);
+         memcpy(whole_ver,line_buf,strstr(line_buf," ")-line_buf);
+     }
+	
+	 
+    fclose(fp);
+    return;
+}
+
+void save_cfg_str_to_file(const char *cfg_file_name, char *str)
+{
+    FILE *file_fd = NULL;
+
+    file_fd = fopen(cfg_file_name, "w+");
+
+    if (NULL == file_fd)
+    {
+        OLED_LOG_DBG("config %s open error\n", cfg_file_name);
+        return;
+    }
+
+    fwrite(str, 1, strlen(str), file_fd);
+
+    fflush(file_fd);
+    fclose(file_fd);
+}
+
+struct thread_recdata
+{
+    int sockfd;
+    char *info;
+};
+
+int udp_sock_test_init(void)
+{
+    int sock_fd;
+
+    struct sockaddr_in server_addr;
+
+    /* Create Socket*/
+    if ((sock_fd = socket(AF_INET, SOCK_DGRAM,0)) < 0)
+    {
+         OLED_LOG_DBG("Failed to create socket\r\n");
+        return -1;
+    }
+
+    memset(&server_addr,0,sizeof(struct sockaddr_in));
+    
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_port = htons(SERV_PORT);
+    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+    if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in)) < 0)
+    {
+        OLED_LOG_DBG("Failed to bind test socket on port %d\n", SERV_PORT);
+        close(sock_fd);
+        return -2;
+    }
+	
+    return sock_fd;
+}
+
+
+void *udp_test_handle(void *rec_data)
+{
+	struct sockaddr_in client_addr;
+	socklen_t client_len = sizeof(client_addr);
+	char rcv_buff[100];
+	int rcv_num = -1;
+	int send_len = 0;
+	struct thread_recdata *thread_test_info;
+	thread_test_info = (struct thread_recdata *)rec_data;
+	
+	memset(&client_addr, 0, sizeof(client_addr));
+
+	while(1)
+	{
+		rcv_num= recvfrom(thread_test_info->sockfd, rcv_buff, sizeof(rcv_buff), 0, (struct sockaddr*)&client_addr, &client_len);
+
+		if (rcv_num>0)
+	       {
+	             rcv_buff[rcv_num] = '\0';
+	             OLED_LOG_DBG("%s %u says: %s\n",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port),rcv_buff);
+
+			if(!strncmp(rcv_buff,"failed",6))
+			{
+				rcv_buff[6]= '_';
+				rcv_buff[7]= 'a';
+				rcv_buff[8]= 'c';
+				rcv_buff[9]= 'k';
+
+				send_len = 10;
+			}
+			else if(!strncmp(rcv_buff,"success",7))
+			{
+				rcv_buff[7]= '_';
+				rcv_buff[8]= 'a';
+				rcv_buff[9]= 'c';
+				rcv_buff[10]= 'k';
+
+				send_len = 11;
+
+				//save_cfg_str_to_file(run_flag_file_name, run_flag);
+                save_cfg_str_to_file(run_flag_file_name, "success");
+			}
+			else
+			{
+				send_len = sizeof(rcv_buff);
+			}
+
+		      sendto(thread_test_info->sockfd,rcv_buff,send_len,0,(struct sockaddr*)&client_addr,sizeof(client_addr)) ;  
+
+		      if(!strncmp(rcv_buff,"success",7)) //如果整机测试成功
+		      {
+		    	     strcpy(run_flag ,"success\n"); 
+                     
+
+			        OLED_LOG_DBG("test_ok,will reset after 10s\r\n");
+		      }
+		    }
+	       else
+	       {
+		      OLED_LOG_DBG("recv error\n");
+	       }
+    	}
+}
+
+int oled_dp_run_state(void)
+{
+	char str[32] = {0};
+
+   // if (g_oled_config.ccu_show_qr)
+    {
+       // int delay_cnt = 0;
+       delay_cnt = 0;
+        qr_change = 1;
+
+        while (delay_cnt ++ < 5)   //5s
+        {
+            if (qr_change == 1)
+            {
+                clear_screen(); 
+                
+                pthread_mutex_lock(&data_mutex);
+                {
+                    qr_change = 0;
+
+                    if(!strncmp(run_flag,RUN_FLAG_AGING,5))
+                    {
+                        show_chn_set(45, 1, 14, 12); //老
+                        show_chn_set(57, 1, 15, 12); //化
+                        show_chn_set(69, 1, 16, 12); //中
+                    }
+                    else if(!strncmp(run_flag,RUN_FLAG_WIFI_SUB_BOARD,8))
+                    {
+                        show_chn_set(30, 1, 20, 12); //单
+                        show_chn_set(42, 1, 21, 12); //板
+                        show_chn_set(54, 1, 18, 12); //产
+                        show_chn_set(66, 1, 19, 12); //测
+                        show_chn_set(78, 1, 16, 12); //中
+                    }
+                    else if(!strncmp(run_flag,RUN_FLAG_TEST,4))
+                    {
+                        show_chn_set(30, 1, 17, 12); //整
+                        show_chn_set(42, 1, 13, 12); //机
+                        show_chn_set(54, 1, 18, 12); //产
+                        show_chn_set(66, 1, 19, 12); //测
+                        show_chn_set(78, 1, 16, 12); //中
+                    }
+			
+                    sprintf(str, "%02d%c%02d", run_time/3600 , ':' , (run_time%3600)/60);
+					
+                	show_str_set(str, 45, 5, show_8x16_mode);
+                }
+                pthread_mutex_unlock(&data_mutex);
+            }
+
+            for (int c = 0; c < 10; c ++)   //  1s
+            {
+                usleep(100000);   // 100ms
+            }
+
+            run_time ++;
+
+		
+        }
+    }
+
+    return 0;
+}
+
+int oled_dp_info(void)
+{
+    char str[32] = {0};
+    char ip[32] = "0.0.0.0";
+
+    #if 1
+    {
+        int sd;
+        struct sockaddr_in sin;
+        struct ifreq ifr;
+
+        sd = socket(AF_INET, SOCK_DGRAM, 0);
+
+        if (-1 == sd)
+        {
+            OLED_LOG_DBG("socket error: %s\n", strerror(errno));
+        }
+        else
+        {
+            strncpy(ifr.ifr_name, g_oled_config.ccu_lan, IFNAMSIZ);
+            
+            ifr.ifr_name[IFNAMSIZ - 1] = 0;
+
+            if (ioctl(sd, SIOCGIFADDR, &ifr) < 0)
+            {
+                OLED_LOG_DBG("ioctl error: %s\n", strerror(errno));
+                snprintf(ip, IP_SIZE, "0.0.0.0");
+            }
+            else
+            {
+                memcpy(&sin, &ifr.ifr_addr, sizeof(sin));
+                snprintf(ip, IP_SIZE, "%s", inet_ntoa(sin.sin_addr));
+            }
+
+            close(sd);
+        }
+    }
+    #endif
+
+    time_t now;
+    struct tm *timenow;
+
+    {
+        time(&now);
+        timenow = localtime(&now);
+    }
+    
+  //  int i = 0;
+    delay_cnt = 0;
+
+    int hour = timenow->tm_hour;
+    int min = timenow->tm_min;
+
+    qr_change = 1;
+
+    while (delay_cnt ++ < 5)  //5s
+    {
+        if (qr_change == 1)
+        {
+            pthread_mutex_lock(&data_mutex);
+            
+            {
+                qr_change = 0;
+
+                clear_screen();
+
+                sprintf(str, "%s", ip);
+                show_str_set(str, 0, 0, show_6x8_mode);  //IP显示
+
+                #if defined (AR9331)
+                {
+                    show_str_set("3", 120, 0, show_6x8_mode); 
+                }
+                #elif defined (AR9533)
+                {
+                    show_chn_set(104, 0, 12, 12);
+                    show_chn_set(116, 0, 13, 12);
+                }
+                #endif
+
+				/* 日期显示 */
+                sprintf(str, "%d-%d-%d", timenow->tm_year + 1900, timenow->tm_mon + 1, timenow->tm_mday);
+                show_str_set(str, 35, 2, show_6x8_mode);
+
+				/* 时间显示 */
+                sprintf(str, "%02d%c%02d", timenow->tm_hour, timenow->tm_sec % 2 == 1 ? ':' : ' ', timenow->tm_min);
+                show_str_set(str, 45, 3, show_8x16_mode);
+
+				/* CCUID显示 */
+
+		   memset(g_oled_config.ccu_id,0,sizeof(g_oled_config.ccu_id));
+		   load_ccu_from_file(CCUID_CFG_FILE,g_oled_config.ccu_id);
+				
+                sprintf(str, "%s(%s)", g_oled_config.ccu_id, g_oled_config.ccu_version);
+                show_str_set(str, 0, 7, show_6x8_mode);
+
+				/* 主机状态显示 */
+                if (g_oled_config.ccu_status == 0)     //正常
+                {
+                   // show_chn_set(104, 6, 4, 12);
+                   // show_chn_set(116, 6, 5, 12);
+
+		     show_chn_set(104, 6, 18, 12); //产
+		     show_chn_set(116, 6, 19, 12); //测
+                }
+                else if (g_oled_config.ccu_status == 1) //
+                {
+                    show_chn_set(104, 6, 8, 12);
+                    show_chn_set(116, 6, 9, 12);
+                }
+                else if (g_oled_config.ccu_status == 2) 
+                {
+                    show_chn_set(104, 6, 10, 12);
+                    show_chn_set(116, 6, 11, 12);
+                }
+                else
+                {
+                    sprintf(str, "E%02d", g_oled_config.ccu_status);
+                    show_str_set(str, 92, 7, show_6x8_mode);
+                }
+            }
+
+            pthread_mutex_unlock(&data_mutex);
+        }
+
+        {
+            time(&now);
+            timenow = localtime(&now);
+        }
+
+        if (hour != timenow->tm_hour || min != timenow->tm_min)
+        {
+            hour = timenow->tm_hour;
+            min = timenow->tm_min;
+
+            sprintf(str, "%02d%c%02d", timenow->tm_hour, timenow->tm_sec % 2 == 1 ? ':' : ' ', timenow->tm_min);
+            show_str_set(str, 45, 3, show_8x16_mode);
+        }
+        else
+        {
+            char str_ch[8] = {0};
+            sprintf(str_ch, "%c", timenow->tm_sec % 2 == 1 ? ':' : ' ');
+            show_str_set(str_ch, 45 + 8 * 2, 3, show_8x16_mode);
+        }
+        
+        //每次显示延时10s
+        for (int c = 0; c < 10; c ++)
+        {
+            usleep(100000);
+        }
+
+        run_time ++;
+    }
+
+    return 0;
+}
+
+void *oled_dp(void *parameter)
+{
+    int ops_start_gw_flag = 0;
+    int ops_reset_firmware__flag = 0;
+   // wakeup_screen();
+    clear_screen();
+
+    while (1)
+    {
+        int ret = is_mac_burn();
+        if(ret == 1)
+		{
+			if (!strncmp(run_flag,RUN_FLAG_WIFI_SUB_BOARD,8)) //wifi单板测试
+            {
+                oled_dp_run_state();
+                oled_dp_info();
+
+                //另外的线程处理串口数据
+            }
+            else if (!strncmp(run_flag,RUN_FLAG_AGING,5)) //老化
+            {
+                oled_dp_run_state();
+                oled_dp_info();
+
+                if(run_time >= 14400)  // 单位秒，4个小时
+                {
+                    OLED_LOG_DBG("aging_ok,wait for test\r\n");
+                    
+                    strcpy(run_flag ,RUN_FLAG_TEST);
+
+                    save_cfg_str_to_file(run_flag_file_name, run_flag);
+                    OLED_LOG_DBG("test string to file ok\n");
+
+                    run_time = 0;
+                }
+            }
+			else if(!strncmp(run_flag,RUN_FLAG_TEST,4)) //整机产测
+			{
+				if(ops_start_gw_flag == 0)
+				{
+					ops_start_gw_flag = 1;
+						
+					//进入整机之前获取ccuid
+					system("export LD_LIBRARY_PATH=/home/hj/smarthome/lib");
+
+	                system("/sbin/hj_auth_ccuid.sh &");
+
+					system("/product/SmartGateway.AR9533 -f TEST -h 2 &");   //  入墙主机参数是-h  1，桌面主机是-h 2
+
+					OLED_LOG_DBG("running---SmartGateway.ar9531\r\n");
+
+				}
+
+				oled_dp_run_state();
+				oled_dp_info();
+			}
+			else if(!strncmp(run_flag,RUN_FLAG_OK,7))
+			{
+				oled_dp_info();
+			
+				if(ops_reset_firmware__flag == 0)
+				{
+					ops_reset_firmware__flag = 1;
+
+					save_cfg_str_to_file(run_flag_file_name, run_flag);
+
+					OLED_LOG_DBG("exe---firstboot -y && reboot\r\n");
+
+					system("firstboot -y && reboot -f");//恢复出厂设置
+				}
+			}
+		}
+		else if(ret == 0)
+		{
+			
+			 clear_screen();
+			 //show_str_set("mac no burn", 25, 3, show_8x16_mode); 
+             show_str_set("MAC ", 25, 3, show_8x16_mode); 
+	         show_chn_set(54, 3, 22, 16); //未
+			 show_chn_set(74, 3, 23, 16); //烧
+			 show_chn_set(94, 3, 24, 16); //录
+			 sleep(10);
+			 oled_dp_info();
+			
+		}
+        else 
+        {
+             clear_screen();
+			 show_str_set("checking mac...", 25, 3, show_8x16_mode); 
+			 sleep(10);
+			 oled_dp_info();
+        }
+	       
+    }
+}
+
+void *uart_recv_deamon(void *parameter)
+{
+
+
+    fd_set rd;
+    int nFlag;
+    struct timeval tval = {2,0};
+
+    int count = 0;
+    unsigned char data_buf[512];
+    teSerial_Status ret = E_SERIAL_ERROR;
+    eSerial_start();
+
+    while (1)
+    {
+        //判断是否在单板产测状态
+        if(!strncmp(run_flag,RUN_FLAG_WIFI_SUB_BOARD,8))
+        {     
+            FD_ZERO(&rd);
+            FD_SET(serial_fd,&rd);
+
+            nFlag = select(serial_fd + 1, &rd, NULL, NULL, &tval);
+
+            if(0 > nFlag)
+            {
+                OLED_LOG_DBG("uartRecv():select error !\n");
+                OLED_LOG_DBG("uartRecv errno = %d", errno);
+                usleep( 100000 );
+            }
+            else if(0 == nFlag)
+            {
+                //OLED_LOG_DBG( "----------------uartRecv():select time out !------------------\n"); 
+        
+                usleep( 100000 );
+            }
+            else
+            {
+                
+                if(FD_ISSET(serial_fd, &rd))
+                {
+                    ret = eSerial_Read(&data_buf[count]);
+
+                    if(ret == E_SERIAL_OK)
+                    {
+                        if(get_uart_frame((uint8_t *)data_buf,1))
+                        {
+                            uart_frame_handle();
+                        }
+                    }
+                    else if(ret == E_SERIAL_FD_ERROR)
+                    {
+                        eSerial_start();
+                    }
+                }
+            }
+            
+        }
+        else
+        {
+             eSerial_stop();
+             if(!strncmp(run_flag,RUN_FLAG_AGING,5))  //老化状态提供cpu使用率
+             {
+                    int i = 0;
+                    while(1)
+                    {
+                        //usleep(1);
+                        i++;
+                        i = i%40000;
+                        if(i > 0 && i< 10)
+                        {
+                            usleep(1);
+                        }
+                        if(strncmp(run_flag,RUN_FLAG_AGING,5) != 0) 
+                        {
+                            break;
+                        }
+
+                    }
+             }
+        }
+    }
+}
+
+int key_file_fd = -1;
+
+void key_init(int gpio_num)
+{
+    char str[120] = {0};
+    int re = 0;
+
+    memset(str, 0, sizeof(str));
+    snprintf(str, sizeof(str), "/sys/class/gpio/gpio%d", gpio_num);
+
+    if ((access(str, F_OK)) == -1)
+    {
+        snprintf(str, sizeof(str), "echo %d > /sys/class/gpio/export", gpio_num);
+        re = system(str);
+
+        if (re != 0)
+        {
+            return;
+        }
+    }
+
+    snprintf(str, sizeof(str), "echo in > /sys/class/gpio/gpio%d/direction", gpio_num);
+    re = system(str);
+
+    if (re != 0)
+    {
+        return;
+    }
+}
+
+void key_file_init(int gpio_num)
+{
+    char file_str[80] = {0};
+
+    snprintf(file_str, sizeof(file_str), "/sys/class/gpio/gpio%d/value", gpio_num);
+
+    key_file_fd = open(file_str, O_RDONLY);
+    
+    if (key_file_fd == -1)
+    {
+        OLED_LOG_DBG("Unable to open file: %s\n", file_str);
+        return;
+    }
+
+    return;
+}
+
+int key_read(void)
+{
+    int ret = -1;
+    char line_buf[80] = {0};
+
+    if (key_file_fd < 0)
+    {
+        return ret;
+    }
+
+    memset(line_buf, 0, sizeof(line_buf));
+
+    if (lseek(key_file_fd, 0, SEEK_SET) < 0)
+    {
+        return ret;
+    }
+
+    if (read(key_file_fd, line_buf, sizeof(line_buf)) < 0)
+    {
+        return ret;
+    }
+
+    if (strlen(line_buf) > 0)
+    {
+        ret = atoi(line_buf);
+    }
+
+    return ret;
+}
+
+int key_file_read(int gpio_num)
+{
+    int ret = -1;
+    char file_str[80] = {0};
+    char line_buf[80] = {0};
+    FILE *fp = NULL;
+
+    snprintf(file_str, sizeof(file_str), "/sys/class/gpio/gpio%d/value", gpio_num);
+
+    fp = fopen(file_str, "r");
+    
+    if (fp == NULL)
+    {
+        OLED_LOG_DBG("Unable to open file: %s\n", file_str);
+        return ret;
+    }
+
+    memset(line_buf, 0, sizeof(line_buf));
+    fgets(line_buf, sizeof(line_buf), fp);
+
+    if (strlen(line_buf) > 0)
+    {
+        ret = atoi(line_buf);
+    }
+    
+    fclose(fp);
+    return ret;
+}
+
+uint8_t get_mac(char *mac_name, char *mac_str, int len)
+{
+    #if 0
+    int fd;
+    int interface;
+    struct ifreq buf[16];
+    struct ifconf ifc;
+
+    char mac[32] = {0};
+
+    if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) >= 0)
+    {
+        int i = 0;
+
+        ifc.ifc_len = sizeof(buf);
+        ifc.ifc_buf = (caddr_t)buf;
+
+        if (!ioctl(fd, SIOCGIFCONF, (char *)&ifc))
+        {
+            interface = ifc.ifc_len / sizeof(struct ifreq);
+
+            while (i < interface)
+            {
+           
+                if (strncmp(mac_name, buf[i].ifr_name, strlen(buf[i].ifr_name)) == 0)
+                {
+                    if (!(ioctl(fd, SIOCGIFHWADDR, (char *)&buf[i])))
+                    {
+                        sprintf(mac, "%02X:%02X:%02X:%02X:%02X:%02X",
+                            (unsigned char)buf[i].ifr_hwaddr.sa_data[0],
+                            (unsigned char)buf[i].ifr_hwaddr.sa_data[1],
+                            (unsigned char)buf[i].ifr_hwaddr.sa_data[2],
+                            (unsigned char)buf[i].ifr_hwaddr.sa_data[3],
+                            (unsigned char)buf[i].ifr_hwaddr.sa_data[4],
+                            (unsigned char)buf[i].ifr_hwaddr.sa_data[5]);
+                    }
+                    snprintf(mac_str, len, "%s", mac);
+			close(fd);
+                    return 1;
+                }
+                i ++;
+            }
+        }
+
+	close(fd);
+    }
+
+    return 0;
+    #endif
+
+    char *temp_str = NULL;
+    char line_buf[512] = {0};
+    FILE *fp = NULL;
+
+    if(mac_name == NULL || mac_str == NULL){
+        OLED_LOG_DBG(" ARG ERROR \n");
+        return 0;
+    }
+
+    if(strcmp(ETH1_MAC_NAME,mac_name) == 0){
+            fp = fopen(ETH1_ADDRESS_FILE_PATH, "r");
+    }
+    else if(strcmp(ETH0_MAC_NAME,mac_name) == 0){
+            fp = fopen(ETH0_ADDRESS_FILE_PATH, "r");
+    }
+    
+    if (fp == NULL)
+    {
+        OLED_LOG_DBG("Unable to open file: %s\n", cfg_file_name);
+        strcpy(mac_str, "*");
+        return 0;
+    }
+
+    temp_str = mac_str;
+
+    while (!feof(fp))
+    {
+        int read_cnt = 0;
+
+        memset(line_buf, 0, sizeof(line_buf));
+
+        read_cnt = fread(line_buf, 1, sizeof(line_buf), fp);
+
+        OLED_LOG_DBG("read_cnt %d \r\n", read_cnt);
+
+        if (read_cnt > 0)
+        {
+            memcpy(temp_str, line_buf, read_cnt);
+            temp_str += read_cnt;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    fclose(fp);
+
+    //转换为大写
+    int i = 0;
+    for(i=0;i<strlen(mac_str);i++)
+		mac_str[i]=toupper(mac_str[i]);
+
+    return 1;
+}
+
+ int is_mac_burn()
+ {
+	char eth1_mac[32] = "";
+
+	 if (get_mac(ETH1_MAC_NAME, eth1_mac, sizeof(eth1_mac)) == 0)
+    {
+        OLED_LOG_DBG("eth1 error\n");
+        return -1;
+    }
+
+	OLED_LOG_DBG("eth1:%s\n",eth1_mac);
+
+    //开头的几位对，且不等于默认mac
+	if(strncmp(eth1_mac,"28:D9:8A:",9) == 0 && strncmp(eth1_mac,"28:D9:8A:0B:FF:FF",17) != 0)
+	{
+		return 1;
+	}
+
+	return 0;
+
+ }
+
+void *key_process(void *parameter)
+{
+    
+    key_init(12);
+    key_file_init(12);    
+   
+
+    while (1)
+    {
+
+        usleep(10000);
+
+        if (key_read() == 0)
+        {
+            if (key_pressed == 0)
+            {
+                OLED_LOG_DBG("Key pressed\r\n");
+            }
+
+            key_pressed += 10;
+        }
+        else
+        {
+            if (key_pressed > 0)
+            {
+
+
+                OLED_LOG_DBG("Key released\r\n");
+			delay_cnt  = 10;
+				
+                key_pressed = 0;
+            }
+        }
+    }
+}
+
+
+#if 1
+
+int main(int argc, char **argv)
+{
+    void *status;
+    int rc;
+
+    strcpy(g_oled_config.ccu_udp_path, argv[0]);
+    strcat(g_oled_config.ccu_udp_path, "_addr");
+
+    openlog("OLED", LOG_PID, LOG_USER);
+     
+    memset((uint8_t *)oled_img, 0xff, 1024);
+    memset((char *)&g_oled_config, 0, sizeof(oled_config_t));
+
+   load_cfg_str_from_file(run_flag_file_name, run_flag);
+   load_version_from_file(VERSION_CFG_FILE, g_oled_config.ccu_version,g_oled_config.version_str);
+   load_ccu_from_file(CCUID_CFG_FILE,g_oled_config.ccu_id);
+   strcpy(g_oled_config.ccu_lan, "eth1");
+   g_oled_config.ccu_show_qr = true;
+   
+
+    #if 1 // process input args
+    {
+        int opt;
+        char *opt_str = "f:k:";
+        
+        while ((opt = getopt(argc, argv, opt_str)) !=  -1)
+        {
+            if (opt == 'f')
+            {
+                strncpy(cfg_file_name, optarg, sizeof(cfg_file_name));
+            }
+            else if (opt == 'k')
+            {
+                strncpy(cfg_file_name, optarg, sizeof(cfg_file_name));
+            }
+        }
+
+        if ((strlen(cfg_file_name) == 0) || (strlen(ko_file_name) == 0))
+        {
+            OLED_LOG_DBG("Usage : %s [-f cfg_file_name] [-k ko_file_nmae]\r\n", argv[0]);
+            return 0;
+        }
+    }
+    #endif
+
+   
+
+   
+
+    #if 1 // mutex init
+    {
+        pthread_mutex_init(&data_mutex, NULL);
+    }
+    #endif
+
+    
+
+   
+    #if 1 // init oled thread
+    {
+        pthread_attr_init(&oled_dp_attr);
+
+        size_t s = 1500;
+        pthread_attr_setstacksize(&oled_dp_attr, s);
+
+        pthread_attr_setdetachstate(&oled_dp_attr, PTHREAD_CREATE_JOINABLE);
+
+        rc = pthread_create(&oled_dp_thread, &oled_dp_attr, oled_dp, NULL);
+
+        if (rc)
+        {
+            OLED_LOG_DBG("Error : unable to create thread oled_dp\r\n");
+            return 0;
+        }
+    }
+    #endif
+
+    #if 1 // init test thread
+    {	
+    	 struct thread_recdata thread_test;
+        int test_sockfd;
+        char *buf = NULL;
+
+        while (buf == NULL)
+        {
+            buf = malloc(1500);
+        }
+
+        memset(buf, 0, 1500);
+
+        /* 创建UDP*/
+        test_sockfd = udp_sock_test_init();
+
+        if (test_sockfd <= 0)
+        {
+            OLED_LOG_DBG("socket init error!\r\n");
+            return 0;
+        }
+
+        thread_test.sockfd = test_sockfd;
+        thread_test.info = buf;
+    
+        pthread_attr_init(&test_dp_attr);
+
+        size_t s = 1500;
+        pthread_attr_setstacksize(&test_dp_attr, s);
+
+        pthread_attr_setdetachstate(&test_dp_attr, PTHREAD_CREATE_JOINABLE);
+
+        rc = pthread_create(&test_dp_thread, &test_dp_attr, udp_test_handle, (void *)&thread_test);
+
+        if (rc)
+        {
+            OLED_LOG_DBG("Error : unable to create thread test_dp\r\n");
+            return 0;
+        }
+    }
+    #endif
+
+
+	#if 1
+    {
+        pthread_attr_init(&key_attr);
+
+        size_t s = 1500;
+        pthread_attr_setstacksize(&key_attr, s);
+
+        pthread_attr_setdetachstate(&key_attr, PTHREAD_CREATE_JOINABLE);
+
+        rc = pthread_create(&key_thread, &key_attr, key_process, NULL);
+
+        if (rc)
+        {
+            OLED_LOG_DBG("Error : unable to create thread key_process\r\n");
+            return 0;
+        }
+    }
+    #endif
+
+     #if 1 // init uart thread
+    {
+        pthread_attr_init(&uart_recv_attr);
+
+        size_t s = 1500;
+        pthread_attr_setstacksize(&uart_recv_attr, s);
+
+        pthread_attr_setdetachstate(&uart_recv_attr, PTHREAD_CREATE_JOINABLE);
+
+        rc = pthread_create(&uart_recv_thread, &uart_recv_attr, uart_recv_deamon, NULL);
+
+        if (rc)
+        {
+            OLED_LOG_DBG("Error : unable to create thread oled_dp\r\n");
+            return 0;
+        }
+    }
+    #endif
+
+    pthread_attr_destroy(&test_dp_attr);
+    pthread_attr_destroy(&oled_dp_attr);
+    pthread_attr_destroy(&key_attr);
+    pthread_attr_destroy(&uart_recv_attr);
+	
+
+#if 1
+    {
+        rc = pthread_join(test_dp_thread, &status);
+        
+        if (rc)
+        {
+            OLED_LOG_DBG("Error : unable to join udp_recv\r\n");
+            return 0;
+        }
+    }
+#endif
+
+    {
+        rc = pthread_join(oled_dp_thread, &status);
+
+        if (rc)
+        {
+            OLED_LOG_DBG("Error : unable to join oled_dp\r\n");
+            return 0;
+        }
+    }
+
+    {
+        rc = pthread_join(key_thread, &status);
+
+        if (rc)
+        {
+            OLED_LOG_DBG("Error : unable to join key_thread\r\n");
+            return 0;
+        }
+    }
+
+    {
+        rc = pthread_join(uart_recv_thread, &status);
+
+        if (rc)
+        {
+            OLED_LOG_DBG("Error : unable to join key_thread\r\n");
+            return 0;
+        }
+    }
+
+    pthread_exit(NULL);
+    return 0;
+}
+
+#endif
+
+

factory_test_src/src/main.h

+#ifndef __MAIN_H__
+#define __MAIN_H__
+
+#define OLED_LOG(level, fmt, args...)   \
+    do                                  \
+    {                                   \
+        syslog(level, fmt, ##args);     \
+        printf("\n["__FILE__":%d] "fmt,__LINE__, ##args); \
+    } while(0)
+
+#define OLED_LOG_DBG(fmt, args...)      OLED_LOG(LOG_DEBUG, fmt, ##args)
+
+
+#define ETH0_MAC_NAME             "eth0"
+#define ETH1_MAC_NAME             "eth1"
+
+
+#define MAC_SIZE    18
+#define IP_SIZE     16
+
+#define IN_PORT     13000
+#define SERV_PORT 27001
+
+#define  VERSION_CFG_FILE  "/etc/ver/online"
+
+#define  SN_CFG_FILE  "/etc/ver/sn_cfg"
+
+#define CCUID_CFG_FILE  "/etc/dropbear/accessory/hj/hj_ccuid"
+
+#define ETH1_ADDRESS_FILE_PATH  "/sys/class/net/eth1/address"
+
+#define ETH0_ADDRESS_FILE_PATH  "/sys/class/net/eth0/address"
+
+#define RUN_FLAG_WIFI_SUB_BOARD  "subboard"  // wifi单板测试
+#define RUN_FLAG_AGING  "aging"  // 老化
+#define RUN_FLAG_TEST  "test"  // 整机产测
+#define RUN_FLAG_OK  "success"  // 测试成功
+
+
+#define SET_SN_CMD "/usr/sbin/fw_setenv sn "
+#define GET_SN_CMD "/usr/sbin/fw_printenv sn -n"
+
+typedef struct
+{
+    char ccu_id[16];
+    char ccu_name[32];
+    char ccu_version[32];
+    char version_str[64];
+    char ccu_lan[16];
+
+    int ccu_show_qr;
+    char ccu_qr_str[128];
+
+    int ccu_status;
+    char ccu_udp_path[128];
+
+    int hw_version;
+} oled_config_t;
+
+extern char run_flag[10];
+
+extern char run_flag_file_name[30];
+
+
+extern oled_config_t g_oled_config;
+
+uint8_t get_mac(char *mac_name, char *mac_str, int len);
+void save_cfg_str_to_file(const char *cfg_file_name, char *str);
+void load_sn_from_file(char *cfg_file_name, char *str);
+
+#endif /* __MAIN_H__ */
+
+

factory_test_src/src/oled_dp.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <time.h>
+#include <signal.h>
+#include <errno.h>
+#include <netdb.h>
+#include <net/if.h>
+#include <arpa/inet.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#include "oled_dp.h"
+
+#define FileTMP "/dev/ssd1306-revision"
+
+/*********************浣跨敤璇存槑*******************/
+/*
+   缁撴瀯浣揙LED_INFO涓?鍖呭惈浜嗛渶瑕佹樉绀虹殑妯″紡鍜屽唴瀹癸紝
+   鍙?瑕侀夋嫨闇瑕佺殑妯″紡鍜屽唴瀹瑰～涓婏紝鐒跺悗鎶婃暣涓?鏂囦??   鍐欏埌鍐呮牳鏂囦欢涓?瑙ｅ彲浠ヤ簡銆?*/
+
+OLED_INFO _g_oled_info = {0};
+
+uint8_t chn_ch[25][32] =
+{
+    {0xFF,0x09,0x91,0x61,0x91,0x09,0x91,0x61,0x91,0x09,0xFF,0x00,0x0F,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x08,0x09,0x0F,0x00}, /* 0 缃?*/
+    {0x98,0xD4,0xB3,0x88,0x48,0xC4,0xAB,0x92,0xAA,0xC6,0x40,0x00,0x04,0x04,0x02,0x02,0x00,0x0F,0x04,0x04,0x04,0x0F,0x00,0x00}, /* 1 缁?*/
+
+    {0x00,0xFE,0x92,0x92,0xFE,0x00,0xFE,0x42,0xD2,0x52,0xCE,0x00,0x08,0x07,0x00,0x08,0x0F,0x00,0x0F,0x08,0x05,0x02,0x0D,0x00}, /* 2 鏈?*/
+    {0x20,0xA4,0x92,0x97,0xEA,0x8A,0x8A,0x96,0x92,0x20,0x20,0x00,0x00,0x08,0x04,0x03,0x00,0x00,0x08,0x08,0x07,0x00,0x00,0x00}, /* 3 鍔?*/
+
+    {0x00,0x02,0xE2,0x02,0x02,0xFE,0x42,0x42,0x42,0x42,0x00,0x00,0x08,0x08,0x0F,0x08,0x08,0x0F,0x08,0x08,0x08,0x08,0x08,0x00}, /* 4 姝?*/
+    {0x0C,0x04,0x75,0x56,0x54,0xD7,0x54,0x56,0x75,0x04,0x0C,0x00,0x00,0x07,0x01,0x01,0x01,0x0F,0x01,0x01,0x05,0x07,0x00,0x00}, /* 5 甯?*/
+
+    {0x00,0xF8,0x88,0x88,0x88,0xFF,0x88,0x88,0x88,0xF8,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x0F,0x00,0x00,0x00,0x01,0x00,0x00}, /* 6 涓?*/
+    {0xFC,0x92,0x54,0xFF,0x54,0x92,0x00,0xFE,0x12,0xF2,0x11,0x00,0x07,0x04,0x04,0x07,0x04,0x04,0x08,0x07,0x00,0x0F,0x00,0x00}, /* 7 鏂?*/
+    
+    {0x82,0xBA,0xA2,0xB6,0xAA,0xEB,0xAA,0xB6,0xA2,0xBA,0x82,0x00,0x0F,0x00,0x04,0x06,0x05,0x04,0x06,0x0C,0x00,0x08,0x0F,0x00}, /* 8 绂?*/
+    {0x98,0xD4,0xB3,0x88,0x00,0x48,0x48,0xFF,0x24,0xA5,0x26,0x00,0x04,0x04,0x02,0x02,0x08,0x08,0x04,0x03,0x05,0x08,0x0E,0x00}, /* 9 绾?*/
+
+    {0x00,0x1F,0x25,0xE5,0x25,0x25,0x25,0x25,0xE5,0x27,0x30,0x00,0x01,0x09,0x05,0x03,0x01,0x01,0x01,0x01,0x0F,0x01,0x01,0x00}, /* 10 寮?*/
+    {0x0C,0x04,0x75,0x56,0x54,0xD7,0x54,0x56,0x75,0x04,0x0C,0x00,0x00,0x07,0x01,0x01,0x01,0x0F,0x01,0x01,0x05,0x07,0x00,0x00}, /* 11 甯?*/
+    
+    {0x00,0x88,0x88,0x88,0x89,0xFA,0x88,0x88,0x88,0x88,0x00,0x00,0x08,0x08,0x08,0x08,0x08,0x0F,0x08,0x08,0x08,0x08,0x08,0x00}, /* 12 主*/
+    {0x88,0x68,0xFF,0x28,0x40,0xFE,0x02,0x02,0xFE,0x00,0x00,0x00,0x00,0x00,0x0F,0x08,0x04,0x03,0x00,0x00,0x07,0x08,0x0E,0x00}, /* 13 机*/
+    
+	{0x20,0x24,0x24,0xA4,0xE4,0x3F,0x34,0x2C,0x24,0xA2,0x20,0x00,0x04,0x02,0x01,0x00,0x07,0x0A,0x0A,0x09,0x09,0x08,0x0E,0x00}, /*"老",14*/
+	{0x20,0x10,0xFC,0x03,0x00,0x80,0xFF,0x20,0x10,0x08,0x04,0x00,0x00,0x00,0x0F,0x00,0x01,0x00,0x07,0x08,0x08,0x08,0x0E,0x00}, /*"化",15*/
+	{0x00,0xF8,0x88,0x88,0x88,0xFF,0x88,0x88,0x88,0xF8,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x0F,0x00,0x00,0x00,0x01,0x00,0x00}, /*"中",16*/
+
+	{0xC2,0xAE,0x9A,0xFF,0x9A,0xAE,0xC4,0xAB,0x92,0xAE,0xC2,0x00,0x08,0x08,0x0E,0x08,0x08,0x0F,0x0A,0x0A,0x0A,0x0A,0x08,0x00}, /*"整",17*/ /* 机，13 */
+	{0x00,0xC4,0x44,0x54,0x65,0x46,0x44,0x64,0x54,0x44,0x44,0x00,0x08,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, /*"产",18*/
+	{0x22,0x44,0xFE,0x02,0xFA,0x02,0xFE,0x00,0xFC,0x00,0xFF,0x00,0x04,0x02,0x09,0x04,0x03,0x04,0x09,0x00,0x01,0x08,0x0F,0x00}, /*"测",19*/
+
+    {0x00,0x7C,0x55,0x56,0x54,0xFC,0x54,0x56,0x55,0x7C,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x0F,0x01,0x01,0x01,0x01,0x01,0x00},/*"单",0*/
+
+    {0x88,0x68,0xFF,0x28,0x40,0xFE,0x12,0xF2,0x12,0x91,0x71,0x00,0x00,0x00,0x0F,0x08,0x04,0x03,0x08,0x05,0x02,0x05,0x08,0x00},/*"板",1*/
+
+    {0x80,0x80,0x88,0x88,0x88,0x88,0x88,0xFF,0x88,0x88,0x88,0x88,0x88,0x80,0x80,0x00,0x20,0x20,0x10,0x08,0x04,0x02,0x01,0xFF,0x01,0x02,0x04,0x08,0x10,0x20,0x20,0x00},/*"未",22*/
+    {0xF0,0x00,0xFF,0x20,0x10,0x00,0x88,0x88,0x4F,0x58,0x24,0x54,0x84,0xE4,0x00,0x00,0x80,0x70,0x0F,0x10,0x20,0x82,0x42,0x32,0x0E,0x02,0x02,0x3E,0x42,0x42,0x72,0x00},/*"烧",23*/
+    {0x80,0x80,0x82,0x92,0x92,0x92,0x92,0x92,0x92,0x92,0x92,0xFE,0x80,0x80,0x80,0x00,0x40,0x40,0x22,0x24,0x10,0x48,0x80,0x7F,0x04,0x08,0x18,0x24,0x22,0x40,0x40,0x00},/*"录",24*/
+
+};
+
+
+void arry_copy(uint8_t *arry_out, uint8_t *arry_in, int len)
+{
+#if 1
+    memcpy(arry_out, arry_in, len);
+#else
+    int i;
+    int arry_len = len;
+    for (i = 0; i < arry_len;i ++)
+    {
+        arry_out[i] = arry_in[i];
+    }
+#endif
+}
+
+void sleep_screen(void)
+{
+    _g_oled_info.oled_oper_mode = oled_sleep;
+    write1306();
+}
+
+void wakeup_screen(void)
+{
+    _g_oled_info.oled_oper_mode = oled_wakeup;
+    write1306();
+}
+
+void clear_screen(void)
+{
+    _g_oled_info.oled_oper_mode = oled_clear;
+    write1306();
+}
+
+void fill_screen(uint8_t fill_data)
+{
+    _g_oled_info.oled_oper_mode = oled_clear;
+    _g_oled_info.fill_char = fill_data;
+    write1306();
+}
+
+void show_str_set(char *str, uint8_t x, uint8_t y, uint8_t strsize)
+{
+    _g_oled_info.oled_oper_mode = oled_show_str;
+
+    _g_oled_info.str_info.pos_x = x;
+    _g_oled_info.str_info.pos_y = y;
+
+    _g_oled_info.str_info.str_size = strsize;
+
+    strcpy((char *)_g_oled_info.str_info.str, str);
+
+    write1306();
+}
+
+void show_chn_set(uint8_t x, uint8_t y, uint8_t num, uint8_t size)
+{
+    //printf("set oled chn\n");
+	_g_oled_info.oled_oper_mode = oled_show_chn;
+
+	_g_oled_info.chn_info.pos_x = x;
+	_g_oled_info.chn_info.pos_y = y;
+
+	arry_copy(_g_oled_info.chn_info.chn, chn_ch[num], 32);
+
+	_g_oled_info.chn_info.chn_size = size;
+
+	write1306();
+}
+
+void show_bmp_set(uint8_t x, uint8_t y, uint8_t x1, uint8_t y1, uint8_t bmp[], uint16_t bmp_len)
+{
+    _g_oled_info.oled_oper_mode = oled_show_bmp;
+
+    _g_oled_info.bmp_info.start_x = x;
+    _g_oled_info.bmp_info.start_y = y;
+
+    _g_oled_info.bmp_info.end_x = x1;
+    _g_oled_info.bmp_info.end_y = y1;
+
+    arry_copy(_g_oled_info.bmp_info.bmp, bmp, bmp_len);
+
+    _g_oled_info.bmp_info.len = bmp_len;
+
+    write1306();
+}
+
+void write1306(void)
+{
+    int fd = -1;            
+
+    if (!(fd = open(FileTMP, O_RDWR)))
+    {
+        // printf("can't open the file %s\n", FileTMP);
+    }
+
+    // fseek(fp, 0, SEEK_END);
+    write(fd, &(_g_oled_info), sizeof(_g_oled_info));
+    close(fd);
+}
+

factory_test_src/src/oled_dp.h

+#ifndef __OLED_DP_H__
+#define __OLED_DP_H__
+
+/*
+* 1. 字表由打包资料中的?取字软件?计算得?;
+* 2. 取字方式 -- 共阴、列行式、?向输出
+*/
+
+/***************说明***********/
+//显示屏有几种显示模式
+//1.字符模式，长?50，分为两种大?6x8?8x16
+//2.中文模式，需要的汉字?要?过取模软件取模
+//3.图片模式，图片也要经过取?
+
+// 屏幕的几种模?
+enum oled_mode
+{
+    oled_clear=0,                   //清屏
+    oled_fill,                      //填充
+    oled_show_chn,                  //显示汉字
+    oled_show_str,                  //显示字符
+    oled_show_bmp,                  //显示图片
+    oled_sleep,                     //睡眠，可以省?
+    oled_wakeup                     //从睡眠模式唤?
+};
+
+enum oled_str_mode
+{
+    show_6x8_mode = 1,                //字符模式的两种大?
+    show_8x16_mode
+};
+
+typedef struct show_str             //字符模式
+{
+    enum oled_str_mode str_size;    //字符的大?
+    uint8_t pos_x;                  //?要显示的位置
+    uint8_t pos_y;
+    uint8_t str[50];                //字符内容
+}str_mode;
+
+typedef struct show_chn     //中文模式
+{
+    uint8_t pos_x;          //显示的位?
+    uint8_t pos_y;
+    uint8_t chn[32];        //显示内容
+    uint8_t chn_size;       //
+}chn_mode;
+
+typedef struct show_bmp     //图片模式
+{
+    uint8_t start_x;        //?始位?
+    uint8_t start_y;
+    uint8_t end_x;          //图片结束位置
+    uint8_t end_y;
+    uint8_t bmp[1024];      //图片内容
+    uint16_t len;           //图片内容字节?
+} bmp_mode;
+
+typedef struct OLED
+{
+    enum oled_mode oled_oper_mode;  //选择模式
+    str_mode str_info;
+    chn_mode chn_info;
+    bmp_mode bmp_info;
+    uint8_t fill_char;          //填充模式?要填充的字节
+} OLED_INFO;
+
+void sleep_screen(void);
+void wakeup_screen(void);
+void clear_screen(void);
+void fill_screen(uint8_t fill_data);
+void show_str_set(char *str, uint8_t x, uint8_t y, uint8_t strsize);
+void show_bmp_set(uint8_t x, uint8_t y, uint8_t x1, uint8_t y1, uint8_t bmp[], uint16_t bmp_len);
+void show_chn_set(uint8_t x, uint8_t y, uint8_t num, uint8_t size);
+void write1306(void);
+
+#endif /* __OLED_DP_H__ */

factory_test_src/src/uart_proto.c

+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include "Serial.h"
+#include "main.h"
+
+//#include "common.h"
+
+//#include "thread.h"
+//#include "app_queue.h"
+//#include "dev_arp.h"
+//#include "net_handle.h"
+
+#include "uart_proto.h"
+
+
+
+uart_data_t g_uart_data;
+static uint16_t g_temp_data_len = 0;
+static uint16_t g_data_len = 0;
+static uint16_t g_recv_crc16 = 0;
+static uint8_t state = SOP_STATE1;
+
+uint16_t make_crc16(uint8_t *msg, uint16_t len)
+{
+    uint16_t crc16 = 0xFFFF;
+    uint16_t i, j = 0;
+    uint8_t c15, bit;
+
+    for (i = 0; i < len ; i++)
+    {
+        for (j = 0; j < 8; j++)
+        {
+            c15 = ((crc16 >> 15 & 1) == 1);
+            bit = ((msg[i] >> (7 - j) & 1) == 1);
+            crc16 <<= 1;
+
+            if (c15 ^ bit)
+            {
+                crc16 ^= 0x1021;
+            }
+        }
+    }
+   // GW_LOG_DBG("crc16 caculate:0x%04x\n",crc16);
+    return crc16;
+}
+
+uint32_t make_crc32(uint8_t *msg, uint16_t len)
+{
+    uint32_t crc32 = 0xFFFFFFFF;
+    uint16_t i, j = 0;
+    uint16_t c15, bit;
+
+    for (i = 0; i < len ; i++)
+    {
+        for (j = 0; j < 8; j++)
+        {
+            c15 = ((crc32 >> 31 & 1) == 1);
+            bit = ((msg[i] >> (7 - j) & 1) == 1);
+            crc32 <<= 1;
+
+            if (c15 ^ bit)
+            {
+                crc32 ^= 0x10211021;
+            }
+        }
+    }
+
+    return crc32;
+}
+
+int kk_execel_cmd(char * cmd,char * buf,int buf_len,int* ret_len)
+{
+    if(cmd == NULL || buf == NULL || buf_len == 0)
+    {
+        GW_LOG_ERR("arg error\n");
+        return -1;
+    }
+
+    memset(buf,0,buf_len);
+
+    FILE *fp = NULL;
+     
+  	fp = popen(cmd,"r");
+  	while(fgets(buf,buf_len,fp)!=NULL){
+  		printf("%s return %s",cmd,buf);  
+  	}
+  	pclose (fp);
+    
+    *ret_len = strlen(buf);
+    return 0;
+}
+
+void uart_frame_send(uint8_t *buf, uint32_t len)
+{
+    int ret = eSerial_WriteBuffer(buf, len);
+    if (ret == E_SERIAL_FD_ERROR)
+    {
+        //eSerial_Init();
+    }
+}
+
+uint8_t pro_check_uart_frame(uint8_t *data, uint16_t data_len)
+{
+    uint16_t i;
+    uint16_t tmp_len;
+    uint16_t tmp_crc;
+    //uint8_t gw_mac_flag = 0;
+    //uint16_t crc;
+
+    if (data_len < PRO_LINK_PAKCET_SIZE)
+    {
+        GW_LOG_ERR("PRO: data_len(%d) < (%d)\n", data_len, PRO_APP_PACKET_MIN_SIZE);
+        return 0;
+    }
+
+    //check header
+    i = 0;
+
+    if (data[0] != PRO_SOF_1 || data[1] != PRO_SOF_2)
+    {
+        GW_LOG_ERR("PRO: sof err (0x%02X 0x%02X)\n", data[0], data[1]);
+        return 0;
+    }
+
+    i += PRO_SOF_SIZE;
+
+    #if 0
+    //check control-field
+    if (data[i] < 0x08 && data[i + 1] == 0x30)
+    {
+        if (gw_mac_flag == 1)
+        {
+            //gw link ack, don't care
+            GW_LOG_DBG("gw link ack\n");
+            return 0;
+        }
+
+        //forward link ack to ccu
+        #if 0
+        if (!dev_arp_query_mac_by_ip(data + PRO_SOF_SIZE, dev_mac))
+        {
+            return 0;
+        }
+        #endif
+
+        crc = make_crc16(data, data_len - 2);
+
+        data[data_len - 2] = crc >> 8;
+        data[data_len - 1] = crc;
+        
+        GW_LOG_DBG("link ack\n");
+
+        // dev_send_net(NET_SEND_NOT_BC, UDP_MSG_LOCAL, &g_ccu_net_addr, data, data_len);
+        //net_handle_send_tcp_data(data, data_len, 0, TCP_FRAME_NORMAL);
+
+        return 0;
+    }
+    #endif
+
+    //i += PRO_CONTORL_FIELD_SIZE; //jump over control-field
+
+    //check data_size
+    tmp_len = ((uint16_t)(data[i]) << 8) + data[i + 1] + PRO_SOF_SIZE + PRO_LEN_SIZE + PRO_CRC_SIZE;
+
+    if (tmp_len != data_len)
+    {
+        GW_LOG_ERR("PRO: data_len(%d) != (%d)\n", data_len, tmp_len);
+        return 0;
+    }
+
+    //check crc
+    i = data_len - PRO_CRC_SIZE - PRO_SOF_SIZE - PRO_LEN_SIZE;
+    tmp_crc = make_crc16(&data[4], i);
+
+    if (tmp_crc != ((((uint16_t)(data[data_len-2])) << 8) + data[data_len - 1]))
+    {
+        GW_LOG_ERR("PRO: crc err(0x%04X) != (0x%02X%02X)\n", tmp_crc, data[i], data[i + 1]);
+        return 0;
+    }
+
+    return 1;
+}
+
+int get_uart_frame(uint8_t * buf,int len)
+{
+    uint8_t ch;
+    int i = 0;
+
+    GW_LOG_DBG("uart fram len:%d  state:%d\n",len,state);
+
+    for (i = 0 ; i < len ; i++)
+    {
+        ch = buf[i];
+
+        switch (state)
+        {
+            case SOP_STATE1:
+                if (ch == PRO_SOF_1)
+                {
+                    state = SOP_STATE2;
+                }
+
+                g_temp_data_len = 0;
+                g_uart_data.data[g_temp_data_len++] = ch;
+                break;
+
+            case SOP_STATE2:
+                if (ch == PRO_SOF_2)
+                {
+                    state = LENGTH_STATE1;
+                    g_uart_data.data[g_temp_data_len++] = ch;
+                }
+                else
+                {
+                    GW_LOG_ERR("uart data err: SOF2");
+
+                    if (ch == PRO_SOF_1)
+                    {
+                        state = SOP_STATE2;
+                    }
+                    else
+                    {
+                        state = SOP_STATE1;
+                    }
+                }
+
+                break;
+
+            /* Length 2 bytes */
+            case LENGTH_STATE1:
+                g_uart_data.data[g_temp_data_len++] = ch;
+                state = LENGTH_STATE2;
+                g_data_len = ((uint16_t)ch) << 8;
+                break;
+
+            case LENGTH_STATE2:
+                g_uart_data.data[g_temp_data_len++] = ch;
+                g_data_len += ch;
+
+                if (g_data_len < 2 || g_data_len > (DEV_UART_RECV_BUFFER_SIZE - (PRO_LINK_PAKCET_SIZE - 2)))
+                {
+                    GW_LOG_ERR("uart data err: LEN err, len = %d", g_data_len);
+
+                    if (ch == PRO_SOF_1)
+                    {
+                        state = SOP_STATE2;
+                    }
+                    else
+                    {
+                        state = SOP_STATE1;
+
+                    }
+
+                    break;
+                }
+
+                state = CONTROL_FIELD_STATE1;
+                g_data_len -= 3;
+
+                if (g_data_len == 0)
+                {
+                    state = CRC16_STATE1;
+                }
+
+                break;
+
+            case CONTROL_FIELD_STATE1:
+                g_uart_data.data[g_temp_data_len++] = ch;
+                state = SEQ_STATE1;
+                break;
+
+            case SEQ_STATE1:
+                g_uart_data.data[g_temp_data_len++] = ch;
+                state = SEQ_STATE2;
+                break;
+
+            case SEQ_STATE2:
+                g_uart_data.data[g_temp_data_len++] = ch;
+                state = DATA_STATE;
+                break;
+
+            case DATA_STATE:
+                if (g_data_len--)
+                {
+                    g_uart_data.data[g_temp_data_len++] = ch;
+                    state = DATA_STATE;
+
+                    if (g_data_len == 0)
+                    {
+                        state = CRC16_STATE1;
+                    }
+
+                    break;
+                }
+
+                break;
+
+            case CRC16_STATE1:
+                g_recv_crc16 = ((uint16_t)ch) << 8;
+                g_uart_data.data[g_temp_data_len++] = ch;
+                state = CRC16_STATE2;
+                break;
+
+            case CRC16_STATE2:
+                state = SOP_STATE1;
+                g_uart_data.data[g_temp_data_len++] = ch;
+                g_uart_data.data_len = g_temp_data_len;
+                g_recv_crc16 += ch;
+
+                if (make_crc16(&g_uart_data.data[4], g_temp_data_len - 6) == g_recv_crc16)
+                {
+                    return true;
+                }
+                else
+                {
+                    GW_LOG_ERR("uart data err: CRC err:0x%04x\n",g_recv_crc16);
+                    state = SOP_STATE1;
+                }
+
+                break;
+
+            default:
+                GW_LOG_ERR("uart data err: INNER err");
+
+                if (ch == PRO_SOF_1)
+                {
+                    state = SOP_STATE2;
+                }
+                else
+                {
+                    state = SOP_STATE1;
+
+                }
+
+                break;
+        }
+    }
+
+    return false;
+}
+
+int get_proto_frame(uint8_t *data, uint16_t data_len, pro_data_t *pro_data)
+{
+    if (pro_check_uart_frame(data, data_len))
+    {
+        pro_data->cf.ack = data[PRO_CF_INDEX] & 0x03;
+        pro_data->cf.dir = (data[PRO_CF_INDEX] >> 5) & 0x01;
+        pro_data->cf.sof_flag = (data[PRO_CF_INDEX] >> 4) & 0x01;
+        pro_data->cf.mf_flag = (data[PRO_CF_INDEX] >> 3) & 0x01;
+
+        pro_data->seq = (((uint16_t)(data[PRO_SEQ_INDEX])) << 8) + data[PRO_SEQ_INDEX + 1];
+
+        pro_data->ch = data[PRO_DATA_INDEX+1];
+        
+        pro_data->opcode = (((uint16_t)(data[PRO_DATA_INDEX + 2])) << 8) + data[PRO_DATA_INDEX + 3];
+        //pro_data->args_len = data_len - PRO_APP_PACKET_MIN_SIZE + 1;
+        pro_data->args_len = data[PRO_DATA_INDEX] -3 ;
+        memcpy(pro_data->arg, data + PRO_DATA_INDEX + 4, pro_data->args_len);
+
+        return true;
+    }
+
+    return false;
+}
+
+uint8_t cf_to_uint8_t(control_field_t *cf)
+{
+    return ((((uint8_t)(cf->ack))) + ((cf->dir) << 5) + ((cf->sof_flag) << 4) + ((cf->mf_flag) << 3));
+}
+
+uint8_t proto_frame_to_uart(pro_data_t *pro_data, uint8_t *uart_data)
+{
+    uint8_t i = 0;
+    uint16_t cf;
+    uint8_t len;
+    uint16_t crc;
+
+    uart_data[i++] = PRO_SOF_1;
+    uart_data[i++] = PRO_SOF_2;
+
+    len = pro_data->args_len + 4 + 3;
+
+    uart_data[i++] = len>>8;
+    uart_data[i++] = len;
+
+    cf = cf_to_uint8_t(&(pro_data->cf));
+    //cf = 0x20;
+    
+    uart_data[i++] = cf;
+
+    uart_data[i++] = pro_data->seq>>8;
+    uart_data[i++] = pro_data->seq;
+
+    uart_data[i++] = pro_data->args_len + 3;
+    uart_data[i++] = pro_data->ch;
+    uart_data[i++] = (pro_data->opcode) >> 8;
+    uart_data[i++] = (pro_data->opcode);
+
+    memcpy(uart_data + i, pro_data->arg, pro_data->args_len);
+    i += pro_data->args_len;
+
+    crc = make_crc16(&uart_data[4], i-4);
+    uart_data[i++] = crc >> 8;
+    uart_data[i++] = crc;
+
+    return i;
+}
+
+
+void pro_send_link_ack(pro_data_t *pro_data)
+{
+    uint8_t buf[PRO_LINK_PAKCET_SIZE];
+    uint16_t len = 2;
+    uint16_t crc;
+    uint8_t i = 0;
+
+    buf[i++] = PRO_SOF_1;
+    buf[i++] = PRO_SOF_2;
+
+    buf[i++] = 0x00;
+    buf[i++] = 0x30;
+
+    len = 2;
+    buf[i++] = len >> 8;
+    buf[i++] = len;
+
+    crc = make_crc16(buf, i);
+    buf[i++] = crc >> 8;
+    buf[i++] = crc;
+    
+    dev_send_uart(buf,i);
+}
+
+void dev_send_uart(uint8_t *data, uint16_t data_len)
+{
+    #if 1 // debug
+    {
+        static char data_print_buf[512] = {0};
+        int i = 0;
+        
+        memset(data_print_buf, 0, sizeof(data_print_buf));
+
+        for (i = 0; i < data_len; i ++)
+        {
+            snprintf(data_print_buf + strlen(data_print_buf), sizeof(data_print_buf), "%02X ", data[i]);
+        }
+
+        GW_LOG_DBG("uart send data %s\n", data_print_buf);
+    }
+    #endif
+
+    uart_frame_send(data, data_len);
+}
+
+static void uart_protocol_print(pro_data_t *pro_data)
+{
+    
+    GW_LOG_DBG("channel %02X\n", pro_data->ch);
+    GW_LOG_DBG("opcode %04X\n", pro_data->opcode);
+    GW_LOG_DBG("args_len: %d\n", pro_data->args_len);
+
+    char print_buf[512] = {0};
+    int i = 0;
+
+    snprintf(print_buf, sizeof(print_buf), "args: ");
+
+    for (i = 0; i < pro_data->args_len; i ++)
+    {
+        snprintf(print_buf + strlen(print_buf), sizeof(print_buf), "%02X ", pro_data->arg[i]);
+    }
+
+    GW_LOG_DBG("%s\n", print_buf);
+}
+
+
+/********proto app func************/
+
+void connect_status_ack(pro_data_t pro_data)
+{
+    pro_data_t pro_data_tmp;
+    memset((char*)&pro_data_tmp,0,sizeof(pro_data_t));
+    memcpy(&pro_data_tmp,&pro_data,sizeof(pro_data_t));
+
+    pro_data_tmp.cf.dir = 1;
+    pro_data_tmp.cf.sof_flag = 0;
+
+    pro_data_tmp.args_len = 0;
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+
+    uint8_t data_buf[255] = {0};
+    uint8_t data_len = 0;
+
+    data_len = proto_frame_to_uart(&pro_data_tmp,data_buf);
+    dev_send_uart(data_buf, data_len);
+}
+
+void system_restart_ack(pro_data_t pro_data)
+{
+    pro_data_t pro_data_tmp;
+    memset((char*)&pro_data_tmp,0,sizeof(pro_data_t));
+    memcpy(&pro_data_tmp,&pro_data,sizeof(pro_data_t));
+
+    pro_data_tmp.cf.dir = 1;
+    pro_data_tmp.cf.sof_flag = 0;
+
+    pro_data_tmp.args_len = 0;
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+
+    uint8_t data_buf[255] = {0};
+    uint8_t data_len = 0;
+
+    data_len = proto_frame_to_uart(&pro_data_tmp,data_buf);
+    dev_send_uart(data_buf, data_len);
+
+    sleep(2);
+    my_system("reboot -f\n");
+}
+
+void read_mac_ack(pro_data_t pro_data)
+{
+    pro_data_t pro_data_tmp;
+    char eth0_mac_str[32] = "";
+    unsigned int  eth0_mac[6] = {0};
+
+
+    memset((char*)&pro_data_tmp,0,sizeof(pro_data_t));
+    memcpy(&pro_data_tmp,&pro_data,sizeof(pro_data_t));
+
+    pro_data_tmp.cf.dir = 1;
+    pro_data_tmp.cf.sof_flag = 0;
+
+    //get mac
+    if (get_mac(ETH0_MAC_NAME, eth0_mac_str, sizeof(eth0_mac_str)) == 0)
+    {
+        OLED_LOG_DBG("get eth0 mac error\n");
+        return ;
+    }
+
+    sscanf(eth0_mac_str, "%x:%x:%x:%x:%x:%x", &eth0_mac[0], \
+        &eth0_mac[1],&eth0_mac[2],&eth0_mac[3],&eth0_mac[4],&eth0_mac[5]);
+
+
+    pro_data_tmp.args_len = 0;
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = 6; // mac len
+    
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[0]&0xff; // mac
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[1]&0xff; // mac
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[2]&0xff; // mac
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[3]&0xff; // mac
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[4]&0xff; // mac
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[5]&0xff; // mac
+
+
+
+    uint8_t data_buf[255] = {0};
+    uint8_t data_len = 0;
+
+    data_len = proto_frame_to_uart(&pro_data_tmp,data_buf);
+    dev_send_uart(data_buf, data_len);
+
+}
+
+int my_system(const char * cmd)                             
+{                                                          
+	FILE * fp;                                                 
+	int res; 
+	char buf[1024];                                   
+	if (cmd == NULL){                                                          
+		GW_LOG_DBG("my_system cmd is NULL!\n");                        
+		return -1;                                                
+	}                                                         
+	if ((fp = popen(cmd, "r") ) == NULL){                                                          
+		perror("popen");                                           
+	 	GW_LOG_DBG("popen error: %s/n", strerror(errno));
+	 	return -1;  
+	}                                                          
+	else{                                                         
+		while(fgets(buf, sizeof(buf), fp)){                                                          
+			GW_LOG_DBG("%s", buf);                                         
+		}                                                          
+		if ( (res = pclose(fp)) == -1){                                                          
+			GW_LOG_DBG("close popen file pointer fp error!\n"); 
+			return res;
+		}                                                         
+		else if (res == 0){                                                          
+		 	return res;                                               
+		}                                                         
+		else{                                                          
+			GW_LOG_DBG("popen res is :%d\n", res); 
+			return res;             
+		}                                                          
+	}                                                          
+} 
+
+int get_art_bin()
+{
+	my_system("dd if=/dev/mtd5 of=/tmp/art.bin");
+
+	if(access("/tmp/art.bin",F_OK) == -1){
+		GW_LOG_DBG(" file not exist: /tmp/art.bin\n");
+		return 0;
+	}
+
+	return 1;
+}
+
+int write_art_bin()
+{
+	GW_LOG_DBG("write art and restart!!!\n");
+	my_system("mtd write /tmp/art-modify.bin  art");
+   // my_system("reboot -f");
+	return 1;
+}
+
+long get_file_len(FILE * fp)
+{
+	long offset;
+	
+	fseek(fp,0,SEEK_END);  //移到文件结尾
+	offset = ftell(fp);
+	fseek(fp,0,SEEK_SET);  //移到文件开头
+
+	return offset;
+}
+
+int mac_modify(unsigned char mac[6])
+{
+	FILE *fp;
+	long offset = 0,fileLen = 0;
+	char *file_content;
+
+	if(!((mac[0]&0xff) == 0x28  && (mac[1]&0xff) == 0xd9  &&  (mac[2]&0xff) == 0x8a))
+		return 0;
+
+	if(get_art_bin() == 0){
+		GW_LOG_DBG("get uboot bin error \n");
+		return 0;
+	}
+
+	if(!(fp =  fopen("/tmp/art.bin","r"))){
+		GW_LOG_DBG("can't open the file: /tmp/art.bin\n");
+		return 0;		
+	}
+
+	offset = get_file_len(fp);
+	GW_LOG_DBG("offset:%ld ",offset);
+
+	file_content = (char *)malloc(offset);
+	memset(file_content,0,offset);
+	fileLen = fread(file_content,1,offset,fp);
+	GW_LOG_DBG("fileLen:%ld \n",fileLen);
+	fclose(fp);
+
+	GW_LOG_DBG("mac:%02x-%02x-%02x-%02x-%02x-%02x\n",file_content[MAC_ADDR]&0xff,file_content[MAC_ADDR+1]&0xff,file_content[MAC_ADDR+2]&0xff,file_content[MAC_ADDR+3]&0xff,file_content[MAC_ADDR+4]&0xff,file_content[MAC_ADDR+5]&0xff);
+	GW_LOG_DBG("mac-input:%02x-%02x-%02x-%02x-%02x-%02x\n",mac[0]&0xff,mac[1]&0xff,mac[2]&0xff,mac[3]&0xff,mac[4]&0xff,mac[5]&0xff);
+	if((file_content[MAC_ADDR]&0xff) == 0x28  && (file_content[MAC_ADDR+1]&0xff) == 0xd9  &&  (file_content[MAC_ADDR+2]&0xff) == 0x8a) {
+				GW_LOG_DBG("modifying\n");
+				file_content[MAC_ADDR] = mac[0];
+				file_content[MAC_ADDR+1] = mac[1];
+				file_content[MAC_ADDR+2] = mac[2];
+				file_content[MAC_ADDR+3] = mac[3];
+				file_content[MAC_ADDR+4] = mac[4];
+				file_content[MAC_ADDR+5] = mac[5];
+	}
+	GW_LOG_DBG("mac-modify:%02x-%02x-%02x-%02x-%02x-%02x\n",file_content[MAC_ADDR]&0xff,file_content[MAC_ADDR+1]&0xff,file_content[MAC_ADDR+2]&0xff,file_content[MAC_ADDR+3]&0xff,file_content[MAC_ADDR+4]&0xff,file_content[MAC_ADDR+5]&0xff);
+
+	if(!(fp =  fopen("/tmp/art-modify.bin","w+"))){
+		GW_LOG_DBG("can't open the file: /tmp/art-modify.bin\n");
+		free(file_content);
+		return 0;		
+	}
+
+	fwrite(file_content,1,offset,fp);
+	fclose(fp);
+	free(file_content);
+	return 1;
+}
+
+int get_art_mac(unsigned char mac[6])
+{
+	FILE *fp;
+	long offset = 0,fileLen = 0;
+	char *file_content;
+
+	if(get_art_bin() == 0){
+		GW_LOG_DBG("get uboot bin error \n");
+		return 0;
+	}
+
+	if(!(fp =  fopen("/tmp/art.bin","r"))){
+		GW_LOG_DBG("can't open the file: /tmp/wifi_scan\n");
+		return 0;		
+	}
+
+	offset = get_file_len(fp);
+	GW_LOG_DBG("offset:%ld ",offset);
+
+	file_content = (char *)malloc(offset);
+	memset(file_content,0,offset);
+	fileLen = fread(file_content,1,offset,fp);
+	GW_LOG_DBG("fileLen:%ld \n",fileLen);
+	fclose(fp);
+
+
+	mac[0] = file_content[MAC_ADDR];
+	mac[1] = file_content[MAC_ADDR+1];
+	mac[2] = file_content[MAC_ADDR+2];
+	mac[3] = file_content[MAC_ADDR+3];
+	mac[4] = file_content[MAC_ADDR+4];
+	mac[5] = file_content[MAC_ADDR+5];
+	GW_LOG_DBG("mac-output:%02x-%02x-%02x-%02x-%02x-%02x\n",mac[0]&0xff,mac[1]&0xff,mac[2]&0xff,mac[3]&0xff,mac[4]&0xff,mac[5]&0xff);
+
+	free(file_content);
+	return 1;
+}
+
+void set_mac_ack(pro_data_t pro_data)
+{
+    unsigned char mac_iput[6] = {0};
+
+    pro_data_t pro_data_tmp;
+    //uint8_t arg_buf[256];
+    
+    memset((char*)&pro_data_tmp,0,sizeof(pro_data_t));
+    memcpy(&pro_data_tmp,&pro_data,sizeof(pro_data_t));
+
+    //pro_data_tmp.arg = arg_buf;
+    memcpy(pro_data_tmp.arg,pro_data.arg,pro_data.args_len);
+
+    pro_data_tmp.cf.dir = 1;
+    pro_data_tmp.cf.sof_flag = 0;
+
+    //pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+    uint8_t mac_len = pro_data_tmp.arg[0];
+
+    int i = 0;
+    for(i = 0; i < mac_len; i++)
+    {
+        mac_iput[i] = pro_data_tmp.arg[i+1];
+    }
+
+    printf("mac input:%02x-%02x-%02x-%02x-%02x-%02x\n",mac_iput[0],\
+            mac_iput[1],mac_iput[2],mac_iput[3],mac_iput[4],mac_iput[5]);
+
+    // ack handle
+    if(mac_modify(mac_iput) == 0)
+    {
+         pro_data_tmp.arg[0] = E_Proto_ERROR; 
+    }
+
+    write_art_bin();
+
+    pro_data_tmp.arg[0] = E_Proto_OK;  // err status
+
+    memset(&pro_data_tmp.arg[1],0,pro_data_tmp.args_len);
+    memcpy(&pro_data_tmp.arg[1],&pro_data.arg[0],pro_data.args_len);
+
+    pro_data_tmp.args_len++;
+    
+    uint8_t data_buf[255] = {0};
+    uint8_t data_len = 0;
+
+    data_len = proto_frame_to_uart(&pro_data_tmp,data_buf);
+    dev_send_uart(data_buf, data_len);
+}
+
+void read_flash_mac_ack(pro_data_t pro_data)
+{
+    pro_data_t pro_data_tmp;
+    unsigned char  eth0_mac[6] = {0};
+
+    memset((char*)&pro_data_tmp,0,sizeof(pro_data_t));
+    memcpy(&pro_data_tmp,&pro_data,sizeof(pro_data_t));
+
+    pro_data_tmp.cf.dir = 1;
+    pro_data_tmp.cf.sof_flag = 0;
+
+    //get mac
+   
+    get_art_mac(eth0_mac);
+
+    pro_data_tmp.args_len = 0;
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = 6; // mac len
+    
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[0]&0xff; // mac
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[1]&0xff; // mac
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[2]&0xff; // mac
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[3]&0xff; // mac
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[4]&0xff; // mac
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = eth0_mac[5]&0xff; // mac
+
+
+
+    uint8_t data_buf[255] = {0};
+    uint8_t data_len = 0;
+
+    data_len = proto_frame_to_uart(&pro_data_tmp,data_buf);
+    dev_send_uart(data_buf, data_len);
+
+}
+
+void read_version_ack(pro_data_t pro_data)
+{
+    pro_data_t pro_data_tmp;
+    memset((char*)&pro_data_tmp,0,sizeof(pro_data_t));
+    memcpy(&pro_data_tmp,&pro_data,sizeof(pro_data_t));
+
+    pro_data_tmp.cf.dir = 1;
+    pro_data_tmp.cf.sof_flag = 0;
+
+    int version_len = strlen(g_oled_config.version_str);
+
+    pro_data_tmp.args_len = 0;
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = version_len; // version len
+
+    memcpy(&pro_data_tmp.arg[pro_data_tmp.args_len],g_oled_config.version_str,version_len);
+
+    pro_data_tmp.args_len += version_len;
+    
+    uint8_t data_buf[255] = {0};
+    uint8_t data_len = 0;
+
+    data_len = proto_frame_to_uart(&pro_data_tmp,data_buf);
+    dev_send_uart(data_buf, data_len);
+}
+
+void exit_subboard_test_ack(pro_data_t pro_data)
+{
+    pro_data_t pro_data_tmp;
+    memset((char*)&pro_data_tmp,0,sizeof(pro_data_t));
+    memcpy(&pro_data_tmp,&pro_data,sizeof(pro_data_t));
+
+    pro_data_tmp.cf.dir = 1;
+    pro_data_tmp.cf.sof_flag = 0;
+
+    //pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+
+    //标志位写入
+    memset(run_flag,0,sizeof(run_flag));
+    strcpy(run_flag ,RUN_FLAG_AGING);
+    save_cfg_str_to_file(run_flag_file_name, run_flag);
+
+    pro_data_tmp.args_len = 0;
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+    
+    uint8_t data_buf[255] = {0};
+    uint8_t data_len = 0;
+
+    data_len = proto_frame_to_uart(&pro_data_tmp,data_buf);
+    dev_send_uart(data_buf, data_len);
+}
+
+void set_sn_ack(pro_data_t pro_data)
+{
+    unsigned char sn_str[128] = {0};
+
+    pro_data_t pro_data_tmp;
+    //uint8_t arg_buf[256];
+    
+    memset((char*)&pro_data_tmp,0,sizeof(pro_data_t));
+    memcpy(&pro_data_tmp,&pro_data,sizeof(pro_data_t));
+
+    //pro_data_tmp.arg = arg_buf;
+    memcpy(pro_data_tmp.arg,pro_data.arg,pro_data.args_len);
+
+    pro_data_tmp.cf.dir = 1;
+    pro_data_tmp.cf.sof_flag = 0;
+
+    //pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+    uint8_t sn_len = pro_data_tmp.arg[0];
+    int i = 0;
+    for(i = 0; i < sn_len; i++)
+    {
+        sn_str[i] = pro_data_tmp.arg[i+1];
+    }
+
+    sn_str[i]='\0';
+    printf("sn_str:%s\n",sn_str);
+
+    pro_data_tmp.arg[0] = 0;  // err status
+
+    memset(&pro_data_tmp.arg[1],0,pro_data_tmp.args_len);
+    memcpy(&pro_data_tmp.arg[1],&pro_data.arg[0],pro_data.args_len);
+
+    pro_data_tmp.args_len++;
+    
+    
+    uint8_t data_buf[255] = {0};
+    uint8_t data_len = 0;
+
+    char buf[64] = {0};
+    int ret_len = 0;
+    char cmd[128] = {0};
+    sprintf(cmd,"%s%s",SET_SN_CMD,sn_str);
+    kk_execel_cmd(cmd,buf,64,&ret_len);
+    //save_cfg_str_to_file(SN_CFG_FILE,(char *)sn_str);
+
+    data_len = proto_frame_to_uart(&pro_data_tmp,data_buf);
+    dev_send_uart(data_buf, data_len);
+}
+
+void get_sn_ack(pro_data_t pro_data)
+{
+    pro_data_t pro_data_tmp;
+    memset((char*)&pro_data_tmp,0,sizeof(pro_data_t));
+    memcpy(&pro_data_tmp,&pro_data,sizeof(pro_data_t));
+
+    pro_data_tmp.cf.dir = 1;
+    pro_data_tmp.cf.sof_flag = 0;
+
+    //pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+
+    //标志位写入
+    uint8_t sn[128] = {0};
+    int sn_len = 0;
+
+    kk_execel_cmd(GET_SN_CMD,(char *)sn,128,&sn_len);
+
+    //int sn_len = strlen((char *)sn);
+
+    pro_data_tmp.args_len = 0;
+    if(sn_len == 0)
+    {
+         pro_data_tmp.arg[pro_data_tmp.args_len++] = 1;  // err status
+    }
+    else
+    {
+         pro_data_tmp.arg[pro_data_tmp.args_len++] = 0;  // err status
+    }
+    
+   
+    sn_len--;//去掉换行符
+
+    pro_data_tmp.arg[pro_data_tmp.args_len++] = sn_len; // version len
+
+    memcpy(&pro_data_tmp.arg[pro_data_tmp.args_len],(char *)sn,sn_len);
+    pro_data_tmp.args_len += sn_len;
+    
+    uint8_t data_buf[255] = {0};
+    uint8_t data_len = 0;
+
+    data_len = proto_frame_to_uart(&pro_data_tmp,data_buf);
+    dev_send_uart(data_buf, data_len);
+}
+
+/********************/
+
+
+void uart_frame_handle()
+{
+    GW_LOG_DBG("uart_frame_handle\n");
+    uint8_t *data = g_uart_data.data;
+    uint8_t data_len = g_uart_data.data_len;
+    pro_data_t pro_data;
+    //uint8_t pro_data_buf[256];
+
+    //pro_data.arg = pro_data_buf;
+
+    if (get_proto_frame(data, data_len, &pro_data) == false)
+    {
+        return;
+    }
+
+    uart_protocol_print(&pro_data);
+
+    // handle msg
+    switch (pro_data.opcode)
+    {
+        case OPCODE_CONNECT_STATUS_QUERY:
+        {
+            connect_status_ack(pro_data);
+            break;
+        }
+
+        case OPCODE_BURN_MAC:
+        {
+            //暂时不支持
+            set_mac_ack(pro_data);
+            break;
+        }
+
+        case OPCODE_READ_MAC:
+        {
+            read_mac_ack(pro_data);
+            break;
+        }
+
+        case OPCODE_SET_SN:
+        {
+            set_sn_ack(pro_data);
+            break;
+        }
+
+        case OPCODE_GET_SN:
+        {
+            get_sn_ack(pro_data);
+            break;
+        }
+
+        case OPCODE_READ_VERSION:
+        {
+            read_version_ack(pro_data);
+            break;
+        }
+
+         case OPCODE_EXIT_SUBBOARD_TEST:
+        {
+            exit_subboard_test_ack(pro_data);
+            break;
+        }
+        case OPCODE_READ_MAC_FROM_FLASH:
+        {
+            read_flash_mac_ack(pro_data);
+            break;
+        }
+        case OPCODE_SYSTEM_RESTART:
+        {
+            system_restart_ack(pro_data);
+            break;
+        }
+
+        default:
+        {
+            GW_LOG_DBG("gw others opcode %04X ack\n", pro_data.opcode);
+            break;
+        }
+    }
+
+    return;
+}
+

factory_test_src/src/uart_proto.h

+#ifndef __UART_PROTO_H__
+#define __UART_PROTO_H__
+
+#include <syslog.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define GW_LOG(level, fmt, args...)   \
+    do                                  \
+    {                                   \
+        syslog(level, fmt, ##args);     \
+        printf("\n["__FILE__":%d] "fmt,__LINE__, ##args);           \
+    } while(0)
+
+#define GW_LOG_DBG(fmt, args...)      GW_LOG(LOG_DEBUG, fmt, ##args)
+#define GW_LOG_ERR(fmt, args...)      GW_LOG(LOG_ERR, fmt, ##args)
+
+
+//define protocal field size
+#define PRO_SOF_SIZE                    2
+#define PRO_CONTORL_FIELD_SIZE          1
+#define PRO_LEN_SIZE                    2
+#define PRO_CRC_SIZE                    2
+#define PRO_SEQ_SIZE                    2
+
+#define PRO_MIN_DATA_SIZE               4 // channel(1) + opcode(2) + args(1)
+
+#define PRO_LINK_PAKCET_SIZE            13
+#define PRO_APP_PACKET_MIN_SIZE         13
+
+//define field index
+#define PRO_SOF_INDEX                   0
+#define PRO_LEN_INDEX                   (PRO_SOF_INDEX + PRO_SOF_SIZE)
+#define PRO_CF_INDEX                    (PRO_LEN_INDEX + PRO_LEN_SIZE)
+#define PRO_SEQ_INDEX                   (PRO_CF_INDEX + PRO_CONTORL_FIELD_SIZE)
+#define PRO_DATA_INDEX                  (PRO_SEQ_INDEX + PRO_SEQ_SIZE)
+
+//define SOF
+#define PRO_SOF_1                       0xAA
+#define PRO_SOF_2                       0x55
+
+#define DEV_UART_RECV_BUFFER_SIZE 255
+
+
+#define MAC_ADDR 0x00000
+
+/***************OPCODE*******************/
+
+#define OPCODE_CONNECT_STATUS_QUERY         0x0000  //ͨѶ״̬ѯ
+#define OPCODE_BURN_MAC      0x0001
+#define OPCODE_READ_MAC         0x0002
+#define OPCODE_SET_SN       0x0003
+#define OPCODE_GET_SN                0x0004
+#define OPCODE_READ_VERSION          0x0005
+#define OPCODE_EXIT_SUBBOARD_TEST          0x0006
+#define OPCODE_READ_MAC_FROM_FLASH          0x0007
+#define OPCODE_SYSTEM_RESTART          0x0008
+
+
+/*********************************/
+
+typedef enum
+{
+    E_Proto_OK = 0,
+    E_Proto_ERROR,
+} teProto_Status;
+
+
+typedef struct
+{
+    uint8_t data_len;
+    uint8_t data[DEV_UART_RECV_BUFFER_SIZE];
+} uart_data_t;
+
+
+typedef enum
+{
+    SOP_STATE1 = 0,
+    SOP_STATE2,
+
+    LENGTH_STATE1,
+    LENGTH_STATE2,
+
+    CONTROL_FIELD_STATE1,
+    
+    SEQ_STATE1,
+    SEQ_STATE2,
+
+    DATA_STATE,
+
+    CRC16_STATE1,
+    CRC16_STATE2,
+} utp_state_t;
+
+typedef struct
+{
+    uint8_t ack;
+    uint8_t dir;
+    uint8_t sof_flag;
+    uint8_t mf_flag;
+} control_field_t;
+
+typedef struct
+{
+    uint16_t length;
+    control_field_t cf;
+    uint16_t seq;
+    uint8_t ch;
+    uint16_t opcode;
+    uint16_t args_len;
+    uint8_t arg[256];
+} pro_data_t;
+
+int my_system(const char * cmd);
+
+uint32_t make_crc32(uint8_t *msg, uint16_t len);
+uint16_t make_crc16(uint8_t *msg, uint16_t len);
+
+uint8_t cf_to_uint8_t(control_field_t *cf);
+
+uint8_t pro_check_uart_frame(uint8_t *data, uint16_t data_len);
+void dev_send_uart(uint8_t *data, uint16_t data_len);
+int get_proto_frame(uint8_t *data, uint16_t data_len, pro_data_t *pro_data);
+
+void pro_send_link_ack(pro_data_t *pro_data);
+
+
+uint8_t proto_frame_to_uart(pro_data_t *pro_data, uint8_t *uart_data);
+
+int get_uart_frame(uint8_t * buf,int len);
+void uart_frame_handle();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __DEV_PROTO_H__ */
+

makefile

@@ -21,6 +21,7 @@ SUBDIRS                 += common/nanomsg
 SUBDIRS                 += common/ev
 SUBDIRS                 += common/sqlite
 SUBDIRS                 += common/hal
+SUBDIRS                 += factory_test_src/src
 #SUBDIRS                 += common/zlog
 #SUBDIRS                 += platform/zigbee