core/java/android/webkit/URLUtil.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2006 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.webkit;

 import android.annotation.Nullable;
 import android.compat.annotation.UnsupportedAppUsage;
 import android.net.ParseException;
 import android.net.Uri;
 import android.net.WebAddress;
 import android.util.Log;

 import java.io.UnsupportedEncodingException;
 import java.util.Locale;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 public final class URLUtil {

     private static final String LOGTAG = "webkit";
     private static final boolean TRACE = false;

     // to refer to bar.png under your package's asset/foo/ directory, use
     // "file:///android_asset/foo/bar.png".
     static final String ASSET_BASE = "file:///android_asset/";
     // to refer to bar.png under your package's res/drawable/ directory, use
     // "file:///android_res/drawable/bar.png". Use "drawable" to refer to
     // "drawable-hdpi" directory as well.
     static final String RESOURCE_BASE = "file:///android_res/";
     static final String FILE_BASE = "file:";
     static final String PROXY_BASE = "file:///cookieless_proxy/";
     static final String CONTENT_BASE = "content:";

     /**
      * Cleans up (if possible) user-entered web addresses
      */
     public static String guessUrl(String inUrl) {

         String retVal = inUrl;
         WebAddress webAddress;

         if (TRACE) Log.v(LOGTAG, "guessURL before queueRequest: " + inUrl);

         if (inUrl.length() == 0) return inUrl;
         if (inUrl.startsWith("about:")) return inUrl;
         // Do not try to interpret data scheme URLs
         if (inUrl.startsWith("data:")) return inUrl;
         // Do not try to interpret file scheme URLs
         if (inUrl.startsWith("file:")) return inUrl;
         // Do not try to interpret javascript scheme URLs
         if (inUrl.startsWith("javascript:")) return inUrl;

         // bug 762454: strip period off end of url
         if (inUrl.endsWith(".") == true) {
             inUrl = inUrl.substring(0, inUrl.length() - 1);
         }

         try {
             webAddress = new WebAddress(inUrl);
         } catch (ParseException ex) {

             if (TRACE) {
                 Log.v(LOGTAG, "smartUrlFilter: failed to parse url = " + inUrl);
             }
             return retVal;
         }

         // Check host
         if (webAddress.getHost().indexOf('.') == -1) {
             // no dot: user probably entered a bare domain.  try .com
             webAddress.setHost("www." + webAddress.getHost() + ".com");
         }
         return webAddress.toString();
     }

     public static String composeSearchUrl(String inQuery, String template,
                                           String queryPlaceHolder) {
         int placeHolderIndex = template.indexOf(queryPlaceHolder);
         if (placeHolderIndex < 0) {
             return null;
         }

         String query;
         StringBuilder buffer = new StringBuilder();
         buffer.append(template.substring(0, placeHolderIndex));

         try {
             query = java.net.URLEncoder.encode(inQuery, "utf-8");
             buffer.append(query);
         } catch (UnsupportedEncodingException ex) {
             return null;
         }

         buffer.append(template.substring(
                 placeHolderIndex + queryPlaceHolder.length()));

         return buffer.toString();
     }

     public static byte[] decode(byte[] url) throws IllegalArgumentException {
         if (url.length == 0) {
             return new byte[0];
         }

         // Create a new byte array with the same length to ensure capacity
         byte[] tempData = new byte[url.length];

         int tempCount = 0;
         for (int i = 0; i < url.length; i++) {
             byte b = url[i];
             if (b == '%') {
                 if (url.length - i > 2) {
                     b = (byte) (parseHex(url[i + 1]) * 16
                             + parseHex(url[i + 2]));
                     i += 2;
                 } else {
                     throw new IllegalArgumentException("Invalid format");
                 }
             }
             tempData[tempCount++] = b;
         }
         byte[] retData = new byte[tempCount];
         System.arraycopy(tempData, 0, retData, 0, tempCount);
         return retData;
     }

     /**
      * @return {@code true} if the url is correctly URL encoded
      */
     @UnsupportedAppUsage
     static boolean verifyURLEncoding(String url) {
         int count = url.length();
         if (count == 0) {
             return false;
         }

         int index = url.indexOf('%');
         while (index >= 0 && index < count) {
             if (index < count - 2) {
                 try {
                     parseHex((byte) url.charAt(++index));
                     parseHex((byte) url.charAt(++index));
                 } catch (IllegalArgumentException e) {
                     return false;
                 }
             } else {
                 return false;
             }
             index = url.indexOf('%', index + 1);
         }
         return true;
     }

     private static int parseHex(byte b) {
         if (b >= '0' && b <= '9') return (b - '0');
         if (b >= 'A' && b <= 'F') return (b - 'A' + 10);
         if (b >= 'a' && b <= 'f') return (b - 'a' + 10);

         throw new IllegalArgumentException("Invalid hex char '" + b + "'");
     }

     /**
      * @return {@code true} if the url is an asset file.
      */
     public static boolean isAssetUrl(String url) {
         return (null != url) && url.startsWith(ASSET_BASE);
     }

     /**
      * @return {@code true} if the url is a resource file.
      * @hide
      */
     @UnsupportedAppUsage
     public static boolean isResourceUrl(String url) {
         return (null != url) && url.startsWith(RESOURCE_BASE);
     }

     /**
      * @return {@code true} if the url is a proxy url to allow cookieless network
      * requests from a file url.
      * @deprecated Cookieless proxy is no longer supported.
      */
     @Deprecated
     public static boolean isCookielessProxyUrl(String url) {
         return (null != url) && url.startsWith(PROXY_BASE);
     }

     /**
      * @return {@code true} if the url is a local file.
      */
     public static boolean isFileUrl(String url) {
         return (null != url) && (url.startsWith(FILE_BASE) &&
                                  !url.startsWith(ASSET_BASE) &&
                                  !url.startsWith(PROXY_BASE));
     }

     /**
      * @return {@code true} if the url is an about: url.
      */
     public static boolean isAboutUrl(String url) {
         return (null != url) && url.startsWith("about:");
     }

     /**
      * @return {@code true} if the url is a data: url.
      */
     public static boolean isDataUrl(String url) {
         return (null != url) && url.startsWith("data:");
     }

     /**
      * @return {@code true} if the url is a javascript: url.
      */
     public static boolean isJavaScriptUrl(String url) {
         return (null != url) && url.startsWith("javascript:");
     }

     /**
      * @return {@code true} if the url is an http: url.
      */
     public static boolean isHttpUrl(String url) {
         return (null != url) &&
                (url.length() > 6) &&
                url.substring(0, 7).equalsIgnoreCase("http://");
     }

     /**
      * @return {@code true} if the url is an https: url.
      */
     public static boolean isHttpsUrl(String url) {
         return (null != url) &&
                (url.length() > 7) &&
                url.substring(0, 8).equalsIgnoreCase("https://");
     }

     /**
      * @return {@code true} if the url is a network url.
      */
     public static boolean isNetworkUrl(String url) {
         if (url == null || url.length() == 0) {
             return false;
         }
         return isHttpUrl(url) || isHttpsUrl(url);
     }

     /**
      * @return {@code true} if the url is a content: url.
      */
     public static boolean isContentUrl(String url) {
         return (null != url) && url.startsWith(CONTENT_BASE);
     }

     /**
      * @return {@code true} if the url is valid.
      */
     public static boolean isValidUrl(String url) {
         if (url == null || url.length() == 0) {
             return false;
         }

         return (isAssetUrl(url) ||
                 isResourceUrl(url) ||
                 isFileUrl(url) ||
                 isAboutUrl(url) ||
                 isHttpUrl(url) ||
                 isHttpsUrl(url) ||
                 isJavaScriptUrl(url) ||
                 isContentUrl(url));
     }

     /**
      * Strips the url of the anchor.
      */
     public static String stripAnchor(String url) {
         int anchorIndex = url.indexOf('#');
         if (anchorIndex != -1) {
             return url.substring(0, anchorIndex);
         }
         return url;
     }

     /**
      * Guesses canonical filename that a download would have, using
      * the URL and contentDisposition. File extension, if not defined,
      * is added based on the mimetype
      * @param url Url to the content
      * @param contentDisposition Content-Disposition HTTP header or {@code null}
      * @param mimeType Mime-type of the content or {@code null}
      *
      * @return suggested filename
      */
     public static final String guessFileName(
             String url,
             @Nullable String contentDisposition,
             @Nullable String mimeType) {
         String filename = null;
         String extension = null;

         // If we couldn't do anything with the hint, move toward the content disposition
         if (contentDisposition != null) {
             filename = parseContentDisposition(contentDisposition);
             if (filename != null) {
                 int index = filename.lastIndexOf('/') + 1;
                 if (index > 0) {
                     filename = filename.substring(index);
                 }
             }
         }

         // If all the other http-related approaches failed, use the plain uri
         if (filename == null) {
             String decodedUrl = Uri.decode(url);
             if (decodedUrl != null) {
                 int queryIndex = decodedUrl.indexOf('?');
                 // If there is a query string strip it, same as desktop browsers
                 if (queryIndex > 0) {
                     decodedUrl = decodedUrl.substring(0, queryIndex);
                 }
                 if (!decodedUrl.endsWith("/")) {
                     int index = decodedUrl.lastIndexOf('/') + 1;
                     if (index > 0) {
                         filename = decodedUrl.substring(index);
                     }
                 }
             }
         }

         // Finally, if couldn't get filename from URI, get a generic filename
         if (filename == null) {
             filename = "downloadfile";
         }

         // Split filename between base and extension
         // Add an extension if filename does not have one
         int dotIndex = filename.indexOf('.');
         if (dotIndex < 0) {
             if (mimeType != null) {
                 extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
                 if (extension != null) {
                     extension = "." + extension;
                 }
             }
             if (extension == null) {
                 if (mimeType != null && mimeType.toLowerCase(Locale.ROOT).startsWith("text/")) {
                     if (mimeType.equalsIgnoreCase("text/html")) {
                         extension = ".html";
                     } else {
                         extension = ".txt";
                     }
                 } else {
                     extension = ".bin";
                 }
             }
         } else {
             if (mimeType != null) {
                 // Compare the last segment of the extension against the mime type.
                 // If there's a mismatch, discard the entire extension.
                 int lastDotIndex = filename.lastIndexOf('.');
                 String typeFromExt = MimeTypeMap.getSingleton().getMimeTypeFromExtension(
                         filename.substring(lastDotIndex + 1));
                 if (typeFromExt != null && !typeFromExt.equalsIgnoreCase(mimeType)) {
                     extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
                     if (extension != null) {
                         extension = "." + extension;
                     }
                 }
             }
             if (extension == null) {
                 extension = filename.substring(dotIndex);
             }
             filename = filename.substring(0, dotIndex);
         }

         return filename + extension;
     }

     /** Regex used to parse content-disposition headers */
     private static final Pattern CONTENT_DISPOSITION_PATTERN =
             Pattern.compile("attachment;\\s*filename\\s*=\\s*(\"?)([^\"]*)\\1\\s*$",
             Pattern.CASE_INSENSITIVE);

     /**
      * Parse the Content-Disposition HTTP Header. The format of the header
      * is defined here: http://www.w3.org/Protocols/rfc2616/rfc2616-sec19.html
      * This header provides a filename for content that is going to be
      * downloaded to the file system. We only support the attachment type.
      * Note that RFC 2616 specifies the filename value must be double-quoted.
      * Unfortunately some servers do not quote the value so to maintain
      * consistent behaviour with other browsers, we allow unquoted values too.
      */
     @UnsupportedAppUsage
     static String parseContentDisposition(String contentDisposition) {
         try {
             Matcher m = CONTENT_DISPOSITION_PATTERN.matcher(contentDisposition);
             if (m.find()) {
                 return m.group(2);
             }
         } catch (IllegalStateException ex) {
              // This function is defined as returning null when it can't parse the header
         }
         return null;
     }
 }
	/*
	* Copyright (C) 2006 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.webkit;

	import android.annotation.Nullable;
	import android.compat.annotation.UnsupportedAppUsage;
	import android.net.ParseException;
	import android.net.Uri;
	import android.net.WebAddress;
	import android.util.Log;

	import java.io.UnsupportedEncodingException;
	import java.util.Locale;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	public final class URLUtil {

	private static final String LOGTAG = "webkit";
	private static final boolean TRACE = false;

	// to refer to bar.png under your package's asset/foo/ directory, use
	// "file:///android_asset/foo/bar.png".
	static final String ASSET_BASE = "file:///android_asset/";
	// to refer to bar.png under your package's res/drawable/ directory, use
	// "file:///android_res/drawable/bar.png". Use "drawable" to refer to
	// "drawable-hdpi" directory as well.
	static final String RESOURCE_BASE = "file:///android_res/";
	static final String FILE_BASE = "file:";
	static final String PROXY_BASE = "file:///cookieless_proxy/";
	static final String CONTENT_BASE = "content:";

	/**
	* Cleans up (if possible) user-entered web addresses
	*/
	public static String guessUrl(String inUrl) {

	String retVal = inUrl;
	WebAddress webAddress;

	if (TRACE) Log.v(LOGTAG, "guessURL before queueRequest: " + inUrl);

	if (inUrl.length() == 0) return inUrl;
	if (inUrl.startsWith("about:")) return inUrl;
	// Do not try to interpret data scheme URLs
	if (inUrl.startsWith("data:")) return inUrl;
	// Do not try to interpret file scheme URLs
	if (inUrl.startsWith("file:")) return inUrl;
	// Do not try to interpret javascript scheme URLs
	if (inUrl.startsWith("javascript:")) return inUrl;

	// bug 762454: strip period off end of url
	if (inUrl.endsWith(".") == true) {
	inUrl = inUrl.substring(0, inUrl.length() - 1);
	}

	try {
	webAddress = new WebAddress(inUrl);
	} catch (ParseException ex) {

	if (TRACE) {
	Log.v(LOGTAG, "smartUrlFilter: failed to parse url = " + inUrl);
	}
	return retVal;
	}

	// Check host
	if (webAddress.getHost().indexOf('.') == -1) {
	// no dot: user probably entered a bare domain. try .com
	webAddress.setHost("www." + webAddress.getHost() + ".com");
	}
	return webAddress.toString();
	}

	public static String composeSearchUrl(String inQuery, String template,
	String queryPlaceHolder) {
	int placeHolderIndex = template.indexOf(queryPlaceHolder);
	if (placeHolderIndex < 0) {
	return null;
	}

	String query;
	StringBuilder buffer = new StringBuilder();
	buffer.append(template.substring(0, placeHolderIndex));

	try {
	query = java.net.URLEncoder.encode(inQuery, "utf-8");
	buffer.append(query);
	} catch (UnsupportedEncodingException ex) {
	return null;
	}

	buffer.append(template.substring(
	placeHolderIndex + queryPlaceHolder.length()));

	return buffer.toString();
	}

	public static byte[] decode(byte[] url) throws IllegalArgumentException {
	if (url.length == 0) {
	return new byte[0];
	}

	// Create a new byte array with the same length to ensure capacity
	byte[] tempData = new byte[url.length];

	int tempCount = 0;
	for (int i = 0; i < url.length; i++) {
	byte b = url[i];
	if (b == '%') {
	if (url.length - i > 2) {
	b = (byte) (parseHex(url[i + 1]) * 16
	+ parseHex(url[i + 2]));
	i += 2;
	} else {
	throw new IllegalArgumentException("Invalid format");
	}
	}
	tempData[tempCount++] = b;
	}
	byte[] retData = new byte[tempCount];
	System.arraycopy(tempData, 0, retData, 0, tempCount);
	return retData;
	}

	/**
	* @return {@code true} if the url is correctly URL encoded
	*/
	@UnsupportedAppUsage
	static boolean verifyURLEncoding(String url) {
	int count = url.length();
	if (count == 0) {
	return false;
	}

	int index = url.indexOf('%');
	while (index >= 0 && index < count) {
	if (index < count - 2) {
	try {
	parseHex((byte) url.charAt(++index));
	parseHex((byte) url.charAt(++index));
	} catch (IllegalArgumentException e) {
	return false;
	}
	} else {
	return false;
	}
	index = url.indexOf('%', index + 1);
	}
	return true;
	}

	private static int parseHex(byte b) {
	if (b >= '0' && b <= '9') return (b - '0');
	if (b >= 'A' && b <= 'F') return (b - 'A' + 10);
	if (b >= 'a' && b <= 'f') return (b - 'a' + 10);

	throw new IllegalArgumentException("Invalid hex char '" + b + "'");
	}

	/**
	* @return {@code true} if the url is an asset file.
	*/
	public static boolean isAssetUrl(String url) {
	return (null != url) && url.startsWith(ASSET_BASE);
	}

	/**
	* @return {@code true} if the url is a resource file.
	* @hide
	*/
	@UnsupportedAppUsage
	public static boolean isResourceUrl(String url) {
	return (null != url) && url.startsWith(RESOURCE_BASE);
	}

	/**
	* @return {@code true} if the url is a proxy url to allow cookieless network
	* requests from a file url.
	* @deprecated Cookieless proxy is no longer supported.
	*/
	@Deprecated
	public static boolean isCookielessProxyUrl(String url) {
	return (null != url) && url.startsWith(PROXY_BASE);
	}

	/**
	* @return {@code true} if the url is a local file.
	*/
	public static boolean isFileUrl(String url) {
	return (null != url) && (url.startsWith(FILE_BASE) &&
	!url.startsWith(ASSET_BASE) &&
	!url.startsWith(PROXY_BASE));
	}

	/**
	* @return {@code true} if the url is an about: url.
	*/
	public static boolean isAboutUrl(String url) {
	return (null != url) && url.startsWith("about:");
	}

	/**
	* @return {@code true} if the url is a data: url.
	*/
	public static boolean isDataUrl(String url) {
	return (null != url) && url.startsWith("data:");
	}

	/**
	* @return {@code true} if the url is a javascript: url.
	*/
	public static boolean isJavaScriptUrl(String url) {
	return (null != url) && url.startsWith("javascript:");
	}

	/**
	* @return {@code true} if the url is an http: url.
	*/
	public static boolean isHttpUrl(String url) {
	return (null != url) &&
	(url.length() > 6) &&
	url.substring(0, 7).equalsIgnoreCase("http://");
	}

	/**
	* @return {@code true} if the url is an https: url.
	*/
	public static boolean isHttpsUrl(String url) {
	return (null != url) &&
	(url.length() > 7) &&
	url.substring(0, 8).equalsIgnoreCase("https://");
	}

	/**
	* @return {@code true} if the url is a network url.
	*/
	public static boolean isNetworkUrl(String url) {
	if (url == null \|\| url.length() == 0) {
	return false;
	}
	return isHttpUrl(url) \|\| isHttpsUrl(url);
	}

	/**
	* @return {@code true} if the url is a content: url.
	*/
	public static boolean isContentUrl(String url) {
	return (null != url) && url.startsWith(CONTENT_BASE);
	}

	/**
	* @return {@code true} if the url is valid.
	*/
	public static boolean isValidUrl(String url) {
	if (url == null \|\| url.length() == 0) {
	return false;
	}

	return (isAssetUrl(url) \|\|
	isResourceUrl(url) \|\|
	isFileUrl(url) \|\|
	isAboutUrl(url) \|\|
	isHttpUrl(url) \|\|
	isHttpsUrl(url) \|\|
	isJavaScriptUrl(url) \|\|
	isContentUrl(url));
	}

	/**
	* Strips the url of the anchor.
	*/
	public static String stripAnchor(String url) {
	int anchorIndex = url.indexOf('#');
	if (anchorIndex != -1) {
	return url.substring(0, anchorIndex);
	}
	return url;
	}

	/**
	* Guesses canonical filename that a download would have, using
	* the URL and contentDisposition. File extension, if not defined,
	* is added based on the mimetype
	* @param url Url to the content
	* @param contentDisposition Content-Disposition HTTP header or {@code null}
	* @param mimeType Mime-type of the content or {@code null}
	*
	* @return suggested filename
	*/
	public static final String guessFileName(
	String url,
	@Nullable String contentDisposition,
	@Nullable String mimeType) {
	String filename = null;
	String extension = null;

	// If we couldn't do anything with the hint, move toward the content disposition
	if (contentDisposition != null) {
	filename = parseContentDisposition(contentDisposition);
	if (filename != null) {
	int index = filename.lastIndexOf('/') + 1;
	if (index > 0) {
	filename = filename.substring(index);
	}
	}
	}

	// If all the other http-related approaches failed, use the plain uri
	if (filename == null) {
	String decodedUrl = Uri.decode(url);
	if (decodedUrl != null) {
	int queryIndex = decodedUrl.indexOf('?');
	// If there is a query string strip it, same as desktop browsers
	if (queryIndex > 0) {
	decodedUrl = decodedUrl.substring(0, queryIndex);
	}
	if (!decodedUrl.endsWith("/")) {
	int index = decodedUrl.lastIndexOf('/') + 1;
	if (index > 0) {
	filename = decodedUrl.substring(index);
	}
	}
	}
	}

	// Finally, if couldn't get filename from URI, get a generic filename
	if (filename == null) {
	filename = "downloadfile";
	}

	// Split filename between base and extension
	// Add an extension if filename does not have one
	int dotIndex = filename.indexOf('.');
	if (dotIndex < 0) {
	if (mimeType != null) {
	extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
	if (extension != null) {
	extension = "." + extension;
	}
	}
	if (extension == null) {
	if (mimeType != null && mimeType.toLowerCase(Locale.ROOT).startsWith("text/")) {
	if (mimeType.equalsIgnoreCase("text/html")) {
	extension = ".html";
	} else {
	extension = ".txt";
	}
	} else {
	extension = ".bin";
	}
	}
	} else {
	if (mimeType != null) {
	// Compare the last segment of the extension against the mime type.
	// If there's a mismatch, discard the entire extension.
	int lastDotIndex = filename.lastIndexOf('.');
	String typeFromExt = MimeTypeMap.getSingleton().getMimeTypeFromExtension(
	filename.substring(lastDotIndex + 1));
	if (typeFromExt != null && !typeFromExt.equalsIgnoreCase(mimeType)) {
	extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
	if (extension != null) {
	extension = "." + extension;
	}
	}
	}
	if (extension == null) {
	extension = filename.substring(dotIndex);
	}
	filename = filename.substring(0, dotIndex);
	}

	return filename + extension;
	}

	/** Regex used to parse content-disposition headers */
	private static final Pattern CONTENT_DISPOSITION_PATTERN =
	Pattern.compile("attachment;\\sfilename\\s=\\s(\"?)([^\"])\\1\\s*$",
	Pattern.CASE_INSENSITIVE);

	/**
	* Parse the Content-Disposition HTTP Header. The format of the header
	* is defined here: http://www.w3.org/Protocols/rfc2616/rfc2616-sec19.html
	* This header provides a filename for content that is going to be
	* downloaded to the file system. We only support the attachment type.
	* Note that RFC 2616 specifies the filename value must be double-quoted.
	* Unfortunately some servers do not quote the value so to maintain
	* consistent behaviour with other browsers, we allow unquoted values too.
	*/
	@UnsupportedAppUsage
	static String parseContentDisposition(String contentDisposition) {
	try {
	Matcher m = CONTENT_DISPOSITION_PATTERN.matcher(contentDisposition);
	if (m.find()) {
	return m.group(2);
	}
	} catch (IllegalStateException ex) {
	// This function is defined as returning null when it can't parse the header
	}
	return null;
	}
	}