wapcodepage.java

WAP Stack implementation jwap.sourceforge.net

                    hdrs.write(Encoding.encodeHeader(wk,
                            Encoding.extensionMedia(token)));
                }
            } else {
                float q = Float.parseFloat(qf);
                byte[] qb = Encoding.qualityFactor(q);
                byte[] lng = null;

                if (wkl != null) {
                    lng = Encoding.shortInteger(wkl.shortValue());
                } else {
                    lng = Encoding.textString(value);
                }

                byte[] dt = new byte[qb.length + lng.length + 1];
                dt[0] = (byte) (qb.length + lng.length);
                System.arraycopy(lng, 0, dt, 1, lng.length);
                System.arraycopy(qb, 0, dt, lng.length + 1, qb.length);
                hdrs.write(Encoding.encodeHeader(wk, dt));
            }
        }
    }

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

        String nv = value.toLowerCase().trim();

        if ("none".equals(nv)) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[] { (byte) 128 }));
        } else if ("bytes".equals(nv)) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[] { (byte) 129 }));
        } else {
            hdrs.write(Encoding.encodeHeader(wk, Encoding.tokenText(value)));
        }
    }

    public void encodeCacheControl(OutputStream hdrs, short wk, String value)
        throws IOException 
    {
        if(value==null) {
            return;
        }
        value = value.trim();
        if( "".equals(value) ) {
            return;
        }
        String nv = value.toLowerCase();
        
        int epos = nv.indexOf('=');
        String arg = null;
        if( epos > 0 ) {
            arg = nv.substring(epos+1);
            nv  = nv.substring(0,epos);
        }
        if( "no-cache".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[]{(byte) 128}));
        } else if( "no-store".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[]{(byte) 129}));
        } else if( "only-if-cached".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[]{(byte) 133}));
        } else if( "public".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[]{(byte) 134}));
        } else if( "private".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[]{(byte) 135}));
        } else if( "no-transform".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[]{(byte) 136}));
        } else if( "must-revalidate".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[]{(byte) 137}));
        } else if( "proxy-revalidate".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[]{(byte) 138}));
        } else if( "max-age".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, deltaSeconds((byte) 130,arg)));
        } else if( "max-stale".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, deltaSeconds((byte) 131,arg)));
        } else if( "min-fresh".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, deltaSeconds((byte) 132,arg)));
        } else if( "s-maxage".equals(nv) ) {
            hdrs.write(Encoding.encodeHeader(wk, deltaSeconds((byte) 139,arg)));
        } else {
          hdrs.write(Encoding.encodeHeader(wk, Encoding.tokenText(value)));
        }
    }
    
    private byte[] deltaSeconds(byte token, String arg) {
      long ds = Long.parseLong(arg);
      byte[] iv = Encoding.integerValue(ds);
      byte[] bytes = new byte[iv.length+1];
      System.arraycopy(bytes,0, bytes,1,iv.length);
      bytes[0]=token;
      return bytes;
    }
    
    public void encodeConnection(OutputStream hdrs, short wk, String value)
        throws IOException {
        if ( value != null && "CLOSE".equalsIgnoreCase(value.trim())) {
            hdrs.write(Encoding.encodeHeader(wk, new byte[] { (byte) 128 }));
        } else {
            hdrs.write(Encoding.encodeHeader(wk, Encoding.tokenText(value)));
        }
    }

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

        Integer code = TransTable.getTable(TT_CTENC).str2code(value.trim());

        if (code != null) {
            hdrs.write(Encoding.encodeHeader(wk,
                    new byte[] { (byte) (code.intValue() & 0xff) }));
        } else {
            hdrs.write(Encoding.encodeHeader(wk, Encoding.tokenText(value)));
        }
    }

    
    public void encodeContentId(OutputStream hdrs, short wk, String value)
    throws IOException {
        hdrs.write(Encoding.encodeHeader(wk, Encoding.quotedString(value)));
    }
    
    public void encodeContentLanguage(OutputStream hdrs, short wk, String value)
        throws IOException {
        if (value == null) {
            return;
        }

        Integer code = TransTable.getTable(TT_LNG).str2code(value.trim());

        if (code != null) {
            hdrs.write(Encoding.encodeHeader(wk,
                    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 encodeContentLocation(OutputStream hdrs, short wk, String value)
        throws IOException {
        hdrs.write(Encoding.encodeHeader(wk, Encoding.textString(value)));
    }

    public void encodeContentType(OutputStream hdrs, short wk, String value)
        throws IOException {
      
        TransTable wkp = TransTable.getTable(TT_WKPARMS);
        // tokenize header-value
        Enumeration e = HeaderToken.tokenize(value);
        HeaderToken token = (HeaderToken) e.nextElement();
        String contentType = token.getToken();
        Integer code = TransTable.getTable(TT_CTYPES).str2code(contentType);

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

        if (code == null) {
            ctv = Encoding.textString(contentType);            
        } else {
            ctv = Encoding.shortInteger(code.shortValue());
        }

        // handle parameters
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        String type = token.getParameter("type");
        if (type == null) { 
            type = token.getParameter("type[mpr]");
        }

        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: contentType parameters are not always 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) {
            // Replace _ with -
            String cset = charset.replace('_','-');
            Integer wkl = TransTable.getTable(TT_CHARSETS).str2code(cset);
            short cwk = wkp.str2code("charset").shortValue();
            if( wkl != null ) {
                out.write(Encoding.encodeHeader(cwk, Encoding.shortInteger(wkl.shortValue())));
            } else {
                log.warn(charset+": Ignoring unknown charset");
            }
        }

        // 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) {