diff --git a/lib/jam_ruby/message_factory.rb b/lib/jam_ruby/message_factory.rb
index 89f8f6ca2..96912edee 100644
--- a/lib/jam_ruby/message_factory.rb
+++ b/lib/jam_ruby/message_factory.rb
@@ -6,15 +6,16 @@
     SERVER_TARGET         = "server"
     SESSION_TARGET_PREFIX = "session:"
     USER_TARGET_PREFIX    = "user:"
+    CLIENT_TARGET_PREFIX  = "client:"
+
 
-	
 
     def initialize()
 			@type_values = {}
-			
+
 			Jampb::ClientMessage::Type.constants.each do |constant|
-				@type_values[Jampb::ClientMessage::Type.const_get(constant)] = constant  
-			end       
+				@type_values[Jampb::ClientMessage::Type.const_get(constant)] = constant
+			end
 
     end
 
@@ -24,75 +25,103 @@
 		end
 
     # create a login message using user/pass
-    def login_with_user_pass(username, password)
-      login = Jampb::Login.new(:username => username, :password => password)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN, :target => SERVER_TARGET, :login => login)
+    def login_with_user_pass(username, password, options = {})
+      login = Jampb::Login.new(:username => username, :password => password, :client_id => options[:client_id])
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN, :route_to => SERVER_TARGET, :login => login)
     end
 
-    # create a login message using token (a cookie or similiar)
-    def login_with_token(token)
-      login = Jampb::Login.new(:token => token)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN, :target => SERVER_TARGET, :login => login)
+    # create a login message using token (a cookie or similar)
+    def login_with_token(token, options = {})
+      login = Jampb::Login.new(:token => token, :client_id => options[:client_id])
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN, :route_to => SERVER_TARGET, :login => login)
     end
 
     # create a login ack (login was successful)
-    def login_ack(public_ip)
-      login_ack = Jampb::LoginAck.new(:public_ip => public_ip)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_ACK, :target => CLIENT_TARGET, :login_ack => login_ack)
+    def login_ack(public_ip, client_id, token)
+      login_ack = Jampb::LoginAck.new(:public_ip => public_ip, :client_id => client_id, :token => token)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_ACK, :route_to => CLIENT_TARGET, :login_ack => login_ack)
     end
 
     # create a music session login message
     def login_music_session(music_session)
       login_music_session = Jampb::LoginMusicSession.new(:music_session => music_session)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_MUSIC_SESSION, :target => SERVER_TARGET, :login_music_session => login_music_session)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_MUSIC_SESSION, :route_to => SERVER_TARGET, :login_music_session => login_music_session)
     end
 
     # create a music session login message ack (success or on failure)
     def login_music_session_ack(error, error_reason)
       login_music_session_ack = Jampb::LoginMusicSessionAck.new(:error => error, :error_reason => error_reason)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_MUSIC_SESSION_ACK, :target => CLIENT_TARGET, :login_music_session_ack => login_music_session_ack)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LOGIN_MUSIC_SESSION_ACK, :route_to => CLIENT_TARGET, :login_music_session_ack => login_music_session_ack)
     end
 
     # create a music session 'leave session' message
     def leave_music_session(music_session)
       leave_music_session = Jampb::LeaveMusicSession.new(:music_session => music_session)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LEAVE_MUSIC_SESSION, :target => SERVER_TARGET, :leave_music_session => leave_music_session)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LEAVE_MUSIC_SESSION, :route_to => SERVER_TARGET, :leave_music_session => leave_music_session)
     end
 
     # create a music session leave message ack (success or on failure)
     def leave_music_session_ack(error, error_reason)
       leave_music_session_ack = Jampb::LeaveMusicSessionAck.new(:error => error, :error_reason => error_reason)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LEAVE_MUSIC_SESSION_ACK, :target => CLIENT_TARGET, :leave_music_session_ack => leave_music_session_ack)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::LEAVE_MUSIC_SESSION_ACK, :route_to => CLIENT_TARGET, :leave_music_session_ack => leave_music_session_ack)
     end
 
 		# create a server error
     def server_generic_error(error_msg)
       error = Jampb::ServerGenericError.new(:error_msg => error_msg)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::SERVER_GENERIC_ERROR, :target => CLIENT_TARGET, :server_generic_error => error)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::SERVER_GENERIC_ERROR, :route_to => CLIENT_TARGET, :server_generic_error => error)
     end
 
 		# create a server rejection error
     def server_rejection_error(error_msg)
       error = Jampb::ServerRejectionError.new(:error_msg => error_msg)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::SERVER_REJECTION_ERROR, :target => CLIENT_TARGET, :server_rejection_error => error)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::SERVER_REJECTION_ERROR, :route_to => CLIENT_TARGET, :server_rejection_error => error)
     end
 
-    # create a user-joined session messag
+    # create a server rejection error
+    def server_permission_error(original_message_id, error_msg)
+      error = Jampb::ServerPermissionError.new(:error_msg => error_msg)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::SERVER_PERMISSION_ERROR, :route_to => CLIENT_TARGET, :server_permission_error => error, :in_reply_to => original_message_id)
+    end
+
+    # create a user-joined session message
     def user_joined_music_session(user_id, username)
       joined = Jampb::UserJoinedMusicSession.new(:user_id => user_id, :username => username)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::USER_JOINED_MUSIC_SESSION, :target => CLIENT_TARGET, :user_joined_music_session => joined)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::USER_JOINED_MUSIC_SESSION, :route_to => CLIENT_TARGET, :user_joined_music_session => joined)
     end
 
 		# create a test message to send in session
 		def test_session_message(session_id, msg)
 			test = Jampb::TestSessionMessage.new(:msg => msg)
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::TEST_SESSION_MESSAGE, :target => SESSION_TARGET_PREFIX + session_id, :test_session_message => test)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::TEST_SESSION_MESSAGE, :route_to => SESSION_TARGET_PREFIX + session_id, :test_session_message => test)
 		end
 
-		# create a heartbeat
+    ############## P2P CLIENT MESSAGES #################
+
+    # send a request to do a ping
+    def ping_request(client_id, from)
+      ping_request = Jampb::PingRequest.new()
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::PING_REQUEST, :route_to => CLIENT_TARGET_PREFIX + client_id, :from => from, :ping_request => ping_request)
+    end
+
+    # respond to a ping_request with an ack
+    def ping_ack(client_id, from)
+      ping_ack = Jampb::PingAck.new()
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::PING_ACK, :route_to => CLIENT_TARGET_PREFIX + client_id, :from => from, :ping_ack => ping_ack)
+    end
+
+    # create a test message to send in session
+    def test_client_message(client_id, from, msg)
+      test = Jampb::TestClientMessage.new(:msg => msg)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::TEST_CLIENT_MESSAGE, :route_to => CLIENT_TARGET_PREFIX + client_id, :from => from, :test_client_message => test)
+    end
+
+    ####################################################
+
+    # create a heartbeat
     def heartbeat()
       heartbeat = Jampb::Heartbeat.new
-      return Jampb::ClientMessage.new(:type => ClientMessage::Type::HEARTBEAT, :target => SERVER_TARGET, :heartbeat => heartbeat)
+      return Jampb::ClientMessage.new(:type => ClientMessage::Type::HEARTBEAT, :route_to => SERVER_TARGET, :heartbeat => heartbeat)
     end
 
     # create a friend update message
@@ -103,30 +132,30 @@
 
     # is this message directed to the server?
     def server_directed? msg
-       return msg.target == MessageFactory::SERVER_TARGET
+       return msg.route_to == MessageFactory::SERVER_TARGET
     end
 
     # is this message directed to the client?
     def client_directed? msg
-       return msg.target == MessageFactory::CLIENT_TARGET
+       return msg.route_to.start_with? MessageFactory::CLIENT_TARGET_PREFIX
     end
 
     # is this message directed to a (music) session?
     def session_directed? msg
-       return msg.target.start_with? MessageFactory::SESSION_TARGET_PREFIX
+       return msg.route_to.start_with? MessageFactory::SESSION_TARGET_PREFIX
     end
 
     # is this message directed to a user?
     def user_directed? msg
-       return msg.target.start_with? MessageFactory::USER_TARGET_PREFIX
+       return msg.route_to.start_with? MessageFactory::USER_TARGET_PREFIX
     end
 
     def extract_session(msg)
-      return msg.target[MessageFactory::SESSION_TARGET_PREFIX..-1]
+      return msg.route_to[MessageFactory::SESSION_TARGET_PREFIX..-1]
     end
 
 		def get_message_type msg
-			return @type_values[msg.type]  
+			return @type_values[msg.type]
 		end
   end
 end
diff --git a/lib/jam_ruby/models/music_session_client.rb b/lib/jam_ruby/models/music_session_client.rb
index 15519afdd..5099cc14f 100644
--- a/lib/jam_ruby/models/music_session_client.rb
+++ b/lib/jam_ruby/models/music_session_client.rb
@@ -1,3 +1,5 @@
+# called 'participant' currently in the REST APIs
+
 module JamRuby
   class MusicSessionClient < ActiveRecord::Base
     self.primary_key = 'id'
@@ -5,10 +7,16 @@ module JamRuby
     belongs_to :user, :class_name => "JamRuby::User"
     belongs_to :music_session, :class_name => "JamRuby::MusicSession"
 
+    validates :client_id, :presence => true
+
 		def to_s
 			return "#{self.user.to_s}:#{self.ip_address}"
 		end
 
-    
+    # decides if a given user can access this client with p2p messaging
+    # the answer is yes if the user is in the same music session
+    def access_p2p?(user)
+      return self.music_session.users.exists?(user)
+    end
   end
 end
diff --git a/spec/factories.rb b/spec/factories.rb
index dc1bcc916..4250c349a 100644
--- a/spec/factories.rb
+++ b/spec/factories.rb
@@ -15,6 +15,5 @@ FactoryGirl.define do
   end
 
   factory :music_session_client, :class => JamRuby::MusicSessionClient do
-    
   end
 end
\ No newline at end of file
diff --git a/spec/jam_ruby/models/music_session_spec.rb b/spec/jam_ruby/models/music_session_spec.rb
index 5fbcdbbb7..ad93f9558 100644
--- a/spec/jam_ruby/models/music_session_spec.rb
+++ b/spec/jam_ruby/models/music_session_spec.rb
@@ -10,8 +10,8 @@ describe MusicSession do
 
     music_session = FactoryGirl.create(:music_session, :creator => user1)
 
-    music_session_member1 = FactoryGirl.create(:music_session_client, :user => user1, :music_session => music_session, :ip_address => "1.1.1.1")
-    music_session_member2 = FactoryGirl.create(:music_session_client, :user => user2, :music_session => music_session, :ip_address => "2.2.2.2")
+    music_session_member1 = FactoryGirl.create(:music_session_client, :user => user1, :music_session => music_session, :ip_address => "1.1.1.1", :client_id => "1")
+    music_session_member2 = FactoryGirl.create(:music_session_client, :user => user2, :music_session => music_session, :ip_address => "2.2.2.2", :client_id => "2")
 
     music_session.access?(user1).should == true
     music_session.access?(user2).should == true