/*

 * Copyright (c) 2004-2009 Voltaire Inc.  All rights reserved.

 * Copyright (c) 2007 Xsigo Systems Inc.  All rights reserved.

 * Copyright (c) 2008 Lawrence Livermore National Lab.  All rights reserved.

 * Copyright (c) 2010,2011 Mellanox Technologies LTD.  All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 *

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif				/* HAVE_CONFIG_H */

#define _GNU_SOURCE

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <stdarg.h>

#include <time.h>

#include <string.h>

#include <errno.h>

#include <inttypes.h>

#include <complib/cl_nodenamemap.h>

#include <infiniband/ibnetdisc.h>

#include "ibdiag_common.h"

#define DIFF_FLAG_PORT_CONNECTION  0x01

#define DIFF_FLAG_PORT_STATE       0x02

#define DIFF_FLAG_LID              0x04

#define DIFF_FLAG_NODE_DESCRIPTION 0x08

#define DIFF_FLAG_DEFAULT (DIFF_FLAG_PORT_CONNECTION | DIFF_FLAG_PORT_STATE)

static char *node_name_map_file = NULL;

static nn_map_t *node_name_map = NULL;

static char *load_cache_file = NULL;

static char *diff_cache_file = NULL;

static unsigned diffcheck_flags = DIFF_FLAG_DEFAULT;

static char *filterdownports_cache_file = NULL;

static ibnd_fabric_t *filterdownports_fabric = NULL;

static struct {

	uint64_t guid;

	char *guid_str;

} node_label;

static char *dr_path = NULL;

static int all = 0;

static int down_links_only = 0;

static int line_mode = 0;

static int add_sw_settings = 0;

static int only_flag = 0;

static int only_type = 0;

static int filterdownport_check(ibnd_node_t *node, ibnd_port_t *port)

{

	ibnd_node_t *fsw;

	ibnd_port_t *fport;

	int fistate;

	fsw = ibnd_find_node_guid(filterdownports_fabric, node->guid);

	if (!fsw)

		return 0;

	if (port->portnum > fsw->numports)

		return 0;

	fport = fsw->ports[port->portnum];

	if (!fport)

		return 0;

	fistate = mad_get_field(fport->info, 0, IB_PORT_STATE_F);

	return (fistate == IB_LINK_DOWN) ? 1 : 0;

}

static void print_port(ibnd_node_t *node, ibnd_port_t *port,

		       const char *out_prefix)

{

	char width[64], speed[64], state[64], physstate[64];

	char remote_guid_str[256];

	char remote_str[256];

	char link_str[256];

	char width_msg[256];

	char speed_msg[256];

	char ext_port_str[256];

	int iwidth, ispeed, fdr10, espeed, istate, iphystate, cap_mask;

	int n = 0;

	uint8_t *info = NULL;

	int rc;

	if (!port)

		return;

	iwidth = mad_get_field(port->info, 0, IB_PORT_LINK_WIDTH_ACTIVE_F);

	ispeed = mad_get_field(port->info, 0, IB_PORT_LINK_SPEED_ACTIVE_F);

	fdr10 = mad_get_field(port->ext_info, 0,

			      IB_MLNX_EXT_PORT_LINK_SPEED_ACTIVE_F) & FDR10;

	if (port->node->type == IB_NODE_SWITCH) {

		if (port->node->ports[0])

			info = (uint8_t *)&port->node->ports[0]->info;

	}

	else

		info = (uint8_t *)&port->info;

	if (info) {

		cap_mask = mad_get_field(info, 0, IB_PORT_CAPMASK_F);

		if (cap_mask & be32toh(IB_PORT_CAP_HAS_EXT_SPEEDS))

			espeed = mad_get_field(port->info, 0,

					       IB_PORT_LINK_SPEED_EXT_ACTIVE_F);

		else

			espeed = 0;

	} else {

		ispeed = 0;

		iwidth = 0;

		espeed = 0;

	}

	istate = mad_get_field(port->info, 0, IB_PORT_STATE_F);

	iphystate = mad_get_field(port->info, 0, IB_PORT_PHYS_STATE_F);

	remote_guid_str[0] = '\0';

	remote_str[0] = '\0';

	link_str[0] = '\0';

	width_msg[0] = '\0';

	speed_msg[0] = '\0';

	if (istate == IB_LINK_DOWN

	    && filterdownports_fabric

	    && filterdownport_check(node, port))

		return;

	/* C14-24.2.1 states that a down port allows for invalid data to be

	 * returned for all PortInfo components except PortState and

	 * PortPhysicalState */

	if (istate != IB_LINK_DOWN) {

		if (!espeed) {

			if (fdr10)

				sprintf(speed, "10.0 Gbps (FDR10)");

			else

				mad_dump_val(IB_PORT_LINK_SPEED_ACTIVE_F, speed,

					     64, &ispeed);

		} else

			mad_dump_val(IB_PORT_LINK_SPEED_EXT_ACTIVE_F, speed,

				     64, &espeed);

		n = snprintf(link_str, 256, "(%3s %18s %6s/%8s)",

		     mad_dump_val(IB_PORT_LINK_WIDTH_ACTIVE_F, width, 64,

				  &iwidth),

		     speed,

		     mad_dump_val(IB_PORT_STATE_F, state, 64, &istate),

		     mad_dump_val(IB_PORT_PHYS_STATE_F, physstate, 64,

				  &iphystate));

	} else {

		n = snprintf(link_str, 256, "(              %6s/%8s)",

		     mad_dump_val(IB_PORT_STATE_F, state, 64, &istate),

		     mad_dump_val(IB_PORT_PHYS_STATE_F, physstate, 64,

				  &iphystate));

	}

	/* again default values due to C14-24.2.1 */

	if (add_sw_settings && istate != IB_LINK_DOWN) {

		snprintf(link_str + n, 256 - n,

			" (HOQ:%d VL_Stall:%d)",

			mad_get_field(port->info, 0,

				IB_PORT_HOQ_LIFE_F),

			mad_get_field(port->info, 0,

				IB_PORT_VL_STALL_COUNT_F));

	}

	if (port->remoteport) {

		char *remap =

		    remap_node_name(node_name_map, port->remoteport->node->guid,

				    port->remoteport->node->nodedesc);

		if (port->remoteport->ext_portnum)

			snprintf(ext_port_str, 256, "%d",

				 port->remoteport->ext_portnum);

		else

			ext_port_str[0] = '\0';

		get_max_msg(width_msg, speed_msg, 256, port);

		if (line_mode) {

			snprintf(remote_guid_str, 256,

				 "0x%016" PRIx64 " ",

				 port->remoteport->guid);

		}

		rc = snprintf(remote_str, sizeof(remote_str),

			      "%s%6d %4d[%2s] \"%s\" (%s %s)\n",

			      remote_guid_str, port->remoteport->base_lid ?

			      port->remoteport->base_lid :

			      port->remoteport->node->smalid,

			      port->remoteport->portnum, ext_port_str, remap,

			      width_msg, speed_msg);

		if (rc > sizeof(remote_str))

			fprintf(stderr, "WARN: string buffer overflow\n");

		free(remap);

	} else {

		if (istate == IB_LINK_DOWN)

			snprintf(remote_str, 256, "           [  ] \"\" ( )\n");

		else

			snprintf(remote_str, 256, "    \"Port not available\"\n");

	}

	if (port->ext_portnum)

		snprintf(ext_port_str, 256, "%d", port->ext_portnum);

	else

		ext_port_str[0] = '\0';

	if (line_mode) {

		char *remap = remap_node_name(node_name_map, node->guid,

					      node->nodedesc);

		printf("%s0x%016" PRIx64 " \"%30s\" ",

		       out_prefix ? out_prefix : "",

		       port->guid, remap);

		free(remap);

	} else

		printf("%s      ", out_prefix ? out_prefix : "");

	if (port->node->type != IB_NODE_SWITCH) {

		if (!line_mode)

			printf("0x%016" PRIx64 " ", port->guid);

		printf("%6d %4d[%2s] ==%s==>  %s",

			port->base_lid,

			port->portnum, ext_port_str, link_str, remote_str);

	} else

		printf("%6d %4d[%2s] ==%s==>  %s",

			node->smalid, port->portnum, ext_port_str,

			link_str, remote_str);

}

static inline const char *nodetype_str(ibnd_node_t * node)

{

	switch (node->type) {

	case IB_NODE_SWITCH:

		return "Switch";

	case IB_NODE_CA:

		return "CA";

	case IB_NODE_ROUTER:

		return "Router";

	}

	return "??";

}

static void print_node_header(ibnd_node_t *node, int *out_header_flag,

		       const char *out_prefix)

{

	uint64_t guid = 0;

	if ((!out_header_flag || !(*out_header_flag)) && !line_mode) {

		char *remap =

			remap_node_name(node_name_map, node->guid, node->nodedesc);

		if (node->type == IB_NODE_SWITCH) {

			if (node->ports[0])

				guid = node->ports[0]->guid;

			else

				guid = mad_get_field64(node->info, 0, IB_NODE_PORT_GUID_F);

			printf("%s%s: 0x%016" PRIx64 " %s:\n",

				out_prefix ? out_prefix : "",

				nodetype_str(node),

				guid,

				remap);

		} else

			printf("%s%s: %s:\n",

				out_prefix ? out_prefix : "",

				nodetype_str(node), remap);

		(*out_header_flag)++;

		free(remap);

	}

}

static void print_node(ibnd_node_t *node, void *user_data)

{

	int i = 0;

	int head_print = 0;

	char *out_prefix = (char *)user_data;

	for (i = 1; i <= node->numports; i++) {

		ibnd_port_t *port = node->ports[i];

		if (!port)

			continue;

		if (!down_links_only ||

		    mad_get_field(port->info, 0,

				  IB_PORT_STATE_F) == IB_LINK_DOWN) {

			print_node_header(node, &head_print, out_prefix);

			print_port(node, port, out_prefix);

		}

	}

}

struct iter_diff_data {

        uint32_t diff_flags;

        ibnd_fabric_t *fabric1;

        ibnd_fabric_t *fabric2;

        const char *fabric1_prefix;

        const char *fabric2_prefix;

};

static void diff_node_ports(ibnd_node_t *fabric1_node,

			    ibnd_node_t *fabric2_node, int *head_print,

			    struct iter_diff_data *data)

{

	int i = 0;

	for (i = 1; i <= fabric1_node->numports; i++) {

		ibnd_port_t *fabric1_port, *fabric2_port;

		int output_diff = 0;

		fabric1_port = fabric1_node->ports[i];

		fabric2_port = fabric2_node->ports[i];

		if (!fabric1_port && !fabric2_port)

			continue;

		if (data->diff_flags & DIFF_FLAG_PORT_CONNECTION) {

			if ((fabric1_port && !fabric2_port)

			    || (!fabric1_port && fabric2_port)

			    || (fabric1_port->remoteport

				&& !fabric2_port->remoteport)

			    || (!fabric1_port->remoteport

				&& fabric2_port->remoteport)

			    || (fabric1_port->remoteport

				&& fabric2_port->remoteport

				&& fabric1_port->remoteport->guid !=

				fabric2_port->remoteport->guid))

				output_diff++;

		}

		/* if either fabric1_port or fabric2_port NULL, should be

		 * handled by port connection diff code

		 */

		if (data->diff_flags & DIFF_FLAG_PORT_STATE

		    && fabric1_port

		    && fabric2_port) {

			int state1, state2;

			state1 = mad_get_field(fabric1_port->info, 0,

					       IB_PORT_STATE_F);

			state2 = mad_get_field(fabric2_port->info, 0,

					       IB_PORT_STATE_F);

			if (state1 != state2)

				output_diff++;

		}

		if (data->diff_flags & DIFF_FLAG_PORT_CONNECTION

		    && data->diff_flags & DIFF_FLAG_LID

		    && fabric1_port && fabric2_port

		    && fabric1_port->remoteport && fabric2_port->remoteport

		    && fabric1_port->remoteport->base_lid != fabric2_port->remoteport->base_lid)

			output_diff++;

		if (data->diff_flags & DIFF_FLAG_PORT_CONNECTION

		    && data->diff_flags & DIFF_FLAG_NODE_DESCRIPTION

		    && fabric1_port && fabric2_port

		    && fabric1_port->remoteport && fabric2_port->remoteport

		    && memcmp(fabric1_port->remoteport->node->nodedesc,

			      fabric2_port->remoteport->node->nodedesc,

			      IB_SMP_DATA_SIZE))

			output_diff++;

		if (output_diff && fabric1_port) {

			print_node_header(fabric1_node,

					    head_print,

					    NULL);

			print_port(fabric1_node,

				   fabric1_port,

				   data->fabric1_prefix);

		}

		if (output_diff && fabric2_port) {

			print_node_header(fabric1_node,

					    head_print,

					    NULL);

			print_port(fabric2_node,

				   fabric2_port,

				   data->fabric2_prefix);

		}

	}

}

static void diff_node_iter(ibnd_node_t *fabric1_node, void *iter_user_data)

{

	struct iter_diff_data *data = iter_user_data;

	ibnd_node_t *fabric2_node;

	int head_print = 0;

	DEBUG("DEBUG: fabric1_node %p\n", fabric1_node);

	fabric2_node = ibnd_find_node_guid(data->fabric2, fabric1_node->guid);

	if (!fabric2_node)

		print_node(fabric1_node, (void *)data->fabric1_prefix);

	else if (data->diff_flags &

		 (DIFF_FLAG_PORT_CONNECTION | DIFF_FLAG_PORT_STATE

		  | DIFF_FLAG_LID | DIFF_FLAG_NODE_DESCRIPTION)) {

		if ((fabric1_node->type == IB_NODE_SWITCH

		     && data->diff_flags & DIFF_FLAG_LID

		     && fabric1_node->smalid != fabric2_node->smalid) ||

		    (data->diff_flags & DIFF_FLAG_NODE_DESCRIPTION

		     && memcmp(fabric1_node->nodedesc, fabric2_node->nodedesc,

			       IB_SMP_DATA_SIZE))) {

			print_node_header(fabric1_node,

					    NULL,

					    data->fabric1_prefix);

			print_node_header(fabric2_node,

					    NULL,

					    data->fabric2_prefix);

			head_print++;

		}

		if (fabric1_node->numports != fabric2_node->numports) {

			print_node_header(fabric1_node,

					    &head_print,

					    NULL);

			printf("%snumports = %d\n", data->fabric1_prefix,

			       fabric1_node->numports);

			printf("%snumports = %d\n", data->fabric2_prefix,

			       fabric2_node->numports);

			return;

		}

		diff_node_ports(fabric1_node, fabric2_node,

				  &head_print, data);

	}

}

static int diff_node(ibnd_node_t *node, ibnd_fabric_t *orig_fabric,

		     ibnd_fabric_t *new_fabric)

{

	struct iter_diff_data iter_diff_data;

	iter_diff_data.diff_flags = diffcheck_flags;

	iter_diff_data.fabric1 = orig_fabric;

	iter_diff_data.fabric2 = new_fabric;

	iter_diff_data.fabric1_prefix = "< ";

	iter_diff_data.fabric2_prefix = "> ";

	if (node)

		diff_node_iter(node, &iter_diff_data);

	else {

		if (only_flag)

			ibnd_iter_nodes_type(orig_fabric, diff_node_iter,

					     only_type, &iter_diff_data);

		else

			ibnd_iter_nodes(orig_fabric, diff_node_iter,

					&iter_diff_data);

	}

	/* Do opposite diff to find existence of node types

	 * in new_fabric but not in orig_fabric.

	 *

	 * In this diff, we don't need to check port connections,

	 * port state, lids, or node descriptions since it has already

	 * been done (i.e. checks are only done when guid exists on both

	 * orig and new).

	 */

	iter_diff_data.diff_flags = diffcheck_flags & ~DIFF_FLAG_PORT_CONNECTION;

	iter_diff_data.diff_flags &= ~DIFF_FLAG_PORT_STATE;

	iter_diff_data.diff_flags &= ~DIFF_FLAG_LID;

	iter_diff_data.diff_flags &= ~DIFF_FLAG_NODE_DESCRIPTION;

	iter_diff_data.fabric1 = new_fabric;

	iter_diff_data.fabric2 = orig_fabric;

	iter_diff_data.fabric1_prefix = "> ";

	iter_diff_data.fabric2_prefix = "< ";

	if (node)

		diff_node_iter(node, &iter_diff_data);

	else {

		if (only_flag)

			ibnd_iter_nodes_type(new_fabric, diff_node_iter,

					     only_type, &iter_diff_data);

		else

			ibnd_iter_nodes(new_fabric, diff_node_iter,

					&iter_diff_data);

	}

	return 0;

}

static int process_opt(void *context, int ch)

{

	struct ibnd_config *cfg = context;

	char *p;

	switch (ch) {

	case 1:

		node_name_map_file = strdup(optarg);

		if (node_name_map_file == NULL)

			IBEXIT("out of memory, strdup for node_name_map_file name failed");

		break;

	case 2:

		load_cache_file = strdup(optarg);

		break;

	case 3:

		diff_cache_file = strdup(optarg);

		break;

	case 4:

		diffcheck_flags = 0;

		p = strtok(optarg, ",");

		while (p) {

			if (!strcasecmp(p, "port"))

				diffcheck_flags |= DIFF_FLAG_PORT_CONNECTION;

			else if (!strcasecmp(p, "state"))

				diffcheck_flags |= DIFF_FLAG_PORT_STATE;

			else if (!strcasecmp(p, "lid"))

				diffcheck_flags |= DIFF_FLAG_LID;

			else if (!strcasecmp(p, "nodedesc"))

				diffcheck_flags |= DIFF_FLAG_NODE_DESCRIPTION;

			else {

				fprintf(stderr, "invalid diff check key: %s\n",

					p);

				return -1;

			}

			p = strtok(NULL, ",");

		}

		break;

	case 5:

		filterdownports_cache_file = strdup(optarg);

		break;

	case 6:

		only_flag = 1;

		only_type = IB_NODE_SWITCH;

		break;

	case 7:

		only_flag = 1;

		only_type = IB_NODE_CA;

		break;

	case 'S':

	case 'G':

		node_label.guid_str = optarg;

		node_label.guid = (uint64_t)strtoull(node_label.guid_str, NULL, 0);

		break;

	case 'D':

		dr_path = strdup(optarg);

		break;

	case 'a':

		all = 1;

		break;

	case 'n':

		cfg->max_hops = strtoul(optarg, NULL, 0);

		break;

	case 'd':

		down_links_only = 1;

		break;

	case 'l':

		line_mode = 1;

		break;

	case 'p':

		add_sw_settings = 1;

		break;

	case 'R':		/* nop */

		break;

	case 'o':

		cfg->max_smps = strtoul(optarg, NULL, 0);

		break;

	default:

		return -1;

	}

	return 0;

}

int main(int argc, char **argv)

{

	struct ibnd_config config = { 0 };

	int rc = 0;

	int resolved = -1;

	ibnd_fabric_t *fabric = NULL;

	ibnd_fabric_t *diff_fabric = NULL;

	struct ibmad_port *ibmad_port;

	ib_portid_t port_id = { 0 };

	uint8_t ni[IB_SMP_DATA_SIZE] = { 0 };

	int mgmt_classes[3] =

	    { IB_SMI_CLASS, IB_SMI_DIRECT_CLASS, IB_SA_CLASS };

	const struct ibdiag_opt opts[] = {

		{"node-name-map", 1, 1, "<file>", "node name map file"},

		{"switch", 'S', 1, "<port_guid>",

		 "start partial scan at the port specified by <port_guid> (hex format)"},

		{"port-guid", 'G', 1, "<port_guid>",

		 "(same as -S)"},

		{"Direct", 'D', 1, "<dr_path>",

		 "start partial scan at the port specified by <dr_path>"},

		{"all", 'a', 0, NULL,

		 "print all nodes found in a partial fabric scan"},

		{"hops", 'n', 1, "<hops>",

		 "Number of hops to include away from specified node"},

		{"down", 'd', 0, NULL, "print only down links"},

		{"line", 'l', 0, NULL,

		 "(line mode) print all information for each link on a single line"},

		{"additional", 'p', 0, NULL,

		 "print additional port settings (PktLifeTime, HoqLife, VLStallCount)"},

		{"load-cache", 2, 1, "<file>",

		 "filename of ibnetdiscover cache to load"},

		{"diff", 3, 1, "<file>",

		 "filename of ibnetdiscover cache to diff"},

		{"diffcheck", 4, 1, "<key(s)>",

		 "specify checks to execute for --diff"},

		{"filterdownports", 5, 1, "<file>",

		 "filename of ibnetdiscover cache to filter downports"},

		{"outstanding_smps", 'o', 1, NULL,

		 "specify the number of outstanding SMP's which should be "

		 "issued during the scan"},

		{"switches-only", 6, 0, NULL,

		 "Output only switches"},

		{"cas-only", 7, 0, NULL,

		 "Output only CAs"},

		{}

	};

	char usage_args[] = "";

	ibdiag_process_opts(argc, argv, &config, "aDdGgKLlnpRS", opts,

			    process_opt, usage_args, NULL);

	argc -= optind;

	argv += optind;

	ibmad_port = mad_rpc_open_port(ibd_ca, ibd_ca_port, mgmt_classes, 3);

	if (!ibmad_port) {

		fprintf(stderr, "Failed to open %s port %d\n", ibd_ca,

			ibd_ca_port);

		exit(1);

	}

	smp_mkey_set(ibmad_port, ibd_mkey);

	if (ibd_timeout) {

		mad_rpc_set_timeout(ibmad_port, ibd_timeout);

		config.timeout_ms = ibd_timeout;

	}

	config.flags = ibd_ibnetdisc_flags;

	config.mkey = ibd_mkey;

	node_name_map = open_node_name_map(node_name_map_file);

	if (dr_path && load_cache_file) {

		mad_rpc_close_port(ibmad_port);

		fprintf(stderr, "Cannot specify cache and direct route path\n");

		exit(1);

	}

	if (dr_path) {

		/* only scan part of the fabric */

		if ((resolved =

		     resolve_portid_str(ibd_ca, ibd_ca_port, &port_id, dr_path,

					IB_DEST_DRPATH, NULL, ibmad_port)) < 0)

			IBWARN("Failed to resolve %s; attempting full scan",

			       dr_path);

	} else if (node_label.guid_str) {

		if ((resolved = resolve_portid_str(

			     ibd_ca, ibd_ca_port, &port_id, node_label.guid_str,

			     IB_DEST_GUID, NULL, ibmad_port)) < 0)

			IBWARN("Failed to resolve %s; attempting full scan\n",

			       node_label.guid_str);

	}

	if (!all && dr_path) {

		if (!smp_query_via(ni, &port_id, IB_ATTR_NODE_INFO, 0,

				   ibd_timeout, ibmad_port)){

			mad_rpc_close_port(ibmad_port);

			fprintf(stderr, "Failed to get local Node Info\n");

			exit(1);

		}

	}

	mad_rpc_close_port(ibmad_port);

	if (diff_cache_file &&

	    !(diff_fabric = ibnd_load_fabric(diff_cache_file, 0)))

		IBEXIT("loading cached fabric for diff failed\n");

	if (filterdownports_cache_file &&

	    !(filterdownports_fabric = ibnd_load_fabric(filterdownports_cache_file, 0)))

		IBEXIT("loading cached fabric for filterdownports failed\n");

	if (load_cache_file) {

		if ((fabric = ibnd_load_fabric(load_cache_file, 0)) == NULL) {

			fprintf(stderr, "loading cached fabric failed\n");

			exit(1);

		}

	} else {

		if (resolved >= 0) {

			if (!config.max_hops)

				config.max_hops = 1;

			if (!(fabric =

			    ibnd_discover_fabric(ibd_ca, ibd_ca_port, &port_id, &config)))

				IBWARN("Partial fabric scan failed;"

				       " attempting full scan\n");

		}

		if (!fabric &&

		    !(fabric = ibnd_discover_fabric(ibd_ca, ibd_ca_port, NULL, &config))) {

			fprintf(stderr, "discover failed\n");

			rc = 1;

			goto close_port;

		}

	}

	if (!all && node_label.guid_str) {

		ibnd_port_t *p = ibnd_find_port_guid(fabric, node_label.guid);

		if (p && (!only_flag || p->node->type == only_type)) {

			ibnd_node_t *n = p->node;

			if (diff_fabric)

				diff_node(n, diff_fabric, fabric);

			else

				print_node(n, NULL);

		}

		else

			fprintf(stderr, "Failed to find port: %s\n", node_label.guid_str);

	} else if (!all && dr_path) {

		ibnd_port_t *p = NULL;

		mad_decode_field(ni, IB_NODE_PORT_GUID_F, &node_label.guid);

		p = ibnd_find_port_guid(fabric, node_label.guid);

		if (p && (!only_flag || p->node->type == only_type)) {

			ibnd_node_t *n = p->node;

			if (diff_fabric)

				diff_node(n, diff_fabric, fabric);

			else

				print_node(n, NULL);

		}

		else

			fprintf(stderr, "Failed to find port: %s\n", dr_path);

	} else {

		if (diff_fabric)

			diff_node(NULL, diff_fabric, fabric);

		else {

			if (only_flag)

				ibnd_iter_nodes_type(fabric, print_node,

						     only_type, NULL);

			else

				ibnd_iter_nodes(fabric, print_node, NULL);

		}

	}

	ibnd_destroy_fabric(fabric);

	if (diff_fabric)

		ibnd_destroy_fabric(diff_fabric);

close_port:

	close_node_name_map(node_name_map);

	exit(rc);

}