SocketConnection.java 10.5 KB
Newer Older
Matt Tucker's avatar
Matt Tucker committed
1 2 3 4 5
/**
 * $RCSfile$
 * $Revision$
 * $Date$
 *
Matt Tucker's avatar
Matt Tucker committed
6
 * Copyright (C) 2004 Jive Software. All rights reserved.
Matt Tucker's avatar
Matt Tucker committed
7
 *
Matt Tucker's avatar
Matt Tucker committed
8 9
 * This software is published under the terms of the GNU Public License (GPL),
 * a copy of which is included in this distribution.
Matt Tucker's avatar
Matt Tucker committed
10
 */
Matt Tucker's avatar
Matt Tucker committed
11

Matt Tucker's avatar
Matt Tucker committed
12 13
package org.jivesoftware.messenger.net;

14
import org.jivesoftware.messenger.*;
Derek DeMoro's avatar
Derek DeMoro committed
15
import org.jivesoftware.messenger.auth.UnauthorizedException;
16 17
import org.jivesoftware.messenger.interceptor.InterceptorManager;
import org.jivesoftware.messenger.interceptor.PacketRejectedException;
Derek DeMoro's avatar
Derek DeMoro committed
18 19 20
import org.jivesoftware.util.LocaleUtils;
import org.jivesoftware.util.Log;
import org.xmpp.packet.Packet;
Matt Tucker's avatar
Matt Tucker committed
21

22 23 24 25 26 27
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.InetAddress;
import java.net.Socket;
28 29
import java.util.HashMap;
import java.util.Iterator;
30
import java.util.Map;
31

Matt Tucker's avatar
Matt Tucker committed
32
/**
33
 * An object to track the state of a XMPP client-server session.
Matt Tucker's avatar
Matt Tucker committed
34 35 36 37 38
 * Currently this class contains the socket channel connecting the
 * client and server.
 *
 * @author Iain Shigeoka
 */
39
public class SocketConnection implements Connection {
Matt Tucker's avatar
Matt Tucker committed
40 41

    /**
42
     * The utf-8 charset for decoding and encoding XMPP packet streams.
Matt Tucker's avatar
Matt Tucker committed
43
     */
44 45 46 47 48
    public static final String CHARSET = "UTF-8";

    private Map listeners = new HashMap();

    private Socket socket;
Matt Tucker's avatar
Matt Tucker committed
49 50 51 52 53 54 55

    private Writer writer;

    private PacketDeliverer deliverer;

    private Session session;
    private boolean secure;
56
    private org.jivesoftware.util.XMLWriter xmlSerializer;
57
    private boolean flashClient = false;
58 59 60
    private int majorVersion = 1;
    private int minorVersion = 0;
    private String language = null;
61

Matt Tucker's avatar
Matt Tucker committed
62 63 64
    /**
     * Create a new session using the supplied socket.
     *
65 66 67 68
     * @param deliverer the packet deliverer this connection will use.
     * @param socket the socket to represent.
     * @param isSecure true if this is a secure connection.
     * @throws NullPointerException if the socket is null.
Matt Tucker's avatar
Matt Tucker committed
69
     */
70 71
    public SocketConnection(PacketDeliverer deliverer, Socket socket, boolean isSecure)
            throws IOException
72
    {
Matt Tucker's avatar
Matt Tucker committed
73 74 75 76 77
        if (socket == null) {
            throw new NullPointerException("Socket channel must be non-null");
        }

        this.secure = isSecure;
78
        this.socket = socket;
79
        writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), CHARSET));
Matt Tucker's avatar
Matt Tucker committed
80
        this.deliverer = deliverer;
81
        xmlSerializer = new XMLSocketWriter(writer, socket);
Matt Tucker's avatar
Matt Tucker committed
82 83 84 85 86 87 88 89
    }

    public boolean validate() {
        if (isClosed()) {
            return false;
        }
        try {
            synchronized (writer) {
90 91
                // Register that we started sending data on the connection
                SocketSendingTracker.getInstance().socketStartedSending(socket);
Derek DeMoro's avatar
Derek DeMoro committed
92 93
                writer.write(" ");
                writer.flush();
Matt Tucker's avatar
Matt Tucker committed
94 95 96
            }
        }
        catch (Exception e) {
97
            Log.warn("Closing no longer valid connection" + "\n" + this.toString(), e);
Matt Tucker's avatar
Matt Tucker committed
98 99
            close();
        }
100 101 102 103
        finally {
            // Register that we finished sending data on the connection
            SocketSendingTracker.getInstance().socketFinishedSending(socket);
        }
Matt Tucker's avatar
Matt Tucker committed
104 105 106 107 108 109 110
        return !isClosed();
    }

    public void init(Session owner) {
        session = owner;
    }

111 112 113 114 115 116 117 118 119
    public Object registerCloseListener(ConnectionCloseListener listener, Object handbackMessage) {
        Object status = null;
        if (isClosed()) {
            listener.onConnectionClose(handbackMessage);
        }
        else {
            status = listeners.put(listener, handbackMessage);
        }
        return status;
Matt Tucker's avatar
Matt Tucker committed
120 121
    }

122 123
    public Object removeCloseListener(ConnectionCloseListener listener) {
        return listeners.remove(listener);
Matt Tucker's avatar
Matt Tucker committed
124 125
    }

126 127 128 129 130
    public InetAddress getInetAddress() {
        return socket.getInetAddress();
    }

    public Writer getWriter() {
Derek DeMoro's avatar
Derek DeMoro committed
131 132 133
        return writer;
    }

Matt Tucker's avatar
Matt Tucker committed
134 135
    public boolean isClosed() {
        if (session == null) {
136
            return socket.isClosed();
Matt Tucker's avatar
Matt Tucker committed
137 138 139 140 141 142 143 144
        }
        return session.getStatus() == Session.STATUS_CLOSED;
    }

    public boolean isSecure() {
        return secure;
    }

145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
    public int getMajorXMPPVersion() {
        return majorVersion;
    }

    public int getMinorXMPPVersion() {
        return minorVersion;
    }

    /**
     * Sets the XMPP version information. In most cases, the version should be "1.0".
     * However, older clients using the "Jabber" protocol do not set a version. In that
     * case, the version is "0.0".
     *
     * @param majorVersion the major version.
     * @param minorVersion the minor version.
     */
    public void setXMPPVersion(int majorVersion, int minorVersion) {
        this.majorVersion = majorVersion;
        this.minorVersion = minorVersion;
    }

    public String getLanguage() {
        return language;
    }

    /**
     * Sets the language code that should be used for this connection (e.g. "en").
     *
     * @param language the language code.
     */
    public void setLanaguage(String language) {
        this.language = language;
    }

    public boolean isFlashClient() {
        return flashClient;
    }

    /**
     * Sets whether the connected client is a flash client. Flash clients need to
     * receive a special character (i.e. \0) at the end of each xml packet. Flash
     * clients may send the character \0 in incoming packets and may start a
     * connection using another openning tag such as: "flash:client".
     *
     * @param flashClient true if the if the connection is a flash client.
     */
    public void setFlashClient(boolean flashClient) {
        this.flashClient = flashClient;
    }

Gaston Dombiak's avatar
Gaston Dombiak committed
195 196 197 198 199 200 201 202 203 204
    public void close() {
        boolean wasClosed = false;
        synchronized (this) {
            if (!isClosed()) {
                try {
                    if (session != null) {
                        session.setStatus(Session.STATUS_CLOSED);
                    }
                    synchronized (writer) {
                        try {
205 206
                            // Register that we started sending data on the connection
                            SocketSendingTracker.getInstance().socketStartedSending(socket);
Gaston Dombiak's avatar
Gaston Dombiak committed
207 208 209 210
                            writer.write("</stream:stream>");
                            if (flashClient) {
                                writer.write('\0');
                            }
211
                            writer.flush();
212
                        }
Gaston Dombiak's avatar
Gaston Dombiak committed
213
                        catch (IOException e) {}
214 215 216 217
                        finally {
                            // Register that we finished sending data on the connection
                            SocketSendingTracker.getInstance().socketFinishedSending(socket);
                        }
218 219
                    }
                }
Gaston Dombiak's avatar
Gaston Dombiak committed
220 221 222 223 224 225 226 227 228 229 230 231
                catch (Exception e) {
                    Log.error(LocaleUtils.getLocalizedString("admin.error.close")
                            + "\n" + this.toString(), e);
                }
                try {
                    socket.close();
                }
                catch (Exception e) {
                    Log.error(LocaleUtils.getLocalizedString("admin.error.close")
                            + "\n" + this.toString(), e);
                }
                wasClosed = true;
Matt Tucker's avatar
Matt Tucker committed
232
            }
Gaston Dombiak's avatar
Gaston Dombiak committed
233 234
        }
        if (wasClosed) {
Matt Tucker's avatar
Matt Tucker committed
235 236 237 238
            notifyCloseListeners();
        }
    }

Derek DeMoro's avatar
Derek DeMoro committed
239
    public void deliver(Packet packet) throws UnauthorizedException, PacketException {
Matt Tucker's avatar
Matt Tucker committed
240 241 242 243
        if (isClosed()) {
            deliverer.deliver(packet);
        }
        else {
244 245 246
            try {
                // Invoke the interceptors before we send the packet
                InterceptorManager.getInstance().invokeInterceptors(packet, session, false, false);
Gaston Dombiak's avatar
Gaston Dombiak committed
247
                boolean errorDelivering = false;
248 249 250 251 252 253 254 255 256
                synchronized (writer) {
                    try {
                        xmlSerializer.write(packet.getElement());
                        if (flashClient) {
                            writer.write('\0');
                        }
                        xmlSerializer.flush();
                    }
                    catch (IOException e) {
Gaston Dombiak's avatar
Gaston Dombiak committed
257
                        Log.debug("Error delivering packet" + "\n" + this.toString(), e);
Gaston Dombiak's avatar
Gaston Dombiak committed
258
                        errorDelivering = true;
259
                    }
Derek DeMoro's avatar
Derek DeMoro committed
260
                }
Gaston Dombiak's avatar
Gaston Dombiak committed
261 262 263 264 265 266 267 268 269 270 271
                if (errorDelivering) {
                    close();
                    // Retry sending the packet again. Most probably if the packet is a
                    // Message it will be stored offline
                    deliverer.deliver(packet);
                }
                else {
                    // Invoke the interceptors after we have sent the packet
                    InterceptorManager.getInstance().invokeInterceptors(packet, session, false, true);
                    session.incrementServerPacketCount();
                }
272 273 274
            }
            catch (PacketRejectedException e) {
                // An interceptor rejected the packet so do nothing
Matt Tucker's avatar
Matt Tucker committed
275 276 277
            }
        }
    }
278

279 280 281 282 283
    public void deliverRawText(String text) {
        if (!isClosed()) {
            boolean errorDelivering = false;
            synchronized (writer) {
                try {
284 285
                    // Register that we started sending data on the connection
                    SocketSendingTracker.getInstance().socketStartedSending(socket);
286 287 288 289 290 291 292 293 294 295
                    writer.write(text);
                    if (flashClient) {
                        writer.write('\0');
                    }
                    writer.flush();
                }
                catch (IOException e) {
                    Log.debug("Error delivering raw text" + "\n" + this.toString(), e);
                    errorDelivering = true;
                }
296 297 298 299
                finally {
                    // Register that we finished sending data on the connection
                    SocketSendingTracker.getInstance().socketFinishedSending(socket);
                }
300 301 302 303 304 305 306
            }
            if (errorDelivering) {
                close();
            }
        }
    }

307 308 309 310 311 312 313 314 315 316 317 318
    /**
     * Notifies all close listeners that the connection has been closed.
     * Used by subclasses to properly finish closing the connection.
     */
    private void notifyCloseListeners() {
        synchronized (listeners) {
            Iterator itr = listeners.keySet().iterator();
            while (itr.hasNext()) {
                ConnectionCloseListener listener = (ConnectionCloseListener)itr.next();
                listener.onConnectionClose(listeners.get(listener));
            }
        }
319
    }
320 321 322 323

    public String toString() {
        return super.toString() + " socket: " + socket + " session: " + session;
    }
324
}