packet.java

Open DMT GPS server source code

        if ((t >= PKT_CLIENT_DMTSP_FMT_0) && (t <= PKT_CLIENT_DMTSP_FMT_F)) {
            return true;
        } else {
            return false;
        }
    }
    
    public static boolean isFixedEventType(int t)
    {
        if ((t == PKT_CLIENT_FIXED_FMT_STD) || (t == PKT_CLIENT_FIXED_FMT_HIGH)) {
            return true;
        } else {
            return false;
        }
    }
    
    public static boolean isCustomEventType(int t)
    {
        if ((t >= PKT_CLIENT_CUSTOM_FORMAT_0) && (t <= PKT_CLIENT_CUSTOM_FORMAT_F)) {
            return true;
        } else {
            return false;
        }
    }

    // ------------------------------------------------------------------------

    public boolean hasAsciiChecksum()
    {
        return this.hasAsciiChecksum;
    }
    
    // ------------------------------------------------------------------------

    public int getPacketLength()
    {
        return MIN_HEADER_LENGTH + this.getPayloadLength();
    }

    public int getPayloadLength()
    {
        return this.payload.getSize();
    }
    
    public boolean hasPayload()
    {
        return (this.getPayloadLength() > 0);
    }

    public Payload getPayload(boolean reset)
    {
        if (reset) {
            // make Payload a data source
            this.payload.resetIndex();
        }
        return this.payload;
    }
    
    public PayloadTemplate getPayloadTemplate()
    {
        if (this.isClient) {
            if (this.payloadTemplate != null) {
                return this.payloadTemplate;
            } else {
                PayloadTemplate plt = GetClientPayloadTemplate(this.type);
                if ((plt == null) && (this.deviceId != null)) {
                    plt = this.deviceId.getClientPayloadTemplate(this.type); // may still return null
                    //if (plt == null) {
                    //    Print.logError("PayloadTemplate not found: " + StringTools.toHexString(this.type,8));
                    //}
                }
                this.payloadTemplate = plt;
                return plt;
            }
        } else {
            return GetServerPayloadTemplate(this.type);
        }
    }
    
    // ------------------------------------------------------------------------
    
    public byte[] getPayloadBytes(int ofs, int len)
    {
        byte b[] = this.getPayload(true).getBytes();
        if (ofs >= b.length) {
            return new byte[0];
        } else {
            if (len > (b.length - ofs)) { len = b.length - ofs; }
            byte n[] = new byte[len];
            System.arraycopy(b, ofs, n, 0, len);
            return n;
        }
    }
    
    // ------------------------------------------------------------------------

    public byte[] encode()
    {
        return this.encode(this.getEncoding());
    }
    
    public byte[] encode(int encoding)
    {
        byte payload[] = this.getPayload(true).getBytes();
        if (encoding == Encoding.ENCODING_BINARY) {
            int len = payload.length;
            byte pkt[] = new byte[MIN_HEADER_LENGTH + len];
            pkt[0] = (byte)(this.header & 0xFF);
            pkt[1] = (byte)(this.type & 0xFF);
            pkt[2] = (byte)(len & 0xFF);
            System.arraycopy(payload, 0, pkt, 3, len);
            return pkt;
        } else {
            StringBuffer sb = new StringBuffer();
            sb.append(Encoding.AsciiEncodingChar);
            sb.append(StringTools.toHexString((long)this.header & 0xFF, 8));
            sb.append(StringTools.toHexString((long)this.type   & 0xFF, 8));
            if (payload.length > 0) {
                switch (encoding) {
                    case Encoding.ENCODING_CSV_CKSUM   :
                    case Encoding.ENCODING_CSV         : {
                        //Print.logDebug("Encoding CSV ...");
                        sb.append(_encodeCSV(this));
                        break;
                    }
                    case Encoding.ENCODING_BASE64_CKSUM: 
                    case Encoding.ENCODING_BASE64      : {
                        //Print.logDebug("Encoding Base64 ...");
                        sb.append(Encoding.ENCODING_BASE64_CHAR); 
                        sb.append(Base64.encode(payload));
                        break;
                    }
                    case Encoding.ENCODING_HEX_CKSUM   : 
                    case Encoding.ENCODING_HEX         : {
                        //Print.logDebug("Encoding Hex ...");
                        sb.append(Encoding.ENCODING_HEX_CHAR); 
                        StringTools.toHexString(payload, sb);
                        break;
                    }
                    case Encoding.ENCODING_UNKNOWN     :
                    default                            : {
                        Print.logError("Unknown encoding: " + encoding);
                        //sb.append("?unknown_encoding?");
                        encoding = Encoding.ENCODING_HEX;
                        sb.append(Encoding.ENCODING_HEX_CHAR); 
                        StringTools.toHexString(payload, sb);
                        break;
                    }
                }
            } else {
                //sb.append(" <No Payload>");
            }
            
            /* add ASCII checksum */
            if (Encoding.IsEncodingChecksum(encoding)) {
                int cksum = CalcChecksum(StringTools.getBytes(sb.toString()));
                if (cksum >= 0) {
                    sb.append(Encoding.AsciiChecksumChar);
                    sb.append(StringTools.toHexString((long)cksum & 0xFF, 8));
                }
            }
            
            /* end of line */
            sb.append(Encoding.AsciiEndOfLineChar);
            return StringTools.getBytes(sb);
            
        }
    }

    // ------------------------------------------------------------------------

    public String toString(int encoding)
    {
        
        /* validate encoding */
        switch (encoding) {
            case Encoding.ENCODING_CSV_CKSUM   :
            case Encoding.ENCODING_CSV         :
            case Encoding.ENCODING_BASE64_CKSUM: 
            case Encoding.ENCODING_BASE64      :
            case Encoding.ENCODING_HEX_CKSUM   : 
            case Encoding.ENCODING_HEX         :
                // valid encoding
                break;
            case Encoding.ENCODING_UNKNOWN     :
            default                            :
                // invalid encoding, pick a valid one
                encoding = Encoding.ENCODING_HEX;
                break;
        }
        
        /* return encoded packet as a string */
        byte b[] = this.encode(encoding);
        if ((b != null) && (b.length > 0)) {
            if (b[0] == Encoding.AsciiEncodingChar) {
                int len = (b[b.length - 1] == Encoding.AsciiEndOfLineChar)? (b.length - 1) : b.length;
                return StringTools.toStringValue(b, 0, len);
            } else {
                return "0x" + StringTools.toHexString(b);
            }
        } else {
            return "";
        }
        
    }

    public String toString()
    {
        return this.toString(this.getEncoding());
    }

    // ------------------------------------------------------------------------

    private static Payload _decodeCSV(Packet pkt, String csv)
        throws PacketParseException
    {
        //Print.logDebug("Parsing CSV: " + csv);

        /* get Payload template field definitions */
        PayloadTemplate plt = pkt.getPayloadTemplate();
        if (plt == null) {
            if (Packet.isCustomEventType(pkt.getPacketType())) {
                throw new PacketParseException(ServerErrors.NAK_FORMAT_NOT_RECOGNIZED, pkt); // errData ok
            } else {
                throw new PacketParseException(ServerErrors.NAK_PACKET_TYPE, pkt); // errData ok
            }
        }

        /* parse csv into fields */
        String csvFlds[] = StringTools.parseString(csv, ',');
        Payload payload = new Payload();
        for (int p = 0, c = 0; c < csvFlds.length; p++) {
            PayloadTemplate.Field pltFld = plt.getField(p);
            if (pltFld == null) { break; }
            c = pltFld.parseString(csvFlds, c, payload);
        }
        //Print.logDebug("Parsed CSV Payload: " + payload);
        payload.resetIndex();
        return payload;

    }

    private static String _encodeCSV(Packet pkt)
    {
        StringBuffer sb = new StringBuffer();
        Payload payload = pkt.getPayload(true);

        /* get Payload template field definitions */
        PayloadTemplate plt = pkt.getPayloadTemplate();
        if (plt == null) {
            // unable to encode with CSV
            sb.append(Encoding.ENCODING_BASE64_CHAR);
            sb.append(Base64.encode(payload.getBytes()));
            return sb.toString();
        }
        
        /* encode to string */
        payload.resetIndex();
        for (int p = 0; payload.isValidReadLength(0); p++) {
            PayloadTemplate.Field pltFld = plt.getField(p);
            if (pltFld == null) { break; }
            sb.append(Encoding.ENCODING_CSV_CHAR);
            int length = pltFld.getLength();
            switch (pltFld.getPrimitiveType()) {
                case PayloadTemplate.PRIMITIVE_GPS: {
                    GeoPoint gp = payload.readGPS(length);
                    if (pltFld.isHiRes()) {
                        sb.append(StringTools.format(gp.getLatitude() , "###0.00000"));
                        sb.append(Encoding.ENCODING_CSV_CHAR);
                        sb.append(StringTools.format(gp.getLongitude(), "###0.00000"));
                    } else {
                        sb.append(StringTools.format(gp.getLatitude() , "###0.0000"));
                        sb.append(Encoding.ENCODING_CSV_CHAR);
                        sb.append(StringTools.format(gp.getLongitude(), "###0.0000"));
                    }
                    break;
                }
                case PayloadTemplate.PRIMITIVE_STRING: {
                    sb.append(payload.readString(length));
                    break;
                }
                case PayloadTemplate.PRIMITIVE_BINARY: {
                    byte b[] = payload.readBytes(length);
                    sb.append("0x" + StringTools.toHexString(b));
                    break;
                }
                case PayloadTemplate.PRIMITIVE_LONG:
                default: {
                    long val = pltFld.isSigned()?
                        payload.readLong(length) :
                        payload.readULong(length);
                    if (pltFld.isHex()) {
                        sb.append( "0x" + StringTools.toHexString(val, length * 8));
                    } else {
                        sb.append(String.valueOf(val));
                    }
                    break;
                }
            }
        }
        return sb.toString();
        
    }

    // ------------------------------------------------------------------------

    /* return the length of the packet starting at the data offset */
    public static int getPacketLength(byte data[], int dataOfs)
    {
        boolean STRICT_ASCII_EOL = false;
        
        /* validate data */
        if (data == null) {
            //Print.logError("No Packet data specified");
            return -1;
        }
        
        /* validate offset/length */
        int dataLen = data.length;
        if (dataOfs + 3 >= dataLen) {
            //Print.logError("Must have at least 3 bytes in packet");
            return -1;
        }
        
        /* find end of packet */
        if (data[dataOfs] == Encoding.AsciiEncodingChar) {
            //Print.logInfo("Ascii packet ...");
            for (int ofs = dataOfs; ofs < dataLen; ofs++) {
                // strictly speaking, an ASCII encoded packet should end with a '\r', however,
                // since this method may be used to parse packets from an ASCII file (which
                // may have been edited by a human), we may also need to check for '\n' as well.
                if (STRICT_ASCII_EOL) {
                    // strict ASCII packet definition, per protocol specification
                    if (data[ofs] == Encoding.AsciiEndOfLineChar) {
                        ofs++; // count EOL
                        //Print.logInfo("Ascii packet length: " + (ofs - dataOfs));
                        return (ofs - dataOfs);
                    }
                } else
                if ((data[ofs] == '\r') || (data[ofs] == '\n')) {
                    // relaxed ASCII packet EOL
                    while ((ofs < dataLen) && ((data[ofs] == '\r') || (data[ofs] == '\n'))) { ofs++; }
                    //Print.logInfo("Ascii packet length: " + (ofs - dataOfs));
                    return (ofs - dataOfs);
                }
            }
            // EOL not found
            //Print.logError("Ascii EOL not found!");
            return -1;
        } else {
            int len = 3 + ((int)data[dataOfs + 2] & 0xFF);
            if ((dataOfs + len) <= dataLen) {
                return len;
            } else {
                // beyond end of 'data'
                return -1;
            }
        }
        
    }
    
    // ------------------------------------------------------------------------

}