static void parse_line (char *buf) { char *fields[64]; size_t fields_num; data_set_t *ds; int i; fields_num = strsplit (buf, fields, 64); if (fields_num < 2) return; ds = (data_set_t *) malloc (sizeof (data_set_t)); if (ds == NULL) return; memset (ds, '\0', sizeof (data_set_t)); sstrncpy (ds->type, fields[0], sizeof (ds->type)); ds->ds_num = fields_num - 1; ds->ds = (data_source_t *) calloc (ds->ds_num, sizeof (data_source_t)); if (ds->ds == NULL) return; for (i = 0; i < ds->ds_num; i++) if (parse_ds (ds->ds + i, fields[i + 1], strlen (fields[i + 1])) != 0) { sfree (ds->ds); ERROR ("types_list: parse_line: Cannot parse data source #%i " "of data set %s", i, ds->type); return; } plugin_register_data_set (ds); sfree (ds->ds); sfree (ds); } /* void parse_line */
// !say [#channel | $nick] text void scriptcmd_say (NetServer *s) { strsplit (CMD[3], BUF, 1); if (BUF[1][0] == 0) { SEND_TEXT (DEST, "%s", HELP_SAY); return; } if (BUF[1][0] == '#') { int i = 0; while (BUF[1][i] != ' ' && BUF[1][i] != 0) i++; my_strncpy (DEST, BUF[1], i); my_strncpy (BUF[2], BUF[1] + i + num_spaces (BUF[1]+i), MSG_SIZE); my_strncpy (BUF[1], BUF[2], MSG_SIZE); } else if (BUF[1][0] == '$') { int i = 0; while (BUF[1][i] != ' ' && BUF[1][i] != 0) i++; my_strncpy (DEST, BUF[1], i); my_strncpy (DEST, DEST+1, CHANNEL_SIZE); if (strcasecmp (NICKSERV, DEST) == 0 || strcasecmp (CHANSERV, DEST) == 0 || strcasecmp (MEMOSERV, DEST) == 0 || strcasecmp (OPERSERV, DEST) == 0) { SEND_TEXT (SOURCE, "Cannot send to IRC Services."); return; } my_strncpy (BUF[2], BUF[1] + i + num_spaces (BUF[1] + i), MSG_SIZE); my_strncpy (BUF[1], BUF[2], MSG_SIZE); } SEND_TEXT (DEST, "%s", BUF[1]); }
static int handle_server(struct parsedfile *config, int lineno, char *value) { char *ip; ip = strsplit(NULL, &value, " "); /* We don't verify this ip/hostname at this stage, */ /* its resolved immediately before use in tsocks.c */ if (currentcontext->address == NULL) currentcontext->address = strdup(ip); else { if (currentcontext == &(config->defaultserver)) show_msg(MSGERR, "Only one default SOCKS server " "may be specified at line %d in " "configuration file\n", lineno); else show_msg(MSGERR, "Only one SOCKS server may be specified " "per path on line %d in configuration " "file. (Path begins on line %d)\n", lineno, currentcontext->lineno); } return(0); }
// !join #channel [key] void scriptcmd_join (NetServer *s) { strsplit (CMD[3], BUF, 3); if (BUF[1][0] == 0) { SEND_TEXT (DEST, "%s", HELP_JOIN); return; } int chan_num = CHANNEL_INDEX (BUF[1]); if (chan_num != -1) // if not already in the channel { SEND_TEXT (DEST, "I'm already on \002%s\002.", BUF[1]); return; } if (!s->channel_add (BUF[1], BUF[2])) { SEND_TEXT (DEST, "Maximum channels reached."); return; } chan_num = CHANNEL_INDEX (BUF[1]); // search it's position again CHANNELS[chan_num]->irc_join (); // join it }
void Scene::parseLineForSphere(std::string line, Sphere &sphere, const int &material_offset) { std::vector<std::string> parts; // vector for ;-seperated variables strsplit(line, ';', parts); // split line if (parts.size() != 3) { std::cout << "parseLineForSphere error in line: " << line << std::endl; return; } else { Vector3 center = strtoVect(parts[0]); float radius = lexical_cast<float>(parts[1]); int matID = lexical_cast<int>(parts[2]) + material_offset; if (matID >= nummats) { cout << "specified material does not exist! Replaced by default" << endl; sphere = Sphere(center, radius, &stdDiffuse); } else { sphere = Sphere(center, radius, &materials[matID]); } } }
// configuration file's local parser static void extra_conf (NetServer *s, c_char bufread) { char buf[2][MSG_SIZE+1]; strsplit (bufread, buf, 1); // add these commands in each new server if (strcasecmp (buf[0], "bot") == 0 && server2extra (s) == NULL) { extra_add (s); #ifdef PING_PATH s->script.events.add ((void *)extra_event); #endif s->script.cmd_bind (extra_cmd_raw, LEVEL_RAW, "!raw", module.mod, HELP_RAW); s->script.cmd_bind (extra_cmd_dccchat, LEVEL_DCCCHAT, "!dccchat", module.mod, HELP_DCCCHAT); s->script.cmd_bind (extra_cmd_ping, LEVEL_PING, "!ping", module.mod, HELP_PING); s->script.cmd_bind (extra_cmd_scan, LEVEL_SCAN, "!scan", module.mod, HELP_SCAN); s->script.cmd_bind (extra_cmd_host, LEVEL_HOST, "!host", module.mod, HELP_HOST); s->vars.var_add ("extra_akickping", extra_var); } }
// !usermask mask newmask void scriptcmd_usermask (NetServer *s) { strsplit (CMD[3], BUF, 3); if (BUF[2][0] == 0) { SEND_TEXT (DEST, "%s", HELP_USERMASK); return; } struct ListUsers::user_type *u = USERS.abs_mask2user (BUF[1]); if (u == NULL) { SEND_TEXT (DEST, "User does not exist."); return; } if (USERS.match_mask_level (CMD[0]) > u->level) { USERS.abs_set_mask (BUF[1], BUF[2]); SEND_TEXT (DEST, "Mask \002%s\002 changed to \002%s\002.", BUF[1], BUF[2]); } else SEND_TEXT (DEST, "Not enough access level."); }
static struct hostent * hostent_from_yp(int family, char *line) { struct hostent *h; char *next, *tokens[10], addr[IN6ADDRSZ]; int i, ntok; if ((h = hostent_alloc(family)) == NULL) return (NULL); for(next = line; line; line = next) { if ((next = strchr(line, '\n'))) { *next = '\0'; next += 1; } ntok = strsplit(line, tokens, 10); if (ntok < 2) continue; if (inet_pton(family, tokens[0], addr) == 1) hostent_add_addr(h, addr, family == AF_INET ? INADDRSZ : IN6ADDRSZ); i = 2; if (!h->h_name) hostent_set_cname(h, tokens[1], 0); else if (strcmp(h->h_name, tokens[1])) i = 1; for (; i < ntok; i++) hostent_add_alias(h, tokens[i], 0); } if (h->h_name == NULL) { free(h); return (NULL); } return (h); }
// !pass password void scriptcmd_pass (NetServer *s) { if (DEST[0] == '#') { SEND_TEXT (DEST, "Do \002not\002 use this command on a channel."); return; } strsplit (CMD[3], BUF, 1); if (BUF[1][0] == 0) { SEND_TEXT (DEST, "%s", HELP_PASS); return; } if (USERS.match_check_pass (CMD[0], BUF[1])) { USERS.match_set_id (CMD[0], 1); mask2nick (CMD[0], BUF[2]); s->irc_watch (BUF[2], 1); SEND_TEXT (DEST, "Password correct."); } else SEND_TEXT (DEST, "Password \002in\002correct."); }
// !cmdlevel !command level void scriptcmd_cmdlevel (NetServer *s) { strsplit (CMD[3], BUF, 3); if (BUF[2][0] == 0) { SEND_TEXT (DEST, "%s", HELP_CMDLEVEL); return; } Script::cmd_type *c = s->script.cmd_get (BUF[1]); if (c == NULL) { SEND_TEXT (DEST, "Command \002%s\002 does not exist.", BUF[1]); return; } int level = atoi (BUF[2]); if (level > LEVEL_MAX) c->level = LEVEL_MAX; else if (level < 0) c->level = 0; else c->level = level; SEND_TEXT (DEST, "Command \002%s\002's level set to \002%d\002.", BUF[1], c->level); }
void JoystickMapper::unserializeMap(string serialConf) { vector<string> splitConf; splitConf = strsplit(serialConf, ','); OEInt index = 0; for (OEInt i = 0; i < (splitConf.size() / 4); i++) { JoystickMapperItem item; OEInt usageId = getItemUsageId(splitConf[index++]); string usageName = splitConf[index++]; float sensitivity = getFloat(splitConf[index++]); bool reverse = getOEInt(splitConf[index++]); usageIdMap[usageId].usageId = getItemUsageId(usageName); usageIdMap[usageId].type = getItemType(usageName); usageIdMap[usageId].sensitivity = sensitivity; usageIdMap[usageId].reverse = reverse; usageIdMap[usageId].value = 0.5F; } }
/* * Fill in struct group from gr_entry */ int exfiles_copy_group_from_gr_entry(struct group *grbuf, char **gr_entry) { int tmplen = 0; tmplen = strlen(gr_entry[0]); strncpy(grbuf->gr_name, gr_entry[0], tmplen+1); if (strlen(grbuf->gr_name) != tmplen) return -1; tmplen = strlen(gr_entry[1]); strncpy(grbuf->gr_passwd, gr_entry[1], tmplen+1); if (strlen(grbuf->gr_passwd) != tmplen) return -1; grbuf->gr_gid = (gid_t)atoi(gr_entry[2]); /* Split the members by comma */ grbuf->gr_mem = strsplit(gr_entry[3], ','); return 0; }
static void *us_handle_client (void *arg) { int fdin; int fdout; FILE *fhin, *fhout; fdin = *((int *) arg); free (arg); arg = NULL; DEBUG ("unixsock plugin: us_handle_client: Reading from fd #%i", fdin); fdout = dup (fdin); if (fdout < 0) { char errbuf[1024]; ERROR ("unixsock plugin: dup failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); close (fdin); pthread_exit ((void *) 1); } fhin = fdopen (fdin, "r"); if (fhin == NULL) { char errbuf[1024]; ERROR ("unixsock plugin: fdopen failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); close (fdin); close (fdout); pthread_exit ((void *) 1); return ((void *) 1); } fhout = fdopen (fdout, "w"); if (fhout == NULL) { char errbuf[1024]; ERROR ("unixsock plugin: fdopen failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); fclose (fhin); /* this closes fdin as well */ close (fdout); pthread_exit ((void *) 1); return ((void *) 1); } /* change output buffer to line buffered mode */ if (setvbuf (fhout, NULL, _IOLBF, 0) != 0) { char errbuf[1024]; ERROR ("unixsock plugin: setvbuf failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); fclose (fhin); fclose (fhout); pthread_exit ((void *) 1); return ((void *) 0); } while (42) { char buffer[1024]; char buffer_copy[1024]; char *fields[128]; int fields_num; int len; errno = 0; if (fgets (buffer, sizeof (buffer), fhin) == NULL) { if ((errno == EINTR) || (errno == EAGAIN)) continue; if (errno != 0) { char errbuf[1024]; WARNING ("unixsock plugin: failed to read from socket #%i: %s", fileno (fhin), sstrerror (errno, errbuf, sizeof (errbuf))); } break; } len = strlen (buffer); while ((len > 0) && ((buffer[len - 1] == '\n') || (buffer[len - 1] == '\r'))) buffer[--len] = '\0'; if (len == 0) continue; sstrncpy (buffer_copy, buffer, sizeof (buffer_copy)); fields_num = strsplit (buffer_copy, fields, sizeof (fields) / sizeof (fields[0])); if (fields_num < 1) { fprintf (fhout, "-1 Internal error\n"); fclose (fhin); fclose (fhout); pthread_exit ((void *) 1); return ((void *) 1); } if (strcasecmp (fields[0], "getval") == 0) { handle_getval (fhout, buffer); } else if (strcasecmp (fields[0], "getthreshold") == 0) { handle_getthreshold (fhout, buffer); } else if (strcasecmp (fields[0], "putval") == 0) { handle_putval (fhout, buffer); } else if (strcasecmp (fields[0], "listval") == 0) { handle_listval (fhout, buffer); } else if (strcasecmp (fields[0], "putnotif") == 0) { handle_putnotif (fhout, buffer); } else if (strcasecmp (fields[0], "flush") == 0) { handle_flush (fhout, buffer); } else { if (fprintf (fhout, "-1 Unknown command: %s\n", fields[0]) < 0) { char errbuf[1024]; WARNING ("unixsock plugin: failed to write to socket #%i: %s", fileno (fhout), sstrerror (errno, errbuf, sizeof (errbuf))); break; } } } /* while (fgets) */ DEBUG ("unixsock plugin: us_handle_client: Exiting.."); fclose (fhin); fclose (fhout); pthread_exit ((void *) 0); return ((void *) 0); } /* void *us_handle_client */
static int lv_config (const char *key, const char *value) { if (virInitialize () != 0) return 1; if (il_domains == NULL) il_domains = ignorelist_create (1); if (il_block_devices == NULL) il_block_devices = ignorelist_create (1); if (il_interface_devices == NULL) il_interface_devices = ignorelist_create (1); if (strcasecmp (key, "Connection") == 0) { char *tmp = strdup (value); if (tmp == NULL) { ERROR (PLUGIN_NAME " plugin: Connection strdup failed."); return 1; } sfree (conn_string); conn_string = tmp; return 0; } if (strcasecmp (key, "RefreshInterval") == 0) { char *eptr = NULL; interval = strtol (value, &eptr, 10); if (eptr == NULL || *eptr != '\0') return 1; return 0; } if (strcasecmp (key, "Domain") == 0) { if (ignorelist_add (il_domains, value)) return 1; return 0; } if (strcasecmp (key, "BlockDevice") == 0) { if (ignorelist_add (il_block_devices, value)) return 1; return 0; } if (strcasecmp (key, "InterfaceDevice") == 0) { if (ignorelist_add (il_interface_devices, value)) return 1; return 0; } if (strcasecmp (key, "IgnoreSelected") == 0) { if (IS_TRUE (value)) { ignorelist_set_invert (il_domains, 0); ignorelist_set_invert (il_block_devices, 0); ignorelist_set_invert (il_interface_devices, 0); } else { ignorelist_set_invert (il_domains, 1); ignorelist_set_invert (il_block_devices, 1); ignorelist_set_invert (il_interface_devices, 1); } return 0; } if (strcasecmp (key, "HostnameFormat") == 0) { char *value_copy; char *fields[HF_MAX_FIELDS]; int i, n; value_copy = strdup (value); if (value_copy == NULL) { ERROR (PLUGIN_NAME " plugin: strdup failed."); return -1; } n = strsplit (value_copy, fields, HF_MAX_FIELDS); if (n < 1) { sfree (value_copy); ERROR (PLUGIN_NAME " plugin: HostnameFormat: no fields"); return -1; } for (i = 0; i < n; ++i) { if (strcasecmp (fields[i], "hostname") == 0) hostname_format[i] = hf_hostname; else if (strcasecmp (fields[i], "name") == 0) hostname_format[i] = hf_name; else if (strcasecmp (fields[i], "uuid") == 0) hostname_format[i] = hf_uuid; else { ERROR (PLUGIN_NAME " plugin: unknown HostnameFormat field: %s", fields[i]); sfree (value_copy); return -1; } } sfree (value_copy); for (i = n; i < HF_MAX_FIELDS; ++i) hostname_format[i] = hf_none; return 0; } if (strcasecmp (key, "PluginInstanceFormat") == 0) { char *value_copy; char *fields[PLGINST_MAX_FIELDS]; int i, n; value_copy = strdup (value); if (value_copy == NULL) { ERROR (PLUGIN_NAME " plugin: strdup failed."); return -1; } n = strsplit (value_copy, fields, PLGINST_MAX_FIELDS); if (n < 1) { sfree (value_copy); ERROR (PLUGIN_NAME " plugin: PluginInstanceFormat: no fields"); return -1; } for (i = 0; i < n; ++i) { if (strcasecmp (fields[i], "none") == 0) { plugin_instance_format[i] = plginst_none; break; } else if (strcasecmp (fields[i], "name") == 0) plugin_instance_format[i] = plginst_name; else if (strcasecmp (fields[i], "uuid") == 0) plugin_instance_format[i] = plginst_uuid; else { ERROR (PLUGIN_NAME " plugin: unknown PluginInstanceFormat field: %s", fields[i]); sfree (value_copy); return -1; } } sfree (value_copy); for (i = n; i < PLGINST_MAX_FIELDS; ++i) plugin_instance_format[i] = plginst_none; return 0; } if (strcasecmp (key, "InterfaceFormat") == 0) { if (strcasecmp (value, "name") == 0) interface_format = if_name; else if (strcasecmp (value, "address") == 0) interface_format = if_address; else if (strcasecmp (value, "number") == 0) interface_format = if_number; else { ERROR (PLUGIN_NAME " plugin: unknown InterfaceFormat: %s", value); return -1; } return 0; } /* Unrecognised option. */ return -1; }
/* rnmrtk_read_parms(): read the parameter file corresponding to an RNMRTK * data file. * @fname: the data filename. * @par: pointer to the output parameter structure. */ int rnmrtk_read_parms (const char *fname, struct rnmrtk_parms *par) { /* declare a few required variables: * @pfname: parameter file name. * @buf: buffer holding parameter file lines. * @nfields: number of strings in the fields array. * @fields: string array of space-delimited fields. * @i: general purpose loop counter. * @fh: parameter file handle. */ char *pfname, buf[N_BUF]; unsigned int i, nfields; char **fields; FILE *fh; /* declare variables required for parsing layout lines: * @dim: main dimension index. * @sub: sub-dimension index. * @pts: point count. */ int dim, sub, pts; /* initialize the parameter structure contents. */ memset(par, 0, sizeof(struct rnmrtk_parms)); /* build the parameter filename string. */ pfname = rnmrtk_parfile(fname); /* check that the string was created successfully. */ if (!pfname) throw("failed to allocate parameter filename"); /* open the parameter file. */ fh = fopen(pfname, "rb"); /* check that the file was opened. */ if (!fh) throw("failed to open '%s'", pfname); /* loop until we've read the entire file. */ while (!feof(fh)) { /* read a new line from the file. */ if (fgets(buf, N_BUF, fh)) { /* trim trailing newlines from the string. */ strnltrim((char*) buf); /* split the line by whitespace. */ fields = strsplit(buf, " ", &nfields); /* trim the fields and convert everything to lowercase. */ strvtrim(fields, nfields); strvcompact(fields, &nfields); strvtolower(fields, nfields); /* determine which parameter line we've tokenized. */ if (strcmp(fields[0], RNMRTK_PARLINE_FORMAT) == 0) { /* parse all available format line fields. */ if (nfields >= 2) { /* parse the endianness of the data. */ if (strcmp(fields[1], RNMRTK_ENDIAN_BIG) == 0) par->endian = BYTES_ENDIAN_BIG; else if (strcmp(fields[1], RNMRTK_ENDIAN_LITTLE) == 0) par->endian = BYTES_ENDIAN_LITTLE; else throw("invalid endianness '%s'", fields[1]); } if (nfields >= 3) { /* parse the word style of the data. */ if (strcmp(fields[2], RNMRTK_WTYPE_INT) == 0) par->isflt = 0; else if (strcmp(fields[2], RNMRTK_WTYPE_FLT) == 0) par->isflt = 1; else throw("invalid word type '%s'", fields[2]); } if (nfields >= 4) { /* parse the header size. */ par->nheader = atoi(fields[3]); } if (nfields >= 5) { /* parse the record length. */ par->reclen = atoi(fields[4]); } if (nfields >= 6) { /* parse the padding size. */ par->nbegin = atoi(fields[5]); } if (nfields >= 7) { /* parse the end padding. */ par->nend = atoi(fields[6]); } } else if (strcmp(fields[0], RNMRTK_PARLINE_DOM) == 0) { /* store the number of dimensions. */ par->nd = nfields - 1; /* check the number of dimensions. */ if (par->nd < 1 || par->nd > RNMRTK_MAXDIM) throw("invalid dimension count %u", par->nd); /* parse the 'dom' line fields. */ for (i = 0; i < par->nd; i++) { /* check that the first character is 't'. */ if (fields[i + 1][0] != 't' || strlen(fields[i + 1]) < 2) throw("invalid field '%s' on '%s'", fields[i + 1], fields[0]); /* parse the dimension index. */ par->ord[i] = atoi(fields[i + 1] + 1); } } else if (strcmp(fields[0], RNMRTK_PARLINE_N) == 0) { /* check for correct field count. */ if (nfields != 2 * par->nd + 1) throw("invalid field count of %u on '%s'", nfields, fields[0]); /* parse the 'n' line fields. */ for (i = 0; i < par->nd; i++) { /* parse the size value. */ par->sz[i] = atoi(fields[2 * i + 1]); /* parse the complex flag. */ if (strcmp(fields[2 * i + 2], RNMRTK_NTYPE_REAL) == 0) par->cx[i] = 0; else if (strcmp(fields[2 * i + 2], RNMRTK_NTYPE_COMPLEX) == 0) par->cx[i] = 1; else throw("invalid real/complex field '%s'", fields[2 * i + 2]); } } else if (strcmp(fields[0], RNMRTK_PARLINE_LAYOUT) == 0) { /* parse the 'layout' line fields. */ for (i = 1; i < nfields; i++) { /* attempt to parse each layout field form. */ if (sscanf(fields[i], "t%d-%d:%d", &dim, &sub, &pts) == 3 && dim > 0 && dim <= par->nd) { /* store the parsed point count. */ par->layout[dim - 1][sub] = pts; } else if (sscanf(fields[i], "t%d:%d", &dim, &pts) == 2 && dim > 0 && dim <= par->nd) { /* store the parsed point count. */ par->layout[dim - 1][1] = pts; } else throw("invalid %s field '%s'", fields[0], fields[i]); } } else if (strcmp(fields[0], RNMRTK_PARLINE_SF) == 0) { /* check for correct field count. */ if (nfields != par->nd + 1) throw("invalid field count of %u on '%s'", nfields, fields[0]); /* parse the 'sf' line fields. */ for (i = 0; i < par->nd; i++) par->sf[i] = atof(fields[i + 1]); } else if (strcmp(fields[0], RNMRTK_PARLINE_PPM) == 0) { /* check for correct field count. */ if (nfields != par->nd + 1) throw("invalid field count of %u on '%s'", nfields, fields[0]); /* parse the 'ppm' line fields. */ for (i = 0; i < par->nd; i++) par->ppm[i] = atof(fields[i + 1]); } else if (strcmp(fields[0], RNMRTK_PARLINE_QUAD) == 0) { /* check for correct field count. */ if (nfields != par->nd + 1) throw("invalid field count of %u on '%s'", nfields, fields[0]); /* parse the 'quad' line fields. */ for (i = 0; i < par->nd; i++) { /* determine the quadrature setting. */ if (strcmp(fields[i + 1], RNMRTK_QUADSTR_TPPI) == 0) par->quad[i] = RNMRTK_QUAD_TPPI; else if (strcmp(fields[i + 1], RNMRTK_QUADSTR_STATES) == 0) par->quad[i] = RNMRTK_QUAD_STATES; else if (strcmp(fields[i + 1], RNMRTK_QUADSTR_STATESTPPI) == 0) par->quad[i] = RNMRTK_QUAD_STATESTPPI; else throw("invalid quadrature '%s'", fields[i + 1]); } } else if (strcmp(fields[0], RNMRTK_PARLINE_SW) == 0) { /* check for correct field count. */ if (nfields != par->nd + 1) throw("invalid field count of %u on '%s'", nfields, fields[0]); /* parse the 'sw' line fields. */ for (i = 0; i < par->nd; i++) par->sw[i] = atof(fields[i + 1]); } /* free the fields string array. */ strvfree(fields, nfields); } } /* close the parameter file. */ fclose(fh); /* free the parameter filename. */ free(pfname); /* return success. */ return 1; }
int worker_process(epdata_t *epd, int thread_at) { //printf("worker_process\n"); working_at_fd = epd->fd; //network_send_error(epd, 503, "Lua Error: main function not found !!!");return 0; //network_send(epd, "aaa", 3);network_be_end(epd);return 0; if(epd->ssl && !epd->ssl_verify) { network_send_error(epd, 400, "No required SSL certificate was send"); return 0; } lua_State *L = epd->L; if(!L) { epd->L = new_lua_thread(_L); if(!epd->L) { network_send_error(epd, 503, "Lua Error: Thread pool full !!!"); return 0; } lua_pushlightuserdata(epd->L, epd); lua_setglobal(epd->L, "__epd__"); L = epd->L; } lua_getglobal(L, "process"); update_timeout(epd->timeout_ptr, STEP_PROCESS_TIMEOUT + 100); int init_tables = 0; char *pt1 = NULL, *pt2 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL; int is_form_post = 0; char *cookies = NULL; pt1 = epd->headers; int i = 0; epd->uri = NULL; epd->host = NULL; epd->query = NULL; epd->http_ver = NULL; epd->referer = NULL; epd->user_agent = NULL; epd->if_modified_since = NULL; //epd->start_time = longtime(); while(t1 = strtok_r(pt1, "\n", &pt1)) { if(++i == 1) { /// first line t2 = strtok_r(t1, " ", &t1); t3 = strtok_r(t1, " ", &t1); epd->http_ver = strtok_r(t1, " ", &t1); if(!epd->http_ver) { return 1; } else { if(init_tables == 0) { lua_newtable(L); //headers } } int len = strlen(epd->http_ver); if(epd->http_ver[len - 1] == 13) { // CR == 13 epd->http_ver[len - 1] = '\0'; } if(t2 && t3) { for(t1 = t2 ; *t1 ; *t1 = toupper(*t1), t1++); epd->method = t2; lua_pushstring(L, t2); lua_setfield(L, -2, "method"); t1 = strtok_r(t3, "?", &t3); t2 = strtok_r(t3, "?", &t3); epd->uri = t1; lua_pushstring(L, t1); lua_setfield(L, -2, "uri"); if(t2) { epd->query = (t2 - 1); epd->query[0] = '?'; lua_pushstring(L, epd->query); lua_setfield(L, -2, "query"); } } continue; } t2 = strtok_r(t1, ":", &t1); if(t2) { if(t2[0] == '\r') { break; } for(t3 = t2; *t3; ++t3) { *t3 = *t3 >= 'A' && *t3 <= 'Z' ? *t3 | 0x60 : *t3; } t3 = t2 + strlen(t2) + 1; //strtok_r ( t1, ":", &t1 ) if(t3) { int len = strlen(t3); if(t3[len - 1] == 13) { /// 13 == CR t3[len - 1] = '\0'; len -= 1; } if(len < 1) { break; } lua_pushstring(L, t3 + (t3[0] == ' ' ? 1 : 0)); lua_setfield(L, -2, t2); /// check content-type if(t2[0] == 'h' && epd->host == NULL && strcmp(t2, "host") == 0) { char *_t = strstr(t3, ":"); if(_t) { _t[0] = '\0'; } epd->host = t3 + (t3[0] == ' ' ? 1 : 0); } else if(t2[1] == 'o' && strcmp(t2, "content-type") == 0) { if(stristr(t3, "x-www-form-urlencoded", len)) { is_form_post = 1; } else if(stristr(t3, "multipart/form-data", len)) { epd->boundary = (char *)stristr(t3, "boundary=", len - 2); if(epd->boundary) { epd->boundary += 9; } } } else if(!cookies && t2[1] == 'o' && strcmp(t2, "cookie") == 0) { cookies = t3 + (t3[0] == ' ' ? 1 : 0); } else if(!epd->user_agent && t2[1] == 's' && strcmp(t2, "user-agent") == 0) { epd->user_agent = t3 + (t3[0] == ' ' ? 1 : 0); } else if(!epd->referer && t2[1] == 'e' && strcmp(t2, "referer") == 0) { epd->referer = t3 + (t3[0] == ' ' ? 1 : 0); } else if(!epd->if_modified_since && t2[1] == 'f' && strcmp(t2, "if-modified-since") == 0) { epd->if_modified_since = t3 + (t3[0] == ' ' ? 1 : 0); } } } } char *client_ip = inet_ntoa(epd->client_addr); lua_pushstring(L, client_ip); lua_setfield(L, -2, "remote-addr"); int l = sizeof(struct sockaddr); struct sockaddr_in addr; getsockname(epd->fd, (struct sockaddr *) &addr, &l); lua_pushstring(L, inet_ntoa(addr.sin_addr)); lua_setfield(L, -2, "server-addr"); lua_setglobal(L, "headers"); lua_newtable(L); /// _GET if(epd->query) { /// parse query string /?a=1&b=2 char *last = NULL; int plen = 0; int qlen = strlen(epd->query) - 1; t1 = (char *)strsplit(epd->query + 1, qlen, "&", &last, &plen); char kk[256] = {0}; while(t1) { char *last2 = NULL; int plen2 = 0; int plen3 = 0; t2 = (char *)strsplit(t1, plen, "=", &last2, &plen2); t3 = (char *)strsplit(t1, plen, "=", &last2, &plen3); if(t2 && plen2 > 0 && plen3 > 0 && plen2 <= 4096 && plen3 <= 4096) { size_t dlen; u_char *p; u_char *src, *dst; p = (u_char *)&buf_4096; p[0] = '\0'; dst = p; dlen = urldecode(&p, (u_char **)&t3, plen3, RAW_UNESCAPE_URL); lua_pushlstring(L, (char *) p, dlen); p[0] = '\0'; dst = p; dlen = urldecode(&dst, (u_char **)&t2, plen2, RAW_UNESCAPE_URL); p[dlen] = '\0'; lua_setfield(L, -2, p); } t1 = (char *)strsplit(epd->query + 1, qlen, "&", &last, &plen); } } lua_setglobal(L, "_GET"); lua_newtable(L); /// _COOKIE if(cookies) { while(t1 = strtok_r(cookies, ";", &cookies)) { t2 = strtok_r(t1, "=", &t1); t3 = strtok_r(t1, "=", &t1); if(t2 && t3 && strlen(t2) > 0 && strlen(t3) > 0) { size_t len, dlen; u_char *p; u_char *src, *dst; len = strlen(t3); p = malloc(len); p[0] = '\0'; dst = p; dlen = urldecode(&dst, (u_char **)&t3, len, RAW_UNESCAPE_URL); lua_pushlstring(L, (char *) p, dlen); len = strlen(t2); if(len > 4096) { free(p); p = malloc(len); } p[0] = '\0'; dst = p; dlen = urldecode(&dst, (u_char **)&t2, len, RAW_UNESCAPE_URL); p[dlen] = '\0'; lua_setfield(L, -2, p + (p[0] == ' ' ? 1 : 0)); free(p); } } } lua_setglobal(L, "_COOKIE"); lua_pushnil(L); lua_setglobal(L, "__body_buf"); epd->vhost_root = get_vhost_root(epd->host, &epd->vhost_root_len); memcpy(buf_4096, epd->vhost_root, epd->vhost_root_len + 1); sprintf(buf_4096 + epd->vhost_root_len + 1, "?.lua;%s/lua-libs/?.lua;", process_chdir); lua_pushstring(L, buf_4096); lua_getglobal(L, "package"); lua_insert(L, -2); //-1 bufres -2 package lua_setfield(L, -2, "path"); //-1: path -2: package lua_pop(L, 1); //void lua_pushlstring(L, epd->vhost_root, epd->vhost_root_len); /// host root lua_setglobal(L, "__root"); lua_pushstring(L, epd->vhost_root + epd->vhost_root_len); /// index-route.lua file epd->iov[0].iov_base = NULL; epd->iov[0].iov_len = 0; epd->iov[1].iov_base = NULL; epd->iov[1].iov_len = 0; lua_routed = 0; if(lua_resume(L, 1) == LUA_ERRRUN && lua_isstring(L, -1)) { LOGF(ERR, "Lua:error %s", lua_tostring(L, -1)); network_send_error(epd, 503, lua_tostring(L, -1)); lua_pop(L, 1); } return 0; }
static char * amfs_parse_defaults(am_node *mp, mntfs *mf, char *def_opts) { char *dflts; char *dfl; char **rvec = NULL; struct mnt_map *mm = (mnt_map *) mf->mf_private; dlog("determining /defaults entry value"); /* * Find out if amd.conf overrode any map-specific /defaults. */ if (mm->cfm && mm->cfm->cfm_defaults) { dlog("map %s map_defaults override: %s", mf->mf_mount, mm->cfm->cfm_defaults); dflts = xstrdup(mm->cfm->cfm_defaults); } else if (mapc_search(mm, "/defaults", &dflts) == 0) { dlog("/defaults gave %s", dflts); } else { return def_opts; /* if nothing found */ } /* trim leading '-' in case thee's one */ if (*dflts == '-') dfl = dflts + 1; else dfl = dflts; /* * Chop the defaults up */ rvec = strsplit(dfl, ' ', '\"'); if (gopt.flags & CFM_SELECTORS_IN_DEFAULTS) { /* * Pick whichever first entry matched the list of selectors. * Strip the selectors from the string, and assign to dfl the * rest of the string. */ if (rvec) { am_opts ap; am_ops *pt; char **sp = rvec; while (*sp) { /* loop until you find something, if any */ memset((char *) &ap, 0, sizeof(am_opts)); /* * This next routine cause many spurious "expansion of ... is" * messages, which are ignored, b/c all we need out of this * routine is to match selectors. These spurious messages may * be wrong, esp. if they try to expand ${key} b/c it will * get expanded to "/defaults" */ pt = ops_match(&ap, *sp, "", mp->am_path, "/defaults", mp->am_parent->am_al->al_mnt->mf_info); free_opts(&ap); /* don't leak */ if (pt == &amfs_error_ops) { plog(XLOG_MAP, "did not match defaults for \"%s\"", *sp); } else { dfl = strip_selectors(*sp, "/defaults"); plog(XLOG_MAP, "matched default selectors \"%s\"", dfl); break; } ++sp; } } } else { /* not selectors_in_defaults */ /* * Extract first value */ dfl = rvec[0]; } /* * If there were any values at all... */ if (dfl) { /* * Log error if there were other values */ if (!(gopt.flags & CFM_SELECTORS_IN_DEFAULTS) && rvec[1]) { dlog("/defaults chopped into %s", dfl); plog(XLOG_USER, "More than a single value for /defaults in %s", mf->mf_info); } /* * Prepend to existing defaults if they exist, * otherwise just use these defaults. */ if (*def_opts && *dfl) { size_t l = strlen(def_opts) + strlen(dfl) + 2; char *nopts = (char *) xmalloc(l); xsnprintf(nopts, l, "%s;%s", dfl, def_opts); XFREE(def_opts); def_opts = nopts; } else if (*dfl) { def_opts = strealloc(def_opts, dfl); } } XFREE(dflts); /* don't need info vector any more */ if (rvec) XFREE(rvec); return def_opts; }
static int apache_read_host (user_data_t *user_data) /* {{{ */ { int i; char *ptr; char *saveptr; char *lines[16]; int lines_num = 0; char *fields[4]; int fields_num; apache_t *st; st = user_data->data; assert (st->url != NULL); /* (Assured by `config_add') */ if (st->curl == NULL) { int status; status = init_host (st); if (status != 0) return (-1); } assert (st->curl != NULL); st->apache_buffer_fill = 0; if (curl_easy_perform (st->curl) != CURLE_OK) { ERROR ("apache: curl_easy_perform failed: %s", st->apache_curl_error); return (-1); } /* fallback - server_type to apache if not set at this time */ if (st->server_type == -1) { WARNING ("apache plugin: Unable to determine server software " "automatically. Will assume Apache."); st->server_type = APACHE; } ptr = st->apache_buffer; saveptr = NULL; while ((lines[lines_num] = strtok_r (ptr, "\n\r", &saveptr)) != NULL) { ptr = NULL; lines_num++; if (lines_num >= 16) break; } for (i = 0; i < lines_num; i++) { fields_num = strsplit (lines[i], fields, 4); if (fields_num == 3) { if ((strcmp (fields[0], "Total") == 0) && (strcmp (fields[1], "Accesses:") == 0)) submit_derive ("apache_requests", "", atoll (fields[2]), st); else if ((strcmp (fields[0], "Total") == 0) && (strcmp (fields[1], "kBytes:") == 0)) submit_derive ("apache_bytes", "", 1024LL * atoll (fields[2]), st); } else if (fields_num == 2) { if (strcmp (fields[0], "Scoreboard:") == 0) submit_scoreboard (fields[1], st); else if ((strcmp (fields[0], "BusyServers:") == 0) /* Apache 1.* */ || (strcmp (fields[0], "BusyWorkers:") == 0) /* Apache 2.* */) submit_gauge ("apache_connections", NULL, atol (fields[1]), st); else if ((strcmp (fields[0], "IdleServers:") == 0) /* Apache 1.x */ || (strcmp (fields[0], "IdleWorkers:") == 0) /* Apache 2.x */) submit_gauge ("apache_idle_workers", NULL, atol (fields[1]), st); } } st->apache_buffer_fill = 0; return (0); } /* }}} int apache_read_host */
static int read_file(const char *path) { FILE *fh; char key_buffer[4096]; char value_buffer[4096]; char *key_ptr; char *value_ptr; char *key_fields[256]; char *value_fields[256]; int key_fields_num; int value_fields_num; int status; int i; fh = fopen(path, "r"); if (fh == NULL) { ERROR("protocols plugin: fopen (%s) failed: %s.", path, sstrerror(errno, key_buffer, sizeof(key_buffer))); return (-1); } status = -1; while (42) { clearerr(fh); key_ptr = fgets(key_buffer, sizeof(key_buffer), fh); if (key_ptr == NULL) { if (feof(fh) != 0) { status = 0; break; } else if (ferror(fh) != 0) { ERROR("protocols plugin: Reading from %s failed.", path); break; } else { ERROR("protocols plugin: fgets failed for an unknown reason."); break; } } /* if (key_ptr == NULL) */ value_ptr = fgets(value_buffer, sizeof(value_buffer), fh); if (value_ptr == NULL) { ERROR("protocols plugin: read_file (%s): Could not read values line.", path); break; } key_ptr = strchr(key_buffer, ':'); if (key_ptr == NULL) { ERROR("protocols plugin: Could not find protocol name in keys line."); break; } *key_ptr = 0; key_ptr++; value_ptr = strchr(value_buffer, ':'); if (value_ptr == NULL) { ERROR("protocols plugin: Could not find protocol name " "in values line."); break; } *value_ptr = 0; value_ptr++; if (strcmp(key_buffer, value_buffer) != 0) { ERROR("protocols plugin: Protocol names in keys and values lines " "don't match: `%s' vs. `%s'.", key_buffer, value_buffer); break; } key_fields_num = strsplit(key_ptr, key_fields, STATIC_ARRAY_SIZE(key_fields)); value_fields_num = strsplit(value_ptr, value_fields, STATIC_ARRAY_SIZE(value_fields)); if (key_fields_num != value_fields_num) { ERROR("protocols plugin: Number of fields in keys and values lines " "don't match: %i vs %i.", key_fields_num, value_fields_num); break; } for (i = 0; i < key_fields_num; i++) { if (values_list != NULL) { char match_name[2 * DATA_MAX_NAME_LEN]; ssnprintf(match_name, sizeof(match_name), "%s:%s", key_buffer, key_fields[i]); if (ignorelist_match(values_list, match_name)) continue; } /* if (values_list != NULL) */ submit(key_buffer, key_fields[i], value_fields[i]); } /* for (i = 0; i < key_fields_num; i++) */ } /* while (42) */ fclose(fh); return (status); } /* int read_file */
static int interface_read (void) { #if HAVE_GETIFADDRS struct ifaddrs *if_list; struct ifaddrs *if_ptr; /* Darwin/Mac OS X and possible other *BSDs */ #if HAVE_STRUCT_IF_DATA # define IFA_DATA if_data # define IFA_RX_BYTES ifi_ibytes # define IFA_TX_BYTES ifi_obytes # define IFA_RX_PACKT ifi_ipackets # define IFA_TX_PACKT ifi_opackets # define IFA_RX_ERROR ifi_ierrors # define IFA_TX_ERROR ifi_oerrors /* #endif HAVE_STRUCT_IF_DATA */ #elif HAVE_STRUCT_NET_DEVICE_STATS # define IFA_DATA net_device_stats # define IFA_RX_BYTES rx_bytes # define IFA_TX_BYTES tx_bytes # define IFA_RX_PACKT rx_packets # define IFA_TX_PACKT tx_packets # define IFA_RX_ERROR rx_errors # define IFA_TX_ERROR tx_errors #else # error "No suitable type for `struct ifaddrs->ifa_data' found." #endif struct IFA_DATA *if_data; if (getifaddrs (&if_list) != 0) return (-1); for (if_ptr = if_list; if_ptr != NULL; if_ptr = if_ptr->ifa_next) { if (if_ptr->ifa_addr != NULL && if_ptr->ifa_addr->sa_family == AF_LINK) { if_data = (struct IFA_DATA *) if_ptr->ifa_data; if_submit (if_ptr->ifa_name, "if_octets", if_data->IFA_RX_BYTES, if_data->IFA_TX_BYTES); if_submit (if_ptr->ifa_name, "if_packets", if_data->IFA_RX_PACKT, if_data->IFA_TX_PACKT); if_submit (if_ptr->ifa_name, "if_errors", if_data->IFA_RX_ERROR, if_data->IFA_TX_ERROR); } } freeifaddrs (if_list); /* #endif HAVE_GETIFADDRS */ #elif KERNEL_LINUX FILE *fh; char buffer[1024]; derive_t incoming, outgoing; char *device; char *dummy; char *fields[16]; int numfields; if ((fh = fopen ("/proc/net/dev", "r")) == NULL) { char errbuf[1024]; WARNING ("interface plugin: fopen: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } while (fgets (buffer, 1024, fh) != NULL) { if (!(dummy = strchr(buffer, ':'))) continue; dummy[0] = '\0'; dummy++; device = buffer; while (device[0] == ' ') device++; if (device[0] == '\0') continue; numfields = strsplit (dummy, fields, 16); if (numfields < 11) continue; incoming = atoll (fields[0]); outgoing = atoll (fields[8]); if_submit (device, "if_octets", incoming, outgoing); incoming = atoll (fields[1]); outgoing = atoll (fields[9]); if_submit (device, "if_packets", incoming, outgoing); incoming = atoll (fields[2]); outgoing = atoll (fields[10]); if_submit (device, "if_errors", incoming, outgoing); incoming = atoll (fields[3]); outgoing = atoll (fields[11]); if_submit (device, "if_dropped", incoming, outgoing); } fclose (fh); /* #endif KERNEL_LINUX */ #elif HAVE_LIBKSTAT int i; derive_t rx; derive_t tx; char iname[DATA_MAX_NAME_LEN]; if (kc == NULL) return (-1); for (i = 0; i < numif; i++) { if (kstat_read (kc, ksp[i], NULL) == -1) continue; if (unique_name) ssnprintf(iname, sizeof(iname), "%s_%d_%s", ksp[i]->ks_module, ksp[i]->ks_instance, ksp[i]->ks_name); else sstrncpy(iname, ksp[i]->ks_name, sizeof(iname)); /* try to get 64bit counters */ rx = get_kstat_value (ksp[i], "rbytes64"); tx = get_kstat_value (ksp[i], "obytes64"); /* or fallback to 32bit */ if (rx == -1LL) rx = get_kstat_value (ksp[i], "rbytes"); if (tx == -1LL) tx = get_kstat_value (ksp[i], "obytes"); if ((rx != -1LL) || (tx != -1LL)) if_submit (iname, "if_octets", rx, tx); /* try to get 64bit counters */ rx = get_kstat_value (ksp[i], "ipackets64"); tx = get_kstat_value (ksp[i], "opackets64"); /* or fallback to 32bit */ if (rx == -1LL) rx = get_kstat_value (ksp[i], "ipackets"); if (tx == -1LL) tx = get_kstat_value (ksp[i], "opackets"); if ((rx != -1LL) || (tx != -1LL)) if_submit (iname, "if_packets", rx, tx); /* no 64bit error counters yet */ rx = get_kstat_value (ksp[i], "ierrors"); tx = get_kstat_value (ksp[i], "oerrors"); if ((rx != -1LL) || (tx != -1LL)) if_submit (iname, "if_errors", rx, tx); } /* #endif HAVE_LIBKSTAT */ #elif defined(HAVE_LIBSTATGRAB) sg_network_io_stats *ios; int i, num; ios = sg_get_network_io_stats (&num); for (i = 0; i < num; i++) if_submit (ios[i].interface_name, "if_octets", ios[i].rx, ios[i].tx); /* #endif HAVE_LIBSTATGRAB */ #elif defined(HAVE_PERFSTAT) perfstat_id_t id; int i, ifs; if ((nif = perfstat_netinterface(NULL, NULL, sizeof(perfstat_netinterface_t), 0)) < 0) { char errbuf[1024]; WARNING ("interface plugin: perfstat_netinterface: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } if (pnif != nif || ifstat == NULL) { free(ifstat); ifstat = malloc(nif * sizeof (*ifstat)); } pnif = nif; id.name[0]='\0'; if ((ifs = perfstat_netinterface(&id, ifstat, sizeof(perfstat_netinterface_t), nif)) < 0) { char errbuf[1024]; WARNING ("interface plugin: perfstat_netinterface (interfaces=%d): %s", nif, sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } for (i = 0; i < ifs; i++) { if_submit (ifstat[i].name, "if_octets", ifstat[i].ibytes, ifstat[i].obytes); if_submit (ifstat[i].name, "if_packets", ifstat[i].ipackets ,ifstat[i].opackets); if_submit (ifstat[i].name, "if_errors", ifstat[i].ierrors, ifstat[i].oerrors ); } #endif /* HAVE_PERFSTAT */ return (0); } /* int interface_read */
static int swap_read_combined (void) /* {{{ */ { FILE *fh; char buffer[1024]; uint8_t have_data = 0; gauge_t swap_used = 0.0; gauge_t swap_cached = 0.0; gauge_t swap_free = 0.0; gauge_t swap_total = 0.0; fh = fopen ("/proc/meminfo", "r"); if (fh == NULL) { char errbuf[1024]; WARNING ("swap plugin: fopen (/proc/meminfo) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } while (fgets (buffer, sizeof (buffer), fh) != NULL) { char *fields[8]; int numfields; numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields)); if (numfields < 2) continue; if (strcasecmp (fields[0], "SwapTotal:") == 0) { swap_total = strtod (fields[1], /* endptr = */ NULL); have_data |= 0x01; } else if (strcasecmp (fields[0], "SwapFree:") == 0) { swap_free = strtod (fields[1], /* endptr = */ NULL); have_data |= 0x02; } else if (strcasecmp (fields[0], "SwapCached:") == 0) { swap_cached = strtod (fields[1], /* endptr = */ NULL); have_data |= 0x04; } } fclose (fh); if (have_data != 0x07) return (ENOENT); if (isnan (swap_total) || (swap_total <= 0.0) || ((swap_free + swap_cached) > swap_total)) return (EINVAL); swap_used = swap_total - (swap_free + swap_cached); swap_submit_gauge (NULL, "used", 1024.0 * swap_used); swap_submit_gauge (NULL, "free", 1024.0 * swap_free); swap_submit_gauge (NULL, "cached", 1024.0 * swap_cached); return (0); } /* }}} int swap_read_combined */
static int read_acpi_callback (char const *dir, /* {{{ */ char const *power_supply, void *user_data) { int *battery_index = user_data; gauge_t current = NAN; gauge_t voltage = NAN; gauge_t charge = NAN; _Bool charging = 0; char const *plugin_instance; char filename[PATH_MAX]; char buffer[1024]; FILE *fh; ssnprintf (filename, sizeof (filename), "%s/%s/state", dir, power_supply); fh = fopen (filename, "r"); if ((fh = fopen (filename, "r")) == NULL) { if ((errno == EAGAIN) || (errno == EINTR) || (errno == ENOENT)) return (0); else return (errno); } /* * [11:00] <@tokkee> $ cat /proc/acpi/battery/BAT1/state * [11:00] <@tokkee> present: yes * [11:00] <@tokkee> capacity state: ok * [11:00] <@tokkee> charging state: charging * [11:00] <@tokkee> present rate: 1724 mA * [11:00] <@tokkee> remaining capacity: 4136 mAh * [11:00] <@tokkee> present voltage: 12428 mV */ while (fgets (buffer, sizeof (buffer), fh) != NULL) { char *fields[8]; int numfields; numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields)); if (numfields < 3) continue; if ((strcmp (fields[0], "charging") == 0) && (strcmp (fields[1], "state:") == 0)) { if (strcmp (fields[2], "charging") == 0) charging = 1; else charging = 0; continue; } /* FIXME: The unit of "present rate" depends on the battery. * Modern batteries export watts, not amperes, i.e. it's not a * current anymore. We should check if the fourth column * contains "mA" and only use a current then. Otherwise, export * a power. */ if ((strcmp (fields[0], "present") == 0) && (strcmp (fields[1], "rate:") == 0)) strtogauge (fields[2], ¤t); else if ((strcmp (fields[0], "remaining") == 0) && (strcmp (fields[1], "capacity:") == 0)) strtogauge (fields[2], &charge); else if ((strcmp (fields[0], "present") == 0) && (strcmp (fields[1], "voltage:") == 0)) strtogauge (fields[2], &voltage); } /* while (fgets (buffer, sizeof (buffer), fh) != NULL) */ fclose (fh); if (!charging) current *= -1.0; /* FIXME: This is a dirty hack for backwards compatibility: The battery * plugin, for a very long time, has had the plugin_instance * hard-coded to "0". So, to keep backwards compatibility, we'll use * "0" for the first battery we find and the power_supply name for all * following. This should be reverted in a future major version. */ plugin_instance = (*battery_index == 0) ? "0" : power_supply; (*battery_index)++; battery_submit (plugin_instance, "charge", charge / 1000.0); battery_submit (plugin_instance, "current", current / 1000.0); battery_submit (plugin_instance, "voltage", voltage / 1000.0); return 0; } /* }}} int read_acpi_callback */
static int read_pmu (void) /* {{{ */ { int i; /* The upper limit here is just a safeguard. If there is a system with * more than 100 batteries, this can easily be increased. */ for (i = 0; i < 100; i++) { FILE *fh; char buffer[1024]; char filename[PATH_MAX]; char plugin_instance[DATA_MAX_NAME_LEN]; gauge_t current = NAN; gauge_t voltage = NAN; gauge_t charge = NAN; ssnprintf (filename, sizeof (filename), PROC_PMU_PATH_FORMAT, i); if (access (filename, R_OK) != 0) break; ssnprintf (plugin_instance, sizeof (plugin_instance), "%i", i); fh = fopen (filename, "r"); if (fh == NULL) { if (errno == ENOENT) break; else if ((errno == EAGAIN) || (errno == EINTR)) continue; else return (errno); } while (fgets (buffer, sizeof (buffer), fh) != NULL) { char *fields[8]; int numfields; numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields)); if (numfields < 3) continue; if (strcmp ("current", fields[0]) == 0) strtogauge (fields[2], ¤t); else if (strcmp ("voltage", fields[0]) == 0) strtogauge (fields[2], &voltage); else if (strcmp ("charge", fields[0]) == 0) strtogauge (fields[2], &charge); } fclose (fh); fh = NULL; battery_submit (plugin_instance, "charge", charge / 1000.0); battery_submit (plugin_instance, "current", current / 1000.0); battery_submit (plugin_instance, "voltage", voltage / 1000.0); } if (i == 0) return (ENOENT); return (0); } /* }}} int read_pmu */
std::string extract_fractions(const std::string &fluid_string, std::vector<double> &fractions) { if (has_fractions_in_string(fluid_string)) { fractions.clear(); std::vector<std::string> names; // Break up into pairs - like "Ethane[0.5]&Methane[0.5]" -> ("Ethane[0.5]","Methane[0.5]") std::vector<std::string> pairs = strsplit(fluid_string, '&'); for (std::size_t i = 0; i < pairs.size(); ++i) { const std::string &fluid = pairs[i]; // Must end with ']' if (fluid[fluid.size()-1] != ']') throw ValueError(format("Fluid entry [%s] must end with ']' character",pairs[i].c_str())); // Split at '[', but first remove the ']' from the end by taking a substring std::vector<std::string> name_fraction = strsplit(fluid.substr(0, fluid.size()-1), '['); if (name_fraction.size() != 2){throw ValueError(format("Could not break [%s] into name/fraction", fluid.substr(0, fluid.size()-1).c_str()));} // Convert fraction to a double char *pEnd; const std::string &name = name_fraction[0], &fraction = name_fraction[1]; double f = strtod(fraction.c_str(), &pEnd); // If pEnd points to the last character in the string, it wasn't able to do the conversion if (pEnd == &(fraction[fraction.size()-1])){throw ValueError(format("Could not convert [%s] into number", fraction.c_str()));} // And add to vector fractions.push_back(f); // Add name names.push_back(name); } if (get_debug_level()>10) std::cout << format("%s:%d: Detected fractions of %s for %s.",__FILE__,__LINE__,vec_to_string(fractions).c_str(), (strjoin(names, "&")).c_str()); // Join fluids back together return strjoin(names, "&"); } else if (has_solution_concentration(fluid_string)) { fractions.clear(); double x; std::vector<std::string> fluid_parts = strsplit(fluid_string,'-'); // Check it worked if (fluid_parts.size() != 2){ throw ValueError(format("Format of incompressible solution string [%s] is invalid, should be like \"EG-20%\" or \"EG-0.2\" ", fluid_string.c_str()) ); } // Convert the concentration into a string char* pEnd; x = strtod(fluid_parts[1].c_str(), &pEnd); // Check if per cent or fraction syntax is used if (!strcmp(pEnd,"%")){ x *= 0.01;} fractions.push_back(x); if (get_debug_level()>10) std::cout << format("%s:%d: Detected incompressible concentration of %s for %s.",__FILE__,__LINE__,vec_to_string(fractions).c_str(), fluid_parts[0].c_str()); return fluid_parts[0]; } else { return fluid_string; } }
static int swap_read_io (void) /* {{{ */ { FILE *fh; char buffer[1024]; _Bool old_kernel = 0; uint8_t have_data = 0; derive_t swap_in = 0; derive_t swap_out = 0; fh = fopen ("/proc/vmstat", "r"); if (fh == NULL) { /* /proc/vmstat does not exist in kernels <2.6 */ fh = fopen ("/proc/stat", "r"); if (fh == NULL) { char errbuf[1024]; WARNING ("swap: fopen: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } else old_kernel = 1; } while (fgets (buffer, sizeof (buffer), fh) != NULL) { char *fields[8]; int numfields; numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields)); if (!old_kernel) { if (numfields != 2) continue; if (strcasecmp ("pswpin", fields[0]) == 0) { strtoderive (fields[1], &swap_in); have_data |= 0x01; } else if (strcasecmp ("pswpout", fields[0]) == 0) { strtoderive (fields[1], &swap_out); have_data |= 0x02; } } else /* if (old_kernel) */ { if (numfields != 3) continue; if (strcasecmp ("page", fields[0]) == 0) { strtoderive (fields[1], &swap_in); strtoderive (fields[2], &swap_out); } } } /* while (fgets) */ fclose (fh); if (have_data != 0x03) return (ENOENT); if (report_bytes) { swap_in = swap_in * pagesize; swap_out = swap_out * pagesize; } swap_submit_derive (NULL, "in", swap_in); swap_submit_derive (NULL, "out", swap_out); return (0); } /* }}} int swap_read_io */
/* Returns zero on success, less than zero on socket error and greater than * zero on other errors. */ static int conn_read_netlink(void) { #if HAVE_STRUCT_LINUX_INET_DIAG_REQ int fd; struct inet_diag_msg *r; char buf[8192]; /* If this fails, it's likely a permission problem. We'll fall back to * reading this information from files below. */ fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_INET_DIAG); if (fd < 0) { ERROR("tcpconns plugin: conn_read_netlink: socket(AF_NETLINK, SOCK_RAW, " "NETLINK_INET_DIAG) failed: %s", sstrerror(errno, buf, sizeof(buf))); return (-1); } struct sockaddr_nl nladdr = {.nl_family = AF_NETLINK}; struct nlreq req = { .nlh.nlmsg_len = sizeof(req), .nlh.nlmsg_type = TCPDIAG_GETSOCK, /* NLM_F_ROOT: return the complete table instead of a single entry. * NLM_F_MATCH: return all entries matching criteria (not implemented) * NLM_F_REQUEST: must be set on all request messages */ .nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST, .nlh.nlmsg_pid = 0, /* The sequence_number is used to track our messages. Since netlink is not * reliable, we don't want to end up with a corrupt or incomplete old * message in case the system is/was out of memory. */ .nlh.nlmsg_seq = ++sequence_number, .r.idiag_family = AF_INET, .r.idiag_states = 0xfff, .r.idiag_ext = 0}; struct iovec iov = {.iov_base = &req, .iov_len = sizeof(req)}; struct msghdr msg = {.msg_name = (void *)&nladdr, .msg_namelen = sizeof(nladdr), .msg_iov = &iov, .msg_iovlen = 1}; if (sendmsg(fd, &msg, 0) < 0) { ERROR("tcpconns plugin: conn_read_netlink: sendmsg(2) failed: %s", sstrerror(errno, buf, sizeof(buf))); close(fd); return (-1); } iov.iov_base = buf; iov.iov_len = sizeof(buf); while (1) { int status; struct nlmsghdr *h; memset(&msg, 0, sizeof(msg)); msg.msg_name = (void *)&nladdr; msg.msg_namelen = sizeof(nladdr); msg.msg_iov = &iov; msg.msg_iovlen = 1; status = recvmsg(fd, (void *)&msg, /* flags = */ 0); if (status < 0) { if ((errno == EINTR) || (errno == EAGAIN)) continue; ERROR("tcpconns plugin: conn_read_netlink: recvmsg(2) failed: %s", sstrerror(errno, buf, sizeof(buf))); close(fd); return (-1); } else if (status == 0) { close(fd); DEBUG("tcpconns plugin: conn_read_netlink: Unexpected zero-sized " "reply from netlink socket."); return (0); } h = (struct nlmsghdr *)buf; while (NLMSG_OK(h, status)) { if (h->nlmsg_seq != sequence_number) { h = NLMSG_NEXT(h, status); continue; } if (h->nlmsg_type == NLMSG_DONE) { close(fd); return (0); } else if (h->nlmsg_type == NLMSG_ERROR) { struct nlmsgerr *msg_error; msg_error = NLMSG_DATA(h); WARNING("tcpconns plugin: conn_read_netlink: Received error %i.", msg_error->error); close(fd); return (1); } r = NLMSG_DATA(h); /* This code does not (need to) distinguish between IPv4 and IPv6. */ conn_handle_ports(ntohs(r->id.idiag_sport), ntohs(r->id.idiag_dport), r->idiag_state); h = NLMSG_NEXT(h, status); } /* while (NLMSG_OK) */ } /* while (1) */ /* Not reached because the while() loop above handles the exit condition. */ return (0); #else return (1); #endif /* HAVE_STRUCT_LINUX_INET_DIAG_REQ */ } /* int conn_read_netlink */ static int conn_handle_line(char *buffer) { char *fields[32]; int fields_len; char *endptr; char *port_local_str; char *port_remote_str; uint16_t port_local; uint16_t port_remote; uint8_t state; int buffer_len = strlen(buffer); while ((buffer_len > 0) && (buffer[buffer_len - 1] < 32)) buffer[--buffer_len] = '\0'; if (buffer_len <= 0) return (-1); fields_len = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields)); if (fields_len < 12) { DEBUG("tcpconns plugin: Got %i fields, expected at least 12.", fields_len); return (-1); } port_local_str = strchr(fields[1], ':'); port_remote_str = strchr(fields[2], ':'); if ((port_local_str == NULL) || (port_remote_str == NULL)) return (-1); port_local_str++; port_remote_str++; if ((*port_local_str == '\0') || (*port_remote_str == '\0')) return (-1); endptr = NULL; port_local = (uint16_t)strtol(port_local_str, &endptr, 16); if ((endptr == NULL) || (*endptr != '\0')) return (-1); endptr = NULL; port_remote = (uint16_t)strtol(port_remote_str, &endptr, 16); if ((endptr == NULL) || (*endptr != '\0')) return (-1); endptr = NULL; state = (uint8_t)strtol(fields[3], &endptr, 16); if ((endptr == NULL) || (*endptr != '\0')) return (-1); return (conn_handle_ports(port_local, port_remote, state)); } /* int conn_handle_line */ static int conn_read_file(const char *file) { FILE *fh; char buffer[1024]; fh = fopen(file, "r"); if (fh == NULL) return (-1); while (fgets(buffer, sizeof(buffer), fh) != NULL) { conn_handle_line(buffer); } /* while (fgets) */ fclose(fh); return (0); } /* int conn_read_file */ /* #endif KERNEL_LINUX */ #elif HAVE_SYSCTLBYNAME /* #endif HAVE_SYSCTLBYNAME */ #elif HAVE_LIBKVM_NLIST #endif /* HAVE_LIBKVM_NLIST */ static int conn_config(const char *key, const char *value) { if (strcasecmp(key, "ListeningPorts") == 0) { if (IS_TRUE(value)) port_collect_listening = 1; else port_collect_listening = 0; } else if ((strcasecmp(key, "LocalPort") == 0) || (strcasecmp(key, "RemotePort") == 0)) { port_entry_t *pe; int port = atoi(value); if ((port < 1) || (port > 65535)) { ERROR("tcpconns plugin: Invalid port: %i", port); return (1); } pe = conn_get_port_entry((uint16_t)port, 1 /* create */); if (pe == NULL) { ERROR("tcpconns plugin: conn_get_port_entry failed."); return (1); } if (strcasecmp(key, "LocalPort") == 0) pe->flags |= PORT_COLLECT_LOCAL; else pe->flags |= PORT_COLLECT_REMOTE; } else if (strcasecmp(key, "AllPortsSummary") == 0) { if (IS_TRUE(value)) port_collect_total = 1; else port_collect_total = 0; } else { return (-1); } return (0); } /* int conn_config */ #if KERNEL_LINUX static int conn_init(void) { if (port_collect_total == 0 && port_list_head == NULL) port_collect_listening = 1; return (0); } /* int conn_init */ static int conn_read(void) { int status; conn_reset_port_entry(); if (linux_source == SRC_NETLINK) { status = conn_read_netlink(); } else if (linux_source == SRC_PROC) { int errors_num = 0; if (conn_read_file("/proc/net/tcp") != 0) errors_num++; if (conn_read_file("/proc/net/tcp6") != 0) errors_num++; if (errors_num < 2) status = 0; else status = ENOENT; } else /* if (linux_source == SRC_DUNNO) */ { /* Try to use netlink for getting this data, it is _much_ faster on systems * with a large amount of connections. */ status = conn_read_netlink(); if (status == 0) { INFO("tcpconns plugin: Reading from netlink succeeded. " "Will use the netlink method from now on."); linux_source = SRC_NETLINK; } else { INFO("tcpconns plugin: Reading from netlink failed. " "Will read from /proc from now on."); linux_source = SRC_PROC; /* return success here to avoid the "plugin failed" message. */ return (0); } } if (status == 0) conn_submit_all(); else return (status); return (0); } /* int conn_read */
/*! * @brief Waits for a native message string and sends a native response. * * Commands: finish, validate, validateBogus, reinitialise * * @return -1 on error, * 0 on success * 1 if end of program desired. */ static int wait_for_and_process_native_message(void) /* ========================================================================= */ { #define MAX_BUF_LEN 1024 #define DELIMS "~" char inbuf[MAX_BUF_LEN], outbuf[MAX_BUF_LEN]; unsigned int inlen, outlen; char *cmd, *dn, *options_str, *nameserver, *addr, *tab_id, *saveptr; int options_num; int val_ret; char *tmp; printf_debug(DEBUG_PREFIX_DNSSEC, "%s\n", "Waiting for native input."); inbuf[0] = '\0'; inlen = 0; if (fread(&inlen, 4, 1, stdin) != 1) { printf_debug(DEBUG_PREFIX_DNSSEC, "%s\n", "Cannot read input length."); return -1; } if (fread(inbuf, 1, inlen, stdin) != inlen) { printf_debug(DEBUG_PREFIX_DNSSEC, "%s\n", "Cannot read message."); return -1; } inbuf[inlen] = '\0'; printf_debug(DEBUG_PREFIX_DNSSEC, "IN %d %s\n", inlen, inbuf); /* First and last character is '"' .*/ --inlen; inbuf[inlen] = '\0'; cmd = strsplit(inbuf + 1, DELIMS, &saveptr); /* * TODO -- strtok_r()? * Use a tokeniser which can handle empty strings. */ if (strcmp(cmd, "finish") == 0) { /* Just tell that exit is desired. */ return 1; } else if (strcmp(cmd, "initialise") == 0) { printf_debug(DEBUG_PREFIX_DNSSEC, "%s\n", "Initialising."); dnssec_validation_init(); /* Generate output. */ if (snprintf(outbuf, MAX_BUF_LEN, "\"%sRet~ok\"", cmd) >= MAX_BUF_LEN) { /* Error. */ printf_debug(DEBUG_PREFIX_DNSSEC, "%s\n", "Error while creating response string."); return -1; } outlen = strlen(outbuf); printf_debug(DEBUG_PREFIX_DNSSEC, "OUT %d %s\n", outlen, outbuf); /* Write and flush. */ fwrite(&outlen, 4, 1, stdout); fputs(outbuf, stdout); fflush(stdout); } else if (strcmp(cmd, "reinitialise") == 0) { printf_debug(DEBUG_PREFIX_DNSSEC, "%s\n", "Reinitialising."); dnssec_validation_deinit(); dnssec_validation_init(); /* Generate no output. */ } else if ((strcmp(cmd, "validate") == 0) || (strcmp(cmd, "validateBogus") == 0)) { /* Tokenise input. */ dn = strsplit(NULL, DELIMS, &saveptr); options_str = strsplit(NULL, DELIMS, &saveptr); nameserver = strsplit(NULL, DELIMS, &saveptr); addr = strsplit(NULL, DELIMS, &saveptr); tab_id = strsplit(NULL, DELIMS, &saveptr); if (('\0' == nameserver[0]) || (strcmp("sysresolver", nameserver) == 0)) { nameserver = NULL; } options_num = strtol(options_str, NULL, 10); val_ret = dnssec_validate(dn, options_num, nameserver, addr, &tmp); /* Generate output. */ if (snprintf(outbuf, MAX_BUF_LEN, "\"%sRet~%s~%d~%s~%s~%s~%s\"", cmd, dn, val_ret, tmp, addr, tab_id, PACKAGE_VERSION) >= MAX_BUF_LEN) { /* Error. */ printf_debug(DEBUG_PREFIX_DNSSEC, "%s\n", "Error while creating response string."); return -1; } outlen = strlen(outbuf); printf_debug(DEBUG_PREFIX_DNSSEC, "OUT %d %s\n", outlen, outbuf); /* Write and flush. */ fwrite(&outlen, 4, 1, stdout); fputs(outbuf, stdout); fflush(stdout); } else { /* No action. */ printf_debug(DEBUG_PREFIX_DNSSEC, "Undefined command '%s'.\n", cmd); } return 0; #undef MAX_BUF_LEN #undef DELIMS }
static int amfs_program_exec(char *info) { char **xivec; int error; /* * Split copy of command info string */ info = strdup(info); if (info == 0) return ENOBUFS; xivec = strsplit(info, ' ', '\''); /* * Put stdout to stderr */ (void) fclose(stdout); if (!logfp) logfp = stderr; /* initialize before possible first use */ (void) dup(fileno(logfp)); if (fileno(logfp) != fileno(stderr)) { (void) fclose(stderr); (void) dup(fileno(logfp)); } /* * Try the exec */ if (amuDebug(D_FULL)) { char **cp = xivec; plog(XLOG_DEBUG, "executing (un)mount command..."); while (*cp) { plog(XLOG_DEBUG, "arg[%ld] = '%s'", (long) (cp - xivec), *cp); cp++; } } if (xivec[0] == 0 || xivec[1] == 0) { errno = EINVAL; plog(XLOG_USER, "1st/2nd args missing to (un)mount program"); } else { (void) execv(xivec[0], xivec + 1); } /* * Save error number */ error = errno; plog(XLOG_ERROR, "exec failed: %m"); /* * Free allocate memory */ XFREE(info); XFREE(xivec); /* * Return error */ return error; }
static int iptables_config(const char *key, const char *value) { /* int ip_value; */ protocol_version_t ip_version = 0; if (strcasecmp(key, "Chain") == 0) ip_version = IPV4; else if (strcasecmp(key, "Chain6") == 0) ip_version = IPV6; else return 1; ip_chain_t temp = {0}; ip_chain_t *final, **list; char *table; char *chain; char *value_copy; char *fields[4]; int fields_num; value_copy = strdup(value); if (value_copy == NULL) { ERROR("strdup failed: %s", STRERRNO); return 1; } /* * Time to fill the temp element * Examine value string, it should look like: * Chain[6] <table> <chain> [<comment|num> [name]] */ /* set IPv4 or IPv6 */ temp.ip_version = ip_version; /* Chain <table> <chain> [<comment|num> [name]] */ fields_num = strsplit(value_copy, fields, 4); if (fields_num < 2) { free(value_copy); return 1; } table = fields[0]; chain = fields[1]; size_t table_len = strlen(table) + 1; if (table_len > sizeof(temp.table)) { ERROR("Table `%s' too long.", table); free(value_copy); return 1; } sstrncpy(temp.table, table, table_len); size_t chain_len = strlen(chain) + 1; if (chain_len > sizeof(temp.chain)) { ERROR("Chain `%s' too long.", chain); free(value_copy); return 1; } sstrncpy(temp.chain, chain, chain_len); if (fields_num >= 3) { char *comment = fields[2]; int rule = atoi(comment); if (rule) { temp.rule.num = rule; temp.rule_type = RTYPE_NUM; } else { temp.rule.comment = strdup(comment); if (temp.rule.comment == NULL) { free(value_copy); return 1; } temp.rule_type = RTYPE_COMMENT; } } else { temp.rule_type = RTYPE_COMMENT_ALL; } if (fields_num >= 4) sstrncpy(temp.name, fields[3], sizeof(temp.name)); free(value_copy); value_copy = NULL; table = NULL; chain = NULL; list = realloc(chain_list, (chain_num + 1) * sizeof(ip_chain_t *)); if (list == NULL) { ERROR("realloc failed: %s", STRERRNO); sfree(temp.rule.comment); return 1; } chain_list = list; final = malloc(sizeof(*final));
std::string getSolutionName(std::string name){ // TODO Solutions: Remove as soon as possible // Split into fluid, concentration pair std::vector<std::string> fluid_concentration = strsplit(std::string(name),'-'); return fluid_concentration[0]; }