void ScreenOverlayManager::SaveLayouts() { #if MYFW_WINDOWS && MYFW_USING_WX cJSON* layouts = cJSON_CreateObject(); for( int i=0; i<ScreenOverlay_NumScreens; i++ ) { if( m_LayoutJSONStrings[i][LayoutType_Wide] != 0 || m_LayoutJSONStrings[i][LayoutType_Tall] != 0 || m_LayoutJSONStrings[i][LayoutType_Square] != 0 ) { cJSON* screenlayout = cJSON_CreateObject(); cJSON_AddItemToObject( layouts, ScreenOverlayNames[i], screenlayout ); if( m_LayoutJSONStrings[i][LayoutType_Wide] ) cJSON_AddStringToObject( screenlayout, "Wide", m_LayoutJSONStrings[i][LayoutType_Wide] ); if( m_LayoutJSONStrings[i][LayoutType_Tall] ) cJSON_AddStringToObject( screenlayout, "Tall", m_LayoutJSONStrings[i][LayoutType_Tall] ); if( m_LayoutJSONStrings[i][LayoutType_Square] ) cJSON_AddStringToObject( screenlayout, "Square", m_LayoutJSONStrings[i][LayoutType_Square] ); } } char* layoutstring = cJSON_Print( layouts ); cJSON_Delete( layouts ); char filename[MAX_PATH]; sprintf_s( filename, MAX_PATH, "Data/Layouts/allscreens.layout" ); FILE* file; fopen_s( &file, filename, "wb" ); fprintf( file, layoutstring ); fclose( file ); free( layoutstring ); #endif }
bool Stream::Send_Jsoon_str() { char cJsonBuff[1024 * 2]; char * m_tmp; m_tmp = cJSON_Print(pRet_root); memset(cJsonBuff, 0, sizeof(cJsonBuff)); sprintf(cJsonBuff, "%sXXEE", m_tmp); free(m_tmp); printf("-----%s \n",cJsonBuff); fflush(stdout); cJSON_Delete(pRet_root); pRet_root = NULL; if(m_clientSocket != -1) { send(m_clientSocket, cJsonBuff, strlen(cJsonBuff), 0); printf("---send len=%d\n",strlen(cJsonBuff)); printf("---send over\n"); fflush(stdout); } }
size_t parse(char *ptr, size_t size, size_t nmemb, char *data) { if(size*nmemb <= 2) { return size*nmemb; } printf("%s\n", ptr); //DEBUG cJSON *root = cJSON_Parse(ptr); struct cJSON *current = root->child; while(strcmp(current->string, "text") != 0) { if(current->next != NULL) { current = current->next; } else { break; printf("done"); //DEBUG } } if(strstr(current->valuestring, "START") != NULL) { bcm2835_gpio_write(PIN, HIGH); } else if(strstr(current->valuestring, "OFF") != NULL) { bcm2835_gpio_write(PIN, LOW); } printf("Current object: %s\n", cJSON_Print(current)); //DEBUG return size*nmemb; }
int ixcgi_reqstb_streaming(char *handle, char *type, int16_t port, int16_t ttl, int fe_id, int ch_id, char *path, char *in, size_t in_size) { cJSON *root; char *out; size_t n_recv; int timeout = 12000; if ((root = cJSON_CreateObject()) == NULL) return -1; cJSON_AddItemToObject(root, HTTPD_OPCODE, cJSON_CreateString(HTTPD_STREAMING)); cJSON_AddItemToObject(root, HTTPD_STREAMING_MY_IP, cJSON_CreateString(getenv("REMOTE_ADDR"))); if (handle[0]) { cJSON_AddItemToObject(root, HTTPD_STREAMING_STOP, cJSON_CreateString(handle)); timeout = 2000; } else { cJSON_AddItemToObject(root, HTTPD_STREAMING_TYPE, cJSON_CreateString(type)); cJSON_AddItemToObject(root, HTTPD_STREAMING_PORT, cJSON_CreateNumber(port)); cJSON_AddItemToObject(root, HTTPD_STREAMING_TTL, cJSON_CreateNumber(ttl)); if ((fe_id >= 0) && (ch_id > 0)) { cJSON_AddItemToObject(root, HTTPD_STREAMING_FE_ID, cJSON_CreateNumber(fe_id)); cJSON_AddItemToObject(root, HTTPD_STREAMING_CH_ID, cJSON_CreateNumber(ch_id)); } else { cJSON_AddItemToObject(root, HTTPD_STREAMING_PATH, cJSON_CreateString(path)); } } n_recv = send_recv_stbd(out = cJSON_Print(root), in, in_size, timeout); cJSON_Delete(root); free(out); return (n_recv == 0) ? -1 : 0 ; }
int main(int args,char *argv[]){ const int smallOutputNumber=-1; int i,j; cJSON *root; int num_chromosome; int req_type=1; char buffer[30]; char req_gene[20]={0}; cJSON *msg; char req_kind[50]="E.coli K12-DH10B"; pi=0; ini=0; req_restrict.rfc10=0; req_restrict.rfc12=0; req_restrict.rfc12a=0; req_restrict.rfc21=0; req_restrict.rfc23=0; req_restrict.rfc25=0; char *req_str=argv_default; if(args==2) req_str=argv[1]; cJSON *request=cJSON_Parse(req_str); if(check_req(request)){ onError("illegal args"); return 0; } i=1; j=1; cJSON *cJSON_temp; cJSON_temp=cJSON_GetObjectItem(request,"type"); if(cJSON_temp) req_type=cJSON_temp->valueint; char req_pam[PAM_LEN+1]; int req_pam_len; strcpy(req_pam,cJSON_GetObjectItem(request,"pam")->valuestring); req_pam_len=(int)strlen(req_pam); char req_specie[30]; struct return_struct rs; int ptts_num; int len[NUM_CHROMOSOME]; strcpy(req_specie,cJSON_GetObjectItem(request,"specie")->valuestring); if(strcmp(req_specie,"SARS")==0){ rs=info_readin(PTT_SARS,ptts,str,wai,NULL); }else if(strcmp(req_specie,"E.coli")==0){ cJSON_temp=cJSON_GetObjectItem(request,"kind"); if(cJSON_temp) strcpy(req_kind,cJSON_temp->valuestring); rs=info_readin(PTT_ECOLI,ptts,str,wai,req_kind); }else if(strcmp(req_specie,"Saccharomycetes")==0){ rs=info_readin(PTT_SACCHAROMYCETES,ptts,str,wai,NULL); }else{ onError("no specie"); return 0; } ptts_num=rs.ptts_num; num_chromosome=rs.num_chromosome; for(i=1;i<=num_chromosome;i++) len[i]=rs.len[i]; double req_r1=0.65; cJSON_temp=cJSON_GetObjectItem(request,"gene"); if(cJSON_temp){ req_r1=cJSON_GetObjectItem(request,"r1")->valuedouble; } cJSON_temp=cJSON_GetObjectItem(request,"gene"); int req_id,req_gene_start,req_gene_end; if(cJSON_temp){ strcpy(req_gene,cJSON_temp->valuestring); for(int i=0;i<ptts_num;i++){ if(strcmp(req_gene,ptts[i].gene)==0){ req_id=ptts[i].chromosome; req_gene_start=ptts[i].s; req_gene_end=ptts[i].t; break; } } }else{ char req_location[20]; strcpy(req_location,cJSON_GetObjectItem(request,"location")->valuestring); sscanf(req_location,"%d:%d..%d",&req_id,&req_gene_start,&req_gene_end); } char req_rfc[10]; strcpy(req_rfc,cJSON_GetObjectItem(request,"rfc")->valuestring); req_restrict.rfc10=req_rfc[0]-48; req_restrict.rfc12=req_rfc[1]-48; req_restrict.rfc12a=req_rfc[2]-48; req_restrict.rfc21=req_rfc[3]-48; req_restrict.rfc23=req_rfc[4]-48; req_restrict.rfc25=req_rfc[5]-48; generate_filename(buffer,req_specie,req_kind,req_pam,req_type); dc_init(buffer); /* This part above is for read in JSON-style request. The result stored in req_specie, req_pam, req_gene_start, req_gene_end, rfc and so on. At the same time, it reads in ptt file for specie, and also open files. */ for(int id=1;id<=num_chromosome;id++){ for(i=LEN;i<len[id]-req_pam_len;i++){ // All possible gRNAs, +direction if(check_pam(str[id]+i,req_pam)){ psb_site[pi].index=i; psb_site[pi].strand='+'; psb_site[pi].chromosome=id; for(j=0;j<req_pam_len;j++) psb_site[pi].pam[j]=(str[id]+i)[j]; psb_site[pi].pam[j]=0; for(j=0;j<LEN;j++) psb_site[pi].nt[j]=(str[id]+i-LEN)[j]; psb_site[pi].nt[j]=0; pi++; } } char req_pam_rev[PAM_LEN]; int last=-1; dna_rev(req_pam_rev,req_pam,req_pam_len); for(i=0;i<len[id]-LEN-req_pam_len;i++){ // All possible gRNAs, -direction if(check_pam(str[id]+i,req_pam_rev)){ psb_site[pi].index=i+req_pam_len-1; psb_site[pi].strand='-'; psb_site[pi].chromosome=id; if(req_pam_len!=last){ last=req_pam_len; } for(j=0;j<req_pam_len;j++) psb_site[pi].pam[j]=dna_rev_char((str[id]+i)[req_pam_len-1-j]); psb_site[pi].pam[j]=0; for(j=0;j<LEN;j++) psb_site[pi].nt[j]=dna_rev_char((str[id]+i+req_pam_len)[LEN-j-1]); psb_site[pi].nt[j]=0; pi++; } } } for(i=0;i<pi;i++){ fflush(stdout); if(psb_site[i].chromosome!=req_id) continue; if(psb_site[i].strand=='+'){ if(psb_site[i].index<req_gene_start || psb_site[i].index+req_pam_len-1>req_gene_end) continue; for(j=psb_site[i].index-LEN;j<psb_site[i].index+req_pam_len-1;j++){ if(wai[req_id][j]!=1) break; } if(j<psb_site[i].index+req_pam_len-1) j=0; else j=1; }else{ if(psb_site[i].index-req_pam_len+1<req_gene_start || psb_site[i].index>req_gene_end) continue; for(j=psb_site[i].index-req_pam_len+1;j<psb_site[i].index+LEN;j++){ if(wai[req_id][j]!=1) break; } if(j<psb_site[i].index+LEN) j=0; else j=1; } if(j){ score(i,&ini,req_type,req_r1); } } dc_save(); sort(in_site,in_site+ini,cmp_in_site); // Sort & Output root=cJSON_CreateObject(); cJSON_AddNumberToObject(root,"status",0); msg=cJSON_CreateObject(); cJSON_AddStringToObject(msg,"specie",req_specie); cJSON_AddStringToObject(msg,"kind",req_kind); cJSON_AddStringToObject(msg,"gene",req_gene); sprintf(buffer,"%d:%d..%d",req_id,req_gene_start,req_gene_end); cJSON_AddStringToObject(msg,"location",buffer); cJSON_AddItemToObject(root,"message",msg); vector<cJSON*> list; list.clear(); for(i=0;i<ini && i!=smallOutputNumber;i++){ cJSON *ans=cJSON_CreateObject(); sprintf(buffer,"#%d",i+1); cJSON_AddStringToObject(ans,"key",buffer); sprintf(buffer,"%s%s",in_site[i].nt,in_site[i].pam); cJSON_AddStringToObject(ans,"grna",buffer); sprintf(buffer,"%d:%d",in_site[i].chromosome,in_site[i].index); cJSON_AddStringToObject(ans,"position",buffer); char xs[2]; xs[0]=in_site[i].strand; xs[1]=0; cJSON_AddStringToObject(ans,"strand",xs); cJSON_AddNumberToObject(ans,"total_score",(int)in_site[i].score); cJSON_AddNumberToObject(ans,"Sspe",(int)(req_r1*in_site[i].Sspe_nor)); cJSON_AddNumberToObject(ans,"Seff",(int)((1.0-req_r1)*in_site[i].Seff_nor)); cJSON_AddNumberToObject(ans,"count",in_site[i].count); cJSON_AddItemToObject(ans,"offtarget",in_site[i].otj); list.push_back(ans); } cJSON_AddItemToObject(root,"result",Create_array_of_anything(&(list[0]),list.size())); printf("%s\n",NomoreSpace(argv[0]=cJSON_Print(root))); free(argv[0]); return 0; }
int32_t process_NXT_event(struct NXThandler_info *mp,int32_t histmode,char *txid,int64_t type,int64_t subtype,struct NXT_AMhdr *AMhdr,char *sender,char *receiver,char *assetid,int64_t assetoshis,char *comment,cJSON *json) { int32_t i,count,highest_priority; NXT_handler NXT_handler = 0; void *handlerdata = 0; struct NXT_protocol *p; struct NXT_protocol_parms PARMS; count = 0; highest_priority = -1; memset(&PARMS,0,sizeof(PARMS)); if ( Num_NXThandlers == 0 ) printf("WARNING: process_NXT_event Num_NXThandlers.%d\n",Num_NXThandlers); for (i=0; i<Num_NXThandlers; i++) { if ( (p= NXThandlers[i]) != 0 ) { if ( AMhdr != 0 || ((p->type < 0 || p->type == type) && (p->subtype < 0 || p->subtype == subtype)) ) { if ( AMhdr != 0 ) { if ( p->AMsigfilter != 0 && p->AMsigfilter != AMhdr->sig ) continue; } else if ( p->assetlist != 0 && assetid != 0 && listcmp(p->assetlist,assetid) != 0 ) continue; if ( strcmp(sender,GENESISACCT) == 0 || strcmp(receiver,GENESISACCT) == 0 || //is_gateway_addr(sender) != 0 || (AMhdr == 0 || p->whitelist == 0 || listcmp(p->whitelist,sender) == 0) || (AMhdr != 0 && cmp_nxt64bits(sender,AMhdr->nxt64bits) == 0) ) { if ( p->priority > highest_priority ) { count = 1; highest_priority = p->priority; NXT_handler = p->NXT_handler; handlerdata = p->handlerdata; PARMS.argjson = json; PARMS.txid = txid; PARMS.sender = sender; PARMS.receiver = receiver; PARMS.type = (int32_t)type; PARMS.subtype = (int32_t)subtype; PARMS.priority = highest_priority; PARMS.histflag = histmode; if ( AMhdr != 0 ) { PARMS.mode = NXTPROTOCOL_AMTXID; PARMS.AMptr = AMhdr; } else { PARMS.mode = NXTPROTOCOL_TYPEMATCH; PARMS.assetid = assetid; PARMS.assetoshis = assetoshis; PARMS.comment = comment; } //printf("call NXT_handler\n"); (*NXT_handler)(mp,&PARMS,handlerdata); } else if ( p->priority == highest_priority ) count++; } //printf("end iter\n"); } } } if ( count > 1 ) printf("WARNING: (%s) claimed %d times, priority.%d\n",cJSON_Print(json),count,highest_priority); // this is bad, also leaks mem! if ( 0 && highest_priority >= 0 && NXT_handler != 0 ) { //printf("count.%d handler.%p NXThandler_info_handler.%p AMhdr.%p\n",count,NXT_handler,multigateway_handler,AMhdr); PARMS.argjson = json; PARMS.txid = txid; PARMS.sender = sender; PARMS.receiver = receiver; PARMS.type = (int32_t)type; PARMS.subtype = (int32_t)subtype; PARMS.priority = highest_priority; PARMS.histflag = histmode; if ( AMhdr != 0 ) { PARMS.mode = NXTPROTOCOL_AMTXID; PARMS.AMptr = AMhdr; } else { PARMS.mode = NXTPROTOCOL_TYPEMATCH; PARMS.assetid = assetid; PARMS.assetoshis = assetoshis; PARMS.comment = comment; } (*NXT_handler)(mp,&PARMS,handlerdata);///histmode,txid,AMhdr,sender,receiver,assetid,assetoshis,comment,json); } return(count != 0); }
void thread_ssid_msgio(void) { int ret = pthread_detach(pthread_self()); Debug("pthread_self():%lu, ret[%d]", pthread_self(), ret); char mac[32] = {0}; char ssid[14] = {"FotileAP_"}; int retssid = 0; while (1) { fd_set rset, wset; FD_ZERO(&rset); //FD_ZERO(&wset); int i, maxfd, rcvfd; maxfd = set_get_max(&ssid_fdset); for(i=0;i<set_get_elem_num(&ssid_fdset);i++) { FD_SET(set_at(&ssid_fdset, i),&rset); } //FD_SET(socket_fd,&wset); struct timeval tval; tval.tv_sec = 0; tval.tv_usec = 10000; if(select(maxfd+1, &rset, NULL, NULL,&tval) > 0) { int i; for(i=0;i<set_get_elem_num(&ssid_fdset);i++) { if(FD_ISSET(set_at(&ssid_fdset, i), &rset)) { rcvfd = set_at(&ssid_fdset, i); break; } } char szRcv[MAX_MESSAGE_LEN] = {0}; int len = 0; int lens =0; unsigned char mac_arr[6] = {0}; //not use if (retssid == 0){ retssid = get_eth0_mac(mac, mac_arr, 32); ssid[9] = mac[12]; ssid[10] = mac[13]; ssid[11] = mac[15]; ssid[12] = mac[16]; Debug("first time get ssid!"); }else{ } int ret = recv(rcvfd, szRcv, MAX_MESSAGE_LEN, 0); //Info("ret[%d]%s", ret, szRcv); if (ret > 0) { cJSON *root1 = cJSON_Parse(szRcv); cJSON *root2 = cJSON_CreateObject(); if(strcmp(cJSON_GetObjectItem(root1,"type")->valuestring,"reqssid") == 0) { cJSON_AddItemToObject(root2, "type", cJSON_CreateString("reqssid")); cJSON_AddNumberToObject(root2, "seq", cJSON_GetObjectItem(root1,"seq")->valueint); if(retssid > 0) { cJSON_AddNumberToObject(root2, "respcode", 0); cJSON_AddStringToObject(root2, "respmsg", ssid); } else { cJSON_AddNumberToObject(root2, "respcode", -1); cJSON_AddStringToObject(root2,"respmsg", "error:get ssid failed!"); } char *out = cJSON_Print(root2); //Info("out[%s]", out); lens = strlen(out); send(rcvfd, out , lens ,0); //Info("%s",rendered); cJSON_Delete(root1); cJSON_Delete(root2); free(out); }else{ Warn("param error!"); } } else { //Warn("[fd:%d]rcv error! close socket", rcvfd); set_erase(rcvfd, &ssid_fdset); close(rcvfd); } } } }
/** * @brief Convert the JSON object to a string. * @return A JSON string representation of the object. */ std::string JsonObject::toString() { char *data = cJSON_Print(m_node); std::string ret(data); free(data); return ret; } // toString
char *InstantDEX_parser(char *forwarder,char *sender,int32_t valid,char *origargstr,cJSON *origargjson) { static char *allorderbooks[] = { (char *)allorderbooks_func, "allorderbooks", "", 0 }; static char *orderbook[] = { (char *)orderbook_func, "orderbook", "", "baseid", "relid", "allfields", "oldest", "maxdepth", "base", "rel", "gui", "showall", "exchange", 0 }; static char *lottostats[] = { (char *)lottostats_func, "lottostats", "", "timestamp", 0 }; static char *cancelquote[] = { (char *)cancelquote_func, "cancelquote", "", "quoteid", 0 }; static char *openorders[] = { (char *)openorders_func, "openorders", "", 0 }; static char *placebid[] = { (char *)placebid_func, "placebid", "", "baseid", "relid", "volume", "price", "timestamp", "baseamount", "relamount", "gui", "automatch", "minperc", "duration", "exchange", "offerNXT", 0 }; static char *placeask[] = { (char *)placeask_func, "placeask", "", "baseid", "relid", "volume", "price", "timestamp", "baseamount", "relamount", ",gui", "automatch", "minperc", "duration", "exchange", "offerNXT", 0 }; static char *bid[] = { (char *)bid_func, "bid", "", "baseid", "relid", "volume", "price", "timestamp", "baseamount", "relamount", "gui", "automatch", "minperc", "duration", "exchange", "offerNXT", 0 }; static char *ask[] = { (char *)ask_func, "ask", "", "baseid", "relid", "volume", "price", "timestamp", "baseamount", "relamount", "gui", "automatch", "minperc", "duration", "exchange", "offerNXT", 0 }; static char *makeoffer3[] = { (char *)makeoffer3_func, "makeoffer3", "", "baseid", "relid", "quoteid", "perc", "deprecated", "baseiQ", "reliQ", "askoffer", "price", "volume", "exchange", "baseamount", "relamount", "offerNXT", "minperc", "jumpasset", 0 }; static char *respondtx[] = { (char *)respondtx_func, "respondtx", "", "cmd", "assetid", "quantityQNT", "priceNQT", "triggerhash", "quoteid", "sig", "data", "minperc", "offerNXT", "otherassetid", "otherqty", 0 }; static char *jumptrades[] = { (char *)jumptrades_func, "jumptrades", "", 0 }; static char *tradehistory[] = { (char *)tradehistory_func, "tradehistory", "", "timestamp", 0 }; static char **commands[] = { allorderbooks, lottostats, cancelquote, respondtx, jumptrades, tradehistory, openorders, makeoffer3, placebid, bid, placeask, ask, orderbook }; int32_t i,j,localaccess = 0; cJSON *argjson,*obj,*nxtobj,*secretobj,*objs[64]; char NXTaddr[MAX_JSON_FIELD],NXTACCTSECRET[MAX_JSON_FIELD],command[MAX_JSON_FIELD],offerNXT[MAX_JSON_FIELD],**cmdinfo,*argstr,*retstr=0; memset(objs,0,sizeof(objs)); command[0] = 0; valid = 1; memset(NXTaddr,0,sizeof(NXTaddr)); if ( is_cJSON_Array(origargjson) != 0 ) { argjson = cJSON_GetArrayItem(origargjson,0); argstr = cJSON_Print(argjson), _stripwhite(argstr,' '); } else argjson = origargjson, argstr = origargstr; NXTACCTSECRET[0] = 0; if ( argjson != 0 ) { if ( (obj= cJSON_GetObjectItem(argjson,"requestType")) == 0 ) obj = cJSON_GetObjectItem(argjson,"method"); nxtobj = cJSON_GetObjectItem(argjson,"NXT"); secretobj = cJSON_GetObjectItem(argjson,"secret"); copy_cJSON(NXTaddr,nxtobj); copy_cJSON(offerNXT,cJSON_GetObjectItem(argjson,"offerNXT")); if ( NXTaddr[0] == 0 && offerNXT[0] == 0 ) { strcpy(NXTaddr,SUPERNET.NXTADDR); strcpy(offerNXT,SUPERNET.NXTADDR); strcpy(sender,SUPERNET.NXTADDR); ensure_jsonitem(argjson,"NXT",NXTaddr); ensure_jsonitem(argjson,"offerNXT",offerNXT); } else if ( offerNXT[0] == 0 && strcmp(NXTaddr,SUPERNET.NXTADDR) == 0 ) { strcpy(offerNXT,SUPERNET.NXTADDR); strcpy(sender,SUPERNET.NXTADDR); ensure_jsonitem(argjson,"offerNXT",offerNXT); } else strcpy(sender,offerNXT); if ( strcmp(offerNXT,SUPERNET.NXTADDR) == 0 ) localaccess = 1; if ( localaccess != 0 && strcmp(NXTaddr,SUPERNET.NXTADDR) != 0 ) { strcpy(NXTaddr,SUPERNET.NXTADDR); ensure_jsonitem(argjson,"NXT",NXTaddr); //printf("subsititute NXT.%s\n",NXTaddr); } //printf("localaccess.%d myaddr.(%s) NXT.(%s) offerNXT.(%s)\n",localaccess,SUPERNET.NXTADDR,NXTaddr,offerNXT); copy_cJSON(command,obj); copy_cJSON(NXTACCTSECRET,secretobj); if ( NXTACCTSECRET[0] == 0 ) { if ( localaccess != 0 || strcmp(command,"findnode") != 0 ) { safecopy(NXTACCTSECRET,SUPERNET.NXTACCTSECRET,sizeof(NXTACCTSECRET)); strcpy(NXTaddr,SUPERNET.NXTADDR); } } //printf("(%s) argstr.(%s) command.(%s) NXT.(%s) valid.%d\n",cJSON_Print(argjson),argstr,command,NXTaddr,valid); //fprintf(stderr,"SuperNET_json_commands sender.(%s) valid.%d | size.%d | command.(%s) orig.(%s)\n",sender,valid,(int32_t)(sizeof(commands)/sizeof(*commands)),command,origargstr); for (i=0; i<(int32_t)(sizeof(commands)/sizeof(*commands)); i++) { cmdinfo = commands[i]; if ( strcmp(cmdinfo[1],command) == 0 ) { //printf("needvalid.(%c) valid.%d %d of %d: cmd.(%s) vs command.(%s)\n",cmdinfo[2][0],valid,i,(int32_t)(sizeof(commands)/sizeof(*commands)),cmdinfo[1],command); if ( cmdinfo[2][0] != 0 && valid <= 0 ) return(0); for (j=3; cmdinfo[j]!=0&&j<3+(int32_t)(sizeof(objs)/sizeof(*objs)); j++) objs[j-3] = cJSON_GetObjectItem(argjson,cmdinfo[j]); retstr = (*(json_handler)cmdinfo[0])(localaccess,valid,sender,objs,j-3,argstr); break; } } } else printf("not JSON to parse?\n"); if ( argstr != origargstr ) free(argstr); return(retstr); }
void *ChangeLightRepresentation (void *param) { (void)param; OCStackResult result = OC_STACK_ERROR; uint8_t j = 0; uint8_t numNotifies = (SAMPLE_MAX_NUM_OBSERVATIONS)/2; OCObservationId obsNotify[numNotifies]; while (!gQuitFlag) { sleep(10); Light.power += 5; if (gLightUnderObservation) { OC_LOG_V(INFO, TAG, " =====> Notifying stack of new power level %d\n", Light.power); if (gObserveNotifyType == 1) { // Notify list of observers. Alternate observers on the list will be notified. j = 0; for (uint8_t i = 0; i < SAMPLE_MAX_NUM_OBSERVATIONS; (i=i+2)) { if (interestedObservers[i].valid == true) { obsNotify[j] = interestedObservers[i].observationId; j++; } } cJSON *json = cJSON_CreateObject(); cJSON *format; cJSON_AddStringToObject(json,"href",gResourceUri); cJSON_AddItemToObject(json, "rep", format=cJSON_CreateObject()); cJSON_AddStringToObject(format, "state", (char *) (Light.state ? "on":"off")); cJSON_AddNumberToObject(format, "power", Light.power); char * obsResp = cJSON_Print(json); cJSON_Delete(json); result = OCNotifyListOfObservers (Light.handle, obsNotify, j, (unsigned char *)obsResp, OC_NA_QOS); free(obsResp); } else if (gObserveNotifyType == 0) { // Notifying all observers result = OCNotifyAllObservers (Light.handle, OC_NA_QOS); if (OC_STACK_NO_OBSERVERS == result) { OC_LOG (INFO, TAG, "=======> No more observers exist, stop sending observations"); gLightUnderObservation = 0; } } else { OC_LOG (ERROR, TAG, "Incorrect notification type selected"); } } #ifdef WITH_PRESENCE if(stopPresenceCount > 0) { OC_LOG_V(INFO, TAG, "================ presence count %d", stopPresenceCount); } if(!stopPresenceCount--) { OC_LOG(INFO, TAG, "================ stopping presence"); OCStopPresence(); } #endif } return NULL; }
struct coin777 *coin777_create(char *coinstr,cJSON *argjson) { char *serverport,*path=0,*conf=0; struct destbuf tmp; struct coin777 *coin = calloc(1,sizeof(*coin)); safecopy(coin->name,coinstr,sizeof(coin->name)); if ( argjson == 0 ) { coin->minconfirms = (strcmp("BTC",coinstr) == 0) ? 3 : 10; coin->estblocktime = (strcmp("BTC",coinstr) == 0) ? 600 : 120; } else { coin->minoutput = get_API_nxt64bits(cJSON_GetObjectItem(argjson,"minoutput")); coin->minconfirms = get_API_int(cJSON_GetObjectItem(argjson,"minconfirms"),(strcmp("BTC",coinstr) == 0) ? 3 : 10); coin->estblocktime = get_API_int(cJSON_GetObjectItem(argjson,"estblocktime"),(strcmp("BTC",coinstr) == 0) ? 600 : 120); coin->jsonstr = cJSON_Print(argjson); coin->argjson = cJSON_Duplicate(argjson,1); if ( (serverport= cJSON_str(cJSON_GetObjectItem(argjson,"rpc"))) != 0 ) safecopy(coin->serverport,serverport,sizeof(coin->serverport)); path = cJSON_str(cJSON_GetObjectItem(argjson,"path")); conf = cJSON_str(cJSON_GetObjectItem(argjson,"conf")); copy_cJSON(&tmp,cJSON_GetObjectItem(argjson,"assetid")), safecopy(coin->mgw.assetidstr,tmp.buf,sizeof(coin->mgw.assetidstr)); coin->mgw.assetidbits = calc_nxt64bits(coin->mgw.assetidstr); copy_cJSON(&tmp,cJSON_GetObjectItem(argjson,"issuer")), safecopy(coin->mgw.issuer,tmp.buf,sizeof(coin->mgw.issuer));; coin->mgw.issuerbits = conv_acctstr(coin->mgw.issuer); printf(">>>>>>>>>>>> a issuer.%s %llu assetid.%llu minoutput.%llu\n",coin->mgw.issuer,(long long)coin->mgw.issuerbits,(long long)coin->mgw.assetidbits,(long long)coin->minoutput); //uint32_t set_assetname(uint64_t *multp,char *name,uint64_t assetbits); _set_assetname(&coin->mgw.ap_mult,coin->mgw.assetname,0,coin->mgw.assetidbits); printf("assetname.(%s) mult.%llu\n",coin->mgw.assetname,coin->mgw.ap_mult); strcpy(coin->mgw.coinstr,coinstr); if ( (coin->mgw.special= cJSON_GetObjectItem(argjson,"special")) == 0 ) coin->mgw.special = cJSON_GetObjectItem(COINS.argjson,"special"); if ( coin->mgw.special != 0 ) coin->mgw.special = NXT_convjson(coin->mgw.special); printf("CONVERTED.(%s)\n",cJSON_Print(coin->mgw.special)); coin->mgw.limbo = cJSON_GetObjectItem(argjson,"limbo"); coin->mgw.dust = get_API_nxt64bits(cJSON_GetObjectItem(argjson,"dust")); coin->mgw.txfee = get_API_nxt64bits(cJSON_GetObjectItem(argjson,"txfee_satoshis")); if ( coin->mgw.txfee == 0 ) coin->mgw.txfee = (uint64_t)(SATOSHIDEN * get_API_float(cJSON_GetObjectItem(argjson,"txfee"))); if ( coin->mgw.txfee == 0 ) coin->mgw.txfee = 10000; coin->mgw.NXTfee_equiv = get_API_nxt64bits(cJSON_GetObjectItem(argjson,"NXTfee_equiv_satoshis")); if ( coin->mgw.NXTfee_equiv == 0 ) coin->mgw.NXTfee_equiv = (uint64_t)(SATOSHIDEN * get_API_float(cJSON_GetObjectItem(argjson,"NXTfee_equiv"))); copy_cJSON(&tmp,cJSON_GetObjectItem(argjson,"opreturnmarker")), safecopy(coin->mgw.opreturnmarker,tmp.buf,sizeof(coin->mgw.opreturnmarker)); printf("OPRETURN.(%s)\n",coin->mgw.opreturnmarker); copy_cJSON(&tmp,cJSON_GetObjectItem(argjson,"marker2")), safecopy(coin->mgw.marker2,tmp.buf,sizeof(coin->mgw.marker2)); coin->mgw.redeemheight = get_API_int(cJSON_GetObjectItem(argjson,"redeemheight"),430000); coin->mgw.use_addmultisig = get_API_int(cJSON_GetObjectItem(argjson,"useaddmultisig"),(strcmp("BTC",coinstr) != 0)); coin->mgw.do_opreturn = get_API_int(cJSON_GetObjectItem(argjson,"do_opreturn"),(strcmp("BTC",coinstr) == 0)); coin->mgw.oldtx_format = get_API_int(cJSON_GetObjectItem(argjson,"oldtx_format"),(strcmp("BTC",coinstr) == 0)); coin->mgw.firstunspentind = get_API_int(cJSON_GetObjectItem(argjson,"firstunspent"),(strcmp("BTCD",coinstr) == 0) ? 2500000 : 0); if ( (coin->mgw.NXTconvrate = get_API_float(cJSON_GetObjectItem(argjson,"NXTconvrate"))) == 0 ) { if ( coin->mgw.NXTfee_equiv != 0 && coin->mgw.txfee != 0 ) coin->mgw.NXTconvrate = ((double)coin->mgw.NXTfee_equiv / coin->mgw.txfee); } copy_cJSON(&tmp,cJSON_GetObjectItem(argjson,"marker")), safecopy(coin->mgw.marker,tmp.buf,sizeof(coin->mgw.marker)); printf("OPRETURN.(%s)\n",coin->mgw.opreturnmarker); } printf("coin777_create %s: (%s) %llu mult.%llu NXTconvrate %.8f minconfirms.%d issuer.(%s) %llu opreturn.%d oldformat.%d\n",coin->mgw.coinstr,coin->mgw.assetidstr,(long long)coin->mgw.assetidbits,(long long)coin->mgw.ap_mult,coin->mgw.NXTconvrate,coin->minconfirms,coin->mgw.issuer,(long long)coin->mgw.issuerbits,coin->mgw.do_opreturn,coin->mgw.oldtx_format); extract_userpass(coin->serverport,coin->userpass,coinstr,SUPERNET.userhome,path,conf); printf("COIN.%s serverport.(%s) userpass.(%s)\n",coin->name,coin->serverport,coin->userpass); COINS.LIST = realloc(COINS.LIST,(COINS.num+1) * sizeof(*coin)); COINS.LIST[COINS.num] = coin, COINS.num++; //ensure_packedptrs(coin); return(coin); }
void http_server_start(http_server_t *http_server) { WSADATA wsa; if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) { printf("Failed. Error Code : %d", WSAGetLastError()); exit(1); } SOCKET s; if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) { printf("Could not create socket : %d" , WSAGetLastError()); exit(1); } struct sockaddr_in server; server.sin_family = AF_INET; server.sin_addr.s_addr = INADDR_ANY; server.sin_port = htons(8888); if (bind(s, (struct sockaddr *)&server, sizeof(server)) == SOCKET_ERROR) { printf("Bind failed with error code : %d" , WSAGetLastError()); exit(EXIT_FAILURE); } listen(s, 3); int c = sizeof(struct sockaddr_in); SOCKET newSocket; struct sockaddr_in client; while ((newSocket = accept(s, (struct sockaddr *)&client, &c)) != INVALID_SOCKET) { char message[500000]; char request[500000]; int recvSize = recv(newSocket, request, sizeof(request), 0); request[recvSize] = '\0'; http_server_request_method_t http_server_request_method; char url[128]; char requestMessage[500000]; parseHttpRequest(request, &http_server_request_method, url, requestMessage); printf("%s\n", url); if (strcmp(url, "/directors") == 0) { cJSON *json = cJSON_CreateArray(); for (size_t i = 0; i < directors_size(http_server->directors); ++i) { director_t *director = directors_get(http_server->directors, i); cJSON *jsonDir = cJSON_CreateObject(); cJSON_AddStringToObject(jsonDir, "name", director->name); cJSON_AddStringToObject(jsonDir, "surname", director->surname); char birthdateStr[128]; sprintf(birthdateStr, "%i-%i-%i", director->birth_date.tm_year, director->birth_date.tm_mday, director->birth_date.tm_mon); cJSON_AddStringToObject(jsonDir, "birthdate", birthdateStr); cJSON *jsonStartup = cJSON_CreateObject(); cJSON_AddStringToObject(jsonStartup, "name", director->startup.name); cJSON_AddStringToObject(jsonStartup, "country", director->startup.country); cJSON_AddItemToObject(jsonDir, "startup", jsonStartup); cJSON_AddNumberToObject(jsonDir, "salary", director->salary); cJSON_AddNumberToObject(jsonDir, "rating", director->rating); cJSON_AddItemToArray(json, jsonDir); } char *jsonStr = cJSON_Print(json); makeHttpResponse(jsonStr, message); cJSON_Delete(json); send(newSocket, message, strlen(message), 0); } else if (strncmp(url, "/directors/", strlen("/directors/")) == 0) { size_t directorIndex = atoi(strstr(url + 1, "/") + 1); director_t *director = directors_get(http_server->directors, directorIndex); if (http_server_request_method == http_server_request_method_delete) { directors_remove(http_server->directors, directorIndex); makeHttpResponse("", message); send(newSocket, message, strlen(message), 0); } else if (http_server_request_method == http_server_request_method_post) { cJSON *json = cJSON_Parse(requestMessage); cJSON *subItem = json->child; while (subItem) { if ((subItem->type == cJSON_String) && (strcmp(subItem->string, "name") == 0)) director_update(director, subItem->valuestring, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); if ((subItem->type == cJSON_String) && (strcmp(subItem->string, "surname") == 0)) director_update(director, NULL, subItem->valuestring, NULL, NULL, NULL, NULL, NULL, NULL, NULL); if ((subItem->type == cJSON_String) && (strcmp(subItem->string, "birthdate") == 0)) { int year; int day; int month; sscanf(subItem->valuestring, "%i-%i-%i", &year, &day, &month); director_update(director, NULL, NULL, &year, &day, &month, NULL, NULL, NULL, NULL); } if ((subItem->type == cJSON_Object) && (strcmp(subItem->string, "startup") == 0)) { cJSON *subJtem = subItem->child; while (subJtem) { if ((subJtem->type == cJSON_String) && (strcmp(subJtem->string, "name") == 0)) director_update(director, NULL, NULL, NULL, NULL, NULL, subJtem->valuestring, NULL, NULL, NULL); if ((subJtem->type == cJSON_String) && (strcmp(subJtem->string, "country") == 0)) director_update(director, NULL, NULL, NULL, NULL, NULL, NULL, subJtem->valuestring, NULL, NULL); subJtem = subJtem->next; } } if ((subItem->type == cJSON_Number) && (strcmp(subItem->string, "salary") == 0)) { director_update(director, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &subItem->valueint, NULL); } if ((subItem->type == cJSON_Number) && (strcmp(subItem->string, "rating") == 0)) { director_update(director, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &subItem->valuedouble); } subItem = subItem->next; } makeHttpResponse("", message); send(newSocket, message, strlen(message), 0); } else { cJSON *json = cJSON_CreateObject(); cJSON_AddStringToObject(json, "name", director->name); cJSON_AddStringToObject(json, "surname", director->surname); char birthdateStr[128]; sprintf(birthdateStr, "%i-%i-%i", director->birth_date.tm_year, director->birth_date.tm_mday, director->birth_date.tm_mon); cJSON_AddStringToObject(json, "birthdate", birthdateStr); cJSON *jsonStartup = cJSON_CreateObject(); cJSON_AddStringToObject(jsonStartup, "name", director->startup.name); cJSON_AddStringToObject(jsonStartup, "country", director->startup.country); cJSON_AddItemToObject(json, "startup", jsonStartup); cJSON_AddNumberToObject(json, "salary", director->salary); cJSON_AddNumberToObject(json, "rating", director->rating); char *jsonStr = cJSON_Print(json); makeHttpResponse(jsonStr, message); cJSON_Delete(json); send(newSocket, message, strlen(message), 0); } } else { const char *message = "HTTP/1.1 404\r\nContent-length: 0\r\n\r\n"; send(newSocket, message, strlen(message), 0); } closesocket(newSocket); } if (newSocket == INVALID_SOCKET) { printf("accept failed with error code : %d" , WSAGetLastError()); exit(1); } closesocket(s); WSACleanup(); }
int write_bb_black_respond(char* fileName,char *rev) { long len; char sw[15]; char uid[60]; char ip_s[20]; char port_s[10]; char port_l[10]; char* pContent; //First read the old config FILE* fp = fopen(fileName, "rb+"); if(fp==NULL) { DEBUG_printf("open error\n"); exit(1); } fseek(fp,0,SEEK_END); len=ftell(fp); if(0 == len) { return 0; } fseek(fp,0,SEEK_SET); pContent = (char*) malloc(sizeof(char)*len+100); fread(pContent,1,len,fp); fclose(fp); cJSON *jsonroot = cJSON_Parse(pContent); //json strcpy(sw,cJSON_GetObjectItem(jsonroot,"api-switch")->valuestring); strcpy(uid,cJSON_GetObjectItem(jsonroot,"api-uid")->valuestring); strcpy(ip_s,cJSON_GetObjectItem(jsonroot,"ip_server")->valuestring); strcpy(port_s,cJSON_GetObjectItem(jsonroot,"port_server")->valuestring); strcpy(port_l,cJSON_GetObjectItem(jsonroot,"port_local")->valuestring); cJSON_Delete(jsonroot); //Write configuration, update fp = fopen(fileName, "w+"); if(fp==NULL) { DEBUG_printf("open error\n"); } cJSON *root; char *out; root=cJSON_CreateObject(); cJSON_AddStringToObject(root, "api-switch" , sw); cJSON_AddStringToObject(root, "api-uid", uid); cJSON_AddStringToObject(root, "auth", rev); cJSON_AddStringToObject(root, "ip_server" ,ip_s); cJSON_AddStringToObject(root, "port_server", port_s); cJSON_AddStringToObject(root, "port_local", port_l); out=cJSON_Print(root); fprintf(fp,"%s",out); fclose(fp); cJSON_Delete(root); free(out); out = NULL; root = NULL; free(pContent); return 1; }
static int _load_config() { cJSON *config = NULL; cJSON *data = NULL; cJSON *elm = NULL; cJSON *startTime = NULL; cJSON *command = NULL; int cnt = 0; int index = 0; int hour,min,second; int ret = OK; if (NULL != task) { free(task); task = NULL; } config = _get_JSON_from_file(CONFIG_FILE_PATH); if (NULL == config) { LOG_ERR("get config errer"); ret = ERROR; goto leave; } /* attendtion free */ PRINTF("data = %s", cJSON_Print(config)); data = cJSON_GetObjectItem(config, "data"); cnt = cJSON_GetArraySize(data); task = (TASK_ENTRY *)malloc(sizeof(TASK_ENTRY)*cnt); if (NULL == task) { LOG_ERR("malloc error!"); ret = ERROR; goto leave; } for(index = 0; index < cnt; index++) { elm = cJSON_GetArrayItem(data, index); startTime = cJSON_GetObjectItem(elm, "startTime"); if( startTime != NULL && startTime->type == cJSON_String ) { sscanf(startTime->valuestring, "%d:%d:%d", &hour, &min, &second); task[index].startTime = hour * 60 * 60 + min * 60 + second; } command = cJSON_GetObjectItem(elm, "command"); if( command != NULL && command->type == cJSON_String ) { if(strlen(command->valuestring) < MAX_COMMAND_LENGTH) { strcpy(task[index].command, command->valuestring); } else { LOG_ERR("command %s size %d error!", command->valuestring, strlen(command->valuestring)); _log_to_file(ERROR_LOG_FILE_PATH, "command %s size %d error!", command->valuestring, strlen(command->valuestring)); } } } _quick_sort(0, cnt - 1, task); task_index = 0; task_MAX = cnt; #ifdef LOG_DEBUG for(index = 0; index < cnt; index++) { PRINTF("%02d:%02d:%02d %s", task[index].startTime/3600, (task[index].startTime % 3600)/60, task[index].startTime%60, task[index].command); } #endif leave: if(config) cJSON_Delete(config); return ret; }
char *jprint(cJSON *json,int32_t freeflag) { char *str; if ( json == 0 ) return(clonestr("{}")); str = cJSON_Print(json), _stripwhite(str,' '); if ( freeflag != 0 ) free_json(json); return(str); }
/** Considers user-defined configuration. Loads and parses user-defined configuration * '.config.json' present in user's home directory for 'plugin interface' and * 'plugins' configuration properties and concats with iotkit-comm configuration properties. */ void concatUserDefinedConfigurations() { char *home, config_file[1024]; home = getenv("HOME"); if (home == NULL || strlen(home) == 0) { struct passwd *pw = getpwuid(getuid()); home = pw->pw_dir; } strcpy(config_file, home); if (*(home + (strlen(home) - 1)) != '/') { strcat(config_file, "/"); } strcat(config_file, USER_CONFIG_FILENAME); char *out; cJSON *json = NULL, *jitem; FILE *fp = fopen(config_file, "rb"); if (fp == NULL) { fprintf(stderr,"Warning: Optional user config file not found. Continuing...\n"); } else { fseek(fp, 0, SEEK_END); long size = ftell(fp); rewind(fp); // read the file char *buffer = (char *)malloc(size+1); if (buffer != NULL) { fread(buffer, 1, size, fp); // parse the file json = cJSON_Parse(buffer); } if (json == NULL || !json) { fprintf(stderr,"Error before: [%s]\n",cJSON_GetErrorPtr()); } else { #if DEBUG out = cJSON_Print(json, 2); fprintf(stderr,"%s\n", out); free(out); #endif if (!isJsonObject(json)) { handleParseConfigError(); } jitem = cJSON_GetObjectItem(json, "pluginInterfaceDirPaths"); if (!isJsonString(jitem)) { handleParseConfigError(); } int pathSize = strlen(g_configData.pluginInterfaceDir) + strlen(jitem->valuestring) + 2; char *pluginInterfaceDirPaths = (char *)malloc(sizeof(char) * pathSize); if (pluginInterfaceDirPaths != NULL) { strcpy(pluginInterfaceDirPaths, g_configData.pluginInterfaceDir); strcat(pluginInterfaceDirPaths, ":"); strcat(pluginInterfaceDirPaths, jitem->valuestring); g_configData.pluginInterfaceDir = pluginInterfaceDirPaths; } #if DEBUG printf("pluginInterfaceDir = %s\n", g_configData.pluginInterfaceDir); #endif jitem = cJSON_GetObjectItem(json, "pluginDirPaths"); if (!isJsonString(jitem)) { handleParseConfigError(); } pathSize = strlen(g_configData.pluginDir) + strlen(jitem->valuestring) + 2; char *pluginDirPaths = (char *)malloc(sizeof(char) * pathSize); if (pluginDirPaths != NULL) { strcpy(pluginDirPaths, g_configData.pluginDir); strcat(pluginDirPaths, ":"); strcat(pluginDirPaths, jitem->valuestring); g_configData.pluginDir = pluginDirPaths; } #if DEBUG printf("pluginDir = %s\n", g_configData.pluginDir); #endif endParseConfig: cJSON_Delete(json); } free(buffer); fclose(fp); // close the file pointer } }
OCEntityHandlerResult ProcessPostRequest (OCEntityHandlerRequest *ehRequest, OCEntityHandlerResponse *response, char *payload, uint16_t maxPayloadSize) { OCEntityHandlerResult ehResult = OC_EH_OK; char *respPLPost_light = NULL; cJSON *json; cJSON *format; /* * The entity handler determines how to process a POST request. * Per the REST paradigm, POST can also be used to update representation of existing * resource or create a new resource. * In the sample below, if the POST is for /a/light then a new instance of the Light * resource is created with default representation (if representation is included in * POST payload it can be used as initial values) as long as the instance is * lesser than max new instance count. Once max instance count is reached, POST on * /a/light updated the representation of /a/light (just like PUT) */ if (ehRequest->resource == Light.handle) { if (gCurrLightInstance < SAMPLE_MAX_NUM_POST_INSTANCE) { // Create new Light instance char newLightUri[URI_MAXSIZE]; snprintf(newLightUri, URI_MAXSIZE, "/a/light/%d", gCurrLightInstance); json = cJSON_CreateObject(); cJSON_AddStringToObject(json,"href",gResourceUri); cJSON_AddItemToObject(json, "rep", format=cJSON_CreateObject()); cJSON_AddStringToObject(format, "createduri", (char *) newLightUri); if (0 == createLightResource (newLightUri, &gLightInstance[gCurrLightInstance])) { OC_LOG (INFO, TAG, "Created new Light instance\n"); gLightInstance[gCurrLightInstance].state = 0; gLightInstance[gCurrLightInstance].power = 0; gCurrLightInstance++; respPLPost_light = cJSON_Print(json); strncpy ((char *)response->resourceUri, newLightUri, MAX_URI_LENGTH); ehResult = OC_EH_RESOURCE_CREATED; } cJSON_Delete(json); } else { // Update repesentation of /a/light Light.state = true; Light.power = 11; respPLPost_light = constructJsonResponse(ehRequest); } } else { for (int i = 0; i < SAMPLE_MAX_NUM_POST_INSTANCE; i++) { if (ehRequest->resource == gLightInstance[i].handle) { gLightInstance[i].state = true; gLightInstance[i].power = 22; if (i == 0) { respPLPost_light = constructJsonResponse(ehRequest); break; } else if (i == 1) { respPLPost_light = constructJsonResponse(ehRequest); } } } } if ((respPLPost_light != NULL) && (maxPayloadSize > strlen ((char *)respPLPost_light))) { strncpy(payload, respPLPost_light, strlen((char *)respPLPost_light)); } else { OC_LOG_V (INFO, TAG, "Response buffer: %d bytes is too small", maxPayloadSize); ehResult = OC_EH_ERROR; } free(respPLPost_light); return ehResult; }
int32_t PLUGNAME(_process_json)(char *forwarder,char *sender,int32_t valid,struct plugin_info *plugin,uint64_t tag,char *retbuf,int32_t maxlen,char *jsonstr,cJSON *json,int32_t initflag,char *tokenstr) { char *resultstr,*methodstr,zerobuf[1],*coinstr,*str = 0; cJSON *array,*item; int32_t i,n,j = 0; struct coin777 *coin; struct destbuf tmp; retbuf[0] = 0; if ( initflag > 0 ) { if ( json != 0 ) { COINS.argjson = cJSON_Duplicate(json,1); COINS.slicei = get_API_int(cJSON_GetObjectItem(json,"slice"),0); if ( (array= cJSON_GetObjectItem(json,"coins")) != 0 && (n= cJSON_GetArraySize(array)) > 0 ) { for (i=j=0; i<n; i++) { item = cJSON_GetArrayItem(array,i); coinstr = cJSON_str(cJSON_GetObjectItem(item,"name")); if ( coinstr != 0 && coinstr[0] != 0 && (coin= coin777_find(coinstr,0)) == 0 ) { printf("CALL coin777_create.(%s) (%s)\n",coinstr,cJSON_Print(item)); coin777_create(coinstr,item); } } } } else strcpy(retbuf,"{\"result\":\"no JSON for init\"}"); COINS.readyflag = 1; plugin->allowremote = 1; //plugin->sleepmillis = 1; } else { if ( plugin_result(retbuf,json,tag) > 0 ) return((int32_t)strlen(retbuf)); resultstr = cJSON_str(cJSON_GetObjectItem(json,"result")); methodstr = cJSON_str(cJSON_GetObjectItem(json,"method")); coinstr = cJSON_str(cJSON_GetObjectItem(json,"coin")); if ( methodstr == 0 || methodstr[0] == 0 ) { printf("(%s) has not method\n",jsonstr); return(0); } //printf("COINS.(%s) for (%s) (%s)\n",methodstr,coinstr!=0?coinstr:"",jsonstr); if ( resultstr != 0 && strcmp(resultstr,"registered") == 0 ) { plugin->registered = 1; strcpy(retbuf,"{\"result\":\"activated\"}"); } else { zerobuf[0] = 0; str = 0; //printf("INSIDE COINS.(%s) methods.%ld\n",jsonstr,sizeof(coins_methods)/sizeof(*coins_methods)); copy_cJSON(&tmp,cJSON_GetObjectItem(json,"NXT")), safecopy(sender,tmp.buf,32); if ( coinstr == 0 ) coinstr = zerobuf; else coin = coin777_find(coinstr,1); #ifdef INSIDE_MGW if ( strcmp(methodstr,"acctpubkeys") == 0 ) { if ( SUPERNET.gatewayid >= 0 ) { if ( coinstr[0] == 0 ) strcpy(retbuf,"{\"result\":\"need to specify coin\"}"); else if ( (coin= coin777_find(coinstr,1)) != 0 ) { int32_t MGW_publish_acctpubkeys(char *coinstr,char *str); char *get_msig_pubkeys(char *coinstr,char *serverport,char *userpass); if ( (str= get_msig_pubkeys(coin->name,coin->serverport,coin->userpass)) != 0 ) { MGW_publish_acctpubkeys(coin->name,str); strcpy(retbuf,"{\"result\":\"published and processed acctpubkeys\"}"); free(str), str= 0; } else sprintf(retbuf,"{\"error\":\"no get_msig_pubkeys result\",\"method\":\"%s\"}",methodstr); } else sprintf(retbuf,"{\"error\":\"no coin777\",\"method\":\"%s\"}",methodstr); } else sprintf(retbuf,"{\"error\":\"gateway only method\",\"method\":\"%s\"}",methodstr); } else if ( strcmp(methodstr,"gotmsigaddr") == 0 ) { if ( SUPERNET.gatewayid < 0 ) printf("GOTMSIG.(%s)\n",jsonstr); } else #endif sprintf(retbuf,"{\"error\":\"unsupported method\",\"method\":\"%s\"}",methodstr); } } //printf("<<<<<<<<<<<< INSIDE PLUGIN.(%s) initflag.%d process %s slice.%d\n",SUPERNET.myNXTaddr,initflag,plugin->name,COINS.slicei); return(plugin_copyretstr(retbuf,maxlen,str)); }
void data_sel() { int rc=0; char *out; char sql[250]={0}; const char *box_id=NULL,*city_id=NULL,*city_name=NULL,*site_id=NULL,*site_name=NULL,*area_id=NULL,*area_name=NULL,*guide_id=NULL,*guide_name=NULL,*type=NULL,*tel=NULL,*gps=NULL,*province_id=NULL,*province_name=NULL; sqlite3 *db; sqlite3_stmt *ppstmt=NULL; cJSON *root; rc = sqlite3_open("/ailvgo/www/database/box.db",&db); if((rc != SQLITE_OK)&&(MODEL==1)) { printf("open database error_sel!\n"); } // printf("mobile:%s\n",ptr1); // printf("time:%s\n",ptr2); memset(sql,0,sizeof(sql)); sprintf(sql,"select box_id,city_id,city_name,site_id,site_name,area_id,area_name,guide_id,guide_name, type,province_id,province_name,tel,gps from box_info"); rc=sqlite3_prepare(db,sql,-1,&ppstmt,0); if((rc != SQLITE_OK)&&(MODEL==1)) { fprintf(stderr,"SQL error:%s \n",sqlite3_errmsg(db)); } rc=sqlite3_step(ppstmt); if(rc==SQLITE_ROW) { root=cJSON_CreateObject(); while(rc == SQLITE_ROW) { box_id=sqlite3_column_text(ppstmt,0); city_id=sqlite3_column_text(ppstmt,1); city_name=sqlite3_column_text(ppstmt,2); site_id=sqlite3_column_text(ppstmt,3); // printf("site_id:%s\n",site_id); site_name=sqlite3_column_text(ppstmt,4); area_id=sqlite3_column_text(ppstmt,5); area_name=sqlite3_column_text(ppstmt,6); guide_id=sqlite3_column_text(ppstmt,7); guide_name=sqlite3_column_text(ppstmt,8); type=sqlite3_column_text(ppstmt,9); province_id=sqlite3_column_text(ppstmt,10); province_name=sqlite3_column_text(ppstmt,11); tel=sqlite3_column_text(ppstmt,12); gps=sqlite3_column_text(ppstmt,13); cJSON_AddStringToObject(root,"type", type); cJSON_AddStringToObject(root,"box_id", box_id); cJSON_AddStringToObject(root,"province_id", province_id); cJSON_AddStringToObject(root,"province_name",province_name); cJSON_AddStringToObject(root,"city_id", city_id); cJSON_AddStringToObject(root,"city_name",city_name); if(NULL != site_id) { cJSON_AddStringToObject(root,"gps",gps); cJSON_AddStringToObject(root,"tel",tel); cJSON_AddStringToObject(root,"site_id",site_id); cJSON_AddStringToObject(root,"site_name",site_name); cJSON_AddStringToObject(root,"area_id",area_id); cJSON_AddStringToObject(root,"area_name",area_name); if(NULL != guide_id) { cJSON_AddStringToObject(root,"guide_id",guide_id); cJSON_AddStringToObject(root,"guide_name",guide_name); } } rc = sqlite3_step(ppstmt); } out =cJSON_Print(root); printf("%s\n",out); // printf("1"); cJSON_Delete(root); free(out); } else { printf(""); } sqlite3_finalize(ppstmt); sqlite3_close(db); }
//test begin---------------------------- void testJson(char* buf,int n){ int i,j; printf(">>testJson() ~000>>buf size:%d >>buf is:%s \n",n,buf); printf(">>testJson() ~000>>buf size:%d \n",n); if(n<=0) return; char bufNew[n]; for(i=0;i<n;i++){ bufNew[i] = buf[i]; } /* //test begin lilei char ** str; char a[2] ="ab"; int len; len = base64DecodeStringRemoveEndZero(a,str); printf(">>testJson() 111.2.1 a is:%s\n",a); printf(">>testJson() 111.2>>decode str is:%s >>len:%d \n",*str,len); return; //test end */ char packageName[SMALL_TEXT_BUFFER_SIZE]; char className[SMALL_TEXT_BUFFER_SIZE]; char title[SMALL_TEXT_BUFFER_SIZE]; char byteMap[BYTEMAP_BUFFER_SIZE]; char * jsonStr; cJSON *fmt = NULL,*JSONroot = NULL,*mJSONroot; JSONroot = cJSON_Parse(bufNew); int num = cJSON_GetArraySize(JSONroot);//check arrays printf(">>testJson() 222>>json root size is:%d \n",num); fmt = cJSON_GetObjectItem(JSONroot,KEY_MESSAGE_TYPE); int msgType = fmt->valueint; printf(">>testJson() 33>>msgType is:%d \n",msgType); if(isInArray(msgType,jsonContainPackage,sizeof(jsonContainPackage)/sizeof(short))){ fmt = cJSON_GetObjectItem(JSONroot,KEY_PACKAGE_NAME); bzero(packageName,SMALL_TEXT_BUFFER_SIZE); //clear packageName snprintf(packageName,SMALL_TEXT_BUFFER_SIZE,"%s",fmt->valuestring); printf(">>testJson() 33>>packageName is:%s \n",packageName); } if(isInArray(msgType,jsonContainClass,sizeof(jsonContainClass)/sizeof(short))){ fmt = cJSON_GetObjectItem(JSONroot,KEY_CLASS_NAME); bzero(className,SMALL_TEXT_BUFFER_SIZE); //clear className snprintf(className,SMALL_TEXT_BUFFER_SIZE,"%s",fmt->valuestring); printf(">>testJson() 33>className is:%s>>className len is:%ld \n",className,strlen(className)); } if(isInArray(msgType,jsonContainTitle,sizeof(jsonContainTitle)/sizeof(short))){ fmt = cJSON_GetObjectItem(JSONroot,KEY_CLASS_TITLE); bzero(title,SMALL_TEXT_BUFFER_SIZE); //clear title snprintf(title,SMALL_TEXT_BUFFER_SIZE,"%s",fmt->valuestring); int length = strlen(title); int lenDec = -1; char * convert = base64_decode(title,length,&lenDec); int lenBase64 = strlen(convert); printf(">>testJson() 33>>base64 decode title is:%s >>title is:%s \n",convert,title); int i; printf(">>testJson() 33>>base64 decode title length is:%d >>origin title length is:%d \n",lenBase64,length); for(i = 0;i<lenBase64;i++){ printf(">>testJson() 33>titile convert[%d]:%d \n",i,convert[i]); } } if(isInArray(msgType,jsonContainBytemap,sizeof(jsonContainBytemap)/sizeof(short))){ fmt = cJSON_GetObjectItem(JSONroot,KEY_BYTEMAP); bzero(byteMap,BYTEMAP_BUFFER_SIZE); //clear byteMap snprintf(byteMap,BYTEMAP_BUFFER_SIZE,"%s",fmt->valuestring); //printf(">>testJson() 33>byteMap is:%s \n",byteMap); printf(">>testJson() 33>byteMap length is:%ld \n",strlen(byteMap)); writePngFileBase64(byteMap,strlen(byteMap),className,strlen(className));//save image printf(">>testJson() 33>byteMap of %s save end>>time is:%ld \n",className,getNowMills()); } if(isInArray(msgType,jsonContainAllAppInfo,sizeof(jsonContainAllAppInfo)/sizeof(short))){ fmt = cJSON_GetObjectItem(JSONroot,KEY_ALL_APPS); //this fmt is array [...] //char allAppInfo[LONG_TEXT_BUFFER_SIZE]; int arraySize = cJSON_GetArraySize(fmt); //snprintf(allAppInfo,LONG_TEXT_BUFFER_SIZE,"%s",fmt->valuestring); printf(">>testJson() 33>all app size is:%d \n",arraySize); cJSON * jsonApp = fmt->child; int appNum = 0; while(jsonApp != NULL){ int count = cJSON_GetArraySize(jsonApp); fmt = cJSON_GetObjectItem(jsonApp,KEY_PACKAGE_NAME); //this fmt is object bzero(packageName,SMALL_TEXT_BUFFER_SIZE); //clear packageName snprintf(packageName,SMALL_TEXT_BUFFER_SIZE,"%s",fmt->valuestring); fmt = cJSON_GetObjectItem(jsonApp,KEY_CLASS_NAME); bzero(className,SMALL_TEXT_BUFFER_SIZE); //clear className snprintf(className,SMALL_TEXT_BUFFER_SIZE,"%s",fmt->valuestring); jsonApp = jsonApp->next; //printf(">>testJson() 33>>packageName:%s >>className:%s \n",packageName,className); //get one app appNum++; if(appNum >= 0){ printf(">>testJson() 33>>packageName:%s >>className:%s \n",packageName,className); mJSONroot = cJSON_CreateObject(); //for send to android cJSON_AddItemToObject(mJSONroot,KEY_MESSAGE_TYPE,cJSON_CreateNumber(MESSAGE_LINUX_GETONEAPP)); cJSON_AddItemToObject(mJSONroot,KEY_PACKAGE_NAME,cJSON_CreateString(packageName)); cJSON_AddItemToObject(mJSONroot,KEY_CLASS_NAME,cJSON_CreateString(className)); jsonStr = cJSON_Print(mJSONroot); cJSON_Delete(mJSONroot); printf(">>testJson() 33>>appNum == %d~~~~~~~~~~~~~~should send\n",appNum); sendMsgToAndroid(jsonStr); //if get all app should not do below } } // cJSON_Delete(JSONroot); // return; //if get all app should not do below } //perse action mJSONroot = cJSON_CreateObject(); //for send to android switch(msgType){ case MESSAGE_ANDROID_READY: cJSON_AddItemToObject(mJSONroot,KEY_MESSAGE_TYPE,cJSON_CreateNumber(MESSAGE_LINUX_GETALL)); jsonStr = cJSON_Print(mJSONroot); //printf(">>testJson() 444>>should send message is:%s >>length is:%ld \n",jsonStr,strlen(jsonStr)); sendMsgToAndroid(jsonStr); break; default: ; } //cJSON_Delete(fmt); cJSON_Delete(JSONroot); cJSON_Delete(mJSONroot); }
BOARD conectar(char *name,BOARD *Board) { BITBOARD BitBoard; int tamanho; char cor; char retorno[10000]; printf("\nInitialising Winsock..."); if (WSAStartup(MAKEWORD(2,2),&wsa) != 0) { printf("Failed. Error Code : %d",WSAGetLastError()); Board=NULL; return *Board; } printf("Initialised."); if((s = socket(AF_INET , SOCK_STREAM , 0 )) == INVALID_SOCKET) { printf("Could not create socket : %d" , WSAGetLastError()); } printf("Socket created.\n"); server.sin_addr.s_addr = inet_addr("127.0.0.1"); server.sin_family = AF_INET; while(cor!= 'b' && cor!='p') { printf("\nEscolha a cor para jogar( b- brancas 50100 , p- pretas 50200 )\n"); cor=getchar(); cor=tolower(cor); if(cor=='b') server.sin_port = htons( 50100 ); if(cor=='p') server.sin_port = htons( 50200 ); } //Connect to remote server if (connect(s , (struct sockaddr *)&server , sizeof(server)) < 0) { puts("connect error"); Board=NULL; return *Board; } puts("Connected"); cJSON *entrada,*saida; entrada=cJSON_CreateObject(); cJSON_AddItemToObject(entrada, "name", cJSON_CreateString("Bobot")); name=cJSON_PrintUnformatted(entrada); puts(name); if( send(s , name , strlen(name) , 0) < 0) { puts("Send failed"); Board=NULL; return *Board; } puts("Data Send\n"); if((tamanho = recv(s , retorno , 10000 , 0)) == SOCKET_ERROR) { puts("recv failed"); Board=NULL; return *Board; } int i; retorno[tamanho]='\0'; puts("Reply received\n"); saida=cJSON_Parse(retorno); name=cJSON_Print(saida); puts(name); Board->whiteInfractions=cJSON_GetObjectItem(saida,"white_infractions")->valueint; Board->blackInfractions=cJSON_GetObjectItem(saida,"black_infractions")->valueint; Board->fiftymoves=cJSON_GetObjectItem(saida,"50moves")->valueint; Board->enpassant[0]=cJSON_GetObjectItem(saida,"enpassant")->valueint; Board->enpassant[1]=cJSON_GetObjectItem(saida,"enpassant")->next->valueint; Board->draw=cJSON_GetObjectItem(saida,"draw")->valueint; Board->badmove=cJSON_GetObjectItem(saida,"bad_move")->valueint; Board->winner= cJSON_GetObjectItem(saida,"winner")->valueint; for(i=0;i<BOARD_SIZE;i++) Board->board[i]=cJSON_GetObjectItem(saida,"board")->valuestring[i]; Board->whoMoves=cJSON_GetObjectItem(saida,"who_moves")->valueint; int whoMoves=Board->whoMoves; printf("%d\n",whoMoves); BitBoard=BoardParser(whoMoves,Board->board); return *Board; }
static void connection_cb(struct ev_loop *loop, ev_io *w, int revents) { struct jrpc_connection *conn; struct jrpc_server *server = (struct jrpc_server *) w->data; size_t bytes_read = 0; //get our 'subclassed' event watcher conn = (struct jrpc_connection *) w; int fd = conn->fd; if (conn->pos == (conn->buffer_size - 1)) { char * new_buffer = realloc(conn->buffer, conn->buffer_size *= 2); if (new_buffer == NULL) { perror("Memory error"); return close_connection(loop, w); } conn->buffer = new_buffer; memset(conn->buffer + conn->pos, 0, conn->buffer_size - conn->pos); } // can not fill the entire buffer, string must be NULL terminated int max_read_size = conn->buffer_size - conn->pos - 1; if ((bytes_read = read(fd, conn->buffer + conn->pos, max_read_size)) == -1) { perror("read"); return close_connection(loop, w); } if (!bytes_read) { // client closed the sending half of the connection if (server->debug_level) printf("Client closed connection.\n"); return close_connection(loop, w); } else { cJSON *root; char *end_ptr = NULL; conn->pos += bytes_read; if ((root = cJSON_Parse_Stream(conn->buffer, &end_ptr)) != NULL) { if (server->debug_level > 1) { char * str_result = cJSON_Print(root); printf("Valid JSON Received:\n%s\n", str_result); free(str_result); } if (root->type == cJSON_Object) { eval_request(server, conn, root); } //shift processed request, discarding it memmove(conn->buffer, end_ptr, strlen(end_ptr) + 2); conn->pos = strlen(end_ptr); memset(conn->buffer + conn->pos, 0, conn->buffer_size - conn->pos - 1); cJSON_Delete(root); } else { // did we parse the all buffer? If so, just wait for more. // else there was an error before the buffer's end if (end_ptr != (conn->buffer + conn->pos)) { if (server->debug_level) { printf("INVALID JSON Received:\n---\n%s\n---\n", conn->buffer); } send_error(conn, JRPC_PARSE_ERROR, strdup( "Parse error. Invalid JSON was received by the server."), NULL); return close_connection(loop, w); } } } }
void StatQuery_Prepare( stat_query_t *query ) { if( !query->req && query->url ) { // GET request, finish the url and create the object query->req = wswcurl_create( query->url ); } // only allow json for POST requests else if( query->has_json ) { const char *json_text; size_t jsonSize, b64Size; unsigned long compSize; void *compData, *b64Data; int z_result; if( query->url ) { Com_Printf( "StatQuery: Tried to add JSON field to GET request\n" ); return; } json_text = cJSON_Print( query->json_out ); jsonSize = strlen( json_text ); // compress compSize = (jsonSize * 1.1) + 12; compData = SQALLOC( compSize ); if( compData == NULL ) { Com_Printf("StatQuery: Failed to allocate space for compressed JSON\n"); return; } z_result = compress( compData, &compSize, (unsigned char*)json_text, jsonSize ); if( z_result != Z_OK ) { Com_Printf("StatQuery: Failed to compress JSON\n"); SQFREE( compData ); return; } // base64 b64Data = base64_encode( compData, compSize, &b64Size ); if( b64Data == NULL ) { Com_Printf("StatQuery: Failed to base64_encode JSON\n"); SQFREE( compData ); return; } // Com_Printf("Match report size: %u, compressed: %u, base64'd: %u\n", reportSize, compSize, b64Size ); // we dont need this anymore SQFREE( compData ); compData = NULL; // set the json field to POST request wswcurl_formadd_raw( query->req, "data", b64Data, b64Size ); SQFREE( b64Data ); } }
/* Create a bunch of objects as demonstration. */ static int print_preallocated(cJSON *root) { /* declarations */ char *out = NULL; char *buf = NULL; char *buf_fail = NULL; int len = 0; int len_fail = 0; /* formatted print */ out = cJSON_Print(root); /* create buffer to succeed */ /* the extra 64 bytes are in case a floating point value is printed */ len = strlen(out) + 64; buf = (char*)malloc(len); if (buf == NULL) { printf("Failed to allocate memory.\n"); exit(1); } /* create buffer to fail */ len_fail = strlen(out); buf_fail = (char*)malloc(len_fail); if (buf_fail == NULL) { printf("Failed to allocate memory.\n"); exit(1); } /* Print to buffer */ if (!cJSON_PrintPreallocated(root, buf, len, 1)) { printf("cJSON_PrintPreallocated failed!\n"); if (strcmp(out, buf) != 0) { printf("cJSON_PrintPreallocated not the same as cJSON_Print!\n"); printf("cJSON_Print result:\n%s\n", out); printf("cJSON_PrintPreallocated result:\n%s\n", buf); } free(out); free(buf_fail); free(buf); return -1; } /* success */ printf("%s\n", buf); /* force it to fail */ if (cJSON_PrintPreallocated(root, buf_fail, len_fail, 1)) { printf("cJSON_PrintPreallocated failed to show error with insufficient memory!\n"); printf("cJSON_Print result:\n%s\n", out); printf("cJSON_PrintPreallocated result:\n%s\n", buf_fail); free(out); free(buf_fail); free(buf); return -1; } free(out); free(buf_fail); free(buf); return 0; }
/* Create a bunch of objects as demonstration. */ void create_objects() { cJSON *root, *fmt, *img, *thm, *fld; char *out; int i; /* declare a few. */ /* Our "days of the week" array: */ const char *strings[7] = { "Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday" }; /* Our matrix: */ int numbers[3][3] = { { 0,-1,0 },{ 1,0,0 },{ 0,0,1 } }; /* Our "gallery" item: */ int ids[4] = { 116,943,234,38793 }; /* Our array of "records": */ struct record fields[2] = { { "zip",37.7668,-1.223959e+2,"","SAN FRANCISCO","CA","94107","US" }, { "zip",37.371991,-1.22026e+2,"","SUNNYVALE","CA","94085","US" } }; /* Here we construct some JSON standards, from the JSON site. */ /* Our "Video" datatype: */ root = cJSON_CreateObject(); cJSON_AddItemToObject(root, "name", cJSON_CreateString("Jack (\"Bee\") Nimble")); cJSON_AddItemToObject(root, "format", fmt = cJSON_CreateObject()); cJSON_AddStringToObject(fmt, "type", "rect"); cJSON_AddNumberToObject(fmt, "width", 1920); cJSON_AddNumberToObject(fmt, "height", 1080); cJSON_AddFalseToObject(fmt, "interlace"); cJSON_AddNumberToObject(fmt, "frame rate", 24); out = cJSON_Print(root); cJSON_Delete(root); printf("%s\n", out); free(out); /* Print to text, Delete the cJSON, print it, release the string. */ /* Our "days of the week" array: */ root = cJSON_CreateStringArray(strings, 7); out = cJSON_Print(root); cJSON_Delete(root); printf("%s\n", out); free(out); /* Our matrix: */ root = cJSON_CreateArray(); for (i = 0; i<3; i++) cJSON_AddItemToArray(root, cJSON_CreateIntArray(numbers[i], 3)); /* cJSON_ReplaceItemInArray(root,1,cJSON_CreateString("Replacement")); */ out = cJSON_Print(root); cJSON_Delete(root); printf("%s\n", out); free(out); /* Our "gallery" item: */ root = cJSON_CreateObject(); cJSON_AddItemToObject(root, "Image", img = cJSON_CreateObject()); cJSON_AddNumberToObject(img, "Width", 800); cJSON_AddNumberToObject(img, "Height", 600); cJSON_AddStringToObject(img, "Title", "View from 15th Floor"); cJSON_AddItemToObject(img, "Thumbnail", thm = cJSON_CreateObject()); cJSON_AddStringToObject(thm, "Url", "http:/*www.example.com/image/481989943"); cJSON_AddNumberToObject(thm, "Height", 125); cJSON_AddStringToObject(thm, "Width", "100"); cJSON_AddItemToObject(img, "IDs", cJSON_CreateIntArray(ids, 4)); out = cJSON_Print(root); cJSON_Delete(root); printf("%s\n", out); free(out); /* Our array of "records": */ root = cJSON_CreateArray(); for (i = 0; i<2; i++) { cJSON_AddItemToArray(root, fld = cJSON_CreateObject()); cJSON_AddStringToObject(fld, "precision", fields[i].precision); cJSON_AddNumberToObject(fld, "Latitude", fields[i].lat); cJSON_AddNumberToObject(fld, "Longitude", fields[i].lon); cJSON_AddStringToObject(fld, "Address", fields[i].address); cJSON_AddStringToObject(fld, "City", fields[i].city); cJSON_AddStringToObject(fld, "State", fields[i].state); cJSON_AddStringToObject(fld, "Zip", fields[i].zip); cJSON_AddStringToObject(fld, "Country", fields[i].country); } /* cJSON_ReplaceItemInObject(cJSON_GetArrayItem(root,1),"City",cJSON_CreateIntArray(ids,4)); */ out = cJSON_Print(root); cJSON_Delete(root); printf("%s\n", out); free(out); }
int main() { char AccessKey[256]={0}; char ScreteKey[256]={0}; char Space[64]={0}; char Path[256]={0}; time_t deadline; ReadUploadInfo("./Information.ini", AccessKey, ScreteKey, Space, Path); std::vector<FileInfo> fi; ScanAllFile(Path,fi); Qiniu_Client client; QINIU_ACCESS_KEY=(const char *)AccessKey; QINIU_SECRET_KEY=(const char *)ScreteKey; Qiniu_Servend_Init(-1); Qiniu_Client_InitMacAuth(&client, 1024, NULL); printf("\n\nStart Uploading...\n"); for(std::vector<FileInfo>::const_iterator it = fi.begin(); it < fi.end(); ++it) { char hash[29]=""; memcpy(hash,it->Hash,28); bool ft=repeatcheck(&client, Space, it->FileLocalInfo,hash); if (ft) continue; char *output; char encodedPutPolicy[256]={0}; time_t deadline; time(&deadline); deadline=deadline+7200; unsigned char hmac_sha1code[256]={0}; unsigned int hmac_sha1code_length; char encodesign[512]={0}; char scope[256]=""; cJSON *fmt; fmt=cJSON_CreateObject(); sprintf_s(scope,256,"%s:%s",Space,it->FileLocalInfo); cJSON_AddStringToObject(fmt,"scope",scope); cJSON_AddNumberToObject(fmt,"deadline",deadline); output=cJSON_Print(fmt); printf("%s\n",output); //Get Code 3£ºencodedPutPolicy size_t destlength=urlsafe_b64_encode(output,strlen(output),encodedPutPolicy,256); printf("encodedPutPolicy=%s\n",encodedPutPolicy); //Get Code 2£ºencodesign unsigned char *sign = HMAC(EVP_sha1(),ScreteKey,strlen(ScreteKey), (const unsigned char *)encodedPutPolicy,destlength, (unsigned char *) hmac_sha1code, &hmac_sha1code_length); destlength=urlsafe_b64_encode(hmac_sha1code,strlen((const char *)hmac_sha1code),encodesign,256); char UpLoadToken[1024]; sprintf_s(UpLoadToken,"%s:%s:%s",AccessKey,encodesign,encodedPutPolicy); char *LocalHashCode=upload(&client, UpLoadToken, it->FileLocalInfo, it->FileGlobalInfo); //if (LocalHashCode == NULL) //{ // int uploadflag=resumable_upload(&client, UpLoadToken, // it->FileLocalInfo, it->FileGlobalInfo,Space); //} free(output); } printf("\n\nStop Uploading...\n"); Qiniu_Client_Cleanup(&client); Qiniu_Servend_Cleanup(); }
int32_t PLUGNAME(_process_json)(char *forwarder,char *sender,int32_t valid,struct plugin_info *plugin,uint64_t tag,char *retbuf,int32_t maxlen,char *origjsonstr,cJSON *origjson,int32_t initflag,char *tokenstr) { char *resultstr,*retstr = 0,*methodstr,*jsonstr,*destplugin,*submethod; struct destbuf tagstr,endpoint; cJSON *retjson,*json,*tokenobj; uint32_t nonce; struct applicant_info apply; retbuf[0] = 0; if ( tokenstr == 0 ) tokenstr = ""; if ( is_cJSON_Array(origjson) != 0 && cJSON_GetArraySize(origjson) == 2 ) json = cJSON_GetArrayItem(origjson,0), jsonstr = cJSON_Print(json), _stripwhite(jsonstr,' '); else json = origjson, jsonstr = origjsonstr; if ( Debuglevel > 2 ) printf("<<<<<<<<<<<< INSIDE relays PLUGIN! process %s [(%s).(%s)]\n",plugin->name,jsonstr,tokenstr); if ( initflag > 0 ) { // configure settings RELAYS.readyflag = 1; plugin->allowremote = 1; strcpy(retbuf,"{\"result\":\"initflag > 0\"}"); } else { if ( plugin_result(retbuf,json,tag) > 0 ) return((int32_t)strlen(retbuf)); resultstr = cJSON_str(cJSON_GetObjectItem(json,"result")); methodstr = cJSON_str(cJSON_GetObjectItem(json,"method")); destplugin = cJSON_str(cJSON_GetObjectItem(json,"destplugin")); submethod = cJSON_str(cJSON_GetObjectItem(json,"submethod")); if ( methodstr == 0 || methodstr[0] == 0 ) { printf("(%s) has not method\n",jsonstr); return(0); } //fprintf(stderr,"RELAYS methodstr.(%s) (%s)\n",methodstr,jsonstr); if ( resultstr != 0 && strcmp(resultstr,"registered") == 0 ) { plugin->registered = 1; strcpy(retbuf,"{\"result\":\"activated\"}"); } #ifdef INSIDE_MGW else if ( strcmp(methodstr,"msigaddr") == 0 ) { char *devMGW_command(char *jsonstr,cJSON *json); if ( SUPERNET.gatewayid >= 0 ) retstr = devMGW_command(jsonstr,json); } #endif else { strcpy(retbuf,"{\"result\":\"relay command under construction\"}"); if ( strcmp(methodstr,"list") == 0 ) retstr = relays_jsonstr(jsonstr,json); else if ( strcmp(methodstr,"telepathy") == 0 ) { sprintf(retbuf,"%s",jsonstr); } else if ( strcmp(methodstr,"busdata") == 0 ) { retstr = busdata_sync(&nonce,jsonstr,cJSON_str(cJSON_GetObjectItem(json,"broadcast")),0); // {"plugin":"relay","method":"busdata","destplugin":"relay","submethod":"join","broadcast":"join","endpoint":""} } else if ( strcmp(methodstr,"allservices") == 0 ) { if ( (retjson= serviceprovider_json()) != 0 ) { retstr = cJSON_Print(retjson), _stripwhite(retstr,' '); free_json(retjson); //printf("got.(%s)\n",retstr); } else printf("null serviceprovider_json()\n"); } else if ( strcmp(methodstr,"protocol") == 0 || strcmp(methodstr,"allprotocols") == 0 ) { if ( strcmp(methodstr,"protocol") == 0 && valid > 0 ) protocols_register(sender,jstr(json,"protocol"),jstr(json,"endpoint"),jint(json,"disconnect")); if ( (retjson= protocols_json(jstr(json,"protocol"))) != 0 ) { retstr = cJSON_Print(retjson), _stripwhite(retstr,' '); free_json(retjson); } else printf("null protocols_json()\n"); } else if ( strcmp(methodstr,"join") == 0 ) { if ( SUPERNET.noncing == 0 ) { copy_cJSON(&tagstr,cJSON_GetObjectItem(json,"tag")); copy_cJSON(&endpoint,cJSON_GetObjectItem(json,"endpoint")); SUPERNET.noncing = 1; if ( SUPERNET.iamrelay != 0 ) { portable_thread_create((void *)calc_nonces,clonestr(endpoint.buf)); sprintf(retbuf,"{\"result\":\"noncing\",\"endpoint\":\"%s\"}",endpoint.buf); } //fprintf(stderr,"join or nonce.(%s)\n",retbuf); } } else if ( strcmp(methodstr,"nonce") == 0 ) { struct destbuf endpoint,sender,destpoint,relaypoint,globalpoint,noncestr; memset(&apply,0,sizeof(apply)); copy_cJSON(&destpoint,cJSON_GetObjectItem(json,"destpoint")); copy_cJSON(&endpoint,cJSON_GetObjectItem(json,"lbendpoint")); copy_cJSON(&relaypoint,cJSON_GetObjectItem(json,"relaypoint")); copy_cJSON(&globalpoint,cJSON_GetObjectItem(json,"globalpoint")); copy_cJSON(&sender,cJSON_GetObjectItem(json,"NXT")); if ( SUPERNET.noncing != 0 && strcmp(SUPERNET.lbendpoint,destpoint.buf) == 0 ) { if ( endpoint.buf[0] != 0 && tokenstr[0] != 0 && (tokenobj= cJSON_Parse(tokenstr)) != 0 ) { strcpy(apply.lbendpoint,endpoint.buf); strcpy(apply.relayendpoint,relaypoint.buf); strcpy(apply.globalendpoint,globalpoint.buf); apply.senderbits = calc_nxt64bits(sender.buf); copy_cJSON(&noncestr,cJSON_GetObjectItem(tokenobj,"nonce")); if ( noncestr.buf[0] != 0 ) apply.nonce = (uint32_t)calc_nxt64bits(noncestr.buf); //printf("tokenobj.(%s) -> nonce.%u\n",tokenstr,apply.nonce); free_json(tokenobj); recv_nonces(&apply); } } } } } return(plugin_copyretstr(retbuf,maxlen,retstr)); }
/** Parses iotkit-comm configuration file * @param[in] config_file path to the configuration file */ bool parseConfigFile(char *config_file) { char *out; cJSON *json = NULL, *jitem, *child, *subjson; bool status = true; FILE *fp = fopen(config_file, "rb"); if (fp == NULL) { fprintf(stderr,"Error can't open file %s\n", config_file); status = false; } else { fseek(fp, 0, SEEK_END); long size = ftell(fp); rewind(fp); // read the file char *buffer = (char *)malloc(size+1); if (buffer != NULL) { fread(buffer, 1, size, fp); // parse the file json = cJSON_Parse(buffer); } if (json == NULL || !json) { fprintf(stderr,"Error before: [%s]\n",cJSON_GetErrorPtr()); status = false; } else { #if DEBUG out = cJSON_Print(json, 2); fprintf(stderr,"%s\n", out); free(out); #endif if (!isJsonObject(json)) { handleParseConfigError(); } jitem = cJSON_GetObjectItem(json, "pluginInterfaceDir"); if (!isJsonString(jitem)) { handleParseConfigError(); } g_configData.pluginInterfaceDir = strdup(jitem->valuestring); #if DEBUG printf("pluginInterfaceDir = %s\n", g_configData.pluginInterfaceDir); #endif jitem = cJSON_GetObjectItem(json, "pluginDir"); if (!isJsonString(jitem)) { handleParseConfigError(); } g_configData.pluginDir = strdup(jitem->valuestring); #if DEBUG printf("pluginDir = %s\n", g_configData.pluginDir); #endif jitem = cJSON_GetObjectItem(json, "communication"); if (!isJsonObject(json)) { handleParseConfigError(); } subjson = cJSON_GetObjectItem(jitem, "pluginFileSuffixes"); if (!isJsonObject(json)) { handleParseConfigError(); } jitem = cJSON_GetObjectItem(subjson, "clientFileSuffix"); if (!isJsonString(jitem)) { handleParseConfigError(); } g_configData.clientFileSuffix = strdup(jitem->valuestring); #if DEBUG printf("clientFileSuffix = %s\n", g_configData.clientFileSuffix); #endif jitem = cJSON_GetObjectItem(subjson, "serverFileSuffix"); if (!isJsonString(jitem)) { handleParseConfigError(); } g_configData.serverFileSuffix = strdup(jitem->valuestring); #if DEBUG printf("serverFileSuffix = %s\n", g_configData.serverFileSuffix); #endif endParseConfig: cJSON_Delete(json); } free(buffer); fclose(fp); // close the file pointer } concatUserDefinedConfigurations(); return status; }
char *status_json_string(int no_cache, int periodical) { char *out = NULL; int pe; /* if we have a very recent status JSON available, return it instead. */ if (!no_cache) { if ((pe = pthread_mutex_lock(&status_json_mt))) { hlog(LOG_ERR, "status_json_string(): could not lock status_json_mt: %s", strerror(pe)); return NULL; } if (status_json_cached && (status_json_cache_t == tick || status_json_cache_t == tick - 1)) { out = hstrdup(status_json_cached); if ((pe = pthread_mutex_unlock(&status_json_mt))) { hlog(LOG_ERR, "status_json_string(): could not unlock status_json_mt: %s", strerror(pe)); hfree(out); return NULL; } return out; } if ((pe = pthread_mutex_unlock(&status_json_mt))) { hlog(LOG_ERR, "status_json_string(): could not unlock status_json_mt: %s", strerror(pe)); return NULL; } } /* Ok, go and build the JSON tree */ cJSON *root = cJSON_CreateObject(); if (http_status_options) cJSON_AddStringToObject(root, "status_options", http_status_options); status_check_motd(root); cJSON *server = cJSON_CreateObject(); cJSON_AddStringToObject(server, "server_id", serverid); cJSON_AddStringToObject(server, "admin", myadmin); cJSON_AddStringToObject(server, "email", myemail); cJSON_AddStringToObject(server, "software", PROGNAME); cJSON_AddStringToObject(server, "software_version", version_build); cJSON_AddStringToObject(server, "software_build_time", verstr_build_time); cJSON_AddStringToObject(server, "software_build_user", verstr_build_user); cJSON_AddStringToObject(server, "software_build_features", verstr_features); cJSON_AddNumberToObject(server, "uptime", tick - startup_tick); cJSON_AddNumberToObject(server, "tick_now", tick); cJSON_AddNumberToObject(server, "time_now", now); cJSON_AddNumberToObject(server, "time_started", startup_time); status_uname(server); cJSON_AddItemToObject(root, "server", server); cJSON *memory = cJSON_CreateObject(); #ifndef _FOR_VALGRIND_ struct cellstatus_t cellst; historydb_cell_stats(&cellst), cJSON_AddNumberToObject(memory, "historydb_cells_used", historydb_cellgauge); cJSON_AddNumberToObject(memory, "historydb_cells_free", cellst.freecount); cJSON_AddNumberToObject(memory, "historydb_used_bytes", historydb_cellgauge*cellst.cellsize_aligned); cJSON_AddNumberToObject(memory, "historydb_allocated_bytes", (long)cellst.blocks * (long)cellst.block_size); cJSON_AddNumberToObject(memory, "historydb_block_size", (long)cellst.block_size); cJSON_AddNumberToObject(memory, "historydb_blocks", (long)cellst.blocks); cJSON_AddNumberToObject(memory, "historydb_blocks_max", (long)cellst.blocks_max); cJSON_AddNumberToObject(memory, "historydb_cell_size", cellst.cellsize); cJSON_AddNumberToObject(memory, "historydb_cell_size_aligned", cellst.cellsize_aligned); cJSON_AddNumberToObject(memory, "historydb_cell_align", cellst.alignment); dupecheck_cell_stats(&cellst), cJSON_AddNumberToObject(memory, "dupecheck_cells_used", dupecheck_cellgauge); cJSON_AddNumberToObject(memory, "dupecheck_cells_free", cellst.freecount); cJSON_AddNumberToObject(memory, "dupecheck_used_bytes", dupecheck_cellgauge*cellst.cellsize_aligned); cJSON_AddNumberToObject(memory, "dupecheck_allocated_bytes", (long)cellst.blocks * (long)cellst.block_size); cJSON_AddNumberToObject(memory, "dupecheck_block_size", (long)cellst.block_size); cJSON_AddNumberToObject(memory, "dupecheck_blocks", (long)cellst.blocks); cJSON_AddNumberToObject(memory, "dupecheck_blocks_max", (long)cellst.blocks_max); cJSON_AddNumberToObject(memory, "dupecheck_cell_size", cellst.cellsize); cJSON_AddNumberToObject(memory, "dupecheck_cell_size_aligned", cellst.cellsize_aligned); cJSON_AddNumberToObject(memory, "dupecheck_cell_align", cellst.alignment); struct cellstatus_t cellst_filter, cellst_filter_wx, cellst_filter_entrycall; filter_cell_stats(&cellst_filter, &cellst_filter_entrycall, &cellst_filter_wx), cJSON_AddNumberToObject(memory, "filter_cells_used", filter_cellgauge); cJSON_AddNumberToObject(memory, "filter_cells_free", cellst_filter.freecount); cJSON_AddNumberToObject(memory, "filter_used_bytes", filter_cellgauge*cellst_filter.cellsize_aligned); cJSON_AddNumberToObject(memory, "filter_allocated_bytes", (long)cellst_filter.blocks * (long)cellst_filter.block_size); cJSON_AddNumberToObject(memory, "filter_block_size", (long)cellst_filter.block_size); cJSON_AddNumberToObject(memory, "filter_blocks", (long)cellst_filter.blocks); cJSON_AddNumberToObject(memory, "filter_blocks_max", (long)cellst_filter.blocks_max); cJSON_AddNumberToObject(memory, "filter_cell_size", cellst_filter.cellsize); cJSON_AddNumberToObject(memory, "filter_cell_size_aligned", cellst_filter.cellsize_aligned); cJSON_AddNumberToObject(memory, "filter_cell_align", cellst_filter.alignment); cJSON_AddNumberToObject(memory, "filter_wx_cells_used", filter_wx_cellgauge); cJSON_AddNumberToObject(memory, "filter_wx_cells_free", cellst_filter_wx.freecount); cJSON_AddNumberToObject(memory, "filter_wx_used_bytes", filter_wx_cellgauge*cellst_filter_wx.cellsize_aligned); cJSON_AddNumberToObject(memory, "filter_wx_allocated_bytes", (long)cellst_filter_wx.blocks * (long)cellst_filter_wx.block_size); cJSON_AddNumberToObject(memory, "filter_wx_block_size", (long)cellst_filter_wx.block_size); cJSON_AddNumberToObject(memory, "filter_wx_blocks", (long)cellst_filter_wx.blocks); cJSON_AddNumberToObject(memory, "filter_wx_blocks_max", (long)cellst_filter_wx.blocks_max); cJSON_AddNumberToObject(memory, "filter_wx_cell_size", cellst_filter_wx.cellsize); cJSON_AddNumberToObject(memory, "filter_wx_cell_size_aligned", cellst_filter_wx.cellsize_aligned); cJSON_AddNumberToObject(memory, "filter_wx_cell_align", cellst_filter_wx.alignment); cJSON_AddNumberToObject(memory, "filter_entrycall_cells_used", filter_entrycall_cellgauge); cJSON_AddNumberToObject(memory, "filter_entrycall_cells_free", cellst_filter_entrycall.freecount); cJSON_AddNumberToObject(memory, "filter_entrycall_used_bytes", filter_entrycall_cellgauge*cellst_filter_entrycall.cellsize_aligned); cJSON_AddNumberToObject(memory, "filter_entrycall_allocated_bytes", (long)cellst_filter_entrycall.blocks * (long)cellst_filter_entrycall.block_size); cJSON_AddNumberToObject(memory, "filter_entrycall_block_size", (long)cellst_filter_entrycall.block_size); cJSON_AddNumberToObject(memory, "filter_entrycall_blocks", (long)cellst_filter_entrycall.blocks); cJSON_AddNumberToObject(memory, "filter_entrycall_blocks_max", (long)cellst_filter_entrycall.blocks_max); cJSON_AddNumberToObject(memory, "filter_entrycall_cell_size", cellst_filter_entrycall.cellsize); cJSON_AddNumberToObject(memory, "filter_entrycall_cell_size_aligned", cellst_filter_entrycall.cellsize_aligned); cJSON_AddNumberToObject(memory, "filter_entrycall_cell_align", cellst_filter_entrycall.alignment); struct cellstatus_t cellst_pbuf_small, cellst_pbuf_medium, cellst_pbuf_large; incoming_cell_stats(&cellst_pbuf_small, &cellst_pbuf_medium, &cellst_pbuf_large); cJSON_AddNumberToObject(memory, "pbuf_small_cells_used", cellst_pbuf_small.cellcount - cellst_pbuf_small.freecount); cJSON_AddNumberToObject(memory, "pbuf_small_cells_free", cellst_pbuf_small.freecount); cJSON_AddNumberToObject(memory, "pbuf_small_cells_alloc", cellst_pbuf_small.cellcount); cJSON_AddNumberToObject(memory, "pbuf_small_used_bytes", (cellst_pbuf_small.cellcount - cellst_pbuf_small.freecount)*cellst_pbuf_small.cellsize_aligned); cJSON_AddNumberToObject(memory, "pbuf_small_allocated_bytes", (long)cellst_pbuf_small.blocks * (long)cellst_pbuf_small.block_size); cJSON_AddNumberToObject(memory, "pbuf_small_block_size", (long)cellst_pbuf_small.block_size); cJSON_AddNumberToObject(memory, "pbuf_small_blocks", (long)cellst_pbuf_small.blocks); cJSON_AddNumberToObject(memory, "pbuf_small_blocks_max", (long)cellst_pbuf_small.blocks_max); cJSON_AddNumberToObject(memory, "pbuf_small_cell_size", cellst_pbuf_small.cellsize); cJSON_AddNumberToObject(memory, "pbuf_small_cell_size_aligned", cellst_pbuf_small.cellsize_aligned); cJSON_AddNumberToObject(memory, "pbuf_small_cell_align", cellst_pbuf_small.alignment); cJSON_AddNumberToObject(memory, "pbuf_medium_cells_used", cellst_pbuf_medium.cellcount - cellst_pbuf_medium.freecount); cJSON_AddNumberToObject(memory, "pbuf_medium_cells_free", cellst_pbuf_medium.freecount); cJSON_AddNumberToObject(memory, "pbuf_medium_cells_alloc", cellst_pbuf_medium.cellcount); cJSON_AddNumberToObject(memory, "pbuf_medium_used_bytes", (cellst_pbuf_medium.cellcount - cellst_pbuf_medium.freecount)*cellst_pbuf_medium.cellsize_aligned); cJSON_AddNumberToObject(memory, "pbuf_medium_allocated_bytes", (long)cellst_pbuf_medium.blocks * (long)cellst_pbuf_medium.block_size); cJSON_AddNumberToObject(memory, "pbuf_medium_block_size", (long)cellst_pbuf_medium.block_size); cJSON_AddNumberToObject(memory, "pbuf_medium_blocks", (long)cellst_pbuf_medium.blocks); cJSON_AddNumberToObject(memory, "pbuf_medium_blocks_max", (long)cellst_pbuf_medium.blocks_max); cJSON_AddNumberToObject(memory, "pbuf_medium_cell_size", cellst_pbuf_medium.cellsize); cJSON_AddNumberToObject(memory, "pbuf_medium_cell_size_aligned", cellst_pbuf_medium.cellsize_aligned); cJSON_AddNumberToObject(memory, "pbuf_medium_cell_align", cellst_pbuf_medium.alignment); cJSON_AddNumberToObject(memory, "pbuf_large_cells_used", cellst_pbuf_large.cellcount - cellst_pbuf_large.freecount); cJSON_AddNumberToObject(memory, "pbuf_large_cells_free", cellst_pbuf_large.freecount); cJSON_AddNumberToObject(memory, "pbuf_large_cells_alloc", cellst_pbuf_large.cellcount); cJSON_AddNumberToObject(memory, "pbuf_large_used_bytes", (cellst_pbuf_large.cellcount - cellst_pbuf_large.freecount)*cellst_pbuf_large.cellsize_aligned); cJSON_AddNumberToObject(memory, "pbuf_large_allocated_bytes", (long)cellst_pbuf_large.blocks * (long)cellst_pbuf_large.block_size); cJSON_AddNumberToObject(memory, "pbuf_large_block_size", (long)cellst_pbuf_large.block_size); cJSON_AddNumberToObject(memory, "pbuf_large_blocks", (long)cellst_pbuf_large.blocks); cJSON_AddNumberToObject(memory, "pbuf_large_blocks_max", (long)cellst_pbuf_large.blocks_max); cJSON_AddNumberToObject(memory, "pbuf_large_cell_size", cellst_pbuf_large.cellsize); cJSON_AddNumberToObject(memory, "pbuf_large_cell_size_aligned", cellst_pbuf_large.cellsize_aligned); cJSON_AddNumberToObject(memory, "pbuf_large_cell_align", cellst_pbuf_large.alignment); struct cellstatus_t cellst_client_heard; client_heard_cell_stats(&cellst_client_heard); cJSON_AddNumberToObject(memory, "client_heard_cells_used", cellst_client_heard.cellcount - cellst_client_heard.freecount); cJSON_AddNumberToObject(memory, "client_heard_cells_free", cellst_client_heard.freecount); cJSON_AddNumberToObject(memory, "client_heard_cells_alloc", cellst_client_heard.cellcount); cJSON_AddNumberToObject(memory, "client_heard_used_bytes", (cellst_client_heard.cellcount - cellst_client_heard.freecount)*cellst_client_heard.cellsize_aligned); cJSON_AddNumberToObject(memory, "client_heard_allocated_bytes", (long)cellst_client_heard.blocks * (long)cellst_client_heard.block_size); cJSON_AddNumberToObject(memory, "client_heard_block_size", (long)cellst_client_heard.block_size); cJSON_AddNumberToObject(memory, "client_heard_blocks", (long)cellst_client_heard.blocks); cJSON_AddNumberToObject(memory, "client_heard_blocks_max", (long)cellst_client_heard.blocks_max); cJSON_AddNumberToObject(memory, "client_heard_cell_size", cellst_client_heard.cellsize); cJSON_AddNumberToObject(memory, "client_heard_cell_size_aligned", cellst_client_heard.cellsize_aligned); cJSON_AddNumberToObject(memory, "client_heard_cell_align", cellst_client_heard.alignment); #endif cJSON_AddItemToObject(root, "memory", memory); cJSON *historydb = cJSON_CreateObject(); cJSON_AddNumberToObject(historydb, "inserts", historydb_inserts); cJSON_AddNumberToObject(historydb, "lookups", historydb_lookups); cJSON_AddNumberToObject(historydb, "hashmatches", historydb_hashmatches); cJSON_AddNumberToObject(historydb, "keymatches", historydb_keymatches); cJSON_AddNumberToObject(historydb, "noposcount", historydb_noposcount); cJSON_AddNumberToObject(historydb, "cleaned", historydb_cleanup_cleaned); cJSON_AddItemToObject(root, "historydb", historydb); cJSON *dupecheck = cJSON_CreateObject(); cJSON_AddNumberToObject(dupecheck, "dupes_dropped", dupecheck_dupecount); cJSON_AddNumberToObject(dupecheck, "uniques_out", dupecheck_outcount); cJSON_AddItemToObject(root, "dupecheck", dupecheck); cJSON *dupe_vars = cJSON_CreateObject(); cJSON_AddNumberToObject(dupe_vars, "exact", dupecheck_dupetypes[0]); cJSON_AddNumberToObject(dupe_vars, "space_trim", dupecheck_dupetypes[DTYPE_SPACE_TRIM]); cJSON_AddNumberToObject(dupe_vars, "8bit_strip", dupecheck_dupetypes[DTYPE_STRIP_8BIT]); cJSON_AddNumberToObject(dupe_vars, "8bit_clear", dupecheck_dupetypes[DTYPE_CLEAR_8BIT]); cJSON_AddNumberToObject(dupe_vars, "8bit_spaced", dupecheck_dupetypes[DTYPE_SPACED_8BIT]); cJSON_AddNumberToObject(dupe_vars, "low_strip", dupecheck_dupetypes[DTYPE_LOWDATA_STRIP]); cJSON_AddNumberToObject(dupe_vars, "low_spaced", dupecheck_dupetypes[DTYPE_LOWDATA_SPACED]); cJSON_AddNumberToObject(dupe_vars, "del_strip", dupecheck_dupetypes[DTYPE_DEL_STRIP]); cJSON_AddNumberToObject(dupe_vars, "del_spaced", dupecheck_dupetypes[DTYPE_DEL_SPACED]); cJSON_AddItemToObject(dupecheck, "variations", dupe_vars); cJSON *json_totals = cJSON_CreateObject(); cJSON *json_listeners = cJSON_CreateArray(); accept_listener_status(json_listeners, json_totals); cJSON_AddItemToObject(root, "totals", json_totals); cJSON_AddItemToObject(root, "listeners", json_listeners); cJSON *json_clients = cJSON_CreateArray(); cJSON *json_uplinks = cJSON_CreateArray(); cJSON *json_peers = cJSON_CreateArray(); cJSON *json_workers = cJSON_CreateArray(); worker_client_list(json_workers, json_clients, json_uplinks, json_peers, json_totals, memory); cJSON_AddItemToObject(root, "workers", json_workers); cJSON_AddItemToObject(root, "uplinks", json_uplinks); cJSON_AddItemToObject(root, "peers", json_peers); cJSON_AddItemToObject(root, "clients", json_clients); /* if this is a periodical per-minute dump, collect historical data */ if (periodical) { cJSON *ct, *cv; struct cdata_list_t *cl; for (cl = cdata_list; (cl); cl = cl->next) { ct = cJSON_GetObjectItem(root, cl->tree); if (!ct) continue; cv = cJSON_GetObjectItem(ct, cl->name); /* cJSON's cv->valueint is just an integer, which will overflow * too quickly. So, let's take the more expensive valuedouble. */ if (cl->gauge) cdata_gauge_sample(cl->cd, (cv) ? cv->valuedouble : -1); else cdata_counter_sample(cl->cd, (cv) ? cv->valuedouble : -1); } } cJSON_AddNumberToObject(json_totals, "tcp_bytes_rx_rate", cdata_get_last_value("totals.tcp_bytes_rx") / CDATA_INTERVAL); cJSON_AddNumberToObject(json_totals, "tcp_bytes_tx_rate", cdata_get_last_value("totals.tcp_bytes_tx") / CDATA_INTERVAL); cJSON_AddNumberToObject(json_totals, "udp_bytes_rx_rate", cdata_get_last_value("totals.udp_bytes_rx") / CDATA_INTERVAL); cJSON_AddNumberToObject(json_totals, "udp_bytes_tx_rate", cdata_get_last_value("totals.udp_bytes_tx") / CDATA_INTERVAL); cJSON_AddNumberToObject(json_totals, "bytes_rx_rate", (cdata_get_last_value("totals.tcp_bytes_rx") + cdata_get_last_value("totals.udp_bytes_rx")) / CDATA_INTERVAL); cJSON_AddNumberToObject(json_totals, "bytes_tx_rate", (cdata_get_last_value("totals.tcp_bytes_tx") + cdata_get_last_value("totals.udp_bytes_tx")) / CDATA_INTERVAL); cJSON *json_rx_errs = cJSON_CreateStringArray(inerr_labels, INERR_BUCKETS); cJSON_AddItemToObject(root, "rx_errs", json_rx_errs); cJSON_AddItemToObject(root, "alarms", status_error_json()); /* the tree is built, print it out to a malloc'ed string */ out = cJSON_Print(root); cJSON_Delete(root); /* cache it */ if ((pe = pthread_mutex_lock(&status_json_mt))) { hlog(LOG_ERR, "status_json_string(): could not lock status_json_mt: %s", strerror(pe)); return NULL; } if (status_json_cached) hfree(status_json_cached); status_json_cached = hstrdup(out); status_json_cache_t = tick; if ((pe = pthread_mutex_unlock(&status_json_mt))) { hlog(LOG_ERR, "status_json_string(): could not unlock status_json_mt: %s", strerror(pe)); return NULL; } return out; }
/** Parses plugin interfaces. Loads the function names present in the corresponding plugin defined in the service specification JSON * @param[in] inf_file file path for the plugin interface * @return returns true upon successful parsing and false otherwise */ bool parsePluginInterfaces(char *inf_file) { char *out; int numentries = 0, i = 0; cJSON *json = NULL, *jitem, *child; bool status = true; FILE *fp = fopen(inf_file, "rb"); if (fp == NULL) { fprintf(stderr,"Error can't open file %s\n", inf_file); status = false; } else { fseek(fp, 0, SEEK_END); long size = ftell(fp); rewind(fp); // read the file char *buffer = (char *)malloc(size+1); if (buffer != NULL) { fread(buffer, 1, size, fp); // parse the file json = cJSON_Parse(buffer); } if (json == NULL || !json) { fprintf(stderr,"Error before: [%s]\n",cJSON_GetErrorPtr()); status = false; } else { #if DEBUG out = cJSON_Print(json, 2); printf("%s\n", out); free(out); #endif if (!isJsonObject(json)) { handleParseInterfacesError(); } jitem = cJSON_GetObjectItem(json, "functions"); if (!isJsonArray(jitem)) { handleParseInterfacesError(); } child = jitem->child; /* How many entries in the array? */ while (child && numentries++ < MAX_PROPERTIES) { child = child->next; } if (!numentries) { handleParseInterfacesError(); } g_funcEntries = numentries; g_funcSignatures = (char **)malloc(numentries*sizeof(char*)); if (!g_funcSignatures) { handleParseInterfacesError(); } memset(g_funcSignatures,0,numentries*sizeof(char*)); child = jitem->child; while (child) { if (!isJsonString(child)) { handleParseInterfacesError(); } g_funcSignatures[i] = strdup(child->valuestring); child = child->next; #if DEBUG printf("g_funcSignature = %s\n", g_funcSignatures[i]); #endif i++; } endParseInterfaces: cJSON_Delete(json); } free(buffer); fclose(fp); // close the file pointer } return status; }