void Client::sendChat(std::string str)
	{
        if((_state != ConnectionState::connected) || (_socket == NULL)){
            if(_chatlistener != NULL)
			{
				_chatlistener->onSendChatDone(ResultCode::connection_error);
			}
            return;
        }
		if(str.length() >= 512)
		{
			if(_chatlistener != NULL)
				_chatlistener->onSendChatDone(ResultCode::bad_request);

			return;
		}

		std::string payload;
		int len;

		cJSON *payloadJSON;
		payloadJSON = cJSON_CreateObject();
		cJSON_AddStringToObject(payloadJSON, "chat" ,str.c_str());
		char *cRet = cJSON_PrintUnformatted(payloadJSON);
		payload = cRet;

		byte * req = buildWarpRequest(RequestType::chat, payload, len);

		char *data = new char[len];
		for(int i=0; i< len; ++i)
		{
			data[i] = req[i];
		}

		_socket->sockSend(data, len);

		delete[] data;
		delete[] req;
		cJSON_Delete(payloadJSON);
		free(cRet);
	}

static bool getacc_allmanacc(data_getacc_reply *data_reply) {
	int count = 0;
	cJSON *root;
	relater_inf *p = protodata->relaterlist.head;

	root = cJSON_CreateArray();

	while (p != NULL) {
		if (p->right == RELATER_AUTHORITY_MAN) {
			cJSON *user = cJSON_CreateObject();
			cJSON_AddStringToObject(user, GETACC_INFO_ACCOUNT, p->username);
			cJSON_AddNumberToObject(user, GETACC_INFO_RIGHT, p->right);
			cJSON_AddItemToArray(root, user);
			count++;
		}
		p = p->next;
	}
	data_reply->json_info = root;
	data_reply->ret = count;
	return true;
}

/***************************************************************************
  Function:       package_json_callback 
  Description:    发到5017端口的callback数据格式
  Input:          
                  
  Output:      输出封装好的callback数据的地址   
  Return:       
  Others:         
****************************************************************************/
char *package_json_callback(int type,char *pic_name,int num)
{
    cJSON *root,*fmt;
    char *out;	
    //Our "Video" datatype: 
    root=cJSON_CreateObject();
	cJSON_AddNumberToObject(root,"msgtype",0);
	cJSON_AddNumberToObject(root,"mainid",2);
	cJSON_AddNumberToObject(root,"subid",6);
	cJSON_AddNumberToObject(root,"status",type );
	cJSON_AddNumberToObject(root,"pic_count",num);
	if(type == 0)
	{
		
		cJSON_AddStringToObject(root,"pic_name",pic_name);

	}
    out=cJSON_PrintUnformatted(root);
    cJSON_Delete(root);
    return out; 
}

/*
 * Special properties. This values can modified with the web interface.
 * I.e. angle of kinect, nmbr of areas, position of areas, minimal blob size.
 */
cJSON* PrintSettings::loadDefaults()
{
	cJSON* root = cJSON_CreateObject();	
	cJSON_AddStringToObject(root, "kind", "printSettings");

	cJSON* html = cJSON_CreateArray();	
	cJSON_AddItemToArray(html, jsonIntField("firstLayer",1,1,10000,100) );
	cJSON_AddItemToArray(html, jsonIntField("lastLayer",10000,1,10000,100) );
	cJSON_AddItemToArray(html, jsonDoubleField("normalLayerExposure",12,1,100,10) );
	cJSON_AddItemToArray(html, jsonIntField("nbrAttachLayers",3,1,100,10) );
	cJSON_AddItemToArray(html, jsonDoubleField("attachLayerExposure",60,1,300,10) );

	cJSON_AddItemToObject(root, "html", html);

	/* Point information for repoke 
	cJSON* areas = cJSON_CreateArray();	
	cJSON_AddItemToArray(areas, jsonArea(1,320.0,240.0,100.0) );
	cJSON_AddItemToObject(root, "areas", areas);
	*/
	return root;
}

int createServerUserLogin(int sock,int serverid,int isSuccess,char* username){
	server_header_2_t* header = createServerHeader(serverid,COMMAND_OTHER_MESSAGE,MESSAGE_TYPE_USER_LOGIN);
	cJSON* json = cJSON_CreateObject();
	cJSON_AddNumberToObject(json,"result",isSuccess);
	cJSON_AddStringToObject(json,"username",username);	
	//cJSON_AddStringToObject(json,"userid","userid");
	char* str = cJSON_Print(json);	
	int total = sizeof(server_header_2_t)+sizeof(uint16_t)+strlen(str);
	void* bufs = malloc(total);
	void* buf = bufs;
	header->total = total;
	memcpy(buf,header,sizeof(server_header_2_t));
	buf += sizeof(server_header_2_t);
	*(uint16_t*)buf = htons(strlen(str));
	buf += sizeof(uint16_t);
	memcpy(buf,str,strlen(str));
	int ret =send(sock,bufs,total,0);
	free(bufs);
	cJSON_Delete(json);
	//free(str);
	return ret;	
}

int createClientUserGetFriends(int sock,int clienttype,char* username){
	client_header_2_t* header = createClientHeader(COMMAND_OTHER_MESSAGE,MESSAGE_TYPE_USER_GET_FRIEND,clienttype);	
	cJSON* json = cJSON_CreateObject();
	cJSON_AddStringToObject(json,"username",username);		
	char* str = cJSON_Print(json);	
	int total = sizeof(client_header_2_t)+sizeof(uint16_t)+strlen(str);
	void* bufs = malloc(total);
	void* buf = bufs;
	header->total = total;
	memcpy(buf,header,sizeof(client_header_2_t));	
	buf += sizeof(client_header_2_t);
	*(uint16_t*)buf = htons(strlen(str));	
	buf += sizeof(uint16_t);
	memcpy(buf,str,strlen(str));
	dump_data(bufs,total);
	int ret =send(sock,bufs,total,0);
	printf("%d\n",ret);
	free(bufs);	
//	free(str);
	cJSON_Delete(json);	
	return ret;	
}

/* Do a printf to stderr or log file as appropriate, then exit. */
void
iperf_errexit(struct iperf_test *test, const char *format, ...)
{
    va_list argp;
    char str[1000];

    va_start(argp, format);
    vsnprintf(str, sizeof(str), format, argp);
    if (test != NULL && test->json_output && test->json_top != NULL) {
	cJSON_AddStringToObject(test->json_top, "error", str);
	iperf_json_finish(test);
    } else
	if (test && test->outfile) {
	    fprintf(test->outfile, "iperf3: %s\n", str);
	}
	else {
	    fprintf(stderr, "iperf3: %s\n", str);
	}
    va_end(argp);
    iperf_delete_pidfile(test);
    exit(1);
}

cJSON *socket_end_serialize(struct socket_end_st *se) {
	cJSON *result, *pipelines;
	char keybuf[SHAREDKEY_BYTESIZE*4], byte[8];
	int i;

	result = cJSON_CreateObject();
	pipelines = cJSON_CreateArray();

	cJSON_AddNumberToObject(result, "id", se->id);
	keybuf[0]=0;
	for (i=0;i<SHAREDKEY_BYTESIZE;++i) {
		snprintf(byte, 8, "%.2x ", se->shared_key[i]);
		strcat(keybuf, byte);
	}
	cJSON_AddStringToObject(result, "SharedKey", keybuf);
	cJSON_AddNumberToObject(result, "SendBuffer", streambuf_nr_bytes(se->send_buffer));
	for (i=se->pipeline_1; i!=-1; i=se->pipeline_end[i]->next_id) {
		cJSON_AddItemToArray(pipelines, pipeline_end_serialize(se->pipeline_end[i]));
	}
	cJSON_AddItemToObject(result, "Pipelines", pipelines);
	return result;
}

Eina_Bool
azy_content_serialize_request_json(Azy_Content *content)
{
   Eina_List *l;
   Eina_Value *v;
   cJSON *object, *params;
   char *msg;

   if ((!content) || (content->buffer))
     return EINA_FALSE;

   object = cJSON_CreateObject();
   cJSON_AddStringToObject(object, "method", content->method);

   if (content->params)
     {
        params = cJSON_CreateArray();
        EINA_LIST_FOREACH(content->params, l, v)
          cJSON_AddItemToArray(params, azy_value_serialize_json(v));

        cJSON_AddItemToObject(object, "params", params);
     }
   cJSON_AddNumberToObject(object, "id", content->id);

   if (eina_log_domain_level_check(azy_log_dom, EINA_LOG_LEVEL_DBG))
     msg = cJSON_Print(object);
   else
     msg = cJSON_PrintUnformatted(object);

   if(!msg) goto free_object;
   azy_content_buffer_set_(content, (unsigned char *)msg, strlen(msg));

   cJSON_Delete(object);
   return EINA_TRUE;

free_object:
   cJSON_Delete(object);
   return EINA_FALSE;
}

int CRedWoodDataParse::AddSensorDataToJson(cJSON* sensorJson, cJSON* descJson)
{
    if (sensorJson == NULL)
        return -1;

    cJSON* jsonSon        = NULL;
    cJSON* jsonGrandChild = NULL;
    jsonSon = sensorJson->child;

    while (jsonSon) {
        jsonGrandChild = jsonSon->child;

        if (jsonGrandChild) {
            //get grandchild value
            switch (jsonGrandChild->type) {
            case cJSON_Number:
                cJSON_AddNumberToObject(descJson, 
                    jsonSon->string, jsonGrandChild->valuedouble);
                break;

            case cJSON_String:
                cJSON_AddStringToObject(descJson, 
                    jsonSon->string, jsonGrandChild->valuestring);
                break;

            default:
                break;
            }
        }
        else {
            cJSON_AddNullToObject(descJson, jsonSon->string);
        }

        jsonSon = jsonSon->next;
    }

    return 0;
}

// Print JSON header to gzout
static void bubble_caller_print_header(gzFile gzout, const char* out_path,
                                       BubbleCallingPrefs prefs,
                                       cJSON **hdrs, size_t nhdrs,
                                       const dBGraph *db_graph)
{
  size_t i;

  // Construct cJSON
  cJSON *json = cJSON_CreateObject();

  cJSON_AddStringToObject(json, "file_format", "CtxBubbles");
  cJSON_AddNumberToObject(json, "format_version", BUBBLE_FORMAT_VERSION);

  // Add standard cortex headers
  json_hdr_make_std(json, out_path, hdrs, nhdrs, db_graph);

  // Add parameters used in bubble calling to the header
  json_hdr_augment_cmd(json, "bubbles", "max_flank_kmers",  cJSON_CreateInt(prefs.max_flank_len));
  json_hdr_augment_cmd(json, "bubbles", "max_allele_kmers", cJSON_CreateInt(prefs.max_allele_len));
  cJSON *haploids = cJSON_CreateArray();
  for(i = 0; i < prefs.num_haploid; i++)
    cJSON_AddItemToArray(haploids, cJSON_CreateInt(prefs.haploid_cols[i]));
  json_hdr_augment_cmd(json, "bubbles", "haploid_colours", haploids);

  // Write header to file
  json_hdr_gzprint(json, gzout);

  // Print comments about the format
  gzputs(gzout, "\n");
  gzputs(gzout, "# This file was generated with McCortex\n");
  gzputs(gzout, "#   written by Isaac Turner <[email protected]>\n");
  gzputs(gzout, "#   url: "CORTEX_URL"\n");
  gzputs(gzout, "# \n");
  gzputs(gzout, "# Comment lines begin with a # and are ignored, but must come after the header\n");
  gzputs(gzout, "\n");

  cJSON_Delete(json);
}

static void _set_cjson_field(E_KRType type, char *name, U_KRValue *value, cJSON *json) 
{ 
    switch(type) 
    { 
        case KR_TYPE_INT: 
            cJSON_AddNumberToObject(json, name, value->i);
            break;
        case KR_TYPE_LONG: 
            cJSON_AddNumberToObject(json, name, value->l);
            break;
        case KR_TYPE_DOUBLE: 
            cJSON_AddNumberToObject(json, name, value->d);
            break;
        case KR_TYPE_POINTER:
            cJSON_AddNumberToObject(json, name, (long )(value->p));
            break;
        case KR_TYPE_STRING: 
            cJSON_AddStringToObject(json, name, value->s?value->s:" ");
            break;
        default: 
            return; 
    } 
} 

void four_moveGreedy(char* charOut) {
	{
		cJSON* objectOut = cJSON_CreateObject();
		cJSON* objectIn = NULL;
		
		{
			cJSON_AddStringToObject(objectOut, "strFunction", "four_moveGreedy");
		}
		
		{
			zeromq_send(objectOut);
			
			objectIn = zeromq_recv();
		}
		
		{
			strcpy(charOut, cJSON_GetObjectItem(objectIn, "strOut")->valuestring);
		}
		
		cJSON_Delete(objectOut);
		cJSON_Delete(objectIn);
	}
}

int Parser_PackScrrenshotError(char * errorStr, char **outputStr)
{
	char * out = NULL;
	int outLen = 0;
	cJSON *pSUSICommDataItem = NULL;
	if(errorStr == NULL || outputStr == NULL) return outLen;

	pSUSICommDataItem = cJSON_CreateObject();
	if(pSUSICommDataItem)
	{
		cJSON_AddStringToObject(pSUSICommDataItem, SCREENSHOT_ERROR_REP, errorStr);
	}

	out = cJSON_PrintUnformatted(pSUSICommDataItem);
	outLen = strlen(out) + 1;
	*outputStr = (char *)(malloc(outLen));
	memset(*outputStr, 0, outLen);
	strcpy(*outputStr, out);
	cJSON_Delete(pSUSICommDataItem);	
	printf("%s\n",out);	
	free(out);
	return outLen;
}

OCStackResult BuildActionJSON(OCAction* action, unsigned char* bufferPtr, uint16_t *remaining)
{
    OCStackResult ret = OC_STACK_ERROR;
    cJSON *json;
    cJSON *body;

    char *jsonStr;
    uint16_t jsonLen;

    OC_LOG(INFO, TAG, PCF("Entering BuildActionJSON"));
    json = cJSON_CreateObject();

    cJSON_AddItemToObject(json, "rep", body = cJSON_CreateObject());

    OCCapability* pointerCapa = action->head;
    while (pointerCapa)
    {
        cJSON_AddStringToObject(body, pointerCapa->capability, pointerCapa->status);
        pointerCapa = pointerCapa->next;
    }

    jsonStr = cJSON_PrintUnformatted(json);

    jsonLen = strlen(jsonStr);
    if (jsonLen < *remaining)
    {
        strcat((char*) bufferPtr, jsonStr);
        *remaining -= jsonLen;
        bufferPtr += jsonLen;
        ret = OC_STACK_OK;
    }

    cJSON_Delete(json);
    free(jsonStr);

    return ret;
}

    void
    OutofcoreOctreeBaseMetadata::serializeMetadataToDisk ()
    {
      if (LOD_num_points_.empty ())
        return;

      // Create JSON object
      boost::shared_ptr<cJSON> idx (cJSON_CreateObject (), cJSON_Delete);
  
      cJSON* name = cJSON_CreateString (tree_name_.c_str ());
      cJSON* version = cJSON_CreateNumber ( __PCL_OUTOFCORE_VERSION__ );
      cJSON* pointtype = cJSON_CreateString (point_type_.c_str ());
      cJSON* lod = cJSON_CreateNumber (static_cast<double> (levels_of_depth_));

      // cJSON does not allow 64 bit ints.  Have to put the points in a double to
      // use this api, will allow counts up to 2^52 points to be stored correctly
      //or split into LSB MSB?
      std::vector<double> lodPoints_db;
      lodPoints_db.insert (lodPoints_db.begin (), LOD_num_points_.begin (), LOD_num_points_.end ());

      cJSON* numpts = cJSON_CreateDoubleArray ( &(lodPoints_db.front ()), static_cast<int>(lodPoints_db.size ()));

      cJSON_AddItemToObject (idx.get (), "name", name);
      cJSON_AddItemToObject (idx.get (), "version", version);
      cJSON_AddItemToObject (idx.get (), "pointtype", pointtype);
      cJSON_AddItemToObject (idx.get (), "lod", lod);
      cJSON_AddItemToObject (idx.get (), "numpts", numpts);
      cJSON_AddStringToObject(idx.get(), "coord_system", coordinate_system_.c_str());

      char* idx_txt = cJSON_Print (idx.get ());

      std::ofstream f (metadata_filename_.string ().c_str (), std::ios::out | std::ios::trunc);
      f << idx_txt;
      f.close ();

      free (idx_txt);
    }

bool boosted_trees::write_boosted_trees_base_info_to_file(const ml_string &path) const {
  
  cJSON *json_boosted = cJSON_CreateObject();
  if(!json_boosted) {
    log_error("couldn't create json object from boosted trees\n");
    return(false);
  }

  cJSON_AddStringToObject(json_boosted, "object", "boosted_trees");
  cJSON_AddNumberToObject(json_boosted, "type", (double)type_);
  cJSON_AddNumberToObject(json_boosted, "index_of_feature_to_predict", index_of_feature_to_predict_);
  cJSON_AddNumberToObject(json_boosted, "number_of_trees", number_of_trees_);
  cJSON_AddNumberToObject(json_boosted, "learning_rate", learning_rate_);
  cJSON_AddNumberToObject(json_boosted, "seed", seed_);
  cJSON_AddNumberToObject(json_boosted, "max_tree_depth", max_tree_depth_);
  cJSON_AddNumberToObject(json_boosted, "subsample", subsample_);
  cJSON_AddNumberToObject(json_boosted, "min_leaf_instances", min_leaf_instances_);
  cJSON_AddNumberToObject(json_boosted, "features_to_consider_per_node", features_to_consider_per_node_);

  bool status = write_model_json_to_file(path, json_boosted);
  cJSON_Delete(json_boosted);
  
  return(status);
}

void passthroughCanMessage(Listener* listener, int id, uint64_t data) {
    cJSON *root = cJSON_CreateObject();
    cJSON_AddNumberToObject(root, ID_FIELD_NAME, id);

    char encodedData[67];
    union {
        uint64_t whole;
        uint8_t bytes[8];
    } combined;
    combined.whole = data;

    sprintf(encodedData, "0x%02x%02x%02x%02x%02x%02x%02x%02x",
            combined.bytes[0],
            combined.bytes[1],
            combined.bytes[2],
            combined.bytes[3],
            combined.bytes[4],
            combined.bytes[5],
            combined.bytes[6],
            combined.bytes[7]);
    cJSON_AddStringToObject(root, DATA_FIELD_NAME, encodedData);

    sendJSON(root, listener);
}

	void Client::getLiveUserInfo(std::string user)
	{
        if((_state != ConnectionState::connected) || (_socket == NULL)){
            if(_zonelistener != NULL)
			{
				liveuser _user;
				_user.result = ResultCode::connection_error;
				_zonelistener->onGetLiveUserInfoDone(_user);
			}
            return;
        }
		int byteLen;
		byte *req;

		std::string payload;
		cJSON *payloadJSON;
		payloadJSON = cJSON_CreateObject();
		cJSON_AddStringToObject(payloadJSON, "name",user.c_str());
		char *cRet = cJSON_PrintUnformatted(payloadJSON);
		payload = cRet;

		req = buildWarpRequest(RequestType::get_user_info, payload, byteLen);

		char *data = new char[byteLen];
		for(int i=0; i< byteLen; ++i)
		{
			data[i] = req[i];
		}

		_socket->sockSend(data, byteLen);

		delete[] data;
		delete[] req;
		cJSON_Delete(payloadJSON);
		free(cRet);
	}

/***************************************************************************
  Function:       package_json_callback 
  Description:    ����5017�˿ڵ�callback���ݸ�ʽ
  Input:          
                  
  Output:      �����װ�õ�callback���ݵĵ�ַ   
  Return:       
  Others:         
****************************************************************************/
char *package_json_callback(char *ipc_status_list)
{
    cJSON *root,*fmt;
    char *out;	
    //Our "Video" datatype: 
    root=cJSON_CreateObject();
	cJSON_AddNumberToObject(root,"msgtype",0);
	cJSON_AddNumberToObject(root,"mainid",2);
	cJSON_AddNumberToObject(root,"subid",4);
	//cJSON_AddNumberToObject(root,"status",type );
	//if(type == 0)
	//{
		cJSON_AddStringToObject(root,"ipc_status_list", ipc_status_list);	
	//}
    //out=cJSON_Print(root);
    out=cJSON_PrintUnformatted(root);
    cJSON_Delete(root);
    //cJSON_Delete(fmt);
    //printf("%s\n",out);	
    //free(out);
    // Print to text, Delete the cJSON, print it, release the string. 

    return out; 
}