wapcodepage.java

WAP协议栈的JAVA实现

                    Encoding.shortInteger(code.shortValue())));
        } else {
            hdrs.write(Encoding.encodeHeader(wk, Encoding.tokenText(value)));
        }
    }

    public void encodeContentLength(OutputStream hdrs, short wk, String value)
        throws IOException {
        hdrs.write(Encoding.encodeHeader(wk,
                Encoding.integerValue(Long.parseLong(value))));
    }

    public void encodeContentType(OutputStream hdrs, short wk, String value)
        throws IOException {
        TransTable wkp = TransTable.getTable("wk-params-1.3");

        // tokenize header-value
        Enumeration e = HeaderToken.tokenize(value);
        HeaderToken token = (HeaderToken) e.nextElement();
        String contentType = token.getToken();
        Integer code = TransTable.getTable("content-types").str2code(contentType);

        // set primary value
        byte[] ctv = null;

        if (code == null) {
            //ctv=Encoding.textString(value);
            ctv = Encoding.textString(token.getToken());
        } else {
            ctv = Encoding.shortInteger(code.shortValue());
        }

        // handle parameters
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        String type = token.getParameter("type");

        if (type != null) {
            // If the content-type is application/vnd.wap.multipart.related,
            // type encoding differs...
            StringBuffer sb = new StringBuffer("type");
            if( "application/vnd.wap.multipart.related".equalsIgnoreCase(contentType) ) {
                sb.append("[MPR]");   
            }
            // TODO: not always be encoded as String (might be Constrained-encoding)
            out.write(Encoding.encodeHeader(wkp.str2code(sb.toString()).shortValue(),
                Encoding.textString(type)));
        }

        String start = token.getParameter("start");

        if (start != null) {
            out.write(Encoding.encodeHeader(wkp.str2code("start").shortValue(),
                Encoding.textString(start)));
        }

        String name = token.getParameter("name");

        if (name != null) {
            out.write(Encoding.encodeHeader(wkp.str2code("name").shortValue(),
                    Encoding.textString(name)));
        }

        String charset = token.getParameter("charset");

        if (charset != null) {
            Integer wkl = TransTable.getTable("charsets").str2code(charset);
            short cwk = wkp.str2code("charset").shortValue();
            if( wkl == null ) {
                out.write(Encoding.encodeHeader(cwk, Encoding.textString(charset)));
            } else {
                out.write(Encoding.encodeHeader(cwk, Encoding.integerValue(wkl.longValue())));
            }
        }

        // create header
        byte[] params = out.toByteArray();

        if (params.length == 0) {
            hdrs.write(Encoding.encodeHeader(wk, ctv));
        } else {
            byte[] length = Encoding.uintVar(params.length + ctv.length);
            byte[] head = new byte[length.length + params.length + ctv.length];

            System.arraycopy(length, 0, head, 0, length.length);
            System.arraycopy(ctv, 0, head, length.length, ctv.length);
            System.arraycopy(params, 0, head, (ctv.length + length.length),
                params.length);

            hdrs.write(Encoding.encodeHeader(wk, head));
        }
    }

    public void encodeContentDisposition(OutputStream hdrs, short wk,
        String value) throws IOException {
        if (value != null) {
            if (value.toUpperCase().equals("FORM-DATA")) {
                hdrs.write(Encoding.encodeHeader(wk,
                        new byte[] { 1, (byte) 128 }));
            } else if (value.toUpperCase().equals("ATTACHMENT")) {
                hdrs.write(Encoding.encodeHeader(wk,
                        new byte[] { 1, (byte) 129 }));
            } else if (value.toUpperCase().equals("INLINE")) {
                hdrs.write(Encoding.encodeHeader(wk,
                        new byte[] { 1, (byte) 130 }));
            } else {
                // Token-Text
                byte[] tt = Encoding.tokenText(value);
                byte[] ln = Encoding.valueLength(tt);
                byte[] lt = new byte[ln.length + tt.length];
                System.arraycopy(ln, 0, lt, 0, ln.length);
                System.arraycopy(tt, 0, lt, ln.length, tt.length);

                hdrs.write(Encoding.encodeHeader(wk, lt));
            }
        }
    }

    public void encodeFrom(OutputStream hdrs, short wk, String value)
        throws IOException {
        if (value == null) {
            return;
        }

        hdrs.write(Encoding.encodeHeader(wk, Encoding.textString(value.trim())));
    }

    public void encodeHost(OutputStream hdrs, short wk, String value)
        throws IOException {
        if (value == null) {
            return;
        }

        hdrs.write(Encoding.encodeHeader(wk, Encoding.textString(value.trim())));
    }

    public void encodeIfMatch(OutputStream hdrs, short wk, String value)
        throws IOException {
        if (value == null) {
            return;
        }

        hdrs.write(Encoding.encodeHeader(wk, Encoding.textString(value.trim())));
    }

    public void encodeIfNonMatch(OutputStream hdrs, short wk, String value)
        throws IOException {
        if (value == null) {
            return;
        }

        hdrs.write(Encoding.encodeHeader(wk, Encoding.textString(value.trim())));
    }

    public void encodeIfRange(OutputStream hdrs, short wk, String value)
        throws IOException {
        if (value == null) {
            return;
        }

        hdrs.write(Encoding.encodeHeader(wk, Encoding.textString(value.trim())));
    }

    public void encodeMaxForwards(OutputStream hdrs, short wk, String value)
        throws IOException {
        if (value == null) {
            return;
        }

        hdrs.write(Encoding.encodeHeader(wk,
                Encoding.integerValue(Long.parseLong(value))));
    }

    public void encodeReferer(OutputStream hdrs, short wk, String value)
        throws IOException {
        if (value == null) {
            return;
        }

        hdrs.write(Encoding.encodeHeader(wk, Encoding.uriValue(value.trim())));
    }

    public void encodeUserAgent(OutputStream hdrs, short wk, String value)
        throws IOException {
        if (value == null) {
            return;
        }

        hdrs.write(Encoding.encodeHeader(wk, Encoding.textString(value.trim())));
    }

    public Header decode(byte[] data) throws HeaderParseException, IOException {
        WSPDecoder d = new WSPDecoder(data);
        int c1 = d.getUint8();
        String key = null;
        String val = null;

        if ((c1 & 0x80) != 0) {
            c1 = c1 & 0x7f;
            key = transTable.code2str(c1);

            byte[] fieldValue = d.getBytes(data.length - 1);

            try {
                val = decodeHeaderField(key, fieldValue);
            } catch( NoSuchMethodException nsme ) {
                log.warn("'"+key+"': Header decoding not yet implemented :-(");
            } catch (Exception e) {
                log.warn("Unable to decode header " + key, e);
            }
        } else {
            d.seek(-1);
            key = d.getCString();
            val = d.getCString();
        }

        return new Header(key, val);
    }

    public String decodeAcceptLanguage(byte[] data) throws IOException {
        WSPDecoder d = new WSPDecoder(data);
        String retval = null;

        int c1 = d.getUint8();

        if (c1 > 31) {
            // Constrained encoding
            if ((c1 & 0x80) != 0) {
                // Short integer
                c1 = c1 & 0x7f;
                retval = TransTable.getTable("languages").code2str(c1);
            } else {
                d.seek(-1);
                retval = d.getCString();
            }
        } else {
            // General form 
        }

        return retval;
    }
    
    public String decodeDate(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        Date dt = d.getDateValue();
        return fmt.format(dt);
    }
    
    public String decodeServer(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        return d.getTextString();
    }
    
    public String decodeContentLength(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        return Long.toString(d.getIntegerValue());
    }

    public String decodeContentType(byte[] data) {
        String retval = null;
        WSPDecoder d = new WSPDecoder(data);
        int o = d.getUint8();
        if( o <= 31 ) { // General Form
          d.seek(-1);
          long len = d.getValueLength();
          o = d.getUint8();
          if( (o & 0x80) != 0 ) {
              // Short-Integer
              short wk = (short) (o&0x7f);
              retval = TransTable.getTable("content-types").code2str(wk);            
          } else if( o <= 30 ) { // long-integer
              d.seek(-1);
              int wk = (int) d.getLongInteger();
              retval = TransTable.getTable("content-types").code2str(wk);            
          } else { // *TEXT EOF
              d.seek(-1);
              retval = d.getTextString();
          }
          byte[] params = d.getBytes(d.getRemainingOctets());
          if( params.length > 0 ) {
            log.warn("decodeContentType: parameter decoding not yet supported"); 
          }
        } else { // Constrained encoding
          if( (o & 0x80) != 0 ) { // Short integer
            short wk = (short) (o&0x7f);
            retval = TransTable.getTable("content-types").code2str(wk);            
          } else { // *Text EOF 
            d.seek(-1);
            retval = d.getTextString();
          }
        }
        return retval;
    }
    
    public String decodeConnection(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        int o = d.getUint8();
        if( o == 128 ) {
            return "CLOSE";   
        }
        d.seek(-1);
        return d.getCString();
    }
    
    public String decodeVia(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        return d.getTextString();
    }    

    public String decodeWarning(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        int o = d.getUint8(), code=0;
        String agent = null, txt = null;
        
        if( (o & 0x80) != 0  ) {
            // Warn-Code
            code = o & 0x7f;
        } else {
            d.getValueLength();
            code = d.getShortInteger();
            agent = d.getTextString();
            txt = d.getTextString();   
        }
        String cTxt = null;
        switch( code ) {
            case 10: cTxt = "110 Response is stale"; break;
            case 11: cTxt = "111 Revalidation failed"; break;
            case 12: cTxt = "112 Disconnected operation"; break;
            case 13: cTxt = "113 Heuristic expiration"; break;
            case 99: cTxt = "199 Miscellaneous (persistent) warning"; break;
            case 14: cTxt = "214 Transformation applied"; break;
            default: cTxt = Integer.toString(code);
        }
        StringBuffer sb = new StringBuffer(cTxt);
        if( agent != null ) {
            sb.append("; agent=\"").append(agent).append('"');
        }
        if( txt != null ) {
            sb.append("; text=").append(txt);
        }
        return sb.toString();
    }    
    
    public String decodeExpires(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        Date dt = d.getDateValue();
        return fmt.format(dt); 
    }
    
    public String decodeCacheControl(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        String ret = null;

        int o = d.getUint8();
        if( o  <= 31 ) { // value-length cache-directive
            log.warn("decoding cache-control (value-length cache-directive) not yet implemented");
        } else  if( (o & 0x80) != 0 ) {
            ret = TransTable.getTable("cache-control").code2str(o);
        } else { // Token-Text
            ret = d.getCString();
        }
        return ret;
    }
}