Linux-C 使用UDP实现的局域网聊天小程序

桃扇骨 2022-02-28 12:16 347阅读 0赞

### **Linux-C 使用UDP实现的局域网聊天小程序** ###

**一、简述**

**      记--使用UDP协议实现的局域网聊天小程序，模仿飞秋的上下线通知功能（广播），能够简单的文字聊天，向指定好友发送消息，群发消息(广播)，传输文件（tcp），使用http获取网络时间。**

**    例子打包：链接: https://pan.baidu.com/s/18cXt-qMd-Ef-4QxmuFgBhQ 提取码: quu9 **

**二、效果**

**       在开发板与Ubuntu进行测试   **![20181211101209447.gif][]

注：Ubuntu与开发板在同一局域网内 且能够ping通。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmZlaWJ1eWk_size_16_color_FFFFFF_t_70][]

**三、工程结构**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmZlaWJ1eWk_size_16_color_FFFFFF_t_70 1][]

**四、源文件**

**catch\_signal.c文件**

#include <stdlib.h>
    #include <unistd.h>
    
    #include "catch_signal.h"
    #include "send_udp_msg.h"
    
    //Ctrl+C信号处理函数
    void catch_sigint(int arg)
    {
    	//广播下线 
    	send_bromsg(g_socket_fd, "192.168.13.255", g_port, "###exit");
    	
    	close(g_socket_fd);
    	sleep(1);
    	g_socket_fd = 0;
    	//退出整个进程 
    	exit(0);
    	
    }

**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 != 7)
        #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;
            }
            else
            {
                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);
    }

**cJSON\_Utils.c文件 (代码有一千多行，不方便贴)  
gettime.c文件**

#include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include "cJSON.h"
    #include "gettime.h"
    
    //演示如何实现一个HTTP请求  与JSON 数据的解析 
    //编译命令 gcc gettime.c  ~/cJSON/cJSON.c  ~/cJSON/cJSON_Utils.c  -o gettime  -I/home/gec/cJSON 
    
    int  print_json(char *string, char *ret_val)
    {
    	
    	//判断字符串是否为NULL 
    	if(string == NULL)
    	{
    		printf("string is NULL\n");
    		return -1;
    	}
    	
    
    	//把该字符串数据转换成JSON数据  (对象)
    	cJSON *root=cJSON_Parse(string);
    		  if(root == NULL)
    		  {
    			  printf("parse error\n");
    			  return -1;
    		  }
    	
    	//获取数据 
    	cJSON *value = cJSON_GetObjectItem(root,"sysTime2");
    		  if(value == NULL)
    		  {
    			  printf("GetObjec error\n");
    			  return -1;
    		  }
    	strcpy(ret_val, cJSON_Print(value));
    	//printf("当前时间=%s\n",cJSON_Print(value));
    	
    	return 1;
    	
    	
    }
    
    //从网络获取当前时间
    int get_time(char *time)
    {
    	int port = 80;
    	char ip[32] = "183.60.139.252";
    
    	//1.创建tcp类型的套接字
    	int tcp_sock = socket(AF_INET,SOCK_STREAM,0);
    	if(tcp_sock==-1)
    	{
    		perror("socket error!\n");
    		return -1;
    	}
    	
    	//2.设置HTTP服务器的地址    利用浏览器去查看对应的HTTP服务器的IP地址  也用 系统接口获取
    	struct sockaddr_in server_addr;
    	bzero(&server_addr,sizeof(server_addr));
    	server_addr.sin_family= AF_INET; 
    	server_addr.sin_addr.s_addr=inet_addr(ip); //时间网站的ip
    	server_addr.sin_port=htons(port);//端口
    	
    	
    	//3.连接网上提供时间那个网页的ip,
    	int ret = connect(tcp_sock,(struct sockaddr *)(&server_addr),sizeof(server_addr));
    	if(ret==-1)
    	{
    		perror("connect failed!\n");
    		return -1;
    	}
    
    	//定义一个HTTP请求的数据BUF   重点！！！
    	char cmd[1024] = {0};
    	//获取当前时间：http://quan.suning.com/getSysTime.do
    	strcpy(cmd,"GET /getSysTime.do HTTP/1.1\r\n");
    	strcat(cmd, "Host: quan.suning.com\r\n\r\n");
    	
    	//获取天气：t.weather.sojson.com/api/weather/city/101280101
    	//strcpy(cmd,"GET /api/weather/city/101280101 HTTP/1.1\r\n");
    	//strcat(cmd, "Host: t.weather.sojson.com\r\n\r\n");
    	
    	//发送请求
    	write(tcp_sock, cmd, strlen(cmd));
    	
    	
    	//接收返回的请求信息
    	char rbuf[4096] = {0};
    	read(tcp_sock, rbuf, sizeof(rbuf));
    	//printf("获取到的信息:%s\n",rbuf);
    	
    	 
    	//关闭socket
    	close(tcp_sock);
    	
    	//解析JSON数据
    	ret = print_json(strstr(rbuf, "{"), time);
    	//strstr(rbuf, "{")   -> 查找字符，返回字符出现的首地址
    	if(ret != 1)
    	{
    		return -1;
    	}
    	return 0;
    }

**main.c文件**

#include <stdio.h>
    #include <sys/types.h>         
    #include <sys/socket.h>
    #include <pthread.h>
    #include <netinet/in.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    #include <string.h>
    #include <signal.h>
    
    #include "kernel_list.h"
    #include "user_list.h"
    #include "gettime.h"
    #include "menu.h"
    #include "recv_file.h"
    #include "transfer_file.h"
    #include "send_udp_msg.h"
    #include "recv_udp_msg.h"
    #include "catch_signal.h"
    
    int g_port = 0;//本应用的端口号
    int g_socket_fd = 0;//本应用的通信socket
    struct  list_head  *g_head = NULL;//内核链表头指针
    
    int main(int argc, char * argv[])
    {
    	int port = 12321;//默认端口
    	
    	if(argc > 1)
    	{
    		//从命令行参数获取端口号
    		port = atoi(argv[2]);
    		
    		//判断端口号是否有效
    		if(port <1025 || port >65534)
    		{
    			printf("port invalid: 1024<port<65535 \n");
    			return -1;
    		}
    	}
    	
    	g_port = port;//将port保存到全局
    	
    	//获取当前时间
    	char time[128] = {0};//当前时间
    	int ret = get_time(time);
    	if(ret != 0)
    	{
    		printf("gettime failed!\n");
    	}
    	else
    	{
    		printf("\n   当前时间：%s\n", time);
    	}
    	
    	//创建UDP通信socket
    	int udp_socket = socket(AF_INET, SOCK_DGRAM, 0);
    	if(udp_socket == -1)
    	{
    		perror("socket error\n");
    		return -1;
    	}
    	
    	g_socket_fd = udp_socket;
    	
    	//设置端口复用的属性  
    	int on=1; //1开启 0关闭
        ret = setsockopt(udp_socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));	
    	if(ret < 0)
    	{
    		perror("setsockopt fail\n");
    		return -1;
    	}
    	
    	//绑定IP地址
    	struct sockaddr_in local_addr;
    	local_addr.sin_family=AF_INET;//IPv4协议
    	local_addr.sin_port = htons(port);//监听端口
    	local_addr.sin_addr.s_addr=htonl(INADDR_ANY);//"0.0.0.0"让系统自动检测主机IP，并绑定
    	ret = bind(udp_socket,(struct sockaddr *)&local_addr,sizeof(local_addr));
    	if(ret == -1)
    	{
    		perror("bind error\n");
    		return -1;
    	}
    	
    	//开启发送广播数据功能
    	ret = setsockopt(udp_socket, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
    	if(ret == -1)
    	{
    		perror("stsockopt error\n");
    		return -1;
    	}
    	
    	//创建头节点
    	g_head =  (struct  list_head*)malloc(sizeof(struct  list_head));
    	//初始化头节点 
    	INIT_LIST_HEAD(g_head);
    	
    	//开启接收线程
    	pthread_t recv_thread;
    	ret = pthread_create(&recv_thread, NULL, recv_msg, (void*)&udp_socket);
    	if(ret !=0 )
    	{
    		printf("create thread error\n");
    		return -1;
    	}
    	
    	
    	//广播上线
    	send_bromsg(udp_socket, "192.168.13.255", port, "###login");
    	
    	//捕捉Ctrl+C信号
    	signal(SIGINT,catch_sigint);
    	
    	//发送数据
    	char buf[1024] = {0};//要发送的数据缓冲区
    	struct sockaddr_in dest_addr = {0};
    	dest_addr.sin_family = AF_INET;//IPv4协议
    	int dest_port = 0;//目标端口
    	char dest_ip[32] = {0};//目标IP地址
    	int choice = -1;
    	int run = 1;
    	
    	while(run)
    	{
    		menu();//显示菜单
    		//接收用户的选择
    		scanf("%s", buf);
    		sscanf(buf, "%1d", &choice);
    		memset(buf,0,sizeof(buf));
    		
    		switch(choice)
    		{
    			case 1://向指定好友发送信息
    				printf("[ip port msg]:\n");
    				scanf("%s %d %s", dest_ip, &dest_port, buf);
    				dest_addr.sin_port = htons(dest_port);
    				dest_addr.sin_addr.s_addr = inet_addr(dest_ip);
    				send_msg(udp_socket, &dest_addr, buf);
    				memset(dest_ip,0,sizeof(dest_ip));
    				break;
    			case 2://广播， 向所有好友发送信息
    				printf("[enter massgae]:\n");
    				scanf("%s", buf);
    				send_bromsg(udp_socket, "192.168.13.255", port, buf);
    				break;
    			case 3://展示好友列表
    				show_user_list(g_head);
    				break;
    			case 4://传输文件
    				printf("[ip port]:\n");
    				scanf("%s %d", dest_ip, &dest_port);
    				dest_addr.sin_port = htons(dest_port);
    				dest_addr.sin_addr.s_addr = inet_addr(dest_ip);
    				send_msg(udp_socket, &dest_addr, "request tansfer file");
    				
    				//transfer_flag = 0;//不传输文件，等待对方接受
    				transfer_file(dest_ip, dest_port);
    				//transfer_flag = 0;
    				memset(dest_ip,0,sizeof(dest_ip));
    				break;
    			case 5:
    				memset(time, 0, sizeof(time));
    				ret = get_time(time);
    				if(ret != 0)
    				{
    					printf("gettime failed!\n");
    				}
    				else
    				{
    					printf("\n   当前时间：%s\n", time);
    				}
    				break;
    			case 0://退出程序,广播下线
    				send_bromsg(udp_socket, "192.168.13.255", port, "###exit");
    				run = 0;
    				break;
    			default:
    				break;
    		}
    		
    		fflush(stdin);//清空输入缓冲区
    		
    	}
    	
    	//关闭socket
    	close(udp_socket);
    	g_socket_fd = 0;
    	
    	return 0;
    }

**menu.c文件**

#include <stdio.h>
    #include "menu.h"
    
    //功能选择菜单
    void menu()
    {
    	/*
    	printf("\n  +------------------------------+\n");
    	printf("  | 1 send massage to a friends  |\n");
    	printf("  | 2 send massage to all friend |\n");
    	printf("  | 3 show the user list         |\n");
    	printf("  | 4 transfer file              |\n");
    	printf("  | 5 current time               |\n");
    	printf("  | 0 exit                       |\n");
    	printf("  +------------------------------+\n");
    	printf("Plead enter you choice:\n");*/
    	//printf("\033c");//清屏
    	printf("\n  +--------------------+\n");
    	printf("  | 1 发送给指定好友   |\n");
    	printf("  | 2 群发给好友       |\n");
    	printf("  | 3 好友列表         |\n");
    	printf("  | 4 发送文件         |\n");
    	printf("  | 5 当前时间         |\n");
    	printf("  | 0 退出             |\n");
    	printf("  +--------------------+\n");
    	printf("  请选择(0~5):\n");
    }

**recv\_file.c文件**

#include <stdio.h>
    #include <sys/types.h>         
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    #include <string.h>
    #include <signal.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <libgen.h> //basename()
    #include <fcntl.h>
    
    #include "recv_file.h"
    
    int recv_file(int port)
    {
    	//创建tcp通信socket
    	int tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
    	if (tcp_socket == -1)
    	{
    		perror("create socketfd failed\n");
    		return -1;
    	}
    	
    	
    	//绑定地址
    	struct sockaddr_in local_addr;
    	local_addr.sin_family = AF_INET;
    	local_addr.sin_port = htons(port); 
    	local_addr.sin_addr.s_addr = INADDR_ANY;
    	int ret = bind(tcp_socket, (struct sockaddr *)&local_addr, sizeof(local_addr));
    	if (ret == -1)
    	{
    		perror("bind  failed\n");
    		return -1;
    	}
    	
    	
    	/* 设置监听模式 */
    	ret = listen(tcp_socket, 5);
    	if(ret == -1)
    	{
    		perror("listen is fail\n");
    		return -1;
    	}
    	
    	
    	//客户端地址信息
    	struct sockaddr_in client_addr={0};
    	int len = sizeof(client_addr);
    		 
    	printf("ready receive!!!!\n");
    	
    				
    	//通信socket
    	int new_socket = 0;
    	
    	while (1)
    	{
    		/* 接受对方的链接请求 */
    		new_socket = accept(tcp_socket,(struct sockaddr *)&client_addr,&len);
    		if(new_socket < 0)
    		{
    			perror("accept error\n");
    			continue;
    		}
    		
    		//输出对方的IP地址信息
    		printf("client connected [%s:%d]\n",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));
    				
    		char file_len[16] = {0};//文件长度
    		char file_name[128] = {0};//文件名称
    		char buf[1024] = {0};//数据缓冲区
    		//读取文件大小和文件名称
    		read(new_socket, buf, sizeof(buf));
    		
    		strncpy(file_len, buf, sizeof(file_len));//取出文件大小
    		strncpy(file_name, buf+sizeof(file_len), sizeof(file_name));//取出文件名称
    		
    		printf(" file name:[%s] file size:[%s] Byte \n",file_name, file_len);
    		
    		//新的文件名
    		sprintf(buf, "recv-%s", file_name);
    		
    		//创建新文件
    		int fd = open(buf, O_RDWR | O_CREAT | O_TRUNC, 0666);
    		
    		int size = atoi(file_len);//文件大小
    		int write_len = 0;//记录已写入的字节数
    		//接收文件
    		while(1)
    		{
    			bzero(buf, 1024);
    			
    			//接收文件数据
    			ret = read(new_socket, buf, sizeof(buf));
    			if( ret <= 0)
    			{
    				printf("\n receive file[recv-%s] done!!!\n", file_name);
    				break;
    			}
    			
    			//将数据写入文件	
    			write(fd, buf, ret);
    			
    			//统计写入的字节数
    			write_len += ret;
    
    			printf("uploading %.2f%% \n", (float)write_len/size * 100);
    			
    		}
    		
    		break;
    		
    	}
    	
    	//关闭socket
    	close(new_socket);
    	close(tcp_socket);
    	return 0;
    }

**recv\_udp\_msg.c文件**

**send\_udp\_msg.c文件**

#include <sys/types.h>         
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    #include <string.h>
    #include <signal.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    
    #include "send_udp_msg.h"
    
    
    //向指定的地址发送信息
    void send_msg(int udp_socket, struct sockaddr_in *dest_addr, char *msg)
    {
    	if( g_socket_fd != 0)
    	{
    		sendto(udp_socket, msg, strlen(msg), 0, (struct sockaddr *)dest_addr,sizeof(*dest_addr));
    	}
    }
    
    
    
    //发送广播数据
    void send_bromsg(int socket_fd,char *ip, int port, char *buf)
    {
    	//设置要广播的地址
    	struct sockaddr_in bro_addr;
    	memset(&bro_addr, 0, sizeof(bro_addr));//清空原有数据
    	bro_addr.sin_family = AF_INET;//IPv4协议
    	bro_addr.sin_port = htons(port);//设置广播端口
    	bro_addr.sin_addr.s_addr = inet_addr(ip);  //设置广播地址
    	
    	//向广播地址发送广播数据 
    	sendto(socket_fd, buf, strlen(buf), 0, (struct sockaddr *)&bro_addr,sizeof(bro_addr));
    }

**transfer\_file.c文件**

#include <stdio.h>
    #include <sys/types.h>         
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    #include <string.h>
    #include <signal.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <libgen.h> //basename()
    #include <fcntl.h>
    
    #include "transfer_file.h"
    
    
    //传输文件
    int transfer_file(char *ip, int port)
    {
    	printf("wait for accept...\n");
    	
    	//创建TCP通信socket
    	int tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
    	if(tcp_socket == -1)
    	{
    		perror("create socketfd is fail\n");
    		return -1;
    	}
    	
    	//目的地址
    	struct sockaddr_in dest_addr;
    	dest_addr.sin_family = AF_INET;
    	dest_addr.sin_port = htons(port); 	
    	dest_addr.sin_addr.s_addr = inet_addr(ip);
    	
    	int ret = -1;
    	//请求连接目标地址
    	while(1)
    	{
    		ret = connect(tcp_socket, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
    		if(ret == 0)//连接成功
    		{
    			break;
    		}
    		printf(".");
    		sleep(1);
    	}
    	printf("\nConnect succeed!\n");
    	
    	char file_path[128] = {0};//文件路径
    	char file_info[2048] = {0};//文件信息
    	
    	
    	char buf[1024] = {0};
    	
    	//获取用户输入的文件路径
    	printf("Please enter file path: ");
    	scanf("%s", file_path);
    	
    	//从文件路径中获取文件名，如"test/a.txt" ==> "a.txt"
    	char file_name[128] = {0};
    	strncpy(file_name, basename(file_path), sizeof(file_name));
    	
    	//打开文件
    	int fd = open(file_path, O_RDWR);
    	if (fd == -1)
    	{
    		printf("open [%s]  failed", file_path);
    		return -1;
    	}	
    	
    	//计算文件大小
    	int len = lseek(fd, 0, SEEK_END);
    
    	//文件光标偏移到文件开始位置
    	lseek(fd, 0, SEEK_SET);
    	
    	
    	//将文件大小和文件名存放到file_info
    	sprintf(file_info, "%d", len);
    	strcpy(file_info + 16, file_name);
    		
    	
    	// 将需要上传的文件名告诉对方 
    	write(tcp_socket, file_info, 144);	
    
    	int send_len = 0;//记录发送了多少字节
    	
    	while (1)
    	{	
    		bzero(buf, sizeof(buf));
    		//读取数据
    		ret = read(fd, buf, sizeof(buf));
    		if (ret <= 0)
    		{
    			printf("send file[%s] succeed!!!!", file_name);
    			break;
    		}
    			
    		//发送数据
    		write(tcp_socket, buf, ret);
    		
    		send_len += ret;//统计发送了多少字节
    		
    		//上传文件的百分比 
    		printf("uploading %.2f%%\n", (float)send_len/len * 100);
    	}
    	
    	// 关闭文件 
    	close(fd);
    	//关闭通信socket 
    	close(tcp_socket);
    	
    	return 0;
    }

**user\_list.c文件**

#include <stdio.h>
    #include "kernel_list.h"
    #include <stdlib.h>
    #include <string.h>
    
    //用户自定义的内核链表结构体
    typedef struct  s_node
    {
    	char  ip[32];  //数据域
    	int   port;
    	struct list_head  list; //地址域
    }Node;
    
    //加入新节点到内核链表中
    int kerlist_add(struct  list_head *head, char *ip, int port)
    {
    	//创建新的节点
    	Node  *new_node =  (Node*)malloc(sizeof(Node));
    	if(new_node ==NULL)
    	{
    		printf("creat node fail\n");
    		return -1;
    	}
    	  
    	//填充节点数据
    	new_node->port  = port;   
    	strcpy(new_node->ip,ip);
    
    	//插入新节点
    	list_add_tail(&new_node->list,head);
    
    	return  1;
    }
    
    //显示好友列表
    void show_user_list(struct  list_head *head)
    {
    	if(head == NULL)
    	{
    		return;
    	}
    	struct list_head  *pos = NULL;
    	int i = 0;
        //遍历链表
    	printf("\n------------好友列表----------------\n");
    	list_for_each(pos,head)
    	{	
    		//得到大结构体的数据
    		Node  *p = list_entry(pos, Node, list);
    	    printf("当前用户号:%d IP:%s port:%d\n",++i,p->ip,p->port);
    	
    	}
    	printf("\n--------当前在线用户数：%d 个------------\n", i);
    	
    }
    
    //检查链表中是否有相同的IP地址
    int is_exist(struct  list_head *head, char *ip)
    {
    	struct list_head  *pos = NULL;
    	int i=0;
        //遍历链表
    	list_for_each(pos,head)
    	{						  	//得到大结构体的数据
    		Node  *p = list_entry(pos, struct s_node,list);
    		
    		if(strcmp(p->ip,ip) == 0)
    		{
    			return 1;  //检查到相同则返回1 
    		}
    	}
    	
    	return 0;
    }
    
    //删除节点函数   
    void del_node(struct list_head  *head, char  *ip)
    {
    	//遍历链表找到需要删除的数据
    	struct list_head  *pos  = head->next;
    	struct list_head  *tmp  = NULL;
    	list_for_each_safe(pos,tmp,head)  //安全的遍历
    	{
    		//取数据  tmp 保存大结构体的首地址
    		Node  *tmp  =  list_entry(pos ,Node, list);
    			
    		if(strcmp(tmp->ip,ip)==0)
    		{
    			//删除节点
    			list_del(pos);
    			
    			//释放堆空间 
    			free(tmp);
    		}
    	}	
    		
    }

[20181211101209447.gif]: /images/20220228/9854cf7dd32841898d259a0ace1ab307.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmZlaWJ1eWk_size_16_color_FFFFFF_t_70]: /images/20220228/153d7f90cc144924abad374545f7a499.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmZlaWJ1eWk_size_16_color_FFFFFF_t_70 1]: /images/20220228/94e95947064a4d25ba322be218c34de0.png