lib/abstract/abstract.c - platform/external/libwebsockets - Git at Google

 /*
  * libwebsockets - small server side websockets and web server implementation
  *
  * Copyright (C) 2010 - 2019 Andy Green <[email protected]>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
  * deal in the Software without restriction, including without limitation the
  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  * sell copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * 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.
  */

 #include <private-lib-core.h>
 #include <private-lib-abstract.h>

 extern const lws_abs_transport_t lws_abs_transport_cli_raw_skt,
 				 lws_abs_transport_cli_unit_test;
 #if defined(LWS_WITH_SMTP)
 extern const lws_abs_protocol_t lws_abs_protocol_smtp;
 #endif
 #if defined(LWS_WITH_MQTT)
 extern const lws_abs_protocol_t lws_abs_protocol_mqttc;
 #endif

 static const lws_abs_transport_t * const available_abs_transports[] = {
 	&lws_abs_transport_cli_raw_skt,
 	&lws_abs_transport_cli_unit_test,
 };

 #if defined(LWS_WITH_ABSTRACT)
 static const lws_abs_protocol_t * const available_abs_protocols[] = {
 #if defined(LWS_WITH_SMTP)
 	&lws_abs_protocol_smtp,
 #endif
 #if defined(LWS_WITH_MQTT)
 	&lws_abs_protocol_mqttc,
 #endif
 };
 #endif

 const lws_abs_transport_t *
 lws_abs_transport_get_by_name(const char *name)
 {
 	int n;

 	for (n = 0; n < (int)LWS_ARRAY_SIZE(available_abs_transports); n++)
 		if (!strcmp(name, available_abs_transports[n]->name))
 			return available_abs_transports[n];

 	lwsl_err("%s: cannot find '%s'\n", __func__, name);

 	return NULL;
 }

 const lws_abs_protocol_t *
 lws_abs_protocol_get_by_name(const char *name)
 {
 #if defined(LWS_WITH_ABSTRACT)
 	int n;

 	for (n = 0; n < (int)LWS_ARRAY_SIZE(available_abs_protocols); n++)
 		if (!strcmp(name, available_abs_protocols[n]->name))
 			return available_abs_protocols[n];
 #endif
 	lwsl_err("%s: cannot find '%s'\n", __func__, name);

 	return NULL;
 }

 const lws_token_map_t *
 lws_abs_get_token(const lws_token_map_t *token_map, short name_index)
 {
 	if (!token_map)
 		return NULL;

 	do {
 		if (token_map->name_index == name_index)
 			return token_map;
 		token_map++;
 	} while (token_map->name_index);

 	return NULL;
 }

 static int
 lws_abstract_compare_connection(lws_abs_t *abs1, lws_abs_t *abs2)
 {
 	/* it has to be using the same protocol */
 	if (abs1->ap != abs2->ap)
 		return 1;

 	/* protocol has to allow some kind of binding */
 	if (!abs1->ap->flags)
 		return 1;

 	/* it has to be using the same transport */
 	if (abs1->at != abs2->at)
 		return 1;

 	/*
 	 * The transport must feel the endpoint and conditions in use match the
 	 * requested endpoint and conditions... and the transport type must be
 	 * willing to allow it
 	 */
 	if (abs1->at->compare(abs1, abs2))
 		return 1;

 	/*
 	 * The protocol must feel they are in compatible modes if any
 	 * (and the protocol type must be willing to allow it)
 	 */
 	if (abs1->ap->compare(abs1, abs2))
 		return 1;

 	/*
 	 * If no objection by now, we can say there's already a comparable
 	 * connection and both the protocol and transport feel we can make
 	 * use of it.
 	 */

 	return 0;
 }

 static int
 find_compatible(struct lws_dll2 *d, void *user)
 {
 	lws_abs_t *ai1 = (lws_abs_t *)user,
 		  *ai2 = lws_container_of(d, lws_abs_t, abstract_instances);

 	if (!lws_abstract_compare_connection(ai1, ai2)) {
 		/* we can bind to it */
 		lws_dll2_add_tail(&ai1->bound, &ai2->children_owner);

 		return 1;
 	}

 	return 0;
 }

 lws_abs_t *
 lws_abs_bind_and_create_instance(const lws_abs_t *abs)
 {
 	size_t size = sizeof(lws_abs_t) + abs->ap->alloc + abs->at->alloc;
 	lws_abs_t *ai;
 	int n;

 	/*
 	 * since we know we will allocate the lws_abs_t, the protocol's
 	 * instance allocation, and the transport's instance allocation,
 	 * we merge it into a single heap allocation
 	 */
 	ai = lws_malloc(size, "abs inst");
 	if (!ai)
 		return NULL;

 	*ai = *abs;
 	ai->ati = NULL;

 	ai->api = (char *)ai + sizeof(lws_abs_t);

 	if (!ai->ap->flags) /* protocol only understands single connections */
 		goto fresh;

 	lws_vhost_lock(ai->vh); /* ----------------------------------- vh { */

 	/*
 	 * Let's have a look for any already-connected transport we can use
 	 */

 	n = lws_dll2_foreach_safe(&ai->vh->abstract_instances_owner, ai,
 				  find_compatible);

 	lws_vhost_unlock(ai->vh); /* } vh --------------------------------- */

 	if (n)
 		goto vh_list_add;

 	/* there's no existing connection doing what we want */

 fresh:

 	ai->ati = (char *)ai->api + abs->ap->alloc;
 	if (ai->at->create(ai)) {
 		ai->ati = NULL;
 		goto bail;
 	}

 vh_list_add:
 	/* add us to the vhost's dll2 of instances */

 	lws_dll2_clear(&ai->abstract_instances);
 	lws_dll2_add_head(&ai->abstract_instances,
 			  &ai->vh->abstract_instances_owner);

 	if (ai->ap->create(ai)) {
 		ai->api = NULL;
 		goto bail;
 	}

 	if (ai->bound.owner) { /* we are a piggybacker */
 		lws_abs_t *ai2 = lws_container_of(ai->bound.owner, lws_abs_t,
 						  children_owner);
 		/*
 		 * Provide an 'event' in the parent context to start handling
 		 * the bind if it's otherwise idle.  We give the parent abs
 		 * because we don't know if we're "next" or whatever.  Just that
 		 * a child joined him and he should look into his child
 		 * situation in case he was waiting for one to appear.
 		 */
 		if (ai2->ap->child_bind(ai2)) {
 			lwsl_info("%s: anticpated child bind fail\n", __func__);
 			lws_dll2_remove(&ai->bound);

 			goto bail;
 		}
 	}

 	return ai;

 bail:
 	lws_abs_destroy_instance(&ai);

 	return NULL;
 }

 /*
  * We get called to clean up each child that was still bound to a parent
  * at the time the parent is getting destroyed.
  */

 static void
 __lws_abs_destroy_instance2(lws_abs_t **ai)
 {
 	lws_abs_t *a = *ai;

 	if (a->api)
 		a->ap->destroy(&a->api);
 	if (a->ati)
 		a->at->destroy(&a->ati);

 	lws_dll2_remove(&a->abstract_instances);

 	*ai = NULL;
 	free(a);
 }

 static int
 __reap_children(struct lws_dll2 *d, void *user)
 {
 	lws_abs_t *ac = lws_container_of(d, lws_abs_t, bound);

 	lws_dll2_foreach_safe(&ac->children_owner, NULL, __reap_children);

 	/* then destroy ourselves */

 	__lws_abs_destroy_instance2(&ac);

 	return 0;
 }

 void
 lws_abs_destroy_instance(lws_abs_t **ai)
 {
 	lws_abs_t *a = *ai;

 	/* destroy child instances that are bound to us first... */

 	lws_vhost_lock(a->vh); /* ----------------------------------- vh { */

 	lws_dll2_foreach_safe(&a->children_owner, NULL, __reap_children);

 	/* ...then destroy ourselves */

 	__lws_abs_destroy_instance2(ai);

 	lws_vhost_unlock(a->vh); /* } vh --------------------------------- */
 }

 lws_abs_t *
 lws_abstract_alloc(struct lws_vhost *vhost, void *user,
 		   const char *abstract_path, const lws_token_map_t *ap_tokens,
 		   const lws_token_map_t *at_tokens, struct lws_sequencer *seq,
 		   void *opaque_user_data)
 {
 	lws_abs_t *abs = lws_zalloc(sizeof(*abs), __func__);
 	struct lws_tokenize ts;
 	lws_tokenize_elem e;
 	char tmp[30];

 	if (!abs)
 		return NULL;

 	lws_tokenize_init(&ts, abstract_path, LWS_TOKENIZE_F_MINUS_NONTERM);

 	e = lws_tokenize(&ts);
 	if (e != LWS_TOKZE_TOKEN)
 		goto abs_path_problem;

 	if (lws_tokenize_cstr(&ts, tmp, sizeof(tmp)))
 		goto abs_path_problem;

 	abs->ap = lws_abs_protocol_get_by_name(tmp);
 	if (!abs->ap)
 		goto abs_path_problem;

 	e = lws_tokenize(&ts);
 	if (e != LWS_TOKZE_DELIMITER)
 		goto abs_path_problem;

 	e = lws_tokenize(&ts);
 	if (e != LWS_TOKZE_TOKEN)
 		goto abs_path_problem;

 	if (lws_tokenize_cstr(&ts, tmp, sizeof(tmp)))
 		goto abs_path_problem;

 	abs->at = lws_abs_transport_get_by_name(tmp);
 	if (!abs->at)
 		goto abs_path_problem;

 	abs->vh = vhost;
 	abs->ap_tokens = ap_tokens;
 	abs->at_tokens = at_tokens;
 	abs->seq = seq;
 	abs->opaque_user_data = opaque_user_data;

 	lwsl_info("%s: allocated %s\n", __func__, abstract_path);

 	return abs;

 abs_path_problem:
 	lwsl_err("%s: bad abs path '%s'\n", __func__, abstract_path);
 	lws_free_set_NULL(abs);

 	return NULL;
 }

 void
 lws_abstract_free(lws_abs_t **pabs)
 {
 	if (*pabs)
 		lws_free_set_NULL(*pabs);
 }
	/*
	* libwebsockets - small server side websockets and web server implementation
	*
	* Copyright (C) 2010 - 2019 Andy Green <[email protected]>
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and associated documentation files (the "Software"), to
	* deal in the Software without restriction, including without limitation the
	* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
	* sell copies of the Software, and to permit persons to whom the Software is
	* furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included in
	* all copies or substantial portions of the Software.
	*
	* 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.
	*/

	#include <private-lib-core.h>
	#include <private-lib-abstract.h>

	extern const lws_abs_transport_t lws_abs_transport_cli_raw_skt,
	lws_abs_transport_cli_unit_test;
	#if defined(LWS_WITH_SMTP)
	extern const lws_abs_protocol_t lws_abs_protocol_smtp;
	#endif
	#if defined(LWS_WITH_MQTT)
	extern const lws_abs_protocol_t lws_abs_protocol_mqttc;
	#endif

	static const lws_abs_transport_t * const available_abs_transports[] = {
	&lws_abs_transport_cli_raw_skt,
	&lws_abs_transport_cli_unit_test,
	};

	#if defined(LWS_WITH_ABSTRACT)
	static const lws_abs_protocol_t * const available_abs_protocols[] = {
	#if defined(LWS_WITH_SMTP)
	&lws_abs_protocol_smtp,
	#endif
	#if defined(LWS_WITH_MQTT)
	&lws_abs_protocol_mqttc,
	#endif
	};
	#endif

	const lws_abs_transport_t *
	lws_abs_transport_get_by_name(const char *name)
	{
	int n;

	for (n = 0; n < (int)LWS_ARRAY_SIZE(available_abs_transports); n++)
	if (!strcmp(name, available_abs_transports[n]->name))
	return available_abs_transports[n];

	lwsl_err("%s: cannot find '%s'\n", __func__, name);

	return NULL;
	}

	const lws_abs_protocol_t *
	lws_abs_protocol_get_by_name(const char *name)
	{
	#if defined(LWS_WITH_ABSTRACT)
	int n;

	for (n = 0; n < (int)LWS_ARRAY_SIZE(available_abs_protocols); n++)
	if (!strcmp(name, available_abs_protocols[n]->name))
	return available_abs_protocols[n];
	#endif
	lwsl_err("%s: cannot find '%s'\n", __func__, name);

	return NULL;
	}

	const lws_token_map_t *
	lws_abs_get_token(const lws_token_map_t *token_map, short name_index)
	{
	if (!token_map)
	return NULL;

	do {
	if (token_map->name_index == name_index)
	return token_map;
	token_map++;
	} while (token_map->name_index);

	return NULL;
	}

	static int
	lws_abstract_compare_connection(lws_abs_t abs1, lws_abs_t abs2)
	{
	/* it has to be using the same protocol */
	if (abs1->ap != abs2->ap)
	return 1;

	/* protocol has to allow some kind of binding */
	if (!abs1->ap->flags)
	return 1;

	/* it has to be using the same transport */
	if (abs1->at != abs2->at)
	return 1;

	/*
	* The transport must feel the endpoint and conditions in use match the
	* requested endpoint and conditions... and the transport type must be
	* willing to allow it
	*/
	if (abs1->at->compare(abs1, abs2))
	return 1;

	/*
	* The protocol must feel they are in compatible modes if any
	* (and the protocol type must be willing to allow it)
	*/
	if (abs1->ap->compare(abs1, abs2))
	return 1;

	/*
	* If no objection by now, we can say there's already a comparable
	* connection and both the protocol and transport feel we can make
	* use of it.
	*/

	return 0;
	}

	static int
	find_compatible(struct lws_dll2 d, void user)
	{
	lws_abs_t ai1 = (lws_abs_t )user,
	*ai2 = lws_container_of(d, lws_abs_t, abstract_instances);

	if (!lws_abstract_compare_connection(ai1, ai2)) {
	/* we can bind to it */
	lws_dll2_add_tail(&ai1->bound, &ai2->children_owner);

	return 1;
	}

	return 0;
	}

	lws_abs_t *
	lws_abs_bind_and_create_instance(const lws_abs_t *abs)
	{
	size_t size = sizeof(lws_abs_t) + abs->ap->alloc + abs->at->alloc;
	lws_abs_t *ai;
	int n;

	/*
	* since we know we will allocate the lws_abs_t, the protocol's
	* instance allocation, and the transport's instance allocation,
	* we merge it into a single heap allocation
	*/
	ai = lws_malloc(size, "abs inst");
	if (!ai)
	return NULL;

	ai = abs;
	ai->ati = NULL;

	ai->api = (char *)ai + sizeof(lws_abs_t);

	if (!ai->ap->flags) /* protocol only understands single connections */
	goto fresh;

	lws_vhost_lock(ai->vh); /* ----------------------------------- vh { */

	/*
	* Let's have a look for any already-connected transport we can use
	*/

	n = lws_dll2_foreach_safe(&ai->vh->abstract_instances_owner, ai,
	find_compatible);

	lws_vhost_unlock(ai->vh); /* } vh --------------------------------- */

	if (n)
	goto vh_list_add;

	/* there's no existing connection doing what we want */

	fresh:

	ai->ati = (char *)ai->api + abs->ap->alloc;
	if (ai->at->create(ai)) {
	ai->ati = NULL;
	goto bail;
	}

	vh_list_add:
	/* add us to the vhost's dll2 of instances */

	lws_dll2_clear(&ai->abstract_instances);
	lws_dll2_add_head(&ai->abstract_instances,
	&ai->vh->abstract_instances_owner);

	if (ai->ap->create(ai)) {
	ai->api = NULL;
	goto bail;
	}

	if (ai->bound.owner) { /* we are a piggybacker */
	lws_abs_t *ai2 = lws_container_of(ai->bound.owner, lws_abs_t,
	children_owner);
	/*
	* Provide an 'event' in the parent context to start handling
	* the bind if it's otherwise idle. We give the parent abs
	* because we don't know if we're "next" or whatever. Just that
	* a child joined him and he should look into his child
	* situation in case he was waiting for one to appear.
	*/
	if (ai2->ap->child_bind(ai2)) {
	lwsl_info("%s: anticpated child bind fail\n", __func__);
	lws_dll2_remove(&ai->bound);

	goto bail;
	}
	}

	return ai;

	bail:
	lws_abs_destroy_instance(&ai);

	return NULL;
	}

	/*
	* We get called to clean up each child that was still bound to a parent
	* at the time the parent is getting destroyed.
	*/

	static void
	__lws_abs_destroy_instance2(lws_abs_t **ai)
	{
	lws_abs_t a = ai;

	if (a->api)
	a->ap->destroy(&a->api);
	if (a->ati)
	a->at->destroy(&a->ati);

	lws_dll2_remove(&a->abstract_instances);

	*ai = NULL;
	free(a);
	}

	static int
	__reap_children(struct lws_dll2 d, void user)
	{
	lws_abs_t *ac = lws_container_of(d, lws_abs_t, bound);

	lws_dll2_foreach_safe(&ac->children_owner, NULL, __reap_children);

	/* then destroy ourselves */

	__lws_abs_destroy_instance2(&ac);

	return 0;
	}

	void
	lws_abs_destroy_instance(lws_abs_t **ai)
	{
	lws_abs_t a = ai;

	/* destroy child instances that are bound to us first... */

	lws_vhost_lock(a->vh); /* ----------------------------------- vh { */

	lws_dll2_foreach_safe(&a->children_owner, NULL, __reap_children);

	/* ...then destroy ourselves */

	__lws_abs_destroy_instance2(ai);

	lws_vhost_unlock(a->vh); /* } vh --------------------------------- */
	}

	lws_abs_t *
	lws_abstract_alloc(struct lws_vhost vhost, void user,
	const char abstract_path, const lws_token_map_t ap_tokens,
	const lws_token_map_t at_tokens, struct lws_sequencer seq,
	void *opaque_user_data)
	{
	lws_abs_t abs = lws_zalloc(sizeof(abs), __func__);
	struct lws_tokenize ts;
	lws_tokenize_elem e;
	char tmp[30];

	if (!abs)
	return NULL;

	lws_tokenize_init(&ts, abstract_path, LWS_TOKENIZE_F_MINUS_NONTERM);

	e = lws_tokenize(&ts);
	if (e != LWS_TOKZE_TOKEN)
	goto abs_path_problem;

	if (lws_tokenize_cstr(&ts, tmp, sizeof(tmp)))
	goto abs_path_problem;

	abs->ap = lws_abs_protocol_get_by_name(tmp);
	if (!abs->ap)
	goto abs_path_problem;

	e = lws_tokenize(&ts);
	if (e != LWS_TOKZE_DELIMITER)
	goto abs_path_problem;

	e = lws_tokenize(&ts);
	if (e != LWS_TOKZE_TOKEN)
	goto abs_path_problem;

	if (lws_tokenize_cstr(&ts, tmp, sizeof(tmp)))
	goto abs_path_problem;

	abs->at = lws_abs_transport_get_by_name(tmp);
	if (!abs->at)
	goto abs_path_problem;

	abs->vh = vhost;
	abs->ap_tokens = ap_tokens;
	abs->at_tokens = at_tokens;
	abs->seq = seq;
	abs->opaque_user_data = opaque_user_data;

	lwsl_info("%s: allocated %s\n", __func__, abstract_path);

	return abs;

	abs_path_problem:
	lwsl_err("%s: bad abs path '%s'\n", __func__, abstract_path);
	lws_free_set_NULL(abs);

	return NULL;
	}

	void
	lws_abstract_free(lws_abs_t **pabs)
	{
	if (*pabs)
	lws_free_set_NULL(*pabs);
	}