cmpp_yx.java

短信

package com.asiainfo.batchsend.sms.sms.cmpp.type;

import com.asiainfo.batchsend.sms.sms.cmpp.CMPP_InitMessage;
import com.asiainfo.batchsend.sms.sms.cmpp.CMPP_Service;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPActiveTestMessage;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPActiveTestMessageResp;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPCancelMessage;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPCancelMessageResp;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPConnectMessage;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPConnectMessageResp;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPDeliverMessage;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPDeliverMessageResp;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPHead;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPQueryMessage;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPQueryMessageResp;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPSubmitMessage;
import com.asiainfo.batchsend.sms.sms.cmpp.message.CMPPSubmitMessageResp;
import com.asiainfo.batchsend.sms.sms.cmpp.message.DeliverMsg;
import com.asiainfo.batchsend.sms.sms.cmpp.message.SubmitMsg;
import com.asiainfo.batchsend.sms.sms.cmpp.socket.SocketManager;
import com.asiainfo.batchsend.sms.sms.cmpp.util.Log;
import com.asiainfo.batchsend.sms.sms.cmpp.util.MD5;
import com.asiainfo.batchsend.sms.sms.cmpp.util.SplitMsg;
import com.asiainfo.batchsend.sms.sms.cmpp.util.Tools;
import com.asiainfo.batchsend.sms.sms.db.SmsLoadSvc;

import java.util.*;
import java.io.*;
import java.net.*;

/**
 * <p>Title: 通信主类</p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Company: </p>
 * @author unascribed
 * @version 1.0
 */

public class CMPP_YX implements CMPP_Service{
    private CMPP_InitMessage initMsg=CMPP_InitMessage.getInstance();
    private SocketManager socketManger=null;
    private String logFile=initMsg.logFile;
    private Socket s=null;
    private String moduleid="";
    private int flag=-1;
    private long time=initMsg.timeout;

    
    private DataInputStream in=null;
    private DataOutputStream out=null;
    private int C=initMsg.C;
    private int N=initMsg.N;
    private int sendOut=1;
    private int checkTime=(int)(System.currentTimeMillis()/1000);
    private String icp=null;
    public CMPP_YX() {
    }
    //初始化CMPP
    public int initCMPP(String host,String icp_ID,String user,String auth,String timeStamp,int version,int port,String loginFlag,String moduleid){
        int stat=-1;
        int timeout=1000*10;
        icp=icp_ID;
        this.moduleid = moduleid;
        try {
            socketManger=new SocketManager(host,user,auth,timeStamp,version,port,timeout);
            if(loginFlag==null)
                flag=2;
            else{
                if(loginFlag.equals("MO"))
                    flag=1;
                if(loginFlag.equals("MT"))
                    flag=0;
                if(loginFlag.equals("MOMT"))
                    flag=2;
            }
            
            stat = initCMPP();
        }
        catch (Exception ex) {
            socketManger.freeSocket();
            s=null;
            stat=-1;
        }
        return stat;
    }
    private int initCMPP()throws Exception{
        sendOut=1;
        int stat = CMPP_SUCCESS;
        try {
            CMPPConnectMessage cMsg=new CMPPConnectMessage();
            sendOut=cMsg.setSequenceID(sendOut);//设置消息流水号
            byte[] auth =getAuthString();//取得MD5加密初始值
            MD5 md5 = new MD5();
            byte md5Msg[]=md5.getMD5ofBytes(auth,auth.length);//进行MD5加密
            stat=login(cMsg,md5Msg,flag);//登陆
            if(stat!=CMPP_SUCCESS){
                Log.printEvent("初使化YX_CMPP发生错误,resp stat:"+stat,logFile);
            }else{
                Log.printEvent("初使化YX_CMPP成功"+Thread.currentThread().getName(),logFile);
            }
        }
        catch (Exception ex){
            stat=CONNECT_INIT_ERROR;
            Log.printError(ex,"初使化YX_CMPP发生错误"+Thread.currentThread().getName(),logFile);
        }
        try {
            Thread.currentThread().sleep(1000);
        }
        catch (Exception ex) {
        }
        return stat;
    }
    private byte[] getAuthString(){//取得登录认证码（转换前）
        byte[] user=socketManger.getUSER();//取得icp_ID
        byte[] auth = socketManger.getAuth();//取得认证码
        byte[] timeStamp = "0000000000".getBytes();//取得时间戳
        if(user==null||auth==null)
            return null;
        byte abyte2[] = new byte[100];
        System.arraycopy(user, 0, abyte2, 0, user.length);//icp
        int k = user.length+ 9;//空９个字节的０
        System.arraycopy(auth, 0, abyte2, k, auth.length);//keys
        k += auth.length;
        System.arraycopy(timeStamp, 0, abyte2, k, 10);//此处时间戳为10位（东软为四位）
        k += 10;
        byte auths[] = new byte[k];
        System.arraycopy(abyte2, 0,auths, 0, k);//取得２５位的MD5加密前值
        return auths;
    }

    private int login(CMPPConnectMessage cMsg,byte[] auth,int loginFlag)throws IOException,Exception{
        int stat = CMPP_SUCCESS;
        int length=12;
        byte[] inMsg = new byte[100];
        System.arraycopy(Tools.int2byte(cMsg.nCommandID),0,inMsg,4,4);
        System.arraycopy(Tools.int2byte(cMsg.nSequenceID),0,inMsg,8,4);
        System.arraycopy(icp.getBytes(),0,inMsg,12,icp.getBytes().length);//6
        length+=icp.getBytes().length;//18
        System.arraycopy(auth,0,inMsg,length,auth.length);//16
        length+=auth.length;//34
        if(loginFlag==1)
            inMsg[34]=(byte)1;
        else
            inMsg[34]=0;//35
        length+=5;//39
        cMsg.nMsgSize=length;
        System.arraycopy(Tools.int2byte(cMsg.nMsgSize),0,inMsg,0,4);
        byte[] send = new byte[length];
        System.arraycopy(inMsg,0,send,0,length);
        s = socketManger.getSocket();//取得Socket
        ///发送认证码
        send(send);//发送认证码
        //接收认证码
        CMPPHead head= Deliver();//接收反馈消息
        if(head.nCommandID==this.COMMAND_CMPP_CONNECT_RESP){
            stat=head.stat;
        }else{
            Log.printEvent("YX:登陆连接反馈发生错误！",logFile);
            stat=CONNECT_MSG_RESP_NOT_FOUNT_ERROR;
        }
        //关闭接收发送通道
        if(stat!=CMPP_SUCCESS){
            close();
        }
        return stat;
    }
    //关闭与网关连接的SOCKET在调用了logout后调用

    //发送断开连接消息给网关
    public void quit(){
        CMPPHead logout = new CMPPHead();
        sendOut=logout.setSequenceID(sendOut);
        logout.nCommandID=2;
        logout.nMsgSize=12;
        try {
            sendHead(logout);
        }
        catch (Exception ex) {
        }
        close();
    }
    //信息提交
    public int submit(SubmitMsg msg)throws IOException{
        try {
            if(msg==null){
                if(!activeTest("auto")){
                    throw new IOException();
                }
                return 0;
            }
            CMPPSubmitMessage submitMessage = new CMPPSubmitMessage(msg);
            boolean splitFlag=true;
            Vector vMsg=null;
            try {
                if(submitMessage.picAndRing!=null){
                    submitMessage.sMsgContent="1";
                    splitFlag=false;
                }
                vMsg = SplitMsg.split(submitMessage.sMsgContent,splitFlag);             //信息分割队列
            }
            catch (Exception ex) {
                return -1;
            }
            int size=vMsg.size();
            int stat[] = new int[size];
            int i;
            for(i=0;i<size;i++){
                sendOut=submitMessage.setSequenceID(sendOut);
                submitMessage.sMsgContent = (String)(vMsg.remove(0));  //信息内容
                submitMessage.nPkTotal=size;
                submitMessage.nPkNumber=i+1;
                stat[i]=sendMsg(submitMessage);
                if(stat[i]!=0) return stat[i];
            }
        }
        catch (IOException ex) {
            close();
            throw ex;
        }
        return 0;
    }
    private int sendMsg(CMPPSubmitMessage msg)throws IOException{
        int stat = CMPP_SUCCESS;
        byte[] sendMsg=null;
        try {
            sendMsg = getSendMsg(msg);
        }
        catch (Exception ex) {
            sendOut--;
            return SUBMIT_MSG_FORMAT_ERROR;
        }
        int i=N;//重新发送次数
        while(i!=0){
            try {
                sendPacket(msg,sendMsg);
            }
            catch (IOException ex) {
                sendOut--;
                throw ex;
            }
            CMPPHead back= Deliver();
            if(back.stat==DELIVER_MSG_TIME_OUT){
                i--;
                if(i==0)
                    stat=SUBMIT_MSG_TIME_OUT;
                continue;
            }
            if(back.nCommandID==this.COMMAND_CMPP_SUBMIT_RESP){
                return back.stat;
            }
            if(back.nCommandID==this.COMMAND_CMPP_TERMINATE){
                throw new IOException();
            }
            if(back.nCommandID==this.COMMAND_CMPP_DELIVER){
            	//下面保存接收到的短信            	
                //deliverMsgList.addElement(((CMPPDeliverMessage)back).getDeliverMsg());
            	DeliverMsg dm = ((CMPPDeliverMessage)back).getDeliverMsg();
            	SmsLoadSvc.saveRecMessage(dm.sSrcTerminalId, dm.sMsgContent, this.moduleid);
                continue;
            }
            else
                return this.CMPP_UNKNOWN_PACKAGE_ERROR;
        }
        return stat;
    }

    private byte[] getSendMsg(CMPPSubmitMessage msg)throws Exception{
        byte send[]= new byte[1024*3];
        send[8]=(byte)msg.nPkTotal;
        send[9]=(byte)msg.nPkNumber;
        send[10]=(byte)msg.nNeedReply;
        send[11]=(byte)msg.nMsgLevel;
        if(msg.sServiceId!=null)
            System.arraycopy(msg.sServiceId.getBytes(),0,send,12,msg.sServiceId.getBytes().length);
        send[22]=(byte)msg.nFeeUserType;
        if(msg.sFeeMobile!=null)
            System.arraycopy(msg.sFeeMobile.getBytes(),0,send,23,msg.sFeeType.getBytes().length);
        send[44]=(byte)msg.nTPpId;
        send[45]=(byte)msg.nTPudhi;
        send[46]=(byte)msg.nMsgFormat;
        System.arraycopy(icp.getBytes(),0,send,47,icp.getBytes().length);
        msg.sFeeType="0"+Integer.parseInt(msg.sFeeType);
        System.arraycopy(msg.sFeeType.getBytes(),0,send,53,msg.sFeeType.getBytes().length);

        System.arraycopy(msg.sFeeCode.getBytes(),0,send,55,msg.sFeeCode.getBytes().length);
        if(msg.sValidTime!=null)
            System.arraycopy(msg.sValidTime.getBytes(),0,send,61,msg.sValidTime.getBytes().length);
        if(msg.sAtTime!=null)
            System.arraycopy(msg.sAtTime.getBytes(),0,send,78,msg.sAtTime.getBytes().length);
        if(msg.sSrcId!=null)
            System.arraycopy(msg.sSrcId.getBytes(),0,send,95,msg.sSrcId.getBytes().length);
        System.arraycopy(msg.getDestBytes(),0,send,117,msg.nDestUsrTl*21);
        send[116]=(byte)msg.nDestUsrTl;
        int size=117+msg.nDestUsrTl*21;
        byte[] sMsgContent=null;
        if(msg.sMsgContent==null && msg.nNeedReply==2) msg.sMsgContent="JF";
        if(msg.picAndRing!=null){
            send[size]=(byte)msg.picAndRing.length;
            System.arraycopy(msg.picAndRing,0,send,size+1,msg.picAndRing.length);
        }else{
            try {
                if(msg.nMsgFormat==8)
                    sMsgContent=msg.sMsgContent.getBytes("iso-10646-ucs-2");
                else if(msg.nMsgFormat==15)
                    sMsgContent=msg.sMsgContent.getBytes("gb2312");
                else
                    sMsgContent=msg.sMsgContent.getBytes("iso-8859-1");
            }
            catch (Exception ex) {
            }
            send[size]=(byte)sMsgContent.length;
            System.arraycopy(sMsgContent,0,send,size+1,sMsgContent.length);
        }
        int length=0;
        if(msg.picAndRing==null)
            length = 118+msg.nDestUsrTl*21+sMsgContent.length;
        else
            length = 118+msg.nDestUsrTl*21+msg.picAndRing.length;
        length++;
        byte[] msgBytes= new byte[length];
        System.arraycopy(send,0,msgBytes,0,length);
        return msgBytes;
    }

    //信息删除
    public int Cancel(){
        CMPPCancelMessage cancelMessage = new CMPPCancelMessage();
        CMPPCancelMessageResp cancelResp = new CMPPCancelMessageResp();

        return 1;
    }
    private CMPPHead dealMsg(CMPPHead head,byte[] msg)throws IOException,Exception{
        CMPPHead backMsg = new CMPPHead();
        int stat=head.stat;
        switch (head.nCommandID){
            case COMMAND_CMPP_NACK_RESP:
                break;
            case COMMAND_CMPP_CONNECT_RESP:
                CMPPConnectMessageResp cResp = new CMPPConnectMessageResp();
                if(msg==null) stat=CONNECT_MSG_NULL_ERROR;
                else{
                    cResp.nStatus=msg[0];
                    try {
                        stat= msg[0];
                        if(stat!=3)
                            cResp.sISMG=new String(msg,1,16);
                        cResp.nVersion=msg[msg.length-1];
                    }
                    catch (Exception ex) {
                        stat=CONNECT_MSG_FORMAT_ERROR;
                    }