messagepackageheader.java

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

    public boolean readHeader(ByteBuffer buffer) throws IOException {
        if (Logging.SHOW_FINE && LOG.isLoggable(Level.FINE)) {
            LOG.fine(MessageFormat.format("Parsing Package Header from byte buffer :{0}", buffer.toString()));
        }
        
        int count = getHeaderCount(buffer);

        if (count < 0) {
            return false;
        }
        for (int i = 1; i <= count; i++) {
            byte headerNameLength = buffer.get();
            byte[] headerNameBytes = new byte[headerNameLength];
            
            buffer.get(headerNameBytes);
            String headerNameString = new String(headerNameBytes, "UTF-8");
            int headerValueLength = buffer.getShort() & 0x0FFFF;  // unsigned
            byte[] headerValueBytes = new byte[headerValueLength];
            
            buffer.get(headerValueBytes);
            if (Logging.SHOW_FINER && LOG.isLoggable(Level.FINER)) {
                LOG.finer(MessageFormat.format("Adding Name {0}: {1}", headerNameString, headerValueBytes));
            }
            headers.add(new Header(headerNameString, headerValueBytes));
        }
        
        // get the end-of-pkg
        buffer.get();
        
        if (Logging.SHOW_FINER && LOG.isLoggable(Level.FINER)) {
            LOG.finer(MessageFormat.format("Parsed {0} header elements, buffer stats :{1}", count, buffer.toString()));
        }
        return true;
    }
    
    /**
     * Add a header.
     *
     * @param name  The header name. The UTF-8 encoded representation of this
     * name may not be longer than 255 bytes.
     * @param value The value for the header. May not exceed 65535 bytes in
     * length.
     */
    public void addHeader(String name, byte[] value) {
        if (name.length() > 255) {
            throw new IllegalArgumentException("name may not exceed 255 bytes in length.");
        }
        
        if (value.length > 65535) {
            throw new IllegalArgumentException("value may not exceed 65535 bytes in length.");
        }
        
        if (Logging.SHOW_FINER && LOG.isLoggable(Level.FINER)) {
            LOG.finer("Add header :" + name + "(" + name.length() + ") with " + value.length + " bytes of value");
        }
        
        headers.add(new Header(name, value));
    }
    
    /**
     * Add a header.
     *
     * @param name  The header name. The UTF-8 encoded representation of this
     * name may not be longer than 255 bytes.
     * @param value The value for the header. May not exceed 65535 bytes in
     * length.
     */
    public void addHeader(String name, String value) {        
        if (Logging.SHOW_FINER && LOG.isLoggable(Level.FINER)) {
            LOG.finer("Add header :" + name + "(" + name.length() + ") with " + value.length() + " chars of value");
        }
        
        try {
            addHeader(name, value.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException never) {
            // utf-8 is a required encoding.
            throw new IllegalStateException("UTF-8 encoding support missing!");
        }
    }
 
    /**
     * Replace a header. Replaces all existing headers with the same name.
     *
     * @param name  The header name. The UTF-8 encoded representation of this
     * name may not be longer than 255 bytes.
     * @param value The value for the header. May not exceed 65535 bytes in
     * length.
     */
    public void replaceHeader(String name, byte[] value) {
        if (name.length() > 255) {
            throw new IllegalArgumentException("name may not exceed 255 bytes in length.");
        }
        
        if (value.length > 65535) {
            throw new IllegalArgumentException("value may not exceed 65535 bytes in length.");
        }
        
        if (Logging.SHOW_FINER && LOG.isLoggable(Level.FINER)) {
            LOG.finer("Replace header :" + name + "(" + name.length() + ") with " + value.length + " bytes of value");
        }
        
        Header newHeader = new Header(name, value);
        ListIterator<Header> eachHeader = getHeaders();
        boolean replaced = false;
        
        while (eachHeader.hasNext()) {
            Header aHeader = eachHeader.next();
            
            if (aHeader.getName().equalsIgnoreCase(name)) {
                eachHeader.set(newHeader);
                replaced = true;
            }
        }
        
        if(!replaced) {
            headers.add(newHeader);
        }
    }
 
    /**
     * Replace a header. Replaces all existing headers with the same name
     *
     * @param name  The header name. The UTF-8 encoded representation of this
     * name may not be longer than 255 bytes.
     * @param value The value for the header. May not exceed 65535 bytes in
     * length.
     */
    public void replaceHeader(String name, String value) {
        if (Logging.SHOW_FINER && LOG.isLoggable(Level.FINER)) {
            LOG.finer("Replace header :" + name + "(" + name.length() + ") with " + value.length() + " chars of value");
        }
        
        try {
            replaceHeader(name, value.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException never) {
            // utf-8 is a required encoding.
            throw new IllegalStateException("UTF-8 encoding support missing!");
        }
    }
    
    /**
     * Gets all of the headers. This iterator provides access to the live
     * data of this instance. Modifying the headers using {@code add()},
     * {@code set()}, {@code remove()} is permitted.
     *
     * @return all of the headers
     */
    public ListIterator<Header> getHeaders() {
        return headers.listIterator();
    }
    
    /**
     * Gets all of the headers matching the specified name
     *
     * @param name the name of the header we are seeking.
     */
    public Iterator<Header> getHeader(String name) {
        List<Header> matchingHeaders = new ArrayList<Header>();
        
        for (Header aHeader : headers) {
            if (name.equals(aHeader.getName())) {
                matchingHeaders.add(aHeader);
            }
        }
        return matchingHeaders.iterator();
    }
    
    /**
     * Write this group of header elements to a stream.
     *
     * @param out the stream to send the headers to.
     * @throws java.io.IOException if an io error occurs
     */
    public void sendToStream(OutputStream out) throws IOException {
        Iterator<Header> eachHeader = getHeaders();
        DataOutput dos = new DataOutputStream(out);
        
        // todo 20021014 [e-mail] A framing signature would help here
        
        while (eachHeader.hasNext()) {
            Header aHeader = eachHeader.next();
            
            byte[] nameBytes = aHeader.getName().getBytes("UTF-8");
            byte[] value = aHeader.getValue();
            
            assert nameBytes.length <= 255;
            assert value.length <= 65535;
            
            dos.write(nameBytes.length);
            dos.write(nameBytes);
            dos.writeShort(value.length);
            dos.write(value);
        }
        
        // write empty header
        dos.write(0);
    }
    
    /**
     * Return a ByteBuffer representing this group of header elements.
     *
     * @return ByteBuffer representing this Header
     */
    public ByteBuffer getByteBuffer() {
        // note: according to the spec this may exceed MAX_HEADER_LEN,
        // but since there are practically only 3 header elements used
        // it's safe to assume this implemention detail.
        ByteBuffer buffer = ByteBuffer.allocate(MAX_HEADER_LEN);
        
        for (Header header : headers) {
            byte[] name;

            try {
                name = header.getName().getBytes("UTF-8");
            } catch (UnsupportedEncodingException never) {
                throw new Error("Required UTF-8 encoding not available.");
            }
            
            byte[] value = header.getValue();
            
            assert name.length <= 255;
            assert value.length <= 65535;
            
            buffer.put((byte) name.length);
            buffer.put(name);
            buffer.putShort((short) value.length);
            buffer.put(value);
        }
        
        // write empty header
        buffer.put((byte) 0);
        buffer.flip();
        
        return buffer;
    }
    
    /**
     * Convenience method setting the "{@code content-length}" header.
     *
     * @param length length of the message.
     */
    public void setContentLengthHeader(long length) {
        byte[] lengthAsBytes = new byte[8];

        for (int eachByte = 0; eachByte < 8; eachByte++) {
            lengthAsBytes[eachByte] = (byte) (length >> ((7 - eachByte) * 8L));
        }
        
        replaceHeader(CONTENT_LENGTH, lengthAsBytes);
    }
    
    /**
     * Convenience method for getting the "{@code content-length}" header.
     *
     * @return length from the header or -1 if there was no
     * {@code content-length} header element.
     */
    public long getContentLengthHeader() {
        Iterator<Header> it = getHeader(CONTENT_LENGTH);

        if (!it.hasNext()) {
            return -1L;
        }
        Header header = it.next();
        byte[] lengthAsBytes = header.getValue();
        
        long lengthAsLong = 0L;
        
        for (int eachByte = 0; eachByte < 8; eachByte++) {
            lengthAsLong |= ((long) (lengthAsBytes[eachByte] & 0xff)) << ((7 - eachByte) * 8L);
        }
        
        return lengthAsLong;
    }
    
    /**
     * Convenience method for setting the "{@code content-type}" header.
     *
     * @param type type of the message.
     */
    public void setContentTypeHeader(MimeMediaType type) {
        replaceHeader(CONTENT_TYPE, type.toString());
    }
    
    /**
     * Convenience method for getting the "{@code content-type}" header.
     *
     * @return type from the header or "{@code application/octet-stream}" if
     * there was no {@code content-type} header.
     */
    public MimeMediaType getContentTypeHeader() {
        Iterator<Header> it = getHeader(CONTENT_TYPE);

        if (!it.hasNext()) {
            // return the generic type. Better than returning "null".
            return MimeMediaType.AOS;
        }
        Header header = it.next();
        
        return MimeMediaType.valueOf(header.getValueString());
    }
}