[thirdparty/lldpd.git] / src / daemon / client.c

/* -*- mode: c; c-file-style: "openbsd" -*- */
/*
 * Copyright (c) 2008 Vincent Bernat <bernat@luffy.cx>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "lldpd.h"

static int
client_handle_none(struct lldpd *cfg, enum hmsg_type *type,
    void *input, int input_len, void **output, int *subscribed)
{
	LLOG_INFO("received noop request from client");
	*type = NONE;
	return 0;
}

/* Return the global configuration */
static int
client_handle_get_configuration(struct lldpd *cfg, enum hmsg_type *type,
    void *input, int input_len, void **output, int *subscribed)
{
	ssize_t output_len;
	output_len = marshal_serialize(lldpd_config, &cfg->g_config, output);
	if (output_len <= 0) {
		output_len = 0;
		*type = NONE;
	}
	return output_len;
}

/* Change the global configuration */
static int
client_handle_set_configuration(struct lldpd *cfg, enum hmsg_type *type,
    void *input, int input_len, void **output, int *subscribed)
{
	struct lldpd_config *config;

	/* Get the proposed configuration. */
	if (marshal_unserialize(lldpd_config, input, input_len, &config) <= 0) {
		*type = NONE;
		return 0;
	}

	/* What needs to be done? Currently, we only support setting the
	 * transmit delay. */
	if (config->c_tx_interval > 0) {
		cfg->g_config.c_tx_interval = config->c_tx_interval;
	}
	if (config->c_tx_interval < 0) {
		LLOG_DEBUG("client asked for immediate retransmission");
		levent_send_now(cfg);
	}

	lldpd_config_cleanup(config);

	return 0;
}

/* Return the list of interfaces.
   Input:  nothing.
   Output: list of interface names (lldpd_interface_list)
*/
static int
client_handle_get_interfaces(struct lldpd *cfg, enum hmsg_type *type,
    void *input, int input_len, void **output, int *subscribed)
{
	struct lldpd_interface *iff, *iff_next;
	struct lldpd_hardware *hardware;
	int output_len;

	/* Build the list of interfaces */
	struct lldpd_interface_list ifs;
	TAILQ_INIT(&ifs);
	TAILQ_FOREACH(hardware, &cfg->g_hardware, h_entries) {
		if ((iff = (struct lldpd_interface*)malloc(sizeof(
			    struct lldpd_interface))) == NULL)
			fatal(NULL);
		iff->name = hardware->h_ifname;
		TAILQ_INSERT_TAIL(&ifs, iff, next);
	}

	output_len = marshal_serialize(lldpd_interface_list, &ifs, output);
	if (output_len <= 0) {
		output_len = 0;
		*type = NONE;
	}

	/* Free the temporary list */
	for (iff = TAILQ_FIRST(&ifs);
	    iff != NULL;
	    iff = iff_next) {
		iff_next = TAILQ_NEXT(iff, next);
		TAILQ_REMOVE(&ifs, iff, next);
		free(iff);
	}

	return output_len;
}

/* Return all available information related to an interface
   Input:  name of the interface (serialized)
   Output: Information about the interface (lldpd_hardware)
*/
static int
client_handle_get_interface(struct lldpd *cfg, enum hmsg_type *type,
    void *input, int input_len, void **output, int *subscribed)
{
	char *name;
	struct lldpd_hardware *hardware;

	/* Get name of the interface */
	if (marshal_unserialize(string, input, input_len, &name) <= 0) {
		*type = NONE;
		return 0;
	}

	/* Search appropriate hardware */
	TAILQ_FOREACH(hardware, &cfg->g_hardware, h_entries)
		if (!strcmp(hardware->h_ifname, name)) {
			int output_len = marshal_serialize(lldpd_hardware, hardware, output);
			free(name);
			if (output_len <= 0) {
				*type = NONE;
				free(name);
				return 0;
			}
			return output_len;
		}

	free(name);
	LLOG_WARNX("no interface %s found", name);
	*type = NONE;
	return 0;
}

/* Set some port related settings (policy, location, power)
   Input: name of the interface, policy/location/power setting to be modified
   Output: nothing
*/
static int
client_handle_set_port(struct lldpd *cfg, enum hmsg_type *type,
    void *input, int input_len, void **output, int *subscribed)
{
	int ret = 0;
	struct lldpd_port_set *set = NULL;
	struct lldpd_hardware *hardware = NULL;
#ifdef ENABLE_LLDPMED
	struct lldpd_med_loc *loc = NULL;
#endif

	if (marshal_unserialize(lldpd_port_set, input, input_len, &set) <= 0) {
		*type = NONE;
		return 0;
	}
	if (!set->ifname) {
		LLOG_WARNX("no interface provided");
		goto set_port_finished;
	}

	/* Search the appropriate hardware */
	TAILQ_FOREACH(hardware, &cfg->g_hardware, h_entries)
	    if (!strcmp(hardware->h_ifname, set->ifname)) {
		    struct lldpd_port *port = &hardware->h_lport;
		    (void)port;
#ifdef ENABLE_LLDPMED
		    if (set->med_policy && set->med_policy->type > 0) {
			    if (set->med_policy->type > LLDP_MED_APPTYPE_LAST) {
				    LLOG_WARNX("invalid policy provided: %d",
					set->med_policy->type);
				    goto set_port_finished;
			    }
			    memcpy(&port->p_med_policy[set->med_policy->type - 1],
				set->med_policy, sizeof(struct lldpd_med_policy));
			    port->p_med_cap_enabled |= LLDP_MED_CAP_POLICY;
		    }
		    if (set->med_location && set->med_location->format > 0) {
			    char *newdata = NULL;
			    if (set->med_location->format > LLDP_MED_LOCFORMAT_LAST) {
				    LLOG_WARNX("invalid location format provided: %d",
					set->med_location->format);
				    goto set_port_finished;
			    }
			    loc = \
				&port->p_med_location[set->med_location->format - 1];
			    free(loc->data);
			    memcpy(loc, set->med_location, sizeof(struct lldpd_med_loc));
			    if (!loc->data || !(newdata = malloc(loc->data_len))) loc->data_len = 0;
			    if (newdata) memcpy(newdata, loc->data, loc->data_len);
			    loc->data = newdata;
			    port->p_med_cap_enabled |= LLDP_MED_CAP_LOCATION;
		    }
		    if (set->med_power) {
			    memcpy(&port->p_med_power, set->med_power,
				sizeof(struct lldpd_med_power));
			    switch (set->med_power->devicetype) {
			    case LLDP_MED_POW_TYPE_PD:
				    port->p_med_cap_enabled |= LLDP_MED_CAP_MDI_PD;
				    port->p_med_cap_enabled &= ~LLDP_MED_CAP_MDI_PSE;
				    break;
			    case LLDP_MED_POW_TYPE_PSE:
				    port->p_med_cap_enabled |= LLDP_MED_CAP_MDI_PSE;
				    port->p_med_cap_enabled &= ~LLDP_MED_CAP_MDI_PD;
				    break;
			    }
		    }
#endif
#ifdef ENABLE_DOT3
		    if (set->dot3_power)
			    memcpy(&port->p_power, set->dot3_power,
				sizeof(struct lldpd_dot3_power));
#endif
		    ret = 1;
		    break;
	    }

	if (ret == 0)
		LLOG_WARN("no interface %s found", set->ifname);

set_port_finished:
	if (!ret) *type = NONE;
	free(set->ifname);
#ifdef ENABLE_LLDPMED
	free(set->med_policy);
	if (set->med_location) free(set->med_location->data);
	free(set->med_location);
	free(set->med_power);
#endif
#ifdef ENABLE_DOT3
	free(set->dot3_power);
#endif
	return 0;
}

/* Register subscribtion to neighbor changes */
static int
client_handle_subscribe(struct lldpd *cfg, enum hmsg_type *type,
    void *input, int input_len, void **output, int *subscribed)
{
	*subscribed = 1;
	return 0;
}

struct client_handle {
	enum hmsg_type type;
	int (*handle)(struct lldpd*, enum hmsg_type *,
	    void *, int, void **, int *);
};

static struct client_handle client_handles[] = {
	{ NONE,			client_handle_none },
	{ GET_CONFIG,		client_handle_get_configuration },
	{ SET_CONFIG,		client_handle_set_configuration },
	{ GET_INTERFACES,	client_handle_get_interfaces },
	{ GET_INTERFACE,	client_handle_get_interface },
	{ SET_PORT,		client_handle_set_port },
	{ SUBSCRIBE,		client_handle_subscribe },
	{ 0,			NULL } };

int
client_handle_client(struct lldpd *cfg,
    ssize_t(*send)(void *, int, void *, size_t),
    void *out,
    enum hmsg_type type, void *buffer, size_t n,
    int *subscribed)
{
	struct client_handle *ch;
	void *answer; size_t len, sent;
	for (ch = client_handles; ch->handle != NULL; ch++) {
		if (ch->type == type) {
			answer = NULL; len = 0;
			len  = ch->handle(cfg, &type, buffer, n, &answer,
			    subscribed);
			sent = send(out, type, answer, len);
			free(answer);
			return sent;
		}
	}

	LLOG_WARNX("unknown message request (%d) received",
	    type);
	return -1;
}
Commit	Line	Data
4b292b55	1	/* -- mode: c; c-file-style: "openbsd" -- */
a552a72e VB	2	/*
	3	* Copyright (c) 2008 Vincent Bernat <bernat@luffy.cx>
	4	*
51434125	5	* Permission to use, copy, modify, and/or distribute this software for any
a552a72e VB	6	* purpose with or without fee is hereby granted, provided that the above
	7	* copyright notice and this permission notice appear in all copies.
	8	*
	9	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	10	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	11	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	12	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	13	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	14	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	15	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	16	*/
	17
	18	#include "lldpd.h"
	19
f6d20631 VB	20	static int
f6d20631 VB	21	client_handle_none(struct lldpd cfg, enum hmsg_type type,
4e90a9e0	22	void input, int input_len, void output, int subscribed)
a552a72e	23	{
f6d20631 VB	24	LLOG_INFO("received noop request from client");
	25	*type = NONE;
	26	return 0;
a552a72e VB	27	}
a552a72e VB	28
8729d69f VB	29	/* Return the global configuration */
	30	static int
	31	client_handle_get_configuration(struct lldpd cfg, enum hmsg_type type,
	32	void input, int input_len, void output, int subscribed)
	33	{
	34	ssize_t output_len;
	35	output_len = marshal_serialize(lldpd_config, &cfg->g_config, output);
	36	if (output_len <= 0) {
	37	output_len = 0;
	38	*type = NONE;
	39	}
	40	return output_len;
	41	}
	42
47287a61 VB	43	/* Change the global configuration */
	44	static int
	45	client_handle_set_configuration(struct lldpd cfg, enum hmsg_type type,
	46	void input, int input_len, void output, int subscribed)
	47	{
	48	struct lldpd_config *config;
	49
	50	/* Get the proposed configuration. */
	51	if (marshal_unserialize(lldpd_config, input, input_len, &config) <= 0) {
	52	*type = NONE;
	53	return 0;
	54	}
	55
	56	/* What needs to be done? Currently, we only support setting the
	57	* transmit delay. */
8843f168 VB	58	if (config->c_tx_interval > 0) {
8843f168 VB	59	cfg->g_config.c_tx_interval = config->c_tx_interval;
47287a61	60	}
8843f168	61	if (config->c_tx_interval < 0) {
47287a61 VB	62	LLOG_DEBUG("client asked for immediate retransmission");
	63	levent_send_now(cfg);
	64	}
	65
	66	lldpd_config_cleanup(config);
	67
	68	return 0;
	69	}
	70
f6d20631 VB	71	/* Return the list of interfaces.
	72	Input: nothing.
	73	Output: list of interface names (lldpd_interface_list)
	74	*/
	75	static int
	76	client_handle_get_interfaces(struct lldpd cfg, enum hmsg_type type,
4e90a9e0	77	void input, int input_len, void output, int subscribed)
a552a72e VB	78	{
	79	struct lldpd_interface iff, iff_next;
	80	struct lldpd_hardware *hardware;
5fd6695c	81	int output_len;
a552a72e VB	82
a552a72e VB	83	/* Build the list of interfaces */
f6d20631	84	struct lldpd_interface_list ifs;
a552a72e VB	85	TAILQ_INIT(&ifs);
	86	TAILQ_FOREACH(hardware, &cfg->g_hardware, h_entries) {
	87	if ((iff = (struct lldpd_interface*)malloc(sizeof(
	88	struct lldpd_interface))) == NULL)
	89	fatal(NULL);
	90	iff->name = hardware->h_ifname;
	91	TAILQ_INSERT_TAIL(&ifs, iff, next);
	92	}
	93
5fd6695c	94	output_len = marshal_serialize(lldpd_interface_list, &ifs, output);
f6d20631 VB	95	if (output_len <= 0) {
	96	output_len = 0;
	97	*type = NONE;
a552a72e VB	98	}
	99
	100	/* Free the temporary list */
	101	for (iff = TAILQ_FIRST(&ifs);
	102	iff != NULL;
	103	iff = iff_next) {
	104	iff_next = TAILQ_NEXT(iff, next);
	105	TAILQ_REMOVE(&ifs, iff, next);
	106	free(iff);
	107	}
f6d20631 VB	108
f6d20631 VB	109	return output_len;
a552a72e VB	110	}
a552a72e VB	111
f6d20631 VB	112	/* Return all available information related to an interface
	113	Input: name of the interface (serialized)
	114	Output: Information about the interface (lldpd_hardware)
	115	*/
	116	static int
	117	client_handle_get_interface(struct lldpd cfg, enum hmsg_type type,
4e90a9e0	118	void input, int input_len, void output, int subscribed)
a552a72e	119	{
f6d20631	120	char *name;
5fd6695c VB	121	struct lldpd_hardware *hardware;
	122
	123	/* Get name of the interface */
f6d20631 VB	124	if (marshal_unserialize(string, input, input_len, &name) <= 0) {
	125	*type = NONE;
	126	return 0;
	127	}
	128
	129	/* Search appropriate hardware */
f6d20631 VB	130	TAILQ_FOREACH(hardware, &cfg->g_hardware, h_entries)
	131	if (!strcmp(hardware->h_ifname, name)) {
	132	int output_len = marshal_serialize(lldpd_hardware, hardware, output);
	133	free(name);
	134	if (output_len <= 0) {
	135	*type = NONE;
	136	free(name);
	137	return 0;
	138	}
	139	return output_len;
	140	}
	141
	142	free(name);
	143	LLOG_WARNX("no interface %s found", name);
	144	*type = NONE;
	145	return 0;
	146	}
	147
	148	/* Set some port related settings (policy, location, power)
	149	Input: name of the interface, policy/location/power setting to be modified
	150	Output: nothing
	151	*/
	152	static int
	153	client_handle_set_port(struct lldpd cfg, enum hmsg_type type,
4e90a9e0	154	void input, int input_len, void output, int subscribed)
f6d20631 VB	155	{
f6d20631 VB	156	int ret = 0;
5fd6695c VB	157	struct lldpd_port_set *set = NULL;
5fd6695c VB	158	struct lldpd_hardware *hardware = NULL;
2a836f02	159	#ifdef ENABLE_LLDPMED
5fd6695c	160	struct lldpd_med_loc *loc = NULL;
2a836f02	161	#endif
a552a72e	162
f6d20631 VB	163	if (marshal_unserialize(lldpd_port_set, input, input_len, &set) <= 0) {
	164	*type = NONE;
	165	return 0;
a552a72e	166	}
f6d20631 VB	167	if (!set->ifname) {
	168	LLOG_WARNX("no interface provided");
	169	goto set_port_finished;
	170	}
	171
	172	/* Search the appropriate hardware */
f6d20631 VB	173	TAILQ_FOREACH(hardware, &cfg->g_hardware, h_entries)
	174	if (!strcmp(hardware->h_ifname, set->ifname)) {
	175	struct lldpd_port *port = &hardware->h_lport;
4b292b55	176	(void)port;
740593ff	177	#ifdef ENABLE_LLDPMED
f6d20631	178	if (set->med_policy && set->med_policy->type > 0) {
4b292b55	179	if (set->med_policy->type > LLDP_MED_APPTYPE_LAST) {
f6d20631 VB	180	LLOG_WARNX("invalid policy provided: %d",
	181	set->med_policy->type);
	182	goto set_port_finished;
	183	}
	184	memcpy(&port->p_med_policy[set->med_policy->type - 1],
	185	set->med_policy, sizeof(struct lldpd_med_policy));
4b292b55	186	port->p_med_cap_enabled \|= LLDP_MED_CAP_POLICY;
f6d20631 VB	187	}
f6d20631 VB	188	if (set->med_location && set->med_location->format > 0) {
4b292b55 VB	189	char *newdata = NULL;
4b292b55 VB	190	if (set->med_location->format > LLDP_MED_LOCFORMAT_LAST) {
f6d20631 VB	191	LLOG_WARNX("invalid location format provided: %d",
	192	set->med_location->format);
	193	goto set_port_finished;
	194	}
5fd6695c	195	loc = \
f6d20631 VB	196	&port->p_med_location[set->med_location->format - 1];
	197	free(loc->data);
	198	memcpy(loc, set->med_location, sizeof(struct lldpd_med_loc));
4b292b55 VB	199	if (!loc->data \|\| !(newdata = malloc(loc->data_len))) loc->data_len = 0;
	200	if (newdata) memcpy(newdata, loc->data, loc->data_len);
	201	loc->data = newdata;
	202	port->p_med_cap_enabled \|= LLDP_MED_CAP_LOCATION;
f6d20631 VB	203	}
	204	if (set->med_power) {
	205	memcpy(&port->p_med_power, set->med_power,
	206	sizeof(struct lldpd_med_power));
	207	switch (set->med_power->devicetype) {
4b292b55 VB	208	case LLDP_MED_POW_TYPE_PD:
	209	port->p_med_cap_enabled \|= LLDP_MED_CAP_MDI_PD;
	210	port->p_med_cap_enabled &= ~LLDP_MED_CAP_MDI_PSE;
f6d20631	211	break;
4b292b55 VB	212	case LLDP_MED_POW_TYPE_PSE:
	213	port->p_med_cap_enabled \|= LLDP_MED_CAP_MDI_PSE;
	214	port->p_med_cap_enabled &= ~LLDP_MED_CAP_MDI_PD;
f6d20631 VB	215	break;
	216	}
	217	}
42ee7382 VB	218	#endif
42ee7382 VB	219	#ifdef ENABLE_DOT3
f6d20631 VB	220	if (set->dot3_power)
	221	memcpy(&port->p_power, set->dot3_power,
	222	sizeof(struct lldpd_dot3_power));
740593ff	223	#endif
f6d20631 VB	224	ret = 1;
	225	break;
	226	}
	227
	228	if (ret == 0)
	229	LLOG_WARN("no interface %s found", set->ifname);
	230
	231	set_port_finished:
	232	if (!ret) *type = NONE;
	233	free(set->ifname);
4b292b55	234	#ifdef ENABLE_LLDPMED
f6d20631 VB	235	free(set->med_policy);
	236	if (set->med_location) free(set->med_location->data);
	237	free(set->med_location);
	238	free(set->med_power);
84853b92	239	#endif
f6d20631 VB	240	#ifdef ENABLE_DOT3
	241	free(set->dot3_power);
	242	#endif
	243	return 0;
	244	}
	245
4e90a9e0 VB	246	/* Register subscribtion to neighbor changes */
	247	static int
	248	client_handle_subscribe(struct lldpd cfg, enum hmsg_type type,
	249	void input, int input_len, void output, int subscribed)
	250	{
	251	*subscribed = 1;
	252	return 0;
	253	}
	254
	255	struct client_handle {
	256	enum hmsg_type type;
	257	int (handle)(struct lldpd, enum hmsg_type *,
	258	void , int, void , int );
	259	};
	260
f6d20631	261	static struct client_handle client_handles[] = {
4e90a9e0	262	{ NONE, client_handle_none },
8729d69f	263	{ GET_CONFIG, client_handle_get_configuration },
47287a61	264	{ SET_CONFIG, client_handle_set_configuration },
4e90a9e0 VB	265	{ GET_INTERFACES, client_handle_get_interfaces },
	266	{ GET_INTERFACE, client_handle_get_interface },
	267	{ SET_PORT, client_handle_set_port },
	268	{ SUBSCRIBE, client_handle_subscribe },
	269	{ 0, NULL } };
f6d20631 VB	270
f6d20631 VB	271	int
e0478a46 VB	272	client_handle_client(struct lldpd *cfg,
	273	ssize_t(send)(void , int, void *, size_t),
	274	void *out,
4e90a9e0 VB	275	enum hmsg_type type, void *buffer, size_t n,
4e90a9e0 VB	276	int *subscribed)
f6d20631 VB	277	{
f6d20631 VB	278	struct client_handle *ch;
e0478a46	279	void *answer; size_t len, sent;
f6d20631 VB	280	for (ch = client_handles; ch->handle != NULL; ch++) {
	281	if (ch->type == type) {
	282	answer = NULL; len = 0;
4e90a9e0 VB	283	len = ch->handle(cfg, &type, buffer, n, &answer,
4e90a9e0 VB	284	subscribed);
e0478a46	285	sent = send(out, type, answer, len);
f6d20631 VB	286	free(answer);
f6d20631 VB	287	return sent;
a552a72e VB	288	}
a552a72e VB	289	}
e0478a46	290
f6d20631 VB	291	LLOG_WARNX("unknown message request (%d) received",
	292	type);
	293	return -1;
a552a72e	294	}