Merge

make/com/sun/Makefile

@@ -41,7 +41,7 @@ endif
 # Omit mirror since it's built with the apt tool.
 SUBDIRS = $(SCRIPT_SUBDIR) image security crypto/provider jndi jmx \
     java inputmethods org xml rowset net/httpserver net/ssl demo \
-    tools jarsigner tracing
+    tools jarsigner tracing servicetag
 
 all build clean clobber::
 	$(SUBDIRS-loop)

make/com/sun/servicetag/Makefile

+# Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+# particular file as subject to the "Classpath" exception as provided
+# by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+# CA 95054 USA or visit www.sun.com if you need additional information or
+# have any questions.
+
+BUILDDIR = ../../..
+PACKAGE = com.sun.servicetag
+PRODUCT = sun
+include $(BUILDDIR)/common/Defs.gmk
+
+#
+# Files to compile
+#
+AUTO_FILES_JAVA_DIRS = com/sun/servicetag
+
+#
+# Rules
+#
+include $(BUILDDIR)/common/Classes.gmk
+
+SERVICETAG_LIBDIR = $(LIBDIR)/servicetag
+SERVICETAG_RESOURCES_DIR = $(CLASSDESTDIR)/com/sun/servicetag/resources
+FILES_copy = $(SERVICETAG_RESOURCES_DIR)/product_registration.xsd \
+             $(SERVICETAG_RESOURCES_DIR)/register.html \
+             $(SERVICETAG_RESOURCES_DIR)/register_ja.html \
+             $(SERVICETAG_RESOURCES_DIR)/register_zh_CN.html \
+             $(SERVICETAG_LIBDIR)/jdk_header.png
+
+# Add all properties files to the FILES_copy list
+SWORDFISH_properties := $(shell \
+       $(CD) $(SHARE_SRC)/classes/com/sun/servicetag/resources; \
+       $(FIND) . -name 'javase_*_swordfish.properties' -print ; \
+    )
+FILES_copy += $(shell \
+   for f in $(SWORDFISH_properties) ; do \
+       echo $(SERVICETAG_RESOURCES_DIR)/$$f ; \
+   done \
+)
+
+
+#
+#OTHER_JAVACFLAGS += -Xlint:unchecked
+
+build: install-servicetag-lib copy-files
+
+copy-files: $(FILES_copy)
+
+$(CLASSBINDIR)/%: $(SHARE_SRC)/classes/%
+	$(install-file)
+
+$(SERVICETAG_LIBDIR)/jdk_header.png: $(SHARE_SRC)/classes/com/sun/servicetag/resources/jdk_header.png
+	$(install-file)
+	$(CHMOD) 444 $@
+
+install-servicetag-lib:
+	@$(RM) -rf $(SERVICETAG_LIBDIR)
+	$(MKDIR) $(SERVICETAG_LIBDIR)
+
+clean clobber::
+	@$(RM) $(FILES_copy)
+
+.PHONY: copy-files

src/share/classes/com/sun/servicetag/BrowserSupport.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+import java.io.IOException;
+import java.net.URI;
+
+/**
+ * BrowserSupport class.
+ *
+ * The implementation of the com.sun.servicetag API needs to be
+ * compiled with JDK 5 as well since the consumer of this API
+ * may require to support JDK 5 (e.g. NetBeans).
+ *
+ * The Desktop.browse() method can be backported in this class
+ * if needed.  The current implementation only supports JDK 6.
+ */
+class BrowserSupport {
+    private static boolean isBrowseSupported = false;
+    private static Method browseMethod = null;
+    private static Object desktop = null;
+    private static volatile Boolean result = false;
+
+
+    private static void initX() {
+        if  (desktop != null) {
+            return;
+        }
+        boolean supported = false;
+        Method browseM = null;
+        Object desktopObj = null;
+        try {
+            // Determine if java.awt.Desktop is supported
+            Class<?> desktopCls = Class.forName("java.awt.Desktop", true, null);
+            Method getDesktopM = desktopCls.getMethod("getDesktop");
+            browseM = desktopCls.getMethod("browse", URI.class);
+
+            Class<?> actionCls = Class.forName("java.awt.Desktop$Action", true, null);
+            final Method isDesktopSupportedMethod = desktopCls.getMethod("isDesktopSupported");
+            Method isSupportedMethod = desktopCls.getMethod("isSupported", actionCls);
+            Field browseField = actionCls.getField("BROWSE");
+            // isDesktopSupported calls getDefaultToolkit which can block
+            // infinitely, see 6636099 for details, to workaround we call
+            // in a  thread and time it out, noting that the issue is specific
+            // to X11, it does not hurt for Windows.
+            Thread xthread = new Thread() {
+                public void run() {
+                    try {
+                        // support only if Desktop.isDesktopSupported() and
+                        // Desktop.isSupported(Desktop.Action.BROWSE) return true.
+                        result = (Boolean) isDesktopSupportedMethod.invoke(null);
+                    } catch (IllegalAccessException e) {
+                        // should never reach here
+                        InternalError x =
+                            new InternalError("Desktop.getDesktop() method not found");
+                        x.initCause(e);
+                    } catch (InvocationTargetException e) {
+                        // browser not supported
+                        if (Util.isVerbose()) {
+                            e.printStackTrace();
+                        }
+                    }
+                }
+            };
+            // set it to daemon, so that the vm will exit.
+            xthread.setDaemon(true);
+            xthread.start();
+            try {
+                xthread.join(5 * 1000);
+            } catch (InterruptedException ie) {
+                // ignore the exception
+            }
+            if (result.booleanValue()) {
+                desktopObj = getDesktopM.invoke(null);
+                result = (Boolean) isSupportedMethod.invoke(desktopObj, browseField.get(null));
+                supported = result.booleanValue();
+            }
+        } catch (ClassNotFoundException e) {
+            // browser not supported
+            if (Util.isVerbose()) {
+                e.printStackTrace();
+            }
+        } catch (NoSuchMethodException e) {
+            // browser not supported
+            if (Util.isVerbose()) {
+                e.printStackTrace();
+            }
+        } catch (NoSuchFieldException e) {
+            // browser not supported
+            if (Util.isVerbose()) {
+                e.printStackTrace();
+            }
+        } catch (IllegalAccessException e) {
+            // should never reach here
+            InternalError x =
+                    new InternalError("Desktop.getDesktop() method not found");
+            x.initCause(e);
+            throw x;
+        } catch (InvocationTargetException e) {
+            // browser not supported
+            if (Util.isVerbose()) {
+                e.printStackTrace();
+            }
+        }
+        isBrowseSupported = supported;
+        browseMethod = browseM;
+        desktop = desktopObj;
+    }
+
+    static boolean isSupported() {
+        initX();
+        return isBrowseSupported;
+    }
+
+    /**
+     * Launches the default browser to display a {@code URI}.
+     * If the default browser is not able to handle the specified
+     * {@code URI}, the application registered for handling
+     * {@code URIs} of the specified type is invoked. The application
+     * is determined from the protocol and path of the {@code URI}, as
+     * defined by the {@code URI} class.
+     * <p>
+     * This method calls the Desktop.getDesktop().browse() method.
+     * <p>
+     * @param uri the URI to be displayed in the user default browser
+     *
+     * @throws NullPointerException if {@code uri} is {@code null}
+     * @throws UnsupportedOperationException if the current platform
+     * does not support the {@link Desktop.Action#BROWSE} action
+     * @throws IOException if the user default browser is not found,
+     * or it fails to be launched, or the default handler application
+     * failed to be launched
+     * @throws IllegalArgumentException if the necessary permissions
+     * are not available and the URI can not be converted to a {@code URL}
+     */
+    static void browse(URI uri) throws IOException {
+        if (uri == null) {
+            throw new NullPointerException("null uri");
+        }
+        if (!isSupported()) {
+            throw new UnsupportedOperationException("Browse operation is not supported");
+        }
+
+        // Call Desktop.browse() method
+        try {
+            if (Util.isVerbose()) {
+                System.out.println("desktop: " + desktop + ":browsing..." + uri);
+            }
+            browseMethod.invoke(desktop, uri);
+        } catch (IllegalAccessException e) {
+            // should never reach here
+            InternalError x =
+                new InternalError("Desktop.getDesktop() method not found");
+            x.initCause(e);
+                throw x;
+        } catch (InvocationTargetException e) {
+            Throwable x = e.getCause();
+            if (x != null) {
+                if (x instanceof UnsupportedOperationException) {
+                    throw (UnsupportedOperationException) x;
+                } else if (x instanceof IllegalArgumentException) {
+                    throw (IllegalArgumentException) x;
+                } else if (x instanceof IOException) {
+                    throw (IOException) x;
+                } else if (x instanceof SecurityException) {
+                    throw (SecurityException) x;
+                } else {
+                    // ignore
+                }
+            }
+        }
+    }
+}

src/share/classes/com/sun/servicetag/LinuxSystemEnvironment.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+// This class is a copy of the com.sun.scn.servicetags.LinuxSystemEnvironment
+// class from the Sun Connection source.
+//
+// The Service Tags team maintains the latest version of the implementation
+// for system environment data collection.  JDK will include a copy of
+// the most recent released version for a JDK release. We rename
+// the package to com.sun.servicetag so that the Sun Connection
+// product always uses the latest version from the com.sun.scn.servicetags
+// package. JDK and users of the com.sun.servicetag API
+// (e.g. NetBeans and SunStudio) will use the version in JDK.
+//
+// So we keep this class in src/share/classes instead of src/<os>/classes.
+
+import java.io.*;
+
+/**
+ * Linux implementation of the SystemEnvironment class.
+ */
+class LinuxSystemEnvironment extends SystemEnvironment {
+    LinuxSystemEnvironment() {
+        setHostId(getLinuxHostId());
+        setSystemModel(getCommandOutput("/bin/uname", "-i"));
+        setSystemManufacturer(getLinuxSystemManufacturer());
+        setCpuManufacturer(getLinuxCpuManufacturer());
+        setSerialNumber(getLinuxSN());
+    }
+    private String dmiInfo = null;
+
+    private static final int SN  = 1;
+    private static final int SYS = 2;
+    private static final int CPU = 3;
+
+    private String getLinuxHostId() {
+        String output = getCommandOutput("/usr/bin/hostid");
+        // trim off the leading 0x
+        if (output.startsWith("0x")) {
+            output = output.substring(2);
+        }
+        return output;
+    }
+
+    /**
+     * Tries to obtain and return the cpu manufacturer.
+     * @return The cpu manufacturer (an empty string if not found or an error occurred)
+     */
+    private String getLinuxCpuManufacturer() {
+        String tmp = getLinuxPSNInfo(CPU);
+        if (tmp.length() > 0) {
+            return tmp;
+        }
+
+        String contents = getFileContent("/proc/cpuinfo");
+        for (String line : contents.split("\n")) {
+            if (line.contains("vendor_id")) {
+                String[] ss = line.split(":", 2);
+                if (ss.length > 1) {
+                    return ss[1].trim();
+                }
+            }
+        }
+
+        // returns an empty string if it can't be found or an error happened
+        return getLinuxDMIInfo("dmi type 4", "manufacturer");
+    }
+
+
+    /**
+     * Tries to obtain and return the system manufacturer.
+     * @return The system manufacturer (an empty string if not found or an error occurred)
+     */
+    private String getLinuxSystemManufacturer() {
+        String tmp = getLinuxPSNInfo(SYS);
+        if (tmp.length() > 0) {
+            return tmp;
+        }
+
+        // returns an empty string if it can't be found or an error happened
+        return getLinuxDMIInfo("dmi type 1", "manufacturer");
+    }
+
+    /**
+     * Tries to obtain and return the serial number of the system.
+     * @return The serial number (an empty string if not found or an error occurred)
+     */
+    private String getLinuxSN() {
+        String tmp = getLinuxPSNInfo(SN);
+        if (tmp.length() > 0) {
+            return tmp;
+        }
+
+        // returns an empty string if it can't be found or an error happened
+        return getLinuxDMIInfo("dmi type 1", "serial number");
+    }
+
+    private String getLinuxPSNInfo(int target) {
+        // try to read from the psn file if it exists
+        String contents = getFileContent("/var/run/psn");
+        String[] ss = contents.split("\n");
+        if (target <= ss.length) {
+            return ss[target-1];
+        }
+
+        // default case is to return ""
+        return "";
+    }
+
+    // reads from dmidecode with the given type and target
+    // returns an empty string if nothing was found or an error occurred
+    //
+    // Sample output segment:
+    // Handle 0x0001
+    //         DMI type 1, 25 bytes.
+    //         System Information
+    //                 Manufacturer: System manufacturer
+    //                 Product Name: System Product Name
+    //                 Version: System Version
+    //                 Serial Number: System Serial Number
+    //                 UUID: 3091D719-B25B-D911-959D-6D1B12C7686E
+    //                 Wake-up Type: Power Switch
+
+    private synchronized String getLinuxDMIInfo(String dmiType, String target) {
+        // only try to get dmidecode information once, after that, we can
+        // reuse the output
+        if (dmiInfo == null) {
+            Thread dmidecodeThread = new Thread() {
+                public void run() {
+                    dmiInfo = getCommandOutput("/usr/sbin/dmidecode");
+                }
+            };
+            dmidecodeThread.start();
+
+            try {
+                dmidecodeThread.join(2000);
+                if (dmidecodeThread.isAlive()) {
+                    dmidecodeThread.interrupt();
+                    dmiInfo = "";
+                }
+            } catch (InterruptedException ie) {
+                dmidecodeThread.interrupt();
+            }
+        }
+
+        if (dmiInfo.length() == 0) {
+            return "";
+        }
+        boolean dmiFlag = false;
+        for (String s : dmiInfo.split("\n")) {
+            String line = s.toLowerCase();
+            if (dmiFlag) {
+                if (line.contains(target)) {
+                    String key = target + ":";
+                    int indx = line.indexOf(key) + key.length();
+                    if (line.contains(key) && indx < line.length()) {
+                        return line.substring(indx).trim();
+                    }
+                    String[] ss = line.split(":");
+                    return ss[ss.length-1];
+                }
+            } else if (line.contains(dmiType)) {
+                dmiFlag = true;
+            }
+        }
+        return "";
+    }
+
+}

src/share/classes/com/sun/servicetag/RegistrationData.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+import java.io.*;
+import java.net.UnknownHostException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+import static com.sun.servicetag.RegistrationDocument.*;
+
+/**
+ * A {@code RegistrationData} object is a container of one or more
+ * {@link #getServiceTags service tags} that identify the
+ * components for product registration.
+ * Each {@code RegistrationData} object has a {@link #getRegistrationURN
+ * uniform resource name} (URN) as its identifier.
+ * <a name="EnvMap"></a>
+ * It also has an <i>environment map</i> with
+ * the following elements:
+ * <blockquote>
+ *       <table border=0>
+ *       <tr>
+ *          <td><tt>hostname</tt></td>
+ *          <td>Hostname of the system</td>
+ *          <td>e.g. woody</td>
+ *       </tr>
+ *       <tr>
+ *          <td><tt>hostId</tt></td>
+ *          <td>Host ID of the system</td>
+ *          <td>e.g. 83abc1ab</td>
+ *       </tr>
+ *       <tr>
+ *          <td><tt>osName</tt></td>
+ *          <td>Operating system name</td>
+ *          <td> e.g. SunOS</td>
+ *       </tr>
+ *       <tr>
+ *          <td><tt>osVersion</tt></td>
+ *          <td>Operating system version</td>
+ *          <td> e.g. 5.10</td>
+ *       </tr>
+ *       <tr>
+ *          <td><tt>osArchitecture</tt></td>
+ *          <td>Operating system architecture</td>
+ *          <td> e.g. sparc</td>
+ *       </tr>
+ *       <tr>
+ *          <td><tt>systemModel</tt></td>
+ *          <td>System model</td>
+ *          <td> e.g. SUNW,Sun-Fire-V440</td>
+ *       </tr>
+ *       <tr>
+ *          <td><tt>systemManufacturer</tt></td>
+ *          <td>System manufacturer</td>
+ *          <td> e.g. Sun Microsystems</td>
+ *       </tr>
+ *       <tr>
+ *          <td><tt>cpuManufacturer</tt></td>
+ *          <td>CPU manufacturer</td>
+ *          <td> e.g. Sun Microsystems</td>
+ *       </tr>
+ *       <tr>
+ *          <td><tt>serialNumber</tt></td>
+ *          <td>System serial number</td>
+ *          <td> e.g. BEL078932</td>
+ *       </tr>
+ *       </table>
+ *  </blockquote>
+ * The <tt>hostname</tt> and <tt>osName</tt> element must have a non-empty value.
+ * If an element is not available on a system and their value will be
+ * empty.
+ * <p>
+ * <a name="XMLSchema">
+ * <b>Registration XML Schema</b></a>
+ * <p>
+ * A {@code RegistrationData} object can be {@link #loadFromXML loaded} from
+ * and {@link #storeToXML stored} into an XML file in the format described
+ * by the
+ * <a href="https://sn-tools.central.sun.com/twiki/pub/ServiceTags/RegistrationRelayService/product_registration.xsd">
+ * registration data schema</a>.  The registration data schema is defined by the
+ * Service Tags Technology.
+ * <p>
+ * Typically the registration data is constructed at installation time
+ * and stored in an XML file for later service tag lookup or registration.
+ *
+ * <p>
+ * <b>Example Usage</b>
+ * <p>
+ * The examples below show how the {@code RegistrationData} can be
+ * used for product registration.
+ * Exception handling is not shown in these examples for clarity.
+ * <ol>
+ * <li>This example shows how the JDK creates a JDK service tag, installs it
+ * in the system service tag registry and adds it to the registration data.
+ * <br>
+ * <blockquote><pre>
+ *   // create a service tag object with an instance_urn
+ *   ServiceTag st = ServiceTag.newInstance(ServiceTag.generateInstanceURN(),
+ *                                          ....);
+ *   // Adds to the system service tag registry if supported
+ *   if (Registry.isSupported()) {
+ *       Registry.getSystemRegistry().addServiceTag(st);
+ *   }
+ *
+ *   // add to the registration data
+ *   RegistrationData registration  = new RegistrationData();
+ *   registration.addServiceTag(st);
+ * </pre></blockquote>
+ * </li>
+ * <li>At this point, the registration data is ready to
+ * send to Sun Connection for registration. This example shows how to register
+ * the JDK via the <i>Registration Relay Service</i>.
+ * <p>
+ * There are several registration services for Sun Connection. For example,
+ * the <a href="https://sn-tools.central.sun.com/twiki/bin/view/ServiceTags/RegistrationRelayService">
+ * Registration Relay Service</a> is a web application interface that
+ * processes the registration data payload sent via HTTP post
+ * and hosts the registration user interface for a specified
+ * registration URL.  Refer to the
+ * Registration Relay Service Specification for details.
+ * <p>
+ * <blockquote><pre>
+ *   // Open the connection to the URL of the registration service
+ *   HttpsURLConnection con = (HttpsURLConnection) url.openConnection();
+ *   con.setDoInput(true);
+ *   con.setDoOutput(true);
+ *   con.setUseCaches(false);
+ *   con.setAllowUserInteraction(false);
+ *   con.setRequestMethod("POST");
+ *   con.setRequestProperty("Content-Type", "text/xml;charset=\"utf-8\"");
+ *   con.connect();
+ *
+ *   // send the registration data to the registration service
+ *   OutputStream out = con.getOutputStream();
+ *   registration.storeToXML(out);
+ *   out.close();
+ * </pre></blockquote>
+ * </li>
+ * <li>This example shows how to store the registration data in an XML file.
+ *     for later service tag lookup or registration.
+ * <br>
+ * <blockquote><pre>
+ *   BufferedOutputStream out = new BufferedOutputStream(
+ *       new FileOutputStream(""&lt;JAVA_HOME&gt;/lib/servicetag/registration.xml"));
+ *   registration.storeToXML(out);
+ *   out.close();
+ * </pre></blockquote>
+ * </li>
+ * <li>This example shows how to install service tags that are in the
+ * registration data in the system service tag registry when determined
+ * to be available.  The system service tag registry might not have existed
+ * when the registration data was constructed.
+ * <br>
+ * <blockquote><pre>
+ *   if (Registry.isSupported()) {
+ *       Set&lt;ServiceTag&gt; svctags = registration.getServiceTags();
+ *       for (ServiceTag st : svctags) {
+ *           Registry.getSystemRegistry().addServiceTag(st);
+ *       }
+ *   }
+ * </pre></blockquote>
+ * </li>
+ * </ol>
+ *
+ * @see <a href="https://sunconnection.sun.com/inventory">Sun Connection Inventory Channel</a>
+ */
+public class RegistrationData {
+    private final Map<String, String> environment = initEnvironment();
+    private final Map<String, ServiceTag> svcTagMap =
+        new LinkedHashMap<String, ServiceTag>();
+    private final String urn;
+
+    /**
+     * Creates a {@code RegistrationData} object with a generated
+     * {@link #getRegistrationURN registration URN}.
+     * The following keys in the {@link #getEnvironmentMap environment map}
+     * will be initialized for the configuration of the
+     * running system:
+     * <blockquote>
+     * <tt>hostname</tt>, <tt>osName</tt>,  <tt>osVersion</tt> and
+     * <tt>osArchitecture</tt>
+     * </blockquote>
+     * and the value of other keys may be empty.
+     */
+    public RegistrationData() {
+        this(Util.generateURN());
+        SystemEnvironment sysEnv = SystemEnvironment.getSystemEnvironment();
+        setEnvironment(ST_NODE_HOSTNAME, sysEnv.getHostname());
+        setEnvironment(ST_NODE_HOST_ID, sysEnv.getHostId());
+        setEnvironment(ST_NODE_OS_NAME, sysEnv.getOsName());
+        setEnvironment(ST_NODE_OS_VERSION, sysEnv.getOsVersion());
+        setEnvironment(ST_NODE_OS_ARCH, sysEnv.getOsArchitecture());
+        setEnvironment(ST_NODE_SYSTEM_MODEL, sysEnv.getSystemModel());
+        setEnvironment(ST_NODE_SYSTEM_MANUFACTURER, sysEnv.getSystemManufacturer());
+        setEnvironment(ST_NODE_CPU_MANUFACTURER, sysEnv.getCpuManufacturer());
+        setEnvironment(ST_NODE_SERIAL_NUMBER, sysEnv.getSerialNumber());
+    }
+
+    // package private
+    RegistrationData(String urn) {
+        this.urn = urn;
+    }
+
+    private Map<String, String> initEnvironment() {
+        Map<String, String> map = new LinkedHashMap<String, String>();
+        map.put(ST_NODE_HOSTNAME, "");
+        map.put(ST_NODE_HOST_ID, "");
+        map.put(ST_NODE_OS_NAME, "");
+        map.put(ST_NODE_OS_VERSION, "");
+        map.put(ST_NODE_OS_ARCH, "");
+        map.put(ST_NODE_SYSTEM_MODEL, "");
+        map.put(ST_NODE_SYSTEM_MANUFACTURER, "");
+        map.put(ST_NODE_CPU_MANUFACTURER, "");
+        map.put(ST_NODE_SERIAL_NUMBER, "");
+        return map;
+    }
+
+    /**
+     * Returns the uniform resource name of this registration data
+     * in this format:
+     * <tt>urn:st:&lt;32-char {@link java.util.UUID uuid}&gt;</tt>
+     *
+     * @return the URN of this registration data.
+     */
+    public String getRegistrationURN() {
+        return urn;
+    }
+
+    /**
+     * Returns a map containing the environment information for this
+     * registration data.  See the set of <a href="#EnvMap">keys</a>
+     * in the environment map. Subsequent update to the environment
+     * map via the {@link #setEnvironment setEnvironment} method will not be reflected
+     * in the returned map.
+     *
+     * @return an environment map for this registration data.
+     */
+    public Map<String, String> getEnvironmentMap() {
+        return new LinkedHashMap<String,String>(environment);
+    }
+
+    /**
+     * Sets an element of the specified {@code name} in the environment map
+     * with the given {@code value}.
+     *
+     * @throws IllegalArgumentException if {@code name} is not a valid key
+     * in the environment map, or {@code value} is not valid.
+     */
+    public void setEnvironment(String name, String value) {
+        if (name == null) {
+            throw new NullPointerException("name is null");
+        }
+        if (value == null) {
+            throw new NullPointerException("value is null");
+        }
+        if (environment.containsKey(name)) {
+            if (name.equals(ST_NODE_HOSTNAME) || name.equals(ST_NODE_OS_NAME)) {
+                if (value.length() == 0) {
+                    throw new IllegalArgumentException("\"" +
+                        name + "\" requires non-empty value.");
+                }
+            }
+            environment.put(name, value);
+        } else {
+            throw new IllegalArgumentException("\"" +
+                 name + "\" is not an environment element.");
+        }
+    }
+
+    /**
+     * Returns all service tags in this registration data.
+     *
+     * @return  a {@link Set Set} of the service tags
+     * in this registration data.
+     */
+    public Set<ServiceTag> getServiceTags() {
+        return new HashSet<ServiceTag>(svcTagMap.values());
+    }
+
+    /**
+     * Adds a service tag to this registration data.
+     * If the given service tag has an empty <tt>instance_urn</tt>,
+     * this method will generate a URN and place it in the copy
+     * of the service tag in this registration data.
+     * This method will return the {@code ServiceTag} object
+     * added to this registration data.
+     *
+     * @param st {@code ServiceTag} object to be added.
+     * @return a {@code ServiceTag} object added to this registration data.
+     *
+     * @throws IllegalArgumentException if
+     *   a service tag of the same {@link ServiceTag#getInstanceURN
+     *   <tt>instance_urn</tt>} already exists in the registry.
+     */
+    public synchronized ServiceTag addServiceTag(ServiceTag st) {
+        ServiceTag svcTag = ServiceTag.newInstanceWithUrnTimestamp(st);
+
+        String instanceURN = svcTag.getInstanceURN();
+        if (svcTagMap.containsKey(instanceURN)) {
+            throw new IllegalArgumentException("Instance_urn = " + instanceURN +
+                    " already exists in the registration data.");
+        } else {
+            svcTagMap.put(instanceURN, svcTag);
+        }
+        return svcTag;
+    }
+
+    /**
+     * Returns a service tag of the given <tt>instance_urn</tt> in this registration
+     * data.
+     *
+     * @param instanceURN the <tt>instance_urn</tt> of the service tag
+     * @return the {@code ServiceTag} object of the given  <tt>instance_urn</tt>
+     *         if exists; otherwise return {@code null}.
+     */
+    public synchronized ServiceTag getServiceTag(String instanceURN) {
+        if (instanceURN == null) {
+            throw new NullPointerException("instanceURN is null");
+        }
+        return svcTagMap.get(instanceURN);
+    }
+
+    /**
+     * Removes a service tag of the given <tt>instance_urn</tt> from this
+     * registration data.
+     *
+     * @param instanceURN the <tt>instance_urn</tt> of
+     * the service tag to be removed.
+     *
+     * @return the removed {@code ServiceTag} object;
+     * or {@code null} if the service tag does not exist in this
+     * registration data.
+     */
+    public synchronized ServiceTag removeServiceTag(String instanceURN) {
+        if (instanceURN == null) {
+            throw new NullPointerException("instanceURN is null");
+        }
+
+        ServiceTag svcTag = null;
+        if (svcTagMap.containsKey(instanceURN)) {
+            svcTag = svcTagMap.remove(instanceURN);
+        }
+        return svcTag;
+    }
+
+     /**
+     * Updates the <tt>product_defined_instance_id</tt> in the service tag
+     * of the given <tt>instance_urn</tt> in this registration data.
+     *
+     * @param instanceURN the <tt>instance_urn</tt> of the service tag to be updated.
+     * @param productDefinedInstanceID the value of the
+     * <tt>product_defined_instance_id</tt> to be set.
+     *
+     * @return the updated {@code ServiceTag} object;
+     * or {@code null} if the service tag does not exist in this
+     * registration data.
+     */
+    public synchronized ServiceTag updateServiceTag(String instanceURN,
+                                                    String productDefinedInstanceID) {
+        ServiceTag svcTag = getServiceTag(instanceURN);
+        if (svcTag == null) {
+            return null;
+        }
+
+        svcTag = ServiceTag.newInstanceWithUrnTimestamp(svcTag);
+        // update the product defined instance ID field
+        svcTag.setProductDefinedInstanceID(productDefinedInstanceID);
+        svcTagMap.put(instanceURN, svcTag);
+        return svcTag;
+    }
+
+    /**
+     * Reads the registration data from the XML document on the
+     * specified input stream.  The XML document must be
+     * in the format described by the <a href="#XMLSchema">
+     * registration data schema</a>.
+     * The specified stream is closed after this method returns.
+     *
+     * @param in the input stream from which to read the XML document.
+     * @return a {@code RegistrationData} object read from the input
+     * stream.
+     *
+     * @throws IllegalArgumentException if the input stream
+     * contains an invalid registration data.
+     *
+     * @throws IOException if an error occurred when reading from the input stream.
+     */
+    public static RegistrationData loadFromXML(InputStream in) throws IOException {
+        try {
+            return RegistrationDocument.load(in);
+        } finally {
+            in.close();
+        }
+    }
+
+    /**
+     * Writes the registration data to the specified output stream
+     * in the format described by the <a href="#XMLSchema">
+     * registration data schema</a> with "UTF-8" encoding.
+     * The specified stream remains open after this method returns.
+     *
+     * @param os the output stream on which to write the XML document.
+     *
+     * @throws IOException if an error occurred when writing to the output stream.
+     */
+    public void storeToXML(OutputStream os) throws IOException {
+        RegistrationDocument.store(os, this);
+        os.flush();
+    }
+
+    /**
+     * Returns a newly allocated byte array containing the registration
+     * data in XML format.
+     *
+     * @return a newly allocated byte array containing the registration
+     * data in XML format.
+     */
+    public byte[] toXML() {
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            storeToXML(out);
+            return out.toByteArray();
+        } catch (IOException e) {
+            // should not reach here
+            return new byte[0];
+        }
+    }
+
+    /**
+     * Returns a string representation of this registration data in XML
+     * format.
+     *
+     * @return a string representation of this registration data in XML
+     *         format.
+     */
+    @Override
+    public String toString() {
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            storeToXML(out);
+            return out.toString("UTF-8");
+        } catch (IOException e) {
+            // should not reach here
+            return "Error creating the return string.";
+        }
+    }
+}

src/share/classes/com/sun/servicetag/RegistrationDocument.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+import java.io.*;
+import java.net.URL;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+import org.xml.sax.InputSource;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.validation.Schema;
+import javax.xml.validation.SchemaFactory;
+import javax.xml.validation.Validator;
+
+// For write operation
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+/**
+ * XML Support Class for Product Registration.
+ */
+class RegistrationDocument {
+
+    private static final String REGISTRATION_DATA_SCHEMA =
+            "/com/sun/servicetag/resources/product_registration.xsd";
+    private static final String REGISTRATION_DATA_VERSION = "1.0";
+    private static final String SERVICE_TAG_VERSION = "1.0";
+    final static String ST_NODE_REGISTRATION_DATA = "registration_data";
+    final static String ST_ATTR_REGISTRATION_VERSION = "version";
+    final static String ST_NODE_ENVIRONMENT = "environment";
+    final static String ST_NODE_HOSTNAME = "hostname";
+    final static String ST_NODE_HOST_ID = "hostId";
+    final static String ST_NODE_OS_NAME = "osName";
+    final static String ST_NODE_OS_VERSION = "osVersion";
+    final static String ST_NODE_OS_ARCH = "osArchitecture";
+    final static String ST_NODE_SYSTEM_MODEL = "systemModel";
+    final static String ST_NODE_SYSTEM_MANUFACTURER = "systemManufacturer";
+    final static String ST_NODE_CPU_MANUFACTURER = "cpuManufacturer";
+    final static String ST_NODE_SERIAL_NUMBER = "serialNumber";
+    final static String ST_NODE_REGISTRY = "registry";
+    final static String ST_ATTR_REGISTRY_URN = "urn";
+    final static String ST_ATTR_REGISTRY_VERSION = "version";
+    final static String ST_NODE_SERVICE_TAG = "service_tag";
+    final static String ST_NODE_INSTANCE_URN = "instance_urn";
+    final static String ST_NODE_PRODUCT_NAME = "product_name";
+    final static String ST_NODE_PRODUCT_VERSION = "product_version";
+    final static String ST_NODE_PRODUCT_URN = "product_urn";
+    final static String ST_NODE_PRODUCT_PARENT_URN = "product_parent_urn";
+    final static String ST_NODE_PRODUCT_PARENT = "product_parent";
+    final static String ST_NODE_PRODUCT_DEFINED_INST_ID = "product_defined_inst_id";
+    final static String ST_NODE_PRODUCT_VENDOR = "product_vendor";
+    final static String ST_NODE_PLATFORM_ARCH = "platform_arch";
+    final static String ST_NODE_TIMESTAMP = "timestamp";
+    final static String ST_NODE_CONTAINER = "container";
+    final static String ST_NODE_SOURCE = "source";
+    final static String ST_NODE_INSTALLER_UID = "installer_uid";
+
+    static RegistrationData load(InputStream in) throws IOException {
+        Document document = initializeDocument(in);
+
+        // Gets the registration URN
+        Element root = getRegistrationDataRoot(document);
+        Element registryRoot =
+                getSingletonElementFromRoot(root, ST_NODE_REGISTRY);
+        String urn = registryRoot.getAttribute(ST_ATTR_REGISTRY_URN);
+
+        // Construct a new RegistrationData object from the DOM tree
+        // Initialize the environment map and service tags
+        RegistrationData regData = new RegistrationData(urn);
+        addServiceTags(registryRoot, regData);
+
+        Element envRoot = getSingletonElementFromRoot(root, ST_NODE_ENVIRONMENT);
+        buildEnvironmentMap(envRoot, regData);
+        return regData;
+    }
+
+    static void store(OutputStream os, RegistrationData registration)
+            throws IOException {
+        // create a new document with the root node
+        Document document = initializeDocument();
+
+        // create the nodes for the environment map and the service tags
+        // in the registration data
+        addEnvironmentNodes(document,
+                            registration.getEnvironmentMap());
+        addServiceTagRegistry(document,
+                              registration.getRegistrationURN(),
+                              registration.getServiceTags());
+        transform(document, os);
+    }
+
+    // initialize a document from an input stream
+    private static Document initializeDocument(InputStream in) throws IOException {
+        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+        try {
+            // XML schema for validation
+            SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
+            URL xsdUrl = RegistrationDocument.class.getResource(REGISTRATION_DATA_SCHEMA);
+            Schema schema = sf.newSchema(xsdUrl);
+            Validator validator = schema.newValidator();
+
+            DocumentBuilder builder = factory.newDocumentBuilder();
+            Document doc = builder.parse(new InputSource(in));
+            validator.validate(new DOMSource(doc));
+            return doc;
+        } catch (SAXException sxe) {
+            IllegalArgumentException e = new IllegalArgumentException("Error generated in parsing");
+            e.initCause(sxe);
+            throw e;
+        } catch (ParserConfigurationException pce) {
+            // Parser with specific options can't be built
+            // should not reach here
+            InternalError x = new InternalError("Error in creating the new document");
+            x.initCause(pce);
+            throw x;
+        }
+    }
+
+    // initialize a new document for the registration data
+    private static Document initializeDocument() throws IOException {
+        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+        try {
+            DocumentBuilder builder = factory.newDocumentBuilder();
+            Document doc = builder.newDocument();
+
+            // initialize the document with the registration_data root
+            Element root = doc.createElement(ST_NODE_REGISTRATION_DATA);
+            doc.appendChild(root);
+            root.setAttribute(ST_ATTR_REGISTRATION_VERSION, REGISTRATION_DATA_VERSION);
+
+            return doc;
+        } catch (ParserConfigurationException pce) {
+            // Parser with specified options can't be built
+            // should not reach here
+            InternalError x = new InternalError("Error in creating the new document");
+            x.initCause(pce);
+            throw x;
+        }
+    }
+
+    // Transform the current DOM tree with the given output stream.
+    private static void transform(Document document, OutputStream os) {
+        try {
+            // Use a Transformer for output
+            TransformerFactory tFactory = TransformerFactory.newInstance();
+            tFactory.setAttribute("indent-number", new Integer(3));
+
+            Transformer transformer = tFactory.newTransformer();
+
+            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+            transformer.setOutputProperty(OutputKeys.METHOD, "xml");
+            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
+            transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
+            transformer.transform(new DOMSource(document),
+                new StreamResult(new BufferedWriter(new OutputStreamWriter(os, "UTF-8"))));
+        } catch (UnsupportedEncodingException ue) {
+            // Should not reach here
+            InternalError x = new InternalError("Error generated during transformation");
+            x.initCause(ue);
+            throw x;
+        } catch (TransformerConfigurationException tce) {
+            // Error generated by the parser
+            // Should not reach here
+            InternalError x = new InternalError("Error in creating the new document");
+            x.initCause(tce);
+            throw x;
+        } catch (TransformerException te) {
+            // Error generated by the transformer
+            InternalError x = new InternalError("Error generated during transformation");
+            x.initCause(te);
+            throw x;
+        }
+    }
+
+    private static void addServiceTagRegistry(Document document,
+                                              String registryURN,
+                                              Set<ServiceTag> svcTags) {
+        // add service tag registry node and its attributes
+        Element reg = document.createElement(ST_NODE_REGISTRY);
+        reg.setAttribute(ST_ATTR_REGISTRY_URN, registryURN);
+        reg.setAttribute(ST_ATTR_REGISTRY_VERSION, SERVICE_TAG_VERSION);
+
+        Element root = getRegistrationDataRoot(document);
+        root.appendChild(reg);
+
+        // adds the elements for the service tags
+        for (ServiceTag st : svcTags) {
+            addServiceTagElement(document, reg, st);
+        }
+    }
+
+    private static void addServiceTagElement(Document document,
+                                             Element registryRoot,
+                                             ServiceTag st) {
+        Element svcTag = document.createElement(ST_NODE_SERVICE_TAG);
+        registryRoot.appendChild(svcTag);
+        addChildElement(document, svcTag,
+                        ST_NODE_INSTANCE_URN, st.getInstanceURN());
+        addChildElement(document, svcTag,
+                        ST_NODE_PRODUCT_NAME, st.getProductName());
+        addChildElement(document, svcTag,
+                        ST_NODE_PRODUCT_VERSION, st.getProductVersion());
+        addChildElement(document, svcTag,
+                        ST_NODE_PRODUCT_URN, st.getProductURN());
+        addChildElement(document, svcTag,
+                        ST_NODE_PRODUCT_PARENT_URN, st.getProductParentURN());
+        addChildElement(document, svcTag,
+                        ST_NODE_PRODUCT_PARENT, st.getProductParent());
+        addChildElement(document, svcTag,
+                        ST_NODE_PRODUCT_DEFINED_INST_ID,
+                        st.getProductDefinedInstanceID());
+        addChildElement(document, svcTag,
+                        ST_NODE_PRODUCT_VENDOR, st.getProductVendor());
+        addChildElement(document, svcTag,
+                        ST_NODE_PLATFORM_ARCH, st.getPlatformArch());
+        addChildElement(document, svcTag,
+                        ST_NODE_TIMESTAMP, Util.formatTimestamp(st.getTimestamp()));
+        addChildElement(document, svcTag,
+                        ST_NODE_CONTAINER, st.getContainer());
+        addChildElement(document, svcTag,
+                        ST_NODE_SOURCE, st.getSource());
+        addChildElement(document, svcTag,
+                        ST_NODE_INSTALLER_UID,
+                        String.valueOf(st.getInstallerUID()));
+    }
+
+    private static void addChildElement(Document document, Element root,
+                                        String element, String text) {
+        Element node = document.createElement(element);
+        node.appendChild(document.createTextNode(text));
+        root.appendChild(node);
+    }
+
+    // Constructs service tags from the document
+    private static void addServiceTags(Element registryRoot,
+                                       RegistrationData registration) {
+        NodeList children = registryRoot.getElementsByTagName(ST_NODE_SERVICE_TAG);
+        int length = (children == null ? 0 : children.getLength());
+        for (int i = 0; i < length; i++) {
+            Element svcTagElement = (Element) children.item(i);
+            ServiceTag st = getServiceTag(svcTagElement);
+            registration.addServiceTag(st);
+        }
+    }
+
+    // build environment map from the document
+    private static void buildEnvironmentMap(Element envRoot,
+                                         RegistrationData registration) {
+        registration.setEnvironment(ST_NODE_HOSTNAME, getTextValue(envRoot, ST_NODE_HOSTNAME));
+        registration.setEnvironment(ST_NODE_HOST_ID, getTextValue(envRoot, ST_NODE_HOST_ID));
+        registration.setEnvironment(ST_NODE_OS_NAME, getTextValue(envRoot, ST_NODE_OS_NAME));
+        registration.setEnvironment(ST_NODE_OS_VERSION, getTextValue(envRoot, ST_NODE_OS_VERSION));
+        registration.setEnvironment(ST_NODE_OS_ARCH, getTextValue(envRoot, ST_NODE_OS_ARCH));
+        registration.setEnvironment(ST_NODE_SYSTEM_MODEL, getTextValue(envRoot, ST_NODE_SYSTEM_MODEL));
+        registration.setEnvironment(ST_NODE_SYSTEM_MANUFACTURER, getTextValue(envRoot, ST_NODE_SYSTEM_MANUFACTURER));
+        registration.setEnvironment(ST_NODE_CPU_MANUFACTURER, getTextValue(envRoot, ST_NODE_CPU_MANUFACTURER));
+        registration.setEnvironment(ST_NODE_SERIAL_NUMBER, getTextValue(envRoot, ST_NODE_SERIAL_NUMBER));
+    }
+
+    // add the nodes representing the environment map in the document
+    private static void addEnvironmentNodes(Document document,
+                                            Map<String, String> envMap) {
+        Element root = getRegistrationDataRoot(document);
+        Element env = document.createElement(ST_NODE_ENVIRONMENT);
+        root.appendChild(env);
+        Set<Map.Entry<String, String>> keys = envMap.entrySet();
+        for (Map.Entry<String, String> entry : keys) {
+            addChildElement(document, env, entry.getKey(), entry.getValue());
+        }
+    }
+
+    private static Element getRegistrationDataRoot(Document doc) {
+        Element root = doc.getDocumentElement();
+        if (!root.getNodeName().equals(ST_NODE_REGISTRATION_DATA)) {
+            throw new IllegalArgumentException("Not a " +
+                    ST_NODE_REGISTRATION_DATA +
+                    " node \"" + root.getNodeName() + "\"");
+        }
+        return root;
+    }
+
+    private static Element getSingletonElementFromRoot(Element root, String name) {
+        NodeList children = root.getElementsByTagName(name);
+        int length = (children == null ? 0 : children.getLength());
+        if (length != 1) {
+            throw new IllegalArgumentException("Invalid number of " + name +
+                    " nodes = " + length);
+        }
+        Element e = (Element) children.item(0);
+        if (!e.getNodeName().equals(name)) {
+            throw new IllegalArgumentException("Not a  " + name +
+                    " node \"" + e.getNodeName() + "\"");
+        }
+        return e;
+    }
+
+    // Constructs one ServiceTag instance from a service tag element root
+    private static ServiceTag getServiceTag(Element svcTagElement) {
+        return new ServiceTag(
+            getTextValue(svcTagElement, ST_NODE_INSTANCE_URN),
+            getTextValue(svcTagElement, ST_NODE_PRODUCT_NAME),
+            getTextValue(svcTagElement, ST_NODE_PRODUCT_VERSION),
+            getTextValue(svcTagElement, ST_NODE_PRODUCT_URN),
+            getTextValue(svcTagElement, ST_NODE_PRODUCT_PARENT),
+            getTextValue(svcTagElement, ST_NODE_PRODUCT_PARENT_URN),
+            getTextValue(svcTagElement, ST_NODE_PRODUCT_DEFINED_INST_ID),
+            getTextValue(svcTagElement, ST_NODE_PRODUCT_VENDOR),
+            getTextValue(svcTagElement, ST_NODE_PLATFORM_ARCH),
+            getTextValue(svcTagElement, ST_NODE_CONTAINER),
+            getTextValue(svcTagElement, ST_NODE_SOURCE),
+            Util.getIntValue(getTextValue(svcTagElement, ST_NODE_INSTALLER_UID)),
+            Util.parseTimestamp(getTextValue(svcTagElement, ST_NODE_TIMESTAMP))
+        );
+    }
+
+    private static String getTextValue(Element e, String tagName) {
+        String value = "";
+        NodeList nl = e.getElementsByTagName(tagName);
+        if (nl != null && nl.getLength() > 0) {
+            Element el = (Element) nl.item(0);
+            Node node = el.getFirstChild();
+            if (node != null) {
+                value = node.getNodeValue();
+            }
+        }
+        return value;
+    }
+}

src/share/classes/com/sun/servicetag/SolarisServiceTag.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+import java.io.IOException;
+import java.util.Set;
+
+/**
+ * Utility class to obtain the service tag for the Solaris Operating System.
+ */
+class SolarisServiceTag {
+    private final static String[] SolarisProductURNs = new String[] {
+        "urn:uuid:a7a38948-2bd5-11d6-98ce-9d3ac1c0cfd7", /* Solaris 8 */
+        "urn:uuid:4f82caac-36f3-11d6-866b-85f428ef944e", /* Solaris 9 */
+        "urn:uuid:a19de03b-48bc-11d9-9607-080020a9ed93", /* Solaris 9 sparc */
+        "urn:uuid:4c35c45b-4955-11d9-9607-080020a9ed93", /* Solaris 9 x86 */
+        "urn:uuid:5005588c-36f3-11d6-9cec-fc96f718e113", /* Solaris 10 */
+        "urn:uuid:6df19e63-7ef5-11db-a4bd-080020a9ed93"  /* Solaris 11 */
+    };
+
+    /**
+     * Returns null if not found.
+     *
+     * There is only one service tag for the operating system.
+     */
+    static ServiceTag getServiceTag() throws IOException {
+        if (Registry.isSupported()) {
+            Registry streg = Registry.getSystemRegistry();
+            for (String parentURN : SolarisProductURNs) {
+                Set<ServiceTag> instances = streg.findServiceTags(parentURN);
+                for (ServiceTag st : instances) {
+                    // there should have only one service tag for the OS
+                    return st;
+                }
+            }
+        }
+        return null;
+    }
+}

src/share/classes/com/sun/servicetag/SolarisSystemEnvironment.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+// This class is a copy of the com.sun.scn.servicetags.SolarisSystemEnvironment
+// class from the Sun Connection source.
+//
+// The Service Tags team maintains the latest version of the implementation
+// for system environment data collection.  JDK will include a copy of
+// the most recent released version for a JDK release. We rename
+// the package to com.sun.servicetag so that the Sun Connection
+// product always uses the latest version from the com.sun.scn.servicetags
+// package. JDK and users of the com.sun.servicetag API
+// (e.g. NetBeans and SunStudio) will use the version in JDK.
+//
+// So we keep this class in src/share/classes instead of src/<os>/classes.
+
+import java.io.*;
+
+/**
+ * Solaris implementation of the SystemEnvironment class.
+ */
+class SolarisSystemEnvironment extends SystemEnvironment {
+    SolarisSystemEnvironment() {
+        setHostId(getCommandOutput("/usr/bin/hostid"));
+        setSystemModel(getCommandOutput("/usr/bin/uname", "-i"));
+        setSystemManufacturer(getSolarisSystemManufacturer());
+        setCpuManufacturer(getSolarisCpuManufacturer());
+        setSerialNumber(getSolarisSN());
+    }
+
+    /**
+     * Tries to obtain the cpu manufacturer.
+     * @return The cpu manufacturer (an empty string if not found or an error occurred)
+     */
+    private String getSolarisCpuManufacturer() {
+        // not fully accurate, this could be another manufacturer (fujitsu for example)
+        if ("sparc".equalsIgnoreCase(System.getProperty("os.arch"))) {
+            return "Sun Microsystems, Inc";
+        }
+
+        // if we're here, then we'll try smbios (type 3)
+        return getSmbiosData("3", "Manufacturer: ");
+    }
+
+    /**
+     * Tries to obtain the system manufacturer.
+     * @return The system manufacturer (an empty string if not found or an error occurred)
+     */
+    private String getSolarisSystemManufacturer() {
+        // not fully accurate, this could be another manufacturer (fujitsu for example)
+        if ("sparc".equalsIgnoreCase(System.getProperty("os.arch"))) {
+            return "Sun Microsystems, Inc";
+        }
+
+        // if we're here, then we'll try smbios (type 1)
+        return getSmbiosData("1", "Manufacturer: ");
+    }
+
+    /**
+     * Tries to obtain the serial number.
+     * @return The serial number (empty string if not found or an error occurred)
+     */
+    private String getSolarisSN() {
+        // try to read from the psn file if it exists
+        String tmp = getFileContent("/var/run/psn");
+        if (tmp.length() > 0) {
+            return tmp.trim();
+        }
+
+        // if we're here, then we'll try sneep
+        String tmpSN = getSneepSN();
+        if (tmpSN.length() > 0) {
+            return tmpSN;
+        }
+
+        // if we're here, then we'll try smbios (type 1)
+        tmpSN = getSmbiosData("1", "Serial Number: ");
+        if (tmpSN.length() > 0) {
+            return tmpSN;
+        }
+
+        // if we're here, then we'll try smbios (type 3)
+        tmpSN = getSmbiosData("3", "Serial Number: ");
+        if (tmpSN.length() > 0) {
+            return tmpSN;
+        }
+
+        // give up and return
+        return "";
+    }
+
+    // Sample smbios output segment:
+    // ID    SIZE TYPE
+    // 1     150  SMB_TYPE_SYSTEM (system information)
+    //
+    //   Manufacturer: Sun Microsystems
+    //   Product: Sun Fire X4600
+    //   Version: To Be Filled By O.E.M.
+    //   Serial Number: 00:14:4F:45:0C:2A
+    private String getSmbiosData(String type, String target) {
+        String output = getCommandOutput("/usr/sbin/smbios", "-t", type);
+        for (String s : output.split("\n")) {
+            if (s.contains(target)) {
+                int indx = s.indexOf(target) + target.length();
+                if (indx < s.length()) {
+                    String tmp = s.substring(indx).trim();
+                    String lowerCaseStr = tmp.toLowerCase();
+                    if (!lowerCaseStr.startsWith("not available")
+                            && !lowerCaseStr.startsWith("to be filled by o.e.m")) {
+                        return tmp;
+                    }
+                }
+            }
+        }
+
+        return "";
+    }
+
+    private String getSneepSN() {
+        String basedir = getCommandOutput("pkgparam","SUNWsneep","BASEDIR");
+        File f = new File(basedir + "/bin/sneep");
+        if (f.exists()) {
+            String sneepSN = getCommandOutput(basedir + "/bin/sneep");
+            if (sneepSN.equalsIgnoreCase("unknown")) {
+                return "";
+            } else {
+                return sneepSN;
+            }
+        } else {
+            return "";
+        }
+    }
+
+}

src/share/classes/com/sun/servicetag/SunConnection.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+import java.io.*;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.io.OutputStreamWriter;
+import java.util.Locale;
+import javax.net.ssl.HttpsURLConnection;
+
+/**
+ * Sun Connection Class for Product Registration.
+ *
+ * Registration Web Application Interface
+ * 1) POST the product registry to the output stream of the registration
+ *    relay service.
+ * 2) Open the webapp URL from a browser with the following parameters:
+ *    registry-urn
+ *    product=jdk
+ *    locale=<default-locale>
+ *    version=<version>
+ *
+ * @see https://sn-tools.central.sun.com/twiki/pub/ServiceTags/RegistrationRelayService/
+ *
+ */
+class SunConnection {
+
+    private static String JDK_REGISTRATION_URL = "https://inventory.sun.com/";
+    private static String SANDBOX_TESTING_URL = "https://inventory-beta.sun.com/";
+    private static String REGISTRATION_WEB_PATH = "RegistrationWeb/register";
+
+    // System properties for testing
+    private static String SVCTAG_REGISTER_TESTING = "servicetag.register.testing";
+    private static String SVCTAG_REGISTRATION_URL = "servicetag.registration.url";
+    private static String SVCTAG_CONNECTION_TIMEOUT = "servicetag.connection.timeout";
+
+    private SunConnection() {
+    }
+
+    /**
+     * Returns a URL for JDK registration interfacing with the Sun Connection
+     * registration relay service in this form:
+     *   <registration-url>/<registry_urn>?product=jdk&locale=<locale>
+     *
+     * The <registration-url> can be overridden by an environment
+     * variable or a system property.
+     *
+     * 1) "servicetag.register.testing" system property to switch to the
+     *    Sun Connection registration sandbox testing.
+     * 2) "servicetag.registration.url" system property to override
+     *    the URL
+     * 3) Default production URL
+     *
+     */
+    static URL getRegistrationURL(String registrationURN, Locale locale, String version) {
+        String url = System.getProperty(SVCTAG_REGISTRATION_URL);
+        if (url == null) {
+            if (System.getProperty(SVCTAG_REGISTER_TESTING) != null) {
+                url = SANDBOX_TESTING_URL;
+            } else {
+                url = JDK_REGISTRATION_URL;
+            }
+        }
+        url += REGISTRATION_WEB_PATH;
+
+        // trim whitespaces
+        url = url.trim();
+        if (url.length() == 0) {
+            throw new InternalError("Empty registration url set");
+        }
+
+        // Add the registry_urn in the URL's query
+        String registerURL = rewriteURL(url, registrationURN, locale, version);
+        try {
+            return new URL(registerURL);
+        } catch (MalformedURLException ex) {
+            // should never reach here
+            InternalError x =
+                new InternalError(ex.getMessage());
+            x.initCause(ex);
+            throw x;
+        }
+    }
+
+    private static String rewriteURL(String url, String registryURN, Locale locale, String version) {
+        StringBuilder sb = new StringBuilder(url.trim());
+        int len = sb.length();
+        if (sb.charAt(len-1) != '/') {
+            sb.append('/');
+        }
+        sb.append(registryURN);
+        sb.append("?");
+        sb.append("product=jdk");
+        sb.append("&");
+        sb.append("locale=").append(locale.toString());
+        sb.append("&");
+        sb.append("version=").append(version);
+        return sb.toString();
+    }
+
+    /**
+     * Registers all products in the given product registry.  If it fails
+     * to post the service tag registry, open the browser with the offline
+     * registration page.
+     *
+     * @param regData registration data to be posted to the Sun Connection
+     *             for registration.
+     * @param locale Locale
+     * @param version JDK version
+     *
+     * @throws IOException if I/O error occurs in this operation
+     */
+    public static void register(RegistrationData regData,
+                                Locale locale,
+                                String version) throws IOException {
+        // Gets the URL for SunConnection registration relay service
+        URL url = getRegistrationURL(regData.getRegistrationURN(),
+                                     locale,
+                                     version);
+
+        // Post the Product Registry to Sun Connection
+        boolean succeed = postRegistrationData(url, regData);
+        if (succeed) {
+            // service tags posted successfully
+            // now prompt for registration
+            openBrowser(url);
+        } else {
+            // open browser with the offline registration page
+            openOfflineRegisterPage();
+        }
+    }
+
+    /**
+     * Opens a browser for JDK product registration.
+     * @param url Registration Webapp URL
+     */
+    private static void openBrowser(URL url) throws IOException {
+        if (!BrowserSupport.isSupported()) {
+            if (Util.isVerbose()) {
+                System.out.println("Browser is not supported");
+            }
+            return;
+        }
+
+        try {
+            BrowserSupport.browse(url.toURI());
+        } catch (URISyntaxException ex) {
+            InternalError x = new InternalError("Error in registering: " + ex.getMessage());
+            x.initCause(ex);
+            throw x;
+        } catch (IllegalArgumentException ex) {
+            if (Util.isVerbose()) {
+                ex.printStackTrace();
+            }
+        } catch (UnsupportedOperationException ex) {
+            // ignore if not supported
+            if (Util.isVerbose()) {
+                ex.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * POST service tag registry to Sun Connection
+     * @param loc the URL of the webapp to handle the POST request
+     * @param streg the Service Tag registry
+     * @return true if posting succeeds; otherwise, false.
+     */
+    private static boolean postRegistrationData(URL url,
+                                                RegistrationData registration) {
+        try {
+            HttpsURLConnection con = (HttpsURLConnection) url.openConnection();
+            con.setDoInput(true);
+            con.setDoOutput(true);
+            con.setUseCaches(false);
+            con.setAllowUserInteraction(false);
+
+            // default 10 seconds timeout
+            String timeout = System.getProperty(SVCTAG_CONNECTION_TIMEOUT, "10");
+            con.setConnectTimeout(Util.getIntValue(timeout) * 1000);
+
+            if (Util.isVerbose()) {
+                System.out.println("Connecting to post registration data at " + url);
+            }
+
+            con.setRequestMethod("POST");
+            con.setRequestProperty("Content-Type", "text/xml;charset=\"utf-8\"");
+            con.connect();
+
+            OutputStream out = con.getOutputStream();
+            registration.storeToXML(out);
+            out.flush();
+            out.close();
+
+            int returnCode = con.getResponseCode();
+            if (Util.isVerbose()) {
+                System.out.println("POST return status = " + returnCode);
+                printReturnData(con, returnCode);
+            }
+            return (returnCode == HttpURLConnection.HTTP_OK);
+        } catch (MalformedURLException me) {
+            // should never reach here
+            InternalError x = new InternalError("Error in registering: " + me.getMessage());
+            x.initCause(me);
+            throw x;
+        } catch (Exception ioe) {
+            // SocketTimeoutException, IOException or UnknownHostException
+            if (Util.isVerbose()) {
+                ioe.printStackTrace();
+            }
+            return false;
+        }
+    }
+
+    /**
+     * Opens the offline registratioin page in the browser.
+     *
+     */
+    private static void openOfflineRegisterPage()
+            throws IOException {
+        if (!BrowserSupport.isSupported()) {
+            if (Util.isVerbose()) {
+                System.out.println("Browser is not supported");
+            }
+            return;
+        }
+
+        File registerPage = Installer.getRegistrationHtmlPage();
+        try {
+            BrowserSupport.browse(registerPage.toURI());
+        } catch (FileNotFoundException ex) {
+            // should never reach here
+            InternalError x =
+                new InternalError("Error in launching " + registerPage + ": " + ex.getMessage());
+            x.initCause(ex);
+            throw x;
+        } catch (IllegalArgumentException ex) {
+            if (Util.isVerbose()) {
+                ex.printStackTrace();
+            }
+        } catch (UnsupportedOperationException ex) {
+            // ignore if not supported
+            if (Util.isVerbose()) {
+                ex.printStackTrace();
+            }
+        }
+    }
+
+    private static void printReturnData(HttpURLConnection con, int returnCode)
+            throws IOException {
+        BufferedReader reader = null;
+        try {
+            if (returnCode < 400) {
+                reader = new BufferedReader(
+                             new InputStreamReader(con.getInputStream()));
+            } else {
+                reader = new BufferedReader(
+                             new InputStreamReader(con.getErrorStream()));
+            }
+            StringBuilder sb = new StringBuilder();
+            String line;
+            while ((line = reader.readLine()) != null) {
+                sb.append(line).append("\n");
+            }
+            System.out.println("Response is : ");
+            System.out.println(sb.toString());
+        } finally {
+            if (reader != null) {
+                reader.close();
+            }
+        }
+    }
+}

src/share/classes/com/sun/servicetag/SystemEnvironment.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+// This class is a copy of the com.sun.scn.servicetags.SystemEnvironment
+// class from the Sun Connection source.
+//
+// The Service Tags team maintains the latest version of the implementation
+// for system environment data collection.  JDK will include a copy of
+// the most recent released version for a JDK release. We rename
+// the package to com.sun.servicetag so that the Sun Connection
+// product always uses the latest version from the com.sun.scn.servicetags
+// package. JDK and users of the com.sun.servicetag API
+// (e.g. NetBeans and SunStudio) will use the version in JDK.
+
+import java.io.*;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+/**
+ * SystemEnvironment class collects the environment data with the
+ * best effort from the underlying platform.
+ */
+public class SystemEnvironment {
+    private String hostname;
+    private String hostId;
+    private String osName;
+    private String osVersion;
+    private String osArchitecture;
+    private String systemModel;
+    private String systemManufacturer;
+    private String cpuManufacturer;
+    private String serialNumber;
+    private static SystemEnvironment sysEnv = null;
+
+    public static synchronized SystemEnvironment getSystemEnvironment() {
+        if (sysEnv == null) {
+            String os = System.getProperty("os.name");
+            if (os.equals("SunOS")) {
+                sysEnv = new SolarisSystemEnvironment();
+            } else if (os.equals("Linux")) {
+                sysEnv = new LinuxSystemEnvironment();
+            } else if (os.startsWith("Windows")) {
+                sysEnv = new WindowsSystemEnvironment();
+            } else {
+                sysEnv = new SystemEnvironment();
+            }
+        }
+        return sysEnv;
+    }
+
+    // package-private
+    SystemEnvironment() {
+        try {
+            this.hostname = InetAddress.getLocalHost().getHostName();
+        } catch (UnknownHostException ex) {
+            this.hostname = "Unknown host";
+        }
+        this.hostId = "";
+        this.osName = System.getProperty("os.name");
+        this.osVersion = System.getProperty("os.version");
+        this.osArchitecture = System.getProperty("os.arch");
+        this.systemModel = "";
+        this.systemManufacturer = "";
+        this.cpuManufacturer = "";
+        this.serialNumber = "";
+    }
+
+
+    /**
+     * Sets the hostname.
+     * @param hostname The hostname to set.
+     */
+    public void setHostname(String hostname) {
+        this.hostname = hostname;
+    }
+
+    /**
+     * Sets the OS name.
+     * @param osName The osName to set.
+     */
+    public void setOsName(String osName) {
+        this.osName = osName;
+    }
+
+    /**
+     * Sets the OS version.
+     * @param osVersion The osVersion to set.
+     */
+    public void setOsVersion(String osVersion) {
+        this.osVersion = osVersion;
+    }
+
+    /**
+     * Sets the OS architecture.
+     * @param osArchitecture The osArchitecture to set.
+     */
+    public void setOsArchitecture(String osArchitecture) {
+        this.osArchitecture = osArchitecture;
+    }
+
+    /**
+     * Sets the system model.
+     * @param systemModel The systemModel to set.
+     */
+    public void setSystemModel(String systemModel) {
+        this.systemModel = systemModel;
+    }
+
+    /**
+     * Sets the system manufacturer.
+     * @param systemManufacturer The systemManufacturer to set.
+     */
+    public void setSystemManufacturer(String systemManufacturer) {
+        this.systemManufacturer = systemManufacturer;
+    }
+
+    /**
+     * Sets the cpu manufacturer.
+     * @param cpuManufacturer The cpuManufacturer to set.
+     */
+    public void setCpuManufacturer(String cpuManufacturer) {
+        this.cpuManufacturer = cpuManufacturer;
+    }
+
+    /**
+     * Sets the serial number.
+     * @param serialNumber The serialNumber to set.
+     */
+    public void setSerialNumber(String serialNumber) {
+        this.serialNumber = serialNumber;
+    }
+
+    /**
+     * Sets the hostid.  Truncates to a max length of 16 chars.
+     * @param hostId The hostid to set.
+     */
+    public void setHostId(String hostId) {
+        if (hostId == null || hostId.equals("null")) {
+            hostId = "";
+        }
+        if (hostId.length() > 16) {
+            hostId = hostId.substring(0,16);
+        }
+        this.hostId = hostId;
+    }
+
+    /**
+     * Returns the hostname.
+     * @return The hostname.
+     */
+    public String getHostname() {
+        return hostname;
+    }
+
+    /**
+     * Returns the osName.
+     * @return The osName.
+     */
+    public String getOsName() {
+        return osName;
+    }
+
+    /**
+     * Returns the osVersion.
+     * @return The osVersion.
+     */
+    public String getOsVersion() {
+        return osVersion;
+    }
+
+    /**
+     * Returns the osArchitecture.
+     * @return The osArchitecture.
+     */
+    public String getOsArchitecture() {
+        return osArchitecture;
+    }
+
+    /**
+     * Returns the systemModel.
+     * @return The systemModel.
+     */
+    public String getSystemModel() {
+        return systemModel;
+    }
+
+    /**
+     * Returns the systemManufacturer.
+     * @return The systemManufacturer.
+     */
+    public String getSystemManufacturer() {
+        return systemManufacturer;
+    }
+
+    /**
+     * Returns the serialNumber.
+     * @return The serialNumber.
+     */
+    public String getSerialNumber() {
+        return serialNumber;
+    }
+
+    /**
+     * Returns the hostId.
+     * @return The hostId.
+     */
+    public String getHostId() {
+        return hostId;
+    }
+
+    /**
+     * Returns the cpuManufacturer.
+     * @return The cpuManufacturer.
+     */
+    public String getCpuManufacturer() {
+        return cpuManufacturer;
+    }
+
+    protected String getCommandOutput(String... command) {
+        StringBuilder sb = new StringBuilder();
+        BufferedReader br = null;
+        Process p = null;
+        try {
+            ProcessBuilder pb = new ProcessBuilder(command);
+            p = pb.start();
+            p.waitFor();
+
+            if (p.exitValue() == 0) {
+                br = new BufferedReader(new InputStreamReader(p.getInputStream()));
+                String line = null;
+                while ((line = br.readLine()) != null) {
+                    line = line.trim();
+                    if (line.length() > 0) {
+                        if (sb.length() > 0) {
+                            sb.append("\n");
+                        }
+                        sb.append(line);
+                    }
+                }
+            }
+            return sb.toString();
+        } catch (InterruptedException ie) {
+            // in case the command hangs
+            if (p != null) {
+                p.destroy();
+            }
+            return "";
+        } catch (Exception e) {
+            // ignore exception
+            return "";
+        } finally {
+            if (p != null) {
+                try {
+                    p.getErrorStream().close();
+                } catch (IOException e) {
+                    // ignore
+                }
+                try {
+                    p.getInputStream().close();
+                } catch (IOException e) {
+                    // ignore
+                }
+                try {
+                    p.getOutputStream().close();
+                } catch (IOException e) {
+                    // ignore
+                }
+                p = null;
+            }
+            if (br != null) {
+                try {
+                    br.close();
+                } catch (IOException e) {
+                    // ignore
+                }
+            }
+        }
+    }
+
+    protected String getFileContent(String filename) {
+        File f = new File(filename);
+        if (!f.exists()) {
+            return "";
+        }
+
+        StringBuilder sb = new StringBuilder();
+        BufferedReader br = null;
+        try {
+            br = new BufferedReader(new FileReader(f));
+            String line = null;
+            while ((line = br.readLine()) != null) {
+                line = line.trim();
+                if (line.length() > 0) {
+                    if (sb.length() > 0) {
+                        sb.append("\n");
+                    }
+                    sb.append(line);
+                }
+            }
+            return sb.toString();
+        } catch (Exception e) {
+            // ignore exception
+            return "";
+        } finally {
+            if (br != null) {
+                try {
+                    br.close();
+                } catch (IOException e) {
+                    // ignore
+                }
+            }
+        }
+    }
+}

src/share/classes/com/sun/servicetag/UnauthorizedAccessException.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+/**
+ * Thrown if the user is not authorized to
+ * {@link Registry#updateServiceTag update} or
+ * {@link Registry#removeServiceTag remove}
+ * a service tag from a {@link Registry}.
+ */
+public class UnauthorizedAccessException extends RuntimeException {
+
+    /**
+     * Constructs an <code>UnauthorizedAccessException</code> object
+     * without detail message.
+     */
+    public UnauthorizedAccessException() {
+    }
+
+
+    /**
+     * Constructs an <code>UnauthorizedAccessException</code> object
+     * with the specified detail message.
+     *
+     * @param msg the detail message.
+     */
+    public UnauthorizedAccessException(String msg) {
+        super(msg);
+    }
+}

src/share/classes/com/sun/servicetag/Util.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+import java.io.*;
+import java.util.Date;
+import java.text.SimpleDateFormat;
+import java.text.ParseException;
+import java.util.TimeZone;
+import java.util.UUID;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+// Utility class for com.sun.servicetag package
+class Util {
+    private static boolean verbose = (System.getProperty("servicetag.verbose") != null);
+    private static String jrepath = null;
+    private static final String REGKEY_TAIL =
+        "microsoft\\windows\\currentversion\\app paths\\stclient.exe";
+    private static final String STCLIENT_TAIL =  "sun\\servicetag\\stclient.exe";
+    private static final String WIN32_STCLIENT =
+        "c:\\Program Files (x86)\\" + STCLIENT_TAIL;
+
+    // for debugging and tracing
+    static boolean isVerbose() {
+        return verbose;
+    }
+
+    /**
+     * Gets the pathname of JRE in the running platform
+     * This can be a JDK or JRE.
+     */
+    static synchronized String getJrePath() {
+        if (jrepath == null) {
+            // Determine the JRE path by checking the existence of
+            // <HOME>/jre/lib and <HOME>/lib.
+            String javaHome = System.getProperty("java.home");
+            jrepath = javaHome + File.separator + "jre";
+            File f = new File(jrepath, "lib");
+            if (!f.exists()) {
+                // java.home usually points to the JRE path
+                jrepath = javaHome;
+            }
+        }
+        return jrepath;
+    }
+
+    /**
+     * Tests if the running platform is a JDK.
+     */
+    static boolean isJdk() {
+        // <HOME>/jre exists which implies it's a JDK
+        return getJrePath().endsWith(File.separator + "jre");
+    }
+
+    /**
+     * Generates the URN string of "urn:st" namespace
+     */
+    static String generateURN() {
+        return "urn:st:" + UUID.randomUUID().toString();
+    }
+
+    static int getIntValue(String value) {
+        try {
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("\"" + value + "\"" +
+                " expected to be an integer");
+        }
+    }
+
+    /**
+     * Formats the Date into a timestamp string in YYYY-MM-dd HH:mm:ss GMT.
+     * @param timestamp Date
+     * @return a string representation of the timestamp
+     *         in the YYYY-MM-dd HH:mm:ss GMT format.
+     */
+    static String formatTimestamp(Date timestamp) {
+        if (timestamp == null) {
+            return "[No timestamp]";
+        }
+        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss z");
+        df.setTimeZone(TimeZone.getTimeZone("GMT"));
+        return df.format(timestamp);
+    }
+
+    /**
+     * Parses a timestamp string in YYYY-MM-dd HH:mm:ss GMT format.
+     * @param timestamp Timestamp in the YYYY-MM-dd HH:mm:ss GMT format.
+     * @return Date
+     */
+    static Date parseTimestamp(String timestamp) {
+        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss z");
+        df.setTimeZone(TimeZone.getTimeZone("GMT"));
+        try {
+            return df.parse(timestamp);
+        } catch (ParseException e) {
+            // should not reach here
+            e.printStackTrace();
+            return new Date();
+        }
+    }
+
+    static String commandOutput(Process p) throws IOException {
+        Reader r = null;
+        Reader err = null;
+        try {
+            r = new InputStreamReader(p.getInputStream());
+            err = new InputStreamReader(p.getErrorStream());
+            String output = commandOutput(r);
+            String errorMsg = commandOutput(err);
+            p.waitFor();
+            return output + errorMsg.trim();
+        } catch (InterruptedException e) {
+            if (isVerbose()) {
+                e.printStackTrace();
+            }
+            return e.getMessage();
+        } finally {
+            if (r != null) {
+                r.close();
+            }
+            if (err != null) {
+                err.close();
+            }
+        }
+    }
+
+    static String commandOutput(Reader r) throws IOException {
+        StringBuilder sb = new StringBuilder();
+        int c;
+        while ((c = r.read()) > 0) {
+            if (c != '\r') {
+                sb.append((char) c);
+            }
+        }
+        return sb.toString();
+    }
+
+    static int getJdkVersion() {
+        parseVersion();
+        return jdkVersion;
+    }
+
+    static int getUpdateVersion() {
+        parseVersion();
+        return jdkUpdate;
+    }
+
+    private static int jdkVersion = 0;
+    private static int jdkUpdate = 0;
+    private static synchronized void parseVersion() {
+        if (jdkVersion > 0) {
+            return;
+        }
+
+        // parse java.runtime.version
+        // valid format of the version string is:
+        // n.n.n[_uu[c]][-<identifer>]-bxx
+        String cs = System.getProperty("java.runtime.version");
+        if (cs.length() >= 5 &&
+            Character.isDigit(cs.charAt(0)) && cs.charAt(1) == '.' &&
+            Character.isDigit(cs.charAt(2)) && cs.charAt(3) == '.' &&
+            Character.isDigit(cs.charAt(4))) {
+            jdkVersion = Character.digit(cs.charAt(2), 10);
+            cs = cs.substring(5, cs.length());
+            if (cs.charAt(0) == '_' && cs.length() >= 3 &&
+                Character.isDigit(cs.charAt(1)) &&
+                Character.isDigit(cs.charAt(2))) {
+                int nextChar = 3;
+                try {
+                    String uu = cs.substring(1, 3);
+                    jdkUpdate = Integer.valueOf(uu).intValue();
+                } catch (NumberFormatException e) {
+                    // not conforming to the naming convention
+                    return;
+                }
+            }
+        } else {
+            throw new InternalError("Invalid java.runtime.version" + cs);
+        }
+    }
+
+    /**
+     * Returns this java string as a null-terminated byte array
+     */
+    private static byte[] stringToByteArray(String str) {
+        return (str + "\u0000").getBytes();
+    }
+
+    /**
+     * Converts a null-terminated byte array to java string
+     */
+    private static String byteArrayToString(byte[] array) {
+        return new String(array, 0, array.length -1);
+    }
+
+    /**
+     * Gets the stclient path using a well known location from
+     * the Windows platform Registry, ensuring the path returned
+     * by the registry is really the one we are looking for,
+     * otherwise it will return null.
+     */
+    private static File getWindowsStClientFile(boolean wow64) {
+        File out = null;
+        String regKey = (wow64 == true)
+            ? "software\\Wow6432Node\\" + REGKEY_TAIL
+            : "software\\" + REGKEY_TAIL;
+        String keyName = "" ; // use the default  key
+        String path = getRegistryKey(regKey, keyName);
+        if (path != null
+                && (new File(path)).exists()
+                && path.toLowerCase().endsWith(STCLIENT_TAIL.toLowerCase())) {
+            out = new File(path);
+        }
+        if (isVerbose()) {
+            System.out.println("stclient=" + out);
+        }
+        return out;
+    }
+
+    /**
+     * Finds a stclient in 32 and 64 bit environments, first by querying
+     * the windows registry, if not then get the well known paths for
+     * 64bit see http://support.microsoft.com/kb/896459
+     */
+
+    static File getWindowsStClientFile() {
+        File stclient = null;
+        if (System.getProperty("os.arch").equals("x86")) {
+            // try to get the default entry
+            stclient = getWindowsStClientFile(false);
+            if (stclient != null) {
+                return stclient;
+            }
+        } else { // we are on 64-bit system
+            // try the wow64 area
+            stclient = getWindowsStClientFile(true);
+            if (stclient != null) {
+                return stclient;
+            }
+            // try the default hard coded path, maybe wow64 registry is missing
+            stclient = new File(WIN32_STCLIENT);
+            if (stclient.canExecute()) {
+                if (isVerbose()) {
+                    System.out.println("stclient(default)=" + stclient);
+                }
+                return stclient;
+            }
+        }
+        if (isVerbose()) {
+            System.out.println("stclient not found");
+        }
+        return null;
+    }
+
+    /**
+     * This uses reflection to access a private java windows registry
+     * interface, any changes to that Class must be appropriately adjusted.
+     * Returns a null if unsuccessful.
+     */
+    private static String getRegistryKey(String regKey, String keyName) {
+        String out = null;
+        try {
+            Class<?> clazz = Class.forName("java.util.prefs.WindowsPreferences");
+
+            // Get the registry methods
+            Method winRegOpenKeyM = clazz.getDeclaredMethod("WindowsRegOpenKey",
+                    int.class, byte[].class, int.class);
+            winRegOpenKeyM.setAccessible(true);
+
+            Method winRegCloseKeyM = clazz.getDeclaredMethod("WindowsRegCloseKey",
+                    int.class);
+            winRegCloseKeyM.setAccessible(true);
+
+            Method winRegQueryValueM = clazz.getDeclaredMethod("WindowsRegQueryValueEx",
+                    int.class, byte[].class);
+            winRegQueryValueM.setAccessible(true);
+
+            // Get all the constants we need
+            int HKLM = getValueFromStaticField("HKEY_LOCAL_MACHINE", clazz);
+            int KEY_READ = getValueFromStaticField("KEY_READ", clazz);
+            int ERROR_CODE = getValueFromStaticField("ERROR_CODE", clazz);
+            int NATIVE_HANDLE = getValueFromStaticField("NATIVE_HANDLE", clazz);
+            int ERROR_SUCCESS = getValueFromStaticField("ERROR_SUCCESS", clazz);
+
+            // Convert keys
+            byte[] reg = stringToByteArray(regKey);
+            byte[] key = stringToByteArray(keyName);
+
+            // Open the registry
+            int[] result = (int[]) winRegOpenKeyM.invoke(null, HKLM, reg, KEY_READ);
+
+            if (result[ERROR_CODE] == ERROR_SUCCESS) {
+                byte[] stvalue = (byte[]) winRegQueryValueM.invoke(null,
+                    result[NATIVE_HANDLE], key);
+                out = byteArrayToString(stvalue);
+                winRegCloseKeyM.invoke(null, result[NATIVE_HANDLE]);
+            }
+        } catch (Exception ex) {
+            if (isVerbose()) {
+                ex.printStackTrace();
+            }
+        }
+        return out;
+    }
+
+    private static int getValueFromStaticField(String fldName, Class<?> klass) throws Exception {
+        Field f = klass.getDeclaredField(fldName);
+        f.setAccessible(true);
+        return f.getInt(null);
+    }
+}

src/share/classes/com/sun/servicetag/WindowsSystemEnvironment.java

+/*
+ * Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.servicetag;
+
+// This class is a copy of the com.sun.scn.servicetags.WindowsSystemEnvironment
+// class from the Sun Connection source.
+//
+// The Service Tags team maintains the latest version of the implementation
+// for system environment data collection.  JDK will include a copy of
+// the most recent released version for a JDK release. We rename
+// the package to com.sun.servicetag so that the Sun Connection
+// product always uses the latest version from the com.sun.scn.servicetags
+// package. JDK and users of the com.sun.servicetag API
+// (e.g. NetBeans and SunStudio) will use the version in JDK.
+//
+// So we keep this class in src/share/classes instead of src/<os>/classes.
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Windows implementation of the SystemEnvironment class.
+ */
+class WindowsSystemEnvironment extends SystemEnvironment {
+    WindowsSystemEnvironment() {
+        super();
+
+        // run a call to make sure things are initialized
+        // ignore the first call result as the system may
+        // give inconsistent data on the first invocation ever
+        getWmicResult("computersystem", "get", "model");
+
+        setSystemModel(getWmicResult("computersystem", "get", "model"));
+        setSystemManufacturer(getWmicResult("computersystem", "get", "manufacturer"));
+        setSerialNumber(getWmicResult("bios", "get", "serialnumber"));
+
+        String cpuMfr = getWmicResult("cpu", "get", "manufacturer");
+        // this isn't as good an option, but if we couldn't get anything
+        // from wmic, try the processor_identifier
+        if (cpuMfr.length() == 0) {
+            String procId = System.getenv("processor_identifer");
+            if (procId != null) {
+                String[] s = procId.split(",");
+                cpuMfr = s[s.length - 1].trim();
+            }
+        }
+        setCpuManufacturer(cpuMfr);
+
+        // try to remove the temp file that gets created from running wmic cmds
+        try {
+            // look in the current working directory
+            File f = new File("TempWmicBatchFile.bat");
+            if (f.exists()) {
+                f.delete();
+            }
+        } catch (Exception e) {
+            // ignore the exception
+        }
+    }
+
+
+    /**
+     * This method invokes wmic outside of the normal environment
+     * collection routines.
+     *
+     * An initial call to wmic can be costly in terms of time.
+     *
+     * <code>
+     * Details of why the first call is costly can be found at:
+     *
+     * http://support.microsoft.com/kb/290216/en-us
+     *
+     * "When you run the Wmic.exe utility for the first time, the utility
+     * compiles its .mof files into the repository. To save time during
+     * Windows installation, this operation takes place as necessary."
+     * </code>
+     */
+    private String getWmicResult(String alias, String verb, String property) {
+        String res = "";
+        BufferedReader in = null;
+        try {
+            ProcessBuilder pb = new ProcessBuilder("cmd", "/C", "WMIC", alias, verb, property);
+            Process p = pb.start();
+            // need this for executing windows commands (at least
+            // needed for executing wmic command)
+            BufferedWriter bw = new BufferedWriter(
+                new OutputStreamWriter(p.getOutputStream()));
+            bw.write(13);
+            bw.flush();
+            bw.close();
+
+            p.waitFor();
+            if (p.exitValue() == 0) {
+                in = new BufferedReader(new InputStreamReader(p.getInputStream()));
+                String line = null;
+                while ((line = in.readLine()) != null) {
+                    line = line.trim();
+                    if (line.length() == 0) {
+                        continue;
+                    }
+                    res = line;
+                }
+                // return the *last* line read
+                return res;
+            }
+
+        } catch (Exception e) {
+            // ignore the exception
+        } finally {
+            if (in != null) {
+                try {
+                    in.close();
+                } catch (IOException e) {
+                    // ignore
+                }
+            }
+        }
+        return res.trim();
+    }
+}

src/share/classes/com/sun/servicetag/package.html

+CTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<html>
+<head>
+<!--
+Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+particular file as subject to the "Classpath" exception as provided
+by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+CA 95054 USA or visit www.sun.com if you need additional information or
+have any questions.
+
+-->
+
+</head>
+<body bgcolor="white">
+
+This package contains classes that allow the creation
+and manipulation of service tags.
+This com.sun.servicetag package is intended for
+<b>Sun internal use</b> only.
+<p>
+<dl>
+<dt><b>Service Tag</b></dt>
+<dd>A service tag is an XML-based data structure that contains identifying
+information about an instance of a product or component on a system.
+</dd>
+</dl>
+<dl>
+<dt><b>Service Tag Registry</b></dt>
+<dd>A service tag registry is a XML-based registry that contains
+the service tags of all the tagged components on a system.  The
+service tag registry is present on systems that have the
+Service Tags software installed.
+</dd>
+</dl>
+<dl>
+<dt><b>Registration Data</b></dt>
+<dd>A registration data is a container of one or more
+service tags that identify the
+components for product registration and will be used to interface
+with the Sun Connection registration services.
+</dd>
+</dl>
+
+This package contains the methods to create service tags, set up the
+registration data for product registration, add service tags to and
+remove them from the system service tag registry.
+<p>
+All methods defined in this package will throw {@code NullPointerException}
+if {@code null} is passed in any input parameter unless it is stated otherwise.
+In addition, they are multi-thread safe.
+</body>
+</html>
+
+

src/share/classes/com/sun/servicetag/resources/Putback-Notes.txt

+README for auto-generating of the offline registration page.
+
+1. register.html is defined by the xDesign team.
+
+2. Before putback in the workspace, we need to modify the 
+   register.html to contain the following:
+
+   (a) replace the pathname of the jdk_header.png image to
+       <img src="@@JDK_HEADER_PNG@@" ....>
+
+   (b) replace the product name from:
+           Java Development Kit Version 6 Update 5 (e.g.)
+       to:
+           Java Development Kit @@JDK_VERSION@@ 
+
+   (c) replace the form action for the "Register My JDK" button with:
+
+       <form name="form1" method="post" action="@@REGISTRATION_URL@@" enctype="text/xml">
+
+   (d) Add this input in the form for posting data after 
+       the <form name=....> line:
+ 
+       <input type="hidden" name="servicetag_payload" value="@@REGISTRATION_PAYLOAD@@">
+
+3. The jdk_header.png is located under <JRE>/lib/servicetag directory.

src/share/classes/com/sun/servicetag/resources/javase_5_swordfish.properties

+# Copyright 2008 Sun Microsystems, Inc.  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.  Sun designates this
+# particular file as subject to the "Classpath" exception as provided
+# by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+# CA 95054 USA or visit www.sun.com if you need additional information or
+# have any questions.
+
+servicetag.jdk.urn     = urn:uuid:d5bed446-05f2-42ed-ba0a-153105a52413
+servicetag.jdk.name    = J2SE 5.0 Development Kit
+servicetag.jre.urn     = urn:uuid:5c6686aa-fd05-46a6-ba3e-700e2d5f7043
+servicetag.jre.name    = J2SE 5.0 Runtime Environment
+servicetag.parent.urn  = urn:uuid:f3c20172-557a-11d7-93d0-d6a41ea318df
+servicetag.parent.name = Java 2 Platform, Standard Edition 5.0

test/com/sun/servicetag/environ.properties

+hostname=ko
+hostId=83abc1ab
+osName=SunOS
+osVersion=5.10
+osArchitecture=sparc
+systemModel=Sun-Fire-V440
+systemManufacturer=Sun Microsystems
+cpuManufacturer=Sun Microsystems
+serialNumber=BEL078932