自学教程：C++ sstrerror函数代码示例

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 intriemann_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 */