Ticket #216: UNCOMMITTED-warnings-fixes.patch

src/notification/newemailnotification.cpp

@@ -43 +43 @@
 
 
 // Notify the user about this event (a new email has arrived)
-void NewEmailNotification::notify( QString sender, QString subject, bool inInbox, QString command, QString folder, QString url )
+void NewEmailNotification::notify( QString sender, QString subject, bool inInbox, QString folder )
 {
   currentAccount_ = CurrentAccount::instance();
 

src/notification/newemailnotification.h

@@ -49 +49 @@
 
   public slots:
     // Notify the user about this event (a new email has arrived)
-    void                  notify( QString sender, QString subject, bool inInbox, QString command, QString folder, QString url );
+    void                  notify( QString sender, QString subject, bool inInbox, QString folder );
 
   private slots:
     // Trigger this event's action (Open the mailbox where the new mail is)

src/network/upnp/igdcontrolpoint.cpp

@@ -37 +37 @@
 
 
 // The constructor
-IgdControlPoint::IgdControlPoint(const QString &hostname, int port, const QString &rootUrl)
+IgdControlPoint::IgdControlPoint(const QString &hostname, quint16 port, const QString &rootUrl)
   : QObject()
   , forwardingService_(0)
   , gatewayAvailable_(false)

src/network/upnp/ssdpconnection.h

@@ -52 +52 @@
     virtual             ~SsdpConnection();
 
     // Send a broadcast to detect all devices
-    void                 queryDevices(int bindPort = 1500);
+    void                 queryDevices( quint16 bindPort = 1500 );
 
   private slots:
     // Data was received by the socket

src/network/upnp/manager.h

@@ -64 +64 @@
     // The broadcast failed
     void                 slotBroadcastTimeout();
     // A device was discovered by the SSDP broadcast
-    void                 slotDeviceFound(const QString &hostname, int port, const QString &rootUrl);
+    void                 slotDeviceFound(const QString &hostname, quint16 port, const QString &rootUrl);
 
 
   private:  // private methods

src/network/upnp/service.cpp

@@ -42 +42 @@
 
 
 // The constructor for information services
-Service::Service(const QString &hostname, int port, const QString &informationUrl)
+Service::Service(const QString &hostname, quint16 port, const QString &informationUrl)
   : informationUrl_(informationUrl)
   , pendingRequests_(0)
 {

src/network/upnp/igdcontrolpoint.h

@@ -47 +47 @@
   public:  // public methods
 
     // The constructor
-                         IgdControlPoint(const QString &hostname, int port, const QString &rootUrl);
+                         IgdControlPoint(const QString &hostname, quint16 port, const QString &rootUrl);
     // The destructor
     virtual             ~IgdControlPoint();
 
@@ -74 +74 @@
     // The host of the gateway
     QString              igdHostname_;
     // The port of the gateway
-    int                  igdPort_;
+    quint16              igdPort_;
     // The root service
     RootService         *rootService_;
     // The wan connection service

src/network/upnp/rootservice.cpp

@@ -126 +126 @@
 
 
 // The contructor
-RootService::RootService(const QString &hostname, int port,
+RootService::RootService(const QString &hostname, quint16 port,
                          const QString &rootUrl)
   : Service(hostname, port, rootUrl)
   , hostname_(hostname)

src/network/upnp/service.h

@@ -36 +36 @@
 struct ServiceParameters
 {
   QString hostname;
-  int     port;
+  quint16 port;
   QString scdpUrl;
   QString controlUrl;
   QString serviceId;
@@ -60 +60 @@
 
   public:  // public methods
     // The constructor for the root service
-                         Service(const QString &hostname, int port,
+                         Service(const QString &hostname, quint16 port,
                                  const QString &informationUrl);
     // The constructor for action services
                          Service(const ServiceParameters &params);

src/network/upnp/rootservice.h

@@ -38 +38 @@
   public:  // public methods
 
     // The constructor
-                         RootService(const QString &hostname, int port, const QString &rootUrl);
+                         RootService(const QString &hostname, quint16 port, const QString &rootUrl);
     // The destructor
     virtual             ~RootService();
 
@@ -76 +76 @@
     // The hostname of the device
     QString                     hostname_;
     // The port of the device
-    int                         port_;
+    quint16                     port_;
     // The udn of the root device
     QString                     rootUdn_;
 };

src/network/upnp/ssdpconnection.cpp

@@ -82 +82 @@
   while( socket_->hasPendingDatagrams() )
   {
     datagram.clear();
-    datagram.resize( socket_->pendingDatagramSize() );
+    datagram.resize( (int)socket_->pendingDatagramSize() );
 
     // Get the HTTP-like content
     socket_->readDatagram( datagram.data(), datagram.size() );
@@ -106 +106 @@
 
 
 // Send a broadcast to detect all devices
-void SsdpConnection::queryDevices(int bindPort)
+void SsdpConnection::queryDevices( quint16 bindPort )
 {
 #ifdef KMESSDEBUG_UPNP_GENERAL
   kDebug() << "Sending broadcast packet.";
@@ -134 +134 @@
   }
 
   // Send the data
-  int bytesWritten = socket_->writeDatagram( data.toAscii(), address, 1900 );
+  qint64 bytesWritten = socket_->writeDatagram( data.toAscii(), address, 1900 );
 
   if(bytesWritten == -1)
   {

src/network/upnp/manager.cpp

@@ -137 +137 @@
 
 
 // A device was discovered by the SSDP broadcast
-void Manager::slotDeviceFound(const QString &hostname, int port, const QString &rootUrl)
+void Manager::slotDeviceFound(const QString &hostname, quint16 port, const QString &rootUrl)
 {
 #ifdef KMESSDEBUG_UPNP_GENERAL
   kDebug() << "Device found, initializing IgdControlPoint to query it.";

src/network/extra/directconnectionpool.cpp

@@ -66 +66 @@
  * Add a connection to the list, tells the object to connect to the given ipaddress/port.
  * Returns true when the connection could be added to the pending list (e.g. it's openConnection() method didn't fail).
  */
-bool DirectConnectionPool::addConnection(DirectConnectionBase *connection, const QString &ipAddress, const int port)
+bool DirectConnectionPool::addConnection(DirectConnectionBase *connection, const QString &ipAddress, const quint16 port)
 {
   // Refuse if there is already an active connection
   if( activeConnection_ != 0 )

src/network/extra/directconnectionbase.cpp

@@ -32 +32 @@
 #endif
 
 
-int DirectConnectionBase::nextServerPort_(-1);
+quint16 DirectConnectionBase::nextServerPort_( 0 );
 
 
 
@@ -53 +53 @@
 
   // Read the interval of ports which we'll use to try establishing a connection
   KConfigGroup group = KMessConfig::instance()->getGlobalConfig( "General" );
-  lowestServerPortLimit_  = group.readEntry( "lowestTransferPort", 6891 );
-  highestServerPortLimit_ = group.readEntry( "highestServerPort", 6900 );
+  lowestServerPortLimit_  = (quint16)group.readEntry( "lowestTransferPort", 6891 );
+  highestServerPortLimit_ = (quint16)group.readEntry( "highestServerPort",  6900 );
 #ifdef KMESSDEBUG_DIRECTCONNECTION_GENERAL
   kDebug() << "Using port interval" << lowestServerPortLimit_ << "-" << highestServerPortLimit_;
 #endif
@@ -220 +220 @@
 
 
 // Return the number of bytes which are already received in the local buffer
-int DirectConnectionBase::getAvailableBytes() const
+qint64 DirectConnectionBase::getAvailableBytes() const
 {
   if(KMESS_NULL(socket_)) return -2;  // same as KExtendedSocket API, means "invalid state"
   return socket_->bytesAvailable();
@@ -229 +229 @@
 
 
 // Get the server port that will be used
-int DirectConnectionBase::getLocalServerPort()
+quint16 DirectConnectionBase::getLocalServerPort()
 {
   // Port not chosen yet
-  if( serverPort_ < 0 )
+  if( serverPort_ == 0 )
   {
     // It's possible to use a random port nowadays,
     // old clients with the "only port 6891" are no longer in use.
@@ -242 +242 @@
     //
     // TODO: verify whether we can use the port by calling openServerPort() earlier.
 
-    if( nextServerPort_ < 0 || nextServerPort_ > highestServerPortLimit_ )
+    if( nextServerPort_ == 0 || nextServerPort_ > highestServerPortLimit_ )
     {
       nextServerPort_ = lowestServerPortLimit_;
     }
@@ -275 +275 @@
 
 
 // Get the remote port the socket is connected with.
-int DirectConnectionBase::getRemotePort() const
+quint16 DirectConnectionBase::getRemotePort() const
 {
   if(socket_ == 0)
   {
@@ -283 +283 @@
   }
   else
   {
-#warning localPort() returns quint16 in native byte order.
     return socket_->localPort();
   }
 }
@@ -376 +375 @@
 
 
 // Connect to a host
-bool DirectConnectionBase::openConnection(const QString &ipAddress, const int port)
+bool DirectConnectionBase::openConnection( const QString &ipAddress, const quint16 port )
 {
 #ifdef KMESSDEBUG_DIRECTCONNECTION_GENERAL
   kDebug() << "Connecting to " << ipAddress << " port " << port << ".";
@@ -428 +427 @@
   KMESS_ASSERT( server_ == 0 );
 #endif
 
-  int  port;
+  quint16 port;
 
   // Get the port
   port = getLocalServerPort();
@@ -467 +466 @@
 
 
 // Verify how many bytes the read buffer has. Note this actually reads the data to test it.
-int DirectConnectionBase::peekBlock( const int size )
+qint64 DirectConnectionBase::peekBlock( const qint64 size )
 {
   // Avoid crashes
   if(KMESS_NULL(socket_)) return -1;
@@ -475 +474 @@
   // Read the data and see how much got read.
   // This is the only reliable method, but expensive in terms of performance.
   QByteArray buffer;
-  buffer.resize( size );
+  buffer.resize( (int)size );
 #ifdef KMESSTEST
   KMESS_ASSERT( size > 0 );
   KMESS_ASSERT( buffer.size() == size );
@@ -486 +485 @@
 
 
 // Read data from the socket
-int DirectConnectionBase::readBlock( char *buffer, int size )
+qint64 DirectConnectionBase::readBlock( char *buffer, qint64 size )
 {
   // Avoid crashes
   if(KMESS_NULL(socket_)) return -1;
@@ -518 +517 @@
 
 
 // Read data from the socket (uses the QByteArray size() as block size)
-int DirectConnectionBase::readBlock( QByteArray &buffer, const int maxSize, const int bufferOffset )
+qint64 DirectConnectionBase::readBlock( QByteArray &buffer, const qint64 maxSize, const qint64 bufferOffset )
 {
   // Avoid crashes
   if(KMESS_NULL(socket_)) return -1;
@@ -531 +530 @@
   }
 
   // Determine the maximum number of bytes we can write to the buffer
-  int bufferSpace = buffer.size() - bufferOffset;
+  qint64 bufferSpace = buffer.size() - bufferOffset;
 
   // API usage check.
   // Warn if certain sizes get a unusual value
@@ -554 +553 @@
   // Fill the buffer from the give offset,
   // size argument is limited to what the buffer can/may sustain.
   char *bufferStart = buffer.data() + bufferOffset;
-  int size = qMin( bufferSpace, maxSize );
+  qint64 size = qMin( bufferSpace, maxSize );
   return readBlock( bufferStart, size );
 }
 
@@ -891 +890 @@
  * @param  size   Size of the block to read.
  * @returns  Whether the has been a write error.
  */
-bool DirectConnectionBase::writeBlock( const char *block, const int size )
+bool DirectConnectionBase::writeBlock( const char *block, const qint64 size )
 {
   lastWriteFailed_ = true;
   if(KMESS_NULL(socket_)) return false;
@@ -927 +926 @@
 #endif
     }
 
-    additionalWriteBuffer_.append( QByteArray::fromRawData( block, size ) );
+    additionalWriteBuffer_.append( QByteArray::fromRawData( block, (int)size ) );
 
     // Protect against consuming all system memory
     // 50 kB is more then enough if you're writing messages of 1300 bytes!
@@ -952 +951 @@
   // Log in network window.
   // Use actual size of written block.
 #ifdef KMESS_NETWORK_WINDOW
-  QByteArray wrapper = QByteArray::fromRawData( block, noBytesWritten );
+  QByteArray wrapper = QByteArray::fromRawData( block, (int)noBytesWritten );
   KMESS_NET_SENT(this, wrapper);
 #endif
 
@@ -963 +962 @@
     kWarning() << "only " << noBytesWritten
                << " of " << size << " bytes could be written!";
 
-    additionalWriteBuffer_.append( QByteArray::fromRawData( block + noBytesWritten, size - noBytesWritten ) );
+    additionalWriteBuffer_.append( QByteArray::fromRawData( block + noBytesWritten, (int)(size - noBytesWritten) ) );
   }
   else
   {

src/network/extra/msnftpconnection.cpp

@@ -250 +250 @@
   unsigned char code;
   unsigned char byte1;
   unsigned char byte2;
-  int           blockSize;
-  int           noBytesRead;
+  qint64        blockSize;
+  qint64        noBytesRead;
 
 
   // Make sure we read all available bytes from the socket before returning
@@ -318 +318 @@
       noBytesRead = readBlock( rawBlock, blockSize );
 
 #ifdef KMESS_NETWORK_WINDOW
-      QByteArray wrapper = QByteArray::fromRawData( rawBlock, noBytesRead );
+      QByteArray wrapper = QByteArray::fromRawData( rawBlock, (int)noBytesRead );
       KMESS_NET_RECEIVED( this, wrapper );
 #endif
 
@@ -419 +419 @@
 
 
 // Retrieve a file
-bool MsnFtpConnection::retrieveFile(QFile *outputFile, const QString &ipAddress, const int port)
+bool MsnFtpConnection::retrieveFile(QFile *outputFile, const QString &ipAddress, const quint16 port)
 {
 #ifdef KMESSTEST
   KMESS_ASSERT( authHandle_.length() > 0 );
@@ -491 +491 @@
   // to parseCommand() or parseReceivedFileData()
 
   char          rawBlock[255];
-  int           blockSize;
-  int           noBytesRead;
+  qint64        blockSize;
+  qint64        noBytesRead;
   QString       commandLine;
   QStringList   command;
 
@@ -524 +524 @@
     }
 
     // Convert data block to UTF8 string
-    commandLine = QString::fromUtf8( rawBlock, noBytesRead );
+    commandLine = QString::fromUtf8( rawBlock, (int)noBytesRead );
 
 #ifdef KMESS_NETWORK_WINDOW
     KMESS_NET_RECEIVED( this, commandLine.toUtf8() );
@@ -695 +695 @@
   KMESS_ASSERT( inputStream_ != 0 );
 #endif
 
-  int  noBytesRead;
-  char rawBlock[2048];
+  qint64 noBytesRead;
+  char   rawBlock[2048];
 
   // Read a block from the file.
   noBytesRead = inputStream_->read( rawBlock + 3, sizeof(rawBlock) - 3 );
@@ -723 +723 @@
 
   // Set the header
   rawBlock[0] = 0;
-  rawBlock[1] = (noBytesRead & 0x00ff);
-  rawBlock[2] = (noBytesRead & 0xff00) >> 8;
+  rawBlock[1] = (char)  ( noBytesRead & 0x00ff );
+  rawBlock[2] = (char)( ( noBytesRead & 0xff00 ) >> 8 );
 
   // Update the progress
   fileBytesRemaining_ -= noBytesRead;

src/network/extra/msndirectconnection.cpp

@@ -145 +145 @@
     // start with a new data block
     if( remainingBlockBytes_ <= 0 )
     {
-      int noBytesPeeked = peekBlock(4);
+      qint64 noBytesPeeked = peekBlock(4);
       if( preambleOffset_ == 0 )
       {
         // First see if there are enough bytes.
@@ -163 +163 @@
       }
 
       // First 4 bytes indicate the message/block length.
-      int noBytesRead = readBlock( preambleBuffer_, 4 - preambleOffset_, preambleOffset_ );
+      qint64 noBytesRead = readBlock( preambleBuffer_, 4 - preambleOffset_, preambleOffset_ );
       if( noBytesRead == 0 )
       {
 #ifdef KMESSDEBUG_DIRECTCONNECTION_GENERAL
@@ -239 +239 @@
       }
 
       // Allocate the buffer.
-      buffer_.resize(remainingBlockBytes_);
+      buffer_.resize( (int)remainingBlockBytes_ );
       buffer_.fill('\0');
       bufferOffset_ = 0;
 
@@ -258 +258 @@
 
     // Fill the next part of the buffer with the bytes received.
     // Read as many bytes as possible, test for errors.
-    int noBytesRead = readBlock( buffer_, remainingBlockBytes_, bufferOffset_ );
+    qint64 noBytesRead = readBlock( buffer_, remainingBlockBytes_, bufferOffset_ );
     if( noBytesRead < 0 )
     {
       kWarning() << "read error "

src/network/extra/directconnectionpool.h

@@ -48 +48 @@
     virtual               ~DirectConnectionPool();
 
     // Add a connection to the list, tells the object to connect to the given ipaddress/port.
-    bool                   addConnection(DirectConnectionBase *connection, const QString &ipAddress, const int port);
+    bool                   addConnection(DirectConnectionBase *connection, const QString &ipAddress, const quint16 port);
     // Add a connection to the list, starts listening for incoming connections (returns zero if couldn't start listening).
     int                    addServerConnection(DirectConnectionBase *connection);
     // Remove all connections from the pending list

src/network/extra/directconnectionbase.h

@@ -68 +68 @@
     // Return true when a write handler is connnected.
     bool                   isWriteHandlerConnected() const;
     // Get the server port that will be used
-    int                    getLocalServerPort();
+    quint16                getLocalServerPort();
     // Get the remote ip the socket is connected with.
     QString                getRemoteIp() const;
     // Get the remote port the socket is connected with.
-    int                    getRemotePort() const;
+    quint16                getRemotePort() const;
     // Return the error description
     QString                getSocketError() const;
     // Connect to a host
-    bool                   openConnection(const QString &ipAddress, const int port);
+    bool                   openConnection( const QString &ipAddress, const quint16 port );
     // Wait for an incoming connection
     bool                   openServerPort();
 
@@ -106 +106 @@
     // Close and delete the server socket
     bool                   closeServerSocket();
     // Return the number of bytes which are already received in the local buffer
-    int                    getAvailableBytes() const;
+    qint64                 getAvailableBytes() const;
     // Return the name of the locally opened port.
     QString                getListeningServiceName() const;
     // Verify how many bytes the read buffer has. Note this actually reads the data to test it.
-    int                    peekBlock( const int size );
+    qint64                 peekBlock( const qint64 size );
     // Read data from the socket
-    int                    readBlock( char *buffer, const int size );
+    qint64                 readBlock( char *buffer, const qint64 size );
     // Read data from the socket (uses the QByteArray size() as block size)
-    int                    readBlock( QByteArray &buffer, const int maxSize = 0, const int offset = 0 );
+    qint64                 readBlock( QByteArray &buffer, const qint64 maxSize = 0, const qint64 offset = 0 );
     // Mark the remote host as authorized (usually after the handshake was successful)
     void                   setAuthorized(bool authorized);
     // Write data to the socket
-    bool                   writeBlock( const char *block, const int size );
+    bool                   writeBlock( const char *block, const qint64 size );
     // Write data to the socket
     bool                   writeBlock( const QByteArray &block );
 
@@ -140 +140 @@
     // The timeout handling for openConnection()
     QTimer                 connectionTimer_;
     // The higher limit to the interval of server ports this class will use
-    int                    highestServerPortLimit_;
+    quint16                highestServerPortLimit_;
     // Whether the class acts as server or client
     bool                   isServer_;
     // Whether the last write action failed.
     bool                   lastWriteFailed_;
     // The lower limit to the interval of server ports this class will use
-    int                    lowestServerPortLimit_;
+    quint16                lowestServerPortLimit_;
     // The server socket which listens for incoming connections.
     QTcpServer            *server_;
     // The server port this class will use
-    int                    serverPort_;
+    quint16                serverPort_;
     // The next server port used with a openServerPort() call.
-    static int             nextServerPort_;
+    static quint16         nextServerPort_;
     // The socket over which data is sent or received.
     QTcpSocket            *socket_;
     // Whether an timeout occured

src/network/extra/msnftpconnection.h

@@ -59 +59 @@
     // Send a file
     bool                   sendFile(QFile *inputFile);
     // Retrieve a file
-    bool                   retrieveFile(QFile *outputFile, const QString &ipAddress, const int port);
+    bool                   retrieveFile(QFile *outputFile, const QString &ipAddress, const quint16 port);
 
   private slots:
     // This is called when a connection is established.
@@ -134 +134 @@
     // The stream to write received data to
     QIODevice             *outputStream_;
     // True when only partial file data was received
-    int                    remainingBlockBytes_;
+    qint64                 remainingBlockBytes_;
     // True if the user cancelled the session
     bool                   userCancelled_;
 

src/network/extra/msndirectconnection.h

@@ -61 +61 @@
     // The buffer for the incoming p2p messages.
     QByteArray             buffer_;
     // The offset of the currently received block
-    uint                   bufferOffset_;
+    quint64                bufferOffset_;
     // The other contact we're connected with
     QString                contactHandle_;
     // Whether the first message is received
@@ -69 +69 @@
     // The buffer for the next preamble message.
     QByteArray             preambleBuffer_;
     // The offset in the preamble buffer
-    int                    preambleOffset_;
+    qint64                 preambleOffset_;
     // Set when only partial data was received
-    uint                   remainingBlockBytes_;
+    quint64                remainingBlockBytes_;
 
   signals:
     // Signal that a full message block was received.

src/network/applications/applicationlist.cpp

@@ -315 +315 @@
  * @return Whether the socket could be created or not.
  *         Returns false if the socket could not be created.
  */
-bool ApplicationList::addConnection(const QString &ipAddress, const int port)
+bool ApplicationList::addConnection(const QString &ipAddress, const quint16 port)
 {
   // Avoid overwriting the current directConnection_ variable.
   if( directConnection_ != 0 )
@@ -539 +539 @@
   P2PApplication *app = 0;
 
   // Extract the SLP data message
-  QString slpMessage = QString::fromUtf8( message.getData(), message.getDataSize() );
+  QString slpMessage = QString::fromUtf8( message.getData(), (int) message.getDataSize() );
 
   if(! slpMessage.startsWith("INVITE"))
   {
@@ -1031 +1031 @@
 
       // Find the call ID
       // Note this assumes that a Call-ID will be found in the first