#undef HAVE_SYSCTLBYNAME /* force HAVE_LIBKVM_NLIST path */
#endif
-#if !KERNEL_LINUX && !HAVE_SYSCTLBYNAME && !HAVE_LIBKVM_NLIST
+#if !KERNEL_LINUX && !HAVE_SYSCTLBYNAME && !HAVE_LIBKVM_NLIST && !KERNEL_AIX
# error "No applicable input method."
#endif
#if KERNEL_LINUX
+# include <asm/types.h>
+/* sys/socket.h is necessary to compile when using netlink on older systems. */
+# include <sys/socket.h>
+# include <linux/netlink.h>
+# include <linux/inet_diag.h>
+# include <sys/socket.h>
+# include <arpa/inet.h>
/* #endif KERNEL_LINUX */
#elif HAVE_SYSCTLBYNAME
# include <netinet/tcp_var.h>
# include <netdb.h>
# include <arpa/inet.h>
-# include <nlist.h>
+# if !defined(HAVE_BSD_NLIST_H) || !HAVE_BSD_NLIST_H
+# include <nlist.h>
+# else /* HAVE_BSD_NLIST_H */
+# include <bsd/nlist.h>
+# endif
# include <kvm.h>
-#endif /* HAVE_LIBKVM_NLIST */
+/* #endif HAVE_LIBKVM_NLIST */
+
+#elif KERNEL_AIX
+# include <arpa/inet.h>
+# include <sys/socketvar.h>
+#endif /* KERNEL_AIX */
#if KERNEL_LINUX
+struct nlreq {
+ struct nlmsghdr nlh;
+ struct inet_diag_req r;
+};
+
static const char *tcp_state[] =
{
"", /* 0 */
# define TCP_STATE_LISTEN 1
# define TCP_STATE_MIN 1
# define TCP_STATE_MAX 10
-#endif /* HAVE_LIBKVM_NLIST */
+/* #endif HAVE_LIBKVM_NLIST */
+
+#elif KERNEL_AIX
+static const char *tcp_state[] =
+{
+ "CLOSED",
+ "LISTEN",
+ "SYN_SENT",
+ "SYN_RCVD",
+ "ESTABLISHED",
+ "CLOSE_WAIT",
+ "FIN_WAIT_1",
+ "CLOSING",
+ "LAST_ACK",
+ "FIN_WAIT_2",
+ "TIME_WAIT"
+};
+
+# define TCP_STATE_LISTEN 1
+# define TCP_STATE_MIN 0
+# define TCP_STATE_MAX 10
+
+struct netinfo_conn {
+ uint32_t unknow1[2];
+ uint16_t dstport;
+ uint16_t unknow2;
+ struct in6_addr dstaddr;
+ uint16_t srcport;
+ uint16_t unknow3;
+ struct in6_addr srcaddr;
+ uint32_t unknow4[36];
+ uint16_t tcp_state;
+ uint16_t unknow5[7];
+};
+
+struct netinfo_header {
+ unsigned int proto;
+ unsigned int size;
+};
+
+# define NETINFO_TCP 3
+extern int netinfo (int proto, void *data, int *size, int n);
+#endif /* KERNEL_AIX */
#define PORT_COLLECT_LOCAL 0x01
#define PORT_COLLECT_REMOTE 0x02
static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
static int port_collect_listening = 0;
+static int port_collect_total = 1;
static port_entry_t *port_list_head = NULL;
+static uint32_t count_total[TCP_STATE_MAX + 1];
+
+#if KERNEL_LINUX
+static uint32_t sequence_number = 0;
+
+enum
+{
+ SRC_DUNNO,
+ SRC_NETLINK,
+ SRC_PROC
+} linux_source = SRC_DUNNO;
+#endif
+
+static void connt_prepare_vl (value_list_t *vl, value_t *values)
+{
+ vl->values = values;
+ vl->values_len = 1;
+ sstrncpy (vl->host, hostname_g, sizeof (vl->host));
+ sstrncpy (vl->plugin, "tcpconns", sizeof (vl->plugin));
+ sstrncpy (vl->type, "tcp_connections", sizeof (vl->type));
+}
static void conn_submit_port_entry (port_entry_t *pe)
{
value_list_t vl = VALUE_LIST_INIT;
int i;
- vl.values = values;
- vl.values_len = 1;
- sstrncpy (vl.host, hostname_g, sizeof (vl.host));
- sstrncpy (vl.plugin, "tcpconns", sizeof (vl.plugin));
- sstrncpy (vl.type, "tcp_connections", sizeof (vl.type));
+ connt_prepare_vl (&vl, values);
if (((port_collect_listening != 0) && (pe->flags & PORT_IS_LISTENING))
|| (pe->flags & PORT_COLLECT_LOCAL))
}
} /* void conn_submit */
+static void conn_submit_port_total (void)
+{
+ value_t values[1];
+ value_list_t vl = VALUE_LIST_INIT;
+ int i;
+
+ connt_prepare_vl (&vl, values);
+
+ sstrncpy (vl.plugin, "all", sizeof (vl.plugin));
+
+ for (i = 1; i <= TCP_STATE_MAX; i++)
+ {
+ vl.values[0].gauge = count_total[i];
+
+ sstrncpy (vl.type_instance, tcp_state[i], sizeof (vl.type_instance));
+
+ plugin_dispatch_values (&vl);
+ }
+}
+
static void conn_submit_all (void)
{
port_entry_t *pe;
+ if (port_collect_total)
+ conn_submit_port_total ();
+
for (pe = port_list_head; pe != NULL; pe = pe->next)
conn_submit_port_entry (pe);
} /* void conn_submit_all */
port_entry_t *prev = NULL;
port_entry_t *pe = port_list_head;
+ memset (&count_total, '\0', sizeof(count_total));
+
while (pe != NULL)
{
/* If this entry was created while reading the files (ant not when handling
return (-1);
}
+ count_total[state]++;
+
/* Listening sockets */
if ((state == TCP_STATE_LISTEN) && (port_collect_listening != 0))
{
} /* int conn_handle_ports */
#if KERNEL_LINUX
+/* Returns zero on success, less than zero on socket error and greater than
+ * zero on other errors. */
+static int conn_read_netlink (void)
+{
+ int fd;
+ struct sockaddr_nl nladdr;
+ struct nlreq req;
+ struct msghdr msg;
+ struct iovec iov;
+ 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);
+ }
+
+ memset(&nladdr, 0, sizeof(nladdr));
+ nladdr.nl_family = AF_NETLINK;
+
+ memset(&req, 0, sizeof(req));
+ req.nlh.nlmsg_len = sizeof(req);
+ 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 */
+ req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
+ req.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. */
+ req.nlh.nlmsg_seq = ++sequence_number;
+ req.r.idiag_family = AF_INET;
+ req.r.idiag_states = 0xfff;
+ req.r.idiag_ext = 0;
+
+ memset(&iov, 0, sizeof(iov));
+ iov.iov_base = &req;
+ iov.iov_len = sizeof(req);
+
+ memset(&msg, 0, sizeof(msg));
+ msg.msg_name = (void*)&nladdr;
+ msg.msg_namelen = sizeof(nladdr);
+ msg.msg_iov = &iov;
+ msg.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);
+} /* int conn_read_netlink */
+
static int conn_handle_line (char *buffer)
{
char *fields[32];
{
if (strcasecmp (key, "ListeningPorts") == 0)
{
- if ((strcasecmp (value, "Yes") == 0)
- || (strcasecmp (value, "True") == 0)
- || (strcasecmp (value, "On") == 0))
+ if (IS_TRUE (value))
port_collect_listening = 1;
else
port_collect_listening = 0;
static int conn_read (void)
{
- int errors_num = 0;
+ int status;
conn_reset_port_entry ();
- if (conn_read_file ("/proc/net/tcp") != 0)
- errors_num++;
- if (conn_read_file ("/proc/net/tcp6") != 0)
- errors_num++;
-
- if (errors_num < 2)
+ if (linux_source == SRC_NETLINK)
{
- conn_submit_all ();
+ status = conn_read_netlink ();
}
- else
+ else if (linux_source == SRC_PROC)
{
- ERROR ("tcpconns plugin: Neither /proc/net/tcp nor /proc/net/tcp6 "
- "coult be read.");
- return (-1);
+ 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 */
/* #endif KERNEL_LINUX */
return (0);
}
-#endif /* HAVE_LIBKVM_NLIST */
+/* #endif HAVE_LIBKVM_NLIST */
+
+#elif KERNEL_AIX
+
+static int conn_read (void)
+{
+ int size;
+ int i;
+ int nconn;
+ void *data;
+ struct netinfo_header *header;
+ struct netinfo_conn *conn;
+
+ conn_reset_port_entry ();
+
+ size = netinfo(NETINFO_TCP, 0, 0, 0);
+ if (size < 0)
+ {
+ ERROR ("tcpconns plugin: netinfo failed return: %i", size);
+ return (-1);
+ }
+
+ if (size == 0)
+ return (0);
+
+ if ((size - sizeof (struct netinfo_header)) % sizeof (struct netinfo_conn))
+ {
+ ERROR ("tcpconns plugin: invalid buffer size");
+ return (-1);
+ }
+
+ data = malloc(size);
+ if (data == NULL)
+ {
+ ERROR ("tcpconns plugin: malloc failed");
+ return (-1);
+ }
+
+ if (netinfo(NETINFO_TCP, data, &size, 0) < 0)
+ {
+ ERROR ("tcpconns plugin: netinfo failed");
+ free(data);
+ return (-1);
+ }
+
+ header = (struct netinfo_header *)data;
+ nconn = header->size;
+ conn = (struct netinfo_conn *)(data + sizeof(struct netinfo_header));
+
+ for (i=0; i < nconn; conn++, i++)
+ {
+ conn_handle_ports (conn->srcport, conn->dstport, conn->tcp_state);
+ }
+
+ free(data);
+
+ conn_submit_all ();
+
+ return (0);
+}
+#endif /* KERNEL_AIX */
void module_register (void)
{
/* no initialization */
#elif HAVE_LIBKVM_NLIST
plugin_register_init ("tcpconns", conn_init);
+#elif KERNEL_AIX
+ /* no initialization */
#endif
plugin_register_read ("tcpconns", conn_read);
} /* void module_register */
projects / collectd.git / blobdiff