src/core/tsi/transport_security.c - platform/external/grpc-grpc - Gitiles

 /*
  *
  * Copyright 2014, Google Inc.
  * All rights reserved.
  *
  * 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.
  *     * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */

 #include "src/core/tsi/transport_security.h"

 #include <stdlib.h>
 #include <string.h>

 /* --- Utils. --- */

 char* tsi_strdup(const char* src) {
   char* dst;
   size_t len;
   if (!src) return NULL;
   len = strlen(src) + 1;
   dst = malloc(len);
   if (!dst) return NULL;
   memcpy(dst, src, len);
   return dst;
 }

 /* --- tsi_result common implementation. --- */

 const char* tsi_result_to_string(tsi_result result) {
   switch (result) {
     case TSI_OK:
       return "TSI_OK";
     case TSI_UNKNOWN_ERROR:
       return "TSI_UNKNOWN_ERROR";
     case TSI_INVALID_ARGUMENT:
       return "TSI_INVALID_ARGUMENT";
     case TSI_PERMISSION_DENIED:
       return "TSI_PERMISSION_DENIED";
     case TSI_INCOMPLETE_DATA:
       return "TSI_INCOMPLETE_DATA";
     case TSI_FAILED_PRECONDITION:
       return "TSI_FAILED_PRECONDITION";
     case TSI_UNIMPLEMENTED:
       return "TSI_UNIMPLEMENTED";
     case TSI_INTERNAL_ERROR:
       return "TSI_INTERNAL_ERROR";
     case TSI_DATA_CORRUPTED:
       return "TSI_DATA_CORRUPTED";
     case TSI_NOT_FOUND:
       return "TSI_NOT_FOUND";
     case TSI_PROTOCOL_FAILURE:
       return "TSI_PROTOCOL_FAILURE";
     case TSI_HANDSHAKE_IN_PROGRESS:
       return "TSI_HANDSHAKE_IN_PROGRESS";
     case TSI_OUT_OF_RESOURCES:
       return "TSI_OUT_OF_RESOURCES";
     default:
       return "UNKNOWN";
   }
 }

 /* --- tsi_frame_protector common implementation. ---

    Calls specific implementation after state/input validation. */

 tsi_result tsi_frame_protector_protect(tsi_frame_protector* self,
                                        const unsigned char* unprotected_bytes,
                                        size_t* unprotected_bytes_size,
                                        unsigned char* protected_output_frames,
                                        size_t* protected_output_frames_size) {
   if (self == NULL || unprotected_bytes == NULL ||
       unprotected_bytes_size == NULL || protected_output_frames == NULL ||
       protected_output_frames_size == NULL) {
     return TSI_INVALID_ARGUMENT;
   }
   return self->vtable->protect(self, unprotected_bytes, unprotected_bytes_size,
                                protected_output_frames,
                                protected_output_frames_size);
 }

 tsi_result tsi_frame_protector_protect_flush(
     tsi_frame_protector* self, unsigned char* protected_output_frames,
     size_t* protected_output_frames_size, size_t* still_pending_size) {
   if (self == NULL || protected_output_frames == NULL ||
       protected_output_frames == NULL || still_pending_size == NULL) {
     return TSI_INVALID_ARGUMENT;
   }
   return self->vtable->protect_flush(self, protected_output_frames,
                                      protected_output_frames_size,
                                      still_pending_size);
 }

 tsi_result tsi_frame_protector_unprotect(
     tsi_frame_protector* self, const unsigned char* protected_frames_bytes,
     size_t* protected_frames_bytes_size, unsigned char* unprotected_bytes,
     size_t* unprotected_bytes_size) {
   if (self == NULL || protected_frames_bytes == NULL ||
       protected_frames_bytes_size == NULL || unprotected_bytes == NULL ||
       unprotected_bytes_size == NULL) {
     return TSI_INVALID_ARGUMENT;
   }
   return self->vtable->unprotect(self, protected_frames_bytes,
                                  protected_frames_bytes_size, unprotected_bytes,
                                  unprotected_bytes_size);
 }

 void tsi_frame_protector_destroy(tsi_frame_protector* self) {
   if (self == NULL) return;
   self->vtable->destroy(self);
 }

 /* --- tsi_handshaker common implementation. ---

    Calls specific implementation after state/input validation. */

 tsi_result tsi_handshaker_get_bytes_to_send_to_peer(tsi_handshaker* self,
                                                     unsigned char* bytes,
                                                     size_t* bytes_size) {
   if (self == NULL) return TSI_INVALID_ARGUMENT;
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
   return self->vtable->get_bytes_to_send_to_peer(self, bytes, bytes_size);
 }

 tsi_result tsi_handshaker_process_bytes_from_peer(tsi_handshaker* self,
                                                   const unsigned char* bytes,
                                                   size_t* bytes_size) {
   if (self == NULL) return TSI_INVALID_ARGUMENT;
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
   return self->vtable->process_bytes_from_peer(self, bytes, bytes_size);
 }

 tsi_result tsi_handshaker_get_result(tsi_handshaker* self) {
   if (self == NULL) return TSI_INVALID_ARGUMENT;
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
   return self->vtable->get_result(self);
 }

 tsi_result tsi_handshaker_extract_peer(tsi_handshaker* self, tsi_peer* peer) {
   if (self == NULL || peer == NULL) return TSI_INVALID_ARGUMENT;
   memset(peer, 0, sizeof(tsi_peer));
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
   if (tsi_handshaker_get_result(self) != TSI_OK) {
     return TSI_FAILED_PRECONDITION;
   }
   return self->vtable->extract_peer(self, peer);
 }

 tsi_result tsi_handshaker_create_frame_protector(
     tsi_handshaker* self, size_t* max_protected_frame_size,
     tsi_frame_protector** protector) {
   tsi_result result;
   if (self == NULL || protector == NULL) return TSI_INVALID_ARGUMENT;
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
   if (tsi_handshaker_get_result(self) != TSI_OK) {
     return TSI_FAILED_PRECONDITION;
   }
   result = self->vtable->create_frame_protector(self, max_protected_frame_size,
                                                 protector);
   if (result == TSI_OK) {
     self->frame_protector_created = 1;
   }
   return result;
 }

 void tsi_handshaker_destroy(tsi_handshaker* self) {
   if (self == NULL) return;
   self->vtable->destroy(self);
 }

 /* --- tsi_peer implementation. --- */

 const tsi_peer_property* tsi_peer_get_property_by_name(const tsi_peer* self,
                                                        const char* name) {
   size_t i;
   if (self == NULL) return NULL;
   for (i = 0; i < self->property_count; i++) {
     const tsi_peer_property* property = &self->properties[i];
     if (name == NULL && property->name == NULL) {
       return property;
     }
     if (name != NULL && property->name != NULL &&
         !strcmp(property->name, name)) {
       return property;
     }
   }
   return NULL;
 }

 tsi_peer_property tsi_init_peer_property(void) {
   tsi_peer_property property;
   memset(&property, 0, sizeof(tsi_peer_property));
   return property;
 }

 static void tsi_peer_destroy_list_property(tsi_peer_property* children,
                                            size_t child_count) {
   size_t i;
   for (i = 0; i < child_count; i++) {
     tsi_peer_property_destruct(&children[i]);
   }
   free(children);
 }

 void tsi_peer_property_destruct(tsi_peer_property* property) {
   if (property->name != NULL) {
     free(property->name);
   }
   switch (property->type) {
     case TSI_PEER_PROPERTY_TYPE_STRING:
       if (property->value.string.data != NULL) {
         free(property->value.string.data);
       }
       break;
     case TSI_PEER_PROPERTY_TYPE_LIST:
       tsi_peer_destroy_list_property(property->value.list.children,
                                      property->value.list.child_count);
     default:
       /* Nothing to free. */
       break;
   }
   *property = tsi_init_peer_property(); /* Reset everything to 0. */
 }

 void tsi_peer_destruct(tsi_peer* self) {
   if (self == NULL) return;
   if (self->properties != NULL) {
     tsi_peer_destroy_list_property(self->properties, self->property_count);
     self->properties = NULL;
   }
   self->property_count = 0;
 }

 tsi_result tsi_construct_signed_integer_peer_property(
     const char* name, int64_t value, tsi_peer_property* property) {
   *property = tsi_init_peer_property();
   property->type = TSI_PEER_PROPERTY_TYPE_SIGNED_INTEGER;
   if (name != NULL) {
     property->name = tsi_strdup(name);
     if (property->name == NULL) return TSI_OUT_OF_RESOURCES;
   }
   property->value.signed_int = value;
   return TSI_OK;
 }

 tsi_result tsi_construct_unsigned_integer_peer_property(
     const char* name, uint64_t value, tsi_peer_property* property) {
   *property = tsi_init_peer_property();
   property->type = TSI_PEER_PROPERTY_TYPE_UNSIGNED_INTEGER;
   if (name != NULL) {
     property->name = tsi_strdup(name);
     if (property->name == NULL) return TSI_OUT_OF_RESOURCES;
   }
   property->value.unsigned_int = value;
   return TSI_OK;
 }

 tsi_result tsi_construct_real_peer_property(const char* name, double value,
                                             tsi_peer_property* property) {
   *property = tsi_init_peer_property();
   property->type = TSI_PEER_PROPERTY_TYPE_REAL;
   if (name != NULL) {
     property->name = tsi_strdup(name);
     if (property->name == NULL) return TSI_OUT_OF_RESOURCES;
   }
   property->value.real = value;
   return TSI_OK;
 }

 tsi_result tsi_construct_allocated_string_peer_property(
     const char* name, size_t value_length, tsi_peer_property* property) {
   *property = tsi_init_peer_property();
   property->type = TSI_PEER_PROPERTY_TYPE_STRING;
   if (name != NULL) {
     property->name = tsi_strdup(name);
     if (property->name == NULL) return TSI_OUT_OF_RESOURCES;
   }
   if (value_length > 0) {
     property->value.string.data = calloc(1, value_length);
     if (property->value.string.data == NULL) {
       tsi_peer_property_destruct(property);
       return TSI_OUT_OF_RESOURCES;
     }
     property->value.string.length = value_length;
   }
   return TSI_OK;
 }

 tsi_result tsi_construct_string_peer_property_from_cstring(
     const char* name, const char* value, tsi_peer_property* property) {
   return tsi_construct_string_peer_property(name, value, strlen(value),
                                             property);
 }

 tsi_result tsi_construct_string_peer_property(const char* name,
                                               const char* value,
                                               size_t value_length,
                                               tsi_peer_property* property) {
   tsi_result result = tsi_construct_allocated_string_peer_property(
       name, value_length, property);
   if (result != TSI_OK) return result;
   if (value_length > 0) {
     memcpy(property->value.string.data, value, value_length);
   }
   return TSI_OK;
 }

 tsi_result tsi_construct_list_peer_property(const char* name,
                                             size_t child_count,
                                             tsi_peer_property* property) {
   *property = tsi_init_peer_property();
   property->type = TSI_PEER_PROPERTY_TYPE_LIST;
   if (name != NULL) {
     property->name = tsi_strdup(name);
     if (property->name == NULL) return TSI_OUT_OF_RESOURCES;
   }
   if (child_count > 0) {
     property->value.list.children =
         calloc(child_count, sizeof(tsi_peer_property));
     if (property->value.list.children == NULL) {
       tsi_peer_property_destruct(property);
       return TSI_OUT_OF_RESOURCES;
     }
     property->value.list.child_count = child_count;
   }
   return TSI_OK;
 }

 tsi_result tsi_construct_peer(size_t property_count, tsi_peer* peer) {
   memset(peer, 0, sizeof(tsi_peer));
   if (property_count > 0) {
     peer->properties = calloc(property_count, sizeof(tsi_peer_property));
     if (peer->properties == NULL) return TSI_OUT_OF_RESOURCES;
     peer->property_count = property_count;
   }
   return TSI_OK;
 }
	/*
	*
	* Copyright 2014, Google Inc.
	* All rights reserved.
	*
	* 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.
	* * Neither the name of Google Inc. nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*
	*/

	#include "src/core/tsi/transport_security.h"

	#include <stdlib.h>
	#include <string.h>

	/* --- Utils. --- */

	char* tsi_strdup(const char* src) {
	char* dst;
	size_t len;
	if (!src) return NULL;
	len = strlen(src) + 1;
	dst = malloc(len);
	if (!dst) return NULL;
	memcpy(dst, src, len);
	return dst;
	}

	/* --- tsi_result common implementation. --- */

	const char* tsi_result_to_string(tsi_result result) {
	switch (result) {
	case TSI_OK:
	return "TSI_OK";
	case TSI_UNKNOWN_ERROR:
	return "TSI_UNKNOWN_ERROR";
	case TSI_INVALID_ARGUMENT:
	return "TSI_INVALID_ARGUMENT";
	case TSI_PERMISSION_DENIED:
	return "TSI_PERMISSION_DENIED";
	case TSI_INCOMPLETE_DATA:
	return "TSI_INCOMPLETE_DATA";
	case TSI_FAILED_PRECONDITION:
	return "TSI_FAILED_PRECONDITION";
	case TSI_UNIMPLEMENTED:
	return "TSI_UNIMPLEMENTED";
	case TSI_INTERNAL_ERROR:
	return "TSI_INTERNAL_ERROR";
	case TSI_DATA_CORRUPTED:
	return "TSI_DATA_CORRUPTED";
	case TSI_NOT_FOUND:
	return "TSI_NOT_FOUND";
	case TSI_PROTOCOL_FAILURE:
	return "TSI_PROTOCOL_FAILURE";
	case TSI_HANDSHAKE_IN_PROGRESS:
	return "TSI_HANDSHAKE_IN_PROGRESS";
	case TSI_OUT_OF_RESOURCES:
	return "TSI_OUT_OF_RESOURCES";
	default:
	return "UNKNOWN";
	}
	}

	/* --- tsi_frame_protector common implementation. ---

	Calls specific implementation after state/input validation. */

	tsi_result tsi_frame_protector_protect(tsi_frame_protector* self,
	const unsigned char* unprotected_bytes,
	size_t* unprotected_bytes_size,
	unsigned char* protected_output_frames,
	size_t* protected_output_frames_size) {
	if (self == NULL \|\| unprotected_bytes == NULL \|\|
	unprotected_bytes_size == NULL \|\| protected_output_frames == NULL \|\|
	protected_output_frames_size == NULL) {
	return TSI_INVALID_ARGUMENT;
	}
	return self->vtable->protect(self, unprotected_bytes, unprotected_bytes_size,
	protected_output_frames,
	protected_output_frames_size);
	}

	tsi_result tsi_frame_protector_protect_flush(
	tsi_frame_protector* self, unsigned char* protected_output_frames,
	size_t* protected_output_frames_size, size_t* still_pending_size) {
	if (self == NULL \|\| protected_output_frames == NULL \|\|
	protected_output_frames == NULL \|\| still_pending_size == NULL) {
	return TSI_INVALID_ARGUMENT;
	}
	return self->vtable->protect_flush(self, protected_output_frames,
	protected_output_frames_size,
	still_pending_size);
	}

	tsi_result tsi_frame_protector_unprotect(
	tsi_frame_protector* self, const unsigned char* protected_frames_bytes,
	size_t* protected_frames_bytes_size, unsigned char* unprotected_bytes,
	size_t* unprotected_bytes_size) {
	if (self == NULL \|\| protected_frames_bytes == NULL \|\|
	protected_frames_bytes_size == NULL \|\| unprotected_bytes == NULL \|\|
	unprotected_bytes_size == NULL) {
	return TSI_INVALID_ARGUMENT;
	}
	return self->vtable->unprotect(self, protected_frames_bytes,
	protected_frames_bytes_size, unprotected_bytes,
	unprotected_bytes_size);
	}

	void tsi_frame_protector_destroy(tsi_frame_protector* self) {
	if (self == NULL) return;
	self->vtable->destroy(self);
	}

	/* --- tsi_handshaker common implementation. ---

	Calls specific implementation after state/input validation. */

	tsi_result tsi_handshaker_get_bytes_to_send_to_peer(tsi_handshaker* self,
	unsigned char* bytes,
	size_t* bytes_size) {
	if (self == NULL) return TSI_INVALID_ARGUMENT;
	if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
	return self->vtable->get_bytes_to_send_to_peer(self, bytes, bytes_size);
	}

	tsi_result tsi_handshaker_process_bytes_from_peer(tsi_handshaker* self,
	const unsigned char* bytes,
	size_t* bytes_size) {
	if (self == NULL) return TSI_INVALID_ARGUMENT;
	if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
	return self->vtable->process_bytes_from_peer(self, bytes, bytes_size);
	}

	tsi_result tsi_handshaker_get_result(tsi_handshaker* self) {
	if (self == NULL) return TSI_INVALID_ARGUMENT;
	if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
	return self->vtable->get_result(self);
	}

	tsi_result tsi_handshaker_extract_peer(tsi_handshaker* self, tsi_peer* peer) {
	if (self == NULL \|\| peer == NULL) return TSI_INVALID_ARGUMENT;
	memset(peer, 0, sizeof(tsi_peer));
	if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
	if (tsi_handshaker_get_result(self) != TSI_OK) {
	return TSI_FAILED_PRECONDITION;
	}
	return self->vtable->extract_peer(self, peer);
	}

	tsi_result tsi_handshaker_create_frame_protector(
	tsi_handshaker* self, size_t* max_protected_frame_size,
	tsi_frame_protector** protector) {
	tsi_result result;
	if (self == NULL \|\| protector == NULL) return TSI_INVALID_ARGUMENT;
	if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
	if (tsi_handshaker_get_result(self) != TSI_OK) {
	return TSI_FAILED_PRECONDITION;
	}
	result = self->vtable->create_frame_protector(self, max_protected_frame_size,
	protector);
	if (result == TSI_OK) {
	self->frame_protector_created = 1;
	}
	return result;
	}

	void tsi_handshaker_destroy(tsi_handshaker* self) {
	if (self == NULL) return;
	self->vtable->destroy(self);
	}

	/* --- tsi_peer implementation. --- */

	const tsi_peer_property* tsi_peer_get_property_by_name(const tsi_peer* self,
	const char* name) {
	size_t i;
	if (self == NULL) return NULL;
	for (i = 0; i < self->property_count; i++) {
	const tsi_peer_property* property = &self->properties[i];
	if (name == NULL && property->name == NULL) {
	return property;
	}
	if (name != NULL && property->name != NULL &&
	!strcmp(property->name, name)) {
	return property;
	}
	}
	return NULL;
	}

	tsi_peer_property tsi_init_peer_property(void) {
	tsi_peer_property property;
	memset(&property, 0, sizeof(tsi_peer_property));
	return property;
	}

	static void tsi_peer_destroy_list_property(tsi_peer_property* children,
	size_t child_count) {
	size_t i;
	for (i = 0; i < child_count; i++) {
	tsi_peer_property_destruct(&children[i]);
	}
	free(children);
	}

	void tsi_peer_property_destruct(tsi_peer_property* property) {
	if (property->name != NULL) {
	free(property->name);
	}
	switch (property->type) {
	case TSI_PEER_PROPERTY_TYPE_STRING:
	if (property->value.string.data != NULL) {
	free(property->value.string.data);
	}
	break;
	case TSI_PEER_PROPERTY_TYPE_LIST:
	tsi_peer_destroy_list_property(property->value.list.children,
	property->value.list.child_count);
	default:
	/* Nothing to free. */
	break;
	}
	property = tsi_init_peer_property(); / Reset everything to 0. */
	}

	void tsi_peer_destruct(tsi_peer* self) {
	if (self == NULL) return;
	if (self->properties != NULL) {
	tsi_peer_destroy_list_property(self->properties, self->property_count);
	self->properties = NULL;
	}
	self->property_count = 0;
	}

	tsi_result tsi_construct_signed_integer_peer_property(
	const char* name, int64_t value, tsi_peer_property* property) {
	*property = tsi_init_peer_property();
	property->type = TSI_PEER_PROPERTY_TYPE_SIGNED_INTEGER;
	if (name != NULL) {
	property->name = tsi_strdup(name);
	if (property->name == NULL) return TSI_OUT_OF_RESOURCES;
	}
	property->value.signed_int = value;
	return TSI_OK;
	}

	tsi_result tsi_construct_unsigned_integer_peer_property(
	const char* name, uint64_t value, tsi_peer_property* property) {
	*property = tsi_init_peer_property();
	property->type = TSI_PEER_PROPERTY_TYPE_UNSIGNED_INTEGER;
	if (name != NULL) {
	property->name = tsi_strdup(name);
	if (property->name == NULL) return TSI_OUT_OF_RESOURCES;
	}
	property->value.unsigned_int = value;
	return TSI_OK;
	}

	tsi_result tsi_construct_real_peer_property(const char* name, double value,
	tsi_peer_property* property) {
	*property = tsi_init_peer_property();
	property->type = TSI_PEER_PROPERTY_TYPE_REAL;
	if (name != NULL) {
	property->name = tsi_strdup(name);
	if (property->name == NULL) return TSI_OUT_OF_RESOURCES;
	}
	property->value.real = value;
	return TSI_OK;
	}

	tsi_result tsi_construct_allocated_string_peer_property(
	const char* name, size_t value_length, tsi_peer_property* property) {
	*property = tsi_init_peer_property();
	property->type = TSI_PEER_PROPERTY_TYPE_STRING;
	if (name != NULL) {
	property->name = tsi_strdup(name);
	if (property->name == NULL) return TSI_OUT_OF_RESOURCES;
	}
	if (value_length > 0) {
	property->value.string.data = calloc(1, value_length);
	if (property->value.string.data == NULL) {
	tsi_peer_property_destruct(property);
	return TSI_OUT_OF_RESOURCES;
	}
	property->value.string.length = value_length;
	}
	return TSI_OK;
	}

	tsi_result tsi_construct_string_peer_property_from_cstring(
	const char* name, const char* value, tsi_peer_property* property) {
	return tsi_construct_string_peer_property(name, value, strlen(value),
	property);
	}

	tsi_result tsi_construct_string_peer_property(const char* name,
	const char* value,
	size_t value_length,
	tsi_peer_property* property) {
	tsi_result result = tsi_construct_allocated_string_peer_property(
	name, value_length, property);
	if (result != TSI_OK) return result;
	if (value_length > 0) {
	memcpy(property->value.string.data, value, value_length);
	}
	return TSI_OK;
	}

	tsi_result tsi_construct_list_peer_property(const char* name,
	size_t child_count,
	tsi_peer_property* property) {
	*property = tsi_init_peer_property();
	property->type = TSI_PEER_PROPERTY_TYPE_LIST;
	if (name != NULL) {
	property->name = tsi_strdup(name);
	if (property->name == NULL) return TSI_OUT_OF_RESOURCES;
	}
	if (child_count > 0) {
	property->value.list.children =
	calloc(child_count, sizeof(tsi_peer_property));
	if (property->value.list.children == NULL) {
	tsi_peer_property_destruct(property);
	return TSI_OUT_OF_RESOURCES;
	}
	property->value.list.child_count = child_count;
	}
	return TSI_OK;
	}

	tsi_result tsi_construct_peer(size_t property_count, tsi_peer* peer) {
	memset(peer, 0, sizeof(tsi_peer));
	if (property_count > 0) {
	peer->properties = calloc(property_count, sizeof(tsi_peer_property));
	if (peer->properties == NULL) return TSI_OUT_OF_RESOURCES;
	peer->property_count = property_count;
	}
	return TSI_OK;
	}