path: root/libopeniscsiusr/misc.c

/*
 * Copyright (C) 2017 Red Hat, Inc.
 *
 * This program 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Gris Ge <fge@redhat.com>
 */

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <dirent.h>
#include <string.h>
#include <unistd.h>
#include <net/if.h>
#include <sys/socket.h>
#include <linux/ethtool.h>
#include <sys/ioctl.h>
#include <linux/sockios.h>
#include <net/if_arp.h>

#include "libopeniscsiusr/libopeniscsiusr.h"
#include "misc.h"
#include "context.h"

#define _UNUSED(x) (void)(x)

#define _ISCSI_LOG_STRERR_ALIGN_WIDTH	80
/* ^ Only used in _iscsi_log_stderr() for pretty log output.
 *   When provided log message is less than 80 bytes, fill it with space, then
 *   print code file name, function name, line after the 80th bytes.
 */

struct _num_str_conv {
	const uint32_t value;
	const char *str;
};

#define _iscsi_str_func_gen(func_name, var_type, var, conv_array) \
const char *func_name(var_type var) { \
	size_t i = 0; \
	uint32_t tmp_var = var & UINT32_MAX; \
	errno = 0; \
	/* In the whole libopeniscsiusr, we don't have negative value */ \
	for (; i < sizeof(conv_array)/sizeof(conv_array[0]); ++i) { \
		if ((conv_array[i].value) == tmp_var) \
			return conv_array[i].str; \
	} \
	errno = EINVAL; \
	return "Invalid argument"; \
}

static const struct _num_str_conv _ISCSI_RC_MSG_CONV[] = {
	{LIBISCSI_OK, "OK"},
	{LIBISCSI_ERR_BUG, "BUG of libopeniscsiusr library"},
	{LIBISCSI_ERR_SESS_NOT_FOUND, "Specified iSCSI session not found"},
	{LIBISCSI_ERR_ACCESS, "Permission deny"},
	{LIBISCSI_ERR_NOMEM, "Out of memory"},
	{LIBISCSI_ERR_SYSFS_LOOKUP, "Could not lookup object in sysfs"},
	{LIBISCSI_ERR_IDBM, "Error accessing/managing iSCSI DB"},
	{LIBISCSI_ERR_TRANS_NOT_FOUND,
		"iSCSI transport module not loaded in kernel or iscsid"},
	{LIBISCSI_ERR_INVAL, "Invalid argument"},
};

_iscsi_str_func_gen(iscsi_strerror, int, rc, _ISCSI_RC_MSG_CONV);

static const struct _num_str_conv _ISCSI_PRI_CONV[] = {
	{LIBISCSI_LOG_PRIORITY_DEBUG, "DEBUG"},
	{LIBISCSI_LOG_PRIORITY_INFO, "INFO"},
	{LIBISCSI_LOG_PRIORITY_WARNING, "WARNING"},
	{LIBISCSI_LOG_PRIORITY_ERROR, "ERROR"},
};

_iscsi_str_func_gen(iscsi_log_priority_str, int, priority, _ISCSI_PRI_CONV);

void _iscsi_log_stderr(struct iscsi_context *ctx, int priority,
		       const char *file, int line, const char *func_name,
		       const char *format, va_list args)
{
	int printed_bytes = 0;

	_UNUSED(ctx);

	printed_bytes += fprintf(stderr, "iSCSI %s: ",
				 iscsi_log_priority_str(priority));
	printed_bytes += vfprintf(stderr, format, args);

	if (printed_bytes < _ISCSI_LOG_STRERR_ALIGN_WIDTH) {
		fprintf(stderr, "%*s # %s:%s():%d\n",
			_ISCSI_LOG_STRERR_ALIGN_WIDTH - printed_bytes, "", file,
			func_name, line);
	} else {
		fprintf(stderr, " # %s:%s():%d\n", file, func_name, line);
	}
}

void _iscsi_log(struct iscsi_context *ctx, int priority, const char *file,
		int line, const char *func_name, const char *format, ...)
{
	va_list args;

	if (ctx->log_func == NULL)
		return;

	va_start(args, format);
	ctx->log_func(ctx, priority, file, line, func_name, format, args);
	va_end(args);
}

int _scan_filter_skip_dot(const struct dirent *dir)
{
	return strcmp(dir->d_name, ".") && strcmp(dir->d_name, "..");
}

bool _file_exists(const char *path)
{
	if (access(path, F_OK) == 0)
		return true;
	else
		return false;
}

static bool _is_eth(struct iscsi_context *ctx, const char *if_name)
{
	struct ifreq ifr;
	int sockfd = -1;
	char strerr_buff[_STRERR_BUFF_LEN];

	assert(if_name != NULL);

	memset(&ifr, 0, sizeof(ifr));

	_strncpy(ifr.ifr_name, if_name, IFNAMSIZ);

	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0) {
		_warn(ctx, "Failed to create SOCK_DGRAM AF_INET socket: %d %s",
		      errno, _strerror(errno, strerr_buff));
		return false;
	}

	if (ioctl(sockfd, SIOCGIFHWADDR, &ifr) != 0) {
		_warn(ctx, "IOCTL SIOCGIFHWADDR to %s failed: %d %s", if_name,
		      errno, _strerror(errno, strerr_buff));
		close(sockfd);
		return false;
	}

	close(sockfd);

	if (ifr.ifr_hwaddr.sa_family == ARPHRD_ETHER)
		return true;

	return false;
}

/*
 * driver_name should be char[_ETH_DRIVER_NAME_MAX_LEN]
 */
static int _eth_driver_get(struct iscsi_context *ctx, const char *if_name,
			   char *driver_name)
{
	int sockfd = -1;
	struct ethtool_drvinfo drvinfo;
	struct ifreq ifr;
	char strerr_buff[_STRERR_BUFF_LEN];

	assert(ctx != NULL);
	assert(if_name != NULL);
	assert(driver_name != NULL);

	memset(&ifr, 0, sizeof(ifr));
	memset(&drvinfo, 0, sizeof(drvinfo));

	_strncpy(ifr.ifr_name, if_name, IFNAMSIZ);
	drvinfo.cmd = ETHTOOL_GDRVINFO;
	ifr.ifr_data = (caddr_t) &drvinfo;

	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0) {
		_error(ctx, "Failed to create SOCK_DGRAM AF_INET socket: %d %s",
		       errno, _strerror(errno, strerr_buff));
		return LIBISCSI_ERR_BUG;
	}

	if (ioctl(sockfd, SIOCETHTOOL, &ifr) != 0) {
		_warn(ctx, "IOCTL SIOCETHTOOL to %s failed: %d %s", if_name,
		      errno, _strerror(errno, strerr_buff));
		close(sockfd);
		return LIBISCSI_ERR_BUG;
	}
	close(sockfd);
	snprintf(driver_name, _ETH_DRIVER_NAME_MAX_LEN, "%s", drvinfo.driver);

	return LIBISCSI_OK;
}

int _eth_ifs_get(struct iscsi_context *ctx, struct _eth_if ***eifs,
		 uint32_t *eif_count)
{
	int rc = LIBISCSI_OK;
	struct if_nameindex *if_ni = NULL;
	struct if_nameindex *if_i = NULL;
	struct _eth_if *eif = NULL;
	uint32_t tmp_count = 0;

	assert(ctx != NULL);
	assert(eifs != NULL);
	assert(eif_count != NULL);

	*eifs = NULL;
	*eif_count = 0;

	if_ni = if_nameindex();
	_alloc_null_check(ctx, if_ni, rc, out);

	for (if_i = if_ni; if_i && if_i->if_index && if_i->if_name; ++if_i)
		tmp_count++;

	if (tmp_count == 0)
		goto out;

	*eifs = calloc(tmp_count, sizeof(struct _eth_if *));
	_alloc_null_check(ctx, *eifs, rc, out);

	for (if_i = if_ni; if_i && if_i->if_index && if_i->if_name; ++if_i) {
		if (! _is_eth(ctx, if_i->if_name))
			continue;
		eif = calloc(1, sizeof(struct _eth_if));
		_alloc_null_check(ctx, eif, rc, out);
		(*eifs)[(*eif_count)++] = eif;
		snprintf(eif->if_name, sizeof(eif->if_name)/sizeof(char),
			 "%s", if_i->if_name);
		_good(_eth_driver_get(ctx, eif->if_name, eif->driver_name),
		      rc, out);
	}

out:
	if (rc != LIBISCSI_OK) {
		_eth_ifs_free(*eifs, *eif_count);
		*eifs = NULL;
		*eif_count = 0;
	}
	if (if_ni != NULL)
		if_freenameindex(if_ni);
	return rc;
}

void _eth_ifs_free(struct _eth_if **eifs, uint32_t eif_count)
{
	uint32_t i = 0;

	if ((eif_count == 0) || (eifs == NULL))
		return;

	for (; i < eif_count; ++i)
		free(eifs[i]);
	free(eifs);
}

void _scandir_free(struct dirent **namelist, int count)
{
	int i = 0;

	if ((namelist == NULL) || (count == 0))
		return;

	for (i = count - 1; i >= 0; --i)
		free(namelist[i]);
	free(namelist);
}

int _scandir(struct iscsi_context *ctx, const char *dir_path,
	     struct dirent ***namelist, int *count)
{
	int rc = LIBISCSI_OK;
	int errno_save = 0;

	assert(ctx != NULL);
	assert(dir_path != NULL);
	assert(namelist != NULL);
	assert(count != NULL);

	*namelist = NULL;
	*count = 0;

	*count = scandir(dir_path, namelist, _scan_filter_skip_dot, alphasort);
	if (*count < 0) {
		errno_save = errno;
		if (errno_save == ENOENT) {
			*count = 0;
			goto out;
		}
		if (errno_save == ENOMEM) {
			rc = LIBISCSI_ERR_NOMEM;
			goto out;
		}
		if (errno_save == ENOTDIR) {
			rc = LIBISCSI_ERR_BUG;
			_error(ctx, "Got ENOTDIR error when scandir %s",
			       dir_path);
			goto out;
		}
		rc = LIBISCSI_ERR_BUG;
		_error(ctx, "Got unexpected error %d when scandir %s",
		       errno_save, dir_path);
		goto out;
	}

out:
	if (rc != LIBISCSI_OK) {
		_scandir_free(*namelist, *count);
		*namelist = NULL;
		*count = 0;
	}

	return rc;
}