/**

 * @file port.c

 * @note Copyright (C) 2011 Richard Cochran <richardcochran@gmail.com>

 *

 * 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 2 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, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#include <arpa/inet.h>

#include <errno.h>

#include <malloc.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/queue.h>

#include <net/if.h>

#include "bmc.h"

#include "clock.h"

#include "filter.h"

#include "missing.h"

#include "msg.h"

#include "phc.h"

#include "port.h"

#include "port_private.h"

#include "print.h"

#include "rtnl.h"

#include "sk.h"

#include "tc.h"

#include "tlv.h"

#include "tmv.h"

#include "tsproc.h"

#include "unicast_client.h"

#include "unicast_service.h"

#include "util.h"

#define ALLOWED_LOST_RESPONSES 3

#define ANNOUNCE_SPAN 1

enum syfu_event {

	SYNC_MISMATCH,

	SYNC_MATCH,

	FUP_MISMATCH,

	FUP_MATCH,

};

static int port_capable(struct port *p);

static int port_is_ieee8021as(struct port *p);

static void port_nrate_initialize(struct port *p);

static int announce_compare(struct ptp_message *m1, struct ptp_message *m2)

{

	struct announce_msg *a = &m1->announce, *b = &m2->announce;

	int len =

		sizeof(a->grandmasterPriority1) +

		sizeof(a->grandmasterClockQuality) +

		sizeof(a->grandmasterPriority2) +

		sizeof(a->grandmasterIdentity) +

		sizeof(a->stepsRemoved);

	return memcmp(&a->grandmasterPriority1, &b->grandmasterPriority1, len);

}

static void announce_to_dataset(struct ptp_message *m, struct port *p,

				struct dataset *out)

{

	struct announce_msg *a = &m->announce;

	out->priority1    = a->grandmasterPriority1;

	out->identity     = a->grandmasterIdentity;

	out->quality      = a->grandmasterClockQuality;

	out->priority2    = a->grandmasterPriority2;

	out->localPriority = p->localPriority;

	out->stepsRemoved = a->stepsRemoved;

	out->sender       = m->header.sourcePortIdentity;

	out->receiver     = p->portIdentity;

}

int clear_fault_asap(struct fault_interval *faint)

{

	switch (faint->type) {

	case FTMO_LINEAR_SECONDS:

		return faint->val == 0 ? 1 : 0;

	case FTMO_LOG2_SECONDS:

		return faint->val == FRI_ASAP ? 1 : 0;

	case FTMO_CNT:

		return 0;

	}

	return 0;

}

static void extract_address(struct ptp_message *m, struct PortAddress *paddr)

{

	int len = 0;

	switch (paddr->networkProtocol) {

	case TRANS_UDP_IPV4:

		len = sizeof(m->address.sin.sin_addr.s_addr);

		memcpy(paddr->address, &m->address.sin.sin_addr.s_addr, len);

		break;

	case TRANS_UDP_IPV6:

		len = sizeof(m->address.sin6.sin6_addr.s6_addr);

		memcpy(paddr->address, &m->address.sin6.sin6_addr.s6_addr, len);

		break;

	case TRANS_IEEE_802_3:

		len = MAC_LEN;

		memcpy(paddr->address, &m->address.sll.sll_addr, len);

		break;

	default:

		return;

	}

	paddr->addressLength = len;

}

static int msg_current(struct ptp_message *m, struct timespec now)

{

	int64_t t1, t2, tmo;

	t1 = m->ts.host.tv_sec * NSEC2SEC + m->ts.host.tv_nsec;

	t2 = now.tv_sec * NSEC2SEC + now.tv_nsec;

	if (m->header.logMessageInterval < -63) {

		tmo = 0;

	} else if (m->header.logMessageInterval > 31) {

		tmo = INT64_MAX;

	} else if (m->header.logMessageInterval < 0) {

		tmo = 4LL * NSEC2SEC / (1 << -m->header.logMessageInterval);

	} else {

		tmo = 4LL * (1 << m->header.logMessageInterval) * NSEC2SEC;

	}

	return t2 - t1 < tmo;

}

static int msg_source_equal(struct ptp_message *m1, struct foreign_clock *fc)

{

	struct PortIdentity *id1, *id2;

	id1 = &m1->header.sourcePortIdentity;

	id2 = &fc->dataset.sender;

	return 0 == memcmp(id1, id2, sizeof(*id1));

}

int source_pid_eq(struct ptp_message *m1, struct ptp_message *m2)

{

	return pid_eq(&m1->header.sourcePortIdentity,

		      &m2->header.sourcePortIdentity);

}

enum fault_type last_fault_type(struct port *port)

{

	return port->last_fault_type;

}

void fault_interval(struct port *port, enum fault_type ft,

		    struct fault_interval *i)

{

	i->type = port->flt_interval_pertype[ft].type;

	i->val = port->flt_interval_pertype[ft].val;

}

int port_fault_fd(struct port *port)

{

	return port->fault_fd;

}

struct fdarray *port_fda(struct port *port)

{

	return &port->fda;

}

int set_tmo_log(int fd, unsigned int scale, int log_seconds)

{

	struct itimerspec tmo = {

		{0, 0}, {0, 0}

	};

	uint64_t ns;

	int i;

	if (log_seconds < 0) {

		log_seconds *= -1;

		for (i = 1, ns = scale * 500000000ULL; i < log_seconds; i++) {

			ns >>= 1;

		}

		tmo.it_value.tv_nsec = ns;

		while (tmo.it_value.tv_nsec >= NS_PER_SEC) {

			tmo.it_value.tv_nsec -= NS_PER_SEC;

			tmo.it_value.tv_sec++;

		}

	} else

		tmo.it_value.tv_sec = scale * (1 << log_seconds);

	return timerfd_settime(fd, 0, &tmo, NULL);

}

int set_tmo_lin(int fd, int seconds)

{

	struct itimerspec tmo = {

		{0, 0}, {0, 0}

	};

	tmo.it_value.tv_sec = seconds;

	return timerfd_settime(fd, 0, &tmo, NULL);

}

int set_tmo_random(int fd, int min, int span, int log_seconds)

{

	uint64_t value_ns, min_ns, span_ns;

	struct itimerspec tmo = {

		{0, 0}, {0, 0}

	};

	if (log_seconds >= 0) {

		min_ns = min * NS_PER_SEC << log_seconds;

		span_ns = span * NS_PER_SEC << log_seconds;

	} else {

		min_ns = min * NS_PER_SEC >> -log_seconds;

		span_ns = span * NS_PER_SEC >> -log_seconds;

	}

	value_ns = min_ns + (span_ns * (random() % (1 << 15) + 1) >> 15);

	tmo.it_value.tv_sec = value_ns / NS_PER_SEC;

	tmo.it_value.tv_nsec = value_ns % NS_PER_SEC;

	return timerfd_settime(fd, 0, &tmo, NULL);

}

int port_set_fault_timer_log(struct port *port,

			     unsigned int scale, int log_seconds)

{

	return set_tmo_log(port->fault_fd, scale, log_seconds);

}

int port_set_fault_timer_lin(struct port *port, int seconds)

{

	return set_tmo_lin(port->fault_fd, seconds);

}

void fc_clear(struct foreign_clock *fc)

{

	struct ptp_message *m;

	while (fc->n_messages) {

		m = TAILQ_LAST(&fc->messages, messages);

		TAILQ_REMOVE(&fc->messages, m, list);

		fc->n_messages--;

		msg_put(m);

	}

}

static void fc_prune(struct foreign_clock *fc)

{

	struct timespec now;

	struct ptp_message *m;

	clock_gettime(CLOCK_MONOTONIC, &now;;

	while (fc->n_messages > FOREIGN_MASTER_THRESHOLD) {

		m = TAILQ_LAST(&fc->messages, messages);

		TAILQ_REMOVE(&fc->messages, m, list);

		fc->n_messages--;

		msg_put(m);

	}

	while (!TAILQ_EMPTY(&fc->messages)) {

		m = TAILQ_LAST(&fc->messages, messages);

		if (msg_current(m, now))

			break;

		TAILQ_REMOVE(&fc->messages, m, list);

		fc->n_messages--;

		msg_put(m);

	}

}

static int delay_req_current(struct ptp_message *m, struct timespec now)

{

	int64_t t1, t2, tmo = 5 * NSEC2SEC;

	t1 = m->ts.host.tv_sec * NSEC2SEC + m->ts.host.tv_nsec;

	t2 = now.tv_sec * NSEC2SEC + now.tv_nsec;

	return t2 - t1 < tmo;

}

void delay_req_prune(struct port *p)

{

	struct timespec now;

	struct ptp_message *m;

	clock_gettime(CLOCK_MONOTONIC, &now;;

	while (!TAILQ_EMPTY(&p->delay_req)) {

		m = TAILQ_LAST(&p->delay_req, delay_req);

		if (delay_req_current(m, now)) {

			break;

		}

		TAILQ_REMOVE(&p->delay_req, m, list);

		msg_put(m);

	}

}

void ts_add(tmv_t *ts, Integer64 correction)

{

	if (!correction) {

		return;

	}

	*ts = tmv_add(*ts, correction_to_tmv(correction));

}

/*

 * Returns non-zero if the announce message is different than last.

 */

static int add_foreign_master(struct port *p, struct ptp_message *m)

{

	struct foreign_clock *fc;

	struct ptp_message *tmp;

	int broke_threshold = 0, diff = 0;

	LIST_FOREACH(fc, &p->foreign_masters, list) {

		if (msg_source_equal(m, fc)) {

			break;

		}

	}

	if (!fc) {

		pr_notice("port %hu: new foreign master %s", portnum(p),

			pid2str(&m->header.sourcePortIdentity));

		fc = malloc(sizeof(*fc));

		if (!fc) {

			pr_err("low memory, failed to add foreign master");

			return 0;

		}

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

		TAILQ_INIT(&fc->messages);

		LIST_INSERT_HEAD(&p->foreign_masters, fc, list);

		fc->port = p;

		fc->dataset.sender = m->header.sourcePortIdentity;

		/* We do not count this first message, see 9.5.3(b) */

		return 0;

	}

	/*

	 * If this message breaks the threshold, that is an important change.

	 */

	fc_prune(fc);

	if (FOREIGN_MASTER_THRESHOLD - 1 == fc->n_messages) {

		broke_threshold = 1;

	}

	/*

	 * Okay, go ahead and add this announcement.

	 */

	msg_get(m);

	fc->n_messages++;

	TAILQ_INSERT_HEAD(&fc->messages, m, list);

	/*

	 * Test if this announcement contains changed information.

	 */

	if (fc->n_messages > 1) {

		tmp = TAILQ_NEXT(m, list);

		diff = announce_compare(m, tmp);

	}

	return broke_threshold || diff;

}

static int follow_up_info_append(struct ptp_message *m)

{

	struct follow_up_info_tlv *fui;

	struct tlv_extra *extra;

	extra = msg_tlv_append(m, sizeof(*fui));

	if (!extra) {

		return -1;

	}

	fui = (struct follow_up_info_tlv *) extra->tlv;

	fui->type = TLV_ORGANIZATION_EXTENSION;

	fui->length = sizeof(*fui) - sizeof(fui->type) - sizeof(fui->length);

	memcpy(fui->id, ieee8021_id, sizeof(ieee8021_id));

	fui->subtype[2] = 1;

	return 0;

}

static int net_sync_resp_append(struct port *p, struct ptp_message *m)

{

	struct timePropertiesDS *tp = clock_time_properties(p->clock);

	struct ClockIdentity cid = clock_identity(p->clock), pid;

	struct currentDS *cds = clock_current_dataset(p->clock);

	struct parent_ds *dad = clock_parent_ds(p->clock);

	struct port *best = clock_best_port(p->clock);

	struct nsm_resp_tlv_head *head;

	struct Timestamp last_sync;

	struct PortAddress *paddr;

	struct ptp_message *tmp;

	struct tlv_extra *extra;

	unsigned char *ptr;

	int tlv_len;

	uint8_t buf[sizeof(*paddr) + sizeof(struct sockaddr_storage)];

	last_sync = tmv_to_Timestamp(clock_ingress_time(p->clock));

	pid = dad->pds.parentPortIdentity.clockIdentity;

	paddr = (struct PortAddress *)buf;

	if (best && !cid_eq(&cid, &pid)) {

		/* Extract the parent's protocol address. */

		paddr->networkProtocol = transport_type(best->trp);

		paddr->addressLength =

			transport_protocol_addr(best->trp, paddr->address);

		if (best->best) {

			tmp = TAILQ_FIRST(&best->best->messages);

			extract_address(tmp, paddr);

		}

	} else {

		/* We are our own parent. */

		paddr->networkProtocol = transport_type(p->trp);

		paddr->addressLength =

			transport_protocol_addr(p->trp, paddr->address);

	}

	tlv_len = sizeof(*head) + sizeof(*extra->foot) + paddr->addressLength;

	extra = msg_tlv_append(m, tlv_len);

	if (!extra) {

		return -1;

	}

	head = (struct nsm_resp_tlv_head *) extra->tlv;

	head->type = TLV_PTPMON_RESP;

	head->length = tlv_len - sizeof(head->type) - sizeof(head->length);

	head->port_state = p->state == PS_GRAND_MASTER ? PS_MASTER : p->state;

	head->parent_addr.networkProtocol = paddr->networkProtocol;

	head->parent_addr.addressLength = paddr->addressLength;

	memcpy(head->parent_addr.address, paddr->address, paddr->addressLength);

	ptr = (unsigned char *) head;

	ptr += sizeof(*head) + paddr->addressLength;

	extra->foot = (struct nsm_resp_tlv_foot *) ptr;

	memcpy(&extra->foot->parent, &dad->pds, sizeof(extra->foot->parent));

	memcpy(&extra->foot->current, cds, sizeof(extra->foot->current));

	memcpy(&extra->foot->timeprop, tp, sizeof(extra->foot->timeprop));

	memcpy(&extra->foot->lastsync, &last_sync, sizeof(extra->foot->lastsync));

	return 0;

}

static struct follow_up_info_tlv *follow_up_info_extract(struct ptp_message *m)

{

	struct follow_up_info_tlv *f;

	struct tlv_extra *extra;

	TAILQ_FOREACH(extra, &m->tlv_list, list) {

		f = (struct follow_up_info_tlv *) extra->tlv;

		if (f->type == TLV_ORGANIZATION_EXTENSION &&

		    f->length == sizeof(*f) - sizeof(f->type) - sizeof(f->length) &&

//		    memcmp(f->id, ieee8021_id, sizeof(ieee8021_id)) &&

		    !f->subtype[0] && !f->subtype[1] && f->subtype[2] == 1) {

			return f;

		}

	}

	return NULL;

}

static void free_foreign_masters(struct port *p)

{

	struct foreign_clock *fc;

	while ((fc = LIST_FIRST(&p->foreign_masters)) != NULL) {

		LIST_REMOVE(fc, list);

		fc_clear(fc);

		free(fc);

	}

}

static int fup_sync_ok(struct ptp_message *fup, struct ptp_message *sync)

{

	/*

	 * NB - If the sk_check_fupsync option is not enabled, then

	 * both of these time stamps will be zero.

	 */

	if (tmv_cmp(fup->hwts.sw, sync->hwts.sw) < 0) {

		return 0;

	}

	return 1;

}

static int incapable_ignore(struct port *p, struct ptp_message *m)

{

	if (port_capable(p)) {

		return 0;

	}

	if (msg_type(m) == ANNOUNCE || msg_type(m) == SYNC) {

		return 1;

	}

	return 0;

}

static int path_trace_append(struct port *p, struct ptp_message *m,

			     struct parent_ds *dad)

{

	int length = 1 + dad->path_length, ptt_len, tlv_len;

	struct path_trace_tlv *ptt;

	struct tlv_extra *extra;

	if (length > PATH_TRACE_MAX) {

		return -1;

	}

	ptt_len = length * sizeof(struct ClockIdentity);

	tlv_len = ptt_len + sizeof(ptt->type) + sizeof(ptt->length);

	extra = msg_tlv_append(m, tlv_len);

	if (!extra) {

		return -1;

	}

	ptt = (struct path_trace_tlv *) extra->tlv;

	ptt->type = TLV_PATH_TRACE;

	ptt->length = ptt_len;

	memcpy(ptt->cid, dad->ptl, ptt->length);

	ptt->cid[length - 1] = clock_identity(p->clock);

	return 0;

}

static int path_trace_ignore(struct port *p, struct ptp_message *m)

{

	struct path_trace_tlv *ptt;

	struct ClockIdentity cid;

	struct tlv_extra *extra;

	int i, cnt;

	if (!p->path_trace_enabled) {

		return 0;

	}

	if (msg_type(m) != ANNOUNCE) {

		return 0;

	}

	TAILQ_FOREACH(extra, &m->tlv_list, list) {

		ptt = (struct path_trace_tlv *) extra->tlv;

		if (ptt->type != TLV_PATH_TRACE) {

			continue;

		}

		cnt = path_length(ptt);

		cid = clock_identity(p->clock);

		for (i = 0; i < cnt; i++) {

			if (cid_eq(&ptt->cid[i], &cid)) {

				return 1;

			}

		}

	}

	return 0;

}

static int peer_prepare_and_send(struct port *p, struct ptp_message *msg,

				 enum transport_event event)

{

	int cnt;

	if (msg_pre_send(msg)) {

		return -1;

	}

	if (msg_unicast(msg)) {

		cnt = transport_sendto(p->trp, &p->fda, event, msg);

	} else {

		cnt = transport_peer(p->trp, &p->fda, event, msg);

	}

	if (cnt <= 0) {

		return -1;

	}

	if (msg_sots_valid(msg)) {

		ts_add(&msg->hwts.ts, p->tx_timestamp_offset);

	}

	return 0;

}

static int port_capable(struct port *p)

{

	if (!port_is_ieee8021as(p)) {

		/* Normal 1588 ports are always capable. */

		goto capable;

	}

	if (tmv_to_nanoseconds(p->peer_delay) >	p->neighborPropDelayThresh) {

		if (p->asCapable)

			pr_debug("port %hu: peer_delay (%" PRId64 ") > neighborPropDelayThresh "

				"(%" PRId32 "), resetting asCapable", portnum(p),

				tmv_to_nanoseconds(p->peer_delay),

				p->neighborPropDelayThresh);

		goto not_capable;

	}

	if (tmv_to_nanoseconds(p->peer_delay) <	p->min_neighbor_prop_delay) {

		if (p->asCapable)

			pr_debug("port %hu: peer_delay (%" PRId64 ") < min_neighbor_prop_delay "

				"(%" PRId32 "), resetting asCapable", portnum(p),

				tmv_to_nanoseconds(p->peer_delay),

				p->min_neighbor_prop_delay);

		goto not_capable;

	}

	if (p->pdr_missing > ALLOWED_LOST_RESPONSES) {

		if (p->asCapable)

			pr_debug("port %hu: missed %d peer delay resp, "

				"resetting asCapable", portnum(p), p->pdr_missing);

		goto not_capable;

	}

	if (p->multiple_seq_pdr_count) {

		if (p->asCapable)

			pr_debug("port %hu: multiple sequential peer delay resp, "

				"resetting asCapable", portnum(p));

		goto not_capable;

	}

	if (!p->peer_portid_valid) {

		if (p->asCapable)

			pr_debug("port %hu: invalid peer port id, "

				"resetting asCapable", portnum(p));

		goto not_capable;

	}

	if (!p->nrate.ratio_valid) {

		if (p->asCapable)

			pr_debug("port %hu: invalid nrate, "

				"resetting asCapable", portnum(p));

		goto not_capable;

	}

capable:

	if (!p->asCapable)

		pr_debug("port %hu: setting asCapable", portnum(p));

	p->asCapable = 1;

	return 1;

not_capable:

	if (p->asCapable)

		port_nrate_initialize(p);

	p->asCapable = 0;

	return 0;

}

int port_clr_tmo(int fd)

{

	struct itimerspec tmo = {

		{0, 0}, {0, 0}

	};

	return timerfd_settime(fd, 0, &tmo, NULL);

}

static int port_ignore(struct port *p, struct ptp_message *m)

{

	struct ClockIdentity c1, c2;

	if (incapable_ignore(p, m)) {

		return 1;

	}

	if (path_trace_ignore(p, m)) {

		return 1;

	}

	if (p->match_transport_specific &&

	    msg_transport_specific(m) != p->transportSpecific) {

		return 1;

	}

	if (pid_eq(&m->header.sourcePortIdentity, &p->portIdentity)) {

		return 1;

	}

	if (m->header.domainNumber != clock_domain_number(p->clock)) {

		return 1;

	}

	c1 = clock_identity(p->clock);

	c2 = m->header.sourcePortIdentity.clockIdentity;

	if (cid_eq(&c1, &c2)) {

		return 1;

	}

	return 0;

}

static int port_nsm_reply(struct port *p, struct ptp_message *m)

{

	struct tlv_extra *extra;

	if (!p->net_sync_monitor) {

		return 0;

	}

	if (!p->hybrid_e2e) {

		return 0;

	}

	if (!msg_unicast(m)) {

		return 0;

	}

	TAILQ_FOREACH(extra, &m->tlv_list, list) {

		if (extra->tlv->type == TLV_PTPMON_REQ) {

			return 1;

		}

	}

	return 0;

}

/*

 * Test whether a 802.1AS port may transmit a sync message.

 */

static int port_sync_incapable(struct port *p)

{

	struct ClockIdentity cid;

	struct PortIdentity pid;

	if (!port_is_ieee8021as(p)) {

		return 0;

	}

	if (clock_gm_capable(p->clock)) {

		return 0;

	}

	cid = clock_identity(p->clock);

	pid = clock_parent_identity(p->clock);

	if (cid_eq(&cid, &pid.clockIdentity)) {

		/*

		 * We are the GM, but without gmCapable set.

		 */

		return 1;

	}

	return 0;

}

static int port_is_ieee8021as(struct port *p)

{

	return p->follow_up_info ? 1 : 0;

}

static void port_management_send_error(struct port *p, struct port *ingress,

				       struct ptp_message *msg, int error_id)

{

	if (port_management_error(p->portIdentity, ingress, msg, error_id))

		pr_err("port %hu: management error failed", portnum(p));

}

static const Octet profile_id_drr[] = {0x00, 0x1B, 0x19, 0x00, 0x01, 0x00};

static const Octet profile_id_p2p[] = {0x00, 0x1B, 0x19, 0x00, 0x02, 0x00};

static int port_management_fill_response(struct port *target,

					 struct ptp_message *rsp, int id)

{

	struct mgmt_clock_description *cd;

	struct management_tlv_datum *mtd;

	struct clock_description *desc;

	struct port_properties_np *ppn;

	struct management_tlv *tlv;

	struct port_ds_np *pdsnp;

	struct tlv_extra *extra;

	struct portDS *pds;

	uint16_t u16;

	uint8_t *buf;

	int datalen;

	extra = tlv_extra_alloc();

	if (!extra) {

		pr_err("failed to allocate TLV descriptor");

		return 0;

	}

	extra->tlv = (struct TLV *) rsp->management.suffix;

	tlv = (struct management_tlv *) rsp->management.suffix;

	tlv->type = TLV_MANAGEMENT;

	tlv->id = id;

	switch (id) {

	case TLV_NULL_MANAGEMENT:

		datalen = 0;

		break;

	case TLV_CLOCK_DESCRIPTION:

		cd = &extra->cd;

		buf = tlv->data;

		cd->clockType = (UInteger16 *) buf;

		buf += sizeof(*cd->clockType);

		*cd->clockType = clock_type(target->clock);

		cd->physicalLayerProtocol = (struct PTPText *) buf;

		switch(transport_type(target->trp)) {

		case TRANS_UDP_IPV4:

		case TRANS_UDP_IPV6:

		case TRANS_IEEE_802_3:

			ptp_text_set(cd->physicalLayerProtocol, "IEEE 802.3");

			break;

		default:

			ptp_text_set(cd->physicalLayerProtocol, NULL);

			break;

		}

		buf += sizeof(struct PTPText) + cd->physicalLayerProtocol->length;

		cd->physicalAddress = (struct PhysicalAddress *) buf;

		u16 = transport_physical_addr(target->trp,

                                              cd->physicalAddress->address);

		memcpy(&cd->physicalAddress->length, &u16, 2);

		buf += sizeof(struct PhysicalAddress) + u16;

		cd->protocolAddress = (struct PortAddress *) buf;

		u16 = transport_type(target->trp);

		memcpy(&cd->protocolAddress->networkProtocol, &u16, 2);

		u16 = transport_protocol_addr(target->trp,

                                              cd->protocolAddress->address);

		memcpy(&cd->protocolAddress->addressLength, &u16, 2);

		buf += sizeof(struct PortAddress) + u16;

		desc = clock_description(target->clock);

		cd->manufacturerIdentity = buf;

		memcpy(cd->manufacturerIdentity,

                       desc->manufacturerIdentity, OUI_LEN);

		buf += OUI_LEN;

		*(buf++) = 0; /* reserved */

		cd->productDescription = (struct PTPText *) buf;

		ptp_text_copy(cd->productDescription, &desc->productDescription);

		buf += sizeof(struct PTPText) + cd->productDescription->length;

		cd->revisionData = (struct PTPText *) buf;

		ptp_text_copy(cd->revisionData, &desc->revisionData);

		buf += sizeof(struct PTPText) + cd->revisionData->length;

		cd->userDescription = (struct PTPText *) buf;

		ptp_text_copy(cd->userDescription, &desc->userDescription);

		buf += sizeof(struct PTPText) + cd->userDescription->length;

		if (target->delayMechanism == DM_P2P) {

			memcpy(buf, profile_id_p2p, PROFILE_ID_LEN);

		} else {

			memcpy(buf, profile_id_drr, PROFILE_ID_LEN);

		}

		buf += PROFILE_ID_LEN;

		datalen = buf - tlv->data;

		break;

	case TLV_PORT_DATA_SET:

		pds = (struct portDS *) tlv->data;

		pds->portIdentity            = target->portIdentity;

		if (target->state == PS_GRAND_MASTER) {

			pds->portState = PS_MASTER;

		} else {

			pds->portState = target->state;

		}

		pds->logMinDelayReqInterval  = target->logMinDelayReqInterval;

		pds->peerMeanPathDelay       = target->peerMeanPathDelay;

		pds->logAnnounceInterval     = target->logAnnounceInterval;

		pds->announceReceiptTimeout  = target->announceReceiptTimeout;

		pds->logSyncInterval         = target->logSyncInterval;

		if (target->delayMechanism) {

			pds->delayMechanism = target->delayMechanism;

		} else {

			pds->delayMechanism = DM_E2E;

		}

		pds->logMinPdelayReqInterval = target->logMinPdelayReqInterval;

		pds->versionNumber           = target->versionNumber;

		datalen = sizeof(*pds);

		break;

	case TLV_LOG_ANNOUNCE_INTERVAL:

		mtd = (struct management_tlv_datum *) tlv->data;

		mtd->val = target->logAnnounceInterval;

		datalen = sizeof(*mtd);

		break;

	case TLV_ANNOUNCE_RECEIPT_TIMEOUT:

		mtd = (struct management_tlv_datum *) tlv->data;

		mtd->val = target->announceReceiptTimeout;

		datalen = sizeof(*mtd);

		break;

	case TLV_LOG_SYNC_INTERVAL:

		mtd = (struct management_tlv_datum *) tlv->data;

		mtd->val = target->logSyncInterval;

		datalen = sizeof(*mtd);

		break;

	case TLV_VERSION_NUMBER: