--- /dev/null
+package com.easysw.cups;
+
+/**
+ * @version 1.00 06-NOV-2002
+ * @author Easy Software Products
+ *
+ * Internet Printing Protocol definitions for the Common UNIX Printing
+ * System (CUPS).
+ *
+ * Copyright 1997-2002 by Easy Software Products.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Easy Software Products and are protected by Federal
+ * copyright law. Distribution and use rights are outlined in the file
+ * "LICENSE.txt" which should have been included with this file. If this
+ * file is missing or damaged please contact Easy Software Products
+ * at:
+ *
+ * Attn: CUPS Licensing Information
+ * Easy Software Products
+ * 44141 Airport View Drive, Suite 204
+ * Hollywood, Maryland 20636-3111 USA
+ *
+ * Voice: (301) 373-9603
+ * EMail: cups-info@cups.org
+ * WWW: http://www.cups.org
+ */
+
+/**
+ * An <code>IPPHttp</code> object is used for reading/writing to the cups
+ * server, and processing responses.
+ *
+ * @author TDB
+ * @version 1.0
+ * @since JDK1.3
+ */
+
+import java.io.*;
+import java.util.*;
+import java.net.*;
+import java.security.*;
+
+public class IPPHttp
+{
+
+ /**
+ * Class constants - most not in use yet.
+ */
+ public static final int HTTP_WAITING = 0x00;
+ public static final int HTTP_OPTIONS = 0x01;
+ public static final int HTTP_GET = 0x02;
+ public static final int HTTP_GET_SEND = 0x03;
+ public static final int HTTP_HEAD = 0x04;
+ public static final int HTTP_POST = 0x05;
+ public static final int HTTP_POST_RECV = 0x06;
+ public static final int HTTP_POST_SEND = 0x07;
+ public static final int HTTP_PUT = 0x08;
+ public static final int HTTP_PUT_RECV = 0x09;
+ public static final int HTTP_DELETE = 0x0A;
+ public static final int HTTP_TRACE = 0x0B;
+ public static final int HTTP_CLOSE = 0x0C;
+ public static final int HTTP_STATUS = 0x0D;
+
+ public static final int HTTP_0_9 = 0x09;
+ public static final int HTTP_1_0 = 0x64;
+ public static final int HTTP_1_1 = 0x65;
+
+ public static final int HTTP_KEEPALIVE_OFF = 0x00;
+ public static final int HTTP_KEEPALIVE_ON = 0x01;
+
+ public static final int HTTP_ENCODE_LENGTH = 0x00;
+ public static final int HTTP_ENCODE_CHUNKED = 0x01;
+
+ public static final int HTTP_ENCRYPT_IF_REQUESTED = 0x00;
+ public static final int HTTP_ENCRYPT_NEVER = 0x01;
+ public static final int HTTP_ENCRYPT_REQUIRED = 0x02;
+ public static final int HTTP_ENCRYPT_ALWAYS = 0x03;
+
+ public static final int HTTP_AUTH_NONE = 0x00;
+ public static final int HTTP_AUTH_BASIC = 0x01;
+ public static final int HTTP_AUTH_MD5 = 0x02;
+ public static final int HTTP_AUTH_MD5_SESS = 0x03;
+ public static final int HTTP_AUTH_MD5_INT = 0x04;
+ public static final int HTTP_AUTH_MD5_SESS_INT = 0x05;
+
+ public static final int HTTP_ERROR = 0xFFFFFFFF;
+ public static final int HTTP_CONTINUE = 0x64;
+ public static final int HTTP_SWITCHING_PROTOCOLS = 0x65;
+ public static final int HTTP_OK = 0xC8;
+ public static final int HTTP_CREATED = 0xC9;
+ public static final int HTTP_ACCEPTED = 0xCA;
+ public static final int HTTP_NOT_AUTHORITATIVE = 0xCB;
+ public static final int HTTP_NO_CONTENT = 0xCC;
+ public static final int HTTP_RESET_CONTENT = 0xCD;
+ public static final int HTTP_PARTIAL_CONTENT = 0xCE;
+ public static final int HTTP_MULTIPLE_CHOICES = 0x12C;
+ public static final int HTTP_MOVED_PERMANENTLY = 0x12D;
+ public static final int HTTP_MOVED_TEMPORARILY = 0x12E;
+ public static final int HTTP_SEE_OTHER = 0x12F;
+ public static final int HTTP_NOT_MODIFIED = 0x130;
+ public static final int HTTP_USE_PROXY = 0x131;
+ public static final int HTTP_BAD_REQUEST = 0x190;
+ public static final int HTTP_UNAUTHORIZED = 0x191;
+ public static final int HTTP_PAYMENT_REQUIRED = 0x192;
+ public static final int HTTP_FORBIDDEN = 0x193;
+ public static final int HTTP_NOT_FOUND = 0x194;
+ public static final int HTTP_METHOD_NOT_ALLOWED = 0x195;
+ public static final int HTTP_NOT_ACCEPTABLE = 0x196;
+ public static final int HTTP_PROXY_AUTHENTICATION = 0x197;
+ public static final int HTTP_REQUEST_TIMEOUT = 0x198;
+ public static final int HTTP_CONFLICT = 0x199;
+ public static final int HTTP_GONE = 0x19A;
+ public static final int HTTP_LENGTH_REQUIRED = 0x19B;
+ public static final int HTTP_PRECONDITION = 0x19C;
+ public static final int HTTP_REQUEST_TOO_LARGE = 0x19D;
+ public static final int HTTP_URI_TOO_LONG = 0x19E;
+ public static final int HTTP_UNSUPPORTED_MEDIATYPE = 0x19F;
+ public static final int HTTP_UPGRADE_REQUIRED = 0x1AA;
+ public static final int HTTP_SERVER_ERROR = 0x1F4;
+ public static final int HTTP_NOT_IMPLEMENTED = 0x1F5;
+ public static final int HTTP_BAD_GATEWAY = 0x1F6;
+ public static final int HTTP_SERVICE_UNAVAILABLE = 0x1F7;
+ public static final int HTTP_GATEWAY_TIMEOUT = 0x1F8;
+
+ public static final int HTTP_NOT_SUPPORTED = 0x1F9;
+
+ public static final int HTTP_FIELD_UNKNOWN = 0xFFFFFFFF;
+ public static final int HTTP_FIELD_ACCEPT_LANGUAGE = 0x00;
+ public static final int HTTP_FIELD_ACCEPT_RANGES = 0x01;
+ public static final int HTTP_FIELD_AUTHORIZATION = 0x02;
+ public static final int HTTP_FIELD_CONNECTION = 0x03;
+ public static final int HTTP_FIELD_CONTENT_ENCODING = 0x04;
+ public static final int HTTP_FIELD_CONTENT_LANGUAGE = 0x05;
+ public static final int HTTP_FIELD_CONTENT_LENGTH = 0x06;
+ public static final int HTTP_FIELD_CONTENT_LOCATION = 0x07;
+ public static final int HTTP_FIELD_CONTENT_MD5 = 0x08;
+ public static final int HTTP_FIELD_CONTENT_RANGE = 0x09;
+ public static final int HTTP_FIELD_CONTENT_TYPE = 0x0A;
+ public static final int HTTP_FIELD_CONTENT_VERSION = 0x0B;
+ public static final int HTTP_FIELD_DATE = 0x0C;
+ public static final int HTTP_FIELD_HOST = 0x0D;
+ public static final int HTTP_FIELD_IF_MODIFIED_SINCE = 0x0E;
+ public static final int HTTP_FIELD_IF_UNMODIFIED_SINCE = 0x0F;
+ public static final int HTTP_FIELD_KEEP_ALIVE = 0x10;
+ public static final int HTTP_FIELD_LAST_MODIFIED = 0x11;
+ public static final int HTTP_FIELD_LINK = 0x12;
+ public static final int HTTP_FIELD_LOCATION = 0x13;
+ public static final int HTTP_FIELD_RANGE = 0x14;
+ public static final int HTTP_FIELD_REFERER = 0x15;
+ public static final int HTTP_FIELD_RETRY_AFTER = 0x16;
+ public static final int HTTP_FIELD_TRANSFER_ENCODING = 0x17;
+ public static final int HTTP_FIELD_UPGRADE = 0x18;
+ public static final int HTTP_FIELD_USER_AGENT = 0x19;
+ public static final int HTTP_FIELD_WWW_AUTHENTICATE = 0x1A;
+ public static final int HTTP_FIELD_MAX = 0x1B;
+
+ public static final String http_fields[] =
+ {
+ "Accept-Language",
+ "Accept-Ranges",
+ "Authorization",
+ "Connection",
+ "Content-Encoding",
+ "Content-Language",
+ "Content-Length",
+ "Content-Location",
+ "Content-MD5",
+ "Content-Range",
+ "Content-Type",
+ "Content-Version",
+ "Date",
+ "Host",
+ "If-Modified-Since",
+ "If-Unmodified-since",
+ "Keep-Alive",
+ "Last-Modified",
+ "Link",
+ "Location",
+ "Range",
+ "Referer",
+ "Retry-After",
+ "Transfer-Encoding",
+ "Upgrade",
+ "User-Agent",
+ "WWW-Authenticate"
+ };
+ public static final String days[] =
+ {
+ "Sun",
+ "Mon",
+ "Tue",
+ "Wed",
+ "Thu",
+ "Fri",
+ "Sat"
+ };
+ public static final String months[] =
+ {
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "May",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Oct",
+ "Nov",
+ "Dec"
+ };
+
+
+
+ //
+ // Private class members.
+ //
+ private URL url; // URL of connection.
+
+ public Socket conn; // Connection socket.
+ public boolean connected; // True when connected.
+
+ public BufferedInputStream is; // Input stream.
+ public BufferedReader br;
+ public BufferedOutputStream os; // Output stream.
+
+ private boolean encrypted;
+
+ public int write_content_length;
+ private char write_buffer[];
+ private int write_buffer_head;
+ private int write_buffer_tail;
+
+ public String read_header_date;
+ public String read_header_server;
+ public String read_header_charset;
+ public String read_header_content_language;
+ public String read_header_content_type;
+ public int read_header_content_length;
+
+ public char read_buffer[];
+ private int read_buffer_head;
+ private int read_buffer_tail;
+
+ public int status;
+ public String status_text;
+ public String version;
+ public int error;
+ public int activity;
+
+ public String hostname; // Hostname from URL
+ public int port; // Port from URL.
+ public String path; // Path from URL.
+ public String user; // User name
+ public String passwd; // Password
+
+ public String auth_type; // none, basic, digest
+ public String realm; // For digest auth
+ public String opaque; // For digest auth
+ public String nonce; // For digest auth
+ public String resource; // For digest auth
+ public String method; // For digest auth
+
+ public String http_request;
+ public int http_content_length;
+
+
+
+ /**
+ * Constructor using <code>URL</code>.
+ *
+ * @param request_url <code>URL</code> of server to connect to.
+ * @throw IOException
+ * @throw UnknownHostException
+ */
+ public IPPHttp( String request_url )
+ throws IOException, UnknownHostException
+ {
+
+ encrypted = false;
+ status = 0;
+ status_text = "";
+ version = "1.0";
+ connected = false;
+ user = "";
+ passwd = "";
+
+ auth_type = "";
+ realm = "";
+ nonce = "";
+ resource = "";
+ method = "";
+
+ try
+ {
+ //
+ // Create the URL and split it up.
+ //
+ url = new URL(request_url);
+ hostname = url.getHost();
+ port = url.getPort();
+ path = url.getPath();
+
+
+ //
+ // Open the socket and set the options.
+ //
+ conn = new Socket(hostname, port);
+ conn.setSoTimeout(200);
+
+ //
+ // Create the input and output streams.
+ //
+ is = new BufferedInputStream(new DataInputStream(conn.getInputStream()));
+ os = new BufferedOutputStream(new DataOutputStream(conn.getOutputStream()));
+ connected = true;
+ }
+ catch(UnknownHostException unknownhostexception)
+ {
+ throw unknownhostexception;
+ }
+ catch(IOException ioexception)
+ {
+ throw ioexception;
+ }
+ }
+
+
+
+ /**
+ * Constructor using <code>URL, user and pass</code>.
+ *
+ * @param request_url <code>URL</code> of server to connect to.
+ * @param p_auth_type <code>String</code> basic or digest.
+ * @param p_user <code>String</code> User name.
+ * @param p_passwd <code>String</code> password.
+ * @throw IOException
+ * @throw UnknownHostException
+ */
+ public IPPHttp( String request_url, String p_auth_type,
+ String p_user, String p_passwd )
+ throws IOException, UnknownHostException
+ {
+ encrypted = false;
+ status = 0;
+ status_text = "";
+ version = "1.0";
+ connected = false;
+
+ user = p_user;
+ passwd = p_passwd;
+ auth_type = p_auth_type;
+
+ realm = "";
+ nonce = "";
+ resource = "";
+ method = "";
+
+ try
+ {
+ //
+ // Create the URL and split it up.
+ //
+ url = new URL(request_url);
+ hostname = url.getHost();
+ port = url.getPort();
+ path = url.getPath();
+
+ //
+ // Open the socket and set the options.
+ //
+ conn = new Socket(hostname, port);
+ conn.setSoTimeout(200);
+
+ //
+ // Create the input and output streams.
+ //
+ is = new BufferedInputStream(new DataInputStream(conn.getInputStream()));
+ os = new BufferedOutputStream(new DataOutputStream(conn.getOutputStream()));
+ connected = true;
+ }
+ catch(UnknownHostException unknownhostexception)
+ {
+ throw unknownhostexception;
+ }
+ catch(IOException ioexception)
+ {
+ throw ioexception;
+ }
+ }
+
+
+
+
+ /**
+ * Re-establish a dropped connection.
+ *
+ * @return <code>boolean</code> True if connected.
+ *
+ * @throw IOException
+ */
+ public boolean reConnect() throws IOException
+ {
+ connected = false;
+ status = 0;
+ status_text = "";
+ try
+ {
+ //
+ // Open the socket and set the options.
+ //
+ conn = new Socket(hostname, port);
+ conn.setSoTimeout(200);
+
+ //
+ // Create the input and output streams.
+ //
+ is = new BufferedInputStream(new DataInputStream(conn.getInputStream()));
+ os = new BufferedOutputStream(new DataOutputStream(conn.getOutputStream()));
+ connected = true;
+ return(connected);
+
+ }
+ catch (IOException ioexception)
+ {
+ connected = false;
+ throw(ioexception);
+ }
+ }
+
+
+
+ /**
+ * Set the user name.
+ *
+ * @param p_user <code>String</code> - user name.
+ */
+ public void setUser(String p_user )
+ {
+ user = p_user;
+ }
+
+
+ /**
+ * Set the password.
+ *
+ * @param p_passwd <code>String</code> - password.
+ */
+ public void setPassword(String p_passwd )
+ {
+ passwd = p_passwd;
+ }
+
+
+
+
+ /**
+ * Write the request header bytes to the server.
+ *
+ * @param request <code>String</code> - the request.
+ * @param content_length <code>int</code> - size of the total request.
+ * @throw IOException
+ */
+ public int writeHeader(String request, int content_length )
+ throws IOException
+ {
+
+ http_request = request;
+ http_content_length = content_length;
+
+ try
+ {
+ String s1 = "POST " + request + " HTTP/1.0\r\n";
+ os.write(s1.getBytes(), 0, s1.length());
+
+ s1 = "Content-type: application/ipp\r\n";
+ os.write(s1.getBytes(), 0, s1.length());
+
+
+ //
+ // Do basic style authorization if needed.
+ //
+ if (auth_type.compareTo("basic") == 0)
+ {
+ s1 = user + ":" + passwd;
+ IPPBase64Encoder encoder = new IPPBase64Encoder();
+ String auth_string = encoder.encode(s1.getBytes());
+ s1 = "Authorization: Basic " + auth_string + "\r\n";
+ os.write(s1.getBytes(), 0, s1.length());
+ }
+ else if (auth_type.compareTo("digest") == 0)
+ {
+ try
+ {
+ IPPMD5 md5 = IPPMD5.getInstance();
+ String auth_string = md5.MD5Digest(user, passwd, realm,
+ "POST", path, nonce );
+ s1 = "Authorization: Digest " + "username=\"" + user + "\", " +
+ "realm=\"" + realm + "\", " +
+ "nonce=\"" + nonce + "\", " +
+ "response=\"" + auth_string + "\"\r\n";
+
+ os.write(s1.getBytes(), 0, s1.length());
+ }
+ catch(NoSuchAlgorithmException e)
+ {
+ System.out.println("No such algorithm: MD5.");
+ }
+ }
+
+ s1 = "Content-length: " + content_length + "\r\n\r\n";
+ os.write(s1.getBytes(), 0, s1.length());
+ os.flush();
+ }
+ catch(IOException ioexception)
+ {
+ error = HTTP_ERROR;
+ throw ioexception;
+ }
+
+
+ try
+ {
+ int local_status = 0;
+
+ //
+ // Check for any response.
+ //
+ if (is.available() > 0)
+ {
+ StringBuffer http_version = new StringBuffer(32);
+ StringBuffer http_status = new StringBuffer(32);
+ StringBuffer http_text = new StringBuffer(256);
+
+ String read_buffer;
+ status = 0;
+ is.mark(8192);
+ while (is.available() > 0)
+ {
+ read_buffer = read_line();
+
+ if (read_buffer.startsWith("HTTP/"))
+ {
+ int i,n;
+ String s2 = read_buffer.substring(5);
+
+
+ for (i=0;(i < s2.length() && s2.charAt(i) != ' '); i++)
+ {
+ http_version.append(s2.charAt(i));
+ }
+ while (i < s2.length() && s2.charAt(i) == ' ')
+ i++;
+ for (;(i < s2.length() && s2.charAt(i) != '\n' &&
+ s2.charAt(i) != '\r' && s2.charAt(i) != ' '); i++)
+ {
+ http_status.append(s2.charAt(i));
+ }
+
+ while (i < s2.length() && s2.charAt(i) == ' ')
+ i++;
+ for (n=0;(n < 256 && i < s2.length() && s2.charAt(i) != '\n' &&
+ s2.charAt(i) != '\r' && s2.charAt(i) != ' '); i++)
+ {
+ http_text.append(s2.charAt(i));
+ }
+ local_status = Integer.parseInt(http_status.toString(), 10);
+ }
+ }
+ is.reset();
+ }
+
+ //
+ // See if we need to reconnect and send authorization.
+ //
+ switch( local_status )
+ {
+ //
+ // Not authorized.
+ //
+ case HTTP_UNAUTHORIZED: read_header();
+ return( local_status );
+ }
+ }
+ catch(IOException ioexception)
+ {
+ error = HTTP_ERROR;
+ throw ioexception;
+ }
+ return(0);
+ }
+
+
+
+
+
+
+ public int checkForResponse()
+ {
+ //
+ // Check for any response.
+ //
+ try
+ {
+ if (is.available() > 0)
+ {
+ StringBuffer http_version = new StringBuffer(32);
+ StringBuffer http_status = new StringBuffer(32);
+ StringBuffer http_text = new StringBuffer(256);
+ int local_status = 0;
+ String read_buffer;
+
+ status = 0;
+ is.mark(8192);
+ while (is.available() > 0)
+ {
+ read_buffer = read_line();
+ if (read_buffer.startsWith("HTTP/"))
+ {
+ int i,n;
+ String s2 = read_buffer.substring(5);
+ for (i=0;(i < s2.length() && s2.charAt(i) != ' '); i++)
+ {
+ http_version.append(s2.charAt(i));
+ }
+ while (i < s2.length() && s2.charAt(i) == ' ')
+ i++;
+ for (;(i < s2.length() && s2.charAt(i) != '\n' &&
+ s2.charAt(i) != '\r' && s2.charAt(i) != ' '); i++)
+ {
+ http_status.append(s2.charAt(i));
+ }
+
+ while (i < s2.length() && s2.charAt(i) == ' ')
+ i++;
+ for (n=0;(n < 256 && i < s2.length() && s2.charAt(i) != '\n' &&
+ s2.charAt(i) != '\r' && s2.charAt(i) != ' '); i++)
+ {
+ http_text.append(s2.charAt(i));
+ }
+ local_status = Integer.parseInt(http_status.toString(), 10);
+ status = local_status;
+ }
+ }
+ is.reset();
+
+ //
+ // See if we need to reconnect and send authorization.
+ //
+ switch( local_status )
+ {
+ //
+ // Not authorized.
+ //
+ case HTTP_UNAUTHORIZED: read_header();
+ return( local_status );
+ }
+ }
+ }
+ catch (IOException e)
+ {
+ return(HTTP_ERROR);
+ }
+ return(0);
+ }
+
+
+ /**
+ * Write bytes to the output stream.
+ *
+ * @param bytes Array of bytes to write to the stream.
+ * @throw IOException
+ */
+ public void write(byte bytes[])
+ throws IOException
+ {
+ try
+ {
+ os.write(bytes, 0, bytes.length);
+ os.flush();
+ }
+ catch(IOException ioexception)
+ {
+ error = HTTP_ERROR;
+ throw ioexception;
+ }
+ }
+
+
+ /**
+ * Write bytes to the output stream.
+ *
+ * @param bytes Array of bytes to write to the stream.
+ * @param length Number of bytes to write to the stream.
+ * @throw IOException
+ */
+ public void write(byte bytes[], int length )
+ throws IOException
+ {
+ try
+ {
+ os.write(bytes, 0, length);
+ os.flush();
+ }
+ catch(IOException ioexception)
+ {
+ error = HTTP_ERROR;
+ throw ioexception;
+ }
+ }
+
+
+
+
+
+
+
+
+
+
+ /**
+ * Read the HTTP header from the input stream.
+ *
+ * @return <code>int</code> Content length of response.
+ * @return 0 Return zero on error.
+ * @throw IOException
+ */
+ public int read_header()
+ throws IOException
+ {
+ boolean done = false;
+ read_header_content_length = 0;
+
+ String read_buffer;
+ while (!done)
+ {
+ read_buffer = read_line();
+ if (read_buffer.startsWith("HTTP/"))
+ {
+ int i,n;
+ String s2 = read_buffer.substring(5);
+
+ StringBuffer http_version = new StringBuffer(32);
+ StringBuffer http_status = new StringBuffer(32);
+ StringBuffer http_text = new StringBuffer(256);
+
+ for (i=0;(i < s2.length() && s2.charAt(i) != ' '); i++)
+ {
+ http_version.append(s2.charAt(i));
+ }
+ while (i < s2.length() && s2.charAt(i) == ' ')
+ i++;
+ for (;(i < s2.length() && s2.charAt(i) != '\n' &&
+ s2.charAt(i) != '\r' && s2.charAt(i) != ' '); i++)
+ {
+ http_status.append(s2.charAt(i));
+ }
+
+ while (i < s2.length() && s2.charAt(i) == ' ')
+ i++;
+ for (n=0;(n < 256 && i < s2.length() && s2.charAt(i) != '\n' &&
+ s2.charAt(i) != '\r' && s2.charAt(i) != ' '); i++)
+ {
+ http_text.append(s2.charAt(i));
+ }
+ version = http_version.toString();
+ status = Integer.parseInt(http_status.toString(), 10);
+ status_text = http_text.toString();
+ }
+ else if (read_buffer.startsWith("WWW-Authenticate: Basic"))
+ {
+ String s2=read_buffer.substring("WWW-Authenticate: Basic".length());
+ auth_type = "basic";
+ }
+ else if (read_buffer.startsWith("WWW-Authenticate: Digest"))
+ {
+ String s2=read_buffer.substring("WWW-Authenticate: Digest".length());
+ auth_type = "digest";
+ parseAuthenticate(s2);
+ }
+ else if (read_buffer.startsWith("Content-Length:"))
+ {
+ String s2 = read_buffer.substring(15);
+ read_header_content_length = Integer.parseInt(s2.trim(), 10);
+ }
+ else if (read_buffer.startsWith("Content-Language:"))
+ {
+ String s3 = read_buffer.substring(17);
+ read_header_content_language = s3.trim();
+ }
+ else if (read_buffer.startsWith("Server:"))
+ {
+ String s4 = read_buffer.substring(7);
+ read_header_server = s4.trim();
+ }
+ else if (read_buffer.startsWith("Date:"))
+ {
+ String s5 = read_buffer.substring(5);
+ read_header_date = s5.trim();
+ }
+ else if (read_buffer.length() == 0)
+ {
+ done = true;
+ return( read_header_content_length );
+ }
+ }
+ return( 0 );
+ }
+
+
+
+ /**
+ * Read a line from the input stream.
+ *
+ * @return <code>String</code> Line read.
+ * @throw <code>IOException</code>
+ */
+ public String read_line()
+ throws IOException
+ {
+ StringBuffer sb = new StringBuffer();
+ int c = 0;
+
+ try
+ {
+ while ((c != -1) && (c != 10))
+ {
+ c = is.read();
+ switch( c )
+ {
+ case -1:
+ case 10:
+ case 13:
+ break;
+
+ default: sb.append((char)c);
+ }
+ }
+ }
+ catch (IOException e)
+ {
+ throw(e);
+ }
+ return(sb.toString());
+ }
+
+
+
+
+
+ /**
+ * Read up to <code>count</code> bytes from the input stream.
+ *
+ * @param <code>count</code> Number of bytes to read.
+ * @return <code>char[]</code> Character array of data read.
+ * @throw <code>IOException</code>
+ */
+ public char[] read(int count)
+ throws IOException
+ {
+ char ac[] = new char[count];
+ int j = 0;
+ try
+ {
+ for (int k = is.read(); k != -1 && j < count; k = is.read())
+ {
+ ac[j++] = (char)k;
+ }
+ }
+ catch(IOException ioexception)
+ {
+ throw ioexception;
+ }
+ return(ac);
+ }
+
+
+ /**
+ * Process the HTTP response from the server.
+ *
+ * @return <code>IPP</code> IPP object containing response data.
+ * @see <code>IPP</code>
+ * @see <code>IPPRequest</code>
+ * @see <code>IPPAttribute</code>
+ * @see <code>IPPValue</code>
+ * @see <code>IPPDefs</code>
+ */
+ public IPP processResponse()
+ {
+ IPP ipp;
+ IPPAttribute attr; // temp attribute
+ IPPValue val; // temp value
+
+ short vtag; // Current value tag
+ short gtag; // Current group tag
+
+ char[] buffer;
+
+ ipp = new IPP();
+ ipp.request = new IPPRequest();
+
+ int read_buffer_bytes = read_buffer.length;
+ int read_buffer_remaining = read_buffer_bytes;
+ int bufferidx = 0;
+ int n;
+
+
+ ipp.current = -1; // current attritue??
+ ipp.last = -1; // last attr?
+ attr = null;
+ buffer = read_buffer;
+ gtag = -1;
+ vtag = -1;
+
+
+ // ---------------------------------------------------------------
+ // State machine to process response.
+ //
+ ipp.state = IPPDefs.IDLE;
+ while ((ipp.state != IPPDefs.TAG_END) &&
+ (read_buffer_remaining > 0))
+ {
+ switch (ipp.state)
+ {
+ case IPPDefs.IDLE :
+ ipp.state++; /* Avoid common problem... */
+
+ //
+ // Get the request header...
+ //
+ case IPPDefs.HEADER :
+ if (read_buffer_remaining < 8)
+ {
+ return (null);
+ }
+
+ //
+ // Verify the major version number...
+ //
+ if (buffer[0] != (char)1)
+ {
+ return (null);
+ }
+
+ //
+ // Then copy the request header over...
+ //
+ ipp.request.version[0] = buffer[bufferidx++];
+ ipp.request.version[1] = buffer[bufferidx++];
+ ipp.request.op_status = (short)((short)buffer[bufferidx] << 8) |
+ (short)buffer[bufferidx+1];
+ bufferidx += 2;
+
+ //
+ // Get the text version of the request status ....
+ //
+ ipp.status = new IPPStatus(ipp.request.op_status);
+
+ ipp.request.request_id = (int)((int)buffer[bufferidx] << 24) |
+ ((int)buffer[bufferidx+1] << 16) |
+ ((int)buffer[bufferidx+2] << 8) |
+ ((int)buffer[bufferidx+3]);
+ bufferidx += 4;
+ read_buffer_remaining -= 8;
+
+ ipp.state = IPPDefs.ATTRIBUTE;
+ ipp.current = -1;
+ ipp.current_tag = IPPDefs.TAG_ZERO;
+ break;
+
+ case IPPDefs.ATTRIBUTE :
+ while (read_buffer_remaining > 0)
+ {
+ //
+ // Read the value tag first.
+ //
+ vtag = (short)buffer[bufferidx++];
+ read_buffer_remaining--;
+ if (vtag == IPPDefs.TAG_END)
+ {
+ //
+ // No more attributes left...
+ //
+ ipp.state = IPPDefs.DATA;
+ if (attr != null)
+ {
+ ipp.addAttribute(attr);
+ attr = null;
+ }
+ break;
+ }
+ else if (vtag < IPPDefs.TAG_UNSUPPORTED_VALUE)
+ {
+ if (attr != null)
+ {
+ ipp.addAttribute(attr);
+ }
+
+ //
+ // Group tag... Set the current group and continue...
+ //
+ gtag = vtag;
+
+ // If still the same group ....
+ if (ipp.current_tag == gtag)
+ {
+ //
+ // Add a separator
+ //
+ attr = new IPPAttribute(IPPDefs.TAG_ZERO,IPPDefs.TAG_ZERO,"");
+ ipp.addAttribute(attr);
+ attr = null;
+ }
+
+
+ ipp.current_tag = gtag;
+ ipp.current = -1;
+ continue;
+ }
+
+ //
+ // Get the name...
+ //
+ n = ((int)buffer[bufferidx] << 8) | (int)buffer[bufferidx+1];
+ bufferidx += 2;
+ read_buffer_remaining -= 2;
+
+ if (n == 0)
+ {
+ //
+ // Parse Error, can't add additional values to null attr
+ //
+ if (attr == null)
+ return (null);
+
+ //
+ // More values for current attribute...
+ //
+
+ //
+ // Make sure we aren't adding a new value of a different
+ // type...
+ //
+
+ if (attr.value_tag == IPPDefs.TAG_STRING ||
+ (attr.value_tag >= IPPDefs.TAG_TEXTLANG &&
+ attr.value_tag <= IPPDefs.TAG_MIMETYPE))
+ {
+ //
+ // String values can sometimes come across in different
+ // forms; accept sets of differing values...
+ //
+ if (vtag != IPPDefs.TAG_STRING &&
+ (vtag < IPPDefs.TAG_TEXTLANG || vtag > IPPDefs.TAG_MIMETYPE))
+ return (null);
+ }
+ else if (attr.value_tag != vtag)
+ return (null);
+ }
+ else
+ {
+ if (attr != null)
+ {
+ ipp.addAttribute(attr);
+ attr = null;
+ }
+
+ //
+ // New Attribute
+ //
+ StringBuffer s = new StringBuffer();
+ for (int i=0; i < n; i++)
+ {
+ s.append((char)buffer[bufferidx++]);
+ read_buffer_remaining--;
+ }
+ attr = new IPPAttribute( gtag, vtag, s.toString() );
+ }
+ n = ((short)buffer[bufferidx] << 8) | (short)buffer[bufferidx+1];
+ bufferidx += 2;
+ read_buffer_remaining -= 2;
+
+ switch (vtag)
+ {
+ case IPPDefs.TAG_INTEGER :
+ case IPPDefs.TAG_ENUM :
+ n = (int)(((int)buffer[bufferidx] << 24) |
+ ((int)buffer[bufferidx+1] << 16) |
+ ((int)buffer[bufferidx+2] << 8) |
+ ((int)buffer[bufferidx+3]));
+ bufferidx += 4;
+ read_buffer_remaining -= 4;
+ attr.addInteger( n );
+ break;
+
+ case IPPDefs.TAG_BOOLEAN :
+ if ((byte)buffer[bufferidx++] > 0)
+ attr.addBoolean(true);
+ else
+ attr.addBoolean(false);
+ read_buffer_remaining --;
+ break;
+
+ case IPPDefs.TAG_TEXT :
+ case IPPDefs.TAG_NAME :
+ case IPPDefs.TAG_KEYWORD :
+ case IPPDefs.TAG_STRING :
+ case IPPDefs.TAG_URI :
+ case IPPDefs.TAG_URISCHEME :
+ case IPPDefs.TAG_CHARSET :
+ case IPPDefs.TAG_LANGUAGE :
+ case IPPDefs.TAG_MIMETYPE :
+ StringBuffer s = new StringBuffer();
+ for (int i=0; i < n; i++ )
+ {
+ s.append( (char)buffer[bufferidx++] );
+ read_buffer_remaining --;
+ }
+ attr.addString( "", s.toString() );
+ break;
+
+
+ case IPPDefs.TAG_DATE :
+ char db[] = new char[11];
+ for (int i=0; i < 11; i++ )
+ {
+ db[i] = (char)buffer[bufferidx++];
+ read_buffer_remaining --;
+ }
+ attr.addDate( db );
+ break;
+
+
+ case IPPDefs.TAG_RESOLUTION :
+ if (read_buffer_remaining < 9)
+ return( null );
+
+ int x, y;
+ byte u;
+ x = (int)(((int)buffer[bufferidx] & 0xff000000) << 24) |
+ (((int)buffer[bufferidx+1] & 0x00ff0000) << 16) |
+ (((int)buffer[bufferidx+2] & 0x0000ff00) << 8) |
+ (((int)buffer[bufferidx+3] & 0x000000ff));
+ bufferidx += 4;
+ read_buffer_remaining -= 4;
+
+ y = (int)(((int)buffer[bufferidx] & 0xff000000) << 24) |
+ (((int)buffer[bufferidx+1] & 0x00ff0000) << 16) |
+ (((int)buffer[bufferidx+2] & 0x0000ff00) << 8) |
+ (((int)buffer[bufferidx+3] & 0x000000ff));
+ bufferidx += 4;
+ read_buffer_remaining -= 4;
+
+ u = (byte)buffer[bufferidx++];
+ read_buffer_remaining--;
+ attr.addResolution( u, x, y );
+ break;
+
+ case IPPDefs.TAG_RANGE :
+ if (read_buffer_remaining < 8)
+ return (null);
+
+ int lower, upper;
+ lower = (int)(((int)buffer[bufferidx] & 0xff000000) << 24) |
+ (((int)buffer[bufferidx+1] & 0x00ff0000) << 16) |
+ (((int)buffer[bufferidx+2] & 0x0000ff00) << 8) |
+ (((int)buffer[bufferidx+3] & 0x000000ff));
+ bufferidx += 4;
+ read_buffer_remaining -= 4;
+
+ upper = (int)(((int)buffer[bufferidx] & 0xff000000) << 24) |
+ (((int)buffer[bufferidx+1] & 0x00ff0000) << 16) |
+ (((int)buffer[bufferidx+2] & 0x0000ff00) << 8) |
+ (((int)buffer[bufferidx+3] & 0x000000ff));
+ bufferidx += 4;
+ read_buffer_remaining -= 4;
+
+ attr.addRange( (short)lower, (short)upper );
+ break;
+
+ case IPPDefs.TAG_TEXTLANG :
+ case IPPDefs.TAG_NAMELANG :
+ //
+ // text-with-language and name-with-language are composite
+ // values:
+ //
+ // charset-length
+ // charset
+ // text-length
+ // text
+ //
+
+ n = ((int)buffer[bufferidx] << 8) | (int)buffer[bufferidx+1];
+ bufferidx += 2;
+
+ StringBuffer cs = new StringBuffer();
+ for (int i=0; i < n; i++ )
+ {
+ cs.append( (char)buffer[bufferidx++] );
+ read_buffer_remaining --;
+ }
+
+ n = ((int)buffer[bufferidx] << 8) | (int)buffer[bufferidx+1];
+ bufferidx += 2;
+
+ StringBuffer tx = new StringBuffer();
+ for (int i=0; i < n; i++ )
+ {
+ tx.append( (char)buffer[bufferidx++] );
+ read_buffer_remaining --;
+ }
+
+ attr.addString( cs.toString(), tx.toString() );
+ break;
+
+
+ default : /* Other unsupported values */
+ if (n > 0)
+ {
+ bufferidx += n;
+ read_buffer_remaining -= n;
+ }
+ break;
+ }
+ } // End of while
+
+ if (attr != null)
+ {
+ ipp.addAttribute(attr);
+ attr = null;
+ }
+ break;
+
+ case IPPDefs.DATA :
+ break;
+
+ default :
+ break; /* anti-compiler-warning-code */
+ }
+ }
+ return (ipp);
+}
+
+
+
+//
+// Parse a WWW-Authenticate: Digest request
+//
+public void parseAuthenticate( String p_auth )
+{
+ String tmp;
+ StringBuffer val;
+ int i,n;
+
+ tmp = p_auth;
+ while (tmp.length() > 0)
+ {
+ i = 0;
+ while (tmp.length() > 0 && (tmp.charAt(i) == ' ' || tmp.charAt(i) == '"'))
+ tmp = tmp.substring(1);
+ i = 0;
+
+ if (tmp.startsWith("realm="))
+ {
+ i = "realm=".length();
+ tmp = tmp.substring(i);
+ i = 0;
+ while ((i < tmp.length()) &&
+ (tmp.charAt(i) == ' ' ||
+ tmp.charAt(i) == '"' ||
+ tmp.charAt(i) == '='))
+ {
+ i++;
+ }
+ val = new StringBuffer(1024);
+ while (i < tmp.length() && tmp.charAt(i) != '"')
+ val.append(tmp.charAt(i++));
+ realm = val.toString();
+ tmp = tmp.substring(i);
+ }
+ else if (tmp.startsWith("nonce="))
+ {
+ i = "nonce=".length();
+ tmp = tmp.substring(i);
+ i = 0;
+ while ((i < tmp.length()) &&
+ (tmp.charAt(i) == ' ' ||
+ tmp.charAt(i) == '"' ||
+ tmp.charAt(i) == '='))
+ {
+ i++;
+ }
+ val = new StringBuffer(1024);
+ while (i < tmp.length() && tmp.charAt(i) != '"')
+ val.append(tmp.charAt(i++));
+ nonce = val.toString();
+ tmp = tmp.substring(i);
+ }
+ else if (tmp.startsWith("opaque="))
+ {
+ i = "opaque=".length();
+ tmp = tmp.substring(i);
+ i = 0;
+ while ((i < tmp.length()) &&
+ (tmp.charAt(i) == ' ' ||
+ tmp.charAt(i) == '"' ||
+ tmp.charAt(i) == '='))
+ {
+ i++;
+ }
+ val = new StringBuffer(1024);
+ while (i < tmp.length() && tmp.charAt(i) != '"')
+ val.append(tmp.charAt(i++));
+ opaque = val.toString();
+ tmp = tmp.substring(i);
+ }
+ else
+ {
+ StringBuffer name = new StringBuffer(256);
+ while ((i < tmp.length()) &&
+ (tmp.charAt(i) != ' ' ||
+ tmp.charAt(i) != '"' ||
+ tmp.charAt(i) != '='))
+ {
+ name.append(tmp.charAt(i++));
+ }
+
+ i = name.toString().length();
+ tmp = tmp.substring(i);
+ i = 0;
+ while ((i < tmp.length()) &&
+ (tmp.charAt(i) == ' ' ||
+ tmp.charAt(i) == '"' ||
+ tmp.charAt(i) == '='))
+ {
+ i++;
+ }
+ val = new StringBuffer(1024);
+ while (i < tmp.length() && tmp.charAt(i) != '"')
+ val.append(tmp.charAt(i++));
+ //junk = val.toString();
+ tmp = tmp.substring(i);
+ }
+ }
+}
+
+
+
+
+
+} // End of IPPHttp class
+
+
projects / thirdparty / cups.git / blobdiff