wapcodepage.java

WAP Stack implementation jwap.sourceforge.net

            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);
            if(log.isDebugEnabled()) {
              log.debug("code2str(0x"+Integer.toHexString(c1)+")="+key);
            }

            byte[] fieldValue = d.getBytes(data.length - 1);
             
            if(key == null ) {
                key="0x"+Integer.toHexString(c1);
                log.warn(key+": unknown header");
            } else {
                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(TT_LNG).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 decodeContentId(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        // remove quote
        d.seek(1);
        return d.getCString();
    }
    
    public String decodeContentDisposition(byte[] data) {
        StringBuffer sb = new StringBuffer();
        WSPDecoder d = new WSPDecoder(data);
        long l = d.getValueLength();
        int o = d.getUint8();
        switch(o) {
            case 128:
                sb.append("Form-Data");
                break;
            case 129:
                sb.append("Attachment");
                break;
            case 130:
                sb.append("Inline");
                break;
            default:
                d.seek(-1);
                sb.append(d.getTextString());
                break;
        }
        // TODO Parse parameters...
        byte[] parms = d.getBytes(d.getRemainingOctets());
        return sb.toString();
    }
    
    public String decodeContentLength(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        return Long.toString(d.getIntegerValue());
    }
    
    public String decodeContentLocation(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        return d.getCString();
    }
    
    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();
          if( len == 0 ) {
            	return "";
          }
          o = d.getUint8();
          if( (o & 0x80) != 0 ) {
              // Short-Integer
              short wk = (short) (o&0x7f);
              retval = TransTable.getTable(TT_CTYPES).code2str(wk);            
          } else if( o <= 30 ) { // long-integer
              d.seek(-1);
              int wk = (int) d.getLongInteger();
              retval = TransTable.getTable(TT_CTYPES).code2str(wk);            
          } else { // *TEXT EOF
              d.seek(-1);
              retval = d.getTextString();
          }
          byte[] params = d.getBytes(d.getRemainingOctets());
          if( params.length > 0 ) {
              WSPDecoder param = new WSPDecoder(params);
              StringBuffer buf = new StringBuffer();
              buf.append(retval);
              while( !param.isEOF() ) {
                  String code = null;
                  try {
                      int c = (int) param.getIntegerValue();
                      TransTable wkp = TransTable.getTable(TT_WKPARMS);
                      code = wkp.code2str((int)c);
                      String val= null;
                      switch(c){
                          case 0x01: // charset
                            int charset = param.getUint8();
                            if( (charset & 0x80) != 0 ) { // Short integer
                                charset = charset & 0x7f;
                                // Lookup charset
                                val = TransTable.getTable(TT_CHARSETS).code2str(charset);
                            } 
                            break;
                          case 0x05: // name version 1.1
                          case 0x06: // fileName version 1.1
                          case 0x07: // name version 1.4
                          case 0x08: // fileName version 1.4
                          case 0x09: // type
                          case 0x0A: // start
                          case 0x0B: // start info
                          case 0x0C: // comment
                          case 0x0D: // domain
                          case 0x0F: // path
                          case 0x12: // MAC
                            val = param.getCString();
                            break;
                      }
                      if( val!=null ) {
                        buf.append("; ").append(code).append("=").append(val);
                      }
                  } catch (Exception e){
                      log.info("decodeContentType: parameter decoding failed, ignoring parameter "+code,e);
                  }
              }
              retval = buf.toString();
          }
        } else { // Constrained encoding
          if( (o & 0x80) != 0 ) { // Short integer
            short wk = (short) (o&0x7f);
            retval = TransTable.getTable(TT_CTYPES).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(TT_CCONTROL).code2str(o);
        } else { // Token-Text
            ret = d.getCString();
        }
        return ret;
    }

    public String decodeLocation(byte[] data) {
        WSPDecoder d = new WSPDecoder(data);
        return d.getTextString();
    }
}