comparison oscgroups/GroupServer.cpp @ 76:0ae87af84e2f

added oscgroups

+/*
+OSCgroups -- open sound control groupcasting infrastructure
+Copyright (C) 2005  Ross Bencina
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+#include "GroupServer.h"
+
+#include <string>
+#include <set>
+#include <iostream>
+#include <ctime>
+#include <algorithm>
+#include <iterator>
+#include <cassert>
+#include <cstring>
+
+#include "ip/NetworkingUtils.h"
+
+#if defined(__BORLANDC__) // workaround for BCB4 release build intrinsics bug
+namespace std {
+using ::__strcpy__;  // avoid error: E2316 '__strcpy__' is not a member of 'std'.
+}
+#endif
+
+/*
+TODO:
+    switch to using char * instead of string:: to avoid allocating new strings
+    every time we execute a find()
+*/
+
+
+static std::ostream& Log()
+{
+    std::time_t t;
+    std::time( &t );
+
+    // ctime() returns a constant width 26 char string including trailing \0
+    // the fields are all constant width.
+    char s[26];
+    std::strcpy( s, std::ctime( &t ) );
+    s[24] = '\0'; // remove trailing null
+
+    std::cout << s << ": ";
+    return std::cout;
+}
+
+
+GroupServer::GroupServer( int timeoutSeconds, int maxUsers, int maxGroups )
+    : timeoutSeconds_( timeoutSeconds )
+    , maxUsers_( maxUsers )
+    , maxGroups_( maxGroups )
+    , userCount_( 0 )
+    , groupCount_( 0 )
+{
+
+}
+
+
+GroupServer::~GroupServer()
+{
+    for( const_user_iterator i = users_begin(); i != users_end(); ++i )
+        delete i->second;
+    for( const_group_iterator i = groups_begin(); i != groups_end(); ++i )
+        delete i->second;
+}
+
+
+User *GroupServer::CreateUser( const char *userName, const char *userPassword )
+{
+    Log() << "creating user '" << userName << "'." << std::endl;
+    
+    User *user = new User( userName, userPassword );
+    std::pair<user_iterator,bool> r =
+            users_.insert( std::make_pair( user->name, user ) );
+    // we assume the caller didn't try to create a user with an existing name
+    assert( r.second == true );
+    ++userCount_;
+
+    return user;
+}
+
+
+User *GroupServer::FindUser( const char *userName )
+{
+    user_iterator user = users_.find( userName );
+
+    return ( user != users_.end() ) ? user->second : (User*) 0;
+}
+
+
+void GroupServer::PurgeStaleUsers()
+{
+    std::time_t currentTime = std::time(0);
+    
+    for( std::map< std::string, User* >::iterator i = users_.begin();
+            i != users_.end(); /* nothing */ ){
+
+        unsigned long inactiveSeconds =
+                i->second->SecondsSinceLastAliveReceived( currentTime );
+        if( inactiveSeconds >= (unsigned int)timeoutSeconds_ ){
+            Log() << "purging user '" << i->second->name << "' after "
+                    << inactiveSeconds << " seconds of inactivity." << std::endl;
+
+            SeparateUserFromAllGroups( i->second );
+            delete i->second;
+            --userCount_;
+                
+            // i think this is safe, we increment i before erasing the
+            // element referenced by its old value...
+            std::map< std::string, User* >::iterator j = i;
+            ++i;
+            users_.erase( j );
+        }else{
+            ++i;
+        }
+    }
+}
+
+
+Group *GroupServer::CreateGroup(
+        const char *groupName, const char *groupPassword )
+{
+    Log() << "creating group '" << groupName << "'." << std::endl;
+    
+    Group *group = new Group( groupName, groupPassword );
+    std::pair<group_iterator, bool> r =
+            groups_.insert( std::make_pair( group->name, group ) );
+    // we assume the caller didn't try to create an existing group
+    assert( r.second == true );
+    ++groupCount_;
+
+    return group;
+}
+
+
+Group *GroupServer::FindGroup( const char *groupName )
+{
+    group_iterator group = groups_.find( groupName );
+
+    return ( group != groups_.end() ) ? group->second : (Group*) 0;
+}
+
+
+// The User <-> Group relation is managed as a bidirectional link (each User
+// contains a set of groups which it is associated with, and each Group
+// maintains a set of Users which it is associated with). The Associate*
+// and Separate* methods below create and destroy the bidirectional link
+// RemoveUserReferenceFromGroup is a helper function which only destroys
+// one side of the link.
+
+void GroupServer::AssociateUserWithGroup( User *user, Group* group )
+{
+    Log() << "adding user '" << user->name
+            << "' to group '" << group->name << "'." << std::endl;
+    
+    user->groups_.insert( group );
+    group->users_.insert( user );
+}
+
+
+void GroupServer::RemoveUserReferenceFromGroup( User *user, Group* group )
+{
+    Log() << "removing user '" << user->name
+            << "' from group '" << group->name << "'." << std::endl;
+    
+    std::set< User* >::iterator i = group->users_.find( user );
+    assert( i != group->users_.end() );
+
+    group->users_.erase( i );
+
+    if( group->users_.empty() ){
+        Log() << "purging empty group '" << group->name << "'." << std::endl;
+        
+        groups_.erase( group->name );
+        delete group;
+        --groupCount_;
+    }
+}
+
+
+void GroupServer::SeparateUserFromGroup( User *user, Group* group )
+{
+    user->groups_.erase( group );
+    RemoveUserReferenceFromGroup( user, group );
+}
+
+
+void GroupServer::SeparateUserFromAllGroups( User *user )
+{
+    for( std::set<Group*>::iterator i = user->groups_.begin();
+            i != user->groups_.end(); ++i ){
+
+        RemoveUserReferenceFromGroup( user, *i);
+    }
+
+    user->groups_.clear();
+}
+
+
+static void UpdateEndpoint( IpEndpointName& dest, const IpEndpointName& src,
+        const char *userName, const char *whichEndpoint )
+{
+    if( dest != src ){
+
+		char endpointString[ IpEndpointName::ADDRESS_AND_PORT_STRING_LENGTH ];
+		src.AddressAndPortAsString( endpointString );
+
+        Log() << "updating " << whichEndpoint << " endpoint for user '"
+                << userName << "' to " << endpointString << "." << std::endl;
+
+        dest = src;
+    }
+}
+
+
+GroupServer::UserStatus GroupServer::UserAlive(
+        const char *userName, const char *userPassword,
+        const IpEndpointName& privateEndpoint,
+		const IpEndpointName& publicEndpoint,
+        const char **groupNamesAndPasswords,
+        UserStatus *userGroupsStatus, int groupCount )
+{
+    // find or create the user, aborting if the password for an existing
+    // user is incorrect, or if the maximum number of users has been reached
+
+    User *user = FindUser( userName );
+    if( user ){
+        if( user->password.compare( userPassword ) != 0 ){
+            Log() << "attempt to update user '"
+                    << userName << "' with incorrect password." << std::endl;
+            return USER_STATUS_WRONG_PASSWORD;
+        }
+    }else{
+        if( userCount_ == maxUsers_ ){
+            Log() << "user limit reached, user '"
+                    << userName << "' not admitted." << std::endl;
+            return USER_STATUS_SERVER_LIMIT_REACHED;
+        }else{
+            user = CreateUser( userName, userPassword );
+        }
+    }
+
+    UpdateEndpoint(
+            user->privateEndpoint, privateEndpoint, userName, "private" );
+    UpdateEndpoint( user->publicEndpoint, publicEndpoint, userName, "public" );
+
+    user->lastAliveMessageArrivalTime = time(0);
+
+
+    // previousButNotCurrentGroups begins containing all the groups the user
+    // was in before the current message was received. We remove those which
+    // the user is still a member of, leaving the set that the user is no
+    // longer a member of. We then use the set to remove associations with
+    // non-current groups.
+
+    std::set<Group*> previousButNotCurrentGroups( user->groups_ );
+
+    for( int i=0; i < groupCount; ++i ){
+        const char *groupName = groupNamesAndPasswords[i*2];
+        const char *groupPassword = groupNamesAndPasswords[i*2 + 1];
+
+        Group *group = FindGroup( groupName );
+        if( group ){
+            if( user->IsMemberOf( group ) ){
+                // check that previousButNotCurrentGroups contains group before
+                // removing it. it won't if we were passed the same group
+                // multiple times
+                std::set<Group*>::iterator j =
+                        previousButNotCurrentGroups.find( group );
+                if( j != previousButNotCurrentGroups.end() )
+                    previousButNotCurrentGroups.erase( j );
+
+                userGroupsStatus[i] = USER_STATUS_OK;
+            }else{
+                // user isn't in group so join it
+                if( group->password.compare( groupPassword ) == 0 ){
+                    AssociateUserWithGroup( user, group );
+                    userGroupsStatus[i] = USER_STATUS_OK;
+                }else{                                   
+                    userGroupsStatus[i] = USER_STATUS_WRONG_PASSWORD;
+                }
+            }
+        }else{  // group doesn't exist
+            if( groupCount_ == maxGroups_ ){
+                Log() << "group limit reached, group '"
+                        << groupName << "' not created." << std::endl;
+                userGroupsStatus[i] = USER_STATUS_SERVER_LIMIT_REACHED;
+            }else{
+                group = CreateGroup( groupName, groupPassword );
+                AssociateUserWithGroup( user, group );
+                userGroupsStatus[i] = USER_STATUS_OK;
+            }
+        }
+    }
+
+    for( std::set<Group*>::iterator j = previousButNotCurrentGroups.begin();
+            j != previousButNotCurrentGroups.end(); ++j ){
+
+        SeparateUserFromGroup( user, *j );
+    }
+
+    return USER_STATUS_OK;
+}
+