/* Copyright (C) 1998-99 Martin Baulig

   Copyright (C) 2004 Nicol\ufffds Lichtmaier

   Copyright (C) 2007 Joe Marcus Clarke

   Copyright (C) 2013 Robert Nagy

   This file is part of LibGTop 1.0.

   Modified by Nicol\ufffds Lichtmaier to give a process open files.

   Contributed by Martin Baulig <martin@home-of-linux.org>, April 1998.

   LibGTop is free software; you can redistribute it and/or modify it

   under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2 of the License,

   or (at your option) any later version.

   LibGTop is distributed in the hope that it will be useful, but WITHOUT

   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

   for more details.

   You should have received a copy of the GNU General Public License

   along with LibGTop; see the file COPYING. If not, write to the

   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

   Boston, MA 02110-1301, USA.

*/

#include <config.h>

#include <glibtop.h>

#include <glibtop/error.h>

#include <glibtop/procopenfiles.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/param.h>

#include <sys/sysctl.h>

#define _KERNEL

#include <sys/file.h>

#undef _KERNEL

#include <sys/mount.h>

#include <sys/un.h>

#include <sys/vnode.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <string.h>

#include <stdlib.h>

#include <kvm.h>

#include "glibtop_private.h"

static const unsigned long _glibtop_sysdeps_proc_open_files =

(1L << GLIBTOP_PROC_OPEN_FILES_NUMBER)|

(1L << GLIBTOP_PROC_OPEN_FILES_TOTAL)|

(1L << GLIBTOP_PROC_OPEN_FILES_SIZE);

kvm_t *kd;

struct filearg {

	SLIST_ENTRY(filearg) next;

	dev_t dev;

	ino_t ino;

	char *name;

	TAILQ_HEAD(fuserhead, fuser) fusers;

};

SLIST_HEAD(fileargs, filearg);

struct fileargs fileargs = SLIST_HEAD_INITIALIZER(fileargs);

/* Init function. */

void

_glibtop_init_proc_open_files_s (glibtop *server)

{

	server->sysdeps.proc_open_files = _glibtop_sysdeps_proc_open_files;

}

static char *

addr_to_string(struct kinfo_file *kf)

{

	char *buffer = NULL;

	struct in_addr faddr;

	memcpy(&faddr, kf->inp_faddru, sizeof(faddr));

	if ((kf->so_protocol == IPPROTO_TCP) ||

	    (kf->so_protocol == IPPROTO_UDP)) {

		if (kf->inp_fport) {

			buffer = g_strdup(faddr.s_addr == INADDR_ANY ? "*" :

 			    inet_ntoa(faddr));

		}

	}

	return buffer;

}

glibtop_open_files_entry *

glibtop_get_proc_open_files_s (glibtop *server, glibtop_proc_open_files *buf,	pid_t pid)

{

	struct kinfo_file *kf, *kflast;

	int cnt;

	char kbuf[_POSIX2_LINE_MAX];

	GArray *entries;

	memset(buf, 0, sizeof (glibtop_proc_open_files));

	if ((kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, kbuf)) == NULL)

		g_warning("%s", kbuf);

	if ((kf = kvm_getfiles(kd, KERN_FILE_BYPID, pid, sizeof(*kf), &cnt)) == NULL)

		g_warning("%s", kvm_geterr(kd));

	entries = g_array_new(FALSE, FALSE, sizeof(glibtop_open_files_entry));

	for (kflast = &kf[cnt]; kf < kflast; ++kf) {

		glibtop_open_files_entry entry = {0};

		if (kf->fd_fd < 0)

			continue;

		if (kf->f_type == DTYPE_SOCKET) {

			if (kf->so_family == AF_LOCAL) {

				entry.type = GLIBTOP_FILE_TYPE_LOCALSOCKET;

				static char *stypename[] = {

					"unused",	/* 0 */

					"stream",

					"dgram",

					"raw",

					"rdm",

					"seqpak"

				};

#define STYPEMAX 5

				char *stype, stypebuf[24];

				if (kf->so_type > STYPEMAX) {

					snprintf(stypebuf, sizeof(stypebuf), "?%d", kf->so_type);

					stype = stypebuf;

				} else {

					stype = stypename[kf->so_type];

				}

				g_strlcpy(entry.info.localsock.name, stype,

				    sizeof(entry.info.localsock.name));

			} else if (kf->so_family == AF_INET ||

				   kf->so_family == AF_INET6) {

				char *addrstr;

				if (kf->so_family == AF_INET)

					entry.type = GLIBTOP_FILE_TYPE_INETSOCKET;

				else

					entry.type = GLIBTOP_FILE_TYPE_INET6SOCKET;

				addrstr = addr_to_string(kf);

				g_strlcpy(entry.info.sock.dest_host,

					  addrstr,

					  sizeof(entry.info.sock.dest_host));

				g_free(addrstr);

				entry.info.sock.dest_port = kf->inp_fport ? ntohs(kf->inp_fport) : 0;

			}

		} else if (kf->f_type == DTYPE_PIPE) {

			entry.type = GLIBTOP_FILE_TYPE_PIPE;

		} else if (kf->f_type == DTYPE_VNODE) {

			int badtype = 0;

			char nbuf[MAXPATHLEN];

			entry.type = GLIBTOP_FILE_TYPE_FILE;

			if ((kf->v_type == VNON) ||

			    (kf->v_type == VBAD) ||

			    (kf->v_tag == VT_NON && !(kf->v_flag & VCLONE))) {

				badtype = 1;

			}

			if (badtype)

				continue;

			if ((kf->v_type == VBLK) ||

			    (kf->v_type == VCHR)) {

				snprintf(nbuf, sizeof(nbuf), "/dev/%s",

				    devname(kf->va_rdev, kf->v_type == VCHR ?  S_IFCHR : S_IFBLK));

			} else {

				snprintf(nbuf, sizeof(nbuf), "inode %llu on %s", kf->va_fileid,

				    kf->f_mntonname);

			}

			g_strlcpy(entry.info.file.name, nbuf,

			    sizeof(entry.info.file.name));

		} else

			continue;

		entry.fd = kf->fd_fd;

		g_array_append_val(entries, entry);

	}

	buf->flags = _glibtop_sysdeps_proc_open_files;

	buf->number = entries->len;

	buf->size = sizeof(glibtop_open_files_entry);

	buf->total = buf->number * buf->size;

	return (glibtop_open_files_entry*)g_array_free(entries, FALSE);

}