int read_types_list (const char *file) { FILE *fh; if (file == NULL) return (-1); fh = fopen (file, "r"); if (fh == NULL) { char errbuf[1024]; fprintf (stderr, "Failed to open types database `%s': %s.\n", file, sstrerror (errno, errbuf, sizeof (errbuf))); ERROR ("Failed to open types database `%s': %s", file, sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } parse_file (fh); fclose (fh); fh = NULL; DEBUG ("Done parsing `%s'", file); return (0); } /* int read_types_list */
static char *camqp_strerror (camqp_config_t *conf, /* {{{ */ char *buffer, size_t buffer_size) { amqp_rpc_reply_t r; r = amqp_get_rpc_reply (conf->connection); switch (r.reply_type) { case AMQP_RESPONSE_NORMAL: sstrncpy (buffer, "Success", sizeof (buffer)); break; case AMQP_RESPONSE_NONE: sstrncpy (buffer, "Missing RPC reply type", sizeof (buffer)); break; case AMQP_RESPONSE_LIBRARY_EXCEPTION: #if HAVE_AMQP_RPC_REPLY_T_LIBRARY_ERRNO if (r.library_errno) return (sstrerror (r.library_errno, buffer, buffer_size)); #else if (r.library_error) return (sstrerror (r.library_error, buffer, buffer_size)); #endif else sstrncpy (buffer, "End of stream", sizeof (buffer)); break; case AMQP_RESPONSE_SERVER_EXCEPTION: if (r.reply.id == AMQP_CONNECTION_CLOSE_METHOD) { amqp_connection_close_t *m = r.reply.decoded; char *tmp = camqp_bytes_cstring (&m->reply_text); ssnprintf (buffer, buffer_size, "Server connection error %d: %s", m->reply_code, tmp); sfree (tmp); } else if (r.reply.id == AMQP_CHANNEL_CLOSE_METHOD) { amqp_channel_close_t *m = r.reply.decoded; char *tmp = camqp_bytes_cstring (&m->reply_text); ssnprintf (buffer, buffer_size, "Server channel error %d: %s", m->reply_code, tmp); sfree (tmp); } else { ssnprintf (buffer, buffer_size, "Server error method %#"PRIx32, r.reply.id); } break; default: ssnprintf (buffer, buffer_size, "Unknown reply type %i", (int) r.reply_type); } return (buffer); } /* }}} char *camqp_strerror */
static int dpdk_event_keep_alive_shm_open(void) { dpdk_events_ctx_t *ec = DPDK_EVENTS_CTX_GET(g_hc); char *shm_name; if (strlen(ec->config.keep_alive.shm_name)) { shm_name = ec->config.keep_alive.shm_name; } else { shm_name = RTE_KEEPALIVE_SHM_NAME; WARNING(DPDK_EVENTS_PLUGIN ": Keep alive shared memory identifier is not " "specified, using default one: %s", shm_name); } char errbuf[ERR_BUF_SIZE]; int fd = shm_open(shm_name, O_RDONLY, 0); if (fd < 0) { ERROR(DPDK_EVENTS_PLUGIN ": Failed to open %s as SHM:%s. Is DPDK KA " "primary application running?", shm_name, sstrerror(errno, errbuf, sizeof(errbuf))); return errno; } if (ec->config.keep_alive.fd != -1) { struct stat stat_old, stat_new; if (fstat(ec->config.keep_alive.fd, &stat_old) || fstat(fd, &stat_new)) { ERROR(DPDK_EVENTS_PLUGIN ": failed to get information about a file"); close(fd); return -1; } /* Check if inode number has changed. If yes, then create a new mapping */ if (stat_old.st_ino == stat_new.st_ino) { close(fd); return 0; } if (munmap(ec->config.keep_alive.shm, sizeof(dpdk_keepalive_shm_t)) != 0) { ERROR(DPDK_EVENTS_PLUGIN ": munmap KA monitor failed"); close(fd); return -1; } close(ec->config.keep_alive.fd); ec->config.keep_alive.fd = -1; } ec->config.keep_alive.shm = (dpdk_keepalive_shm_t *)mmap( 0, sizeof(*(ec->config.keep_alive.shm)), PROT_READ, MAP_SHARED, fd, 0); if (ec->config.keep_alive.shm == MAP_FAILED) { ERROR(DPDK_EVENTS_PLUGIN ": Failed to mmap KA SHM:%s", sstrerror(errno, errbuf, sizeof(errbuf))); close(fd); return errno; } ec->config.keep_alive.fd = fd; return 0; }
/* * Open a TCP connection to the UPS network server * Returns -1 on error * Returns socket file descriptor otherwise */ static int net_open (char const *node, char const *service) { int sd; int status; struct addrinfo *ai_return; struct addrinfo *ai_list; /* TODO: Change this to `AF_UNSPEC' if apcupsd can handle IPv6 */ struct addrinfo ai_hints = { .ai_family = AF_INET, .ai_socktype = SOCK_STREAM }; status = getaddrinfo (node, service, &ai_hints, &ai_return); if (status != 0) { char errbuf[1024]; INFO ("apcups plugin: getaddrinfo failed: %s", (status == EAI_SYSTEM) ? sstrerror (errno, errbuf, sizeof (errbuf)) : gai_strerror (status)); return (-1); } /* Create socket */ sd = -1; for (ai_list = ai_return; ai_list != NULL; ai_list = ai_list->ai_next) { sd = socket (ai_list->ai_family, ai_list->ai_socktype, ai_list->ai_protocol); if (sd >= 0) break; } /* `ai_list' still holds the current description of the socket.. */ if (sd < 0) { DEBUG ("apcups plugin: Unable to open a socket"); freeaddrinfo (ai_return); return (-1); } status = connect (sd, ai_list->ai_addr, ai_list->ai_addrlen); freeaddrinfo (ai_return); if (status != 0) /* `connect(2)' failed */ { char errbuf[1024]; INFO ("apcups plugin: connect failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); close (sd); return (-1); } DEBUG ("apcups plugin: Done opening a socket %i", sd); return (sd); } /* int net_open */
static int zookeeper_connect (void) { int sk = -1; int status; struct addrinfo *ai; struct addrinfo *ai_list; const char *host; const char *port; host = (zk_host != NULL) ? zk_host : ZOOKEEPER_DEF_HOST; port = (zk_port != NULL) ? zk_port : ZOOKEEPER_DEF_PORT; struct addrinfo ai_hints = { .ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM }; status = getaddrinfo (host, port, &ai_hints, &ai_list); if (status != 0) { char errbuf[1024]; INFO ("getaddrinfo failed: %s", (status == EAI_SYSTEM) ? sstrerror (errno, errbuf, sizeof (errbuf)) : gai_strerror (status)); return (-1); } for (ai = ai_list; ai != NULL; ai = ai->ai_next) { sk = socket (ai->ai_family, SOCK_STREAM, 0); if (sk < 0) { char errbuf[1024]; WARNING ("zookeeper: socket(2) failed: %s", sstrerror (errno, errbuf, sizeof(errbuf))); continue; } status = (int) connect (sk, ai->ai_addr, ai->ai_addrlen); if (status != 0) { char errbuf[1024]; close (sk); sk = -1; WARNING ("zookeeper: connect(2) failed: %s", sstrerror (errno, errbuf, sizeof(errbuf))); continue; } /* connected */ break; } freeaddrinfo(ai_list); return (sk); } /* int zookeeper_connect */
static int memcached_connect_inet (memcached_t *st) { struct addrinfo *ai_list; int status; int fd = -1; struct addrinfo ai_hints = { .ai_family = AF_UNSPEC, .ai_flags = AI_ADDRCONFIG, .ai_socktype = SOCK_STREAM }; status = getaddrinfo (st->connhost, st->connport, &ai_hints, &ai_list); if (status != 0) { char errbuf[1024]; ERROR ("memcached plugin: memcached_connect_inet: " "getaddrinfo(%s,%s) failed: %s", st->connhost, st->connport, (status == EAI_SYSTEM) ? sstrerror (errno, errbuf, sizeof (errbuf)) : gai_strerror (status)); return (-1); } for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) { /* create our socket descriptor */ fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol); if (fd < 0) { char errbuf[1024]; WARNING ("memcached plugin: memcached_connect_inet: " "socket(2) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); continue; } /* connect to the memcached daemon */ status = (int) connect (fd, ai_ptr->ai_addr, ai_ptr->ai_addrlen); if (status != 0) { shutdown (fd, SHUT_RDWR); close (fd); fd = -1; continue; } /* A socket could be opened and connecting succeeded. We're done. */ break; } freeaddrinfo (ai_list); return (fd); } /* int memcached_connect_inet */
static int nagios_print(char const *buffer) /* {{{ */ { char const *file = NAGIOS_COMMAND_FILE; int fd; int status; struct flock lock = {0}; if (nagios_command_file != NULL) file = nagios_command_file; fd = open(file, O_WRONLY | O_APPEND); if (fd < 0) { char errbuf[1024]; status = errno; ERROR("notify_nagios plugin: Opening \"%s\" failed: %s", file, sstrerror(status, errbuf, sizeof(errbuf))); return status; } lock.l_type = F_WRLCK; lock.l_whence = SEEK_END; status = fcntl(fd, F_GETLK, &lock); if (status != 0) { char errbuf[1024]; status = errno; ERROR("notify_nagios plugin: Failed to acquire write lock on \"%s\": %s", file, sstrerror(status, errbuf, sizeof(errbuf))); close(fd); return status; } status = (int)lseek(fd, 0, SEEK_END); if (status == -1) { char errbuf[1024]; status = errno; ERROR("notify_nagios plugin: Seeking to end of \"%s\" failed: %s", file, sstrerror(status, errbuf, sizeof(errbuf))); close(fd); return status; } status = (int)swrite(fd, buffer, strlen(buffer)); if (status != 0) { char errbuf[1024]; status = errno; ERROR("notify_nagios plugin: Writing to \"%s\" failed: %s", file, sstrerror(status, errbuf, sizeof(errbuf))); close(fd); return status; } close(fd); return status; } /* }}} int nagios_print */
static int pf_read (void) { struct pf_status state; int fd; int status; int i; fd = open (pf_device, O_RDONLY); if (fd < 0) { char errbuf[1024]; ERROR("pf plugin: Unable to open %s: %s", pf_device, sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } memset (&state, 0, sizeof (state)); status = ioctl (fd, DIOCGETSTATUS, &state); if (status != 0) { char errbuf[1024]; ERROR("pf plugin: ioctl(DIOCGETSTATUS) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); close(fd); return (-1); } close (fd); fd = -1; if (!state.running) { WARNING ("pf plugin: PF is not running."); return (-1); } for (i = 0; i < PFRES_MAX; i++) pf_submit ("pf_counters", pf_reasons[i], state.counters[i], /* is gauge = */ 0); for (i = 0; i < LCNT_MAX; i++) pf_submit ("pf_limits", pf_lcounters[i], state.lcounters[i], /* is gauge = */ 0); for (i = 0; i < FCNT_MAX; i++) pf_submit ("pf_state", pf_fcounters[i], state.fcounters[i], /* is gauge = */ 0); for (i = 0; i < SCNT_MAX; i++) pf_submit ("pf_source", pf_scounters[i], state.scounters[i], /* is gauge = */ 0); pf_submit ("pf_states", "current", (uint32_t) state.states, /* is gauge = */ 1); return (0); } /* int pf_read */
static int zookeeper_query (char *buffer, size_t buffer_size) { int sk = -1; int status; size_t buffer_fill; sk = zookeeper_connect(); if (sk < 0) { ERROR ("zookeeper: Could not connect to daemon"); return (-1); } status = (int) swrite (sk, "mntr\r\n", strlen("mntr\r\n")); if (status != 0) { char errbuf[1024]; ERROR ("zookeeper: write(2) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); close (sk); return (-1); } memset (buffer, 0, buffer_size); buffer_fill = 0; while ((status = (int) recv (sk, buffer + buffer_fill, buffer_size - buffer_fill, /* flags = */ 0)) != 0) { if (status < 0) { char errbuf[1024]; if ((errno == EAGAIN) || (errno == EINTR)) continue; ERROR ("zookeeper: Error reading from socket: %s", sstrerror (errno, errbuf, sizeof (errbuf))); close (sk); return (-1); } buffer_fill += (size_t) status; } /* while (recv) */ status = 0; if (buffer_fill == 0) { WARNING ("zookeeper: No data returned by MNTR command."); status = -1; } close(sk); return (status); } /* int zookeeper_query */
static int fhcount_read(void) { int numfields = 0; int buffer_len = 60; gauge_t used, unused, max; int prc_used, prc_unused; char *fields[3]; char buffer[buffer_len]; char errbuf[1024]; FILE *fp; // Open file fp = fopen("/proc/sys/fs/file-nr" , "r"); if (fp == NULL) { ERROR("fhcount: fopen: %s", sstrerror(errno, errbuf, sizeof(errbuf))); return(EXIT_FAILURE); } if (fgets(buffer, buffer_len, fp) == NULL) { ERROR("fhcount: fgets: %s", sstrerror(errno, errbuf, sizeof(errbuf))); return(EXIT_FAILURE); } fclose(fp); // Tokenize string numfields = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields)); if (numfields != 3) { ERROR("fhcount: Line doesn't contain 3 fields"); return(EXIT_FAILURE); } // Define the values strtogauge(fields[0], &used); strtogauge(fields[1], &unused); strtogauge(fields[2], &max); prc_used = (gauge_t) used/max*100; prc_unused = (gauge_t) unused/max*100; // Submit values if (values_absolute) { fhcount_submit("file_handles", "used", (gauge_t) used); fhcount_submit("file_handles", "unused", (gauge_t) unused); fhcount_submit("file_handles", "max", (gauge_t) max); } if (values_percentage) { fhcount_submit("percent", "used", (gauge_t) prc_used); fhcount_submit("percent", "unused", (gauge_t) prc_unused); } return(0); }
/* Reads a file which contains only a number (and optionally a trailing * newline) and parses that number. */ static int sysfs_file_to_buffer(char const *dir, /* {{{ */ char const *power_supply, char const *basename, char *buffer, size_t buffer_size) { int status; FILE *fp; char filename[PATH_MAX]; ssnprintf (filename, sizeof (filename), "%s/%s/%s", dir, power_supply, basename); /* No file isn't the end of the world -- not every system will be * reporting the same set of statistics */ if (access (filename, R_OK) != 0) return ENOENT; fp = fopen (filename, "r"); if (fp == NULL) { status = errno; if (status != ENOENT) { char errbuf[1024]; WARNING ("battery plugin: fopen (%s) failed: %s", filename, sstrerror (status, errbuf, sizeof (errbuf))); } return status; } if (fgets (buffer, buffer_size, fp) == NULL) { status = errno; if (status != ENODEV) { char errbuf[1024]; WARNING ("battery plugin: fgets (%s) failed: %s", filename, sstrerror (status, errbuf, sizeof (errbuf))); } fclose (fp); return status; } strstripnewline (buffer); fclose (fp); return 0; } /* }}} int sysfs_file_to_buffer */
static int setup_socket (const char *path) { struct sockaddr_un sa; int status; unlink(path); int sock_fd = socket(PF_UNIX, SOCK_STREAM, 0); if (sock_fd < 0) { char errbuf[1024]; ERROR ("aggregator plugin: socket failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } memset (&sa, '\0', sizeof (sa)); sa.sun_family = AF_UNIX; sstrncpy (sa.sun_path, (path != NULL) ? path : DEFAULT_SOCK_FILE, sizeof (sa.sun_path)); /* unlink (sa.sun_path); */ DEBUG ("aggregator plugin: socket path = %s", sa.sun_path); status = bind (sock_fd, (struct sockaddr *) &sa, sizeof (sa)); if (status != 0) { char errbuf[1024]; sstrerror (errno, errbuf, sizeof (errbuf)); ERROR ("aggregator plugin: bind failed: %s", errbuf); close (sock_fd); sock_fd = -1; return (-1); } chmod (sa.sun_path, sock_perms); status = listen (sock_fd, 8); if (status != 0) { char errbuf[1024]; ERROR ("aggregator plugin: listen failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); close (sock_fd); sock_fd = -1; return (-1); } return sock_fd; }
static int wg_send_buffer (struct wg_callback *cb) { ssize_t status = 0; status = swrite (cb->sock_fd, cb->send_buf, strlen (cb->send_buf)); if (status < 0) { const char *protocol = cb->protocol ? cb->protocol : WG_DEFAULT_PROTOCOL; if (cb->log_send_errors) { char errbuf[1024]; ERROR ("write_graphite plugin: send to %s:%s (%s) failed with status %zi (%s)", cb->node, cb->service, protocol, status, sstrerror (errno, errbuf, sizeof (errbuf))); } close (cb->sock_fd); cb->sock_fd = -1; return (-1); } return (0); }
static int tbl_config_append_array_i (char *name, int **var, size_t *len, oconfig_item_t *ci) { int *tmp; size_t i; if (1 > ci->values_num) { log_err ("\"%s\" expects at least one argument.", name); return 1; } for (i = 0; i < ci->values_num; ++i) { if (OCONFIG_TYPE_NUMBER != ci->values[i].type) { log_err ("\"%s\" expects numerical arguments only.", name); return 1; } } *len += ci->values_num; tmp = (int *)realloc (*var, *len * sizeof (**var)); if (NULL == tmp) { char errbuf[1024]; log_err ("realloc failed: %s.", sstrerror (errno, errbuf, sizeof (errbuf))); return -1; } *var = tmp; for (i = *len - ci->values_num; i < *len; ++i) (*var)[i] = (int)ci->values[i].value.number; return 0; } /* tbl_config_append_array_s */
int read_types_list (const char *file) { FILE *fh; if (file == NULL) return (-1); fh = fopen (file, "r"); if (fh == NULL) { char errbuf[1024]; ERROR ("open (%s) failed: %s", file, sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } parse_file (fh); fclose (fh); fh = NULL; DEBUG ("Done parsing `%s'", file); return (0); } /* int read_types_list */
static int csv_create_file (const char *filename, const data_set_t *ds) { FILE *csv; int i; if (check_create_dir (filename)) return (-1); csv = fopen (filename, "w"); if (csv == NULL) { char errbuf[1024]; ERROR ("csv plugin: fopen (%s) failed: %s", filename, sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } fprintf (csv, "epoch"); for (i = 0; i < ds->ds_num; i++) fprintf (csv, ",%s", ds->ds[i].name); fprintf (csv, "\n"); fclose (csv); return 0; } /* int csv_create_file */
static void *mc_receive_thread (void *arg) /* {{{ */ { socket_entry_t *mc_receive_socket_entries; int status; size_t i; mc_receive_socket_entries = NULL; status = create_sockets (&mc_receive_socket_entries, &mc_receive_sockets_num, (mc_receive_group != NULL) ? mc_receive_group : MC_RECEIVE_GROUP_DEFAULT, (mc_receive_port != NULL) ? mc_receive_port : MC_RECEIVE_PORT_DEFAULT, /* listen = */ 1); if (status != 0) { ERROR ("gmond plugin: create_sockets failed."); return ((void *) -1); } mc_receive_sockets = (struct pollfd *) calloc (mc_receive_sockets_num, sizeof (*mc_receive_sockets)); if (mc_receive_sockets == NULL) { ERROR ("gmond plugin: calloc failed."); for (i = 0; i < mc_receive_sockets_num; i++) close (mc_receive_socket_entries[i].fd); free (mc_receive_socket_entries); mc_receive_socket_entries = NULL; mc_receive_sockets_num = 0; return ((void *) -1); } for (i = 0; i < mc_receive_sockets_num; i++) { mc_receive_sockets[i].fd = mc_receive_socket_entries[i].fd; mc_receive_sockets[i].events = POLLIN | POLLPRI; mc_receive_sockets[i].revents = 0; } while (mc_receive_thread_loop != 0) { status = poll (mc_receive_sockets, mc_receive_sockets_num, -1); if (status <= 0) { char errbuf[1024]; if (errno == EINTR) continue; ERROR ("gmond plugin: poll failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); break; } for (i = 0; i < mc_receive_sockets_num; i++) { if (mc_receive_sockets[i].revents != 0) mc_handle_socket (mc_receive_sockets + i); } } /* while (mc_receive_thread_loop != 0) */ free (mc_receive_socket_entries); return ((void *) 0); } /* }}} void *mc_receive_thread */
static int irq_read (void) { FILE *fh; char buffer[1024]; fh = fopen ("/proc/interrupts", "r"); if (fh == NULL) { char errbuf[1024]; ERROR ("irq plugin: fopen (/proc/interrupts): %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } while (fgets (buffer, BUFSIZE, fh) != NULL) { char irq_name[64]; int irq_name_len; derive_t irq_value; char *endptr; int i; char *fields[64]; int fields_num; fields_num = strsplit (buffer, fields, 64); if (fields_num < 2) continue; errno = 0; /* To distinguish success/failure after call */ irq_name_len = ssnprintf (irq_name, sizeof (irq_name), "%s", fields[0]); endptr = &irq_name[irq_name_len-1]; if ((endptr == fields[0]) || (errno != 0) || (*endptr != ':')) continue; /* remove : */ *endptr = 0; irq_value = 0; for (i = 1; i < fields_num; i++) { /* Per-CPU value */ value_t v; int status; status = irq_parse_value (fields[i], &v); if (status != 0) break; irq_value += v.derive; } /* for (i) */ irq_submit (irq_name, irq_value); } fclose (fh); return (0); } /* int irq_read */
size_t cdtime_to_iso8601 (char *s, size_t max, cdtime_t t) /* {{{ */ { struct timespec t_spec; struct tm t_tm; size_t len; CDTIME_T_TO_TIMESPEC (t, &t_spec); NORMALIZE_TIMESPEC (t_spec); if (localtime_r ((time_t *)&t_spec.tv_sec, &t_tm) == NULL) { char errbuf[1024]; ERROR ("cdtime_to_iso8601: localtime_r failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (0); } len = strftime (s, max, "%Y-%m-%dT%H:%M:%S", &t_tm); if (len == 0) return 0; if (max - len > 2) { int n = snprintf (s + len, max - len, ".%09i", (int)t_spec.tv_nsec); len += (n < max - len) ? n : max - len; } if (max - len > 3) { int n = strftime (s + len, max - len, "%z", &t_tm); len += (n < max - len) ? n : max - len; } s[max - 1] = '\0'; return len; } /* }}} size_t cdtime_to_iso8601 */
static struct ip_vs_get_dests *ipvs_get_dests (struct ip_vs_service_entry *se) { struct ip_vs_get_dests *ret; socklen_t len; len = sizeof (*ret) + sizeof (struct ip_vs_dest_entry) * se->num_dests; if (NULL == (ret = malloc (len))) { log_err ("ipvs_get_dests: Out of memory."); exit (3); } ret->fwmark = se->fwmark; ret->protocol = se->protocol; ret->addr = se->addr; ret->port = se->port; ret->num_dests = se->num_dests; if (0 != getsockopt (sockfd, IPPROTO_IP, IP_VS_SO_GET_DESTS, (void *)ret, &len)) { char errbuf[1024]; log_err ("ipvs_get_dests: getsockopt() failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); free (ret); return NULL; } return ret; } /* ip_vs_get_dests */
static int camqp_subscribe_init (camqp_config_t *conf) /* {{{ */ { int status; pthread_t *tmp; tmp = realloc (subscriber_threads, sizeof (*subscriber_threads) * (subscriber_threads_num + 1)); if (tmp == NULL) { ERROR ("amqp plugin: realloc failed."); camqp_config_free (conf); return (ENOMEM); } subscriber_threads = tmp; tmp = subscriber_threads + subscriber_threads_num; memset (tmp, 0, sizeof (*tmp)); status = pthread_create (tmp, /* attr = */ NULL, camqp_subscribe_thread, conf); if (status != 0) { char errbuf[1024]; ERROR ("amqp plugin: pthread_create failed: %s", sstrerror (status, errbuf, sizeof (errbuf))); camqp_config_free (conf); return (status); } subscriber_threads_num++; return (0); } /* }}} int camqp_subscribe_init */
static void statsd_network_read (statsd_config_t *conf, int fd) /* {{{ */ { char buffer[4096] = {0}; size_t buffer_size; ssize_t status; status = recv (fd, buffer, sizeof (buffer), /* flags = */ MSG_DONTWAIT); if (status < 0) { char errbuf[1024]; if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) return; ERROR ("statsd plugin: recv(2) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return; } buffer_size = (size_t) status; if (buffer_size >= sizeof (buffer)) buffer_size = sizeof (buffer) - 1; buffer[buffer_size] = 0; pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); statsd_parse_buffer (conf, buffer); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); } /* }}} void statsd_network_read */
static int memcached_connect_unix (memcached_t *st) { struct sockaddr_un serv_addr; int fd; memset (&serv_addr, 0, sizeof (serv_addr)); serv_addr.sun_family = AF_UNIX; sstrncpy (serv_addr.sun_path, st->socket, sizeof (serv_addr.sun_path)); /* create our socket descriptor */ fd = socket (AF_UNIX, SOCK_STREAM, 0); if (fd < 0) { char errbuf[1024]; ERROR ("memcached plugin: memcached_connect_unix: socket(2) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } /* connect to the memcached daemon */ int status = connect (fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)); if (status != 0) { shutdown (fd, SHUT_RDWR); close (fd); fd = -1; } return (fd); } /* int memcached_connect_unix */
static int numa_init (void) /* {{{ */ { /* Determine the number of nodes on this machine. */ while (42) { char path[PATH_MAX]; struct stat statbuf = { 0 }; int status; ssnprintf (path, sizeof (path), NUMA_ROOT_DIR "/node%i", max_node + 1); status = stat (path, &statbuf); if (status == 0) { max_node++; continue; } else if (errno == ENOENT) { break; } else /* ((status != 0) && (errno != ENOENT)) */ { char errbuf[1024]; ERROR ("numa plugin: stat(%s) failed: %s", path, sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } } DEBUG ("numa plugin: Found %i nodes.", max_node + 1); return (0); } /* }}} int numa_init */
static int statsd_init (void) /* {{{ */ { pthread_mutex_lock (&metrics_lock); if (metrics_tree == NULL) metrics_tree = c_avl_create ((void *) strcmp); if (!network_thread_running) { int status; status = pthread_create (&network_thread, /* attr = */ NULL, statsd_network_thread, /* args = */ NULL); if (status != 0) { char errbuf[1024]; pthread_mutex_unlock (&metrics_lock); ERROR ("statsd plugin: pthread_create failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (status); } } network_thread_running = 1; pthread_mutex_unlock (&metrics_lock); return (0); } /* }}} int statsd_init */
static void statsd_network_read (int fd) /* {{{ */ { char buffer[4096]; size_t buffer_size; ssize_t status; status = recv (fd, buffer, sizeof (buffer), /* flags = */ MSG_DONTWAIT); if (status < 0) { char errbuf[1024]; if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) return; ERROR ("statsd plugin: recv(2) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return; } buffer_size = (size_t) status; if (buffer_size >= sizeof (buffer)) buffer_size = sizeof (buffer) - 1; buffer[buffer_size] = 0; statsd_parse_buffer (buffer); } /* }}} void statsd_network_read */
static int riemann_send(struct riemann_host *host, Msg const *msg) { u_char *buffer; size_t buffer_len; int status; pthread_mutex_lock (&host->lock); status = riemann_connect (host); if (status != 0) { pthread_mutex_unlock (&host->lock); return status; } buffer_len = msg__get_packed_size(msg); if (host->use_tcp) buffer_len += 4; buffer = malloc (buffer_len); if (buffer == NULL) { pthread_mutex_unlock (&host->lock); ERROR ("write_riemann plugin: malloc failed."); return ENOMEM; } memset (buffer, 0, buffer_len); if (host->use_tcp) { uint32_t length = htonl ((uint32_t) (buffer_len - 4)); memcpy (buffer, &length, 4); msg__pack(msg, buffer + 4); } else { msg__pack(msg, buffer); } status = (int) swrite (host->s, buffer, buffer_len); if (status != 0) { char errbuf[1024]; riemann_disconnect (host); pthread_mutex_unlock (&host->lock); ERROR ("write_riemann plugin: Sending to Riemann at %s:%s failed: %s", (host->node != NULL) ? host->node : RIEMANN_HOST, (host->service != NULL) ? host->service : RIEMANN_PORT, sstrerror (errno, errbuf, sizeof (errbuf))); sfree (buffer); return -1; } pthread_mutex_unlock (&host->lock); sfree (buffer); return 0; }
static int request_meta_data (const char *host, const char *name) /* {{{ */ { Ganglia_metadata_msg msg; char buffer[BUFF_SIZE]; unsigned int buffer_size; XDR xdr; size_t i; memset (&msg, 0, sizeof (msg)); msg.id = gmetadata_request; msg.Ganglia_metadata_msg_u.grequest.metric_id.host = strdup (host); msg.Ganglia_metadata_msg_u.grequest.metric_id.name = strdup (name); if ((msg.Ganglia_metadata_msg_u.grequest.metric_id.host == NULL) || (msg.Ganglia_metadata_msg_u.grequest.metric_id.name == NULL)) { sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host); sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name); return (-1); } memset (buffer, 0, sizeof (buffer)); xdrmem_create (&xdr, buffer, sizeof (buffer), XDR_ENCODE); if (!xdr_Ganglia_metadata_msg (&xdr, &msg)) { sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host); sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name); return (-1); } buffer_size = xdr_getpos (&xdr); DEBUG ("gmond plugin: Requesting meta data for %s/%s.", host, name); pthread_mutex_lock (&mc_send_sockets_lock); for (i = 0; i < mc_send_sockets_num; i++) { ssize_t status = sendto (mc_send_sockets[i].fd, buffer, (size_t) buffer_size, /* flags = */ 0, (struct sockaddr *) &mc_send_sockets[i].addr, mc_send_sockets[i].addrlen); if (status == -1) { char errbuf[1024]; ERROR ("gmond plugin: sendto(2) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); continue; } } pthread_mutex_unlock (&mc_send_sockets_lock); sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host); sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name); return (0); } /* }}} int request_meta_data */
static void *statsd_network_thread (void *args) /* {{{ */ { statsd_config_t *conf = args; fds_poll_t fds; int status; size_t i; memset(&fds, 0, sizeof(fds_poll_t)); pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); status = statsd_network_init (conf, &fds); if (status != 0) { ERROR ("statsd plugin: Unable to open listening sockets."); pthread_exit ((void *) 0); } pthread_cleanup_push(statsd_network_release, &fds); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); while (1) { status = poll (fds.fds, (nfds_t) fds.fds_num, /* timeout = */ -1); if (status < 0) { char errbuf[1024] = {0}; if (EAGAIN == errno) continue; if (EINTR == errno) { DEBUG("statsd plugin: poll(2) has been interrupted"); break; } ERROR ("statsd plugin: poll(2) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); break; } DEBUG("statsd plugin: ohh some moving in the sockets"); for (i = 0; i < fds.fds_num; i++) { if ((fds.fds[i].revents & (POLLIN | POLLPRI)) == 0) continue; statsd_network_read(conf, fds.fds[i].fd); fds.fds[i].revents = 0; } pthread_testcancel(); } /* wait for pthread_cancel */ pthread_cleanup_pop(1); return ((void *) 0); } /* }}} void *statsd_network_thread */
static int swap_read_separate (void) /* {{{ */ { FILE *fh; char buffer[1024]; fh = fopen ("/proc/swaps", "r"); if (fh == NULL) { char errbuf[1024]; WARNING ("swap plugin: fopen (/proc/swaps) failed: %s", sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } while (fgets (buffer, sizeof (buffer), fh) != NULL) { char *fields[8]; int numfields; char *endptr; char path[PATH_MAX]; gauge_t size; gauge_t used; gauge_t free; numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields)); if (numfields != 5) continue; sstrncpy (path, fields[0], sizeof (path)); escape_slashes (path, sizeof (path)); errno = 0; endptr = NULL; size = strtod (fields[2], &endptr); if ((endptr == fields[2]) || (errno != 0)) continue; errno = 0; endptr = NULL; used = strtod (fields[3], &endptr); if ((endptr == fields[3]) || (errno != 0)) continue; if (size < used) continue; free = size - used; swap_submit_gauge (path, "used", used); swap_submit_gauge (path, "free", free); } fclose (fh); return (0); } /* }}} int swap_read_separate */