messagepackageheader.java

JXTA&#8482 is a set of open, generalized peer-to-peer (P2P) protocols that allow any networked devi

/*
 * Copyright (c) 2001-2007 Sun Microsystems, Inc.  All rights reserved.
 *  
 *  The Sun Project JXTA(TM) Software License
 *  
 *  Redistribution and use in source and binary forms, with or without 
 *  modification, are permitted provided that the following conditions are met:
 *  
 *  1. Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *  
 *  2. 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.
 *  
 *  3. The end-user documentation included with the redistribution, if any, must 
 *     include the following acknowledgment: "This product includes software 
 *     developed by Sun Microsystems, Inc. for JXTA(TM) technology." 
 *     Alternately, this acknowledgment may appear in the software itself, if 
 *     and wherever such third-party acknowledgments normally appear.
 *  
 *  4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must 
 *     not be used to endorse or promote products derived from this software 
 *     without prior written permission. For written permission, please contact 
 *     Project JXTA at http://www.jxta.org.
 *  
 *  5. Products derived from this software may not be called "JXTA", nor may 
 *     "JXTA" appear in their name, without prior written permission of Sun.
 *  
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 SUN 
 *  MICROSYSTEMS OR ITS 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.
 *  
 *  JXTA is a registered trademark of Sun Microsystems, Inc. in the United 
 *  States and other countries.
 *  
 *  Please see the license information page at :
 *  <http://www.jxta.org/project/www/license.html> for instructions on use of 
 *  the license in source files.
 *  
 *  ====================================================================
 *  
 *  This software consists of voluntary contributions made by many individuals 
 *  on behalf of Project JXTA. For more information on Project JXTA, please see 
 *  http://www.jxta.org.
 *  
 *  This license is based on the BSD license adopted by the Apache Foundation. 
 */

package net.jxta.impl.endpoint.msgframing;


import java.util.logging.Level;
import net.jxta.logging.Logging;
import java.util.logging.Logger;

import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.text.MessageFormat;
import java.util.ListIterator;

import net.jxta.document.MimeMediaType;


/**
 * Header Package for Messages. Analogous to HTTP Headers.
 */
public class MessagePackageHeader {
    
    /**
     * Logger
     */
    private final static transient Logger LOG = Logger.getLogger(MessagePackageHeader.class.getName());
    
    /**
     * Standard header name for content-length
     */
    private final static String CONTENT_LENGTH = "content-length";
    
    /**
     * Standard header name for content-type
     */
    private final static String CONTENT_TYPE = "content-type";
    
    /**
     * The maximum size of Header data buffers we will emit.
     */
    private final static int MAX_HEADER_LEN = 1024;
    
    /**
     * Used for storing individual header elements.
     */
    public static class Header {
        
        final String  name;
        final byte[] value;
        
        public Header(String name, byte[] value) {
            this.name = name;
            
            assert value.length <= 65535;
            
            this.value = value;
        }
        
        /**
         * {@inheritDoc}
         */
        @Override
        public String toString() {
            return MessageFormat.format("{0} := {1}", name, value);
        }
        
        public String getName() {
            return name;
        }
        
        public byte[] getValue() {
            return value;
        }
        
        public String getValueString() {
            try {
                return new String(value, "UTF-8");
            } catch (UnsupportedEncodingException never) {
                // utf-8 is a required encoding.
                throw new Error("UTF-8 encoding support missing!");
            }
        }
    }
    
    /**
     * The individual header elements in the order they were read.
     */
    private final List<Header> headers = new ArrayList<Header>();
    
    /**
     * Creates a new instance of MessagePackageHeader. Used for outgoing messages.
     */
    public MessagePackageHeader() {}
    
    /**
     * Creates a new instance of MessagePackageHeader. Used for incoming messages.
     *
     * @param in The stream from which the headers will be read.
     * @throws java.io.IOException if an io error occurs.
     */
    public MessagePackageHeader(InputStream in) throws IOException {
        boolean sawEmpty = false;
        boolean sawLength = false;
        boolean sawType = false;
        DataInput di = new DataInputStream(in);
        
        // todo 20021014 [e-mail] A framing signature would help here.
        
        do {
            byte headerNameLength = di.readByte();
            
            if (0 == headerNameLength) {
                sawEmpty = true;
            } else {
                byte[] headerNameBytes = new byte[headerNameLength];
                
                di.readFully(headerNameBytes);
                
                String headerNameString = new String(headerNameBytes, "UTF-8");
                
                if (headerNameString.equalsIgnoreCase(CONTENT_LENGTH)) {
                    if (sawLength) {
                        throw new IOException("Duplicate content-length header");
                    }
                    sawLength = true;
                }
                
                if (headerNameString.equalsIgnoreCase(CONTENT_TYPE)) {
                    if (sawType) {
                        throw new IOException("Duplicate content-type header");
                    }
                    sawType = true;
                }
                
                int headerValueLength = di.readUnsignedShort();
                
                byte[] headerValueBytes = new byte[headerValueLength];
                
                di.readFully(headerValueBytes);
                
                headers.add(new Header(headerNameString, headerValueBytes));
                
            }
        } while (!sawEmpty);
        
        if (!sawLength) {
            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.warning("Content Length header was missing");
            }
            throw new IOException("Content Length header was missing");
        }
        
        if (!sawType) {
            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.warning("Content Type header was missing");
            }
            throw new IOException("Content Type header was missing");
        }
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public String toString() {
        StringBuilder result = new StringBuilder();
        
        result.append('[');
        
        Iterator<Header> eachHeader = getHeaders();

        while (eachHeader.hasNext()) {
            Header aHeader = eachHeader.next();
            
            result.append(" {");
            result.append(aHeader);
            result.append('}');
            
            if (eachHeader.hasNext()) {
                result.append(',');
            }
        }
        
        result.append(']');
        
        return result.toString();
    }
    
    /**
     * Returns number of header elements otherwise -1
     *
     * @param buffer the byte buffer
     * @return number of header elements
     */
    private int getHeaderCount(ByteBuffer buffer) {
        int pos = buffer.position();
        int limit = buffer.limit();
        int headerCount = 0;
        boolean sawZero = false;
        
        while (pos < limit) {
            // get header name length
            int len = buffer.get(pos) & 0xFF;

            pos += 1;
            
            if (0 == len) {
                sawZero = true;
                break;
            }
            
            // advance past name
            pos += len;
            
            if ((pos + 2) >= limit) {
                // not enough data
                break;
            }
            
            // get value length
            len = buffer.getShort(pos) & 0xFFFF;
            pos += 2;
            
            // advance past value
            pos += len;
            
            headerCount++;
        }
        
        return sawZero ? headerCount : -1;
    }
    
    /**
     * Reads a Header from a ByteBuffer
     *
     * @param buffer the input buffer
     * @return {@code true} If the header block was completely read.
     * @throws IOException if an io error is encountered
     */