/* * Copyright (C) 2015 Michael Brown . * * 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 #include #include #include #include #include #include #include /** @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 \ "" \ "" \ "" \ "" \ "urn:schemas-xmlsoap-org:ws:2005:04:discovery" \ "" \ "" \ "http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe" \ "" \ "" \ "urn:uuid:%s" \ "" \ "" \ "" \ "" \ "" \ "PeerDist:PeerDistData" \ "" \ "" \ "%s" \ "" \ "" \ "" \ "" /** * 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 /* "" */ + 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 ), "", 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 tag */ scopes = peerdist_discovery_reply_values ( data, len, "wsd:Scopes" ); if ( ! scopes ) { DBGC ( reply, "PCCRD %p missing tag\n", reply ); return -ENOENT; } /* Find tag */ xaddrs = peerdist_discovery_reply_values ( data, len, "wsd:XAddrs" ); if ( ! xaddrs ) { DBGC ( reply, "PCCRD %p missing tag\n", reply ); return -ENOENT; } /* Find tag */ blockcount = peerdist_discovery_reply_values ( data, len, "PeerDist:BlockCount" ); if ( ! blockcount ) { DBGC ( reply, "PCCRD %p missing 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; }