pccrd.c

Go to the documentation of this file.

/*
 * 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 );
FILE_SECBOOT ( PERMITTED );

#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;
}