src/net/pccrd.c

/*
 * Copyright (C) 2015 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * 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.
 *
 * You can also choose to distribute this program under the terms of
 * the Unmodified Binary Distribution Licence (as given in the file
 * COPYING.UBDL), provided that you have satisfied its requirements.
 */

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <assert.h>
#include <ipxe/pccrd.h>

/** @file
 *
 * Peer Content Caching and Retrieval: Discovery Protocol [MS-PCCRD]
 *
 * This protocol manages to ingeniously combine the excessive
 * verbosity of XML with a paucity of actual information.  For
 * example: even in version 2.0 of the protocol it is still not
 * possible to discover which peers hold a specific block within a
 * given segment.
 *
 * For added bonus points, version 1.0 of the protocol is specified to
 * use a case-sensitive string comparison (for SHA2 digest values) but
 * nothing specifies whether the strings in question should be in
 * upper or lower case.  There are example strings given in the
 * specification, but the author skilfully manages to leave the issue
 * unresolved by using the somewhat implausible digest value of
 * "0200000000000000000000000000000000000000000000000000000000000000".
 *
 * Just in case you were thinking that the silver lining of the choice
 * to use an XML-based protocol would be the ability to generate and
 * process messages with standard tools, version 2.0 of the protocol
 * places most of the critical information inside a Base64-encoded
 * custom binary data structure.  Within an XML element, naturally.
 *
 * I hereby announce this specification to be the 2015 winner of the
 * prestigious "UEFI HII API" award for incompetent design.
 */

/** Discovery request format */
#define PEERDIST_DISCOVERY_REQUEST					      \
	"<?xml version=\"1.0\" encoding=\"utf-8\"?>"			      \
	"<soap:Envelope "						      \
	    "xmlns:soap=\"http://www.w3.org/2003/05/soap-envelope\" "	      \
	    "xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" " \
	    "xmlns:wsd=\"http://schemas.xmlsoap.org/ws/2005/04/discovery\" "  \
	    "xmlns:PeerDist=\"http://schemas.microsoft.com/p2p/"	      \
			     "2007/09/PeerDistributionDiscovery\">"	      \
	  "<soap:Header>"						      \
	    "<wsa:To>"							      \
	      "urn:schemas-xmlsoap-org:ws:2005:04:discovery"		      \
	    "</wsa:To>"							      \
	    "<wsa:Action>"						      \
	      "http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe"	      \
	    "</wsa:Action>"						      \
	    "<wsa:MessageID>"						      \
	      "urn:uuid:%s"						      \
	    "</wsa:MessageID>"						      \
	  "</soap:Header>"						      \
	  "<soap:Body>"							      \
	    "<wsd:Probe>"						      \
	      "<wsd:Types>"						      \
		"PeerDist:PeerDistData"					      \
	      "</wsd:Types>"						      \
	      "<wsd:Scopes MatchBy=\"http://schemas.xmlsoap.org/ws/"	      \
				    "2005/04/discovery/strcmp0\">"	      \
		"%s"							      \
	      "</wsd:Scopes>"						      \
	    "</wsd:Probe>"						      \
	  "</soap:Body>"						      \
	"</soap:Envelope>"

/**
 * Construct discovery request
 *
 * @v uuid		Message UUID string
 * @v id		Segment identifier string
 * @ret request		Discovery request, or NULL on failure
 *
 * The request is dynamically allocated; the caller must eventually
 * free() the request.
 */
char * peerdist_discovery_request ( const char *uuid, const char *id ) {
	char *request;
	int len;

	/* Construct request */
	len = asprintf ( &request, PEERDIST_DISCOVERY_REQUEST, uuid, id );
	if ( len < 0 )
		return NULL;

	return request;
}

/**
 * Locate discovery reply tag
 *
 * @v data		Reply data (not NUL-terminated)
 * @v len		Length of reply data
 * @v tag		XML tag
 * @ret found		Found tag (or NULL if not found)
 */
static char * peerdist_discovery_reply_tag ( char *data, size_t len,
					     const char *tag ) {
	size_t tag_len = strlen ( tag );

	/* Search, allowing for the fact that the reply data is not
	 * cleanly NUL-terminated and may contain embedded NULs due to
	 * earlier parsing.
	 */
	for ( ; len >= tag_len ; data++, len-- ) {
		if ( strncmp ( data, tag, tag_len ) == 0 )
			return data;
	}
	return NULL;
}

/**
 * Locate discovery reply values
 *
 * @v data		Reply data (not NUL-terminated, will be modified)
 * @v len		Length of reply data
 * @v name		XML tag name
 * @ret values		Tag values (or NULL if not found)
 *
 * The reply data is modified by adding NULs and moving characters as
 * needed to produce a NUL-separated list of values, terminated with a
 * zero-length string.
 *
 * This is not supposed to be a full XML parser; it's supposed to
 * include just enough functionality to allow PeerDist discovery to
 * work with existing implementations.
 */
static char * peerdist_discovery_reply_values ( char *data, size_t len,
						const char *name ) {
	char buf[ 2 /* "</" */ + strlen ( name ) + 1 /* ">" */ + 1 /* NUL */ ];
	char *open;
	char *close;
	char *start;
	char *end;
	char *in;
	char *out;
	char c;

	/* Locate opening tag */
	snprintf ( buf, sizeof ( buf ), "<%s>", name );
	open = peerdist_discovery_reply_tag ( data, len, buf );
	if ( ! open )
		return NULL;
	start = ( open + strlen ( buf ) );
	len -= ( start - data );
	data = start;

	/* Locate closing tag */
	snprintf ( buf, sizeof ( buf ), "</%s>", name );
	close = peerdist_discovery_reply_tag ( data, len, buf );
	if ( ! close )
		return NULL;
	assert ( close >= open );
	end = close;

	/* Strip initial whitespace, convert other whitespace
	 * sequences to single NULs, add terminating pair of NULs.
	 * This will probably overwrite part of the closing tag.
	 */
	for ( in = start, out = start ; in < end ; in++ ) {
		c = *in;
		if ( isspace ( c ) ) {
			if ( ( out > start ) && ( out[-1] != '\0' ) )
				*(out++) = '\0';
		} else {
			*(out++) = c;
		}
	}
	*(out++) = '\0';
	*(out++) = '\0';
	assert ( out < ( close + strlen ( buf ) ) );

	return start;
}

/**
 * Parse discovery reply
 *
 * @v data		Reply data (not NUL-terminated, will be modified)
 * @v len		Length of reply data
 * @v reply		Discovery reply to fill in
 * @ret rc		Return status code
 *
 * The discovery reply includes pointers to strings within the
 * modified reply data.
 */
int peerdist_discovery_reply ( char *data, size_t len,
			       struct peerdist_discovery_reply *reply ) {
	static const struct peerdist_discovery_block_count zcount = {
		.hex = "00000000",
	};
	struct peerdist_discovery_block_count *count;
	unsigned int max;
	unsigned int i;
	char *scopes;
	char *xaddrs;
	char *blockcount;
	char *in;
	char *out;
	size_t skip;

	/* Find <wsd:Scopes> tag */
	scopes = peerdist_discovery_reply_values ( data, len, "wsd:Scopes" );
	if ( ! scopes ) {
		DBGC ( reply, "PCCRD %p missing <wsd:Scopes> tag\n", reply );
		return -ENOENT;
	}

	/* Find <wsd:XAddrs> tag */
	xaddrs = peerdist_discovery_reply_values ( data, len, "wsd:XAddrs" );
	if ( ! xaddrs ) {
		DBGC ( reply, "PCCRD %p missing <wsd:XAddrs> tag\n", reply );
		return -ENOENT;
	}

	/* Find <PeerDist:BlockCount> tag */
	blockcount = peerdist_discovery_reply_values ( data, len,
						       "PeerDist:BlockCount" );
	if ( ! blockcount ) {
		DBGC ( reply, "PCCRD %p missing <PeerDist:BlockCount> tag\n",
		       reply );
		return -ENOENT;
	}

	/* Determine maximum number of segments (according to number
	 * of entries in the block count list).
	 */
	max = ( strlen ( blockcount ) / sizeof ( *count ) );
	count = container_of ( blockcount,
			       struct peerdist_discovery_block_count, hex[0] );

	/* Eliminate any segments with a zero block count */
	for ( i = 0, in = scopes, out = scopes ; *in ; i++, in += skip ) {

		/* Fail if we have overrun the maximum number of segments */
		if ( i >= max ) {
			DBGC ( reply, "PCCRD %p too many segment IDs\n",
			       reply );
			return -EPROTO;
		}

		/* Delete segment if block count is zero */
		skip = ( strlen ( in ) + 1 /* NUL */ );
		if ( memcmp ( count[i].hex, zcount.hex,
			      sizeof ( zcount.hex ) ) == 0 )
			continue;
		strcpy ( out, in );
		out += skip;
	}
	out[0] = '\0'; /* Ensure list is terminated with a zero-length string */

	/* Fill in discovery reply */
	reply->ids = scopes;
	reply->locations = xaddrs;

	return 0;
}