1 /*
   2  * Copyright (c) 1997, 2002, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.awt.datatransfer;
  27 
  28 import java.io.Externalizable;
  29 import java.io.ObjectOutput;
  30 import java.io.ObjectInput;
  31 import java.io.IOException;
  32 import java.util.Enumeration;
  33 import java.util.Locale;
  34 
  35 
  36 /**
  37  * A Multipurpose Internet Mail Extension (MIME) type, as defined
  38  * in RFC 2045 and 2046.
  39  *
  40  * THIS IS *NOT* - REPEAT *NOT* - A PUBLIC CLASS! DataFlavor IS
  41  * THE PUBLIC INTERFACE, AND THIS IS PROVIDED AS A ***PRIVATE***
  42  * (THAT IS AS IN *NOT* PUBLIC) HELPER CLASS!
  43  */
  44 class MimeType implements Externalizable, Cloneable {
  45 
  46     /*
  47      * serialization support
  48      */
  49 
  50     static final long serialVersionUID = -6568722458793895906L;
  51 
  52     /**
  53      * Constructor for externalization; this constructor should not be
  54      * called directly by an application, since the result will be an
  55      * uninitialized, immutable <code>MimeType</code> object.
  56      */
  57     public MimeType() {
  58     }
  59 
  60     /**
  61      * Builds a <code>MimeType</code> from a <code>String</code>.
  62      *
  63      * @param rawdata text used to initialize the <code>MimeType</code>
  64      * @throws NullPointerException if <code>rawdata</code> is null
  65      */
  66     public MimeType(String rawdata) throws MimeTypeParseException {
  67         parse(rawdata);
  68     }
  69 
  70     /**
  71      * Builds a <code>MimeType</code> with the given primary and sub
  72      * type but has an empty parameter list.
  73      *
  74      * @param primary the primary type of this <code>MimeType</code>
  75      * @param sub the subtype of this <code>MimeType</code>
  76      * @throws NullPointerException if either <code>primary</code> or
  77      *         <code>sub</code> is null
  78      */
  79     public MimeType(String primary, String sub) throws MimeTypeParseException {
  80         this(primary, sub, new MimeTypeParameterList());
  81     }
  82 
  83     /**
  84      * Builds a <code>MimeType</code> with a pre-defined
  85      * and valid (or empty) parameter list.
  86      *
  87      * @param primary the primary type of this <code>MimeType</code>
  88      * @param sub the subtype of this <code>MimeType</code>
  89      * @param mtpl the requested parameter list
  90      * @throws NullPointerException if either <code>primary</code>,
  91      *         <code>sub</code> or <code>mtpl</code> is null
  92      */
  93     public MimeType(String primary, String sub, MimeTypeParameterList mtpl) throws
  94 MimeTypeParseException {
  95         //    check to see if primary is valid
  96         if(isValidToken(primary)) {
  97             primaryType = primary.toLowerCase(Locale.ENGLISH);
  98         } else {
  99             throw new MimeTypeParseException("Primary type is invalid.");
 100         }
 101 
 102         //    check to see if sub is valid
 103         if(isValidToken(sub)) {
 104             subType = sub.toLowerCase(Locale.ENGLISH);
 105         } else {
 106             throw new MimeTypeParseException("Sub type is invalid.");
 107         }
 108 
 109         parameters = (MimeTypeParameterList)mtpl.clone();
 110     }
 111 
 112     public int hashCode() {
 113 
 114         // We sum up the hash codes for all of the strings. This
 115         // way, the order of the strings is irrelevant
 116         int code = 0;
 117         code += primaryType.hashCode();
 118         code += subType.hashCode();
 119         code += parameters.hashCode();
 120         return code;
 121     } // hashCode()
 122 
 123     /**
 124      * <code>MimeType</code>s are equal if their primary types,
 125      * subtypes, and  parameters are all equal. No default values
 126      * are taken into account.
 127      * @param thatObject the object to be evaluated as a
 128      *    <code>MimeType</code>
 129      * @return <code>true</code> if <code>thatObject</code> is
 130      *    a <code>MimeType</code>; otherwise returns <code>false</code>
 131      */
 132     public boolean equals(Object thatObject) {
 133         if (!(thatObject instanceof MimeType)) {
 134             return false;
 135         }
 136         MimeType that = (MimeType)thatObject;
 137         boolean isIt =
 138             ((this.primaryType.equals(that.primaryType)) &&
 139              (this.subType.equals(that.subType)) &&
 140              (this.parameters.equals(that.parameters)));
 141         return isIt;
 142     } // equals()
 143 
 144     /**
 145      * A routine for parsing the MIME type out of a String.
 146      *
 147      * @throws NullPointerException if <code>rawdata</code> is null
 148      */
 149     private void parse(String rawdata) throws MimeTypeParseException {
 150         int slashIndex = rawdata.indexOf('/');
 151         int semIndex = rawdata.indexOf(';');
 152         if((slashIndex < 0) && (semIndex < 0)) {
 153             //    neither character is present, so treat it
 154             //    as an error
 155             throw new MimeTypeParseException("Unable to find a sub type.");
 156         } else if((slashIndex < 0) && (semIndex >= 0)) {
 157             //    we have a ';' (and therefore a parameter list),
 158             //    but no '/' indicating a sub type is present
 159             throw new MimeTypeParseException("Unable to find a sub type.");
 160         } else if((slashIndex >= 0) && (semIndex < 0)) {
 161             //    we have a primary and sub type but no parameter list
 162             primaryType = rawdata.substring(0,slashIndex).
 163                 trim().toLowerCase(Locale.ENGLISH);
 164             subType = rawdata.substring(slashIndex + 1).
 165                 trim().toLowerCase(Locale.ENGLISH);
 166             parameters = new MimeTypeParameterList();
 167         } else if (slashIndex < semIndex) {
 168             //    we have all three items in the proper sequence
 169             primaryType = rawdata.substring(0, slashIndex).
 170                 trim().toLowerCase(Locale.ENGLISH);
 171             subType = rawdata.substring(slashIndex + 1,
 172                 semIndex).trim().toLowerCase(Locale.ENGLISH);
 173             parameters = new
 174 MimeTypeParameterList(rawdata.substring(semIndex));
 175         } else {
 176             //    we have a ';' lexically before a '/' which means we have a primary type
 177             //    & a parameter list but no sub type
 178             throw new MimeTypeParseException("Unable to find a sub type.");
 179         }
 180 
 181         //    now validate the primary and sub types
 182 
 183         //    check to see if primary is valid
 184         if(!isValidToken(primaryType)) {
 185             throw new MimeTypeParseException("Primary type is invalid.");
 186         }
 187 
 188         //    check to see if sub is valid
 189         if(!isValidToken(subType)) {
 190             throw new MimeTypeParseException("Sub type is invalid.");
 191         }
 192     }
 193 
 194     /**
 195      * Retrieve the primary type of this object.
 196      */
 197     public String getPrimaryType() {
 198         return primaryType;
 199     }
 200 
 201     /**
 202      * Retrieve the sub type of this object.
 203      */
 204     public String getSubType() {
 205         return subType;
 206     }
 207 
 208     /**
 209      * Retrieve a copy of this object's parameter list.
 210      */
 211     public MimeTypeParameterList getParameters() {
 212         return (MimeTypeParameterList)parameters.clone();
 213     }
 214 
 215     /**
 216      * Retrieve the value associated with the given name, or null if there
 217      * is no current association.
 218      */
 219     public String getParameter(String name) {
 220         return parameters.get(name);
 221     }
 222 
 223     /**
 224      * Set the value to be associated with the given name, replacing
 225      * any previous association.
 226      *
 227      * @throw IllegalArgumentException if parameter or value is illegal
 228      */
 229     public void setParameter(String name, String value) {
 230         parameters.set(name, value);
 231     }
 232 
 233     /**
 234      * Remove any value associated with the given name.
 235      *
 236      * @throw IllegalArgumentExcpetion if parameter may not be deleted
 237      */
 238     public void removeParameter(String name) {
 239         parameters.remove(name);
 240     }
 241 
 242     /**
 243      * Return the String representation of this object.
 244      */
 245     public String toString() {
 246         return getBaseType() + parameters.toString();
 247     }
 248 
 249     /**
 250      * Return a String representation of this object
 251      * without the parameter list.
 252      */
 253     public String getBaseType() {
 254         return primaryType + "/" + subType;
 255     }
 256 
 257     /**
 258      * Returns <code>true</code> if the primary type and the
 259      * subtype of this object are the same as the specified
 260      * <code>type</code>; otherwise returns <code>false</code>.
 261      *
 262      * @param type the type to compare to <code>this</code>'s type
 263      * @return <code>true</code> if the primary type and the
 264      *    subtype of this object are the same as the
 265      *    specified <code>type</code>; otherwise returns
 266      *    <code>false</code>
 267      */
 268     public boolean match(MimeType type) {
 269         if (type == null)
 270             return false;
 271         return primaryType.equals(type.getPrimaryType())
 272                     && (subType.equals("*")
 273                             || type.getSubType().equals("*")
 274                             || (subType.equals(type.getSubType())));
 275     }
 276 
 277     /**
 278      * Returns <code>true</code> if the primary type and the
 279      * subtype of this object are the same as the content type
 280      * described in <code>rawdata</code>; otherwise returns
 281      * <code>false</code>.
 282      *
 283      * @param rawdata the raw data to be examined
 284      * @return <code>true</code> if the primary type and the
 285      *    subtype of this object are the same as the content type
 286      *    described in <code>rawdata</code>; otherwise returns
 287      *    <code>false</code>; if <code>rawdata</code> is
 288      *    <code>null</code>, returns <code>false</code>
 289      */
 290     public boolean match(String rawdata) throws MimeTypeParseException {
 291         if (rawdata == null)
 292             return false;
 293         return match(new MimeType(rawdata));
 294     }
 295 
 296     /**
 297      * The object implements the writeExternal method to save its contents
 298      * by calling the methods of DataOutput for its primitive values or
 299      * calling the writeObject method of ObjectOutput for objects, strings
 300      * and arrays.
 301      * @exception IOException Includes any I/O exceptions that may occur
 302      */
 303     public void writeExternal(ObjectOutput out) throws IOException {
 304         String s = toString(); // contains ASCII chars only
 305         // one-to-one correspondence between ASCII char and byte in UTF string
 306         if (s.length() <= 65535) { // 65535 is max length of UTF string
 307             out.writeUTF(s);
 308         } else {
 309             out.writeByte(0);
 310             out.writeByte(0);
 311             out.writeInt(s.length());
 312             out.write(s.getBytes());
 313         }
 314     }
 315 
 316     /**
 317      * The object implements the readExternal method to restore its
 318      * contents by calling the methods of DataInput for primitive
 319      * types and readObject for objects, strings and arrays.  The
 320      * readExternal method must read the values in the same sequence
 321      * and with the same types as were written by writeExternal.
 322      * @exception ClassNotFoundException If the class for an object being
 323      *              restored cannot be found.
 324      */
 325     public void readExternal(ObjectInput in) throws IOException,
 326 ClassNotFoundException {
 327         String s = in.readUTF();
 328         if (s == null || s.length() == 0) { // long mime type
 329             byte[] ba = new byte[in.readInt()];
 330             in.readFully(ba);
 331             s = new String(ba);
 332         }
 333         try {
 334             parse(s);
 335         } catch(MimeTypeParseException e) {
 336             throw new IOException(e.toString());
 337         }
 338     }
 339 
 340     /**
 341      * Returns a clone of this object.
 342      * @return a clone of this object
 343      */
 344 
 345     public Object clone() {
 346         MimeType newObj = null;
 347         try {
 348             newObj = (MimeType)super.clone();
 349         } catch (CloneNotSupportedException cannotHappen) {
 350         }
 351         newObj.parameters = (MimeTypeParameterList)parameters.clone();
 352         return newObj;
 353     }
 354 
 355     private String    primaryType;
 356     private String    subType;
 357     private MimeTypeParameterList parameters;
 358 
 359     //    below here be scary parsing related things
 360 
 361     /**
 362      * Determines whether or not a given character belongs to a legal token.
 363      */
 364     private static boolean isTokenChar(char c) {
 365         return ((c > 040) && (c < 0177)) && (TSPECIALS.indexOf(c) < 0);
 366     }
 367 
 368     /**
 369      * Determines whether or not a given string is a legal token.
 370      *
 371      * @throws NullPointerException if <code>s</code> is null
 372      */
 373     private boolean isValidToken(String s) {
 374         int len = s.length();
 375         if(len > 0) {
 376             for (int i = 0; i < len; ++i) {
 377                 char c = s.charAt(i);
 378                 if (!isTokenChar(c)) {
 379                     return false;
 380                 }
 381             }
 382             return true;
 383         } else {
 384             return false;
 385         }
 386     }
 387 
 388     /**
 389      * A string that holds all the special chars.
 390      */
 391 
 392     private static final String TSPECIALS = "()<>@,;:\\\"/[]?=";
 393 
 394 } // class MimeType