obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 875 insertions, 0 deletions

diff --git a/libjava/classpath/gnu/javax/print/ipp/IppRequest.java b/libjava/classpath/gnu/javax/print/ipp/IppRequest.java
new file mode 100644
index 000000000..ae1f2c409
--- /dev/null
+++ b/libjava/classpath/gnu/javax/print/ipp/IppRequest.java
@@ -0,0 +1,875 @@
+/* IppRequest.java --
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+ This file is part of GNU Classpath.
+
+ GNU Classpath is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ GNU Classpath 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 for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNU Classpath; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library.  Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module.  An independent module is a module which is not derived from
+ or based on this library.  If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so.  If you do not wish to do so, delete this
+ exception statement from your version. */
+
+
+package gnu.javax.print.ipp;
+
+import gnu.classpath.debug.Component;
+import gnu.classpath.debug.SystemLogger;
+import gnu.javax.print.ipp.attribute.CharsetSyntax;
+import gnu.javax.print.ipp.attribute.NaturalLanguageSyntax;
+import gnu.javax.print.ipp.attribute.RequestedAttributes;
+import gnu.javax.print.ipp.attribute.job.AttributesCharset;
+import gnu.javax.print.ipp.attribute.job.AttributesNaturalLanguage;
+import gnu.javax.print.ipp.attribute.job.JobId;
+import gnu.javax.print.ipp.attribute.job.JobUri;
+import gnu.javax.print.ipp.attribute.printer.DocumentFormat;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URL;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.List;
+import java.util.logging.Logger;
+
+import javax.print.attribute.Attribute;
+import javax.print.attribute.AttributeSet;
+import javax.print.attribute.DateTimeSyntax;
+import javax.print.attribute.EnumSyntax;
+import javax.print.attribute.HashAttributeSet;
+import javax.print.attribute.IntegerSyntax;
+import javax.print.attribute.ResolutionSyntax;
+import javax.print.attribute.SetOfIntegerSyntax;
+import javax.print.attribute.TextSyntax;
+import javax.print.attribute.URISyntax;
+import javax.print.attribute.standard.Compression;
+import javax.print.attribute.standard.Copies;
+import javax.print.attribute.standard.DocumentName;
+import javax.print.attribute.standard.Fidelity;
+import javax.print.attribute.standard.Finishings;
+import javax.print.attribute.standard.JobHoldUntil;
+import javax.print.attribute.standard.JobImpressions;
+import javax.print.attribute.standard.JobKOctets;
+import javax.print.attribute.standard.JobMediaSheets;
+import javax.print.attribute.standard.JobName;
+import javax.print.attribute.standard.JobOriginatingUserName;
+import javax.print.attribute.standard.JobPriority;
+import javax.print.attribute.standard.JobSheets;
+import javax.print.attribute.standard.Media;
+import javax.print.attribute.standard.MultipleDocumentHandling;
+import javax.print.attribute.standard.NumberUp;
+import javax.print.attribute.standard.OrientationRequested;
+import javax.print.attribute.standard.PageRanges;
+import javax.print.attribute.standard.PrintQuality;
+import javax.print.attribute.standard.PrinterResolution;
+import javax.print.attribute.standard.PrinterURI;
+import javax.print.attribute.standard.RequestingUserName;
+import javax.print.attribute.standard.SheetCollate;
+import javax.print.attribute.standard.Sides;
+
+/**
+ * <code>IppRequest</code> models a request to an IPP compatible
+ * server as described in RFC 2910 - IPP/1.1: Encoding and Transport.
+ * <p>
+ * The byte stream is structured as follows (for an official description
+ * please have a look at the RFC document mentioned above):
+ * <ul>
+ * <li>version-number          - 2 bytes - required</li>
+ * <li>operation-id            - 2 bytes - required</li>
+ * <li>request-id              - 4 bytes - required</li>
+ * <li>attribute-group         - n bytes - 0 or more</li>
+ * <li>end-of-attributes-tag   - 1 byte  - required</li>
+ * <li>data                    - q bytes - optional</li>
+ * </ul>
+ * </p>
+ *
+ * @author Wolfgang Baer (WBaer@gmx.de)
+ */
+public class IppRequest
+{
+
+  /**
+   * The printer-poll timeout.
+   */
+  private static final int timeout = 1000;
+
+  /**
+   * Helper class used to write the attributes of a request
+   * into the supplied data output stream in the correct way.
+   *
+   * @author Wolfgang Baer (WBaer@gmx.de)
+   */
+  class RequestWriter
+  {
+    private DataOutputStream out;
+
+    /**
+     * Creates a RequestWriter.
+     *
+     * @param stream the stream to write to.
+     */
+    RequestWriter(DataOutputStream stream)
+    {
+      out = stream;
+    }
+
+    /**
+     * Writes an attribute in IntegerSyntax into the stream.
+     * @param attribute the attribute
+     * @throws IOException if thrown by the stream
+     */
+    private void write(IntegerSyntax attribute) throws IOException
+    {
+      String name = ((Attribute) attribute).getName();
+      out.writeByte(IppValueTag.INTEGER);
+      out.writeShort(name.length());
+      out.write(name.getBytes());
+      out.writeShort(4); // length, integer is 4 bytes
+      out.writeInt(attribute.getValue());
+    }
+
+    /**
+     * Writes an attribute in EnumSyntax into the stream.
+     * @param attribute the attribute
+     * @throws IOException if thrown by the stream
+     */
+    private void write(EnumSyntax attribute) throws IOException
+    {
+      // in JPS API enum syntax is used for enums, keyword and boolean types
+      String name = ((Attribute) attribute).getName();
+
+      // the enum value types
+      if (attribute instanceof Finishings
+          || attribute instanceof OrientationRequested
+          || attribute instanceof PrintQuality)
+        {
+          out.writeByte(IppValueTag.ENUM);
+          out.writeShort(name.length());
+          out.write(name.getBytes());
+          out.writeShort(4); // length, enum is 4 bytes
+          out.writeInt(attribute.getValue());
+        }
+      // the boolean value type
+      else if (attribute instanceof Fidelity)
+        {
+          out.writeByte(IppValueTag.BOOLEAN);
+          out.writeShort(name.length());
+          out.write(name.getBytes());
+          out.writeShort(1); // length, boolean is 1 bytes
+          out.writeByte(attribute.getValue() == 0 ? 0x00 : 0x01);
+        }
+      // the keyword value types
+      else
+        {
+          String keyword = attribute.toString();
+          out.writeByte(IppValueTag.KEYWORD);
+          out.writeShort(name.length());
+          out.write(name.getBytes());
+          out.writeShort(keyword.length());
+          out.write(keyword.getBytes());
+        }
+    }
+
+    /**
+     * Writes an attribute in SetOfIntegerSyntax into the stream.
+     * @param attribute the attribute
+     * @throws IOException if thrown by the stream
+     */
+    private void write(SetOfIntegerSyntax attribute) throws IOException
+    {
+      String name = ((Attribute) attribute).getName();
+      int[][] ranges = attribute.getMembers();
+      for (int i = 0; i < ranges.length; i++)
+        {
+          out.writeByte(IppValueTag.RANGEOFINTEGER);
+          if (i == 0)
+            {
+              out.writeShort(name.length());
+              out.write(name.getBytes());
+            }
+          else
+            out.writeShort(0x0000); // only name-length
+
+          out.writeShort(8); // range is 8 bytes
+          out.writeInt(ranges[i][0]);
+          out.writeInt(ranges[i][1]);
+        }
+    }
+
+    /**
+     * Writes an attribute in ResolutionSyntax into the stream.
+     * @param attribute the attribute
+     * @throws IOException if thrown by the stream
+     */
+    private void write(ResolutionSyntax attribute) throws IOException
+    {
+      String name = ((Attribute) attribute).getName();
+      out.writeByte(IppValueTag.RESOLUTION);
+      out.writeShort(name.length());
+      out.write(name.getBytes());
+      out.writeShort(9); // length fixed to 9
+      out.writeInt(attribute.getCrossFeedResolution(ResolutionSyntax.DPI));
+      out.writeInt(attribute.getFeedResolution(ResolutionSyntax.DPI));
+      out.writeByte(ResolutionSyntax.DPI);
+    }
+
+    /**
+     * Writes an attribute in DateTimeSyntax into the stream.
+     * <p>
+     * The syntax value is defined as 11 octets follwing the
+     * DateAndTime format of RFC 1903. (see IppResponse)
+     * </p>
+     *
+     * @param attribute the attribute
+     * @throws IOException if thrown by the stream
+     */
+    private void write(DateTimeSyntax attribute) throws IOException
+    {
+      String name = ((Attribute) attribute).getName();
+      out.writeByte(IppValueTag.DATETIME);
+      out.writeShort(name.length());
+      out.write(name.getBytes());
+      out.writeShort(11); // length fixed to 11
+
+      Date date = attribute.getValue();
+      Calendar cal = new GregorianCalendar();
+      cal.setTime(date);
+
+      out.writeShort(cal.get(Calendar.YEAR));
+      out.writeByte(cal.get(Calendar.MONTH));
+      out.writeByte(cal.get(Calendar.DAY_OF_MONTH));
+      out.writeByte(cal.get(Calendar.HOUR_OF_DAY));
+      out.writeByte(cal.get(Calendar.MINUTE));
+      int second = cal.get(Calendar.SECOND);
+      out.writeByte(second == 0 ? 60 : second);
+      out.writeByte(cal.get(Calendar.MILLISECOND) / 100);
+
+      int offsetInMillis = cal.get(Calendar.ZONE_OFFSET);
+      char directionFromUTC = '+';
+      if (offsetInMillis < 0)
+        {
+          directionFromUTC = '-';
+          offsetInMillis = offsetInMillis * (-1);
+        }
+
+      out.writeByte(directionFromUTC);
+      out.writeByte(offsetInMillis / 3600000); // hours
+      out.writeByte((offsetInMillis % 3600000) / 60000); // minutes
+    }
+
+    /**
+     * Writes an attribute in TextSyntax into the stream.
+     * <p>
+     * By default attributes are qritten as TEXT_WITHOUT_LANGUAGE value-tag.
+     * As some attributes in the JPS are TextSyntax attributes but actually
+     * of NAME value-tag in IPP this method checks for these attributes and
+     * writes them as NAME_WITHOUT_LANGUAGE value-tag into the stream.
+     * </p>
+     *
+     * @param attribute the attribute
+     * @param out the stream to write to
+     * @throws IOException if thrown by the stream
+     */
+    private void write(TextSyntax attribute) throws IOException
+    {
+      // We only use *WithoutLanguage, correct according to spec.
+      String name = ((Attribute) attribute).getName();
+
+      if (attribute instanceof RequestingUserName
+          || attribute instanceof JobName
+          || attribute instanceof DocumentName
+          || attribute instanceof JobOriginatingUserName)
+        out.writeByte(IppValueTag.NAME_WITHOUT_LANGUAGE);
+      else if (attribute instanceof DocumentFormat)
+        out.writeByte(IppValueTag.MIME_MEDIA_TYPE);
+      else
+        out.writeByte(IppValueTag.TEXT_WITHOUT_LANGUAGE);
+
+      out.writeShort(name.length());
+      out.write(name.getBytes());
+      out.writeShort(attribute.getValue().length());
+      out.write(attribute.getValue().getBytes());
+    }
+
+    /**
+     * Writes an attribute in URISyntax into the stream.
+     * @param attribute the attribute
+     * @param out the stream to write to
+     * @throws IOException if thrown by the stream
+     */
+    private void write(URISyntax attribute) throws IOException
+    {
+      // only uriScheme syntax type should not appear
+      // in a request (reference-uri-schemes-supported)
+      String name = ((Attribute) attribute).getName();
+      String uriAscii = attribute.getURI().toASCIIString();
+      out.writeByte(IppValueTag.URI);
+      out.writeShort(name.length());
+      out.write(name.getBytes());
+      out.writeShort(uriAscii.length());
+      out.write(uriAscii.getBytes());
+    }
+
+    /**
+     * Writes an attribute in CharsetSyntax into the stream.
+     * @param attribute the attribute
+     * @param out the stream to write to
+     * @throws IOException if thrown by the stream
+     */
+    private void write(CharsetSyntax attribute) throws IOException
+    {
+      String name = ((Attribute) attribute).getName();
+      out.writeByte(IppValueTag.CHARSET);
+      out.writeShort(name.length());
+      out.write(name.getBytes());
+      out.writeShort(attribute.getValue().length());
+      out.write(attribute.getValue().getBytes());
+    }
+
+    /**
+     * Writes an attribute in NaturalLanguageSyntax into the stream.
+     * @param attribute the attribute
+     * @param out the stream to write to
+     * @throws IOException if thrown by the stream
+     */
+    private void write(NaturalLanguageSyntax attribute) throws IOException
+    {
+      String name = ((Attribute) attribute).getName();
+      out.writeByte(IppValueTag.NATURAL_LANGUAGE);
+      out.writeShort(name.length());
+      out.write(name.getBytes());
+      out.writeShort(attribute.getValue().length());
+      out.write(attribute.getValue().getBytes());
+    }
+
+    /**
+     * Writes an attribute in RequestedAttributes into the stream.
+     * @param attribute the attribute
+     * @param out the stream to write to
+     * @throws IOException if thrown by the stream
+     */
+    private void write(RequestedAttributes attribute) throws IOException
+    {
+      String[] values = attribute.getValues();
+
+      String name = ((Attribute) attribute).getName();
+      out.writeByte(IppValueTag.KEYWORD);
+      out.writeShort(name.length());
+      out.write(name.getBytes());
+      out.writeShort(values[0].length());
+      out.write(values[0].getBytes());
+
+      for (int i=1; i < values.length; i++)
+        {
+          out.writeByte(IppValueTag.KEYWORD);
+          out.writeShort(0x0000); // length for additional value
+          out.writeShort(values[i].length());
+          out.write(values[i].getBytes());
+        }
+    }
+
+
+    /**
+     * Writes the given operation attribute group of the given map instance
+     * (key=group, values=set of attributes) into the supplied data
+     * output stream.
+     *
+     * @param attributes the set with the attributes.
+     *
+     * @throws IOException if thrown by the used DataOutputStream.
+     * @throws IppException if unknown attributes occur.
+     */
+    public void writeOperationAttributes(AttributeSet attributes)
+        throws IOException, IppException
+    {
+      out.write(IppDelimiterTag.OPERATION_ATTRIBUTES_TAG);
+
+      // its essential to write these two in this order and as first ones
+      Attribute att = attributes.get(AttributesCharset.class);
+      write((CharsetSyntax) att);
+
+      logger.log(Component.IPP, "Attribute: Name: <"
+        + att.getCategory().getName() + "> Value: <" + att.toString() + ">");
+
+      attributes.remove(AttributesCharset.class);
+
+      att = attributes.get(AttributesNaturalLanguage.class);
+      write((NaturalLanguageSyntax) att);
+      attributes.remove(AttributesNaturalLanguage.class);
+
+      logger.log(Component.IPP, "Attribute: Name: <"
+        + att.getCategory().getName() + "> Value: <" + att.toString() + ">");
+
+      // furthermore its essential to now write out the target attribute
+      PrinterURI printerUri = (PrinterURI) attributes.get(PrinterURI.class);
+      JobUri jobUri = (JobUri) attributes.get(JobUri.class);
+      JobId jobId = (JobId) attributes.get(JobId.class);
+      RequestedAttributes reqAttrs
+        = (RequestedAttributes)attributes.get(RequestedAttributes.class);
+      if (printerUri != null && jobId == null && jobUri == null)
+        {
+          write(printerUri);
+          attributes.remove(PrinterURI.class);
+          logger.log(Component.IPP, "Attribute: Name: <" + printerUri
+            .getCategory().getName() + "> Value: <" + printerUri.toString() + ">");
+        }
+      else if (jobUri != null && jobId == null && printerUri == null)
+        {
+          write(jobUri);
+          attributes.remove(JobUri.class);
+          logger.log(Component.IPP, "Attribute: Name: <" + jobUri
+            .getCategory().getName() + "> Value: <" + jobUri.toString() + ">");
+        }
+      else if (printerUri != null && jobId != null && jobUri == null)
+        {
+          write(printerUri); // must be third
+          write(jobId);
+          attributes.remove(PrinterURI.class);
+          attributes.remove(JobId.class);
+          logger.log(Component.IPP, "Attribute: Name: <" + printerUri
+            .getCategory().getName() + "> Value: <" + printerUri.toString() + ">");
+          logger.log(Component.IPP, "Attribute: Name: <" + jobId.getCategory()
+            .getName() + "> Value: <" + jobId.toString() + ">");
+        }
+      else if (jobUri != null && jobId != null)
+        {
+          write(jobUri);
+          attributes.remove(JobUri.class);
+          attributes.remove(JobId.class); // MUST NOT redundant
+          logger.log(Component.IPP, "Attribute: Name: <" + jobUri.getCategory()
+            .getName() + "> Value: <" + jobUri.toString() + ">");
+        }
+      else if (reqAttrs != null)
+        {
+          write(reqAttrs);
+          attributes.remove(RequestedAttributes.class);
+          logger.log(Component.IPP, "RequestedAttributes: <" + reqAttrs + ">");
+        }
+      else
+        {
+          throw new IppException("Unknown target operation attribute combination.");
+        }
+
+      writeAttributes(attributes);
+    }
+
+    /**
+     * Writes the given attribute groups of the given map instance
+     * (key=group, values=set of attributes) into the supplied data
+     * output stream.
+     *
+     * @param attributes the set with the attributes.
+     *
+     * @throws IOException if thrown by the used DataOutputStream.
+     * @throws IppException if unknown attributes occur.
+     */
+    public void writeAttributes(AttributeSet attributes)
+        throws IOException, IppException
+    {
+      Attribute[] attributeArray = attributes.toArray();
+      for (int i = 0; i < attributeArray.length; i++)
+        {
+          logger.log(Component.IPP, "Attribute: Name: <" + attributeArray[i]
+            .getCategory().getName() + "> Value: <"
+            + attributeArray[i].toString() + ">");
+
+          if (attributeArray[i] instanceof IntegerSyntax)
+            write((IntegerSyntax) attributeArray[i]);
+          else if (attributeArray[i] instanceof TextSyntax)
+            write((TextSyntax) attributeArray[i]);
+          else if (attributeArray[i] instanceof DateTimeSyntax)
+            write((DateTimeSyntax) attributeArray[i]);
+          else if (attributeArray[i] instanceof ResolutionSyntax)
+            write((ResolutionSyntax) attributeArray[i]);
+          else if (attributeArray[i] instanceof SetOfIntegerSyntax)
+            write((SetOfIntegerSyntax) attributeArray[i]);
+          else if (attributeArray[i] instanceof EnumSyntax)
+            write((EnumSyntax) attributeArray[i]);
+          else if (attributeArray[i] instanceof URISyntax)
+            write((URISyntax) attributeArray[i]);
+          else if (attributeArray[i] instanceof CharsetSyntax)
+            write((CharsetSyntax) attributeArray[i]);
+          else if (attributeArray[i] instanceof NaturalLanguageSyntax)
+            write((NaturalLanguageSyntax) attributeArray[i]);
+          else if (attributeArray[i] instanceof RequestedAttributes)
+            write((RequestedAttributes) attributeArray[i]);
+          else
+            throw new IppException("Unknown syntax type");
+        }
+    }
+
+  }
+
+  /**
+   * Logger for tracing - enable by passing
+   * -Dgnu.classpath.debug.components=ipp to the vm.
+   */
+  static final Logger logger = SystemLogger.SYSTEM;
+
+  /**
+   * The request id counter simply counts up
+   * to give unique request ids per JVM instance.
+   */
+  private static int requestIdCounter = 1;
+
+  /** The IPP version defaults to 1.1 */
+  private static final short VERSION = 0x0101;
+
+  /** Signals if the request is already on its way */
+  private boolean alreadySent = false;
+
+  /** The operation type of this request. */
+  private short operation_id;
+
+  /**
+   * The request id of this request. This is
+   * assigned automatically by the constructor.
+   */
+  private final int request_id;
+
+  private AttributeSet operationAttributes;
+
+  private AttributeSet printerAttributes;
+
+  private AttributeSet jobAttributes;
+
+  private Object data;
+
+  private URI requestUri;
+
+  /** The underlying connection - IPP is http based */
+  private HttpURLConnection  connection;
+
+  /**
+   * Creates an IPPRequest instance.
+   *
+   * @param uri the URI of the request
+   * @param user the user if any
+   * @param password the password of the supplied user
+   */
+  public IppRequest(URI uri, String user, String password)
+  {
+    request_id = incrementRequestIdCounter();
+    requestUri = uri;
+
+    try
+      {
+        URL url = new URL("http",
+                      user == null
+                      ? uri.getHost() : user + ":"
+                      + password + "@" + uri.getHost(),
+                      uri.getPort(), uri.getPath());
+
+        connection = (HttpURLConnection) url.openConnection();
+        connection.setRequestMethod("POST");
+        connection.setDoOutput(true);
+
+        connection.setRequestProperty("Content-type", "application/ipp");
+        connection.setRequestProperty("Accept", "text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2");
+      }
+    catch (IOException e)
+      {
+        // MalformedURLException - uri is already checked
+        // ProtocolException - POST is correct method type
+        // IOException -HTTPURLConnection constructor actually
+        // does never throw this exception.
+        logger.log(Component.IPP, "Unexpected IOException", e);
+      }
+
+    logger.log(Component.IPP, "[IppConnection] Host: " + uri.getHost()
+                              + " Port: " + uri.getPort() + " Path: "
+                              + uri.getPath());
+  }
+
+  /**
+   * Synchronized method to be called by the constructor
+   * to assign a unique request id to this request.
+   *
+   * @return The unique request id.
+   */
+  private synchronized int incrementRequestIdCounter()
+  {
+    return IppRequest.requestIdCounter++;
+  }
+
+  /**
+   * Returns the id of this request.
+   *
+   * @return The request ID.
+   */
+  public int getRequestID()
+  {
+    return request_id;
+  }
+
+  /**
+   * Sets the data of the request. The data used in this
+   * request will be the one of the supplied inputstream
+   * instead of the alternative byte array possibility.
+   *
+   * @param stream the input stream to use for the data.
+   */
+  public void setData(InputStream stream)
+  {
+    data = stream;
+  }
+
+  /**
+   * Sets the data of the request. The data used in this
+   * request will be the one of the supplied byte[]
+   * instead of the alternative input stream possibility.
+   *
+   * @param bytes the byte[] to use for the data.
+   */
+  public void setData(byte[] bytes)
+  {
+    data = bytes;
+  }
+
+  /**
+   * Sets the operation id for this request.
+   *
+   * @param id the operation id.
+   */
+  public void setOperationID(short id)
+  {
+    operation_id = id;
+  }
+
+  /**
+   * Adds the default values for the operation
+   * attributes "attributes-charset" and
+   * "attributes-natural-language"
+   */
+  public void setOperationAttributeDefaults()
+  {
+    if (operationAttributes == null)
+      operationAttributes = new HashAttributeSet();
+
+    operationAttributes.add(AttributesCharset.UTF8);
+    operationAttributes.add(AttributesNaturalLanguage.EN);
+  }
+
+  /**
+   * Add the job attribute of this request to the given
+   * attribute set.
+   *
+   * @param attribute the job attribute.
+   */
+  public void addJobAttribute(Attribute attribute)
+  {
+    if (jobAttributes == null)
+      jobAttributes = new HashAttributeSet();
+
+    jobAttributes.add(attribute);
+  }
+
+  /**
+   * Sets the printer attribute of this request to the given
+   * attribute set.
+   *
+   * @param attribute the printer attribute.
+   */
+  public void addPrinterAttributes(Attribute attribute)
+  {
+    if (printerAttributes == null)
+      printerAttributes = new HashAttributeSet();
+
+    printerAttributes.add(attribute);
+  }
+
+  /**
+   * Adds the given attribute to the operation attributes set.
+   *
+   * @param attribute the operation attribute to add.
+   */
+  public void addOperationAttribute(Attribute attribute)
+  {
+    if (operationAttributes == null)
+      operationAttributes = new HashAttributeSet();
+
+    operationAttributes.add(attribute);
+  }
+
+  /**
+   * Filters from the given attribute set the job operation out
+   * and adds them to the operation attributes set.
+   *
+   * @param set the attributes to filter, may not be <code>null</code>.
+   */
+  public void addAndFilterJobOperationAttributes(AttributeSet set)
+  {
+    if (operationAttributes == null)
+      operationAttributes = new HashAttributeSet();
+
+    // document-natural-language - not defined in JPS attributes
+    // document-format - specified outside, special treatment
+    Attribute[] tmp = set.toArray();
+    for (int i = 0; i < tmp.length; i++)
+      {
+        if (tmp[i].getCategory().equals(JobName.class)
+            || tmp[i].getCategory().equals(Fidelity.class)
+            || tmp[i].getCategory().equals(JobImpressions.class)
+            || tmp[i].getCategory().equals(JobKOctets.class)
+            || tmp[i].getCategory().equals(JobMediaSheets.class)
+            || tmp[i].getCategory().equals(Compression.class)
+            || tmp[i].getCategory().equals(DocumentName.class)
+            || tmp[i].getCategory().equals(RequestingUserName.class))
+
+          operationAttributes.add(tmp[i]);
+      }
+  }
+
+  /**
+   * Filters from the given attribute set the job template attributes
+   * out and adds them to the job attributes set.
+   *
+   * @param set the attributes to filter, may not be <code>null</code>.
+   */
+  public void addAndFilterJobTemplateAttributes(AttributeSet set)
+  {
+    if (jobAttributes == null)
+      jobAttributes = new HashAttributeSet();
+
+    // document-natural-language - not defined in JPS attributes
+    // document-format - specified outside, special treatment
+    Attribute[] tmp = set.toArray();
+    for (int i = 0; i < tmp.length; i++)
+      {
+        if (tmp[i].getCategory().equals(JobPriority.class)
+            || tmp[i].getCategory().equals(JobHoldUntil.class)
+            || tmp[i].getCategory().equals(JobSheets.class)
+            || tmp[i].getCategory().equals(MultipleDocumentHandling.class)
+            || tmp[i].getCategory().equals(Copies.class)
+            || tmp[i].getCategory().equals(Finishings.class)
+            || tmp[i].getCategory().equals(PageRanges.class)
+            || tmp[i].getCategory().equals(NumberUp.class)
+            || tmp[i].getCategory().equals(OrientationRequested.class)
+            || tmp[i].getCategory().equals(Media.class)
+            || tmp[i].getCategory().equals(PrinterResolution.class)
+            || tmp[i].getCategory().equals(PrintQuality.class)
+            || tmp[i].getCategory().equals(SheetCollate.class)
+            || tmp[i].getCategory().equals(Sides.class))
+
+          jobAttributes.add(tmp[i]);
+      }
+  }
+
+  /**
+   * Does some validation of the supplied parameters and then
+   * sends the request to the ipp server or service.
+   *
+   * @return The response if any.
+   *
+   * @throws IllegalStateException if request is already sent
+   * @throws IppException if connection or request failed.
+   * @throws IOException if writing of the header, attributes or footer fails.
+   */
+  public IppResponse send() throws IppException, IOException
+  {
+    if (alreadySent)
+      throw new IllegalStateException("Request is already sent");
+
+    alreadySent = true;
+
+    OutputStream stream = connection.getOutputStream();
+    DataOutputStream out = new DataOutputStream(stream);
+
+    //  the header 8 bytes long
+    out.writeShort(VERSION);
+    out.writeShort(operation_id);
+    out.writeInt(request_id);
+
+    logger.log(Component.IPP, "OperationID: " + Integer.toHexString(operation_id)
+      + " RequestID: " + request_id);
+
+    // Pass stuff the the attribute writer which knows how to
+    // write the attributes in correct order
+    logger.log(Component.IPP, "Operation Attributes");
+
+    RequestWriter writer = new RequestWriter(out);
+    writer.writeOperationAttributes(operationAttributes);
+
+    if (jobAttributes != null)
+      {
+        logger.log(Component.IPP, "Job Attributes");
+        out.write(IppDelimiterTag.JOB_ATTRIBUTES_TAG);
+        writer.writeAttributes(jobAttributes);
+      }
+    if (printerAttributes != null)
+      {
+        logger.log(Component.IPP, "Printer Attributes");
+        out.write(IppDelimiterTag.PRINTER_ATTRIBUTES_TAG);
+        writer.writeAttributes(printerAttributes);
+      }
+
+    // write the delimiter to the data
+    out.write(IppDelimiterTag.END_OF_ATTRIBUTES_TAG);
+
+    // check if data is byte[] or inputstream
+    if (data instanceof InputStream)
+      {
+        byte[] readbuf = new byte[2048];
+        int len = 0;
+        while( (len = ((InputStream) data).read(readbuf)) > 0)
+          out.write(readbuf, 0, len);
+      }
+    else if (data != null)
+      {
+        out.write((byte[]) data);
+      }
+
+    out.flush();
+    stream.flush();
+
+    // Set the connection timeout, for if the printer is offline.
+    // FIXME: The print services polling should probably be done in its
+    // own thread.
+    connection.setConnectTimeout( timeout );
+
+    int responseCode = connection.getResponseCode();
+
+    if (responseCode == HttpURLConnection.HTTP_OK)
+      {
+        IppResponse response = new IppResponse(requestUri, operation_id);
+        response.setResponseData(connection.getInputStream());
+        return response;
+      }
+
+    logger.log(Component.IPP, "HTTP-Statuscode: " + responseCode);
+
+    throw new IppException("Request failed got HTTP status code "
+                           + responseCode);
+  }
+
+}