/*

 * Copyright (c) 2006-2008 Voltaire, Inc. All rights reserved.

 * Copyright (c) 2012-2015 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.

 *

 */

/*

 * Abstract:

 *    Implementation of opensm partition management configuration

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif				/* HAVE_CONFIG_H */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <errno.h>

#include <ctype.h>

#include <iba/ib_types.h>

#include <opensm/osm_file_ids.h>

#define FILE_ID OSM_FILE_PRTN_CONFIG_C

#include <opensm/osm_base.h>

#include <opensm/osm_partition.h>

#include <opensm/osm_subnet.h>

#include <opensm/osm_log.h>

#include <arpa/inet.h>

typedef enum {

	LIMITED,

	FULL,

	BOTH

} membership_t;

const ib_gid_t osm_ipoib_broadcast_mgid = {

	{

	 0xff,			/*  multicast field */

	 0x12,			/*  non-permanent bit, link local scope */

	 0x40, 0x1b,		/*  IPv4 signature */

	 0xff, 0xff,		/*  16 bits of P_Key (to be filled in) */

	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  48 bits of zeros */

	 0xff, 0xff, 0xff, 0xff,	/*  32 bit IPv4 broadcast address */

	 },

};

struct group_flags {

	unsigned mtu, rate, sl, scope_mask;

	uint32_t Q_Key;

	uint8_t TClass;

	uint32_t FlowLabel;

};

struct precreate_mgroup {

	ib_gid_t mgid;

	struct group_flags flags;

};

struct part_conf {

	osm_log_t *p_log;

	osm_subn_t *p_subn;

	osm_prtn_t *p_prtn;

	unsigned is_ipoib;

	struct group_flags flags;

	membership_t membership;

	boolean_t indx0;

};

extern osm_prtn_t *osm_prtn_make_new(osm_log_t * p_log, osm_subn_t * p_subn,

				     const char *name, uint16_t pkey);

extern ib_api_status_t osm_prtn_add_all(osm_log_t * p_log, osm_subn_t * p_subn,

					osm_prtn_t * p, unsigned type,

					boolean_t full, boolean_t indx0);

extern ib_api_status_t osm_prtn_add_port(osm_log_t * p_log,

					 osm_subn_t * p_subn, osm_prtn_t * p,

					 ib_net64_t guid, boolean_t full,

					 boolean_t indx0);

ib_api_status_t osm_prtn_add_mcgroup(osm_log_t * p_log, osm_subn_t * p_subn,

				     osm_prtn_t * p, uint8_t rate, uint8_t mtu,

				     uint8_t sl, uint8_t scope, uint32_t Q_Key,

				     uint8_t TClass, uint32_t FlowLabel,

				     const ib_gid_t *mgid);

static inline boolean_t mgid_is_broadcast(const ib_gid_t *mgid)

{

	return (memcmp(mgid, &osm_ipoib_broadcast_mgid,

			sizeof(osm_ipoib_broadcast_mgid)) == 0);

}

static inline boolean_t mgid_is_ip(const ib_gid_t *mgid)

{

	ib_net16_t ipsig = mgid->ip_multicast.signature;

	return (ipsig == cl_hton16(0x401b) || ipsig == cl_hton16(0x601b));

}

static inline boolean_t ip_mgroup_pkey_ok(struct part_conf *conf,

					  struct precreate_mgroup *group)

{

	ib_net16_t mpkey = group->mgid.ip_multicast.p_key;

	char gid_str[INET6_ADDRSTRLEN];

	if (mgid_is_broadcast(&group->mgid)

	    /* user requested "wild card" of pkey */

	    || mpkey == 0x0000

	    /* user was smart enough to match */

	    || mpkey == (conf->p_prtn->pkey | cl_hton16(0x8000)))

		return (TRUE);

	OSM_LOG(conf->p_log, OSM_LOG_ERROR,

		"IP MC group (%s) specified with invalid pkey 0x%04x "

		"for partition pkey = 0x%04x (%s)\n",

		inet_ntop(AF_INET6, group->mgid.raw, gid_str, sizeof gid_str),

		cl_ntoh16(mpkey), cl_ntoh16(conf->p_prtn->pkey), conf->p_prtn->name);

	return (FALSE);

}

static inline boolean_t ip_mgroup_rate_ok(struct part_conf *conf,

				struct precreate_mgroup *group)

{

	char gid_str[INET6_ADDRSTRLEN];

	if (group->flags.rate == conf->flags.rate)

		return (TRUE);

	OSM_LOG(conf->p_log, OSM_LOG_ERROR,

		"IP MC group (%s) specified with invalid rate (%d): "

		"partition pkey = 0x%04x (%s) "

		"[Partition broadcast group rate = %d]\n",

		inet_ntop(AF_INET6, group->mgid.raw, gid_str, sizeof gid_str),

		group->flags.rate, cl_ntoh16(conf->p_prtn->pkey),

		conf->p_prtn->name, conf->flags.rate);

	return (FALSE);

}

static inline boolean_t ip_mgroup_mtu_ok(struct part_conf *conf,

				struct precreate_mgroup *group)

{

	char gid_str[INET6_ADDRSTRLEN];

	if (group->flags.mtu == conf->flags.mtu)

		return (TRUE);

	OSM_LOG(conf->p_log, OSM_LOG_ERROR,

		"IP MC group (%s) specified with invalid mtu (%d): "

		"partition pkey = 0x%04x (%s) "

		"[Partition broadcast group mtu = %d]\n",

		inet_ntop(AF_INET6, group->mgid.raw, gid_str, sizeof gid_str),

		group->flags.mtu, cl_ntoh16(conf->p_prtn->pkey),

		conf->p_prtn->name, conf->flags.mtu);

	return (FALSE);

}

static void __create_mgrp(struct part_conf *conf, struct precreate_mgroup *group)

{

	unsigned int scope;

	if (!group->flags.scope_mask) {

		osm_prtn_add_mcgroup(conf->p_log, conf->p_subn, conf->p_prtn,

				     (uint8_t) group->flags.rate,

				     (uint8_t) group->flags.mtu,

				     group->flags.sl,

				     0,

				     group->flags.Q_Key,

				     group->flags.TClass,

				     group->flags.FlowLabel,

				     &group->mgid);

	} else {

		for (scope = 0; scope < 16; scope++) {

			if (((1<<scope) & group->flags.scope_mask) == 0)

				continue;

			osm_prtn_add_mcgroup(conf->p_log, conf->p_subn, conf->p_prtn,

					     (uint8_t)group->flags.rate,

					     (uint8_t)group->flags.mtu,

					     (uint8_t)group->flags.sl,

					     (uint8_t)scope,

					     group->flags.Q_Key,

					     group->flags.TClass,

					     group->flags.FlowLabel,

					     &group->mgid);

		}

	}

}

static int partition_create(unsigned lineno, struct part_conf *conf,

			    char *name, char *id, char *flag, char *flag_val)

{

	ib_net16_t pkey;

	if (!id && name && isdigit(*name)) {

		id = name;

		name = NULL;

	}

	if (id) {

		char *end;

		pkey = cl_hton16((uint16_t)strtoul(id, &end, 0));

		if (end == id || *end)

			return -1;

	} else

		pkey = 0;

	conf->p_prtn = osm_prtn_make_new(conf->p_log, conf->p_subn,

					 name, pkey);

	if (!conf->p_prtn)

		return -1;

	if (!conf->p_subn->opt.qos && conf->flags.sl != OSM_DEFAULT_SL) {

		OSM_LOG(conf->p_log, OSM_LOG_DEBUG, "Overriding SL %d"

			" to default SL %d on partition %s"

			" as QoS is not enabled.\n",

			conf->flags.sl, OSM_DEFAULT_SL, name);

		conf->flags.sl = OSM_DEFAULT_SL;

	}

	conf->p_prtn->sl = (uint8_t) conf->flags.sl;

	if (conf->is_ipoib) {

		struct precreate_mgroup broadcast_mgroup;

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

		broadcast_mgroup.mgid = osm_ipoib_broadcast_mgid;

		pkey = CL_HTON16(0x8000) | conf->p_prtn->pkey;

		memcpy(&broadcast_mgroup.mgid.raw[4], &pkey , sizeof(pkey));

		broadcast_mgroup.flags.mtu = conf->flags.mtu;

		broadcast_mgroup.flags.rate = conf->flags.rate;

		broadcast_mgroup.flags.sl = conf->flags.sl;

		broadcast_mgroup.flags.Q_Key = conf->flags.Q_Key ?

						conf->flags.Q_Key :

						OSM_IPOIB_BROADCAST_MGRP_QKEY;

		broadcast_mgroup.flags.TClass = conf->flags.TClass;

		broadcast_mgroup.flags.FlowLabel = conf->flags.FlowLabel;

		__create_mgrp(conf, &broadcast_mgroup);

	}

	return 0;

}

static unsigned long int verify_val(unsigned lineno, osm_log_t *p_log,

					char *flag, char *val)

{

	char *end;

	unsigned long int ret = strtoul(val, &end, 0);

	if (val && *end)

		OSM_LOG(p_log, OSM_LOG_VERBOSE,

			"PARSE WARN: line %d: "

			"suspicious val=(%s) detected. "

			"flag=(%s)\n", lineno, val, flag);

	return ret;

}

/* returns 1 if processed 0 if _not_ */

static int parse_group_flag(unsigned lineno, osm_log_t * p_log,

			    struct group_flags *flags,

			    char *flag, char *val)

{

	int rc = 0;

	int len = strlen(flag);

	if (!strncmp(flag, "mtu", len)) {

		rc = 1;

		if (!val || (flags->mtu = verify_val(lineno, p_log, flag, val)) == 0)

			OSM_LOG(p_log, OSM_LOG_VERBOSE,

				"PARSE WARN: line %d: "

				"flag \'mtu\' requires valid value"

				" - skipped\n", lineno);

	} else if (!strncmp(flag, "rate", len)) {

		rc = 1;

		if (!val || (flags->rate = verify_val(lineno, p_log, flag, val)) == 0)

			OSM_LOG(p_log, OSM_LOG_VERBOSE,

				"PARSE WARN: line %d: "

				"flag \'rate\' requires valid value"

				" - skipped\n", lineno);

	} else if (!strncmp(flag, "scope", len)) {

		unsigned int scope;

		rc = 1;

		if (!val || (scope = verify_val(lineno, p_log, flag, val)) == 0 || scope > 0xF)

			OSM_LOG(p_log, OSM_LOG_VERBOSE,

				"PARSE WARN: line %d: "

				"flag \'scope\' requires valid value"

				" - skipped\n", lineno);

		else

			flags->scope_mask |= (1<

	} else if (!strncmp(flag, "Q_Key", strlen(flag))) {

		rc = 1;

		if (!val || (flags->Q_Key = verify_val(lineno, p_log, flag, val)) == 0)

			OSM_LOG(p_log, OSM_LOG_VERBOSE,

				"PARSE WARN: line %d: "

				"flag \'Q_Key\' requires valid value"

				" - using '0'\n", lineno);

	} else if (!strncmp(flag, "TClass", strlen(flag))) {

		rc = 1;

		if (!val || (flags->TClass = verify_val(lineno, p_log, flag, val)) == 0)

			OSM_LOG(p_log, OSM_LOG_VERBOSE,

				"PARSE WARN: line %d: "

				"flag \'TClass\' requires valid value"

				" - using '0'\n", lineno);

	} else if (!strncmp(flag, "sl", len)) {

		unsigned sl;

		char *end;

		rc = 1;

		if (!val || !*val || (sl = strtoul(val, &end, 0)) > 15 ||

		    (*end && !isspace(*end)))

			OSM_LOG(p_log, OSM_LOG_VERBOSE,

				"PARSE WARN: line %d: "

				"flag \'sl\' requires valid value"

				" - skipped\n", lineno);

		else

			flags->sl = sl;

	} else if (!strncmp(flag, "FlowLabel", len)) {

		uint32_t FlowLabel;

		char *end;

		rc = 1;

		if (!val || !*val ||

		    (FlowLabel = strtoul(val, &end, 0)) > 0xFFFFF ||

		    (*end && !isspace(*end)))

			OSM_LOG(p_log, OSM_LOG_VERBOSE,

				"PARSE WARN: line %d: "

				"flag \'FlowLabel\' requires valid value"

				" - skipped\n", lineno);

		else

			flags->FlowLabel = FlowLabel;

	}

	return rc;

}

static int partition_add_flag(unsigned lineno, struct part_conf *conf,

			      char *flag, char *val)

{

	int len = strlen(flag);

	/* ipoib gc group flags are processed here. */

	if (parse_group_flag(lineno, conf->p_log, &conf->flags, flag, val))

		return 0;

	/* partition flags go here. */

	if (!strncmp(flag, "ipoib", len)) {

		conf->is_ipoib = 1;

	} else if (!strncmp(flag, "defmember", len)) {

		if (!val || (strncmp(val, "limited", strlen(val))

			     && strncmp(val, "both", strlen(val))

			     && strncmp(val, "full", strlen(val))))

			OSM_LOG(conf->p_log, OSM_LOG_VERBOSE,

				"PARSE WARN: line %d: "

				"flag \'defmember\' requires valid value (limited or full or both)"

				" - skipped\n", lineno);

		else {

			if (!strncmp(val, "full", strlen(val)))

				conf->membership = FULL;

			else if (!strncmp(val, "both", strlen(val)))

				conf->membership = BOTH;

			else

				conf->membership = LIMITED;

		}

	} else if (!strcmp(flag, "indx0"))

		conf->indx0 = TRUE;

	else {

		OSM_LOG(conf->p_log, OSM_LOG_VERBOSE,

			"PARSE WARN: line %d: "

			"unrecognized partition flag \'%s\'"

			" - ignored\n", lineno, flag);

	}

	return 0;

}

static void manage_membership_change(struct part_conf *conf, osm_prtn_t * p,

				     unsigned type, membership_t membership,

				     ib_net64_t guid)

{

	cl_map_t *p_tbl;

	cl_map_iterator_t p_next, p_item;

	osm_physp_t *p_physp;

	/* In allow_both_pkeys mode */

	/* if membership of the PKEY is set to FULL */

	/* need to clean up the part_guid_tbl table entry for this guid */

	/* if membership of the PKEY is set to LIMITED */

	/* need to clean up the full_guid_tbl table entry for this guid */

	/* as it could be populated because of previous definitions */

	if (!conf->p_subn->opt.allow_both_pkeys || membership == BOTH)

		return;

	switch (type){

	/* ALL = 0 */

	case 0:

		cl_map_remove_all(membership == LIMITED ?

				  &p->full_guid_tbl : &p->part_guid_tbl);

		break;

	/* specific GUID */

	case 0xFF:

		cl_map_remove(membership == LIMITED ?

			      &p->full_guid_tbl : &p->part_guid_tbl,

			      cl_hton64(guid));

		break;

	case IB_NODE_TYPE_CA:

	case IB_NODE_TYPE_SWITCH:

	case IB_NODE_TYPE_ROUTER:

		p_tbl = (membership == LIMITED) ?

			 &p->full_guid_tbl : &p->part_guid_tbl;

		p_next = cl_map_head(p_tbl);

		while (p_next != cl_map_end(p_tbl)) {

			p_item = p_next;

			p_next = cl_map_next(p_item);

			p_physp = (osm_physp_t *) cl_map_obj(p_item);

			if (osm_node_get_type(p_physp->p_node) == type)

				cl_map_remove_item(p_tbl, p_item);

		}

		break;

	default:

		break;

	}

}

static int partition_add_all(struct part_conf *conf, osm_prtn_t * p,

			     unsigned type, membership_t membership)

{

	manage_membership_change(conf, p, type, membership, 0);

	if (membership != LIMITED &&

	    osm_prtn_add_all(conf->p_log, conf->p_subn, p, type, TRUE, conf->indx0) != IB_SUCCESS)

		return -1;

	if ((membership == LIMITED ||

	     (membership == BOTH && conf->p_subn->opt.allow_both_pkeys)) &&

	    osm_prtn_add_all(conf->p_log, conf->p_subn, p, type, FALSE, conf->indx0) != IB_SUCCESS)

		return -1;

	return 0;

}

static int partition_add_port(unsigned lineno, struct part_conf *conf,

			      char *name, char *flag)

{

	osm_prtn_t *p = conf->p_prtn;

	ib_net64_t guid;

	membership_t membership = conf->membership;

	if (!name || !*name || !strncmp(name, "NONE", strlen(name)))

		return 0;

	if (flag) {

		/* reset default membership to limited */

		membership = LIMITED;

		if (!strncmp(flag, "full", strlen(flag)))

			membership = FULL;

		else if (!strncmp(flag, "both", strlen(flag)))

			membership = BOTH;

		else if (strncmp(flag, "limited", strlen(flag))) {

			OSM_LOG(conf->p_log, OSM_LOG_VERBOSE,

				"PARSE WARN: line %d: "

				"unrecognized port flag \'%s\'."

				" Assume \'limited\'\n", lineno, flag);

		}

	}

	if (!strncmp(name, "ALL", strlen(name)))

		return partition_add_all(conf, p, 0, membership);

	else if (!strncmp(name, "ALL_CAS", strlen(name)))

		return partition_add_all(conf, p, IB_NODE_TYPE_CA, membership);

	else if (!strncmp(name, "ALL_SWITCHES", strlen(name)))

		return partition_add_all(conf, p, IB_NODE_TYPE_SWITCH,

					 membership);

	else if (!strncmp(name, "ALL_ROUTERS", strlen(name)))

		return partition_add_all(conf, p, IB_NODE_TYPE_ROUTER,

					 membership);

	else if (!strncmp(name, "SELF", strlen(name))) {

		guid = cl_ntoh64(conf->p_subn->sm_port_guid);

	} else {

		char *end;

		guid = strtoull(name, &end, 0);

		if (!guid || *end)

			return -1;

	}

	manage_membership_change(conf, p, 0xFF, membership, guid);

	if (membership != LIMITED &&

	    osm_prtn_add_port(conf->p_log, conf->p_subn, p,

			      cl_hton64(guid), TRUE, conf->indx0) != IB_SUCCESS)

		return -1;

	if ((membership == LIMITED ||

	    (membership == BOTH && conf->p_subn->opt.allow_both_pkeys)) &&

	    osm_prtn_add_port(conf->p_log, conf->p_subn, p,

			      cl_hton64(guid), FALSE, conf->indx0) != IB_SUCCESS)

		return -1;

	return 0;

}

/* conf file parser */

#define STRIP_HEAD_SPACES(p) while (*(p) == ' ' || *(p) == '\t' || \

		*(p) == '\n') { (p)++; }

#define STRIP_TAIL_SPACES(p) { char *q = (p) + strlen(p); \

				while ( q != (p) && ( *q == '\0' || \

					*q == ' ' || *q == '\t' || \

					*q == '\n')) { *q-- = '\0'; }; }

static int parse_name_token(char *str, char **name, char **val)

{

	int len = 0;

	char *p, *q;

	*name = *val = NULL;

	p = str;

	while (*p == ' ' || *p == '\t' || *p == '\n')

		p++;

	q = strchr(p, '=');

	if (q)

		*q++ = '\0';

	len = strlen(str) + 1;

	str = q;

	q = p + strlen(p);

	while (q != p && (*q == '\0' || *q == ' ' || *q == '\t' || *q == '\n'))

		*q-- = '\0';

	*name = p;

	p = str;

	if (!p)

		return len;

	while (*p == ' ' || *p == '\t' || *p == '\n')

		p++;

	q = p + strlen(p);

	len += (int)(q - str) + 1;

	while (q != p && (*q == '\0' || *q == ' ' || *q == '\t' || *q == '\n'))

		*q-- = '\0';

	*val = p;

	return len;

}

static int parse_mgroup_flags(osm_log_t * p_log,

				struct precreate_mgroup *mgroup,

				char *p, unsigned lineno)

{

	int ret, len = 0;

	char *flag, *val, *q;

	do {

		flag = val = NULL;

		q = strchr(p, ',');

		if (q)

			*q++ = '\0';

		ret = parse_name_token(p, &flag, &val;;

		if (!parse_group_flag(lineno, p_log, &mgroup->flags,

				     flag, val)) {

			OSM_LOG(p_log, OSM_LOG_VERBOSE,

				"PARSE WARN: line %d: "

				"unrecognized mgroup flag \'%s\'"

				" - ignored\n", lineno, flag);

		}

		p += ret;

		len += ret;

	} while (q);

	return (len);

}

static int mgroup_create(char *p, char *mgid, unsigned lineno, struct part_conf *conf)

{

	int ret = 0;

	struct precreate_mgroup mgroup;

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

	if (inet_pton(AF_INET6, mgid, &mgroup.mgid) != 1

	    || mgroup.mgid.raw[0] != 0xff) {

		OSM_LOG(conf->p_log, OSM_LOG_ERROR,

			"PARSE ERROR partition conf file line %d: "

			"mgid \"%s\": gid is not multicast\n", lineno, mgid);

		return 0;

	}

	/* inherit partition flags */

	mgroup.flags.mtu = conf->flags.mtu;

	mgroup.flags.rate = conf->flags.rate;

	mgroup.flags.sl = conf->flags.sl;

	mgroup.flags.Q_Key = conf->flags.Q_Key;

	mgroup.flags.FlowLabel = conf->flags.FlowLabel;

	mgroup.flags.scope_mask = conf->flags.scope_mask;

	/* override with user specified flags */

	ret = parse_mgroup_flags(conf->p_log, &mgroup, p, lineno);

	/* check/verify special IP group parameters */

	if (mgid_is_ip(&mgroup.mgid)) {

		ib_net16_t pkey = conf->p_prtn->pkey | cl_hton16(0x8000);

		if (!ip_mgroup_pkey_ok(conf, &mgroup)

		    || !ip_mgroup_rate_ok(conf, &mgroup)

		    || !ip_mgroup_mtu_ok(conf, &mgroup))

			goto error;

		/* set special IP settings */

		memcpy(&mgroup.mgid.raw[4], &pkey, sizeof(pkey));

		if (mgroup.flags.Q_Key == 0)

			mgroup.flags.Q_Key = OSM_IPOIB_BROADCAST_MGRP_QKEY;

	}

	/* don't create multiple copies of the group */

	if (osm_get_mgrp_by_mgid(conf->p_subn, &mgroup.mgid))

		goto error;

	/* create the group */

	__create_mgrp(conf, &mgroup);

error:

	return ret;

}

static struct part_conf *new_part_conf(osm_log_t * p_log, osm_subn_t * p_subn)

{

	static struct part_conf part;

	struct part_conf *conf = ∂

	memset(conf, 0, sizeof(*conf));

	conf->p_log = p_log;

	conf->p_subn = p_subn;

	conf->p_prtn = NULL;

	conf->is_ipoib = 0;

	conf->flags.sl = OSM_DEFAULT_SL;

	conf->flags.rate = OSM_DEFAULT_MGRP_RATE;

	conf->flags.mtu = OSM_DEFAULT_MGRP_MTU;

	conf->membership = LIMITED;

	conf->indx0 = FALSE;

	return conf;

}

static int flush_part_conf(struct part_conf *conf)

{

	memset(conf, 0, sizeof(*conf));

	return 0;

}

static int parse_part_conf(struct part_conf *conf, char *str, int lineno)

{

	int ret, len = 0;

	char *name, *id, *flag, *flval;

	char *q, *p;

	p = str;

	if (*p == '\t' || *p == '\0' || *p == '\n')

		p++;

	len += (int)(p - str);

	str = p;

	if (conf->p_prtn)

		goto skip_header;

	q = strchr(p, ':');

	if (!q) {

		OSM_LOG(conf->p_log, OSM_LOG_ERROR, "PARSE ERROR: line %d: "

			"no partition definition found\n", lineno);

		fprintf(stderr, "\nPARSE ERROR: line %d: "

			"no partition definition found\n", lineno);

		return -1;

	}

	*q++ = '\0';

	str = q;

	name = id = flag = flval = NULL;

	q = strchr(p, ',');

	if (q)

		*q = '\0';

	ret = parse_name_token(p, &name, &id;;

	p += ret;

	len += ret;

	while (q) {

		flag = flval = NULL;

		q = strchr(p, ',');

		if (q)

			*q++ = '\0';

		ret = parse_name_token(p, &flag, &flval);

		if (!flag) {

			OSM_LOG(conf->p_log, OSM_LOG_ERROR,

				"PARSE ERROR: line %d: "

				"bad partition flags\n", lineno);

			fprintf(stderr, "\nPARSE ERROR: line %d: "

				"bad partition flags\n", lineno);

			return -1;

		}

		p += ret;

		len += ret;

		partition_add_flag(lineno, conf, flag, flval);

	}

	if (p != str || (partition_create(lineno, conf,

					  name, id, flag, flval) < 0)) {

		OSM_LOG(conf->p_log, OSM_LOG_ERROR, "PARSE ERROR: line %d: "

			"bad partition definition\n", lineno);

		fprintf(stderr, "\nPARSE ERROR: line %d: "

			"bad partition definition\n", lineno);

		return -1;

	}

skip_header:

	do {

		name = flag = NULL;

		q = strchr(p, ',');

		if (q)

			*q++ = '\0';

		ret = parse_name_token(p, &name, &flag;;

		len += ret;

		if (strcmp(name, "mgid") == 0) {

			/* parse an mgid line if specified. */

			len += mgroup_create(p+ret, flag, lineno, conf);

			goto done; /* We're done: this consumes the line */

		}

		if (partition_add_port(lineno, conf, name, flag) < 0) {

			OSM_LOG(conf->p_log, OSM_LOG_ERROR,

				"PARSE ERROR: line %d: "

				"bad PortGUID\n", lineno);

			fprintf(stderr, "PARSE ERROR: line %d: "

				"bad PortGUID\n", lineno);

			return -1;

		}

		p += ret;

	} while (q);

done:

	return len;

}

/**

 * @return 1 on error, 0 on success

 */

int osm_prtn_config_parse_file(osm_log_t * p_log, osm_subn_t * p_subn,

			       const char *file_name)

{

	char line[4096];

	struct part_conf *conf = NULL;

	FILE *file;

	int lineno;

	int is_parse_success;

	line[0] = '\0';

	file = fopen(file_name, "r");

	if (!file) {

		OSM_LOG(p_log, OSM_LOG_VERBOSE,

			"Cannot open config file \'%s\': %s\n",

			file_name, strerror(errno));

		return -1;

	}

	lineno = 0;

	is_parse_success = 0;

	while (fgets(line, sizeof(line) - 1, file) != NULL) {

		char *q, *p = line;

		lineno++;

		p = line;

		q = strchr(p, '#');

		if (q)

			*q = '\0';

		do {

			int len;

			while (*p == ' ' || *p == '\t' || *p == '\n')

				p++;

			if (*p == '\0')

				break;

			if (!conf && !(conf = new_part_conf(p_log, p_subn))) {

				OSM_LOG(p_log, OSM_LOG_ERROR,

					"PARSE ERROR: line %d: "

					"internal: cannot create config\n",

					lineno);

				fprintf(stderr,

					"PARSE ERROR: line %d: "

					"internal: cannot create config\n",

					lineno);

				is_parse_success = -1;

				break;

			}

			q = strchr(p, ';');

			if (q)

				*q = '\0';

			len = parse_part_conf(conf, p, lineno);

			if (len < 0) {

				is_parse_success = -1;

				break;

			}

			is_parse_success = 1;

			p += len;

			if (q) {

				flush_part_conf(conf);

				conf = NULL;

			}

		} while (q);

		if (is_parse_success == -1)

			break;

	}

	fclose(file);

	return (is_parse_success == 1) ? 0 : 1;

}