/*
 * Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*-
 *      news stream opener
 */

package sun.net.www;

import java.io.*;
import java.util.Collections;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.NoSuchElementException;

An RFC 844 or MIME message header. Includes methods for parsing headers from incoming streams, fetching values, setting values, and printing headers. Key values of null are legal: they indicate lines in the header that don't have a valid key, but do have a value (this isn't legal according to the standard, but lines like this are everywhere).
/** An RFC 844 or MIME message header. Includes methods for parsing headers from incoming streams, fetching values, setting values, and printing headers. Key values of null are legal: they indicate lines in the header that don't have a valid key, but do have a value (this isn't legal according to the standard, but lines like this are everywhere). */
public class MessageHeader { private String keys[]; private String values[]; private int nkeys; public MessageHeader () { grow(); } public MessageHeader (InputStream is) throws java.io.IOException { parseHeader(is); }
Reset a message header (all key/values removed)
/** * Reset a message header (all key/values removed) */
public synchronized void reset() { keys = null; values = null; nkeys = 0; grow(); }
Find the value that corresponds to this key. It finds only the first occurrence of the key.
Params:
  • k – the key to find.
Returns:null if not found.
/** * Find the value that corresponds to this key. * It finds only the first occurrence of the key. * @param k the key to find. * @return null if not found. */
public synchronized String findValue(String k) { if (k == null) { for (int i = nkeys; --i >= 0;) if (keys[i] == null) return values[i]; } else for (int i = nkeys; --i >= 0;) { if (k.equalsIgnoreCase(keys[i])) return values[i]; } return null; } // return the location of the key public synchronized int getKey(String k) { for (int i = nkeys; --i >= 0;) if ((keys[i] == k) || (k != null && k.equalsIgnoreCase(keys[i]))) return i; return -1; } public synchronized String getKey(int n) { if (n < 0 || n >= nkeys) return null; return keys[n]; } public synchronized String getValue(int n) { if (n < 0 || n >= nkeys) return null; return values[n]; }
Deprecated: Use multiValueIterator() instead. Find the next value that corresponds to this key. It finds the first value that follows v. To iterate over all the values of a key use:
         for(String v=h.findValue(k); v!=null; v=h.findNextValue(k, v)) {
             ...
         }
 
/** Deprecated: Use multiValueIterator() instead. * * Find the next value that corresponds to this key. * It finds the first value that follows v. To iterate * over all the values of a key use: * <pre> * for(String v=h.findValue(k); v!=null; v=h.findNextValue(k, v)) { * ... * } * </pre> */
public synchronized String findNextValue(String k, String v) { boolean foundV = false; if (k == null) { for (int i = nkeys; --i >= 0;) if (keys[i] == null) if (foundV) return values[i]; else if (values[i] == v) foundV = true; } else for (int i = nkeys; --i >= 0;) if (k.equalsIgnoreCase(keys[i])) if (foundV) return values[i]; else if (values[i] == v) foundV = true; return null; }
Removes bare Negotiate and Kerberos headers when an "NTLM ..." appears. All Performed on headers with key being k.
Returns:true if there is a change
/** * Removes bare Negotiate and Kerberos headers when an "NTLM ..." * appears. All Performed on headers with key being k. * @return true if there is a change */
public boolean filterNTLMResponses(String k) { boolean found = false; for (int i=0; i<nkeys; i++) { if (k.equalsIgnoreCase(keys[i]) && values[i] != null && values[i].length() > 5 && values[i].regionMatches(true, 0, "NTLM ", 0, 5)) { found = true; break; } } if (found) { int j = 0; for (int i=0; i<nkeys; i++) { if (k.equalsIgnoreCase(keys[i]) && ( "Negotiate".equalsIgnoreCase(values[i]) || "Kerberos".equalsIgnoreCase(values[i]))) { continue; } if (i != j) { keys[j] = keys[i]; values[j] = values[i]; } j++; } if (j != nkeys) { nkeys = j; return true; } } return false; } class HeaderIterator implements Iterator<String> { int index = 0; int next = -1; String key; boolean haveNext = false; Object lock; public HeaderIterator (String k, Object lock) { key = k; this.lock = lock; } public boolean hasNext () { synchronized (lock) { if (haveNext) { return true; } while (index < nkeys) { if (key.equalsIgnoreCase (keys[index])) { haveNext = true; next = index++; return true; } index ++; } return false; } } public String next() { synchronized (lock) { if (haveNext) { haveNext = false; return values [next]; } if (hasNext()) { return next(); } else { throw new NoSuchElementException ("No more elements"); } } } public void remove () { throw new UnsupportedOperationException ("remove not allowed"); } }
return an Iterator that returns all values of a particular key in sequence
/** * return an Iterator that returns all values of a particular * key in sequence */
public Iterator<String> multiValueIterator (String k) { return new HeaderIterator (k, this); } public synchronized Map<String, List<String>> getHeaders() { return getHeaders(null); } public synchronized Map<String, List<String>> getHeaders(String[] excludeList) { return filterAndAddHeaders(excludeList, null); } public synchronized Map<String, List<String>> filterAndAddHeaders( String[] excludeList, Map<String, List<String>> include) { boolean skipIt = false; Map<String, List<String>> m = new HashMap<String, List<String>>(); for (int i = nkeys; --i >= 0;) { if (excludeList != null) { // check if the key is in the excludeList. // if so, don't include it in the Map. for (int j = 0; j < excludeList.length; j++) { if ((excludeList[j] != null) && (excludeList[j].equalsIgnoreCase(keys[i]))) { skipIt = true; break; } } } if (!skipIt) { List<String> l = m.get(keys[i]); if (l == null) { l = new ArrayList<String>(); m.put(keys[i], l); } l.add(values[i]); } else { // reset the flag skipIt = false; } } if (include != null) { for (Map.Entry<String,List<String>> entry: include.entrySet()) { List<String> l = m.get(entry.getKey()); if (l == null) { l = new ArrayList<String>(); m.put(entry.getKey(), l); } l.addAll(entry.getValue()); } } for (String key : m.keySet()) { m.put(key, Collections.unmodifiableList(m.get(key))); } return Collections.unmodifiableMap(m); }
Prints the key-value pairs represented by this header. Also prints the RFC required blank line at the end. Omits pairs with a null key.
/** Prints the key-value pairs represented by this header. Also prints the RFC required blank line at the end. Omits pairs with a null key. */
public synchronized void print(PrintStream p) { for (int i = 0; i < nkeys; i++) if (keys[i] != null) { p.print(keys[i] + (values[i] != null ? ": "+values[i]: "") + "\r\n"); } p.print("\r\n"); p.flush(); }
Adds a key value pair to the end of the header. Duplicates are allowed
/** Adds a key value pair to the end of the header. Duplicates are allowed */
public synchronized void add(String k, String v) { grow(); keys[nkeys] = k; values[nkeys] = v; nkeys++; }
Prepends a key value pair to the beginning of the header. Duplicates are allowed
/** Prepends a key value pair to the beginning of the header. Duplicates are allowed */
public synchronized void prepend(String k, String v) { grow(); for (int i = nkeys; i > 0; i--) { keys[i] = keys[i-1]; values[i] = values[i-1]; } keys[0] = k; values[0] = v; nkeys++; }
Overwrite the previous key/val pair at location 'i' with the new k/v. If the index didn't exist before the key/val is simply tacked onto the end.
/** Overwrite the previous key/val pair at location 'i' * with the new k/v. If the index didn't exist before * the key/val is simply tacked onto the end. */
public synchronized void set(int i, String k, String v) { grow(); if (i < 0) { return; } else if (i >= nkeys) { add(k, v); } else { keys[i] = k; values[i] = v; } }
grow the key/value arrays as needed
/** grow the key/value arrays as needed */
private void grow() { if (keys == null || nkeys >= keys.length) { String[] nk = new String[nkeys + 4]; String[] nv = new String[nkeys + 4]; if (keys != null) System.arraycopy(keys, 0, nk, 0, nkeys); if (values != null) System.arraycopy(values, 0, nv, 0, nkeys); keys = nk; values = nv; } }
Remove the key from the header. If there are multiple values under the same key, they are all removed. Nothing is done if the key doesn't exist. After a remove, the other pairs' order are not changed.
Params:
  • k – the key to remove
/** * Remove the key from the header. If there are multiple values under * the same key, they are all removed. * Nothing is done if the key doesn't exist. * After a remove, the other pairs' order are not changed. * @param k the key to remove */
public synchronized void remove(String k) { if(k == null) { for (int i = 0; i < nkeys; i++) { while (keys[i] == null && i < nkeys) { for(int j=i; j<nkeys-1; j++) { keys[j] = keys[j+1]; values[j] = values[j+1]; } nkeys--; } } } else { for (int i = 0; i < nkeys; i++) { while (k.equalsIgnoreCase(keys[i]) && i < nkeys) { for(int j=i; j<nkeys-1; j++) { keys[j] = keys[j+1]; values[j] = values[j+1]; } nkeys--; } } } }
Sets the value of a key. If the key already exists in the header, it's value will be changed. Otherwise a new key/value pair will be added to the end of the header.
/** Sets the value of a key. If the key already exists in the header, it's value will be changed. Otherwise a new key/value pair will be added to the end of the header. */
public synchronized void set(String k, String v) { for (int i = nkeys; --i >= 0;) if (k.equalsIgnoreCase(keys[i])) { values[i] = v; return; } add(k, v); }
Set's the value of a key only if there is no key with that value already.
/** Set's the value of a key only if there is no * key with that value already. */
public synchronized void setIfNotSet(String k, String v) { if (findValue(k) == null) { add(k, v); } }
Convert a message-id string to canonical form (strips off leading and trailing <>s)
/** Convert a message-id string to canonical form (strips off leading and trailing <>s) */
public static String canonicalID(String id) { if (id == null) return ""; int st = 0; int len = id.length(); boolean substr = false; int c; while (st < len && ((c = id.charAt(st)) == '<' || c <= ' ')) { st++; substr = true; } while (st < len && ((c = id.charAt(len - 1)) == '>' || c <= ' ')) { len--; substr = true; } return substr ? id.substring(st, len) : id; }
Parse a MIME header from an input stream.
/** Parse a MIME header from an input stream. */
public void parseHeader(InputStream is) throws java.io.IOException { synchronized (this) { nkeys = 0; } mergeHeader(is); }
Parse and merge a MIME header from an input stream.
/** Parse and merge a MIME header from an input stream. */
@SuppressWarnings("fallthrough") public void mergeHeader(InputStream is) throws java.io.IOException { if (is == null) return; char s[] = new char[10]; int firstc = is.read(); while (firstc != '\n' && firstc != '\r' && firstc >= 0) { int len = 0; int keyend = -1; int c; boolean inKey = firstc > ' '; s[len++] = (char) firstc; parseloop:{ while ((c = is.read()) >= 0) { switch (c) { case ':': if (inKey && len > 0) keyend = len; inKey = false; break; case '\t': c = ' '; /*fall through*/ case ' ': inKey = false; break; case '\r': case '\n': firstc = is.read(); if (c == '\r' && firstc == '\n') { firstc = is.read(); if (firstc == '\r') firstc = is.read(); } if (firstc == '\n' || firstc == '\r' || firstc > ' ') break parseloop; /* continuation */ c = ' '; break; } if (len >= s.length) { char ns[] = new char[s.length * 2]; System.arraycopy(s, 0, ns, 0, len); s = ns; } s[len++] = (char) c; } firstc = -1; } while (len > 0 && s[len - 1] <= ' ') len--; String k; if (keyend <= 0) { k = null; keyend = 0; } else { k = String.copyValueOf(s, 0, keyend); if (keyend < len && s[keyend] == ':') keyend++; while (keyend < len && s[keyend] <= ' ') keyend++; } String v; if (keyend >= len) v = new String(); else v = String.copyValueOf(s, keyend, len - keyend); add(k, v); } } public synchronized String toString() { String result = super.toString() + nkeys + " pairs: "; for (int i = 0; i < keys.length && i < nkeys; i++) { result += "{"+keys[i]+": "+values[i]+"}"; } return result; } }