Ticket #193: webcam-firststeps.patch

network/applications/filetransferp2p.cpp

@@ -473 +473 @@
             << ( usePreview ? "with thumbnail." : "without thumbnail." );
 #endif
 
-  // Create the short name
-  uint shortNameLength = fileName_.length();
-
   // Get the file data (preview
   ulong filesize  = fileData->size();
   int flags       = (hasPreview ? 0 : 1);
@@ -493 +490 @@
   P2PMessage::insertBytes( context, flags,    16 );  // Field 4: 1 if NO preview data
 
   // Field 5: the file name
-  const unsigned short * utf16Name = fileName_.utf16();
-  int offset = 20;
-  for(uint i = 0; i < shortNameLength; ++i)
-  {
-    P2PMessage::insertShortBytes(context, utf16Name[i], offset);
-    offset += 2;
-  }
-
+  P2PMessage::insertUtf16String( context, fileName_, 20 );
   P2PMessage::insertBytes(context, 0xFFFFFFFF, 570); // Field 6: some splitter field.
 
   // Insert preview data
@@ -836 +826 @@
 }
 
 
+
 /**
  * @brief Called when the thumbnail is generated.
  */
@@ -843 +834 @@
 {
   bool hasPreview = thumbnailProvider_->isSuccessful();
 
-  // Create the session id and context field
-  QString context   = createContextField( file_, hasPreview );
-  uint    sessionID = (uint)KMessShared::generateID();
-
   // Send the invitation
-  sendSlpSessionInvitation(sessionID, getAppId(), 2, context);
+  QString context = createContextField( file_, hasPreview );
+  sendSlpSessionInvitation( KMessShared::generateID(), getAppId(), 2, context );
 
-
   // Generate the HTML to cancel the transfer
   QString html = i18n( "Sending file &quot;%1&quot; (%2).",
                        "<span class=\"filename invitationFilename\">" + fileName_ + "</span>",

network/applications/p2papplicationbase.cpp

@@ -286 +286 @@
     }
 
     // Also attempt to match on the messageID alone if:
-    // - it's a 0x80 message. In this case sendP2PMessage() has overwritten the previous uniqueID.
+    // - it's a 0x80 message. In this case sendP2PMessageImpl() has overwritten the previous uniqueID.
     // - the UniqueID is not set. (also happens with normal ack messages in GAIM 1.5).
     //
     // This happens with 0x01 control messages:
@@ -863 +863 @@
       shouldSendAck_ = true;
       gotDataPreparation(p2pMessage);
     }
-    // Check for data messages
-    else if(p2pMessage.isMsnObjectData()
-         || p2pMessage.isFileData())
+    // Check for normal data messages
+    else if( p2pMessage.isMsnObjectData()
+         ||  p2pMessage.isFileData())
     {
       gotDataFragment(p2pMessage);
     }
-    else if(waitingState_ == P2P_WAIT_FOR_FILE_DATA
-         && p2pMessage.getFlags() == 0
-         && p2pMessage.isFragment())
+    else if( waitingState_ == P2P_WAIT_FOR_FILE_DATA
+         &&  p2pMessage.getFlags() == 0
+         &&  p2pMessage.isFragment())
     {
       // HACK: added for Kopete 0.9.2 code (has no flag set with data messages).
       kWarning() << "Expecting data message, "
@@ -882 +882 @@
                     " class="   << metaObject()->className() << ")!";
       gotDataFragment(p2pMessage);
     }
+    else if( p2pMessage.getFlags() == 0
+         &&  p2pMessage.getDataSize() >= 18
+         &&  (quint8) ( p2pMessage.getData()[0] ) == 0x80 )
+    {
+      // Webcam setup. Even WLM sends then without flags.
+      // At the switchboard the "footercode" is set to 4.
+      // Pass it to the WebcamTransferP2P class to deal with it.
+      // Not using gotDataFragment() here because it will check if everything is received.
+      gotData( p2pMessage );
+    }
     else
     {
       // Unknown p2p message
@@ -1187 +1197 @@
   // Reserve the next message ID.
   nextMessageID_++;
 
-  // Set the total size field, this causes sendP2PMessage()
+  // Set the total size field, this causes sendP2PMessageImpl()
   // to handle fragmented messages correctly.
   // The 'fragmentMessageID_' is set so KMess sends all fragments with the same message ID.
   // It could happen the client receives a SLP ACK meanwhile, and ACKs it with a new message ID.
@@ -1220 +1230 @@
 
   // TODO: Check the various footer codes send for certain transfers.
   QByteArray p2pMessage( 4, 0x00 );
-  sendP2PMessage(p2pMessage, 0, 1, P2P_MSG_DATA_PREPARATION);
+  sendP2PMessageImpl( p2pMessage, 0, P2P_TYPE_PICTURE, P2P_MSG_DATA_PREPARATION );
 
   // TODO: after the data preparation is sent, WLM8 starts a direct connection setup:
   // - it does not send an ACK yet
@@ -1373 +1383 @@
               << " buffer=" << bytesRead;
 #endif
 
-    // Determine the progress value now because mesageOffset_ it reset by the last sendP2PMessage() call.
+    // Determine the progress value now because mesageOffset_ it reset by the last sendP2PMessageImpl() call.
     unsigned long nextProgressValue = ( fragmentOffset_ + bytesRead );
 
     // Determine the flags:
     // Funny, MSN6 doesn't seam to care which flag was set
     // while transferring the file. KMess however, does.
-    bool writeSuccess = false;
+    uint flag = 0;
     switch( dataType_ )
     {
-      case P2P_TYPE_PICTURE:
-        writeSuccess = sendP2PMessage( data, P2PMessage::MSN_FLAG_OBJECT_DATA, 1, P2P_MSG_DATA, fragmentMessageID_ );
-        break;
-
-      case P2P_TYPE_FILE:
-        writeSuccess = sendP2PMessage( data, P2PMessage::MSN_FLAG_FILE_DATA, 2, P2P_MSG_DATA, fragmentMessageID_ );
-        break;
-
+      case P2P_TYPE_PICTURE: flag = P2PMessage::MSN_FLAG_OBJECT_DATA; break;
+      case P2P_TYPE_FILE:    flag = P2PMessage::MSN_FLAG_FILE_DATA;   break;
       default:
         // Display error message for the first message only.
         if( fragmentOffset_ == 0 )
@@ -1401 +1405 @@
                         " class="   << metaObject()->className() <<
                         " action=tryflag).";
         }
-
-        writeSuccess = sendP2PMessage( data, 0, 1, P2P_MSG_DATA, fragmentMessageID_ ); // The best solution in this situation
     }
 
+    // Send the message
+    bool writeSuccess = sendP2PMessageImpl( data, flag, dataType_, P2P_MSG_DATA, fragmentMessageID_ );
+
     // Avoid next round if write was blocked already.
     // This could happen if a direct connection can't write all data.
     // The DirectConnectionBase class will automatically send the remaining parts, so don't worry about that here.
@@ -1524 +1529 @@
 
 
 /**
- * @brief Send a P2P ACK message.
+ * @brief Internal function to send a P2P ACK message.
  *
  * This method is the internal implementation for sendP2PAck() and others.
  *
@@ -1693 +1698 @@
 
 
 /**
- * @brief Sends a P2P Message.
+ * @brief Sends a complete P2P message payload.
  *
+ * It splits the data message into chunks which fit in the individual P2P messages.
+ *
+ * If you need to send data, use sendData() instead.
+ * This method is stream based, and also takes care of state changes.
+ *
+ * @param messageData    The message payload to send.
+ * @param flagField      The value for the flag field in the P2P header.
+ * @param footerCode     The message footer, which is appended when the message is sent over the switchboard.
+ * @param messageType    The type of the message. This value is returned with gotAck().
+ */
+void P2PApplicationBase::sendP2PMessage(const QByteArray &messageData, int flagField, P2PDataType footerCode, P2PMessageType messageType)
+{
+  // Make sure the message gets sent in chunks of 1202 bytes.
+  // Only set fragmentTotalSize_ if there are chunks, for useless debug messages.
+  int remainingBytes = messageData.size();
+  fragmentOffset_    = 0;
+  fragmentTotalSize_ = ( remainingBytes <= 1202 ? 0 : remainingBytes );
+
+  do
+  {
+    // Let another QByteArray encapsulate a part of the utf8Message
+    const char *dataPointer = messageData.data() + fragmentOffset_;
+    uint        dataSize    = qMin( remainingBytes, 1202 );
+    QByteArray  messagePart = QByteArray::fromRawData( dataPointer, dataSize );
+
+    // Send the message with the generic sendP2PMessageImpl() method
+    // fragmentOffset_ is updated automatically
+    sendP2PMessageImpl( messagePart, flagField, footerCode, messageType );
+    remainingBytes -= dataSize;
+
+#ifdef KMESSTEST
+    KMESS_ASSERT( (uint) remainingBytes == fragmentTotalSize_ - fragmentOffset_ );
+#endif
+  }
+  while( remainingBytes > 0 );
+
+  // Reset for normal operations
+  fragmentOffset_    = 0;
+  fragmentTotalSize_ = 0;
+}
+
+
+
+/**
+ * @brief Internal function to send a single P2P message.
+ *
  * This method constructs the P2P binary header fields.
  * The constructed message is delivered to ApplicationList::sendMessage().
  *
@@ -1705 +1756 @@
  * - outgoingMessages_ is updated to trace ACKs back later.
  *
  * The fragmentTotalSize_ should be set to the total size before sending message fragments.
- * This is done automatically by sendSlpMessage().
+ * This is done automatically by sendP2PMessage() function, which is part of the public API.
  *
  * @param messageData    The message payload to send. This can be binary file data or a SLP MIME data.
  * @param flagField      The value for the flag field in the P2P header.
  * @param footerCode     The message footer, which is appended when the message is sent over the switchboard.
  * @param messageType    The type of the message. This value is stored with in the unacked message queue.
  *                       This value is used later to respond to ACKs of certain special messages.
- * @param messageID      Optional message ID to enforce. If nothing is selected, the next available message ID will be used automatically.
+ * @param messageID      Optional message ID to enforce. If nothing is selected,
+ *                       the next available message ID will be used automatically.
+ *                       This parameter is used to send file data with a specific message ID.
  * @return               Whether the message can be sent. If the socket would block, false is returned.
  *                       This only occurs for direct connections connections.
  */
-bool P2PApplicationBase::sendP2PMessage(const QByteArray &messageData, int flagField, uint footerCode, P2PMessageType messageType, unsigned long messageID)
+bool P2PApplicationBase::sendP2PMessageImpl(const QByteArray &messageData, int flagField, P2PDataType footerCode, P2PMessageType messageType, unsigned long messageID)
 {
 #ifdef KMESSTEST
   KMESS_ASSERT( messageData.size() <= 1202 );
@@ -1762 +1815 @@
 
 
   // Determine the message size:
+  // Internal trick: fragmentTotalSize_ is set by the caller if this is a splitted message.
   uint messageSize = messageData.size();
   ulong totalSize;
   ulong offsetField;
@@ -1786 +1840 @@
   // Set session ID to zero when SLP messages are sent.
   unsigned long sessionID = getSessionID();
   if( flagField == 0
-  &&  messageType != P2P_MSG_DATA_PREPARATION )
+  &&  messageType != P2P_MSG_DATA_PREPARATION
+  &&  messageType != P2P_MSG_WEBCAM_SETUP )  // HACK!  to fix this we need to pass messages as 'P2PMessage'.
   {
     sessionID = 0;
   }
@@ -1804 +1859 @@
 
 
   // Deliver the message over the correct link (switchboard or direct connection)
-  bool writeSuccess = applicationList_->sendMessage( this, header, messageData, footerCode );
+  bool writeSuccess = applicationList_->sendMessage( this, header, messageData, (uint) footerCode );
   if( ! writeSuccess )
   {
     // This only happens when a direct connection transfer is congested.
@@ -1896 +1951 @@
  */
 void P2PApplicationBase::sendP2PWaitingError()
 {
-  sendP2PMessage(0, P2PMessage::MSN_FLAG_WAITING, 0);
+  sendP2PMessageImpl( 0, P2PMessage::MSN_FLAG_WAITING );
   shouldSendAck_ = false;
 }
 
@@ -1905 +1960 @@
 /**
  * @brief Send a complete SLP message in multiple P2P packets.
  *
- * It splits the SLP message into chunks which fit in the P2P payload.
- * Each part will be sent with sendP2PMessage().
- * The messages always have a Session ID of zero.
- *
  * This is a low-level function which is primary used by 
  * P2PApplication::sendSlpInvitation(), P2PApplication::sendSlpBye(), etc..
  *
+ * It converts the SLP string to the payload data,
+ * which could be splitted across multiple P2P messages.
+ *
  * @param  slpMessage   The whole SLP message to send, including SLP headers.
- * @param  messageType  The type of the message, used to trace ACK messages back later.
+ * @param  messageType  The type of the message. This value is returned with gotAck().
  */
 void P2PApplicationBase::sendSlpMessage(const QString &slpMessage, P2PMessageType messageType)
 {
@@ -1928 +1982 @@
   // Make sure the extra padded '\0' character is there. MSN 6-WLM rely on this.
   utf8Message.append('\0');
 
-  // Make sure the message gets sent in chunks of 1202 bytes.
-  // Only set fragmentTotalSize_ if there are chunks, for useless debug messages.
-  int remainingBytes = utf8Message.size();
-  fragmentOffset_    = 0;
-  fragmentTotalSize_ = ( remainingBytes <= 1202 ? 0 : remainingBytes );
-
-  do
-  {
-    // Let another QByteArray encapsulate a part of the utf8Message
-    char *dataPointer = utf8Message.data() + fragmentOffset_;
-    uint  dataSize    = qMin(remainingBytes, 1202);
-    messagePart = QByteArray::fromRawData( dataPointer, dataSize );
-
-    // Send the message with the generic sendP2PMessage() method
-    // fragmentOffset_ is updated automatically
-    sendP2PMessage(messagePart, 0, 0, messageType);
-    remainingBytes -= dataSize;
-
-#ifdef KMESSTEST
-    KMESS_ASSERT( (uint) remainingBytes == fragmentTotalSize_ - fragmentOffset_ );
-#endif
-  }
-  while(remainingBytes > 0);
-
-  // Reset for normal operations
-  fragmentOffset_    = 0;
-  fragmentTotalSize_ = 0;
+  sendP2PMessage( utf8Message, 0, P2P_TYPE_NEGOTIATION, messageType );  // will split the message.
 }
 
 
@@ -2137 +2165 @@
       }
 
       // Send the message
-      sendP2PMessage(0, waitFlag, 0);  // TODO: pass the original message which is unacked!!
+      sendP2PMessageImpl(0, waitFlag, 0);  // TODO: pass the original message which is unacked!!
 */
       testUnAckedMessages( true );  // TODO: argument is not used, and replaces sendP2PWaitingError().
 

network/applications/webapplicationp2p.cpp

@@ -82 +82 @@
 //  int realAppID    = appID.mid(4, 4).toInt();
 
   // Parse the context
-  context += "===="; // Make sure the base64 encoded string is null padded to avoid problems with QString::fromUtf16().
+  // Contents is something like '10331021;1;Tic Tac Toe'
   QByteArray decodedContext = QByteArray::fromBase64( context.toLatin1() );
+  QString    contextString  = QString::fromUtf16( reinterpret_cast<const ushort*>( decodedContext.data() ), decodedContext.size() / 2 );
 
-  // Contents is something like '10331021;1;Tic Tac Toe'
-  QString contextString = QString::fromUtf16( reinterpret_cast<const ushort*>( decodedContext.data() ), decodedContext.size() / 2 );
-
   // Get the fields
   QString unknown = contextString.section(';', 1, 1);
   QString appName = contextString.section(';', 2, 2);

network/applications/p2papplication.cpp

@@ -2787 +2787 @@
 
 #ifdef KMESSTEST
   // Test, as other invocations likely result in undefined client behavour
-  // (
   KMESS_ASSERT(   gotSlpMessage_ );
-  KMESS_ASSERT( isWaitingState( P2P_WAIT_DEFAULT ) );
+  KMESS_ASSERT( isWaitingState( P2P_WAIT_DEFAULT ) || isWaitingState( P2P_WAIT_USER_ACCEPT ) );
   KMESS_ASSERT( ! callID_.isEmpty() );
   KMESS_ASSERT( ! branch_.isEmpty() );
 #endif

network/applications/p2papplicationbase.h

@@ -228 +228 @@
       P2P_MSG_DATA                = 5,  ///< The actual data message.
       P2P_MSG_SESSION_BYE         = 6,  ///< The SLP BYE message.
       P2P_MSG_TRANSFER_DECLINE    = 7,  ///< The SLP 603 Decline message.
-      P2P_MSG_SLP_ERROR           = 8   ///< One of the possible SLP error messages.
+      P2P_MSG_SLP_ERROR           = 8,  ///< One of the possible SLP error messages.
+      P2P_MSG_WEBCAM_SETUP        = 8   ///< One of the possible webcam setup messages.
     };
 
     /**
@@ -242 +243 @@
     , P2P_TYPE_PICTURE     = 1  ///< Packet contains MsnObject data.
     , P2P_TYPE_FILE        = 2  ///< Packet contains file data.
     , P2P_TYPE_INK         = 3  ///< Packet contains an Ink message.
+    , P2P_TYPE_WEBCAM      = 4  ///< Packet contains a webcam setup message.
     };
 
     /**
@@ -260 +262 @@
       P2P_WAIT_DEFAULT             = 0,  ///< Not waiting at all.
       P2P_WAIT_FOR_SLP_OK_ACK      = 1,  ///< Waiting for remote client to ack the the SLP OK message.
       P2P_WAIT_FOR_FILE_DATA       = 2,  ///< Waiting for remote client to send file data.
+      P2P_WAIT_FOR_WEBCAM_DATA     = 19, ///< Waiting for remote client to send webcam invite data.
       P2P_WAIT_FOR_PREPARE         = 3,  ///< Waiting for remote client to send some prepare message.
       P2P_WAIT_FOR_PREPARE_ACK     = 4,  ///< Waiting for remote client to ack the data preparation.
       P2P_WAIT_FOR_SLP_BYE         = 5,  ///< Waiting for remote client to send the SLP BYE.
@@ -332 +335 @@
     void                   sendP2PAbort();
     // Send an low-level ACK message for a received message if this is needed.
     bool                   sendP2PAck();
+    // Send a low-level P2P data message
+    void                   sendP2PMessage(const QByteArray &messageData, int flagField = 0, P2PDataType footerCode = P2P_TYPE_NEGOTIATION, P2PMessageType messageType = P2P_MSG_UNKNOWN);
     // Send a low-level error message that the application is waiting for a certain message.
     void                   sendP2PWaitingError();
     // Send a given string using sendP2PMessage()
@@ -384 +389 @@
     // Send a P2P ACK message
     void                   sendP2PAckImpl(int ackType = P2PMessage::MSN_FLAG_ACK, UnAckedMessage *originalMessageData = 0);
     // Send a P2P message
-    bool                   sendP2PMessage(const QByteArray &messageData, int flagField = 0, uint footerCode = 0, P2PMessageType messageType = P2P_MSG_UNKNOWN, unsigned long messageID = 0);
+    bool                   sendP2PMessageImpl(const QByteArray &messageData, int flagField = 0, P2PDataType footerCode = P2P_TYPE_NEGOTIATION, P2PMessageType messageType = P2P_MSG_UNKNOWN, unsigned long messageID = 0);
     // Test if there are still unacked messages.
     void                   testUnAckedMessages(bool sendError);
 

network/applications/webcamtransferp2p.cpp

@@ -18 +18 @@
 #include "webcamtransferp2p.h"
 
 #include "../../kmessdebug.h"
+#include "../../utils/kmessshared.h"
 #include "../mimemessage.h"
 
 #include <KLocale>
+#include <stdlib.h>   // rand()
 
 
+//
+// I'd like to have many thanks to the Kopete developers here,
+// without them writing this code would have been a lot harder.
+// Especially since all webcam online docs seam to be gone.
+//
 
+
+
+
 /**
  * Constructor
  *
@@ -31 +41 @@
  */
 WebcamTransferP2P::WebcamTransferP2P(ApplicationList *applicationList)
 : P2PApplication(applicationList)
+, isUserSender_(false)
 {
   setApplicationType( ChatMessage::TYPE_APPLICATION_WEBCAM );
 }
@@ -63 +74 @@
  *
  * @param  message  The invitation message
  */
-void WebcamTransferP2P::contactStarted1_ContactInvitesUser(const MimeMessage & /*message*/)
+void WebcamTransferP2P::contactStarted1_ContactInvitesUser(const MimeMessage & message)
 {
-#ifdef KMESSDEBUG_WEBAPPLICATION_P2P
+#ifdef KMESSDEBUG_WEBCAMTRANSFER_P2P
   kDebug();
 #endif
 
-#if 0
-  QString  appID   = message.getValue("AppID");
-  QString  eufGuid = message.getValue("EUF-GUID");
-  QString  context = message.getValue("Context");
+  // Read the values from the message
+  uint    appID   = message.getValue("AppID").toUInt();
+  QString eufGuid = message.getValue("EUF-GUID");
+  QString context = message.getValue("Context");
 
-  // Parse the context
-  context += "===="; // Make sure the base64 encoded string is null padded to avoid problems with QString::fromUtf16().
-  QByteArray decodedContext;
-  KCodecs::base64Decode(context.utf8(), decodedContext);
+  if(appID != 4)
+  {
+    kWarning() << "Received unexpected AppID: " << appID << ".";
 
-  // Contents is another GUID
-  QString contextString = QString::fromUtf16( reinterpret_cast<const unsigned short*>(decodedContext.data()) );
+    // Wouldn't know what to do if the AppID is not 2, so send an 500 Internal Error back.
+    showEventMessage( i18n("The webcam invitation was cancelled. Bad data was received."), ChatMessage::CONTENT_APP_CANCELED, true );
+    sendCancelMessage( CANCEL_ABORT );
+    return;
+  }
+
+  // Contact can request a webcam from us, or share it's own webcam.
+  isUserSender_ = ( eufGuid == getPullAppId() );
+
+  // Parse the context, it contains another GUI
+  QByteArray decodedContext = QByteArray::fromBase64( context.toLatin1() );
+  webcamGuid_ = P2PMessage::extractUtf16String( decodedContext.data(), 0, decodedContext.size() );
+
+  // Display the accept message.
+#ifdef KMESSDEBUG_WEBCAMTRANSFER_P2P
+  kDebug() << "Webcam invitation received, GUID=" << webcamGuid_ << endl;
+  kDebug() << "waiting for user to accept..." << endl;
 #endif
 
-  // KMess does not support the webapplication invitations yet,
-  // this class is currently a STUB to produce a proper error message
-  showSystemMessage( i18n( "The contact is inviting you for '%1', but this is not implemented yet.",
-                           i18n("webcam") ),
-                     ChatMessage::CONTENT_SYSTEM_NOTICE, true );
+  offerAcceptOrReject( i18n("You are invited to view this person's webcam.") );
+}
 
-  // Tell the contact we don't support this.
-  sendCancelMessage(CANCEL_NOT_INSTALLED);
 
-//  // Everything seams OK, accept this message:
-//  contactStarted2_UserAccepts();
+
+/**
+ * Step two of a contact-started chat: the user accepts
+ */
+void WebcamTransferP2P::contactStarted2_UserAccepts()
+{
+#ifdef KMESSDEBUG_FILETRANSFER_P2P
+  kDebug() << "sending accept message";
+#endif
+
+  // Create the message
+  MimeMessage message;
+  message.addField( "SessionID", QString::number( getInvitationSessionID() ) );
+
+  // Send the message
+  sendSlpOkMessage(message);
+  setWaitingState( P2P_WAIT_FOR_WEBCAM_DATA, 120000 );  // 120 seconds
 }
 
 
 
+
 /**
+ * Step three of a contact-started chat: the contact confirms the accept
+ */
+void WebcamTransferP2P::contactStarted3_ContactConfirmsAccept(const MimeMessage& /*message*/)
+{
+#ifdef KMESSDEBUG_WEBCAMTRANSFER_P2P
+  kDebug();
+#endif
+
+  // The invitation continues with the gotData() call.
+}
+
+
+
+/**
+ * Create the producer or viewer XML tag.
+ */
+QString WebcamTransferP2P::createSipXml( uint session, uint rid )
+{
+  QString rootNode = ( isUserSender_ ? "producer" : "viewer" );
+
+  QString ipTags = "<tcpipaddress1>10.0.0.1</tcpipaddress1>";
+
+  /*
+  uint ip_number=1;
+  QStringList::iterator it;
+  QStringList ips=m_dispatcher->localIp();
+  for ( it = ips.begin(); it != ips.end(); ++it )
+  {
+          ip+=QString("<tcpipaddress%1>%2</tcpipaddress%3>").arg(ip_number).arg(*it).arg(ip_number);
+          ++ip_number;
+  }
+
+  //QString port = QString::number(getAvailablePort());
+  //m_listener = new KServerSocket(port, this) ;
+  */
+
+  int port = 0;
+
+  return "<" + rootNode + ">"
+           "<version>2.0</version>"
+           "<rid>" + QString::number( rid ) + "</rid>"
+           "<udprid>" + QString::number( rid + 1 ) + "</udprid>"
+           "<session>" + QString::number( session ) + "</session>"
+           "<ctypes>0</ctypes>"
+           "<cpu>2931</cpu>"
+           "<tcp>"
+             "<tcpport>7786</tcpport>"     // "\t\t\t\t\t\t\t\t  "
+             "<tcplocalport>7786</tcplocalport>"  // "\t\t\t\t\t\t\t\t  "
+             "<tcpexternalport>7786</tcpexternalport>" + ipTags +
+           "</tcp>"
+           "<udp>"
+             "<udplocalport>7786</udplocalport>"
+             "<udpexternalport>31863</udpexternalport>"
+             "<udpexternalip>" + ipTags + "</udpexternalip>"
+             "<a1_port>31859</a1_port>"
+             "<b1_port>31860</b1_port>"
+             "<b2_port>31861</b2_port>"
+             "<b3_port>31862</b3_port>"
+             "<symmetricallocation>1</symmetricallocation>"
+             "<symmetricallocationincrement>1</symmetricallocationincrement>"
+             "<udpversion>1</udpversion>"
+             "<udpinternalipaddress1>127.0.0.1</udpinternalipaddress1>"
+           "</udp>"
+           "<codec></codec>"
+           "<channelmode>1</channelmode>"
+         "</" + rootNode + ">\r\n\r\n";
+}
+
+
+
+/**
+ * Return the application's GUID for "video conference" invitations.
+ */
+QString WebcamTransferP2P::getConferenceAppId()
+{
+  return "{4BD96FC0-AB17-4425-A14A-439185962DC8}";
+}
+
+
+
+/**
  * Return the application's GUID for "user push" invitations.
  */
 QString WebcamTransferP2P::getPushAppId()
@@ -117 +234 @@
 }
 
 
+
+/**
+ * Called when SIP data is received.
+ * This is the second stage of the webcam invitation.
+ *
+ * @param  message  P2P message with the data.
+ */
+void WebcamTransferP2P::gotData(const P2PMessage &message)
+{
+  bool contactStarted = ( ! isUserStartedApp() );
+  QString contents = P2PMessage::extractUtf16String( message.getData(), 10, message.getDataSize() - 10 );
+
+#ifdef KMESSDEBUG_FILETRANSFER_P2P
+  kDebug() << "received setup data:" << contents;
+#endif
+
+  sendP2PAck();
+
+  // Find out what to do.
+  if( contents == "syn" )
+  {
+    if( contactStarted )
+    {
+      sendSipMessage("syn", 0x17,0x2a,0x01);
+    }
+    else
+    {
+      sendSipMessage("ack", 0xea,0x00,0x00);
+    }
+  }
+  else if( contents == "ack" )
+  {
+    if( contactStarted )
+    {
+      sendSipMessage("ack", 0xea,0x00,0x00);
+    }
+
+    // Send the <producer> message
+    if( isUserSender_ )
+    {
+      uint session    = rand() % 1000 + 5000;
+      uint rid        = rand() % 100 + 50;
+      authentication_ = "recipientid=" + QString::number( rid ) + "&sessionid=" + QString::number( session ) + "\r\n\r\n";
+      QString producerXml = createSipXml( session, rid );
+      sendSipMessage( producerXml, 0, 0, 0 );
+    }
+  }
+  else if( contents.startsWith("<") )
+  {
+    // XML.
+  }
+  else
+  {
+    sendP2PAbort();
+  }
+}
+
+
+
+/**
+ * Send a webcam negotiation message