• Das Erstellen neuer Accounts wurde ausgesetzt. Bei berechtigtem Interesse bitte Kontaktaufnahme über die üblichen Wege. Beste Grüße der Admin

only on()-events tracken??

Paykoman

New member
Hallo liebes Forum,

nun meine Server-Umstrukturierung ist nahezu fertig, die neue Lobby fürs userhandling, helpfer-Funktionen und meinem Spamschutz funktionieren tadellos.
Leider habe ich noch ein klitzekleines Problem das atm meinen SpamSchutz etwas demoliert! =(

Mein Server:
Code:
/** oben der ganze require quatsch und co */

var lobby = new lobby(lobbyOptions, io);

/** Server */
var socket = io.listen(server);
socket = socket.of('/global'); // set namespace
socket.on('connection', function(client) // run server
{
/** connection handling */
    lobby.onConnect(client); // add new socket to lobby, this will authorize with cookie/session-ID
    client.on('reAuth', function(){ lobby.onConnect(client); }); // this for reAuth (if default auth failed will this be called)
    client.on('disconnect', function(){ lobby.onDisconnect(client.uid, client.socketServer, client.id); });

    
    /** emit handlings */
    client.on('testEmit',function(data){
	    console.log('klick received');
	    lobby.deliver( client.uid, 1, {'testReceive': {msg: "server empfang und sendete zurück..."}}, 'main');
	   // client.emit('testReceive', {msg: "server empfang und sendete zurück..."});
	   // io.of('/global').connected[client.id].emit('testReceive', {msg: "Hallo Welt!"} );
	});
});

Die ganze auth Geschichte und neue Struktur klappt wunderbar, ich habe mir ein kleines system gegen Spam ausgedacht, wo nach unterschiedlichen Kriterien ein user spamScores sammelt, beim erreichen einer gewissen Punktezahl wird er gekickt/gebannt. Um die Punkte zu erhöhen nutzte ich derzeit noch einen emit Tracker, so das bei jedem emit ggf. besagte Punkte steigen.

SpamSchutz (in meiner Lobby-Klasse):
Code:
// track each emit of this user
var emit = client.emit;
client.emit = function() {
    if( that.maxSpamCheck(arguments[0], ((that.asOpt.punishDublicates) === true ? JSON.stringify(arguments) : false), client.uid) === true ) // send the emit name then defined emits will not raise the spameScore
    {
        // emit.apply(client, arguments);
    }
};

var $emit = client.$emit;
client.$emit = function() {
    if( that.maxSpamCheck(arguments[0], ((that.asOpt.punishDublicates) === true ? JSON.stringify(arguments) : false), client.uid) === true ) // send the emit name then defined emits will not raise the spameScore
    {
        // $emit.apply(client, arguments);
    }
};

Auch dies klappt, es muss aber umgestellt werden auf die socket.on()-Funktionen und nicht die emits die der Server im Auftrag des Client sendet.
Wenn der Server ein emit vom Client erhält, dies muss vom System gewertet werden und nicht wenn der Client etwas zum server emitet und der Server daraufhin z.B. 10 andere Clients emited.

Schwer zu erklären... Aber ein Beispiel, ein User kommt online, seine Kontaktliste wird abgearbeitet so dass jeder Kontakt der online ist via emit über das onlinekommen benachrichtigt wird. Die obige Funktion würde nun jeden emit für die spam-Kalkulation benutzten, dies darf aber nicht passieren!!! Es dürfen nur emits von des Clienten gewertet werden die von der Webseite zum Server gehen, diese werden ja wie oben im Server-Beispiel durch die "client.on('testEmit',function(data){...}" behandelt, und genau hier muss das System ansetzten und die "Daten" die die Webseiten in namen des Client gesendet hat muss ins Spamsystem gelangen und geprüft/getrackt werden =(

Aktuell würde mir nur eine Manuelle implementierung einfallen, gibt es hier nicht die Möglichkeit die on()-Events genau wie die emits zu tracken?

Manuelle-Lösung wäre so:
Code:
client.on('testEmit',function(data)
{
    if( lobby.checkSpam('testEmit', arguments) ) // die lobby muss dann nach entsprechender Verarbeitung ture oder false liefern um die Anfrage weiter verarbeiten zu können
    {
        lobby.deliver( client.uid, 1, {'testReceive': {msg: "server empfang und sendete zurück..."}}, 'main');
    }
});

Nun das wäre halt sehr unschön, weil ich diese if-Abfrage in jeder Funktion die eben angesprochen werden kann einbauen muss, wie man oben sieht kann die bisherige funktion dann via emit.apply(); den ausstehenden emit ausühren oder eben nicht sowas für die on()-Events wäre wirklich wirklich praktisch!

MFG: Paykoman
PS: wie immer überaus dankbar für eure Unterstützung!
 
Zuletzt bearbeitet:
Du kannst die .on()-Funktion doch genauso manipulieren wie emit. In etwa so:
Code:
var oldOn = client.on;
client.on = function(name, func){
	oldOn.call(this, name, function(){
		if (lobby.checkSpam(name, arguments)){
			func.apply(this, arguments);
		}
	});
};
- ungetestet.

PS: Natürlich darf die Variable oldOn nicht global sein ;)
 
Kleiner Nachtrag,

komisch an der Sache ist, das meine lobby den Job nicht mehr erledigen kann, die socket.io Instanz wird ja als "client" übergeben so das die lobby eben auch socket.io-Kram erledigen wie zuvor auch das mit dem emit das hat auch die lobby übernommen.

Hier mal kurz der Überblick wie ich die Lobby einbinde und so...

SERVER:
Code:
var server = require('http').createServer();
var io = require('socket.io').listen('7979', { log: false }),
    lobby = require('./lobby.js'),
    fs = require('fs'),
    mysql = require("mysql"),
    squel = require("squel"),
    vali = require('validator'),
	striptags = require('striptags'),
	errorlog = 'errorlog/error_dev.txt';

/** Server Settings */
var errorLogger = {
    enabled: false,
    file: 'errorlog/error_dev.txt'
};
var lobbyOptions = { /* options sind hier definiert */ };

// lobby init
var lobby = new lobby(lobbyOptions, io); // gebe io an die lobby damit die lobby emits senden kann etc.

/** Server */
var socket = io.listen(server);
socket = socket.of('/global'); // set namespace
socket.on('connection', function(client) // run server
{
/** connection handling */
    lobby.onConnect(client); // add new socket to lobby, this will authorize with cookie/session-ID
    client.on('reAuth', function(){ lobby.onConnect(client); }); // this for reAuth (if default auth failed will this be called)
    client.on('disconnect', function(){ lobby.onDisconnect(client.uid, client.socketServer, client.id); });
    
/** track each call of this user */
    var fetchOn = ( typeof client.on != 'undefined' ) ? client.on : client.$on;
    client.on = function( name, func ){
        fetchOn.call(this, name, function()
        {
            if( lobby.maxSpamCheck(name, ((lobby.asOpt.punishDublicates) === true ? JSON.stringify(arguments) : false), client.uid) === true ) // send the emit name then defined emits will not raise the spameScore
            {
                func.apply(this, arguments);
            }
        });
    };
});

console.log('Juhu Server running');


lobby (große Datei überflüssigen Kram habe ich raus gemacht zur Übersichtlichkeit) :
Code:
module.exports = lobby;

/**
 * Module dependencies.
 */
var memcache = require("memcache"),
        vali = require('validator');
        
// raus genommen zu viel Platz-verschwendung
    
/**
 * lobby...
 * manage new socket-connections, auth by php-sess, support multiple-tab-connections and handle socket-spam
 */
function lobby(opt, io){
/** global constants */
    var that = this; // refferenz for async functions
    var io = io;
    
/** option-parameter */
    // lobby options
    this.lOpt = extend({ /* options hier */}, opt['lobbyOpt']);
    var useDefinedSockets = ( Object.keys(this.lOpt.sockets).length > 0 ); // save global use the server defined sockets
    var lobbyClearTimer = this.lOpt.removeInterval * 60000;
    
    // antiSpam options
    this.asOpt = extend({ /* options hier */ }, opt['antiSpamOpt']);
    bannTime = this.asOpt.banDuration * 60000; // we save as mili seconds
    
/** lobby loops - init by server start */
    //...
    
/** lobby core */
    // client-handling
    this.onConnect = function(client){
        /**
         * dise funktion holt die session, ist diese existent so wird die sess an this.authenticate() 
         * weiter gereicht so das dort die weiteren Schritte verwaltet werden
         */
        this.authenticate(client, session); // weitergabe der socket.io instanz erfolgt dann hier mit übergabe der session (fehlt jetz hier wo die her kommt, tut aber auch nix zum Thema bei)
    };
    this.authenticate = function(client, session){
        this.debug(3, client.id+' -> addClient() & validation.');
        
        // hier werden Daten bereit gestellt / verarbeitet
        
        if( ipCheck && !isBanned ){
            /** auth success now handling of the client and socket-connection */
            
            // hier ist weiterer connection Kram (gewesen)... :D
            
            // we have now the server so get now the max connections
            var maxCon = ( useDefinedSockets ) ? this.lOpt.socketMaxCon[server] : this.lOpt.socketMaxCon; // check max connections on defined sockets or of single socket
            
            // check max connections on defined sockets. Has limit been reached then disconnect this new connection
            if( /** prüfung ala ban und korrektheit des auth prozesses */ )
            {
                /** anforderung von reAuth */
            }
            else // all is OK - the last steps to finish the connection
            {
                // SOOO HIER wird es interessant, hier erfolgen dann die Eintragung des users in lobby u.s.w. und dann auch das tracking da alles I.O ist!
                
                /** track each call of this user */
                var fetchOn = ( typeof client.on != 'undefined' ) ? client.on : client.$on;
                client.on = function( name, func ){
                    fetchOn.call(this, name, function()
                    {
                        if( that.maxSpamCheck(name, ((that.asOpt.punishDublicates) === true ? JSON.stringify(arguments) : false), client.uid) === true ) // send the emit name then defined emits will not raise the spameScore
                        {
                            func.apply(this, arguments);
                        }
                    });
                };
                
                // das war die alten emit funktionen die uach funktionierten aber eben halt völlig fail waren für diesen Job...
                
                
                // var emit = client.emit;
                // client.emit = function() {
                //     if( that.maxSpamCheck(arguments[0], ((that.asOpt.punishDublicates) === true ? JSON.stringify(arguments) : false), client.uid) === true ) // send the emit name then defined emits will not raise the spameScore
                //     {
                //         // emit.apply(client, arguments);
                //     }
                // };
                
                // var $emit = client.$emit;
                // client.$emit = function() {
                //     if( that.maxSpamCheck(arguments[0], ((that.asOpt.punishDublicates) === true ? JSON.stringify(arguments) : false), client.uid) === true ) // send the emit name then defined emits will not raise the spameScore
                //     {
                //         // $emit.apply(client, arguments);
                //     }
                // };
            }
        }
        else // diconnect with auth is failed (wrong ip or device)
        {
            // hier ist der Kram für fehlgeschlagenes aut, disconnect() erfolgt hier
        }
    }
    this.onDisconnect = function( userID, server, socketID ){ // this func remove only a socket-id on the connection-list
        // hier werden die user bei disconnect() aus der lobby entfernt und offline-status an jeweilige Kontakte gesendet
    };
    
    // emit to contactlist, selected contacts, subscribers or to a user on all connections or to a user self for sync to all connections
    
    // send onlinestatus to users contactlist
    
    // helper
    
/** antiSpam loops - init by server start */
    
/** antiSpam core */
    
}

Und nun ja client steht an benötigter stelle zur Verfügung und beim server war die Manipulation natürlich ausgeklammert als ich getestet habe ob die lobby den Job wieder übernehmen kann, wäre nämlich schöner es nicht im Server haben zu müssen.

Habe noch einen kleinen Nachtrag =(
Undzwar kommen die übermittelten Argumente nicht bei der Funktion an =(

Code:
/** track each call of this user */
var fetchOn = ( typeof client.on != 'undefined' ) ? client.on : client.$on;
client.on = function( name, func ){
    fetchOn.call(this, name, function()
    {
        var args = ( typeof arguments[0] != 'undefines' ) ? arguments[0] : arguments;
        if( lobby.maxSpamCheck(name, ((lobby.asOpt.punishDublicates) === true ? JSON.stringify(args) : false), client.uid) === true ) // send the emit name then defined emits will not raise the spameScore
        {
            func.apply(this, args); // hier können wohl keine args übermittelt werden -,-
        }
    }, arguments); // hier muss es hin
};

client.on('searchbar',function(data){
    console.log('go search');
    console.log(data); // undefined erscheint im SSH Terminal :(
});
 
Zuletzt bearbeitet:
Warum erzeugst du die args-Variable (die du auch noch falsch erzeugst...)? Nimm einfach arguments und es sollte funktionieren...

Und das arguments im .call() ergibt gar keinen Sinn.
 
Zurück
Oben