static void print_ve() { int i, idx; /* If sort order != veid (already sorted by) */ if (g_sort_field) { qsort(veinfo, n_veinfo, sizeof(struct Cveinfo), field_names[g_sort_field].sort_fn); } if (!(!show_hdr || fmt_json)) print_hdr(); if (fmt_json) printf("["); for (i = 0; i < n_veinfo; i++) { if (sort_rev) idx = n_veinfo - i - 1; else idx = i; if (veinfo[idx].hide) continue; if (only_stopped_ve && veinfo[idx].status == VE_RUNNING) continue; if (fmt_json) print_one_ve_json(&veinfo[idx]); else print_one_ve(&veinfo[idx]); } if (fmt_json) printf("\n]\n"); }
void print_err() { print_hdr(); puts("<h1>ERROR IN DATA</h1>"); print_end(); exit(2); }
int test_wnd(char **wnd, void *pkt, uint32_t seq){ int err; pkt = malloc(MAX_PKT_SIZE); make_pkt(pkt, ACK, advwin, NULL, 0); print_hdr((struct xtcphdr*)pkt); err = add_to_wnd(seq, pkt, (const char **)wnd); if(err < 0) { _DEBUG("%s\n", "ERROR"); free(wnd); return err; } print_wnd((const char**)wnd); return 0; }
static void print_nodes(const char *be_name, boolean_t dsets, boolean_t snaps, boolean_t parsable, be_node_list_t *be_nodes) { struct hdr_info hdr; enum be_fmt be_fmt = BE_FMT_DEFAULT; if (dsets) be_fmt |= BE_FMT_DATASET; if (snaps) be_fmt |= BE_FMT_SNAPSHOT; if (!parsable) { init_hdr_cols(be_fmt, &hdr); count_widths(be_fmt, &hdr, be_nodes); print_hdr(&hdr); } if (be_fmt == BE_FMT_DEFAULT) print_be_nodes(be_name, parsable, &hdr, be_nodes); else print_fmt_nodes(be_name, be_fmt, parsable, &hdr, be_nodes); }
void or_gdf(void) { if (_is_ncname(elements[0])) { char *dataset = NULL, *tmp = NULL, *exe, *exedot; if ((dataset = strrchr(project, '/'))) { extern const char *oodroot; tmp = malloc(strlen(oodroot) + strlen(project) + strlen(dataset) + 7); sprintf(tmp, "%s/%s%s.xml", oodroot, project, dataset); exe = malloc(strlen(tmp)+1); strcpy(exe, tmp); exedot = strrchr(exe, '.'); strcpy(exedot+1, "sh"); if (!access(exe, R_OK|X_OK)) { execl("/bin/sh", "sh", exe, elements[0], NULL); do404(); } else { if (elements[1] && !strcmp(elements[1], "xml")) { print_hdr_xml(); execl("/bin/sh", "sh", "/home/oracc/bin/gdf-entry.sh", tmp, elements[0], "xml", NULL); } else if (!elements[1] || !strcmp(elements[1], "html")) { print_hdr(); execl("/bin/sh", "sh", "/home/oracc/bin/gdf-entry.sh", tmp, elements[0], NULL); } } } } do404(); }
int main(int argc, char **argv) { struct lnstat_file *lnstat_files; const char *basename; int i, c; int interval = DEFAULT_INTERVAL; int hdr = 2; enum { MODE_DUMP, MODE_JSON, MODE_NORMAL, } mode = MODE_NORMAL; unsigned long count = 1; struct table_hdr *header; static struct field_params fp; int num_req_files = 0; char *req_files[LNSTAT_MAX_FILES]; /* backwards compatibility mode for old tools */ basename = strrchr(argv[0], '/'); if (basename) basename += 1; /* name after slash */ else basename = argv[0]; /* no slash */ if (!strcmp(basename, "rtstat")) { /* rtstat compatibility mode */ req_files[0] = "rt_cache"; num_req_files = 1; } else if (!strcmp(basename, "ctstat")) { /* ctstat compatibility mode */ req_files[0] = "ip_conntrack"; num_req_files = 1; } while ((c = getopt_long(argc, argv,"Vc:djf:h?i:k:s:w:", opts, NULL)) != -1) { int len = 0; char *tmp, *tok; switch (c) { case 'c': count = strtoul(optarg, NULL, 0); break; case 'd': mode = MODE_DUMP; break; case 'j': mode = MODE_JSON; break; case 'f': req_files[num_req_files++] = strdup(optarg); break; case '?': case 'h': usage(argv[0], 0); break; case 'i': sscanf(optarg, "%u", &interval); break; case 'k': tmp = strdup(optarg); if (!tmp) break; for (tok = strtok(tmp, ","); tok; tok = strtok(NULL, ",")) { if (fp.num >= MAX_FIELDS) { fprintf(stderr, "WARN: too many keys" " requested: (%d max)\n", MAX_FIELDS); break; } fp.params[fp.num++].name = tok; } break; case 's': sscanf(optarg, "%u", &hdr); break; case 'w': tmp = strdup(optarg); if (!tmp) break; i = 0; for (tok = strtok(tmp, ","); tok; tok = strtok(NULL, ",")) { len = strtoul(tok, NULL, 0); if (len > FIELD_WIDTH_MAX) len = FIELD_WIDTH_MAX; fp.params[i].print.width = len; i++; } if (i == 1) { for (i = 0; i < MAX_FIELDS; i++) fp.params[i].print.width = len; } break; default: usage(argv[0], 1); break; } } lnstat_files = lnstat_scan_dir(PROC_NET_STAT, num_req_files, (const char **) req_files); switch (mode) { case MODE_DUMP: lnstat_dump(stderr, lnstat_files); break; case MODE_NORMAL: case MODE_JSON: if (!map_field_params(lnstat_files, &fp, interval)) exit(1); header = build_hdr_string(lnstat_files, &fp, 80); if (!header) exit(1); if (interval < 1 ) interval = 1; for (i = 0; i < count; i++) { lnstat_update(lnstat_files); if (mode == MODE_JSON) print_json(stdout, lnstat_files, &fp); else { if ((hdr > 1 && (! (i % 20))) || (hdr == 1 && i == 0)) print_hdr(stdout, header); print_line(stdout, lnstat_files, &fp); } fflush(stdout); if (i < count - 1) sleep(interval); } break; } return 1; }
static void ublimage_print_header(const void *ptr) { struct ubl_header *ubl_hdr = (struct ubl_header *) ptr; print_hdr(ubl_hdr); }
/** The get-recrod command */ int cmd_get_record (int argc, const char *argv[]) { if (OPTIONS.tenant[0] == 0) { fprintf (stderr, "%% No tenantid provided\n"); return 1; } if (OPTIONS.host[0] == 0) { fprintf (stderr, "%% No hostid provided\n"); return 1; } var *apires = api_get ("/%s/host/%s", OPTIONS.tenant, OPTIONS.host); if (OPTIONS.json) { var_dump (apires, stdout); var_free (apires); return 0; } #define Arr(x) var_get_array_forkey(apires,x) #define Vint(x) var_get_int_forkey(apires,x) #define Vstr(x) var_get_str_forkey(apires,x) #define Vfrac(x) var_get_double_forkey(apires,x) #define VDint(x,y) var_get_int_forkey(var_get_dict_forkey(apires,x),y) #define VDstr(x,y) var_get_str_forkey(var_get_dict_forkey(apires,x),y) #define VDfrac(x,y) var_get_double_forkey(var_get_dict_forkey(apires,x),y) #define VAfrac(x,y) var_get_double_atindex(var_get_array_forkey(apires,x),y) #define Vdone(x) var_delete_key(apires,x) /* -------------------------------------------------------------*/ print_hdr ("HOST"); print_value ("UUID", "%s", OPTIONS.host); print_value ("Hostname", "%s", Vstr("hostname")); print_value ("Address", "%s", VDstr("agent","ip")); print_value ("Status", "\033[1m%s\033[0m", Vstr("status")); print_array ("Problems", Arr("problems")); Vdone("hostname"); Vdone("agent"); Vdone("status"); Vdone("problems"); char uptimestr[128]; uint64_t uptime = Vint("uptime"); Vdone("uptime"); uint64_t u_days = uptime / 86400ULL; uint64_t u_hours = (uptime - (86400 * u_days)) / 3600ULL; uint64_t u_mins = (uptime - (86400 * u_days) - (3600 * u_hours)) / 60ULL; uint64_t u_sec = uptime % 60; if (u_days) { sprintf (uptimestr, "%llu day%s, %llu:%02llu:%02llu", u_days, (u_days==1)?"":"s", u_hours, u_mins, u_sec); } else if (u_hours) { sprintf (uptimestr, "%llu:%02llu:%02llu", u_hours, u_mins, u_sec); } else { sprintf (uptimestr, "%llu minute%s, %llu second%s", u_mins, (u_mins==1)?"":"s", u_sec, (u_sec==1)?"":"s"); } print_value ("Uptime","%s",uptimestr); print_value ("OS/Hardware","%s %s (%s)", VDstr("os","kernel"), VDstr("os","version"), VDstr("os","arch")); const char *dist = VDstr("os","distro"); if (dist) print_value ("Distribution", "%s", dist); Vdone("os"); /* -------------------------------------------------------------*/ print_hdr ("RESOURCES"); print_value ("Processes","\033[1m%llu\033[0m " "(\033[1m%llu\033[0m running, " "\033[1m%llu\033[0m stuck)", VDint("proc","total"), VDint("proc","run"), VDint("proc","stuck")); Vdone("proc"); print_value ("Load Average", "\033[1m%6.2f\033[0m / " "\033[1m%6.2f\033[0m / " "\033[1m%6.2f\033[0m", VAfrac ("loadavg",0), VAfrac ("loadavg", 1), VAfrac ("loadavg",2)); Vdone ("loadavg"); char cpubuf[128]; sprintf (cpubuf, "\033[1m%6.2f \033[0m%%", Vfrac("pcpu")); char meter[32]; strcpy (meter, "-[ ]+"); double iowait = VDfrac("io","pwait"); double pcpu = Vfrac("pcpu"); Vdone("pcpu"); double level = 4.5; int pos = 2; while (level < 100.0 && pos < 22) { if (level < pcpu) meter[pos++] = '#'; else meter[pos++] = ' '; level += 4.5; } print_value ("CPU", "%-40s %s", cpubuf, meter); if (iowait>0.001) print_value ("CPU iowait", "\033[1m%6.2f %%\033[0m", iowait); print_value ("Available RAM", "\033[1m%.2f\033[0m MB", ((double)VDint("mem","total"))/1024.0); print_value ("Free RAM", "\033[1m%.2f\033[0m MB", ((double)VDint("mem","free"))/1024.0); print_value ("Network in/out", "\033[1m%i\033[0m Kb/s " "(\033[1m%i\033[0m pps) / " "\033[1m%i\033[0m Kb/s " "(\033[1m%i\033[0m pps)", VDint("net","in_kbs"), VDint("net","in_pps"), VDint("net","out_kbs"), VDint("net","out_pps")); print_value ("Disk i/o", "\033[1m%i\033[0m rdops / " "\033[1m%i\033[0m wrops", VDint("io","rdops"), VDint("io","wrops")); Vdone("mem"); Vdone("net"); Vdone("io"); Vdone("badness"); print_values (apires, NULL); /* -------------------------------------------------------------*/ print_hdr ("PROCESS LIST"); const char *top_hdr[] = {"USER","PID","CPU","MEM","NAME",NULL}; const char *top_fld[] = {"user","pid","pcpu","pmem","name",NULL}; columnalign top_align[] = {CA_L, CA_R, CA_R, CA_R, CA_L, CA_NULL}; vartype top_tp[] = {VAR_STR,VAR_INT,VAR_DOUBLE,VAR_DOUBLE,VAR_STR,VAR_NULL}; int top_wid[] = {15, 7, 9, 9, 0, 0}; int top_div[] = {0, 0, 0, 0, 0, 0}; const char *top_suf[] = {"",""," %", " %", "", NULL}; var *v_top = var_get_array_forkey (apires, "top"); print_table (v_top, top_hdr, top_fld, top_align, top_tp, top_wid, top_suf, top_div); Vdone("top"); /* -------------------------------------------------------------*/ print_hdr ("STORAGE"); const char *df_hdr[] = {"DEVICE","SIZE","FS","USED","MOUNTPOINT",NULL}; const char *df_fld[] = {"device","size","fs","pused","mount",NULL}; columnalign df_aln[] = {CA_L,CA_R,CA_L,CA_R,CA_L,CA_NULL}; vartype df_tp[] = {VAR_STR,VAR_INT,VAR_STR,VAR_DOUBLE,VAR_STR,VAR_NULL}; int df_wid[] = {12, 14, 6, 8, 0}; int df_div[] = {0, (1024), 0, 0, 0, 0}; const char *df_suf[] = {""," GB", "", " %", "", ""}; var *v_df = var_get_array_forkey (apires, "df"); /*print_generic_table (v_df);*/ print_table (v_df, df_hdr, df_fld, df_aln, df_tp, df_wid, df_suf, df_div); Vdone("df"); /** Print any remaining table data */ print_tables (apires); printf ("---------------------------------------------" "-----------------------------------\n"); var_free (apires); print_done(); return 0; }
int main() { struct tm t1; struct tm t2; // struct tm *ct1,*ct2; char *s=getenv("REQUEST_METHOD"); char *endptr; int i; unsigned int contentlength; char buff[10000]; char a,b; const char *len1 = getenv("CONTENT_LENGTH"); /* printf("Content-Type: text/html\n\n"); printf( "<HTML><HEAD><TITLE>Environment</TITLE></HEAD>\n"); printf( "<BODY>\n"); printf( "Your request is: %s<BR><br>\n",getenv("REQUEST_STRING")); printf( "Variables:<BR>\n"); printf( "<I><B>REQUEST_METHOD</B></I>=%s<br>\n",getenv("REQUEST_METHOD")); printf( "<I><B>QUERY_STRING</B></I>=%s<br>\n",getenv("QUERY_STRING")); printf( "<I><B>CONTENT_LENGTH</B></I>=%s<br>\n",getenv("CONTENT_LENGTH")); printf( "<I><B>CONTENT_TYPE</B></I>=%s<br>\n",getenv("CONTENT_TYPE")); printf( "<I><B>GATEWAY_INTERFACE</B></I>=%s<br>\n",getenv("GATEWAY_INTERFACE")); printf( "<I><B>REMOTE_ADDR</B></I>=%s<br>\n",getenv("REMOTE_ADDR")); printf( "<I><B>REMOTE_HOST</B></I>=%s<br>\n",getenv("REMOTE_HOST")); printf( "<I><B>SCRIPT_NAME</B></I>=%s<br>\n",getenv("SCRIPT_NAME")); printf( "<I><B>SCRIPT_FILENAME</B></I>=%s<br>\n",getenv("SCRIPT_FILENAME")); printf( "<I><B>SERVER_NAME</B></I>=%s<br>\n",getenv("SERVER_NAME")); printf( "<I><B>SERVER_PORT</B></I>=%s<br>\n",getenv("SERVER_PORT")); printf( "<I><B>SERVER_PROTOCOL</B></I>=%s<br>\n",getenv("SERVER_PROTOCOL")); printf( "<I><B>SERVER_SOFTWARE</B></I>=%s<br>\n",getenv("SERVER_SOFTWARE")); printf( "<I><B>HTTP_ACCEPT</B></I>=%s<br>\n",getenv("HTTP_ACCEPT")); printf( "<I><B>HTTP_USER_AGENT</B></I>=%s<br>\n",getenv("HTTP_USER_AGENT")); printf( "</BODY></HTML>\n"); exit(2); */ if(s!=NULL) { if(strcmp(s,"GET")==0) { strcpy(buff,getenv("QUERY_STRING")); }else if(strcmp(s,"POST")==0) { contentlength=strtol(len1, &endptr, 10); fread(buff, contentlength, 1, stdin); } ParseInput(buff); } if (InputCount!=10) print_err(); print_hdr(); t1.tm_mday=atoi(InputValues[0]); t1.tm_mon=atoi(InputValues[1])-1; t1.tm_year=atoi(InputValues[2])-1900; t1.tm_hour=atoi(InputValues[3]); t1.tm_min=atoi(InputValues[4]); t1.tm_sec=0; t2.tm_mday=atoi(InputValues[5]); t2.tm_mon=atoi(InputValues[6])-1; t2.tm_year=atoi(InputValues[7])-1900; t2.tm_hour=atoi(InputValues[8]); t2.tm_min=atoi(InputValues[9]); t2.tm_sec=59; time1=mktime(&t1); time2=mktime(&t2); /* ct1 = gmtime(&time1); printf("ct1 y=%d m=%d d=%d h=%d mm=%d <br>\n",ct1->tm_year,ct1->tm_mon,ct1->tm_mday,ct1->tm_hour,ct1->tm_min); ct2 = gmtime(&time2); printf("ct2 y=%d m=%d d=%d h=%d mm=%d<br>\n",ct2->tm_year,ct2->tm_mon,ct2->tm_mday,ct2->tm_hour,ct2->tm_min); */ printf("<h3>Statistics for %02d:%02d:%02d %02d:%02d - %02d:%02d:%02d %02d:%02d</h2><hr>\n", t1.tm_mday,t1.tm_mon+1,t1.tm_year+1900,t1.tm_hour,t1.tm_min, t2.tm_mday,t2.tm_mon+1,t2.tm_year+1900,t2.tm_hour,t2.tm_min); // printf("<h2>Statistics for %s - %s</h2><hr>\n",asctime(&t1),asctime(&t2)); // printf("%d<br>",time1); // printf("%d",time2); read_cfg(); qsort(entries,count,sizeof(s_entry),traf_comparer); puts("<h3>Sorted by traffic</h2>"); print_results(1); /* qsort(entries,count,sizeof(s_entry),name_comparer); puts("<h3>Sorted by user name</h2>"); print_results(2); */ qsort(entries,count,sizeof(s_entry),ip_comparer); puts("<h3>Sorted by ip address</h2>"); print_results(1); qsort(entries,count,sizeof(s_entry),name_comparer); puts("<h3>Statistics by date and time</h2>"); print_stat_by_date_time(); print_end(); return 0; }
static void print_fmt_nodes(const char *be_name, enum be_fmt be_fmt, boolean_t parsable, be_node_list_t *nodes) { char buf[64]; char datetime[DT_BUF_LEN]; struct hdr_info *hdr = NULL; be_node_list_t *cur_be; hdr = hdrs + be_fmt; init_hdr_cols(be_fmt, hdr); count_widths(be_fmt, hdr, nodes); if (!parsable) print_hdr(hdr); for (cur_be = nodes; cur_be != NULL; cur_be = cur_be->be_next_node) { char active[3] = "-\0"; int ai = 0; const char *datetime_fmt = "%F %R"; const char *name = cur_be->be_node_name; const char *mntpt = cur_be->be_mntpt; uint64_t used = cur_be->be_space_used; time_t creation = cur_be->be_node_creation; struct tm *tm; if (be_name != NULL && strcmp(be_name, name) != 0) continue; if (!parsable) (void) printf("%-s\n", name); else active[0] = '\0'; tm = localtime(&creation); (void) strftime(datetime, DT_BUF_LEN, datetime_fmt, tm); if (cur_be->be_active) active[ai++] = 'N'; if (cur_be->be_active_on_boot) active[ai] = 'R'; nicenum(used, buf, sizeof (buf)); if (be_fmt & BE_FMT_DATASET) if (parsable) (void) printf("%s;%s;%s;%s;%llu;%s;%ld\n", cur_be->be_node_name, cur_be->be_root_ds, active, (cur_be->be_mounted ? mntpt: ""), used, cur_be->be_policy_type, creation); else (void) printf(" %-*s %-*s %-*s %-*s %-*s " "%-*s\n", hdr->cols[0].width-3, cur_be->be_root_ds, hdr->cols[1].width, active, hdr->cols[2].width, (cur_be->be_mounted ? mntpt: "-"), hdr->cols[3].width, buf, hdr->cols[4].width, cur_be->be_policy_type, hdr->cols[5].width, datetime); if (be_fmt & BE_FMT_SNAPSHOT) print_be_snapshots(cur_be, hdr, parsable); } }
int main(int argc,char *argv[]) { FILE *fpA; FILE *fpB; FILE *fpC; int c; unsigned int alpha=0xff; if (argc !=1) sscanf(argv[1],"%x",&alpha); fpA=fopen("paltable.c","w"); fpB=fopen("stdkey.h","w"); fprintf(stderr,"making spectra.\n"); make_reg(); fprintf(stderr,"making color bars.\n"); make_root(); make_out_reg(256,17,256); fprintf(stderr,"printing palette table.\n"); print_reg(fpA,"KeyPalReg",256); print_reg_hdr(fpB,"KeyPalReg",256); fprintf(stderr,"printing rgb tables.\n"); make_map(256); print_map(fpA,"KeyLinear",256,alpha); print_hdr(fpB,"KeyLinear",256); fpC=fopen("linear-mag.key","w"); fprintf(fpC,"# linear magnitude\n"); fprintf(fpC,"%d\n",256); for (c=0;c<256;c++) fprintf(fpC,"%.2x%.2x%.2x%.2x\n",alpha,mag[c][0],mag[c][1],mag[c][2]); fclose(fpC); fpC=fopen("linear-sgn.key","w"); fprintf(fpC,"# linear signed\n"); fprintf(fpC,"%d\n",256); for (c=0;c<256;c++) fprintf(fpC,"%.2x%.2x%.2x%.2x\n",alpha,sgn[c][0],sgn[c][1],sgn[c][2]); fclose(fpC); make_map(20); print_map(fpA,"KeyTwentyBlk",20,alpha); print_hdr(fpB,"KeyTwentyBlk",20); fpC=fopen("twentyblk-mag.key","w"); fprintf(fpC,"# twentyblk magnitude\n"); fprintf(fpC,"%d\n",20); for (c=0;c<20;c++) fprintf(fpC,"%.2x%.2x%.2x%.2x\n",alpha,mag[c][0],mag[c][1],mag[c][2]); fclose(fpC); fpC=fopen("twentyblk-sgn.key","w"); fprintf(fpC,"# twentyblk signed\n"); fprintf(fpC,"%d\n",20); for (c=0;c<20;c++) fprintf(fpC,"%.2x%.2x%.2x%.2x\n",alpha,sgn[c][0],sgn[c][1],sgn[c][2]); fclose(fpC); make_map(10); print_map(fpA,"KeyTenBlk",10,alpha); print_hdr(fpB,"KeyTenBlk",10); fpC=fopen("tenblk-mag.key","w"); fprintf(fpC,"# tenblk magnitude\n"); fprintf(fpC,"%d\n",10); for (c=0;c<10;c++) fprintf(fpC,"%.2x%.2x%.2x%.2x\n",alpha,mag[c][0],mag[c][1],mag[c][2]); fclose(fpC); fpC=fopen("tenblk-sgn.key","w"); fprintf(fpC,"# tenblk signed\n"); fprintf(fpC,"%d\n",10); for (c=0;c<10;c++) fprintf(fpC,"%.2x%.2x%.2x%.2x\n",alpha,sgn[c][0],sgn[c][1],sgn[c][2]); fclose(fpC); make_map(5); print_map(fpA,"KeyFiveBlk",5,alpha); print_hdr(fpB,"KeyFiveBlk",5); fpC=fopen("fiveblk-mag.key","w"); fprintf(fpC,"# fiveblk magnitude\n"); fprintf(fpC,"%d\n",256); for (c=0;c<5;c++) fprintf(fpC,"%.2x%.2x%.2x%.2x\n",alpha,mag[c][0],mag[c][1],mag[c][2]); fclose(fpC); fpC=fopen("fiveblk-sgn.key","w"); fprintf(fpC,"# fiveblk signed\n"); fprintf(fpC,"%d\n",256); for (c=0;c<5;c++) fprintf(fpC,"%.2x%.2x%.2x%.2x\n",alpha,sgn[c][0],sgn[c][1],sgn[c][2]); fclose(fpC); make_cmap(256); print_cmap(fpA,"KeyLinearC",256); print_chdr(fpB,"KeyLinearC",256); make_cmap(20); print_cmap(fpA,"KeyTwentyblkC",20); print_chdr(fpB,"KeyTwentyBlkC",20); make_cmap(10); print_cmap(fpA,"KeyTenBlkC",10); print_chdr(fpB,"KeyTenBlkC",10); make_cmap(5); print_cmap(fpA,"KeyFiveBlkC",5); print_chdr(fpB,"KeyFiveBlkC",5); fclose(fpA); fclose(fpB); return 0; }