avp.java

提供对diameter消息,avp的封装解析功能的工具类

package com.tseg.ocs.data;


public class AVP
{
    byte payload[];//实际载荷
    public int code;
    private int flags;//AVP flags
    public int vendor_id;
    private static final int avp_flag_vendor = 128;
    private static final int avp_flag_mandatory = 64;
    private static final int avp_flag_private = 32;

    public AVP()
    {

    }

    public AVP(AVP avp)
    {
        payload = new byte[avp.payload.length];
        System.arraycopy(avp.payload, 0, payload, 0, avp.payload.length);
        code = avp.code;
        flags = avp.flags;
        vendor_id = avp.vendor_id;
    }

    public AVP(int i, byte abyte0[])
    {
        this(i, 0, abyte0);
    }
    //由code,vendor_id,payload字节数组来构造avp实例
    public AVP(int i, int j, byte abyte0[])
    {
        code = i;
        vendor_id = j;
        payload = abyte0;
    }

    public static final int decodeSize(byte abyte0[], int i, int j)
    {
        //将字节数组abyte0的第i个字节开始的j个字节解析成一个avp, 返回经过字边界处理的avp length
		if(j < 8)
        {
            return 0;
        }
        int k = packunpack.unpack32(abyte0, i + 4);
        int l = k >> 24 & 0xff;//取得 avp flags
        int i1 = k & 0xffffff;//取得 avp length域的值
        System.out.println("i1 = "+i1);
        int j1 = i1 + 3 & -4;//载荷经过字边界处理后的avp length
        System.out.println("j1="+j1);
        if((l & 0x80) != 0)//若v比特置位
        {
            if(i1 < 12)
            {
                return 0;
            }
        } else
        if(i1 < 8)
        {
            return 0;
        }
		//abyte0[i] -- abyte0[i+j1]为某个avp对应的字节序列
        return j1;
    }

    public boolean decode(byte abyte0[], int i, int j)
    {
        //将字节数组abyte0的第i+1个元素abyte0[i]开始的j个字节解析成某个avp,j-- avp length
		if(j < 8)
        {
            return false;
        }
        int k = 0;
        code = packunpack.unpack32(abyte0, i + k);//第一个4字节解析给avp的code域
        k += 4;
        int l = packunpack.unpack32(abyte0, i + k);
        k += 4;
        flags = l >> 24 & 0xff;//第二个4字节的最高字节解析给avp flags

        int i1 = l & 0xffffff;////第二个4字节的低三个字节解析给avp length
        int j1 = i1 + 3 & -4;//将avp的payload域做字边界处理
        if(j != j1)
        {
            return false;
        }
        i1 -= 8;//减去消息头中固定8字节长度

        if((flags & 0x80) != 0)//若v比特置位但vendor_id域长度<4则为不合法
        {
            if(i1 < 4)
            {
                return false;
            }
            vendor_id = packunpack.unpack32(abyte0, i + k);//取得vendor_id域的值
            k += 4;
            i1 -= 4;
        }
		//k--已解析字节数，i1--待解析字节数
        setPayload(abyte0, i + k, i1);//avp的payload中存储的是未经字边界处理的字节数组,即真正的字节数组
        k += i1;
		System.out.println("the avp's total length="+k);
        return true;
    }
    //返回经过字边界处理后的avp length
    int encodeSize()
    {
        int i = 8;
        if(vendor_id != 0)
        {
            i += 4;
        }
        i += payload.length ;
        i= i+ 3 & -4;
        return i;
    } 
    //将avp封装到字节数组abyte0的abyte0[i]开始的元素中
    public int encode(byte abyte0[], int i)
    {
        int j = 8;//首先是取得固定8字节avp header
        if(vendor_id != 0)
        {
            j += 4;
        }
        j += payload.length;

        int k = flags;

        if(vendor_id != 0)
        {
            k |= 0x80;//V比特置位
        } else
        {
            k &= 0xffffff7f;//V比特清0
        }

        int l = 0;
        packunpack.pack32(abyte0, i + l, code);//对avp code进行编码
        l += 4;
        //将avp flags及 avp length编码入字节数组
        packunpack.pack32(abyte0, i + l, j | k << 24);//avp length--payload未经过字边界的处理
        l += 4;
		//将vendor_id编码入字节数组
        if(vendor_id != 0)
        {
            packunpack.pack32(abyte0, i + l, vendor_id);
            l += 4;
        }
		//将payload拷贝入字节数组
        System.arraycopy(payload, 0, abyte0, i + l, payload.length);
		//此时，字节数组abyte0的avp length域的值是载荷域payload未经过字边界处理的avp长度值
		System.out.println("real length = "+l);
		System.out.println("return length = "+encodeSize());

        return encodeSize();//但返回值是经过字边界处理后的字节数组的长度
    }

    public byte[] encode()
    {
        int i = 8;
        if(vendor_id != 0)
        {
            i += 4;
        }
        i += payload.length;
        int j = flags;
        if(vendor_id != 0)
        {
            j |= 0x80;
        } else
        {
            j &= 0xffffff7f;
        }
		int l = encodeSize();
        byte abyte0[] = new byte[l];//返回的字节数组是载荷域经过字边界处理后的
        int k = 0;
        packunpack.pack32(abyte0, k, code);
        k += 4;
        packunpack.pack32(abyte0, k, i | j << 24);
        k += 4;
        if(vendor_id != 0)
        {
            packunpack.pack32(abyte0, k, vendor_id);
            k += 4;
        }
        System.arraycopy(payload, 0, abyte0, k, payload.length);

		System.out.println(k == l);
        return abyte0;
    }
    //获得avp Data域的值，以字节数组的形式返回
    byte[] queryPayload()
    {
        byte abyte0[] = new byte[payload.length];
        System.arraycopy(payload, 0, abyte0, 0, payload.length);
        return abyte0;
    }

    int queryPayloadSize()
    {
        return payload.length;
    }

    void setPayload(byte abyte0[])
    {
        setPayload(abyte0, 0, abyte0.length);
    }

    void setPayload(byte abyte0[], int i, int j)
    {
        //将字节数组abyte0的abyte0[i]开始的j个字节赋值给payload
		byte abyte1[] = new byte[j];
        System.arraycopy(abyte0, i, abyte1, 0, j);
        payload = abyte1;
    }

    public boolean isVendorSpecific()
    {
        return vendor_id != 0;
    }

    public boolean isMandatory()
    {
        return (flags & 0x40) != 0;
    }

    public boolean isPrivate()
    {
        return (flags & 0x20) != 0;
    }

    public void setMandatory(boolean flag)
    {
        if(flag)
        {
            flags |= 0x40;
        } else
        {
            flags &= 0xffffffbf;
        }
    }

    public void setPrivate(boolean flag)
    {
        if(flag)
        {
            flags |= 0x20;
        } else
        {
            flags &= 0xffffffdf;
        }
    }
}