smppclient.cs.svn-base

EasySMPP是一个VS.NET平台下的短信开发包

                }
            }//ReconnectTimeout

            #endregion Properties

            #region Events

            public event SubmitSmRespEventHandler OnSubmitSmResp;

            public event DeliverSmEventHandler OnDeliverSm;

            public event LogEventHandler OnLog;

            #endregion Events

            #region Private functions
            private void connectToSMSC()
            {
                try
                {
                    if (!smscArray.HasItems)
                    {
                        logMessage(LogLevels.LogErrors, "Connect | ERROR #1011 : No SMSC defined. Please ddd SMSC definition first.");
                        return;
                    }
                    initClientParameters();

                    IPAddress ipAddress = IPAddress.Parse(smscArray.currentSMSC.Host);
                    IPEndPoint remoteEP = new IPEndPoint(ipAddress, smscArray.currentSMSC.Port);
                    //  Create a TCP/IP  socket.
                    //Try to disconnect if connected
                    tryToDisconnect();
                    clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                    logMessage(LogLevels.LogSteps, "Trying to connect to " + smscArray.currentSMSC.Description + "[" + smscArray.currentSMSC.Host + ":" + smscArray.currentSMSC.Port + "]");
                    clientSocket.BeginConnect(remoteEP, new AsyncCallback(connectCallback), clientSocket);
                    connectionState= ConnectionStates.SMPP_SOCKET_CONNECT_SENT;
                }
                catch (Exception ex)
                {
                    logMessage(LogLevels.LogExceptions, "connectToSMSC | " + ex.ToString());
                }

            }//connectToSMSC

            private void tryToDisconnect()
            {
                try
                {
                    if (clientSocket != null)
                    {
                        if (clientSocket.Connected)
                        {
                            clientSocket.Shutdown(SocketShutdown.Both);
                        }
                        clientSocket.Close();
                        clientSocket = null;
                    }
                }
                catch (Exception ex)
                {
                    logMessage(LogLevels.LogExceptions, "tryToDisconnect | " + ex.ToString());
                }
            }//tryToDisconnect

            private void disconnectSocket()
            {
                try
                {
                    disconnect(clientSocket);
                }
                catch (Exception ex)
                {
                    logMessage(LogLevels.LogExceptions, "disconnectSocket | " + ex.ToString());
                }
            }//disconnectSocket

            private void disconnect(Socket client)
            {
                try
                {
                    logMessage(LogLevels.LogSteps, "Disconnected");
                    connectionState= ConnectionStates.SMPP_SOCKET_DISCONNECTED;
                    client.Shutdown(SocketShutdown.Both);
                    client.Close();
                    client = null;
                }
                catch (Exception ex)
                {
                    logMessage(LogLevels.LogExceptions, "disconnect | " + ex.ToString());
                }
            }//Disconnect


            private void receive()
            {
                try
                {
                    // Create the state object.
                    StateObject state = new StateObject();
                    state.workSocket = clientSocket;

                    // Begin receiving the data from the remote device.
                    clientSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                        new AsyncCallback(receiveCallback), state);

                }
                catch (Exception ex)
                {
                    logMessage(LogLevels.LogExceptions, "receive | " + ex.ToString());
                }

            }//receive

            private void bind()
            {
                try
                {
                    byte[] Bind_PDU = new byte[1024];
                    int pos, i, n;

                    pos = 7;
                    Bind_PDU[pos] = 0x09;

                    pos = 12;
                    Tools.CopyIntToArray(smscArray.currentSMSC.SequenceNumber, Bind_PDU, pos);
                    pos = 15;

                    pos++;
                    n = smscArray.currentSMSC.SystemId.Length;
                    for (i = 0; i < n; i++, pos++)
                        Bind_PDU[pos] = (byte)smscArray.currentSMSC.SystemId[i];
                    Bind_PDU[pos] = 0;

                    pos++;
                    n = smscArray.currentSMSC.Password.Length;
                    for (i = 0; i < n; i++, pos++)
                        Bind_PDU[pos] = (byte)smscArray.currentSMSC.Password[i];
                    Bind_PDU[pos] = 0;

                    pos++;
                    n = smscArray.currentSMSC.SystemType.Length;
                    for (i = 0; i < n; i++, pos++)
                        Bind_PDU[pos] = (byte)smscArray.currentSMSC.SystemType[i];
                    Bind_PDU[pos] = 0;

                    Bind_PDU[++pos] = 0x34; //interface version
                    Bind_PDU[++pos] = (byte)smscArray.currentSMSC.AddrTon; //addr_ton
                    Bind_PDU[++pos] = (byte)smscArray.currentSMSC.AddrNpi; //addr_npi
                    
                    //address_range
                    pos++;
                    n = smscArray.currentSMSC.AddressRange.Length;
                    for (i = 0; i < n; i++, pos++)
                        Bind_PDU[pos] = (byte)smscArray.currentSMSC.AddressRange[i];
                    Bind_PDU[pos] = 0x00;

                    pos++;
                    Bind_PDU[3] = Convert.ToByte(pos & 0x00FF);
                    Bind_PDU[2] = Convert.ToByte((pos >> 8) & 0x00FF);

                    // Begin sending the data to the remote device.
                    logMessage(LogLevels.LogSteps, "BindSent");
                    Send(Bind_PDU, pos);
                    connectionState= ConnectionStates.SMPP_BIND_SENT;
                    receive();
                }
                catch (Exception ex)
                {
                    logMessage(LogLevels.LogExceptions, "bind | " + ex.ToString());
                }

            }//bind

            private void unBind()
            {
                if (connectionState== ConnectionStates.SMPP_BINDED)
                {
                    try
                    {
                        byte[] _PDU = new byte[16];

                        Tools.CopyIntToArray(16, _PDU, 0);

                        Tools.CopyIntToArray(0x00000006, _PDU, 4);

                        Tools.CopyIntToArray(smscArray.currentSMSC.SequenceNumber, _PDU, 12);

                        logMessage(LogLevels.LogSteps, "Unbind sent.");
                        connectionState= ConnectionStates.SMPP_UNBIND_SENT;

                        Send(_PDU, 16);
                    }
                    catch (Exception ex)
                    {
                        logMessage(LogLevels.LogExceptions, "unBind | " + ex.ToString());
                    }
                }

            }//unBind


            private void processSubmitSmResp(SubmitSmRespEventArgs e)
            {
                try
                {
                    undeliveredMessages--;

                    if (OnSubmitSmResp != null)
                    {
                        OnSubmitSmResp(e);
                    }
                }
                catch (Exception ex)
                {
                    logMessage(LogLevels.LogExceptions, "processSubmitSmResp | " + ex.ToString());
                }

            }//processSubmitSmResp

            private void processDeliverSm(DeliverSmEventArgs e)
            {
                try
                {
                    if (OnDeliverSm != null)
                    {
                        OnDeliverSm(e);
                    }
                    else
                        sendDeliverSmResp(e.SequenceNumber, StatusCodes.ESME_ROK);
                }
                catch (Exception ex)
                {
                    logMessage(LogLevels.LogExceptions, "processDeliverSm | " + ex.ToString());
                }
            }//processDeliverSm

            private void processLog(LogEventArgs e)
            {
                try
                {
                    if (OnLog != null)
                    {
                        OnLog(e);
                    }
                }
                catch
                {
                }

            }//processLog

            private void logMessage(int logLevel, string pMessage)
            {
                try
                {
                    if ((this.LogLevel & logLevel) > 0)
                    {
                        LogEventArgs evArg = new LogEventArgs(pMessage);
                        processLog(evArg);
                    }
                }
                catch (Exception ex)
                {
                    // DO NOT USE LOG INSIDE LOG FUNCTION !!! logMessage(LogLevels.LogExceptions, "logMessage | " +ex.ToString());
                }
            }//logMessage

            private void connectCallback(IAsyncResult ar)
            {
                try
                {
                    // Retrieve the socket from the state object.
                    Socket client = (Socket)ar.AsyncState;

                    // Complete the connection.
                    client.EndConnect(ar);
                    clientSocket = client;
                    clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);
                    connectionState= ConnectionStates.SMPP_SOCKET_CONNECTED;
                    logMessage(LogLevels.LogSteps, "Connected");
                    lastSeenConnected = DateTime.Now;
                    bind();
                }
                catch (Exception ex)
                {
                    logMessage(LogLevels.LogExceptions, "connectCallback | " + ex.ToString());
                    tryToReconnect();
                }
            }//connectCallback


            private void tryToReconnect()
            {
                try