RubyGems - xmppify - Versions diffs - 0.0.12 - Mend

xmppify 0.0.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (120) hide show

data/app/assets/javascripts/xmpp/strophejs-plugins/register/README.markdown ADDED Viewed

@@ -0,0 +1,44 @@
+# strophe.register.js
+A Strophe Plugin for In-Band Registration.
+( [XEP 0077](http://xmpp.org/extensions/xep-0077.html) )
+## Usage
+Just link the register plugin below the strophe library in your HTML head
+section:
+``` html
+<head>
+<!-- ... -->
+<script type="text/javascript" src="strophe.min.js"></script>
+<script type="text/javascript" src="strophe.register.js"></script>
+<!-- ... -->
+</head>
+```
+Before you connect:
+``` javascript
+var callback = function (status) {
+    if (status === Strophe.Status.REGISTER) {
+        connection.register.fields.username = "juliet";
+        connection.register.fields.password = "R0m30";
+        connection.register.submit();
+    } else if (status === Strophe.Status.REGISTERED) {
+        console.log("registered!");
+        connection.authenticate();
+    } else if (status === Strophe.Status.CONNECTED) {
+        console.log("logged in!");
+    } else {
+        // every other status a connection.connect would receive
+    }
+};
+connection.register.connect("example.com", callback, wait, hold);
+```
+After that you're logged in with a fresh smelling jid.
+## ToDo
+- write specs

data/app/assets/javascripts/xmpp/strophejs-plugins/register/strophe.register.js ADDED Viewed

@@ -0,0 +1,431 @@
+/*
+This library is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published
+ by the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+ .
+ This library is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+ General Public License for more details.
+  Copyright (c) dodo <dodo@blacksec.org>, 2011
+*/
+/**
+* File: strophe.register.js
+* A Strophe plugin for XMPP In-Band Registration.
+*/
+Strophe.addConnectionPlugin('register', {
+    _connection: null,
+    //The plugin must have the init function.
+    init: function(conn) {
+        this._connection = conn;
+        // compute free emun index number
+        var i = 0;
+        Object.keys(Strophe.Status).forEach(function (key) {
+            i = Math.max(i, Strophe.Status[key]);
+        });
+        /* extend name space
+         *  NS.REGISTER - In-Band Registration
+         *              from XEP 77.
+         */
+        Strophe.addNamespace('REGISTER', 'jabber:iq:register');
+        Strophe.Status.REGISTERING = i + 1;
+        Strophe.Status.REGIFAIL    = i + 2;
+        Strophe.Status.REGISTER    = i + 3;
+        Strophe.Status.SUBMITTING  = i + 4;
+        Strophe.Status.SBMTFAIL    = i + 5;
+        Strophe.Status.REGISTERED  = i + 6;
+        if (conn.disco)
+            conn.disco.addFeature(Strophe.NS.REGISTER);
+        // hooking strophe's connection.reset
+        var self = this, reset = conn.reset;
+        conn.reset = function () {
+            reset();
+            self.instructions = "";
+            self.fields = {};
+            self.authentication = {};
+            self.registered = false;
+            self.enabled = null;
+        };
+    },
+    /** Function: connect
+     *  Starts the registration process.
+     *
+     *  As the registration process proceeds, the user supplied callback will
+     *  be triggered multiple times with status updates.  The callback
+     *  should take two arguments - the status code and the error condition.
+     *
+     *  The status code will be one of the values in the Strophe.Status
+     *  constants.  The error condition will be one of the conditions
+     *  defined in RFC 3920 or the condition 'strophe-parsererror'.
+     *
+     *  Please see XEP 77 for a more detailed explanation of the optional
+     *  parameters below.
+     *
+     *  Parameters:
+     *    (String) domain - The xmpp server's Domain.  This will be the server,
+     *      which will be contacted to register a new JID.
+     *      The server has to provide and allow In-Band Registration (XEP-0077).
+     *    (Function) callback The connect callback function.
+     *    (Integer) wait - The optional HTTPBIND wait value.  This is the
+     *      time the server will wait before returning an empty result for
+     *      a request.  The default setting of 60 seconds is recommended.
+     *      Other settings will require tweaks to the Strophe.TIMEOUT value.
+     *    (Integer) hold - The optional HTTPBIND hold value.  This is the
+     *      number of connections the server will hold at one time.  This
+     *      should almost always be set to 1 (the default).
+     */
+    connect: function (domain, callback, wait, hold) {
+        var that = this._connection;
+        this.instructions = "";
+        this.fields = {};
+        this.authentication = {};
+        this.registered = false;
+        this.enabled = false;
+        that.connect_callback = callback;
+        that.connected = false;
+        that.authenticated = false;
+        that.disconnecting = false;
+        that.errors = 0;
+        that.domain = domain || that.domain;
+        that.wait = wait || that.wait;
+        that.hold = hold || that.hold;
+        // build the body tag
+        var body = that._buildBody().attrs({
+            to: that.domain,
+            "xml:lang": "en",
+            wait: that.wait,
+            hold: that.hold,
+            content: "text/xml; charset=utf-8",
+            ver: "1.6",
+            "xmpp:version": "1.0",
+            "xmlns:xmpp": Strophe.NS.BOSH
+        });
+        that._changeConnectStatus(Strophe.Status.CONNECTING, null);
+        that._requests.push(
+            new Strophe.Request(body.tree(),
+                                that._onRequestStateChange.bind(
+                                    that, this._register_cb.bind(this)),
+                                body.tree().getAttribute("rid")));
+        that._throttledRequestHandler();
+    },
+    /** PrivateFunction: _register_cb
+     *  _Private_ handler for initial registration request.
+     *
+     *  This handler is used to process the initial registration request
+     *  response from the BOSH server. It is used to set up a bosh session
+     *  and requesting registration fields from host.
+     *
+     *  Parameters:
+     *    (Strophe.Request) req - The current request.
+     */
+    _register_cb: function (req) {
+        var that = this._connection;
+        Strophe.info("_register_cb was called");
+        that.connected = true;
+        var bodyWrap = req.getResponse();
+        if (!bodyWrap) { return; }
+        if (that.xmlInput !== Strophe.Connection.prototype.xmlInput) {
+            that.xmlInput(bodyWrap);
+        }
+        if (that.rawInput !== Strophe.Connection.prototype.rawInput) {
+            that.rawInput(Strophe.serialize(bodyWrap));
+        }
+        var typ = bodyWrap.getAttribute("type");
+        var cond, conflict;
+        if (typ !== null && typ == "terminate") {
+            // an error occurred
+            cond = bodyWrap.getAttribute("condition");
+            conflict = bodyWrap.getElementsByTagName("conflict");
+            if (cond !== null) {
+                if (cond == "remote-stream-error" && conflict.length > 0) {
+                    cond = "conflict";
+                }
+                that._changeConnectStatus(Strophe.Status.CONNFAIL, cond);
+            } else {
+                that._changeConnectStatus(Strophe.Status.CONNFAIL, "unknown");
+            }
+            return;
+        }
+        // check to make sure we don't overwrite these if _connect_cb is
+        // called multiple times in the case of missing stream:features
+        if (!that.sid) {
+            that.sid = bodyWrap.getAttribute("sid");
+        }
+        if (!that.stream_id) {
+            that.stream_id = bodyWrap.getAttribute("authid");
+        }
+        var wind = bodyWrap.getAttribute('requests');
+        if (wind) { that.window = parseInt(wind, 10); }
+        var hold = bodyWrap.getAttribute('hold');
+        if (hold) { that.hold = parseInt(hold, 10); }
+        var wait = bodyWrap.getAttribute('wait');
+        if (wait) { that.wait = parseInt(wait, 10); }
+        var register, mechanisms;
+        register = bodyWrap.getElementsByTagName("register");
+        mechanisms = bodyWrap.getElementsByTagName("mechanism");
+        if (register.length === 0 && mechanisms.length === 0) {
+            // we didn't get stream:features yet, so we need wait for it
+            // by sending a blank poll request
+            var body = that._buildBody();
+            that._requests.push(
+                new Strophe.Request(body.tree(),
+                                    that._onRequestStateChange.bind(
+                                        that, this._register_cb.bind(this)),
+                                    body.tree().getAttribute("rid")));
+            that._throttledRequestHandler();
+            return;
+        }
+        var i, mech;
+        for (i = 0; i < mechanisms.length; i++) {
+            mech = Strophe.getText(mechanisms[i]);
+            if (mech == 'DIGEST-MD5') {
+                this.authentication.sasl_digest_md5 = true;
+            } else if (mech == 'PLAIN') {
+                this.authentication.sasl_plain = true;
+            } else if (mech == 'ANONYMOUS') {
+                this.authentication.sasl_anonymous = true;
+            }
+        }
+        if (register.length === 0) {
+            that._changeConnectStatus(Strophe.Status.REGIFAIL, null);
+            return;
+        } else this.enabled = true;
+        // send a get request for registration, to get all required data fields
+        that._changeConnectStatus(Strophe.Status.REGISTERING, null);
+        that._addSysHandler(this._get_register_cb.bind(this),
+                            null, "iq", null, null);
+        that.send($iq({type: "get"}).c("query",
+            {xmlns: Strophe.NS.REGISTER}).tree());
+    },
+    /** PrivateFunction: _get_register_cb
+     *  _Private_ handler for Registration Fields Request.
+     *
+     *  Parameters:
+     *    (XMLElement) elem - The query stanza.
+     *
+     *  Returns:
+     *    false to remove the handler.
+     */
+    _get_register_cb: function (stanza) {
+        var i, query, field, that = this._connection;
+        query = stanza.getElementsByTagName("query");
+        if (query.length !== 1) {
+            that._changeConnectStatus(Strophe.Status.REGIFAIL, "unknown");
+            return false;
+        }
+        query = query[0];
+        // get required fields
+        for (i = 0; i < query.childNodes.length; i++) {
+            field = query.childNodes[i];
+            if (field.tagName.toLowerCase() === 'instructions') {
+                // this is a special element
+                // it provides info about given data fields in a textual way.
+                this.instructions = Strophe.getText(field);
+                continue;
+            } else if (field.tagName.toLowerCase() === 'x') {
+                // ignore x for now
+                continue;
+            }
+            this.fields[field.tagName.toLowerCase()] = Strophe.getText(field);
+        }
+        that._changeConnectStatus(Strophe.Status.REGISTER, null);
+        return false;
+    },
+    /** Function: submit
+     *  Submits Registration data.
+     *
+     *  As the registration process proceeds, the user supplied callback will
+     *  be triggered with status code Strophe.Status.REGISTER. At this point
+     *  the user should fill all required fields in connection.register.fields
+     *  and invoke this function to procceed in the registration process.
+     */
+    submit: function () {
+        var i, name, query, fields, that = this._connection;
+        query = $iq({type: "set"}).c("query", {xmlns:Strophe.NS.REGISTER});
+        // set required fields
+        fields = Object.keys(this.fields);
+        for (i = 0; i < fields.length; i++) {
+            name = fields[i];
+            query.c(name).t(this.fields[name]).up();
+        }
+                // providing required information
+        that._changeConnectStatus(Strophe.Status.SUBMITTING, null);
+        that._addSysHandler(this._submit_cb.bind(this),
+                            null, "iq", null, null);
+        that.send(query);
+    },
+    /** PrivateFunction: _submit_cb
+     *  _Private_ handler for submitted registration information.
+     *
+     *  Parameters:
+     *    (XMLElement) elem - The query stanza.
+     *
+     *  Returns:
+     *    false to remove the handler.
+     */
+    _submit_cb: function (stanza) {
+        var i, query, field, error = null, that = this._connection;
+        query = stanza.getElementsByTagName("query");
+        if (query.length > 0) {
+            query = query[0];
+            // update fields
+            for (i = 0; i < query.childNodes.length; i++) {
+                field = query.childNodes[i];
+                if (field.tagName.toLowerCase() === 'instructions') {
+                    // this is a special element
+                    // it provides info about given data fields in a textual way
+                    this.instructions = Strophe.getText(field);
+                    continue;
+                }
+                this.fields[field.tagName.toLowerCase()]=Strophe.getText(field);
+            }
+        }
+        console.log(stanza);
+        if (stanza.getAttribute("type") === "error") {
+            error = stanza.getElementsByTagName("error");
+            if (error.length !== 1) {
+                that._changeConnectStatus(Strophe.Status.SBMTFAIL, "unknown");
+                return false;
+            }
+            // this is either 'conflict' or 'not-acceptable'
+            error = error[0].firstChild.tagName.toLowerCase();
+            if (error === 'conflict')
+                // already registered
+                this.registered = true;
+        } else
+            this.registered = true;
+        if (this.registered) {
+            that.jid  = this.fields.username + "@" + that.domain;
+            that.pass = this.fields.password;
+        }
+        if (error === null) {
+            console.log("Registered successful.");
+            that._changeConnectStatus(Strophe.Status.REGISTERED, null);
+        } else {
+            console.log("Registration failed.");
+            that._changeConnectStatus(Strophe.Status.SBMTFAIL, error);
+        }
+        return false;
+    },
+    /** Function: authenticate
+     *  Login with newly registered account.
+     *
+     *  This is just a helper function to authenticate with the new account of
+     *  the successful registration. This is recommended to do in the
+     *  user supplied callback when receiving Strophe.Status.REGISTERED.
+     *  It is also possible to do it on Strophe.Status.SBMTFAIL when
+     *  connection.register.registered is true under the circumstances that an
+     *  already existing account with the appendant password was supplied.
+     */
+    authenticate: function () {
+        var auth_str, hashed_auth_str, that = this._connection;
+        if (Strophe.getNodeFromJid(that.jid) === null &&
+            this.authentication.sasl_anonymous) {
+            that._changeConnectStatus(Strophe.Status.AUTHENTICATING, null);
+            that._sasl_success_handler = that._addSysHandler(
+                that._sasl_success_cb.bind(that), null,
+                "success", null, null);
+            that._sasl_failure_handler = that._addSysHandler(
+                that._sasl_failure_cb.bind(that), null,
+                "failure", null, null);
+            that.send($build("auth", {
+                xmlns: Strophe.NS.SASL,
+                mechanism: "ANONYMOUS"
+            }).tree());
+        } else if (Strophe.getNodeFromJid(that.jid) === null) {
+            // we don't have a node, which is required for non-anonymous
+            // client connections
+            that._changeConnectStatus(Strophe.Status.CONNFAIL,
+                                      'x-strophe-bad-non-anon-jid');
+            that.disconnect();
+        } else if (this.authentication.sasl_digest_md5) {
+            that._changeConnectStatus(Strophe.Status.AUTHENTICATING, null);
+            that._sasl_challenge_handler = that._addSysHandler(
+                that._sasl_challenge1_cb.bind(that), null,
+                "challenge", null, null);
+            that._sasl_failure_handler = that._addSysHandler(
+                that._sasl_failure_cb.bind(that), null,
+                "failure", null, null);
+            that.send($build("auth", {
+                xmlns: Strophe.NS.SASL,
+                mechanism: "DIGEST-MD5"
+            }).tree());
+        } else if (this.authentication.sasl_plain) {
+            // Build the plain auth string (barejid null
+            // username null password) and base 64 encoded.
+            auth_str = Strophe.getBareJidFromJid(that.jid);
+            auth_str = auth_str + "\u0000";
+            auth_str = auth_str + Strophe.getNodeFromJid(that.jid);
+            auth_str = auth_str + "\u0000";
+            auth_str = auth_str + that.pass;
+            that._changeConnectStatus(Strophe.Status.AUTHENTICATING, null);
+            that._sasl_success_handler = that._addSysHandler(
+                that._sasl_success_cb.bind(that), null,
+                "success", null, null);
+            that._sasl_failure_handler = that._addSysHandler(
+                that._sasl_failure_cb.bind(that), null,
+                "failure", null, null);
+            hashed_auth_str = Base64.encode(auth_str);
+            that.send($build("auth", {
+                xmlns: Strophe.NS.SASL,
+                mechanism: "PLAIN"
+            }).t(hashed_auth_str).tree());
+        } else {
+            that._changeConnectStatus(Strophe.Status.AUTHENTICATING, null);
+            that._addSysHandler(that._auth1_cb.bind(that), null, null,
+                                null, "_auth_1");
+            that.send($iq({
+                type: "get",
+                to: that.domain,
+                id: "_auth_1"
+            }).c("query", {
+                xmlns: Strophe.NS.AUTH
+            }).c("username", {}).t(Strophe.getNodeFromJid(that.jid)).tree());
+        }
+    },
+});

data/app/assets/javascripts/xmpp/strophejs-plugins/roster/public/javascript/strophe.roster.js ADDED Viewed

@@ -0,0 +1,40 @@
+(function(Strophe) {
+	// only presence based, add roster later if needed, see chapter14
+	function log(msg) {
+		if (window.console) {
+			console.log('roster.' + msg);
+		}
+	}
+	var roster = {
+		init: function (conn) {
+			this._conn = conn;
+			this.contacts = {};
+			Strophe.addNamespace('ROSTER', 'jabber:iq:roster');
+		},
+		statusChanged: function (status) {
+			if (status === Strophe.Status.CONNECTED) {
+				this._conn.send($pres());
+				this._conn.addHandler(this.presenceChanged.bind(this),
+									  null, "presence");
+			}
+		},
+		presenceChanged: function(pres) {
+			var from = pres.getAttribute('from');
+			var type = pres.getAttribute('type') || "available";
+			if (from !== this._conn.jid) {
+				this.contacts[from] = type;
+				if (type === "unavailable") {
+					delete this.contacts[from];
+				}
+				this.onPresenceChanged(from,type);
+			}
+			return true;
+		},
+		onPresenceChanged: function(from,type) {
+			log('onPresenceChanged: ' + from + " => " + type);
+		}
+	};
+	Strophe.addConnectionPlugin('roster', roster);
+})(Strophe);

data/app/assets/javascripts/xmpp/strophejs-plugins/roster/spec/strophe.roster.spec.js ADDED Viewed

@@ -0,0 +1,65 @@
+describe("Roster", function() {
+	var conn, roster;
+	beforeEach(function() {
+		conn = new Strophe.Connection();
+		roster = conn.roster;
+		conn._changeConnectStatus(Strophe.Status.CONNECTED);
+		conn.authenticated = true;
+	});
+	it("adds contacts on presence stanza", function() {
+		var pres = $pres({from: 'n@d/r'});
+		conn._dataRecv(createRequest(pres));
+		expect(conn.roster.contacts).toEqual({'n@d/r': 'available'});
+	});
+	it("removes contacts on presence stanza where type is unavailable", function() {
+		var pres = $pres({from: 'n@d/r', type: 'unavailable'});
+		conn.roster.contacts = { 'n@d/r': 'available'};
+		conn._dataRecv(createRequest(pres));
+		expect(conn.roster.contacts).toEqual({});
+	});
+	it("calls callback on presence stanza", function() {
+		spyOn(roster,'onPresenceChanged').andCallThrough();
+		var pres = $pres({from: 'n@d/r'});
+		conn._dataRecv(createRequest(pres));
+		expect(conn.roster.contacts).toEqual({'n@d/r': 'available'});
+		expect(roster.onPresenceChanged).toHaveBeenCalledWith('n@d/r','available');
+		pres = $pres({from: 'n@d/r', type: 'unavailable'});
+		conn._dataRecv(createRequest(pres));
+		expect(conn.roster.contacts).toEqual({});
+		expect(roster.onPresenceChanged).toHaveBeenCalledWith('n@d/r','unavailable');
+	});
+	describe("state and callback", function() {
+		var c1, c2;
+		beforeEach(function() {
+			c1 = new Strophe.Connection();
+			c2 = new Strophe.Connection();
+			c1._changeConnectStatus(Strophe.Status.CONNECTED);
+			c2._changeConnectStatus(Strophe.Status.CONNECTED);
+			c1.authenticated = c2.authenticated = true;
+		});
+		it("allows per connection contacts", function() {
+			var pres = $pres({from: 'n@d/r'});
+			c1._dataRecv(createRequest(pres));
+			expect(c2.roster.contacts).toEqual({});
+			expect(c1.roster.contacts).toEqual({'n@d/r': 'available'});
+		});
+		it("allows per connection callbacks", function() {
+			var pres = $pres({from: 'n@d/r'});
+			var cb = jasmine.createSpy();
+			spyOn(c1.roster,'onPresenceChanged').andCallThrough();
+			c2.roster.onPresenceChanged = cb;
+			c1._dataRecv(createRequest(pres));
+			c2._dataRecv(createRequest(pres));
+			expect(cb).toHaveBeenCalled();
+			expect(cb.callCount).toEqual(1);
+			expect(c1.roster.onPresenceChanged.callCount).toEqual(1);
+		});
+	});
+});

data/app/assets/javascripts/xmpp/strophejs-plugins/roster/spec/support/jasmine.json ADDED Viewed

@@ -0,0 +1,15 @@
+{
+ "src_dir"  : "/public/javascript/",
+ "spec_dir" : "/spec/",
+ "server":{
+   "port":8124
+ },
+ "externals":[
+  "https://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min.js",
+  "https://github.com/velesin/jasmine-jquery/raw/master/lib/jasmine-jquery.js",
+  "http://localhost/strophe.js",
+  "http://localhost/Stanzas.js"
+ ]
+}