/*

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

 * Copyright (c) 2002-2015 Mellanox Technologies LTD. All rights reserved.

 * Copyright (c) 1996-2003 Intel Corporation. All rights reserved.

 * Copyright (c) 2009 HNR Consulting. All rights reserved.

 * Copyright (c) 2013 Oracle and/or its affiliates. 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.

 *

 */

/*

 * Abstract:

 *    Implementation of inform record functions.

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif				/* HAVE_CONFIG_H */

#include <stdlib.h>

#include <string.h>

#include <arpa/inet.h>

#include <complib/cl_debug.h>

#include <opensm/osm_file_ids.h>

#define FILE_ID OSM_FILE_INFORM_C

#include <opensm/osm_helper.h>

#include <opensm/osm_inform.h>

#include <vendor/osm_vendor_api.h>

#include <opensm/osm_pkey.h>

#include <opensm/osm_sa.h>

#include <opensm/osm_opensm.h>

typedef struct osm_infr_match_ctxt {

	cl_list_t *p_remove_infr_list;

	ib_mad_notice_attr_t *p_ntc;

} osm_infr_match_ctxt_t;

void osm_infr_delete(IN osm_infr_t * p_infr)

{

	free(p_infr);

}

osm_infr_t *osm_infr_new(IN const osm_infr_t * p_infr_rec)

{

	osm_infr_t *p_infr;

	CL_ASSERT(p_infr_rec);

	p_infr = (osm_infr_t *) malloc(sizeof(osm_infr_t));

	if (p_infr)

		memcpy(p_infr, p_infr_rec, sizeof(osm_infr_t));

	return p_infr;

}

static void dump_all_informs(IN const osm_subn_t * p_subn, IN osm_log_t * p_log)

{

	cl_list_item_t *p_list_item;

	if (!OSM_LOG_IS_ACTIVE_V2(p_log, OSM_LOG_DEBUG))

		return;

	p_list_item = cl_qlist_head(&p_subn->sa_infr_list);

	while (p_list_item != cl_qlist_end(&p_subn->sa_infr_list)) {

		osm_dump_inform_info_v2(p_log,

				        &((osm_infr_t *) p_list_item)->

				        inform_record.inform_info, FILE_ID, OSM_LOG_DEBUG);

		p_list_item = cl_qlist_next(p_list_item);

	}

}

/**********************************************************************

 * Match an infr by the InformInfo and Address vector

 **********************************************************************/

static cl_status_t match_inf_rec(IN const cl_list_item_t * p_list_item,

				 IN void *context)

{

	osm_infr_t *p_infr_rec = (osm_infr_t *) context;

	osm_infr_t *p_infr = (osm_infr_t *) p_list_item;

	ib_inform_info_t *p_ii_rec = &p_infr_rec->inform_record.inform_info;

	ib_inform_info_t *p_ii = &p_infr->inform_record.inform_info;

	osm_log_t *p_log = p_infr_rec->sa->p_log;

	cl_status_t status = CL_NOT_FOUND;

	OSM_LOG_ENTER(p_log);

	if (memcmp(&p_infr->report_addr, &p_infr_rec->report_addr,

		   sizeof(p_infr_rec->report_addr))) {

		OSM_LOG(p_log, OSM_LOG_DEBUG, "Differ by Address\n");

		goto Exit;

	}

	/* if inform_info.gid is not zero, ignore lid range */

	if (ib_gid_is_notzero(&p_ii_rec->gid)) {

		if (memcmp(&p_ii->gid, &p_ii_rec->gid, sizeof(p_ii->gid))) {

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Differ by InformInfo.gid\n");

			goto Exit;

		}

	} else {

		if ((p_ii->lid_range_begin != p_ii_rec->lid_range_begin) ||

		    (p_ii->lid_range_end != p_ii_rec->lid_range_end)) {

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Differ by InformInfo.LIDRange\n");

			goto Exit;

		}

	}

	if (p_ii->trap_type != p_ii_rec->trap_type) {

		OSM_LOG(p_log, OSM_LOG_DEBUG,

			"Differ by InformInfo.TrapType\n");

		goto Exit;

	}

	if (p_ii->is_generic != p_ii_rec->is_generic) {

		OSM_LOG(p_log, OSM_LOG_DEBUG,

			"Differ by InformInfo.IsGeneric\n");

		goto Exit;

	}

	if (p_ii->is_generic) {

		if (p_ii->g_or_v.generic.trap_num !=

		    p_ii_rec->g_or_v.generic.trap_num)

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Differ by InformInfo.Generic.TrapNumber\n");

		else if (p_ii->g_or_v.generic.qpn_resp_time_val !=

			 p_ii_rec->g_or_v.generic.qpn_resp_time_val)

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Differ by InformInfo.Generic.QPNRespTimeVal\n");

		else if (p_ii->g_or_v.generic.node_type_msb !=

			 p_ii_rec->g_or_v.generic.node_type_msb)

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Differ by InformInfo.Generic.NodeTypeMSB\n");

		else if (p_ii->g_or_v.generic.node_type_lsb !=

			 p_ii_rec->g_or_v.generic.node_type_lsb)

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Differ by InformInfo.Generic.NodeTypeLSB\n");

		else

			status = CL_SUCCESS;

	} else {

		if (p_ii->g_or_v.vend.dev_id != p_ii_rec->g_or_v.vend.dev_id)

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Differ by InformInfo.Vendor.DeviceID\n");

		else if (p_ii->g_or_v.vend.qpn_resp_time_val !=

			 p_ii_rec->g_or_v.vend.qpn_resp_time_val)

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Differ by InformInfo.Vendor.QPNRespTimeVal\n");

		else if (p_ii->g_or_v.vend.vendor_id_msb !=

			 p_ii_rec->g_or_v.vend.vendor_id_msb)

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Differ by InformInfo.Vendor.VendorIdMSB\n");

		else if (p_ii->g_or_v.vend.vendor_id_lsb !=

			 p_ii_rec->g_or_v.vend.vendor_id_lsb)

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Differ by InformInfo.Vendor.VendorIdLSB\n");

		else

			status = CL_SUCCESS;

	}

Exit:

	OSM_LOG_EXIT(p_log);

	return status;

}

osm_infr_t *osm_infr_get_by_rec(IN osm_subn_t const *p_subn,

				IN osm_log_t * p_log,

				IN osm_infr_t * p_infr_rec)

{

	cl_list_item_t *p_list_item;

	OSM_LOG_ENTER(p_log);

	dump_all_informs(p_subn, p_log);

	OSM_LOG(p_log, OSM_LOG_DEBUG, "Looking for Inform Record\n");

	osm_dump_inform_info_v2(p_log, &(p_infr_rec->inform_record.inform_info),

			        FILE_ID, OSM_LOG_DEBUG);

	OSM_LOG(p_log, OSM_LOG_DEBUG, "InformInfo list size %d\n",

		cl_qlist_count(&p_subn->sa_infr_list));

	p_list_item = cl_qlist_find_from_head(&p_subn->sa_infr_list,

					      match_inf_rec, p_infr_rec);

	if (p_list_item == cl_qlist_end(&p_subn->sa_infr_list))

		p_list_item = NULL;

	OSM_LOG_EXIT(p_log);

	return (osm_infr_t *) p_list_item;

}

void osm_infr_insert_to_db(IN osm_subn_t * p_subn, IN osm_log_t * p_log,

			   IN osm_infr_t * p_infr)

{

	OSM_LOG_ENTER(p_log);

	OSM_LOG(p_log, OSM_LOG_DEBUG,

		"Inserting new InformInfo Record into Database\n");

	OSM_LOG(p_log, OSM_LOG_DEBUG, "Dump before insertion (size %d)\n",

		cl_qlist_count(&p_subn->sa_infr_list));

	dump_all_informs(p_subn, p_log);

#if 0

	osm_dump_inform_info_v2(p_log,

			        &(p_infr->inform_record.inform_info),

			        FILE_ID, OSM_LOG_DEBUG);

#endif

	cl_qlist_insert_head(&p_subn->sa_infr_list, &p_infr->list_item);

	p_subn->p_osm->sa.dirty = TRUE;

	OSM_LOG(p_log, OSM_LOG_DEBUG, "Dump after insertion (size %d)\n",

		cl_qlist_count(&p_subn->sa_infr_list));

	dump_all_informs(p_subn, p_log);

	OSM_LOG_EXIT(p_log);

}

void osm_infr_remove_from_db(IN osm_subn_t * p_subn, IN osm_log_t * p_log,

			     IN osm_infr_t * p_infr)

{

	char gid_str[INET6_ADDRSTRLEN];

	OSM_LOG_ENTER(p_log);

	OSM_LOG(p_log, OSM_LOG_DEBUG, "Removing InformInfo Subscribing GID:%s"

		" Enum:0x%X from Database\n",

		inet_ntop(AF_INET6, p_infr->inform_record.subscriber_gid.raw,

			  gid_str, sizeof gid_str),

		p_infr->inform_record.subscriber_enum);

	osm_dump_inform_info_v2(p_log, &(p_infr->inform_record.inform_info),

			        FILE_ID, OSM_LOG_DEBUG);

	cl_qlist_remove_item(&p_subn->sa_infr_list, &p_infr->list_item);

	p_subn->p_osm->sa.dirty = TRUE;

	osm_infr_delete(p_infr);

	OSM_LOG_EXIT(p_log);

}

ib_api_status_t osm_infr_remove_subscriptions(IN osm_subn_t * p_subn,

					      IN osm_log_t * p_log,

					      IN ib_net64_t port_guid)

{

	cl_list_item_t *p_list_item;

	osm_infr_t *p_infr;

	ib_api_status_t status = CL_NOT_FOUND;

	OSM_LOG_ENTER(p_log);

	/* go over all inform info available at the subnet */

	/* match to the given GID and delete subscriptions if match */

	p_list_item = cl_qlist_head(&p_subn->sa_infr_list);

	while (p_list_item != cl_qlist_end(&p_subn->sa_infr_list)) {

		p_infr = (osm_infr_t *)p_list_item;

		p_list_item = cl_qlist_next(p_list_item);

		if (port_guid != p_infr->inform_record.subscriber_gid.unicast.interface_id)

			continue;

		/* Remove this event subscription */

		osm_infr_remove_from_db(p_subn, p_log, p_infr);

		status = CL_SUCCESS;

	}

	OSM_LOG_EXIT(p_log);

	return (status);

}

/**********************************************************************

 * Send a report:

 * Given a target address to send to and the notice.

 * We need to send SubnAdmReport

 **********************************************************************/

static ib_api_status_t send_report(IN osm_infr_t * p_infr_rec,	/* the informinfo */

				   IN ib_mad_notice_attr_t * p_ntc	/* notice to send */

    )

{

	osm_madw_t *p_report_madw;

	ib_mad_notice_attr_t *p_report_ntc;

	ib_mad_t *p_mad;

	ib_sa_mad_t *p_sa_mad;

	static atomic32_t trap_fwd_trans_id = 0x02DAB000;

	ib_api_status_t status = IB_SUCCESS;

	osm_log_t *p_log = p_infr_rec->sa->p_log;

	ib_net64_t tid;

	OSM_LOG_ENTER(p_log);

	/* HACK: who switches or uses the src and dest GIDs in the grh_info ?? */

	/* it is better to use LIDs since the GIDs might not be there for SMI traps */

	OSM_LOG(p_log, OSM_LOG_DEBUG, "Forwarding Notice Event from LID %u"

		" to InformInfo LID %u GUID 0x%" PRIx64 ", TID 0x%X\n",

		cl_ntoh16(p_ntc->issuer_lid),

		cl_ntoh16(p_infr_rec->report_addr.dest_lid),

		cl_ntoh64(p_infr_rec->inform_record.subscriber_gid.unicast.interface_id),

		trap_fwd_trans_id);

	/* get the MAD to send */

	p_report_madw = osm_mad_pool_get(p_infr_rec->sa->p_mad_pool,

					 p_infr_rec->h_bind, MAD_BLOCK_SIZE,

					 &(p_infr_rec->report_addr));

	if (!p_report_madw) {

		OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 0203: "

			"Cannot send report to LID %u, osm_mad_pool_get failed\n",

			cl_ntoh16(p_infr_rec->report_addr.dest_lid));

		status = IB_ERROR;

		goto Exit;

	}

	p_report_madw->resp_expected = TRUE;

	/* advance trap trans id (cant simply ++ on some systems inside ntoh) */

	tid = cl_hton64((uint64_t) cl_atomic_inc(&trap_fwd_trans_id) &

			(uint64_t) (0xFFFFFFFF));

	if (trap_fwd_trans_id == 0)

		tid = cl_hton64((uint64_t) cl_atomic_inc(&trap_fwd_trans_id) &

				(uint64_t) (0xFFFFFFFF));

	p_mad = osm_madw_get_mad_ptr(p_report_madw);

	ib_mad_init_new(p_mad, IB_MCLASS_SUBN_ADM, 2, IB_MAD_METHOD_REPORT,

			tid, IB_MAD_ATTR_NOTICE, 0);

	p_sa_mad = osm_madw_get_sa_mad_ptr(p_report_madw);

	p_report_ntc = (ib_mad_notice_attr_t *) & (p_sa_mad->data);

	/* copy the notice */

	*p_report_ntc = *p_ntc;

	/* The TRUE is for: response is expected */

	osm_sa_send(p_infr_rec->sa, p_report_madw, TRUE);

Exit:

	OSM_LOG_EXIT(p_log);

	return status;

}

static int is_access_permitted(osm_infr_t *p_infr_rec,

			       osm_infr_match_ctxt_t *p_infr_match )

{

	cl_list_t *p_infr_to_remove_list = p_infr_match->p_remove_infr_list;

	ib_inform_info_t *p_ii = &(p_infr_rec->inform_record.inform_info);

	ib_mad_notice_attr_t *p_ntc = p_infr_match->p_ntc;

	uint16_t trap_num = cl_ntoh16(p_ntc->g_or_v.generic.trap_num);

	osm_subn_t *p_subn = p_infr_rec->sa->p_subn;

	osm_log_t *p_log = p_infr_rec->sa->p_log;

	osm_mgrp_t *p_mgrp;

	ib_gid_t source_gid;

	osm_port_t *p_src_port;

	osm_port_t *p_dest_port;

	/* In case of SM_GID_IN_SERVICE_TRAP(64) or SM_GID_OUT_OF_SERVICE_TRAP(65) traps

	   the source gid comparison should be done on the trap source (saved

	   as the gid in the data details field).

	   For traps SM_MGID_CREATED_TRAP(66) or SM_MGID_DESTROYED_TRAP(67)

	   the data details gid is the MGID.

	   We need to check whether the subscriber has a compatible

	   pkey with MC group.

	   In all other cases the issuer gid is the trap source.

	*/

	if (trap_num >= SM_GID_IN_SERVICE_TRAP &&

	    trap_num <= SM_MGID_DESTROYED_TRAP)

		/* The issuer of these traps is the SM so source_gid

		   is the gid saved on the data details */

		source_gid = p_ntc->data_details.ntc_64_67.gid;

	else

		source_gid = p_ntc->issuer_gid;

	p_dest_port = osm_get_port_by_lid(p_subn,

					  p_infr_rec->report_addr.dest_lid);

	if (!p_dest_port) {

		OSM_LOG(p_log, OSM_LOG_INFO,

			"Cannot find destination port with LID:%u\n",

			cl_ntoh16(p_infr_rec->report_addr.dest_lid));

		goto Exit;

	}

	/* Check if there is a pkey match. o13-17.1.1 */

	switch (trap_num) {

		case SM_MGID_CREATED_TRAP:

		case SM_MGID_DESTROYED_TRAP:

			p_mgrp = osm_get_mgrp_by_mgid(p_subn, &source_gid);

			if (!p_mgrp) {

				char gid_str[INET6_ADDRSTRLEN];

				OSM_LOG(p_log, OSM_LOG_INFO,

					"Cannot find MGID %s\n",

					inet_ntop(AF_INET6, source_gid.raw, gid_str, sizeof gid_str));

				goto Exit;

			}

			if (!osm_physp_has_pkey(p_log,

						p_mgrp->mcmember_rec.pkey,

						p_dest_port->p_physp)) {

				char gid_str[INET6_ADDRSTRLEN];

				OSM_LOG(p_log, OSM_LOG_INFO,

					"MGID %s and port GUID:0x%016" PRIx64 " do not share same pkey\n",

					inet_ntop(AF_INET6, source_gid.raw, gid_str, sizeof gid_str),

					cl_ntoh64(p_dest_port->guid));

				goto Exit;

			}

			break;

		default:

			p_src_port =

			    osm_get_port_by_guid(p_subn, source_gid.unicast.interface_id);

			if (!p_src_port) {

				OSM_LOG(p_log, OSM_LOG_INFO,

					"Cannot find source port with GUID:0x%016" PRIx64 "\n",

					cl_ntoh64(source_gid.unicast.interface_id));

				goto Exit;

			}

			if (osm_port_share_pkey(p_log, p_src_port, p_dest_port,

						p_subn->opt.allow_both_pkeys) == FALSE) {

				OSM_LOG(p_log, OSM_LOG_DEBUG, "Mismatch by Pkey\n");

				/* According to o13-17.1.2 - If this informInfo

				   does not have lid_range_begin of 0xFFFF,

				   then this informInfo request should be

				   removed from database */

				if (p_ii->lid_range_begin != 0xFFFF) {

					OSM_LOG(p_log, OSM_LOG_VERBOSE,

						"Pkey mismatch on lid_range_begin != 0xFFFF. "

						"Need to remove this informInfo from db\n");

					/* add the informInfo record to the remove_infr list */

					cl_list_insert_tail(p_infr_to_remove_list, p_infr_rec);

				}

				goto Exit;

			}

			break;

	}

	return 1;

Exit:

	return 0;

}

/**********************************************************************

 * This routine compares a given Notice and a ListItem of InformInfo type.

 * PREREQUISITE:

 * The Notice.GID should be pre-filled with the trap generator GID

 **********************************************************************/

static void match_notice_to_inf_rec(IN cl_list_item_t * p_list_item,

				    IN void *context)

{

	osm_infr_match_ctxt_t *p_infr_match = (osm_infr_match_ctxt_t *) context;

	ib_mad_notice_attr_t *p_ntc = p_infr_match->p_ntc;

	osm_infr_t *p_infr_rec = (osm_infr_t *) p_list_item;

	ib_inform_info_t *p_ii = &(p_infr_rec->inform_record.inform_info);

	osm_log_t *p_log = p_infr_rec->sa->p_log;

	OSM_LOG_ENTER(p_log);

	/* matching rules

	 * InformInfo   Notice

	 * GID          IssuerGID    if non zero must match the trap

	 * LIDRange     IssuerLID    apply only if GID=0

	 * IsGeneric    IsGeneric    is compulsory and must match the trap

	 * Type         Type         if not 0xFFFF must match

	 * TrapNumber   TrapNumber   if not 0xFFFF must match

	 * DeviceId     DeviceID     if not 0xFFFF must match

	 * QPN dont care

	 * ProducerType ProducerType match or 0xFFFFFF // EZ: actually my interpretation

	 * VendorID     VendorID     match or 0xFFFFFF

	 */

	/* GID          IssuerGID    if non zero must match the trap  */

	if (p_ii->gid.unicast.prefix != 0

	    || p_ii->gid.unicast.interface_id != 0) {

		/* match by GID */

		if (memcmp(&(p_ii->gid), &(p_ntc->issuer_gid),

			   sizeof(ib_gid_t))) {

			OSM_LOG(p_log, OSM_LOG_DEBUG, "Mismatch by GID\n");

			goto Exit;

		}

	} else {

		/* LIDRange     IssuerLID    apply only if GID=0 */

		/* If lid_range_begin of the informInfo is 0xFFFF - then it should be ignored. */

		if (p_ii->lid_range_begin != 0xFFFF) {

			/* a real lid range is given - check it */

			if ((cl_hton16(p_ii->lid_range_begin) >

			     cl_hton16(p_ntc->issuer_lid))

			    || (cl_hton16(p_ntc->issuer_lid) >

				cl_hton16(p_ii->lid_range_end))) {

				OSM_LOG(p_log, OSM_LOG_DEBUG,

					"Mismatch by LID Range. Needed: %u <= %u <= %u\n",

					cl_hton16(p_ii->lid_range_begin),

					cl_hton16(p_ntc->issuer_lid),

					cl_hton16(p_ii->lid_range_end));

				goto Exit;

			}

		}

	}

	/* IsGeneric    IsGeneric    is compulsory and must match the trap  */

	if ((p_ii->is_generic && !ib_notice_is_generic(p_ntc)) ||

	    (!p_ii->is_generic && ib_notice_is_generic(p_ntc))) {

		OSM_LOG(p_log, OSM_LOG_DEBUG, "Mismatch by Generic/Vendor\n");

		goto Exit;

	}

	/* Type         Type         if not 0xFFFF must match */

	if ((p_ii->trap_type != 0xFFFF) &&

	    (cl_ntoh16(p_ii->trap_type) != ib_notice_get_type(p_ntc))) {

		OSM_LOG(p_log, OSM_LOG_DEBUG, "Mismatch by Type\n");

		goto Exit;

	}

	/* based on generic type */

	if (p_ii->is_generic) {

		/* TrapNumber   TrapNumber   if not 0xFFFF must match */

		if ((p_ii->g_or_v.generic.trap_num != 0xFFFF) &&

		    (p_ii->g_or_v.generic.trap_num !=

		     p_ntc->g_or_v.generic.trap_num)) {

			OSM_LOG(p_log, OSM_LOG_DEBUG, "Mismatch by Trap Num\n");

			goto Exit;

		}

		/* ProducerType ProducerType match or 0xFFFFFF  */

		if ((cl_ntoh32(ib_inform_info_get_prod_type(p_ii)) != 0xFFFFFF)

		    && (ib_inform_info_get_prod_type(p_ii) !=

			ib_notice_get_prod_type(p_ntc))) {

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Mismatch by Node Type: II=0x%06X (%s) Trap=0x%06X (%s)\n",

				cl_ntoh32(ib_inform_info_get_prod_type(p_ii)),

				ib_get_producer_type_str

				(ib_inform_info_get_prod_type(p_ii)),

				cl_ntoh32(ib_notice_get_prod_type(p_ntc)),

				ib_get_producer_type_str(ib_notice_get_prod_type

							 (p_ntc)));

			goto Exit;

		}

	} else {

		/* DeviceId     DeviceID     if not 0xFFFF must match */

		if ((p_ii->g_or_v.vend.dev_id != 0xFFFF) &&

		    (p_ii->g_or_v.vend.dev_id != p_ntc->g_or_v.vend.dev_id)) {

			OSM_LOG(p_log, OSM_LOG_DEBUG, "Mismatch by Dev Id\n");

			goto Exit;

		}

		/* VendorID     VendorID     match or 0xFFFFFF  */

		if ((ib_inform_info_get_vend_id(p_ii) != CL_HTON32(0xFFFFFF)) &&

		    (ib_inform_info_get_vend_id(p_ii) !=

		     ib_notice_get_vend_id(p_ntc))) {

			OSM_LOG(p_log, OSM_LOG_DEBUG,

				"Mismatch by Vendor ID\n");

			goto Exit;

		}

	}

	if (!is_access_permitted(p_infr_rec, p_infr_match))

		goto Exit;

	/* send the report to the address provided in the inform record */

	OSM_LOG(p_log, OSM_LOG_DEBUG, "MATCH! Sending Report...\n");

	send_report(p_infr_rec, p_ntc);

Exit:

	OSM_LOG_EXIT(p_log);

}

/**********************************************************************

 * Once a Trap was received by osm_trap_rcv, or a Trap sourced by

 * the SM was sent (Traps 64-67), this routine is called with a copy of

 * the notice data.

 * Given a notice attribute - compare and see if it matches the InformInfo

 * element and if it does - call the Report(Notice) for the

 * target QP registered by the address stored in the InformInfo element

 **********************************************************************/

static void log_notice(osm_log_t * log, osm_log_level_t level,

		       ib_mad_notice_attr_t * ntc)

{

	char gid_str[INET6_ADDRSTRLEN], gid_str2[INET6_ADDRSTRLEN];

	ib_gid_t *gid;

	ib_gid_t *gid1, *gid2;

	/* an official Event information log */

	if (ib_notice_is_generic(ntc)) {

		if ((ntc->g_or_v.generic.trap_num == CL_HTON16(SM_GID_IN_SERVICE_TRAP)) ||

		    (ntc->g_or_v.generic.trap_num == CL_HTON16(SM_GID_OUT_OF_SERVICE_TRAP)) ||

		    (ntc->g_or_v.generic.trap_num == CL_HTON16(SM_MGID_CREATED_TRAP)) ||

		    (ntc->g_or_v.generic.trap_num == CL_HTON16(SM_MGID_DESTROYED_TRAP)))

			gid = &ntc->data_details.ntc_64_67.gid;

		else

			gid = &ntc->issuer_gid;

		switch (cl_ntoh16(ntc->g_or_v.generic.trap_num)) {

		case SM_GID_IN_SERVICE_TRAP:

		case SM_GID_OUT_OF_SERVICE_TRAP:

			OSM_LOG(log, level,

				"Reporting Informational Notice \"%s\", GID:%s\n",

				ib_get_trap_str(ntc->g_or_v.generic.trap_num),

				inet_ntop(AF_INET6, gid->raw, gid_str, sizeof gid_str));

			break;

		case SM_MGID_CREATED_TRAP:

		case SM_MGID_DESTROYED_TRAP:

			OSM_LOG(log, level,

				"Reporting Informational Notice \"%s\", MGID:%s\n",

				ib_get_trap_str(ntc->g_or_v.generic.trap_num),

				inet_ntop(AF_INET6, gid->raw, gid_str, sizeof gid_str));

			break;

		case SM_UNPATH_TRAP:

		case SM_REPATH_TRAP:

			/* TODO: Fill in details once SM starts to use these traps */

			OSM_LOG(log, level,

				"Reporting Informational Notice \"%s\"n",

				ib_get_trap_str(ntc->g_or_v.generic.trap_num));

			break;

		case SM_LINK_STATE_CHANGED_TRAP:

			OSM_LOG(log, level,

				"Reporting Urgent Notice \"%s\" from switch LID %u, "

				"GUID 0x%016" PRIx64 "\n",

				ib_get_trap_str(ntc->g_or_v.generic.trap_num),

				cl_ntoh16(ntc->issuer_lid),

				cl_ntoh64(gid->unicast.interface_id));

			break;

		case SM_LINK_INTEGRITY_THRESHOLD_TRAP:

		case SM_BUFFER_OVERRUN_THRESHOLD_TRAP:

		case SM_WATCHDOG_TIMER_EXPIRED_TRAP:

			OSM_LOG(log, level,

				"Reporting Urgent Notice \"%s\" from LID %u, "

				"GUID 0x%016" PRIx64 ", port %u\n",

				ib_get_trap_str(ntc->g_or_v.generic.trap_num),

				cl_ntoh16(ntc->issuer_lid),

				cl_ntoh64(gid->unicast.interface_id),

				ntc->data_details.ntc_129_131.port_num);

			break;

		case SM_LOCAL_CHANGES_TRAP:

			if (ntc->data_details.ntc_144.local_changes == 1)

				OSM_LOG(log, level,

					"Reporting Informational Notice \"%s\" from LID %u, "

					"GUID 0x%016" PRIx64 ", ChangeFlags 0x%04x, "

					"CapabilityMask2 0x%04x\n",

					ib_get_trap_str(ntc->g_or_v.generic.trap_num),

					cl_ntoh16(ntc->issuer_lid),

					cl_ntoh64(gid->unicast.interface_id),

					cl_ntoh16(ntc->data_details.ntc_144.change_flgs),

					cl_ntoh16(ntc->data_details.ntc_144.cap_mask2));

			else

				OSM_LOG(log, level,

					"Reporting Informational Notice \"%s\" from LID %u, "

					"GUID 0x%016" PRIx64 ", new CapabilityMask 0x%08x\n",

					ib_get_trap_str(ntc->g_or_v.generic.trap_num),

					cl_ntoh16(ntc->issuer_lid),

					cl_ntoh64(gid->unicast.interface_id),

					cl_ntoh32(ntc->data_details.ntc_144.new_cap_mask));

			break;

		case SM_SYS_IMG_GUID_CHANGED_TRAP:

			OSM_LOG(log, level,

				"Reporting Informational Notice \"%s\" from LID %u, "

				"GUID 0x%016" PRIx64 ", new SysImageGUID 0x%016" PRIx64 "\n",

				ib_get_trap_str(ntc->g_or_v.generic.trap_num),

				cl_ntoh16(ntc->issuer_lid),

				cl_ntoh64(gid->unicast.interface_id),

				cl_ntoh64(ntc->data_details.ntc_145.new_sys_guid));

			break;

		case SM_BAD_MKEY_TRAP:

			OSM_LOG(log, level,

				"Reporting Security Notice \"%s\" from LID %u, "

				"GUID 0x%016" PRIx64 ", Method 0x%x, Attribute 0x%x, "

				"AttrMod 0x%x, M_Key 0x%016" PRIx64 "\n",

				ib_get_trap_str(ntc->g_or_v.generic.trap_num),

				cl_ntoh16(ntc->issuer_lid),

				cl_ntoh64(gid->unicast.interface_id),

				ntc->data_details.ntc_256.method,

				cl_ntoh16(ntc->data_details.ntc_256.attr_id),

				cl_ntoh32(ntc->data_details.ntc_256.attr_mod),

				cl_ntoh64(ntc->data_details.ntc_256.mkey));

			break;

		case SM_BAD_PKEY_TRAP:

		case SM_BAD_QKEY_TRAP:

			gid1 = &ntc->data_details.ntc_257_258.gid1;

			gid2 = &ntc->data_details.ntc_257_258.gid2;

			OSM_LOG(log, level,

				"Reporting Security Notice \"%s\" from LID %u, "

				"GUID 0x%016" PRIx64 " : LID1 %u, LID2 %u, %s 0x%x, "

				"SL %d, QP1 0x%x, QP2 0x%x, GID1 %s, GID2 %s\n",

				ib_get_trap_str(ntc->g_or_v.generic.trap_num),

				cl_ntoh16(ntc->issuer_lid),

				cl_ntoh64(gid->unicast.interface_id),

				cl_ntoh16(ntc->data_details.ntc_257_258.lid1),

				cl_ntoh16(ntc->data_details.ntc_257_258.lid2),

				cl_ntoh16(ntc->g_or_v.generic.trap_num) == SM_BAD_QKEY_TRAP ?

					"Q_Key" : "P_Key",

				cl_ntoh32(ntc->data_details.ntc_257_258.key),

				cl_ntoh32(ntc->data_details.ntc_257_258.qp1) >> 28,

				cl_ntoh32(ntc->data_details.ntc_257_258.qp1) & 0xffffff,

				cl_ntoh32(ntc->data_details.ntc_257_258.qp2) & 0xffffff,

				inet_ntop(AF_INET6, gid1->raw, gid_str, sizeof gid_str),

				inet_ntop(AF_INET6, gid2->raw, gid_str2, sizeof gid_str2));

			break;

		case SM_BAD_SWITCH_PKEY_TRAP:

			gid1 = &ntc->data_details.ntc_259.gid1;

			gid2 = &ntc->data_details.ntc_259.gid2;

			OSM_LOG(log, level,

				"Reporting Security Notice \"%s\" from switch LID %u, "

				"GUID 0x%016" PRIx64 " port %d : data_valid 0x%04x, "

				"LID1 %u, LID2 %u, PKey 0x%04x, "

				"SL %d, QP1 0x%x, QP2 0x%x, GID1 %s, GID2 %s\n",

				ib_get_trap_str(ntc->g_or_v.generic.trap_num),

				cl_ntoh16(ntc->issuer_lid),

				cl_ntoh64(gid->unicast.interface_id),

				ntc->data_details.ntc_259.port_no,

				cl_ntoh16(ntc->data_details.ntc_259.data_valid),

				cl_ntoh16(ntc->data_details.ntc_259.lid1),

				cl_ntoh16(ntc->data_details.ntc_259.lid2),

				cl_ntoh16(ntc->data_details.ntc_257_258.key),

				cl_ntoh32(ntc->data_details.ntc_259.sl_qp1) >> 28,

				cl_ntoh32(ntc->data_details.ntc_259.sl_qp1) & 0xffffff,

				cl_ntoh32(ntc->data_details.ntc_259.qp2),

				inet_ntop(AF_INET6, gid1->raw, gid_str, sizeof gid_str),

				inet_ntop(AF_INET6, gid2->raw, gid_str2, sizeof gid_str2));

			break;

		default:

			OSM_LOG(log, level,

				"Reporting Generic Notice type:%u num:%u (%s)"

				" from LID:%u GID:%s\n",

				ib_notice_get_type(ntc),

				cl_ntoh16(ntc->g_or_v.generic.trap_num),

				ib_get_trap_str(ntc->g_or_v.generic.trap_num),

				cl_ntoh16(ntc->issuer_lid),

				inet_ntop(AF_INET6, gid->raw, gid_str, sizeof gid_str));

			break;

		}

	} else

		OSM_LOG(log, level,

			"Reporting Vendor Notice type:%u vend:%u dev:%u"

			" from LID:%u GID:%s\n",

			ib_notice_get_type(ntc),

			cl_ntoh32(ib_notice_get_vend_id(ntc)),

			cl_ntoh16(ntc->g_or_v.vend.dev_id),

			cl_ntoh16(ntc->issuer_lid),

			inet_ntop(AF_INET6, ntc->issuer_gid.raw, gid_str,

				  sizeof gid_str));

}

ib_api_status_t osm_report_notice(IN osm_log_t * p_log, IN osm_subn_t * p_subn,

				  IN ib_mad_notice_attr_t * p_ntc)

{

	osm_infr_match_ctxt_t context;

	cl_list_t infr_to_remove_list;

	osm_infr_t *p_infr_rec;

	osm_infr_t *p_next_infr_rec;

	OSM_LOG_ENTER(p_log);

	/*

	 * we must make sure we are ready for this...

	 * note that the trap receivers might be initialized before

	 * the osm_infr_init call is performed.

	 */

	if (p_subn->sa_infr_list.state != CL_INITIALIZED) {

		OSM_LOG(p_log, OSM_LOG_DEBUG,

			"Ignoring Notice Reports since Inform List is not initialized yet!\n");

		return IB_ERROR;

	}

	if (OSM_LOG_IS_ACTIVE_V2(p_log, OSM_LOG_INFO))

		log_notice(p_log, OSM_LOG_INFO, p_ntc);

	/* Create a list that will hold all the infr records that should

	   be removed due to violation. o13-17.1.2 */

	cl_list_construct(&infr_to_remove_list);

	cl_list_init(&infr_to_remove_list, 5);

	context.p_remove_infr_list = &infr_to_remove_list;

	context.p_ntc = p_ntc;

	/* go over all inform info available at the subnet */

	/* try match to the given notice and send if match */

	cl_qlist_apply_func(&p_subn->sa_infr_list, match_notice_to_inf_rec,

			    &context);

	/* If we inserted items into the infr_to_remove_list - we need to

	   remove them */

	p_infr_rec = (osm_infr_t *) cl_list_remove_head(&infr_to_remove_list);

	while (p_infr_rec != NULL) {

		p_next_infr_rec =

		    (osm_infr_t *) cl_list_remove_head(&infr_to_remove_list);

		osm_infr_remove_from_db(p_subn, p_log, p_infr_rec);

		p_infr_rec = p_next_infr_rec;

	}

	cl_list_destroy(&infr_to_remove_list);

	/* report IB traps to plugin */

	osm_opensm_report_event(p_subn->p_osm, OSM_EVENT_ID_TRAP, p_ntc);

	OSM_LOG_EXIT(p_log);

	return IB_SUCCESS;

}