1 /*
   2  * Copyright (c) 1997, 2012, 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 javax.activation;
  27 
  28 import java.io.*;
  29 import java.util.Locale;
  30 
  31 /**
  32  * A Multipurpose Internet Mail Extension (MIME) type, as defined
  33  * in RFC 2045 and 2046.
  34  *
  35  * @since 1.6
  36  */
  37 public class MimeType implements Externalizable {
  38 
  39     private String    primaryType;
  40     private String    subType;
  41     private MimeTypeParameterList parameters;
  42 
  43     /**
  44      * A string that holds all the special chars.
  45      */
  46     private static final String TSPECIALS = "()<>@,;:/[]?=\\\"";
  47 
  48     /**
  49      * Default constructor.
  50      */
  51     public MimeType() {
  52         primaryType = "application";
  53         subType = "*";
  54         parameters = new MimeTypeParameterList();
  55     }
  56 
  57     /**
  58      * Constructor that builds a MimeType from a String.
  59      *
  60      * @param rawdata   the MIME type string

  61      */
  62     public MimeType(String rawdata) throws MimeTypeParseException {
  63         parse(rawdata);
  64     }
  65 
  66     /**
  67      * Constructor that builds a MimeType with the given primary and sub type
  68      * but has an empty parameter list.
  69      *
  70      * @param primary   the primary MIME type
  71      * @param sub       the MIME sub-type
  72      * @exception       MimeTypeParseException  if the primary type or subtype
  73      *                                          is not a valid token
  74      */
  75     public MimeType(String primary, String sub) throws MimeTypeParseException {
  76         //    check to see if primary is valid
  77         if (isValidToken(primary)) {
  78             primaryType = primary.toLowerCase(Locale.ENGLISH);
  79         } else {
  80             throw new MimeTypeParseException("Primary type is invalid.");
  81         }
  82 
  83         //    check to see if sub is valid
  84         if (isValidToken(sub)) {
  85             subType = sub.toLowerCase(Locale.ENGLISH);
  86         } else {
  87             throw new MimeTypeParseException("Sub type is invalid.");
  88         }
  89 
  90         parameters = new MimeTypeParameterList();
  91     }
  92 
  93     /**
  94      * A routine for parsing the MIME type out of a String.
  95      */
  96     private void parse(String rawdata) throws MimeTypeParseException {
  97         int slashIndex = rawdata.indexOf('/');
  98         int semIndex = rawdata.indexOf(';');
  99         if ((slashIndex < 0) && (semIndex < 0)) {
 100             //    neither character is present, so treat it
 101             //    as an error
 102             throw new MimeTypeParseException("Unable to find a sub type.");
 103         } else if ((slashIndex < 0) && (semIndex >= 0)) {
 104             //    we have a ';' (and therefore a parameter list),
 105             //    but no '/' indicating a sub type is present
 106             throw new MimeTypeParseException("Unable to find a sub type.");
 107         } else if ((slashIndex >= 0) && (semIndex < 0)) {
 108             //    we have a primary and sub type but no parameter list
 109             primaryType = rawdata.substring(0, slashIndex).trim().
 110                                                 toLowerCase(Locale.ENGLISH);
 111             subType = rawdata.substring(slashIndex + 1).trim().
 112                                                 toLowerCase(Locale.ENGLISH);
 113             parameters = new MimeTypeParameterList();
 114         } else if (slashIndex < semIndex) {
 115             //    we have all three items in the proper sequence
 116             primaryType = rawdata.substring(0, slashIndex).trim().
 117                                                 toLowerCase(Locale.ENGLISH);
 118             subType = rawdata.substring(slashIndex + 1, semIndex).trim().
 119                                                 toLowerCase(Locale.ENGLISH);
 120             parameters = new MimeTypeParameterList(rawdata.substring(semIndex));
 121         } else {
 122             // we have a ';' lexically before a '/' which means we
 123             // have a primary type and a parameter list but no sub type
 124             throw new MimeTypeParseException("Unable to find a sub type.");
 125         }
 126 
 127         //    now validate the primary and sub types
 128 
 129         //    check to see if primary is valid
 130         if (!isValidToken(primaryType))
 131             throw new MimeTypeParseException("Primary type is invalid.");
 132 
 133         //    check to see if sub is valid
 134         if (!isValidToken(subType))
 135             throw new MimeTypeParseException("Sub type is invalid.");
 136     }
 137 
 138     /**
 139      * Retrieve the primary type of this object.
 140      *
 141      * @return  the primary MIME type
 142      */
 143     public String getPrimaryType() {
 144         return primaryType;
 145     }
 146 
 147     /**
 148      * Set the primary type for this object to the given String.
 149      *
 150      * @param primary   the primary MIME type
 151      * @exception       MimeTypeParseException  if the primary type
 152      *                                          is not a valid token
 153      */
 154     public void setPrimaryType(String primary) throws MimeTypeParseException {
 155         //    check to see if primary is valid
 156         if (!isValidToken(primaryType))
 157             throw new MimeTypeParseException("Primary type is invalid.");
 158         primaryType = primary.toLowerCase(Locale.ENGLISH);
 159     }
 160 
 161     /**
 162      * Retrieve the subtype of this object.
 163      *
 164      * @return  the MIME subtype
 165      */
 166     public String getSubType() {
 167         return subType;
 168     }
 169 
 170     /**
 171      * Set the subtype for this object to the given String.
 172      *
 173      * @param sub       the MIME subtype
 174      * @exception       MimeTypeParseException  if the subtype
 175      *                                          is not a valid token
 176      */
 177     public void setSubType(String sub) throws MimeTypeParseException {
 178         //    check to see if sub is valid
 179         if (!isValidToken(subType))
 180             throw new MimeTypeParseException("Sub type is invalid.");
 181         subType = sub.toLowerCase(Locale.ENGLISH);
 182     }
 183 
 184     /**
 185      * Retrieve this object's parameter list.
 186      *
 187      * @return  a MimeTypeParameterList object representing the parameters
 188      */
 189     public MimeTypeParameterList getParameters() {
 190         return parameters;
 191     }
 192 
 193     /**
 194      * Retrieve the value associated with the given name, or null if there
 195      * is no current association.
 196      *
 197      * @param name      the parameter name
 198      * @return          the paramter's value
 199      */
 200     public String getParameter(String name) {
 201         return parameters.get(name);
 202     }
 203 
 204     /**
 205      * Set the value to be associated with the given name, replacing
 206      * any previous association.
 207      *
 208      * @param name      the parameter name
 209      * @param value     the paramter's value
 210      */
 211     public void setParameter(String name, String value) {
 212         parameters.set(name, value);
 213     }
 214 
 215     /**
 216      * Remove any value associated with the given name.
 217      *
 218      * @param name      the parameter name
 219      */
 220     public void removeParameter(String name) {
 221         parameters.remove(name);
 222     }
 223 
 224     /**
 225      * Return the String representation of this object.
 226      */
 227     public String toString() {
 228         return getBaseType() + parameters.toString();
 229     }
 230 
 231     /**
 232      * Return a String representation of this object
 233      * without the parameter list.
 234      *
 235      * @return  the MIME type and sub-type
 236      */
 237     public String getBaseType() {
 238         return primaryType + "/" + subType;
 239     }
 240 
 241     /**
 242      * Determine if the primary and sub type of this object is
 243      * the same as what is in the given type.
 244      *
 245      * @param type      the MimeType object to compare with
 246      * @return          true if they match
 247      */
 248     public boolean match(MimeType type) {
 249         return primaryType.equals(type.getPrimaryType())
 250                     && (subType.equals("*")
 251                             || type.getSubType().equals("*")
 252                             || (subType.equals(type.getSubType())));
 253     }
 254 
 255     /**
 256      * Determine if the primary and sub type of this object is
 257      * the same as the content type described in rawdata.
 258      *
 259      * @param rawdata   the MIME type string to compare with
 260      * @return          true if they match

 261      */
 262     public boolean match(String rawdata) throws MimeTypeParseException {
 263         return match(new MimeType(rawdata));
 264     }
 265 
 266     /**
 267      * The object implements the writeExternal method to save its contents
 268      * by calling the methods of DataOutput for its primitive values or
 269      * calling the writeObject method of ObjectOutput for objects, strings
 270      * and arrays.
 271      *
 272      * @param out       the ObjectOutput object to write to
 273      * @exception IOException Includes any I/O exceptions that may occur
 274      */
 275     public void writeExternal(ObjectOutput out) throws IOException {
 276         out.writeUTF(toString());
 277         out.flush();
 278     }
 279 
 280     /**
 281      * The object implements the readExternal method to restore its
 282      * contents by calling the methods of DataInput for primitive
 283      * types and readObject for objects, strings and arrays.  The
 284      * readExternal method must read the values in the same sequence
 285      * and with the same types as were written by writeExternal.
 286      *
 287      * @param in        the ObjectInput object to read from
 288      * @exception ClassNotFoundException If the class for an object being
 289      *              restored cannot be found.
 290      */
 291     public void readExternal(ObjectInput in)
 292                                 throws IOException, ClassNotFoundException {
 293         try {
 294             parse(in.readUTF());
 295         } catch (MimeTypeParseException e) {
 296             throw new IOException(e.toString());
 297         }
 298     }
 299 
 300     //    below here be scary parsing related things
 301 
 302     /**
 303      * Determine whether or not a given character belongs to a legal token.
 304      */
 305     private static boolean isTokenChar(char c) {
 306         return ((c > 040) && (c < 0177)) && (TSPECIALS.indexOf(c) < 0);
 307     }
 308 
 309     /**
 310      * Determine whether or not a given string is a legal token.
 311      */
 312     private boolean isValidToken(String s) {
 313         int len = s.length();
 314         if (len > 0) {
 315             for (int i = 0; i < len; ++i) {
 316                 char c = s.charAt(i);
 317                 if (!isTokenChar(c)) {
 318                     return false;
 319                 }
 320             }
 321             return true;
 322         } else {
 323             return false;
 324         }
 325     }
 326 
 327     /**
 328      * A simple parser test,
 329      * for debugging...
 330      *
 331     public static void main(String[] args)
 332                                 throws MimeTypeParseException, IOException {
 333         for (int i = 0; i < args.length; ++i) {
 334             System.out.println("Original: " + args[i]);
 335 
 336             MimeType type = new MimeType(args[i]);
 337 
 338             System.out.println("Short:    " + type.getBaseType());
 339             System.out.println("Parsed:   " + type.toString());
 340             System.out.println();
 341         }
 342     }
 343     */
 344 }
--- EOF ---